1 /* 2 * Copyright (c) 1996, 2019, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 /* 27 * Portions Copyright IBM Corporation, 2001. All Rights Reserved. 28 */ 29 30 package java.math; 31 32 import static java.math.BigInteger.LONG_MASK; 33 import java.util.Arrays; 34 import java.util.Objects; 35 36 /** 37 * Immutable, arbitrary-precision signed decimal numbers. A 38 * {@code BigDecimal} consists of an arbitrary precision integer 39 * <i>unscaled value</i> and a 32-bit integer <i>scale</i>. If zero 40 * or positive, the scale is the number of digits to the right of the 41 * decimal point. If negative, the unscaled value of the number is 42 * multiplied by ten to the power of the negation of the scale. The 43 * value of the number represented by the {@code BigDecimal} is 44 * therefore <code>(unscaledValue × 10<sup>-scale</sup>)</code>. 45 * 46 * <p>The {@code BigDecimal} class provides operations for 47 * arithmetic, scale manipulation, rounding, comparison, hashing, and 48 * format conversion. The {@link #toString} method provides a 49 * canonical representation of a {@code BigDecimal}. 50 * 51 * <p>The {@code BigDecimal} class gives its user complete control 52 * over rounding behavior. If no rounding mode is specified and the 53 * exact result cannot be represented, an exception is thrown; 54 * otherwise, calculations can be carried out to a chosen precision 55 * and rounding mode by supplying an appropriate {@link MathContext} 56 * object to the operation. In either case, eight <em>rounding 57 * modes</em> are provided for the control of rounding. Using the 58 * integer fields in this class (such as {@link #ROUND_HALF_UP}) to 59 * represent rounding mode is deprecated; the enumeration values 60 * of the {@code RoundingMode} {@code enum}, (such as {@link 61 * RoundingMode#HALF_UP}) should be used instead. 62 * 63 * <p>When a {@code MathContext} object is supplied with a precision 64 * setting of 0 (for example, {@link MathContext#UNLIMITED}), 65 * arithmetic operations are exact, as are the arithmetic methods 66 * which take no {@code MathContext} object. (This is the only 67 * behavior that was supported in releases prior to 5.) As a 68 * corollary of computing the exact result, the rounding mode setting 69 * of a {@code MathContext} object with a precision setting of 0 is 70 * not used and thus irrelevant. In the case of divide, the exact 71 * quotient could have an infinitely long decimal expansion; for 72 * example, 1 divided by 3. If the quotient has a nonterminating 73 * decimal expansion and the operation is specified to return an exact 74 * result, an {@code ArithmeticException} is thrown. Otherwise, the 75 * exact result of the division is returned, as done for other 76 * operations. 77 * 78 * <p>When the precision setting is not 0, the rules of 79 * {@code BigDecimal} arithmetic are broadly compatible with selected 80 * modes of operation of the arithmetic defined in ANSI X3.274-1996 81 * and ANSI X3.274-1996/AM 1-2000 (section 7.4). Unlike those 82 * standards, {@code BigDecimal} includes many rounding modes, which 83 * were mandatory for division in {@code BigDecimal} releases prior 84 * to 5. Any conflicts between these ANSI standards and the 85 * {@code BigDecimal} specification are resolved in favor of 86 * {@code BigDecimal}. 87 * 88 * <p>Since the same numerical value can have different 89 * representations (with different scales), the rules of arithmetic 90 * and rounding must specify both the numerical result and the scale 91 * used in the result's representation. 92 * 93 * 94 * <p>In general the rounding modes and precision setting determine 95 * how operations return results with a limited number of digits when 96 * the exact result has more digits (perhaps infinitely many in the 97 * case of division and square root) than the number of digits returned. 98 * 99 * First, the 100 * total number of digits to return is specified by the 101 * {@code MathContext}'s {@code precision} setting; this determines 102 * the result's <i>precision</i>. The digit count starts from the 103 * leftmost nonzero digit of the exact result. The rounding mode 104 * determines how any discarded trailing digits affect the returned 105 * result. 106 * 107 * <p>For all arithmetic operators , the operation is carried out as 108 * though an exact intermediate result were first calculated and then 109 * rounded to the number of digits specified by the precision setting 110 * (if necessary), using the selected rounding mode. If the exact 111 * result is not returned, some digit positions of the exact result 112 * are discarded. When rounding increases the magnitude of the 113 * returned result, it is possible for a new digit position to be 114 * created by a carry propagating to a leading {@literal "9"} digit. 115 * For example, rounding the value 999.9 to three digits rounding up 116 * would be numerically equal to one thousand, represented as 117 * 100×10<sup>1</sup>. In such cases, the new {@literal "1"} is 118 * the leading digit position of the returned result. 119 * 120 * <p>Besides a logical exact result, each arithmetic operation has a 121 * preferred scale for representing a result. The preferred 122 * scale for each operation is listed in the table below. 123 * 124 * <table class="striped" style="text-align:left"> 125 * <caption>Preferred Scales for Results of Arithmetic Operations 126 * </caption> 127 * <thead> 128 * <tr><th scope="col">Operation</th><th scope="col">Preferred Scale of Result</th></tr> 129 * </thead> 130 * <tbody> 131 * <tr><th scope="row">Add</th><td>max(addend.scale(), augend.scale())</td> 132 * <tr><th scope="row">Subtract</th><td>max(minuend.scale(), subtrahend.scale())</td> 133 * <tr><th scope="row">Multiply</th><td>multiplier.scale() + multiplicand.scale()</td> 134 * <tr><th scope="row">Divide</th><td>dividend.scale() - divisor.scale()</td> 135 * <tr><th scope="row">Square root</th><td>radicand.scale()/2</td> 136 * </tbody> 137 * </table> 138 * 139 * These scales are the ones used by the methods which return exact 140 * arithmetic results; except that an exact divide may have to use a 141 * larger scale since the exact result may have more digits. For 142 * example, {@code 1/32} is {@code 0.03125}. 143 * 144 * <p>Before rounding, the scale of the logical exact intermediate 145 * result is the preferred scale for that operation. If the exact 146 * numerical result cannot be represented in {@code precision} 147 * digits, rounding selects the set of digits to return and the scale 148 * of the result is reduced from the scale of the intermediate result 149 * to the least scale which can represent the {@code precision} 150 * digits actually returned. If the exact result can be represented 151 * with at most {@code precision} digits, the representation 152 * of the result with the scale closest to the preferred scale is 153 * returned. In particular, an exactly representable quotient may be 154 * represented in fewer than {@code precision} digits by removing 155 * trailing zeros and decreasing the scale. For example, rounding to 156 * three digits using the {@linkplain RoundingMode#FLOOR floor} 157 * rounding mode, <br> 158 * 159 * {@code 19/100 = 0.19 // integer=19, scale=2} <br> 160 * 161 * but<br> 162 * 163 * {@code 21/110 = 0.190 // integer=190, scale=3} <br> 164 * 165 * <p>Note that for add, subtract, and multiply, the reduction in 166 * scale will equal the number of digit positions of the exact result 167 * which are discarded. If the rounding causes a carry propagation to 168 * create a new high-order digit position, an additional digit of the 169 * result is discarded than when no new digit position is created. 170 * 171 * <p>Other methods may have slightly different rounding semantics. 172 * For example, the result of the {@code pow} method using the 173 * {@linkplain #pow(int, MathContext) specified algorithm} can 174 * occasionally differ from the rounded mathematical result by more 175 * than one unit in the last place, one <i>{@linkplain #ulp() ulp}</i>. 176 * 177 * <p>Two types of operations are provided for manipulating the scale 178 * of a {@code BigDecimal}: scaling/rounding operations and decimal 179 * point motion operations. Scaling/rounding operations ({@link 180 * #setScale setScale} and {@link #round round}) return a 181 * {@code BigDecimal} whose value is approximately (or exactly) equal 182 * to that of the operand, but whose scale or precision is the 183 * specified value; that is, they increase or decrease the precision 184 * of the stored number with minimal effect on its value. Decimal 185 * point motion operations ({@link #movePointLeft movePointLeft} and 186 * {@link #movePointRight movePointRight}) return a 187 * {@code BigDecimal} created from the operand by moving the decimal 188 * point a specified distance in the specified direction. 189 * 190 * <p>For the sake of brevity and clarity, pseudo-code is used 191 * throughout the descriptions of {@code BigDecimal} methods. The 192 * pseudo-code expression {@code (i + j)} is shorthand for "a 193 * {@code BigDecimal} whose value is that of the {@code BigDecimal} 194 * {@code i} added to that of the {@code BigDecimal} 195 * {@code j}." The pseudo-code expression {@code (i == j)} is 196 * shorthand for "{@code true} if and only if the 197 * {@code BigDecimal} {@code i} represents the same value as the 198 * {@code BigDecimal} {@code j}." Other pseudo-code expressions 199 * are interpreted similarly. Square brackets are used to represent 200 * the particular {@code BigInteger} and scale pair defining a 201 * {@code BigDecimal} value; for example [19, 2] is the 202 * {@code BigDecimal} numerically equal to 0.19 having a scale of 2. 203 * 204 * 205 * <p>All methods and constructors for this class throw 206 * {@code NullPointerException} when passed a {@code null} object 207 * reference for any input parameter. 208 * 209 * @apiNote Care should be exercised if {@code BigDecimal} objects 210 * are used as keys in a {@link java.util.SortedMap SortedMap} or 211 * elements in a {@link java.util.SortedSet SortedSet} since 212 * {@code BigDecimal}'s <i>natural ordering</i> is <em>inconsistent 213 * with equals</em>. See {@link Comparable}, {@link 214 * java.util.SortedMap} or {@link java.util.SortedSet} for more 215 * information. 216 * 217 * @see BigInteger 218 * @see MathContext 219 * @see RoundingMode 220 * @see java.util.SortedMap 221 * @see java.util.SortedSet 222 * @author Josh Bloch 223 * @author Mike Cowlishaw 224 * @author Joseph D. Darcy 225 * @author Sergey V. Kuksenko 226 * @since 1.1 227 */ 228 public class BigDecimal extends Number implements Comparable<BigDecimal> { 229 /** 230 * The unscaled value of this BigDecimal, as returned by {@link 231 * #unscaledValue}. 232 * 233 * @serial 234 * @see #unscaledValue 235 */ 236 private final BigInteger intVal; 237 238 /** 239 * The scale of this BigDecimal, as returned by {@link #scale}. 240 * 241 * @serial 242 * @see #scale 243 */ 244 private final int scale; // Note: this may have any value, so 245 // calculations must be done in longs 246 247 /** 248 * The number of decimal digits in this BigDecimal, or 0 if the 249 * number of digits are not known (lookaside information). If 250 * nonzero, the value is guaranteed correct. Use the precision() 251 * method to obtain and set the value if it might be 0. This 252 * field is mutable until set nonzero. 253 * 254 * @since 1.5 255 */ 256 private transient int precision; 257 258 /** 259 * Used to store the canonical string representation, if computed. 260 */ 261 private transient String stringCache; 262 263 /** 264 * Sentinel value for {@link #intCompact} indicating the 265 * significand information is only available from {@code intVal}. 266 */ 267 static final long INFLATED = Long.MIN_VALUE; 268 269 private static final BigInteger INFLATED_BIGINT = BigInteger.valueOf(INFLATED); 270 271 /** 272 * If the absolute value of the significand of this BigDecimal is 273 * less than or equal to {@code Long.MAX_VALUE}, the value can be 274 * compactly stored in this field and used in computations. 275 */ 276 private final transient long intCompact; 277 278 // All 18-digit base ten strings fit into a long; not all 19-digit 279 // strings will 280 private static final int MAX_COMPACT_DIGITS = 18; 281 282 /* Appease the serialization gods */ 283 @java.io.Serial 284 private static final long serialVersionUID = 6108874887143696463L; 285 286 private static final ThreadLocal<StringBuilderHelper> 287 threadLocalStringBuilderHelper = new ThreadLocal<StringBuilderHelper>() { 288 @Override 289 protected StringBuilderHelper initialValue() { 290 return new StringBuilderHelper(); 291 } 292 }; 293 294 // Cache of common small BigDecimal values. 295 private static final BigDecimal ZERO_THROUGH_TEN[] = { 296 new BigDecimal(BigInteger.ZERO, 0, 0, 1), 297 new BigDecimal(BigInteger.ONE, 1, 0, 1), 298 new BigDecimal(BigInteger.TWO, 2, 0, 1), 299 new BigDecimal(BigInteger.valueOf(3), 3, 0, 1), 300 new BigDecimal(BigInteger.valueOf(4), 4, 0, 1), 301 new BigDecimal(BigInteger.valueOf(5), 5, 0, 1), 302 new BigDecimal(BigInteger.valueOf(6), 6, 0, 1), 303 new BigDecimal(BigInteger.valueOf(7), 7, 0, 1), 304 new BigDecimal(BigInteger.valueOf(8), 8, 0, 1), 305 new BigDecimal(BigInteger.valueOf(9), 9, 0, 1), 306 new BigDecimal(BigInteger.TEN, 10, 0, 2), 307 }; 308 309 // Cache of zero scaled by 0 - 15 310 private static final BigDecimal[] ZERO_SCALED_BY = { 311 ZERO_THROUGH_TEN[0], 312 new BigDecimal(BigInteger.ZERO, 0, 1, 1), 313 new BigDecimal(BigInteger.ZERO, 0, 2, 1), 314 new BigDecimal(BigInteger.ZERO, 0, 3, 1), 315 new BigDecimal(BigInteger.ZERO, 0, 4, 1), 316 new BigDecimal(BigInteger.ZERO, 0, 5, 1), 317 new BigDecimal(BigInteger.ZERO, 0, 6, 1), 318 new BigDecimal(BigInteger.ZERO, 0, 7, 1), 319 new BigDecimal(BigInteger.ZERO, 0, 8, 1), 320 new BigDecimal(BigInteger.ZERO, 0, 9, 1), 321 new BigDecimal(BigInteger.ZERO, 0, 10, 1), 322 new BigDecimal(BigInteger.ZERO, 0, 11, 1), 323 new BigDecimal(BigInteger.ZERO, 0, 12, 1), 324 new BigDecimal(BigInteger.ZERO, 0, 13, 1), 325 new BigDecimal(BigInteger.ZERO, 0, 14, 1), 326 new BigDecimal(BigInteger.ZERO, 0, 15, 1), 327 }; 328 329 // Half of Long.MIN_VALUE & Long.MAX_VALUE. 330 private static final long HALF_LONG_MAX_VALUE = Long.MAX_VALUE / 2; 331 private static final long HALF_LONG_MIN_VALUE = Long.MIN_VALUE / 2; 332 333 // Constants 334 /** 335 * The value 0, with a scale of 0. 336 * 337 * @since 1.5 338 */ 339 public static final BigDecimal ZERO = 340 ZERO_THROUGH_TEN[0]; 341 342 /** 343 * The value 1, with a scale of 0. 344 * 345 * @since 1.5 346 */ 347 public static final BigDecimal ONE = 348 ZERO_THROUGH_TEN[1]; 349 350 /** 351 * The value 10, with a scale of 0. 352 * 353 * @since 1.5 354 */ 355 public static final BigDecimal TEN = 356 ZERO_THROUGH_TEN[10]; 357 358 /** 359 * The value 0.1, with a scale of 1. 360 */ 361 private static final BigDecimal ONE_TENTH = valueOf(1L, 1); 362 363 /** 364 * The value 0.5, with a scale of 1. 365 */ 366 private static final BigDecimal ONE_HALF = valueOf(5L, 1); 367 368 // Constructors 369 370 /** 371 * Trusted package private constructor. 372 * Trusted simply means if val is INFLATED, intVal could not be null and 373 * if intVal is null, val could not be INFLATED. 374 */ 375 BigDecimal(BigInteger intVal, long val, int scale, int prec) { 376 this.scale = scale; 377 this.precision = prec; 378 this.intCompact = val; 379 this.intVal = intVal; 380 } 381 382 /** 383 * Translates a character array representation of a 384 * {@code BigDecimal} into a {@code BigDecimal}, accepting the 385 * same sequence of characters as the {@link #BigDecimal(String)} 386 * constructor, while allowing a sub-array to be specified. 387 * 388 * @implNote If the sequence of characters is already available 389 * within a character array, using this constructor is faster than 390 * converting the {@code char} array to string and using the 391 * {@code BigDecimal(String)} constructor. 392 * 393 * @param in {@code char} array that is the source of characters. 394 * @param offset first character in the array to inspect. 395 * @param len number of characters to consider. 396 * @throws NumberFormatException if {@code in} is not a valid 397 * representation of a {@code BigDecimal} or the defined subarray 398 * is not wholly within {@code in}. 399 * @since 1.5 400 */ 401 public BigDecimal(char[] in, int offset, int len) { 402 this(in,offset,len,MathContext.UNLIMITED); 403 } 404 405 /** 406 * Translates a character array representation of a 407 * {@code BigDecimal} into a {@code BigDecimal}, accepting the 408 * same sequence of characters as the {@link #BigDecimal(String)} 409 * constructor, while allowing a sub-array to be specified and 410 * with rounding according to the context settings. 411 * 412 * @implNote If the sequence of characters is already available 413 * within a character array, using this constructor is faster than 414 * converting the {@code char} array to string and using the 415 * {@code BigDecimal(String)} constructor. 416 * 417 * @param in {@code char} array that is the source of characters. 418 * @param offset first character in the array to inspect. 419 * @param len number of characters to consider. 420 * @param mc the context to use. 421 * @throws ArithmeticException if the result is inexact but the 422 * rounding mode is {@code UNNECESSARY}. 423 * @throws NumberFormatException if {@code in} is not a valid 424 * representation of a {@code BigDecimal} or the defined subarray 425 * is not wholly within {@code in}. 426 * @since 1.5 427 */ 428 public BigDecimal(char[] in, int offset, int len, MathContext mc) { 429 // protect against huge length, negative values, and integer overflow 430 try { 431 Objects.checkFromIndexSize(offset, len, in.length); 432 } catch (IndexOutOfBoundsException e) { 433 throw new NumberFormatException 434 ("Bad offset or len arguments for char[] input."); 435 } 436 437 // This is the primary string to BigDecimal constructor; all 438 // incoming strings end up here; it uses explicit (inline) 439 // parsing for speed and generates at most one intermediate 440 // (temporary) object (a char[] array) for non-compact case. 441 442 // Use locals for all fields values until completion 443 int prec = 0; // record precision value 444 int scl = 0; // record scale value 445 long rs = 0; // the compact value in long 446 BigInteger rb = null; // the inflated value in BigInteger 447 // use array bounds checking to handle too-long, len == 0, 448 // bad offset, etc. 449 try { 450 // handle the sign 451 boolean isneg = false; // assume positive 452 if (in[offset] == '-') { 453 isneg = true; // leading minus means negative 454 offset++; 455 len--; 456 } else if (in[offset] == '+') { // leading + allowed 457 offset++; 458 len--; 459 } 460 461 // should now be at numeric part of the significand 462 boolean dot = false; // true when there is a '.' 463 long exp = 0; // exponent 464 char c; // current character 465 boolean isCompact = (len <= MAX_COMPACT_DIGITS); 466 // integer significand array & idx is the index to it. The array 467 // is ONLY used when we can't use a compact representation. 468 int idx = 0; 469 if (isCompact) { 470 // First compact case, we need not to preserve the character 471 // and we can just compute the value in place. 472 for (; len > 0; offset++, len--) { 473 c = in[offset]; 474 if ((c == '0')) { // have zero 475 if (prec == 0) 476 prec = 1; 477 else if (rs != 0) { 478 rs *= 10; 479 ++prec; 480 } // else digit is a redundant leading zero 481 if (dot) 482 ++scl; 483 } else if ((c >= '1' && c <= '9')) { // have digit 484 int digit = c - '0'; 485 if (prec != 1 || rs != 0) 486 ++prec; // prec unchanged if preceded by 0s 487 rs = rs * 10 + digit; 488 if (dot) 489 ++scl; 490 } else if (c == '.') { // have dot 491 // have dot 492 if (dot) // two dots 493 throw new NumberFormatException("Character array" 494 + " contains more than one decimal point."); 495 dot = true; 496 } else if (Character.isDigit(c)) { // slow path 497 int digit = Character.digit(c, 10); 498 if (digit == 0) { 499 if (prec == 0) 500 prec = 1; 501 else if (rs != 0) { 502 rs *= 10; 503 ++prec; 504 } // else digit is a redundant leading zero 505 } else { 506 if (prec != 1 || rs != 0) 507 ++prec; // prec unchanged if preceded by 0s 508 rs = rs * 10 + digit; 509 } 510 if (dot) 511 ++scl; 512 } else if ((c == 'e') || (c == 'E')) { 513 exp = parseExp(in, offset, len); 514 // Next test is required for backwards compatibility 515 if ((int) exp != exp) // overflow 516 throw new NumberFormatException("Exponent overflow."); 517 break; // [saves a test] 518 } else { 519 throw new NumberFormatException("Character " + c 520 + " is neither a decimal digit number, decimal point, nor" 521 + " \"e\" notation exponential mark."); 522 } 523 } 524 if (prec == 0) // no digits found 525 throw new NumberFormatException("No digits found."); 526 // Adjust scale if exp is not zero. 527 if (exp != 0) { // had significant exponent 528 scl = adjustScale(scl, exp); 529 } 530 rs = isneg ? -rs : rs; 531 int mcp = mc.precision; 532 int drop = prec - mcp; // prec has range [1, MAX_INT], mcp has range [0, MAX_INT]; 533 // therefore, this subtract cannot overflow 534 if (mcp > 0 && drop > 0) { // do rounding 535 while (drop > 0) { 536 scl = checkScaleNonZero((long) scl - drop); 537 rs = divideAndRound(rs, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode); 538 prec = longDigitLength(rs); 539 drop = prec - mcp; 540 } 541 } 542 } else { 543 char coeff[] = new char[len]; 544 for (; len > 0; offset++, len--) { 545 c = in[offset]; 546 // have digit 547 if ((c >= '0' && c <= '9') || Character.isDigit(c)) { 548 // First compact case, we need not to preserve the character 549 // and we can just compute the value in place. 550 if (c == '0' || Character.digit(c, 10) == 0) { 551 if (prec == 0) { 552 coeff[idx] = c; 553 prec = 1; 554 } else if (idx != 0) { 555 coeff[idx++] = c; 556 ++prec; 557 } // else c must be a redundant leading zero 558 } else { 559 if (prec != 1 || idx != 0) 560 ++prec; // prec unchanged if preceded by 0s 561 coeff[idx++] = c; 562 } 563 if (dot) 564 ++scl; 565 continue; 566 } 567 // have dot 568 if (c == '.') { 569 // have dot 570 if (dot) // two dots 571 throw new NumberFormatException("Character array" 572 + " contains more than one decimal point."); 573 dot = true; 574 continue; 575 } 576 // exponent expected 577 if ((c != 'e') && (c != 'E')) 578 throw new NumberFormatException("Character array" 579 + " is missing \"e\" notation exponential mark."); 580 exp = parseExp(in, offset, len); 581 // Next test is required for backwards compatibility 582 if ((int) exp != exp) // overflow 583 throw new NumberFormatException("Exponent overflow."); 584 break; // [saves a test] 585 } 586 // here when no characters left 587 if (prec == 0) // no digits found 588 throw new NumberFormatException("No digits found."); 589 // Adjust scale if exp is not zero. 590 if (exp != 0) { // had significant exponent 591 scl = adjustScale(scl, exp); 592 } 593 // Remove leading zeros from precision (digits count) 594 rb = new BigInteger(coeff, isneg ? -1 : 1, prec); 595 rs = compactValFor(rb); 596 int mcp = mc.precision; 597 if (mcp > 0 && (prec > mcp)) { 598 if (rs == INFLATED) { 599 int drop = prec - mcp; 600 while (drop > 0) { 601 scl = checkScaleNonZero((long) scl - drop); 602 rb = divideAndRoundByTenPow(rb, drop, mc.roundingMode.oldMode); 603 rs = compactValFor(rb); 604 if (rs != INFLATED) { 605 prec = longDigitLength(rs); 606 break; 607 } 608 prec = bigDigitLength(rb); 609 drop = prec - mcp; 610 } 611 } 612 if (rs != INFLATED) { 613 int drop = prec - mcp; 614 while (drop > 0) { 615 scl = checkScaleNonZero((long) scl - drop); 616 rs = divideAndRound(rs, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode); 617 prec = longDigitLength(rs); 618 drop = prec - mcp; 619 } 620 rb = null; 621 } 622 } 623 } 624 } catch (ArrayIndexOutOfBoundsException | NegativeArraySizeException e) { 625 NumberFormatException nfe = new NumberFormatException(); 626 nfe.initCause(e); 627 throw nfe; 628 } 629 this.scale = scl; 630 this.precision = prec; 631 this.intCompact = rs; 632 this.intVal = rb; 633 } 634 635 private int adjustScale(int scl, long exp) { 636 long adjustedScale = scl - exp; 637 if (adjustedScale > Integer.MAX_VALUE || adjustedScale < Integer.MIN_VALUE) 638 throw new NumberFormatException("Scale out of range."); 639 scl = (int) adjustedScale; 640 return scl; 641 } 642 643 /* 644 * parse exponent 645 */ 646 private static long parseExp(char[] in, int offset, int len){ 647 long exp = 0; 648 offset++; 649 char c = in[offset]; 650 len--; 651 boolean negexp = (c == '-'); 652 // optional sign 653 if (negexp || c == '+') { 654 offset++; 655 c = in[offset]; 656 len--; 657 } 658 if (len <= 0) // no exponent digits 659 throw new NumberFormatException("No exponent digits."); 660 // skip leading zeros in the exponent 661 while (len > 10 && (c=='0' || (Character.digit(c, 10) == 0))) { 662 offset++; 663 c = in[offset]; 664 len--; 665 } 666 if (len > 10) // too many nonzero exponent digits 667 throw new NumberFormatException("Too many nonzero exponent digits."); 668 // c now holds first digit of exponent 669 for (;; len--) { 670 int v; 671 if (c >= '0' && c <= '9') { 672 v = c - '0'; 673 } else { 674 v = Character.digit(c, 10); 675 if (v < 0) // not a digit 676 throw new NumberFormatException("Not a digit."); 677 } 678 exp = exp * 10 + v; 679 if (len == 1) 680 break; // that was final character 681 offset++; 682 c = in[offset]; 683 } 684 if (negexp) // apply sign 685 exp = -exp; 686 return exp; 687 } 688 689 /** 690 * Translates a character array representation of a 691 * {@code BigDecimal} into a {@code BigDecimal}, accepting the 692 * same sequence of characters as the {@link #BigDecimal(String)} 693 * constructor. 694 * 695 * @implNote If the sequence of characters is already available 696 * as a character array, using this constructor is faster than 697 * converting the {@code char} array to string and using the 698 * {@code BigDecimal(String)} constructor. 699 * 700 * @param in {@code char} array that is the source of characters. 701 * @throws NumberFormatException if {@code in} is not a valid 702 * representation of a {@code BigDecimal}. 703 * @since 1.5 704 */ 705 public BigDecimal(char[] in) { 706 this(in, 0, in.length); 707 } 708 709 /** 710 * Translates a character array representation of a 711 * {@code BigDecimal} into a {@code BigDecimal}, accepting the 712 * same sequence of characters as the {@link #BigDecimal(String)} 713 * constructor and with rounding according to the context 714 * settings. 715 * 716 * @implNote If the sequence of characters is already available 717 * as a character array, using this constructor is faster than 718 * converting the {@code char} array to string and using the 719 * {@code BigDecimal(String)} constructor. 720 * 721 * @param in {@code char} array that is the source of characters. 722 * @param mc the context to use. 723 * @throws ArithmeticException if the result is inexact but the 724 * rounding mode is {@code UNNECESSARY}. 725 * @throws NumberFormatException if {@code in} is not a valid 726 * representation of a {@code BigDecimal}. 727 * @since 1.5 728 */ 729 public BigDecimal(char[] in, MathContext mc) { 730 this(in, 0, in.length, mc); 731 } 732 733 /** 734 * Translates the string representation of a {@code BigDecimal} 735 * into a {@code BigDecimal}. The string representation consists 736 * of an optional sign, {@code '+'} (<code> '\u002B'</code>) or 737 * {@code '-'} (<code>'\u002D'</code>), followed by a sequence of 738 * zero or more decimal digits ("the integer"), optionally 739 * followed by a fraction, optionally followed by an exponent. 740 * 741 * <p>The fraction consists of a decimal point followed by zero 742 * or more decimal digits. The string must contain at least one 743 * digit in either the integer or the fraction. The number formed 744 * by the sign, the integer and the fraction is referred to as the 745 * <i>significand</i>. 746 * 747 * <p>The exponent consists of the character {@code 'e'} 748 * (<code>'\u0065'</code>) or {@code 'E'} (<code>'\u0045'</code>) 749 * followed by one or more decimal digits. The value of the 750 * exponent must lie between -{@link Integer#MAX_VALUE} ({@link 751 * Integer#MIN_VALUE}+1) and {@link Integer#MAX_VALUE}, inclusive. 752 * 753 * <p>More formally, the strings this constructor accepts are 754 * described by the following grammar: 755 * <blockquote> 756 * <dl> 757 * <dt><i>BigDecimalString:</i> 758 * <dd><i>Sign<sub>opt</sub> Significand Exponent<sub>opt</sub></i> 759 * <dt><i>Sign:</i> 760 * <dd>{@code +} 761 * <dd>{@code -} 762 * <dt><i>Significand:</i> 763 * <dd><i>IntegerPart</i> {@code .} <i>FractionPart<sub>opt</sub></i> 764 * <dd>{@code .} <i>FractionPart</i> 765 * <dd><i>IntegerPart</i> 766 * <dt><i>IntegerPart:</i> 767 * <dd><i>Digits</i> 768 * <dt><i>FractionPart:</i> 769 * <dd><i>Digits</i> 770 * <dt><i>Exponent:</i> 771 * <dd><i>ExponentIndicator SignedInteger</i> 772 * <dt><i>ExponentIndicator:</i> 773 * <dd>{@code e} 774 * <dd>{@code E} 775 * <dt><i>SignedInteger:</i> 776 * <dd><i>Sign<sub>opt</sub> Digits</i> 777 * <dt><i>Digits:</i> 778 * <dd><i>Digit</i> 779 * <dd><i>Digits Digit</i> 780 * <dt><i>Digit:</i> 781 * <dd>any character for which {@link Character#isDigit} 782 * returns {@code true}, including 0, 1, 2 ... 783 * </dl> 784 * </blockquote> 785 * 786 * <p>The scale of the returned {@code BigDecimal} will be the 787 * number of digits in the fraction, or zero if the string 788 * contains no decimal point, subject to adjustment for any 789 * exponent; if the string contains an exponent, the exponent is 790 * subtracted from the scale. The value of the resulting scale 791 * must lie between {@code Integer.MIN_VALUE} and 792 * {@code Integer.MAX_VALUE}, inclusive. 793 * 794 * <p>The character-to-digit mapping is provided by {@link 795 * java.lang.Character#digit} set to convert to radix 10. The 796 * String may not contain any extraneous characters (whitespace, 797 * for example). 798 * 799 * <p><b>Examples:</b><br> 800 * The value of the returned {@code BigDecimal} is equal to 801 * <i>significand</i> × 10<sup> <i>exponent</i></sup>. 802 * For each string on the left, the resulting representation 803 * [{@code BigInteger}, {@code scale}] is shown on the right. 804 * <pre> 805 * "0" [0,0] 806 * "0.00" [0,2] 807 * "123" [123,0] 808 * "-123" [-123,0] 809 * "1.23E3" [123,-1] 810 * "1.23E+3" [123,-1] 811 * "12.3E+7" [123,-6] 812 * "12.0" [120,1] 813 * "12.3" [123,1] 814 * "0.00123" [123,5] 815 * "-1.23E-12" [-123,14] 816 * "1234.5E-4" [12345,5] 817 * "0E+7" [0,-7] 818 * "-0" [0,0] 819 * </pre> 820 * 821 * @apiNote For values other than {@code float} and 822 * {@code double} NaN and ±Infinity, this constructor is 823 * compatible with the values returned by {@link Float#toString} 824 * and {@link Double#toString}. This is generally the preferred 825 * way to convert a {@code float} or {@code double} into a 826 * BigDecimal, as it doesn't suffer from the unpredictability of 827 * the {@link #BigDecimal(double)} constructor. 828 * 829 * @param val String representation of {@code BigDecimal}. 830 * 831 * @throws NumberFormatException if {@code val} is not a valid 832 * representation of a {@code BigDecimal}. 833 */ 834 public BigDecimal(String val) { 835 this(val.toCharArray(), 0, val.length()); 836 } 837 838 /** 839 * Translates the string representation of a {@code BigDecimal} 840 * into a {@code BigDecimal}, accepting the same strings as the 841 * {@link #BigDecimal(String)} constructor, with rounding 842 * according to the context settings. 843 * 844 * @param val string representation of a {@code BigDecimal}. 845 * @param mc the context to use. 846 * @throws ArithmeticException if the result is inexact but the 847 * rounding mode is {@code UNNECESSARY}. 848 * @throws NumberFormatException if {@code val} is not a valid 849 * representation of a BigDecimal. 850 * @since 1.5 851 */ 852 public BigDecimal(String val, MathContext mc) { 853 this(val.toCharArray(), 0, val.length(), mc); 854 } 855 856 /** 857 * Translates a {@code double} into a {@code BigDecimal} which 858 * is the exact decimal representation of the {@code double}'s 859 * binary floating-point value. The scale of the returned 860 * {@code BigDecimal} is the smallest value such that 861 * <code>(10<sup>scale</sup> × val)</code> is an integer. 862 * <p> 863 * <b>Notes:</b> 864 * <ol> 865 * <li> 866 * The results of this constructor can be somewhat unpredictable. 867 * One might assume that writing {@code new BigDecimal(0.1)} in 868 * Java creates a {@code BigDecimal} which is exactly equal to 869 * 0.1 (an unscaled value of 1, with a scale of 1), but it is 870 * actually equal to 871 * 0.1000000000000000055511151231257827021181583404541015625. 872 * This is because 0.1 cannot be represented exactly as a 873 * {@code double} (or, for that matter, as a binary fraction of 874 * any finite length). Thus, the value that is being passed 875 * <em>in</em> to the constructor is not exactly equal to 0.1, 876 * appearances notwithstanding. 877 * 878 * <li> 879 * The {@code String} constructor, on the other hand, is 880 * perfectly predictable: writing {@code new BigDecimal("0.1")} 881 * creates a {@code BigDecimal} which is <em>exactly</em> equal to 882 * 0.1, as one would expect. Therefore, it is generally 883 * recommended that the {@linkplain #BigDecimal(String) 884 * String constructor} be used in preference to this one. 885 * 886 * <li> 887 * When a {@code double} must be used as a source for a 888 * {@code BigDecimal}, note that this constructor provides an 889 * exact conversion; it does not give the same result as 890 * converting the {@code double} to a {@code String} using the 891 * {@link Double#toString(double)} method and then using the 892 * {@link #BigDecimal(String)} constructor. To get that result, 893 * use the {@code static} {@link #valueOf(double)} method. 894 * </ol> 895 * 896 * @param val {@code double} value to be converted to 897 * {@code BigDecimal}. 898 * @throws NumberFormatException if {@code val} is infinite or NaN. 899 */ 900 public BigDecimal(double val) { 901 this(val,MathContext.UNLIMITED); 902 } 903 904 /** 905 * Translates a {@code double} into a {@code BigDecimal}, with 906 * rounding according to the context settings. The scale of the 907 * {@code BigDecimal} is the smallest value such that 908 * <code>(10<sup>scale</sup> × val)</code> is an integer. 909 * 910 * <p>The results of this constructor can be somewhat unpredictable 911 * and its use is generally not recommended; see the notes under 912 * the {@link #BigDecimal(double)} constructor. 913 * 914 * @param val {@code double} value to be converted to 915 * {@code BigDecimal}. 916 * @param mc the context to use. 917 * @throws ArithmeticException if the result is inexact but the 918 * RoundingMode is UNNECESSARY. 919 * @throws NumberFormatException if {@code val} is infinite or NaN. 920 * @since 1.5 921 */ 922 public BigDecimal(double val, MathContext mc) { 923 if (Double.isInfinite(val) || Double.isNaN(val)) 924 throw new NumberFormatException("Infinite or NaN"); 925 // Translate the double into sign, exponent and significand, according 926 // to the formulae in JLS, Section 20.10.22. 927 long valBits = Double.doubleToLongBits(val); 928 int sign = ((valBits >> 63) == 0 ? 1 : -1); 929 int exponent = (int) ((valBits >> 52) & 0x7ffL); 930 long significand = (exponent == 0 931 ? (valBits & ((1L << 52) - 1)) << 1 932 : (valBits & ((1L << 52) - 1)) | (1L << 52)); 933 exponent -= 1075; 934 // At this point, val == sign * significand * 2**exponent. 935 936 /* 937 * Special case zero to supress nonterminating normalization and bogus 938 * scale calculation. 939 */ 940 if (significand == 0) { 941 this.intVal = BigInteger.ZERO; 942 this.scale = 0; 943 this.intCompact = 0; 944 this.precision = 1; 945 return; 946 } 947 // Normalize 948 while ((significand & 1) == 0) { // i.e., significand is even 949 significand >>= 1; 950 exponent++; 951 } 952 int scl = 0; 953 // Calculate intVal and scale 954 BigInteger rb; 955 long compactVal = sign * significand; 956 if (exponent == 0) { 957 rb = (compactVal == INFLATED) ? INFLATED_BIGINT : null; 958 } else { 959 if (exponent < 0) { 960 rb = BigInteger.valueOf(5).pow(-exponent).multiply(compactVal); 961 scl = -exponent; 962 } else { // (exponent > 0) 963 rb = BigInteger.TWO.pow(exponent).multiply(compactVal); 964 } 965 compactVal = compactValFor(rb); 966 } 967 int prec = 0; 968 int mcp = mc.precision; 969 if (mcp > 0) { // do rounding 970 int mode = mc.roundingMode.oldMode; 971 int drop; 972 if (compactVal == INFLATED) { 973 prec = bigDigitLength(rb); 974 drop = prec - mcp; 975 while (drop > 0) { 976 scl = checkScaleNonZero((long) scl - drop); 977 rb = divideAndRoundByTenPow(rb, drop, mode); 978 compactVal = compactValFor(rb); 979 if (compactVal != INFLATED) { 980 break; 981 } 982 prec = bigDigitLength(rb); 983 drop = prec - mcp; 984 } 985 } 986 if (compactVal != INFLATED) { 987 prec = longDigitLength(compactVal); 988 drop = prec - mcp; 989 while (drop > 0) { 990 scl = checkScaleNonZero((long) scl - drop); 991 compactVal = divideAndRound(compactVal, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode); 992 prec = longDigitLength(compactVal); 993 drop = prec - mcp; 994 } 995 rb = null; 996 } 997 } 998 this.intVal = rb; 999 this.intCompact = compactVal; 1000 this.scale = scl; 1001 this.precision = prec; 1002 } 1003 1004 /** 1005 * Translates a {@code BigInteger} into a {@code BigDecimal}. 1006 * The scale of the {@code BigDecimal} is zero. 1007 * 1008 * @param val {@code BigInteger} value to be converted to 1009 * {@code BigDecimal}. 1010 */ 1011 public BigDecimal(BigInteger val) { 1012 scale = 0; 1013 intVal = val; 1014 intCompact = compactValFor(val); 1015 } 1016 1017 /** 1018 * Translates a {@code BigInteger} into a {@code BigDecimal} 1019 * rounding according to the context settings. The scale of the 1020 * {@code BigDecimal} is zero. 1021 * 1022 * @param val {@code BigInteger} value to be converted to 1023 * {@code BigDecimal}. 1024 * @param mc the context to use. 1025 * @throws ArithmeticException if the result is inexact but the 1026 * rounding mode is {@code UNNECESSARY}. 1027 * @since 1.5 1028 */ 1029 public BigDecimal(BigInteger val, MathContext mc) { 1030 this(val,0,mc); 1031 } 1032 1033 /** 1034 * Translates a {@code BigInteger} unscaled value and an 1035 * {@code int} scale into a {@code BigDecimal}. The value of 1036 * the {@code BigDecimal} is 1037 * <code>(unscaledVal × 10<sup>-scale</sup>)</code>. 1038 * 1039 * @param unscaledVal unscaled value of the {@code BigDecimal}. 1040 * @param scale scale of the {@code BigDecimal}. 1041 */ 1042 public BigDecimal(BigInteger unscaledVal, int scale) { 1043 // Negative scales are now allowed 1044 this.intVal = unscaledVal; 1045 this.intCompact = compactValFor(unscaledVal); 1046 this.scale = scale; 1047 } 1048 1049 /** 1050 * Translates a {@code BigInteger} unscaled value and an 1051 * {@code int} scale into a {@code BigDecimal}, with rounding 1052 * according to the context settings. The value of the 1053 * {@code BigDecimal} is <code>(unscaledVal × 1054 * 10<sup>-scale</sup>)</code>, rounded according to the 1055 * {@code precision} and rounding mode settings. 1056 * 1057 * @param unscaledVal unscaled value of the {@code BigDecimal}. 1058 * @param scale scale of the {@code BigDecimal}. 1059 * @param mc the context to use. 1060 * @throws ArithmeticException if the result is inexact but the 1061 * rounding mode is {@code UNNECESSARY}. 1062 * @since 1.5 1063 */ 1064 public BigDecimal(BigInteger unscaledVal, int scale, MathContext mc) { 1065 long compactVal = compactValFor(unscaledVal); 1066 int mcp = mc.precision; 1067 int prec = 0; 1068 if (mcp > 0) { // do rounding 1069 int mode = mc.roundingMode.oldMode; 1070 if (compactVal == INFLATED) { 1071 prec = bigDigitLength(unscaledVal); 1072 int drop = prec - mcp; 1073 while (drop > 0) { 1074 scale = checkScaleNonZero((long) scale - drop); 1075 unscaledVal = divideAndRoundByTenPow(unscaledVal, drop, mode); 1076 compactVal = compactValFor(unscaledVal); 1077 if (compactVal != INFLATED) { 1078 break; 1079 } 1080 prec = bigDigitLength(unscaledVal); 1081 drop = prec - mcp; 1082 } 1083 } 1084 if (compactVal != INFLATED) { 1085 prec = longDigitLength(compactVal); 1086 int drop = prec - mcp; // drop can't be more than 18 1087 while (drop > 0) { 1088 scale = checkScaleNonZero((long) scale - drop); 1089 compactVal = divideAndRound(compactVal, LONG_TEN_POWERS_TABLE[drop], mode); 1090 prec = longDigitLength(compactVal); 1091 drop = prec - mcp; 1092 } 1093 unscaledVal = null; 1094 } 1095 } 1096 this.intVal = unscaledVal; 1097 this.intCompact = compactVal; 1098 this.scale = scale; 1099 this.precision = prec; 1100 } 1101 1102 /** 1103 * Translates an {@code int} into a {@code BigDecimal}. The 1104 * scale of the {@code BigDecimal} is zero. 1105 * 1106 * @param val {@code int} value to be converted to 1107 * {@code BigDecimal}. 1108 * @since 1.5 1109 */ 1110 public BigDecimal(int val) { 1111 this.intCompact = val; 1112 this.scale = 0; 1113 this.intVal = null; 1114 } 1115 1116 /** 1117 * Translates an {@code int} into a {@code BigDecimal}, with 1118 * rounding according to the context settings. The scale of the 1119 * {@code BigDecimal}, before any rounding, is zero. 1120 * 1121 * @param val {@code int} value to be converted to {@code BigDecimal}. 1122 * @param mc the context to use. 1123 * @throws ArithmeticException if the result is inexact but the 1124 * rounding mode is {@code UNNECESSARY}. 1125 * @since 1.5 1126 */ 1127 public BigDecimal(int val, MathContext mc) { 1128 int mcp = mc.precision; 1129 long compactVal = val; 1130 int scl = 0; 1131 int prec = 0; 1132 if (mcp > 0) { // do rounding 1133 prec = longDigitLength(compactVal); 1134 int drop = prec - mcp; // drop can't be more than 18 1135 while (drop > 0) { 1136 scl = checkScaleNonZero((long) scl - drop); 1137 compactVal = divideAndRound(compactVal, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode); 1138 prec = longDigitLength(compactVal); 1139 drop = prec - mcp; 1140 } 1141 } 1142 this.intVal = null; 1143 this.intCompact = compactVal; 1144 this.scale = scl; 1145 this.precision = prec; 1146 } 1147 1148 /** 1149 * Translates a {@code long} into a {@code BigDecimal}. The 1150 * scale of the {@code BigDecimal} is zero. 1151 * 1152 * @param val {@code long} value to be converted to {@code BigDecimal}. 1153 * @since 1.5 1154 */ 1155 public BigDecimal(long val) { 1156 this.intCompact = val; 1157 this.intVal = (val == INFLATED) ? INFLATED_BIGINT : null; 1158 this.scale = 0; 1159 } 1160 1161 /** 1162 * Translates a {@code long} into a {@code BigDecimal}, with 1163 * rounding according to the context settings. The scale of the 1164 * {@code BigDecimal}, before any rounding, is zero. 1165 * 1166 * @param val {@code long} value to be converted to {@code BigDecimal}. 1167 * @param mc the context to use. 1168 * @throws ArithmeticException if the result is inexact but the 1169 * rounding mode is {@code UNNECESSARY}. 1170 * @since 1.5 1171 */ 1172 public BigDecimal(long val, MathContext mc) { 1173 int mcp = mc.precision; 1174 int mode = mc.roundingMode.oldMode; 1175 int prec = 0; 1176 int scl = 0; 1177 BigInteger rb = (val == INFLATED) ? INFLATED_BIGINT : null; 1178 if (mcp > 0) { // do rounding 1179 if (val == INFLATED) { 1180 prec = 19; 1181 int drop = prec - mcp; 1182 while (drop > 0) { 1183 scl = checkScaleNonZero((long) scl - drop); 1184 rb = divideAndRoundByTenPow(rb, drop, mode); 1185 val = compactValFor(rb); 1186 if (val != INFLATED) { 1187 break; 1188 } 1189 prec = bigDigitLength(rb); 1190 drop = prec - mcp; 1191 } 1192 } 1193 if (val != INFLATED) { 1194 prec = longDigitLength(val); 1195 int drop = prec - mcp; 1196 while (drop > 0) { 1197 scl = checkScaleNonZero((long) scl - drop); 1198 val = divideAndRound(val, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode); 1199 prec = longDigitLength(val); 1200 drop = prec - mcp; 1201 } 1202 rb = null; 1203 } 1204 } 1205 this.intVal = rb; 1206 this.intCompact = val; 1207 this.scale = scl; 1208 this.precision = prec; 1209 } 1210 1211 // Static Factory Methods 1212 1213 /** 1214 * Translates a {@code long} unscaled value and an 1215 * {@code int} scale into a {@code BigDecimal}. 1216 * 1217 * @apiNote This static factory method is provided in preference 1218 * to a ({@code long}, {@code int}) constructor because it allows 1219 * for reuse of frequently used {@code BigDecimal} values. 1220 * 1221 * @param unscaledVal unscaled value of the {@code BigDecimal}. 1222 * @param scale scale of the {@code BigDecimal}. 1223 * @return a {@code BigDecimal} whose value is 1224 * <code>(unscaledVal × 10<sup>-scale</sup>)</code>. 1225 */ 1226 public static BigDecimal valueOf(long unscaledVal, int scale) { 1227 if (scale == 0) 1228 return valueOf(unscaledVal); 1229 else if (unscaledVal == 0) { 1230 return zeroValueOf(scale); 1231 } 1232 return new BigDecimal(unscaledVal == INFLATED ? 1233 INFLATED_BIGINT : null, 1234 unscaledVal, scale, 0); 1235 } 1236 1237 /** 1238 * Translates a {@code long} value into a {@code BigDecimal} 1239 * with a scale of zero. 1240 * 1241 * @apiNote This static factory method is provided in preference 1242 * to a ({@code long}) constructor because it allows for reuse of 1243 * frequently used {@code BigDecimal} values. 1244 * 1245 * @param val value of the {@code BigDecimal}. 1246 * @return a {@code BigDecimal} whose value is {@code val}. 1247 */ 1248 public static BigDecimal valueOf(long val) { 1249 if (val >= 0 && val < ZERO_THROUGH_TEN.length) 1250 return ZERO_THROUGH_TEN[(int)val]; 1251 else if (val != INFLATED) 1252 return new BigDecimal(null, val, 0, 0); 1253 return new BigDecimal(INFLATED_BIGINT, val, 0, 0); 1254 } 1255 1256 static BigDecimal valueOf(long unscaledVal, int scale, int prec) { 1257 if (scale == 0 && unscaledVal >= 0 && unscaledVal < ZERO_THROUGH_TEN.length) { 1258 return ZERO_THROUGH_TEN[(int) unscaledVal]; 1259 } else if (unscaledVal == 0) { 1260 return zeroValueOf(scale); 1261 } 1262 return new BigDecimal(unscaledVal == INFLATED ? INFLATED_BIGINT : null, 1263 unscaledVal, scale, prec); 1264 } 1265 1266 static BigDecimal valueOf(BigInteger intVal, int scale, int prec) { 1267 long val = compactValFor(intVal); 1268 if (val == 0) { 1269 return zeroValueOf(scale); 1270 } else if (scale == 0 && val >= 0 && val < ZERO_THROUGH_TEN.length) { 1271 return ZERO_THROUGH_TEN[(int) val]; 1272 } 1273 return new BigDecimal(intVal, val, scale, prec); 1274 } 1275 1276 static BigDecimal zeroValueOf(int scale) { 1277 if (scale >= 0 && scale < ZERO_SCALED_BY.length) 1278 return ZERO_SCALED_BY[scale]; 1279 else 1280 return new BigDecimal(BigInteger.ZERO, 0, scale, 1); 1281 } 1282 1283 /** 1284 * Translates a {@code double} into a {@code BigDecimal}, using 1285 * the {@code double}'s canonical string representation provided 1286 * by the {@link Double#toString(double)} method. 1287 * 1288 * @apiNote This is generally the preferred way to convert a 1289 * {@code double} (or {@code float}) into a {@code BigDecimal}, as 1290 * the value returned is equal to that resulting from constructing 1291 * a {@code BigDecimal} from the result of using {@link 1292 * Double#toString(double)}. 1293 * 1294 * @param val {@code double} to convert to a {@code BigDecimal}. 1295 * @return a {@code BigDecimal} whose value is equal to or approximately 1296 * equal to the value of {@code val}. 1297 * @throws NumberFormatException if {@code val} is infinite or NaN. 1298 * @since 1.5 1299 */ 1300 public static BigDecimal valueOf(double val) { 1301 // Reminder: a zero double returns '0.0', so we cannot fastpath 1302 // to use the constant ZERO. This might be important enough to 1303 // justify a factory approach, a cache, or a few private 1304 // constants, later. 1305 return new BigDecimal(Double.toString(val)); 1306 } 1307 1308 // Arithmetic Operations 1309 /** 1310 * Returns a {@code BigDecimal} whose value is {@code (this + 1311 * augend)}, and whose scale is {@code max(this.scale(), 1312 * augend.scale())}. 1313 * 1314 * @param augend value to be added to this {@code BigDecimal}. 1315 * @return {@code this + augend} 1316 */ 1317 public BigDecimal add(BigDecimal augend) { 1318 if (this.intCompact != INFLATED) { 1319 if ((augend.intCompact != INFLATED)) { 1320 return add(this.intCompact, this.scale, augend.intCompact, augend.scale); 1321 } else { 1322 return add(this.intCompact, this.scale, augend.intVal, augend.scale); 1323 } 1324 } else { 1325 if ((augend.intCompact != INFLATED)) { 1326 return add(augend.intCompact, augend.scale, this.intVal, this.scale); 1327 } else { 1328 return add(this.intVal, this.scale, augend.intVal, augend.scale); 1329 } 1330 } 1331 } 1332 1333 /** 1334 * Returns a {@code BigDecimal} whose value is {@code (this + augend)}, 1335 * with rounding according to the context settings. 1336 * 1337 * If either number is zero and the precision setting is nonzero then 1338 * the other number, rounded if necessary, is used as the result. 1339 * 1340 * @param augend value to be added to this {@code BigDecimal}. 1341 * @param mc the context to use. 1342 * @return {@code this + augend}, rounded as necessary. 1343 * @throws ArithmeticException if the result is inexact but the 1344 * rounding mode is {@code UNNECESSARY}. 1345 * @since 1.5 1346 */ 1347 public BigDecimal add(BigDecimal augend, MathContext mc) { 1348 if (mc.precision == 0) 1349 return add(augend); 1350 BigDecimal lhs = this; 1351 1352 // If either number is zero then the other number, rounded and 1353 // scaled if necessary, is used as the result. 1354 { 1355 boolean lhsIsZero = lhs.signum() == 0; 1356 boolean augendIsZero = augend.signum() == 0; 1357 1358 if (lhsIsZero || augendIsZero) { 1359 int preferredScale = Math.max(lhs.scale(), augend.scale()); 1360 BigDecimal result; 1361 1362 if (lhsIsZero && augendIsZero) 1363 return zeroValueOf(preferredScale); 1364 result = lhsIsZero ? doRound(augend, mc) : doRound(lhs, mc); 1365 1366 if (result.scale() == preferredScale) 1367 return result; 1368 else if (result.scale() > preferredScale) { 1369 return stripZerosToMatchScale(result.intVal, result.intCompact, result.scale, preferredScale); 1370 } else { // result.scale < preferredScale 1371 int precisionDiff = mc.precision - result.precision(); 1372 int scaleDiff = preferredScale - result.scale(); 1373 1374 if (precisionDiff >= scaleDiff) 1375 return result.setScale(preferredScale); // can achieve target scale 1376 else 1377 return result.setScale(result.scale() + precisionDiff); 1378 } 1379 } 1380 } 1381 1382 long padding = (long) lhs.scale - augend.scale; 1383 if (padding != 0) { // scales differ; alignment needed 1384 BigDecimal arg[] = preAlign(lhs, augend, padding, mc); 1385 matchScale(arg); 1386 lhs = arg[0]; 1387 augend = arg[1]; 1388 } 1389 return doRound(lhs.inflated().add(augend.inflated()), lhs.scale, mc); 1390 } 1391 1392 /** 1393 * Returns an array of length two, the sum of whose entries is 1394 * equal to the rounded sum of the {@code BigDecimal} arguments. 1395 * 1396 * <p>If the digit positions of the arguments have a sufficient 1397 * gap between them, the value smaller in magnitude can be 1398 * condensed into a {@literal "sticky bit"} and the end result will 1399 * round the same way <em>if</em> the precision of the final 1400 * result does not include the high order digit of the small 1401 * magnitude operand. 1402 * 1403 * <p>Note that while strictly speaking this is an optimization, 1404 * it makes a much wider range of additions practical. 1405 * 1406 * <p>This corresponds to a pre-shift operation in a fixed 1407 * precision floating-point adder; this method is complicated by 1408 * variable precision of the result as determined by the 1409 * MathContext. A more nuanced operation could implement a 1410 * {@literal "right shift"} on the smaller magnitude operand so 1411 * that the number of digits of the smaller operand could be 1412 * reduced even though the significands partially overlapped. 1413 */ 1414 private BigDecimal[] preAlign(BigDecimal lhs, BigDecimal augend, long padding, MathContext mc) { 1415 assert padding != 0; 1416 BigDecimal big; 1417 BigDecimal small; 1418 1419 if (padding < 0) { // lhs is big; augend is small 1420 big = lhs; 1421 small = augend; 1422 } else { // lhs is small; augend is big 1423 big = augend; 1424 small = lhs; 1425 } 1426 1427 /* 1428 * This is the estimated scale of an ulp of the result; it assumes that 1429 * the result doesn't have a carry-out on a true add (e.g. 999 + 1 => 1430 * 1000) or any subtractive cancellation on borrowing (e.g. 100 - 1.2 => 1431 * 98.8) 1432 */ 1433 long estResultUlpScale = (long) big.scale - big.precision() + mc.precision; 1434 1435 /* 1436 * The low-order digit position of big is big.scale(). This 1437 * is true regardless of whether big has a positive or 1438 * negative scale. The high-order digit position of small is 1439 * small.scale - (small.precision() - 1). To do the full 1440 * condensation, the digit positions of big and small must be 1441 * disjoint *and* the digit positions of small should not be 1442 * directly visible in the result. 1443 */ 1444 long smallHighDigitPos = (long) small.scale - small.precision() + 1; 1445 if (smallHighDigitPos > big.scale + 2 && // big and small disjoint 1446 smallHighDigitPos > estResultUlpScale + 2) { // small digits not visible 1447 small = BigDecimal.valueOf(small.signum(), this.checkScale(Math.max(big.scale, estResultUlpScale) + 3)); 1448 } 1449 1450 // Since addition is symmetric, preserving input order in 1451 // returned operands doesn't matter 1452 BigDecimal[] result = {big, small}; 1453 return result; 1454 } 1455 1456 /** 1457 * Returns a {@code BigDecimal} whose value is {@code (this - 1458 * subtrahend)}, and whose scale is {@code max(this.scale(), 1459 * subtrahend.scale())}. 1460 * 1461 * @param subtrahend value to be subtracted from this {@code BigDecimal}. 1462 * @return {@code this - subtrahend} 1463 */ 1464 public BigDecimal subtract(BigDecimal subtrahend) { 1465 if (this.intCompact != INFLATED) { 1466 if ((subtrahend.intCompact != INFLATED)) { 1467 return add(this.intCompact, this.scale, -subtrahend.intCompact, subtrahend.scale); 1468 } else { 1469 return add(this.intCompact, this.scale, subtrahend.intVal.negate(), subtrahend.scale); 1470 } 1471 } else { 1472 if ((subtrahend.intCompact != INFLATED)) { 1473 // Pair of subtrahend values given before pair of 1474 // values from this BigDecimal to avoid need for 1475 // method overloading on the specialized add method 1476 return add(-subtrahend.intCompact, subtrahend.scale, this.intVal, this.scale); 1477 } else { 1478 return add(this.intVal, this.scale, subtrahend.intVal.negate(), subtrahend.scale); 1479 } 1480 } 1481 } 1482 1483 /** 1484 * Returns a {@code BigDecimal} whose value is {@code (this - subtrahend)}, 1485 * with rounding according to the context settings. 1486 * 1487 * If {@code subtrahend} is zero then this, rounded if necessary, is used as the 1488 * result. If this is zero then the result is {@code subtrahend.negate(mc)}. 1489 * 1490 * @param subtrahend value to be subtracted from this {@code BigDecimal}. 1491 * @param mc the context to use. 1492 * @return {@code this - subtrahend}, rounded as necessary. 1493 * @throws ArithmeticException if the result is inexact but the 1494 * rounding mode is {@code UNNECESSARY}. 1495 * @since 1.5 1496 */ 1497 public BigDecimal subtract(BigDecimal subtrahend, MathContext mc) { 1498 if (mc.precision == 0) 1499 return subtract(subtrahend); 1500 // share the special rounding code in add() 1501 return add(subtrahend.negate(), mc); 1502 } 1503 1504 /** 1505 * Returns a {@code BigDecimal} whose value is <code>(this × 1506 * multiplicand)</code>, and whose scale is {@code (this.scale() + 1507 * multiplicand.scale())}. 1508 * 1509 * @param multiplicand value to be multiplied by this {@code BigDecimal}. 1510 * @return {@code this * multiplicand} 1511 */ 1512 public BigDecimal multiply(BigDecimal multiplicand) { 1513 int productScale = checkScale((long) scale + multiplicand.scale); 1514 if (this.intCompact != INFLATED) { 1515 if ((multiplicand.intCompact != INFLATED)) { 1516 return multiply(this.intCompact, multiplicand.intCompact, productScale); 1517 } else { 1518 return multiply(this.intCompact, multiplicand.intVal, productScale); 1519 } 1520 } else { 1521 if ((multiplicand.intCompact != INFLATED)) { 1522 return multiply(multiplicand.intCompact, this.intVal, productScale); 1523 } else { 1524 return multiply(this.intVal, multiplicand.intVal, productScale); 1525 } 1526 } 1527 } 1528 1529 /** 1530 * Returns a {@code BigDecimal} whose value is <code>(this × 1531 * multiplicand)</code>, with rounding according to the context settings. 1532 * 1533 * @param multiplicand value to be multiplied by this {@code BigDecimal}. 1534 * @param mc the context to use. 1535 * @return {@code this * multiplicand}, rounded as necessary. 1536 * @throws ArithmeticException if the result is inexact but the 1537 * rounding mode is {@code UNNECESSARY}. 1538 * @since 1.5 1539 */ 1540 public BigDecimal multiply(BigDecimal multiplicand, MathContext mc) { 1541 if (mc.precision == 0) 1542 return multiply(multiplicand); 1543 int productScale = checkScale((long) scale + multiplicand.scale); 1544 if (this.intCompact != INFLATED) { 1545 if ((multiplicand.intCompact != INFLATED)) { 1546 return multiplyAndRound(this.intCompact, multiplicand.intCompact, productScale, mc); 1547 } else { 1548 return multiplyAndRound(this.intCompact, multiplicand.intVal, productScale, mc); 1549 } 1550 } else { 1551 if ((multiplicand.intCompact != INFLATED)) { 1552 return multiplyAndRound(multiplicand.intCompact, this.intVal, productScale, mc); 1553 } else { 1554 return multiplyAndRound(this.intVal, multiplicand.intVal, productScale, mc); 1555 } 1556 } 1557 } 1558 1559 /** 1560 * Returns a {@code BigDecimal} whose value is {@code (this / 1561 * divisor)}, and whose scale is as specified. If rounding must 1562 * be performed to generate a result with the specified scale, the 1563 * specified rounding mode is applied. 1564 * 1565 * @deprecated The method {@link #divide(BigDecimal, int, RoundingMode)} 1566 * should be used in preference to this legacy method. 1567 * 1568 * @param divisor value by which this {@code BigDecimal} is to be divided. 1569 * @param scale scale of the {@code BigDecimal} quotient to be returned. 1570 * @param roundingMode rounding mode to apply. 1571 * @return {@code this / divisor} 1572 * @throws ArithmeticException if {@code divisor} is zero, 1573 * {@code roundingMode==ROUND_UNNECESSARY} and 1574 * the specified scale is insufficient to represent the result 1575 * of the division exactly. 1576 * @throws IllegalArgumentException if {@code roundingMode} does not 1577 * represent a valid rounding mode. 1578 * @see #ROUND_UP 1579 * @see #ROUND_DOWN 1580 * @see #ROUND_CEILING 1581 * @see #ROUND_FLOOR 1582 * @see #ROUND_HALF_UP 1583 * @see #ROUND_HALF_DOWN 1584 * @see #ROUND_HALF_EVEN 1585 * @see #ROUND_UNNECESSARY 1586 */ 1587 @Deprecated(since="9") 1588 public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) { 1589 if (roundingMode < ROUND_UP || roundingMode > ROUND_UNNECESSARY) 1590 throw new IllegalArgumentException("Invalid rounding mode"); 1591 if (this.intCompact != INFLATED) { 1592 if ((divisor.intCompact != INFLATED)) { 1593 return divide(this.intCompact, this.scale, divisor.intCompact, divisor.scale, scale, roundingMode); 1594 } else { 1595 return divide(this.intCompact, this.scale, divisor.intVal, divisor.scale, scale, roundingMode); 1596 } 1597 } else { 1598 if ((divisor.intCompact != INFLATED)) { 1599 return divide(this.intVal, this.scale, divisor.intCompact, divisor.scale, scale, roundingMode); 1600 } else { 1601 return divide(this.intVal, this.scale, divisor.intVal, divisor.scale, scale, roundingMode); 1602 } 1603 } 1604 } 1605 1606 /** 1607 * Returns a {@code BigDecimal} whose value is {@code (this / 1608 * divisor)}, and whose scale is as specified. If rounding must 1609 * be performed to generate a result with the specified scale, the 1610 * specified rounding mode is applied. 1611 * 1612 * @param divisor value by which this {@code BigDecimal} is to be divided. 1613 * @param scale scale of the {@code BigDecimal} quotient to be returned. 1614 * @param roundingMode rounding mode to apply. 1615 * @return {@code this / divisor} 1616 * @throws ArithmeticException if {@code divisor} is zero, 1617 * {@code roundingMode==RoundingMode.UNNECESSARY} and 1618 * the specified scale is insufficient to represent the result 1619 * of the division exactly. 1620 * @since 1.5 1621 */ 1622 public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) { 1623 return divide(divisor, scale, roundingMode.oldMode); 1624 } 1625 1626 /** 1627 * Returns a {@code BigDecimal} whose value is {@code (this / 1628 * divisor)}, and whose scale is {@code this.scale()}. If 1629 * rounding must be performed to generate a result with the given 1630 * scale, the specified rounding mode is applied. 1631 * 1632 * @deprecated The method {@link #divide(BigDecimal, RoundingMode)} 1633 * should be used in preference to this legacy method. 1634 * 1635 * @param divisor value by which this {@code BigDecimal} is to be divided. 1636 * @param roundingMode rounding mode to apply. 1637 * @return {@code this / divisor} 1638 * @throws ArithmeticException if {@code divisor==0}, or 1639 * {@code roundingMode==ROUND_UNNECESSARY} and 1640 * {@code this.scale()} is insufficient to represent the result 1641 * of the division exactly. 1642 * @throws IllegalArgumentException if {@code roundingMode} does not 1643 * represent a valid rounding mode. 1644 * @see #ROUND_UP 1645 * @see #ROUND_DOWN 1646 * @see #ROUND_CEILING 1647 * @see #ROUND_FLOOR 1648 * @see #ROUND_HALF_UP 1649 * @see #ROUND_HALF_DOWN 1650 * @see #ROUND_HALF_EVEN 1651 * @see #ROUND_UNNECESSARY 1652 */ 1653 @Deprecated(since="9") 1654 public BigDecimal divide(BigDecimal divisor, int roundingMode) { 1655 return this.divide(divisor, scale, roundingMode); 1656 } 1657 1658 /** 1659 * Returns a {@code BigDecimal} whose value is {@code (this / 1660 * divisor)}, and whose scale is {@code this.scale()}. If 1661 * rounding must be performed to generate a result with the given 1662 * scale, the specified rounding mode is applied. 1663 * 1664 * @param divisor value by which this {@code BigDecimal} is to be divided. 1665 * @param roundingMode rounding mode to apply. 1666 * @return {@code this / divisor} 1667 * @throws ArithmeticException if {@code divisor==0}, or 1668 * {@code roundingMode==RoundingMode.UNNECESSARY} and 1669 * {@code this.scale()} is insufficient to represent the result 1670 * of the division exactly. 1671 * @since 1.5 1672 */ 1673 public BigDecimal divide(BigDecimal divisor, RoundingMode roundingMode) { 1674 return this.divide(divisor, scale, roundingMode.oldMode); 1675 } 1676 1677 /** 1678 * Returns a {@code BigDecimal} whose value is {@code (this / 1679 * divisor)}, and whose preferred scale is {@code (this.scale() - 1680 * divisor.scale())}; if the exact quotient cannot be 1681 * represented (because it has a non-terminating decimal 1682 * expansion) an {@code ArithmeticException} is thrown. 1683 * 1684 * @param divisor value by which this {@code BigDecimal} is to be divided. 1685 * @throws ArithmeticException if the exact quotient does not have a 1686 * terminating decimal expansion 1687 * @return {@code this / divisor} 1688 * @since 1.5 1689 * @author Joseph D. Darcy 1690 */ 1691 public BigDecimal divide(BigDecimal divisor) { 1692 /* 1693 * Handle zero cases first. 1694 */ 1695 if (divisor.signum() == 0) { // x/0 1696 if (this.signum() == 0) // 0/0 1697 throw new ArithmeticException("Division undefined"); // NaN 1698 throw new ArithmeticException("Division by zero"); 1699 } 1700 1701 // Calculate preferred scale 1702 int preferredScale = saturateLong((long) this.scale - divisor.scale); 1703 1704 if (this.signum() == 0) // 0/y 1705 return zeroValueOf(preferredScale); 1706 else { 1707 /* 1708 * If the quotient this/divisor has a terminating decimal 1709 * expansion, the expansion can have no more than 1710 * (a.precision() + ceil(10*b.precision)/3) digits. 1711 * Therefore, create a MathContext object with this 1712 * precision and do a divide with the UNNECESSARY rounding 1713 * mode. 1714 */ 1715 MathContext mc = new MathContext( (int)Math.min(this.precision() + 1716 (long)Math.ceil(10.0*divisor.precision()/3.0), 1717 Integer.MAX_VALUE), 1718 RoundingMode.UNNECESSARY); 1719 BigDecimal quotient; 1720 try { 1721 quotient = this.divide(divisor, mc); 1722 } catch (ArithmeticException e) { 1723 throw new ArithmeticException("Non-terminating decimal expansion; " + 1724 "no exact representable decimal result."); 1725 } 1726 1727 int quotientScale = quotient.scale(); 1728 1729 // divide(BigDecimal, mc) tries to adjust the quotient to 1730 // the desired one by removing trailing zeros; since the 1731 // exact divide method does not have an explicit digit 1732 // limit, we can add zeros too. 1733 if (preferredScale > quotientScale) 1734 return quotient.setScale(preferredScale, ROUND_UNNECESSARY); 1735 1736 return quotient; 1737 } 1738 } 1739 1740 /** 1741 * Returns a {@code BigDecimal} whose value is {@code (this / 1742 * divisor)}, with rounding according to the context settings. 1743 * 1744 * @param divisor value by which this {@code BigDecimal} is to be divided. 1745 * @param mc the context to use. 1746 * @return {@code this / divisor}, rounded as necessary. 1747 * @throws ArithmeticException if the result is inexact but the 1748 * rounding mode is {@code UNNECESSARY} or 1749 * {@code mc.precision == 0} and the quotient has a 1750 * non-terminating decimal expansion. 1751 * @since 1.5 1752 */ 1753 public BigDecimal divide(BigDecimal divisor, MathContext mc) { 1754 int mcp = mc.precision; 1755 if (mcp == 0) 1756 return divide(divisor); 1757 1758 BigDecimal dividend = this; 1759 long preferredScale = (long)dividend.scale - divisor.scale; 1760 // Now calculate the answer. We use the existing 1761 // divide-and-round method, but as this rounds to scale we have 1762 // to normalize the values here to achieve the desired result. 1763 // For x/y we first handle y=0 and x=0, and then normalize x and 1764 // y to give x' and y' with the following constraints: 1765 // (a) 0.1 <= x' < 1 1766 // (b) x' <= y' < 10*x' 1767 // Dividing x'/y' with the required scale set to mc.precision then 1768 // will give a result in the range 0.1 to 1 rounded to exactly 1769 // the right number of digits (except in the case of a result of 1770 // 1.000... which can arise when x=y, or when rounding overflows 1771 // The 1.000... case will reduce properly to 1. 1772 if (divisor.signum() == 0) { // x/0 1773 if (dividend.signum() == 0) // 0/0 1774 throw new ArithmeticException("Division undefined"); // NaN 1775 throw new ArithmeticException("Division by zero"); 1776 } 1777 if (dividend.signum() == 0) // 0/y 1778 return zeroValueOf(saturateLong(preferredScale)); 1779 int xscale = dividend.precision(); 1780 int yscale = divisor.precision(); 1781 if(dividend.intCompact!=INFLATED) { 1782 if(divisor.intCompact!=INFLATED) { 1783 return divide(dividend.intCompact, xscale, divisor.intCompact, yscale, preferredScale, mc); 1784 } else { 1785 return divide(dividend.intCompact, xscale, divisor.intVal, yscale, preferredScale, mc); 1786 } 1787 } else { 1788 if(divisor.intCompact!=INFLATED) { 1789 return divide(dividend.intVal, xscale, divisor.intCompact, yscale, preferredScale, mc); 1790 } else { 1791 return divide(dividend.intVal, xscale, divisor.intVal, yscale, preferredScale, mc); 1792 } 1793 } 1794 } 1795 1796 /** 1797 * Returns a {@code BigDecimal} whose value is the integer part 1798 * of the quotient {@code (this / divisor)} rounded down. The 1799 * preferred scale of the result is {@code (this.scale() - 1800 * divisor.scale())}. 1801 * 1802 * @param divisor value by which this {@code BigDecimal} is to be divided. 1803 * @return The integer part of {@code this / divisor}. 1804 * @throws ArithmeticException if {@code divisor==0} 1805 * @since 1.5 1806 */ 1807 public BigDecimal divideToIntegralValue(BigDecimal divisor) { 1808 // Calculate preferred scale 1809 int preferredScale = saturateLong((long) this.scale - divisor.scale); 1810 if (this.compareMagnitude(divisor) < 0) { 1811 // much faster when this << divisor 1812 return zeroValueOf(preferredScale); 1813 } 1814 1815 if (this.signum() == 0 && divisor.signum() != 0) 1816 return this.setScale(preferredScale, ROUND_UNNECESSARY); 1817 1818 // Perform a divide with enough digits to round to a correct 1819 // integer value; then remove any fractional digits 1820 1821 int maxDigits = (int)Math.min(this.precision() + 1822 (long)Math.ceil(10.0*divisor.precision()/3.0) + 1823 Math.abs((long)this.scale() - divisor.scale()) + 2, 1824 Integer.MAX_VALUE); 1825 BigDecimal quotient = this.divide(divisor, new MathContext(maxDigits, 1826 RoundingMode.DOWN)); 1827 if (quotient.scale > 0) { 1828 quotient = quotient.setScale(0, RoundingMode.DOWN); 1829 quotient = stripZerosToMatchScale(quotient.intVal, quotient.intCompact, quotient.scale, preferredScale); 1830 } 1831 1832 if (quotient.scale < preferredScale) { 1833 // pad with zeros if necessary 1834 quotient = quotient.setScale(preferredScale, ROUND_UNNECESSARY); 1835 } 1836 1837 return quotient; 1838 } 1839 1840 /** 1841 * Returns a {@code BigDecimal} whose value is the integer part 1842 * of {@code (this / divisor)}. Since the integer part of the 1843 * exact quotient does not depend on the rounding mode, the 1844 * rounding mode does not affect the values returned by this 1845 * method. The preferred scale of the result is 1846 * {@code (this.scale() - divisor.scale())}. An 1847 * {@code ArithmeticException} is thrown if the integer part of 1848 * the exact quotient needs more than {@code mc.precision} 1849 * digits. 1850 * 1851 * @param divisor value by which this {@code BigDecimal} is to be divided. 1852 * @param mc the context to use. 1853 * @return The integer part of {@code this / divisor}. 1854 * @throws ArithmeticException if {@code divisor==0} 1855 * @throws ArithmeticException if {@code mc.precision} {@literal >} 0 and the result 1856 * requires a precision of more than {@code mc.precision} digits. 1857 * @since 1.5 1858 * @author Joseph D. Darcy 1859 */ 1860 public BigDecimal divideToIntegralValue(BigDecimal divisor, MathContext mc) { 1861 if (mc.precision == 0 || // exact result 1862 (this.compareMagnitude(divisor) < 0)) // zero result 1863 return divideToIntegralValue(divisor); 1864 1865 // Calculate preferred scale 1866 int preferredScale = saturateLong((long)this.scale - divisor.scale); 1867 1868 /* 1869 * Perform a normal divide to mc.precision digits. If the 1870 * remainder has absolute value less than the divisor, the 1871 * integer portion of the quotient fits into mc.precision 1872 * digits. Next, remove any fractional digits from the 1873 * quotient and adjust the scale to the preferred value. 1874 */ 1875 BigDecimal result = this.divide(divisor, new MathContext(mc.precision, RoundingMode.DOWN)); 1876 1877 if (result.scale() < 0) { 1878 /* 1879 * Result is an integer. See if quotient represents the 1880 * full integer portion of the exact quotient; if it does, 1881 * the computed remainder will be less than the divisor. 1882 */ 1883 BigDecimal product = result.multiply(divisor); 1884 // If the quotient is the full integer value, 1885 // |dividend-product| < |divisor|. 1886 if (this.subtract(product).compareMagnitude(divisor) >= 0) { 1887 throw new ArithmeticException("Division impossible"); 1888 } 1889 } else if (result.scale() > 0) { 1890 /* 1891 * Integer portion of quotient will fit into precision 1892 * digits; recompute quotient to scale 0 to avoid double 1893 * rounding and then try to adjust, if necessary. 1894 */ 1895 result = result.setScale(0, RoundingMode.DOWN); 1896 } 1897 // else result.scale() == 0; 1898 1899 int precisionDiff; 1900 if ((preferredScale > result.scale()) && 1901 (precisionDiff = mc.precision - result.precision()) > 0) { 1902 return result.setScale(result.scale() + 1903 Math.min(precisionDiff, preferredScale - result.scale) ); 1904 } else { 1905 return stripZerosToMatchScale(result.intVal,result.intCompact,result.scale,preferredScale); 1906 } 1907 } 1908 1909 /** 1910 * Returns a {@code BigDecimal} whose value is {@code (this % divisor)}. 1911 * 1912 * <p>The remainder is given by 1913 * {@code this.subtract(this.divideToIntegralValue(divisor).multiply(divisor))}. 1914 * Note that this is <em>not</em> the modulo operation (the result can be 1915 * negative). 1916 * 1917 * @param divisor value by which this {@code BigDecimal} is to be divided. 1918 * @return {@code this % divisor}. 1919 * @throws ArithmeticException if {@code divisor==0} 1920 * @since 1.5 1921 */ 1922 public BigDecimal remainder(BigDecimal divisor) { 1923 BigDecimal divrem[] = this.divideAndRemainder(divisor); 1924 return divrem[1]; 1925 } 1926 1927 1928 /** 1929 * Returns a {@code BigDecimal} whose value is {@code (this % 1930 * divisor)}, with rounding according to the context settings. 1931 * The {@code MathContext} settings affect the implicit divide 1932 * used to compute the remainder. The remainder computation 1933 * itself is by definition exact. Therefore, the remainder may 1934 * contain more than {@code mc.getPrecision()} digits. 1935 * 1936 * <p>The remainder is given by 1937 * {@code this.subtract(this.divideToIntegralValue(divisor, 1938 * mc).multiply(divisor))}. Note that this is not the modulo 1939 * operation (the result can be negative). 1940 * 1941 * @param divisor value by which this {@code BigDecimal} is to be divided. 1942 * @param mc the context to use. 1943 * @return {@code this % divisor}, rounded as necessary. 1944 * @throws ArithmeticException if {@code divisor==0} 1945 * @throws ArithmeticException if the result is inexact but the 1946 * rounding mode is {@code UNNECESSARY}, or {@code mc.precision} 1947 * {@literal >} 0 and the result of {@code this.divideToIntgralValue(divisor)} would 1948 * require a precision of more than {@code mc.precision} digits. 1949 * @see #divideToIntegralValue(java.math.BigDecimal, java.math.MathContext) 1950 * @since 1.5 1951 */ 1952 public BigDecimal remainder(BigDecimal divisor, MathContext mc) { 1953 BigDecimal divrem[] = this.divideAndRemainder(divisor, mc); 1954 return divrem[1]; 1955 } 1956 1957 /** 1958 * Returns a two-element {@code BigDecimal} array containing the 1959 * result of {@code divideToIntegralValue} followed by the result of 1960 * {@code remainder} on the two operands. 1961 * 1962 * <p>Note that if both the integer quotient and remainder are 1963 * needed, this method is faster than using the 1964 * {@code divideToIntegralValue} and {@code remainder} methods 1965 * separately because the division need only be carried out once. 1966 * 1967 * @param divisor value by which this {@code BigDecimal} is to be divided, 1968 * and the remainder computed. 1969 * @return a two element {@code BigDecimal} array: the quotient 1970 * (the result of {@code divideToIntegralValue}) is the initial element 1971 * and the remainder is the final element. 1972 * @throws ArithmeticException if {@code divisor==0} 1973 * @see #divideToIntegralValue(java.math.BigDecimal, java.math.MathContext) 1974 * @see #remainder(java.math.BigDecimal, java.math.MathContext) 1975 * @since 1.5 1976 */ 1977 public BigDecimal[] divideAndRemainder(BigDecimal divisor) { 1978 // we use the identity x = i * y + r to determine r 1979 BigDecimal[] result = new BigDecimal[2]; 1980 1981 result[0] = this.divideToIntegralValue(divisor); 1982 result[1] = this.subtract(result[0].multiply(divisor)); 1983 return result; 1984 } 1985 1986 /** 1987 * Returns a two-element {@code BigDecimal} array containing the 1988 * result of {@code divideToIntegralValue} followed by the result of 1989 * {@code remainder} on the two operands calculated with rounding 1990 * according to the context settings. 1991 * 1992 * <p>Note that if both the integer quotient and remainder are 1993 * needed, this method is faster than using the 1994 * {@code divideToIntegralValue} and {@code remainder} methods 1995 * separately because the division need only be carried out once. 1996 * 1997 * @param divisor value by which this {@code BigDecimal} is to be divided, 1998 * and the remainder computed. 1999 * @param mc the context to use. 2000 * @return a two element {@code BigDecimal} array: the quotient 2001 * (the result of {@code divideToIntegralValue}) is the 2002 * initial element and the remainder is the final element. 2003 * @throws ArithmeticException if {@code divisor==0} 2004 * @throws ArithmeticException if the result is inexact but the 2005 * rounding mode is {@code UNNECESSARY}, or {@code mc.precision} 2006 * {@literal >} 0 and the result of {@code this.divideToIntgralValue(divisor)} would 2007 * require a precision of more than {@code mc.precision} digits. 2008 * @see #divideToIntegralValue(java.math.BigDecimal, java.math.MathContext) 2009 * @see #remainder(java.math.BigDecimal, java.math.MathContext) 2010 * @since 1.5 2011 */ 2012 public BigDecimal[] divideAndRemainder(BigDecimal divisor, MathContext mc) { 2013 if (mc.precision == 0) 2014 return divideAndRemainder(divisor); 2015 2016 BigDecimal[] result = new BigDecimal[2]; 2017 BigDecimal lhs = this; 2018 2019 result[0] = lhs.divideToIntegralValue(divisor, mc); 2020 result[1] = lhs.subtract(result[0].multiply(divisor)); 2021 return result; 2022 } 2023 2024 /** 2025 * Returns an approximation to the square root of {@code this} 2026 * with rounding according to the context settings. 2027 * 2028 * <p>The preferred scale of the returned result is equal to 2029 * {@code this.scale()/2}. The value of the returned result is 2030 * always within one ulp of the exact decimal value for the 2031 * precision in question. If the rounding mode is {@link 2032 * RoundingMode#HALF_UP HALF_UP}, {@link RoundingMode#HALF_DOWN 2033 * HALF_DOWN}, or {@link RoundingMode#HALF_EVEN HALF_EVEN}, the 2034 * result is within one half an ulp of the exact decimal value. 2035 * 2036 * <p>Special case: 2037 * <ul> 2038 * <li> The square root of a number numerically equal to {@code 2039 * ZERO} is numerically equal to {@code ZERO} with a preferred 2040 * scale according to the general rule above. In particular, for 2041 * {@code ZERO}, {@code ZERO.sqrt(mc).equals(ZERO)} is true with 2042 * any {@code MathContext} as an argument. 2043 * </ul> 2044 * 2045 * @param mc the context to use. 2046 * @return the square root of {@code this}. 2047 * @throws ArithmeticException if {@code this} is less than zero. 2048 * @throws ArithmeticException if an exact result is requested 2049 * ({@code mc.getPrecision()==0}) and there is no finite decimal 2050 * expansion of the exact result 2051 * @throws ArithmeticException if 2052 * {@code (mc.getRoundingMode()==RoundingMode.UNNECESSARY}) and 2053 * the exact result cannot fit in {@code mc.getPrecision()} 2054 * digits. 2055 * @see BigInteger#sqrt() 2056 * @since 9 2057 */ 2058 public BigDecimal sqrt(MathContext mc) { 2059 int signum = signum(); 2060 if (signum == 1) { 2061 /* 2062 * The following code draws on the algorithm presented in 2063 * "Properly Rounded Variable Precision Square Root," Hull and 2064 * Abrham, ACM Transactions on Mathematical Software, Vol 11, 2065 * No. 3, September 1985, Pages 229-237. 2066 * 2067 * The BigDecimal computational model differs from the one 2068 * presented in the paper in several ways: first BigDecimal 2069 * numbers aren't necessarily normalized, second many more 2070 * rounding modes are supported, including UNNECESSARY, and 2071 * exact results can be requested. 2072 * 2073 * The main steps of the algorithm below are as follows, 2074 * first argument reduce the value to the numerical range 2075 * [1, 10) using the following relations: 2076 * 2077 * x = y * 10 ^ exp 2078 * sqrt(x) = sqrt(y) * 10^(exp / 2) if exp is even 2079 * sqrt(x) = sqrt(y/10) * 10 ^((exp+1)/2) is exp is odd 2080 * 2081 * Then use Newton's iteration on the reduced value to compute 2082 * the numerical digits of the desired result. 2083 * 2084 * Finally, scale back to the desired exponent range and 2085 * perform any adjustment to get the preferred scale in the 2086 * representation. 2087 */ 2088 2089 // The code below favors relative simplicity over checking 2090 // for special cases that could run faster. 2091 2092 int preferredScale = this.scale()/2; 2093 BigDecimal zeroWithFinalPreferredScale = valueOf(0L, preferredScale); 2094 2095 // First phase of numerical normalization, strip trailing 2096 // zeros and check for even powers of 10. 2097 BigDecimal stripped = this.stripTrailingZeros(); 2098 int strippedScale = stripped.scale(); 2099 2100 // Numerically sqrt(10^2N) = 10^N 2101 if (stripped.isPowerOfTen() && 2102 strippedScale % 2 == 0) { 2103 BigDecimal result = valueOf(1L, strippedScale/2); 2104 if (result.scale() != preferredScale) { 2105 // Adjust to requested precision and preferred 2106 // scale as appropriate. 2107 result = result.add(zeroWithFinalPreferredScale, mc); 2108 } 2109 return result; 2110 } 2111 2112 // After stripTrailingZeros, the representation is normalized as 2113 // 2114 // unscaledValue * 10^(-scale) 2115 // 2116 // where unscaledValue is an integer with the mimimum 2117 // precision for the cohort of the numerical value. To 2118 // allow binary floating-point hardware to be used to get 2119 // approximately a 15 digit approximation to the square 2120 // root, it is helpful to instead normalize this so that 2121 // the significand portion is to right of the decimal 2122 // point by roughly (scale() - precision() +1). 2123 2124 // Now the precision / scale adjustment 2125 int scaleAdjust = 0; 2126 int scale = stripped.scale() - stripped.precision() + 1; 2127 if (scale % 2 == 0) { 2128 scaleAdjust = scale; 2129 } else { 2130 scaleAdjust = scale - 1; 2131 } 2132 2133 BigDecimal working = stripped.scaleByPowerOfTen(scaleAdjust); 2134 2135 assert // Verify 0.1 <= working < 10 2136 ONE_TENTH.compareTo(working) <= 0 && working.compareTo(TEN) < 0; 2137 2138 // Use good ole' Math.sqrt to get the initial guess for 2139 // the Newton iteration, good to at least 15 decimal 2140 // digits. This approach does incur the cost of a 2141 // 2142 // BigDecimal -> double -> BigDecimal 2143 // 2144 // conversion cycle, but it avoids the need for several 2145 // Newton iterations in BigDecimal arithmetic to get the 2146 // working answer to 15 digits of precision. If many fewer 2147 // than 15 digits were needed, it might be faster to do 2148 // the loop entirely in BigDecimal arithmetic. 2149 // 2150 // (A double value might have as much many as 17 decimal 2151 // digits of precision; it depends on the relative density 2152 // of binary and decimal numbers at different regions of 2153 // the number line.) 2154 // 2155 // (It would be possible to check for certain special 2156 // cases to avoid doing any Newton iterations. For 2157 // example, if the BigDecimal -> double conversion was 2158 // known to be exact and the rounding mode had a 2159 // low-enough precision, the post-Newton rounding logic 2160 // could be applied directly.) 2161 2162 BigDecimal guess = new BigDecimal(Math.sqrt(working.doubleValue())); 2163 int guessPrecision = 15; 2164 int originalPrecision = mc.getPrecision(); 2165 int targetPrecision; 2166 2167 // If an exact value is requested, it must only need about 2168 // half of the input digits to represent since multiplying 2169 // an N digit number by itself yield a 2N-1 digit or 2N 2170 // digit result. 2171 if (originalPrecision == 0) { 2172 targetPrecision = stripped.precision()/2 + 1; 2173 } else { 2174 targetPrecision = originalPrecision; 2175 } 2176 2177 // When setting the precision to use inside the Newton 2178 // iteration loop, take care to avoid the case where the 2179 // precision of the input exceeds the requested precision 2180 // and rounding the input value too soon. 2181 BigDecimal approx = guess; 2182 int workingPrecision = working.precision(); 2183 do { 2184 int tmpPrecision = Math.max(Math.max(guessPrecision, targetPrecision + 2), 2185 workingPrecision); 2186 MathContext mcTmp = new MathContext(tmpPrecision, RoundingMode.HALF_EVEN); 2187 // approx = 0.5 * (approx + fraction / approx) 2188 approx = ONE_HALF.multiply(approx.add(working.divide(approx, mcTmp), mcTmp)); 2189 guessPrecision *= 2; 2190 } while (guessPrecision < targetPrecision + 2); 2191 2192 BigDecimal result; 2193 RoundingMode targetRm = mc.getRoundingMode(); 2194 if (targetRm == RoundingMode.UNNECESSARY || originalPrecision == 0) { 2195 RoundingMode tmpRm = 2196 (targetRm == RoundingMode.UNNECESSARY) ? RoundingMode.DOWN : targetRm; 2197 MathContext mcTmp = new MathContext(targetPrecision, tmpRm); 2198 result = approx.scaleByPowerOfTen(-scaleAdjust/2).round(mcTmp); 2199 2200 // If result*result != this numerically, the square 2201 // root isn't exact 2202 if (this.subtract(result.multiply(result)).compareTo(ZERO) != 0) { 2203 throw new ArithmeticException("Computed square root not exact."); 2204 } 2205 } else { 2206 result = approx.scaleByPowerOfTen(-scaleAdjust/2).round(mc); 2207 2208 switch (targetRm) { 2209 case DOWN: 2210 case FLOOR: 2211 // Check if too big 2212 if (result.multiply(result).compareTo(this) > 0 ) { 2213 BigDecimal ulp = ulp = result.ulp(); 2214 // Adjust increment down in case of 1.0 = 10^0 2215 // since the next smaller number is only 1/10 2216 // as far way as the next larger at exponent 2217 // boundaries. Test approx and *not* result to 2218 // avoid having to detect an arbitrary power of ten. 2219 if (approx.compareTo(ONE) == 0) { 2220 ulp = ulp.multiply(ONE_TENTH); 2221 } 2222 result = result.subtract(ulp); 2223 } 2224 break; 2225 2226 case UP: 2227 case CEILING: 2228 // Check if too small 2229 if (result.multiply(result).compareTo(this) < 0 ) { 2230 result = result.add(result.ulp()); 2231 } 2232 break; 2233 2234 default: 2235 // Do nothing for half-way cases 2236 // HALF_DOWN, HALF_EVEN, HALF_UP 2237 // See fix-up in paper, up down by *1/2* ulp 2238 2239 break; 2240 } 2241 2242 } 2243 2244 // Test numerical properties at full precision before any 2245 // scale adjustments. 2246 assert squareRootResultAssertions(result, mc); 2247 if (result.scale() != preferredScale) { 2248 // The preferred scale of an add is 2249 // max(addend.scale(), augend.scale()). Therefore, if 2250 // the scale of the result is first minimized using 2251 // stripTrailingZeros(), adding a zero of the 2252 // preferred scale rounding the correct precision will 2253 // perform the proper scale vs precision tradeoffs. 2254 result = result.stripTrailingZeros(). 2255 add(zeroWithFinalPreferredScale, 2256 new MathContext(originalPrecision, RoundingMode.UNNECESSARY)); 2257 } 2258 return result; 2259 } else { 2260 switch (signum) { 2261 case -1: 2262 throw new ArithmeticException("Attempted square root " + 2263 "of negative BigDecimal"); 2264 case 0: 2265 return valueOf(0L, scale()/2); 2266 2267 default: 2268 throw new AssertionError("Bad value from signum"); 2269 } 2270 } 2271 } 2272 2273 private boolean isPowerOfTen() { 2274 return BigInteger.ONE.equals(this.unscaledValue()); 2275 } 2276 2277 /** 2278 * For nonzero values, check numerical correctness properties of 2279 * the computed result for the chosen rounding mode. 2280 * 2281 * For the directed roundings, for DOWN and FLOOR, result^2 must 2282 * be {@code <=} the input and (result+ulp)^2 must be {@code >} the 2283 * input. Conversely, for UP and CEIL, result^2 must be {@code >=} the 2284 * input and (result-ulp)^2 must be {@code <} the input. 2285 */ 2286 private boolean squareRootResultAssertions(BigDecimal result, MathContext mc) { 2287 if (result.signum() == 0) { 2288 return squareRootZeroResultAssertions(result, mc); 2289 } else { 2290 RoundingMode rm = mc.getRoundingMode(); 2291 BigDecimal ulp = result.ulp(); 2292 BigDecimal neighborUp = result.add(ulp); 2293 // Make neighbor down accurate even for powers of ten 2294 if (result.isPowerOfTen()) { 2295 ulp = ulp.divide(TEN); 2296 } 2297 BigDecimal neighborDown = result.subtract(ulp); 2298 2299 // Both the starting value and result should be nonzero and positive. 2300 if (result.signum() != 1 || 2301 this.signum() != 1) { 2302 return false; 2303 } 2304 2305 switch (rm) { 2306 case DOWN: 2307 case FLOOR: 2308 assert 2309 result.multiply(result).compareTo(this) <= 0 && 2310 neighborUp.multiply(neighborUp).compareTo(this) > 0: 2311 "Square of result out for bounds rounding " + rm; 2312 return true; 2313 2314 case UP: 2315 case CEILING: 2316 assert 2317 result.multiply(result).compareTo(this) >= 0 && 2318 neighborDown.multiply(neighborDown).compareTo(this) < 0: 2319 "Square of result out for bounds rounding " + rm; 2320 return true; 2321 2322 2323 case HALF_DOWN: 2324 case HALF_EVEN: 2325 case HALF_UP: 2326 BigDecimal err = result.multiply(result).subtract(this).abs(); 2327 BigDecimal errUp = neighborUp.multiply(neighborUp).subtract(this); 2328 BigDecimal errDown = this.subtract(neighborDown.multiply(neighborDown)); 2329 // All error values should be positive so don't need to 2330 // compare absolute values. 2331 2332 int err_comp_errUp = err.compareTo(errUp); 2333 int err_comp_errDown = err.compareTo(errDown); 2334 2335 assert 2336 errUp.signum() == 1 && 2337 errDown.signum() == 1 : 2338 "Errors of neighbors squared don't have correct signs"; 2339 2340 assert 2341 err_comp_errUp <= 0 && 2342 err_comp_errDown <= 0 : 2343 "Computed square root has larger error than neighbors for " + rm; 2344 2345 assert 2346 ((err_comp_errUp == 0 ) ? err_comp_errDown < 0 : true) && 2347 ((err_comp_errDown == 0 ) ? err_comp_errUp < 0 : true) : 2348 "Incorrect error relationships"; 2349 // && could check for digit conditions for ties too 2350 return true; 2351 2352 default: // Definition of UNNECESSARY already verified. 2353 return true; 2354 } 2355 } 2356 } 2357 2358 private boolean squareRootZeroResultAssertions(BigDecimal result, MathContext mc) { 2359 return this.compareTo(ZERO) == 0; 2360 } 2361 2362 /** 2363 * Returns a {@code BigDecimal} whose value is 2364 * <code>(this<sup>n</sup>)</code>, The power is computed exactly, to 2365 * unlimited precision. 2366 * 2367 * <p>The parameter {@code n} must be in the range 0 through 2368 * 999999999, inclusive. {@code ZERO.pow(0)} returns {@link 2369 * #ONE}. 2370 * 2371 * Note that future releases may expand the allowable exponent 2372 * range of this method. 2373 * 2374 * @param n power to raise this {@code BigDecimal} to. 2375 * @return <code>this<sup>n</sup></code> 2376 * @throws ArithmeticException if {@code n} is out of range. 2377 * @since 1.5 2378 */ 2379 public BigDecimal pow(int n) { 2380 if (n < 0 || n > 999999999) 2381 throw new ArithmeticException("Invalid operation"); 2382 // No need to calculate pow(n) if result will over/underflow. 2383 // Don't attempt to support "supernormal" numbers. 2384 int newScale = checkScale((long)scale * n); 2385 return new BigDecimal(this.inflated().pow(n), newScale); 2386 } 2387 2388 2389 /** 2390 * Returns a {@code BigDecimal} whose value is 2391 * <code>(this<sup>n</sup>)</code>. The current implementation uses 2392 * the core algorithm defined in ANSI standard X3.274-1996 with 2393 * rounding according to the context settings. In general, the 2394 * returned numerical value is within two ulps of the exact 2395 * numerical value for the chosen precision. Note that future 2396 * releases may use a different algorithm with a decreased 2397 * allowable error bound and increased allowable exponent range. 2398 * 2399 * <p>The X3.274-1996 algorithm is: 2400 * 2401 * <ul> 2402 * <li> An {@code ArithmeticException} exception is thrown if 2403 * <ul> 2404 * <li>{@code abs(n) > 999999999} 2405 * <li>{@code mc.precision == 0} and {@code n < 0} 2406 * <li>{@code mc.precision > 0} and {@code n} has more than 2407 * {@code mc.precision} decimal digits 2408 * </ul> 2409 * 2410 * <li> if {@code n} is zero, {@link #ONE} is returned even if 2411 * {@code this} is zero, otherwise 2412 * <ul> 2413 * <li> if {@code n} is positive, the result is calculated via 2414 * the repeated squaring technique into a single accumulator. 2415 * The individual multiplications with the accumulator use the 2416 * same math context settings as in {@code mc} except for a 2417 * precision increased to {@code mc.precision + elength + 1} 2418 * where {@code elength} is the number of decimal digits in 2419 * {@code n}. 2420 * 2421 * <li> if {@code n} is negative, the result is calculated as if 2422 * {@code n} were positive; this value is then divided into one 2423 * using the working precision specified above. 2424 * 2425 * <li> The final value from either the positive or negative case 2426 * is then rounded to the destination precision. 2427 * </ul> 2428 * </ul> 2429 * 2430 * @param n power to raise this {@code BigDecimal} to. 2431 * @param mc the context to use. 2432 * @return <code>this<sup>n</sup></code> using the ANSI standard X3.274-1996 2433 * algorithm 2434 * @throws ArithmeticException if the result is inexact but the 2435 * rounding mode is {@code UNNECESSARY}, or {@code n} is out 2436 * of range. 2437 * @since 1.5 2438 */ 2439 public BigDecimal pow(int n, MathContext mc) { 2440 if (mc.precision == 0) 2441 return pow(n); 2442 if (n < -999999999 || n > 999999999) 2443 throw new ArithmeticException("Invalid operation"); 2444 if (n == 0) 2445 return ONE; // x**0 == 1 in X3.274 2446 BigDecimal lhs = this; 2447 MathContext workmc = mc; // working settings 2448 int mag = Math.abs(n); // magnitude of n 2449 if (mc.precision > 0) { 2450 int elength = longDigitLength(mag); // length of n in digits 2451 if (elength > mc.precision) // X3.274 rule 2452 throw new ArithmeticException("Invalid operation"); 2453 workmc = new MathContext(mc.precision + elength + 1, 2454 mc.roundingMode); 2455 } 2456 // ready to carry out power calculation... 2457 BigDecimal acc = ONE; // accumulator 2458 boolean seenbit = false; // set once we've seen a 1-bit 2459 for (int i=1;;i++) { // for each bit [top bit ignored] 2460 mag += mag; // shift left 1 bit 2461 if (mag < 0) { // top bit is set 2462 seenbit = true; // OK, we're off 2463 acc = acc.multiply(lhs, workmc); // acc=acc*x 2464 } 2465 if (i == 31) 2466 break; // that was the last bit 2467 if (seenbit) 2468 acc=acc.multiply(acc, workmc); // acc=acc*acc [square] 2469 // else (!seenbit) no point in squaring ONE 2470 } 2471 // if negative n, calculate the reciprocal using working precision 2472 if (n < 0) // [hence mc.precision>0] 2473 acc=ONE.divide(acc, workmc); 2474 // round to final precision and strip zeros 2475 return doRound(acc, mc); 2476 } 2477 2478 /** 2479 * Returns a {@code BigDecimal} whose value is the absolute value 2480 * of this {@code BigDecimal}, and whose scale is 2481 * {@code this.scale()}. 2482 * 2483 * @return {@code abs(this)} 2484 */ 2485 public BigDecimal abs() { 2486 return (signum() < 0 ? negate() : this); 2487 } 2488 2489 /** 2490 * Returns a {@code BigDecimal} whose value is the absolute value 2491 * of this {@code BigDecimal}, with rounding according to the 2492 * context settings. 2493 * 2494 * @param mc the context to use. 2495 * @return {@code abs(this)}, rounded as necessary. 2496 * @throws ArithmeticException if the result is inexact but the 2497 * rounding mode is {@code UNNECESSARY}. 2498 * @since 1.5 2499 */ 2500 public BigDecimal abs(MathContext mc) { 2501 return (signum() < 0 ? negate(mc) : plus(mc)); 2502 } 2503 2504 /** 2505 * Returns a {@code BigDecimal} whose value is {@code (-this)}, 2506 * and whose scale is {@code this.scale()}. 2507 * 2508 * @return {@code -this}. 2509 */ 2510 public BigDecimal negate() { 2511 if (intCompact == INFLATED) { 2512 return new BigDecimal(intVal.negate(), INFLATED, scale, precision); 2513 } else { 2514 return valueOf(-intCompact, scale, precision); 2515 } 2516 } 2517 2518 /** 2519 * Returns a {@code BigDecimal} whose value is {@code (-this)}, 2520 * with rounding according to the context settings. 2521 * 2522 * @param mc the context to use. 2523 * @return {@code -this}, rounded as necessary. 2524 * @throws ArithmeticException if the result is inexact but the 2525 * rounding mode is {@code UNNECESSARY}. 2526 * @since 1.5 2527 */ 2528 public BigDecimal negate(MathContext mc) { 2529 return negate().plus(mc); 2530 } 2531 2532 /** 2533 * Returns a {@code BigDecimal} whose value is {@code (+this)}, and whose 2534 * scale is {@code this.scale()}. 2535 * 2536 * <p>This method, which simply returns this {@code BigDecimal} 2537 * is included for symmetry with the unary minus method {@link 2538 * #negate()}. 2539 * 2540 * @return {@code this}. 2541 * @see #negate() 2542 * @since 1.5 2543 */ 2544 public BigDecimal plus() { 2545 return this; 2546 } 2547 2548 /** 2549 * Returns a {@code BigDecimal} whose value is {@code (+this)}, 2550 * with rounding according to the context settings. 2551 * 2552 * <p>The effect of this method is identical to that of the {@link 2553 * #round(MathContext)} method. 2554 * 2555 * @param mc the context to use. 2556 * @return {@code this}, rounded as necessary. A zero result will 2557 * have a scale of 0. 2558 * @throws ArithmeticException if the result is inexact but the 2559 * rounding mode is {@code UNNECESSARY}. 2560 * @see #round(MathContext) 2561 * @since 1.5 2562 */ 2563 public BigDecimal plus(MathContext mc) { 2564 if (mc.precision == 0) // no rounding please 2565 return this; 2566 return doRound(this, mc); 2567 } 2568 2569 /** 2570 * Returns the signum function of this {@code BigDecimal}. 2571 * 2572 * @return -1, 0, or 1 as the value of this {@code BigDecimal} 2573 * is negative, zero, or positive. 2574 */ 2575 public int signum() { 2576 return (intCompact != INFLATED)? 2577 Long.signum(intCompact): 2578 intVal.signum(); 2579 } 2580 2581 /** 2582 * Returns the <i>scale</i> of this {@code BigDecimal}. If zero 2583 * or positive, the scale is the number of digits to the right of 2584 * the decimal point. If negative, the unscaled value of the 2585 * number is multiplied by ten to the power of the negation of the 2586 * scale. For example, a scale of {@code -3} means the unscaled 2587 * value is multiplied by 1000. 2588 * 2589 * @return the scale of this {@code BigDecimal}. 2590 */ 2591 public int scale() { 2592 return scale; 2593 } 2594 2595 /** 2596 * Returns the <i>precision</i> of this {@code BigDecimal}. (The 2597 * precision is the number of digits in the unscaled value.) 2598 * 2599 * <p>The precision of a zero value is 1. 2600 * 2601 * @return the precision of this {@code BigDecimal}. 2602 * @since 1.5 2603 */ 2604 public int precision() { 2605 int result = precision; 2606 if (result == 0) { 2607 long s = intCompact; 2608 if (s != INFLATED) 2609 result = longDigitLength(s); 2610 else 2611 result = bigDigitLength(intVal); 2612 precision = result; 2613 } 2614 return result; 2615 } 2616 2617 2618 /** 2619 * Returns a {@code BigInteger} whose value is the <i>unscaled 2620 * value</i> of this {@code BigDecimal}. (Computes <code>(this * 2621 * 10<sup>this.scale()</sup>)</code>.) 2622 * 2623 * @return the unscaled value of this {@code BigDecimal}. 2624 * @since 1.2 2625 */ 2626 public BigInteger unscaledValue() { 2627 return this.inflated(); 2628 } 2629 2630 // Rounding Modes 2631 2632 /** 2633 * Rounding mode to round away from zero. Always increments the 2634 * digit prior to a nonzero discarded fraction. Note that this rounding 2635 * mode never decreases the magnitude of the calculated value. 2636 * 2637 * @deprecated Use {@link RoundingMode#UP} instead. 2638 */ 2639 @Deprecated(since="9") 2640 public static final int ROUND_UP = 0; 2641 2642 /** 2643 * Rounding mode to round towards zero. Never increments the digit 2644 * prior to a discarded fraction (i.e., truncates). Note that this 2645 * rounding mode never increases the magnitude of the calculated value. 2646 * 2647 * @deprecated Use {@link RoundingMode#DOWN} instead. 2648 */ 2649 @Deprecated(since="9") 2650 public static final int ROUND_DOWN = 1; 2651 2652 /** 2653 * Rounding mode to round towards positive infinity. If the 2654 * {@code BigDecimal} is positive, behaves as for 2655 * {@code ROUND_UP}; if negative, behaves as for 2656 * {@code ROUND_DOWN}. Note that this rounding mode never 2657 * decreases the calculated value. 2658 * 2659 * @deprecated Use {@link RoundingMode#CEILING} instead. 2660 */ 2661 @Deprecated(since="9") 2662 public static final int ROUND_CEILING = 2; 2663 2664 /** 2665 * Rounding mode to round towards negative infinity. If the 2666 * {@code BigDecimal} is positive, behave as for 2667 * {@code ROUND_DOWN}; if negative, behave as for 2668 * {@code ROUND_UP}. Note that this rounding mode never 2669 * increases the calculated value. 2670 * 2671 * @deprecated Use {@link RoundingMode#FLOOR} instead. 2672 */ 2673 @Deprecated(since="9") 2674 public static final int ROUND_FLOOR = 3; 2675 2676 /** 2677 * Rounding mode to round towards {@literal "nearest neighbor"} 2678 * unless both neighbors are equidistant, in which case round up. 2679 * Behaves as for {@code ROUND_UP} if the discarded fraction is 2680 * ≥ 0.5; otherwise, behaves as for {@code ROUND_DOWN}. Note 2681 * that this is the rounding mode that most of us were taught in 2682 * grade school. 2683 * 2684 * @deprecated Use {@link RoundingMode#HALF_UP} instead. 2685 */ 2686 @Deprecated(since="9") 2687 public static final int ROUND_HALF_UP = 4; 2688 2689 /** 2690 * Rounding mode to round towards {@literal "nearest neighbor"} 2691 * unless both neighbors are equidistant, in which case round 2692 * down. Behaves as for {@code ROUND_UP} if the discarded 2693 * fraction is {@literal >} 0.5; otherwise, behaves as for 2694 * {@code ROUND_DOWN}. 2695 * 2696 * @deprecated Use {@link RoundingMode#HALF_DOWN} instead. 2697 */ 2698 @Deprecated(since="9") 2699 public static final int ROUND_HALF_DOWN = 5; 2700 2701 /** 2702 * Rounding mode to round towards the {@literal "nearest neighbor"} 2703 * unless both neighbors are equidistant, in which case, round 2704 * towards the even neighbor. Behaves as for 2705 * {@code ROUND_HALF_UP} if the digit to the left of the 2706 * discarded fraction is odd; behaves as for 2707 * {@code ROUND_HALF_DOWN} if it's even. Note that this is the 2708 * rounding mode that minimizes cumulative error when applied 2709 * repeatedly over a sequence of calculations. 2710 * 2711 * @deprecated Use {@link RoundingMode#HALF_EVEN} instead. 2712 */ 2713 @Deprecated(since="9") 2714 public static final int ROUND_HALF_EVEN = 6; 2715 2716 /** 2717 * Rounding mode to assert that the requested operation has an exact 2718 * result, hence no rounding is necessary. If this rounding mode is 2719 * specified on an operation that yields an inexact result, an 2720 * {@code ArithmeticException} is thrown. 2721 * 2722 * @deprecated Use {@link RoundingMode#UNNECESSARY} instead. 2723 */ 2724 @Deprecated(since="9") 2725 public static final int ROUND_UNNECESSARY = 7; 2726 2727 2728 // Scaling/Rounding Operations 2729 2730 /** 2731 * Returns a {@code BigDecimal} rounded according to the 2732 * {@code MathContext} settings. If the precision setting is 0 then 2733 * no rounding takes place. 2734 * 2735 * <p>The effect of this method is identical to that of the 2736 * {@link #plus(MathContext)} method. 2737 * 2738 * @param mc the context to use. 2739 * @return a {@code BigDecimal} rounded according to the 2740 * {@code MathContext} settings. 2741 * @throws ArithmeticException if the rounding mode is 2742 * {@code UNNECESSARY} and the 2743 * {@code BigDecimal} operation would require rounding. 2744 * @see #plus(MathContext) 2745 * @since 1.5 2746 */ 2747 public BigDecimal round(MathContext mc) { 2748 return plus(mc); 2749 } 2750 2751 /** 2752 * Returns a {@code BigDecimal} whose scale is the specified 2753 * value, and whose unscaled value is determined by multiplying or 2754 * dividing this {@code BigDecimal}'s unscaled value by the 2755 * appropriate power of ten to maintain its overall value. If the 2756 * scale is reduced by the operation, the unscaled value must be 2757 * divided (rather than multiplied), and the value may be changed; 2758 * in this case, the specified rounding mode is applied to the 2759 * division. 2760 * 2761 * @apiNote Since BigDecimal objects are immutable, calls of 2762 * this method do <em>not</em> result in the original object being 2763 * modified, contrary to the usual convention of having methods 2764 * named <code>set<i>X</i></code> mutate field <i>{@code X}</i>. 2765 * Instead, {@code setScale} returns an object with the proper 2766 * scale; the returned object may or may not be newly allocated. 2767 * 2768 * @param newScale scale of the {@code BigDecimal} value to be returned. 2769 * @param roundingMode The rounding mode to apply. 2770 * @return a {@code BigDecimal} whose scale is the specified value, 2771 * and whose unscaled value is determined by multiplying or 2772 * dividing this {@code BigDecimal}'s unscaled value by the 2773 * appropriate power of ten to maintain its overall value. 2774 * @throws ArithmeticException if {@code roundingMode==UNNECESSARY} 2775 * and the specified scaling operation would require 2776 * rounding. 2777 * @see RoundingMode 2778 * @since 1.5 2779 */ 2780 public BigDecimal setScale(int newScale, RoundingMode roundingMode) { 2781 return setScale(newScale, roundingMode.oldMode); 2782 } 2783 2784 /** 2785 * Returns a {@code BigDecimal} whose scale is the specified 2786 * value, and whose unscaled value is determined by multiplying or 2787 * dividing this {@code BigDecimal}'s unscaled value by the 2788 * appropriate power of ten to maintain its overall value. If the 2789 * scale is reduced by the operation, the unscaled value must be 2790 * divided (rather than multiplied), and the value may be changed; 2791 * in this case, the specified rounding mode is applied to the 2792 * division. 2793 * 2794 * @apiNote Since BigDecimal objects are immutable, calls of 2795 * this method do <em>not</em> result in the original object being 2796 * modified, contrary to the usual convention of having methods 2797 * named <code>set<i>X</i></code> mutate field <i>{@code X}</i>. 2798 * Instead, {@code setScale} returns an object with the proper 2799 * scale; the returned object may or may not be newly allocated. 2800 * 2801 * @deprecated The method {@link #setScale(int, RoundingMode)} should 2802 * be used in preference to this legacy method. 2803 * 2804 * @param newScale scale of the {@code BigDecimal} value to be returned. 2805 * @param roundingMode The rounding mode to apply. 2806 * @return a {@code BigDecimal} whose scale is the specified value, 2807 * and whose unscaled value is determined by multiplying or 2808 * dividing this {@code BigDecimal}'s unscaled value by the 2809 * appropriate power of ten to maintain its overall value. 2810 * @throws ArithmeticException if {@code roundingMode==ROUND_UNNECESSARY} 2811 * and the specified scaling operation would require 2812 * rounding. 2813 * @throws IllegalArgumentException if {@code roundingMode} does not 2814 * represent a valid rounding mode. 2815 * @see #ROUND_UP 2816 * @see #ROUND_DOWN 2817 * @see #ROUND_CEILING 2818 * @see #ROUND_FLOOR 2819 * @see #ROUND_HALF_UP 2820 * @see #ROUND_HALF_DOWN 2821 * @see #ROUND_HALF_EVEN 2822 * @see #ROUND_UNNECESSARY 2823 */ 2824 @Deprecated(since="9") 2825 public BigDecimal setScale(int newScale, int roundingMode) { 2826 if (roundingMode < ROUND_UP || roundingMode > ROUND_UNNECESSARY) 2827 throw new IllegalArgumentException("Invalid rounding mode"); 2828 2829 int oldScale = this.scale; 2830 if (newScale == oldScale) // easy case 2831 return this; 2832 if (this.signum() == 0) // zero can have any scale 2833 return zeroValueOf(newScale); 2834 if(this.intCompact!=INFLATED) { 2835 long rs = this.intCompact; 2836 if (newScale > oldScale) { 2837 int raise = checkScale((long) newScale - oldScale); 2838 if ((rs = longMultiplyPowerTen(rs, raise)) != INFLATED) { 2839 return valueOf(rs,newScale); 2840 } 2841 BigInteger rb = bigMultiplyPowerTen(raise); 2842 return new BigDecimal(rb, INFLATED, newScale, (precision > 0) ? precision + raise : 0); 2843 } else { 2844 // newScale < oldScale -- drop some digits 2845 // Can't predict the precision due to the effect of rounding. 2846 int drop = checkScale((long) oldScale - newScale); 2847 if (drop < LONG_TEN_POWERS_TABLE.length) { 2848 return divideAndRound(rs, LONG_TEN_POWERS_TABLE[drop], newScale, roundingMode, newScale); 2849 } else { 2850 return divideAndRound(this.inflated(), bigTenToThe(drop), newScale, roundingMode, newScale); 2851 } 2852 } 2853 } else { 2854 if (newScale > oldScale) { 2855 int raise = checkScale((long) newScale - oldScale); 2856 BigInteger rb = bigMultiplyPowerTen(this.intVal,raise); 2857 return new BigDecimal(rb, INFLATED, newScale, (precision > 0) ? precision + raise : 0); 2858 } else { 2859 // newScale < oldScale -- drop some digits 2860 // Can't predict the precision due to the effect of rounding. 2861 int drop = checkScale((long) oldScale - newScale); 2862 if (drop < LONG_TEN_POWERS_TABLE.length) 2863 return divideAndRound(this.intVal, LONG_TEN_POWERS_TABLE[drop], newScale, roundingMode, 2864 newScale); 2865 else 2866 return divideAndRound(this.intVal, bigTenToThe(drop), newScale, roundingMode, newScale); 2867 } 2868 } 2869 } 2870 2871 /** 2872 * Returns a {@code BigDecimal} whose scale is the specified 2873 * value, and whose value is numerically equal to this 2874 * {@code BigDecimal}'s. Throws an {@code ArithmeticException} 2875 * if this is not possible. 2876 * 2877 * <p>This call is typically used to increase the scale, in which 2878 * case it is guaranteed that there exists a {@code BigDecimal} 2879 * of the specified scale and the correct value. The call can 2880 * also be used to reduce the scale if the caller knows that the 2881 * {@code BigDecimal} has sufficiently many zeros at the end of 2882 * its fractional part (i.e., factors of ten in its integer value) 2883 * to allow for the rescaling without changing its value. 2884 * 2885 * <p>This method returns the same result as the two-argument 2886 * versions of {@code setScale}, but saves the caller the trouble 2887 * of specifying a rounding mode in cases where it is irrelevant. 2888 * 2889 * @apiNote Since {@code BigDecimal} objects are immutable, 2890 * calls of this method do <em>not</em> result in the original 2891 * object being modified, contrary to the usual convention of 2892 * having methods named <code>set<i>X</i></code> mutate field 2893 * <i>{@code X}</i>. Instead, {@code setScale} returns an 2894 * object with the proper scale; the returned object may or may 2895 * not be newly allocated. 2896 * 2897 * @param newScale scale of the {@code BigDecimal} value to be returned. 2898 * @return a {@code BigDecimal} whose scale is the specified value, and 2899 * whose unscaled value is determined by multiplying or dividing 2900 * this {@code BigDecimal}'s unscaled value by the appropriate 2901 * power of ten to maintain its overall value. 2902 * @throws ArithmeticException if the specified scaling operation would 2903 * require rounding. 2904 * @see #setScale(int, int) 2905 * @see #setScale(int, RoundingMode) 2906 */ 2907 public BigDecimal setScale(int newScale) { 2908 return setScale(newScale, ROUND_UNNECESSARY); 2909 } 2910 2911 // Decimal Point Motion Operations 2912 2913 /** 2914 * Returns a {@code BigDecimal} which is equivalent to this one 2915 * with the decimal point moved {@code n} places to the left. If 2916 * {@code n} is non-negative, the call merely adds {@code n} to 2917 * the scale. If {@code n} is negative, the call is equivalent 2918 * to {@code movePointRight(-n)}. The {@code BigDecimal} 2919 * returned by this call has value <code>(this × 2920 * 10<sup>-n</sup>)</code> and scale {@code max(this.scale()+n, 2921 * 0)}. 2922 * 2923 * @param n number of places to move the decimal point to the left. 2924 * @return a {@code BigDecimal} which is equivalent to this one with the 2925 * decimal point moved {@code n} places to the left. 2926 * @throws ArithmeticException if scale overflows. 2927 */ 2928 public BigDecimal movePointLeft(int n) { 2929 if (n == 0) return this; 2930 2931 // Cannot use movePointRight(-n) in case of n==Integer.MIN_VALUE 2932 int newScale = checkScale((long)scale + n); 2933 BigDecimal num = new BigDecimal(intVal, intCompact, newScale, 0); 2934 return num.scale < 0 ? num.setScale(0, ROUND_UNNECESSARY) : num; 2935 } 2936 2937 /** 2938 * Returns a {@code BigDecimal} which is equivalent to this one 2939 * with the decimal point moved {@code n} places to the right. 2940 * If {@code n} is non-negative, the call merely subtracts 2941 * {@code n} from the scale. If {@code n} is negative, the call 2942 * is equivalent to {@code movePointLeft(-n)}. The 2943 * {@code BigDecimal} returned by this call has value <code>(this 2944 * × 10<sup>n</sup>)</code> and scale {@code max(this.scale()-n, 2945 * 0)}. 2946 * 2947 * @param n number of places to move the decimal point to the right. 2948 * @return a {@code BigDecimal} which is equivalent to this one 2949 * with the decimal point moved {@code n} places to the right. 2950 * @throws ArithmeticException if scale overflows. 2951 */ 2952 public BigDecimal movePointRight(int n) { 2953 if (n == 0) return this; 2954 2955 // Cannot use movePointLeft(-n) in case of n==Integer.MIN_VALUE 2956 int newScale = checkScale((long)scale - n); 2957 BigDecimal num = new BigDecimal(intVal, intCompact, newScale, 0); 2958 return num.scale < 0 ? num.setScale(0, ROUND_UNNECESSARY) : num; 2959 } 2960 2961 /** 2962 * Returns a BigDecimal whose numerical value is equal to 2963 * ({@code this} * 10<sup>n</sup>). The scale of 2964 * the result is {@code (this.scale() - n)}. 2965 * 2966 * @param n the exponent power of ten to scale by 2967 * @return a BigDecimal whose numerical value is equal to 2968 * ({@code this} * 10<sup>n</sup>) 2969 * @throws ArithmeticException if the scale would be 2970 * outside the range of a 32-bit integer. 2971 * 2972 * @since 1.5 2973 */ 2974 public BigDecimal scaleByPowerOfTen(int n) { 2975 return new BigDecimal(intVal, intCompact, 2976 checkScale((long)scale - n), precision); 2977 } 2978 2979 /** 2980 * Returns a {@code BigDecimal} which is numerically equal to 2981 * this one but with any trailing zeros removed from the 2982 * representation. For example, stripping the trailing zeros from 2983 * the {@code BigDecimal} value {@code 600.0}, which has 2984 * [{@code BigInteger}, {@code scale}] components equals to 2985 * [6000, 1], yields {@code 6E2} with [{@code BigInteger}, 2986 * {@code scale}] components equals to [6, -2]. If 2987 * this BigDecimal is numerically equal to zero, then 2988 * {@code BigDecimal.ZERO} is returned. 2989 * 2990 * @return a numerically equal {@code BigDecimal} with any 2991 * trailing zeros removed. 2992 * @since 1.5 2993 */ 2994 public BigDecimal stripTrailingZeros() { 2995 if (intCompact == 0 || (intVal != null && intVal.signum() == 0)) { 2996 return BigDecimal.ZERO; 2997 } else if (intCompact != INFLATED) { 2998 return createAndStripZerosToMatchScale(intCompact, scale, Long.MIN_VALUE); 2999 } else { 3000 return createAndStripZerosToMatchScale(intVal, scale, Long.MIN_VALUE); 3001 } 3002 } 3003 3004 // Comparison Operations 3005 3006 /** 3007 * Compares this {@code BigDecimal} with the specified 3008 * {@code BigDecimal}. Two {@code BigDecimal} objects that are 3009 * equal in value but have a different scale (like 2.0 and 2.00) 3010 * are considered equal by this method. This method is provided 3011 * in preference to individual methods for each of the six boolean 3012 * comparison operators ({@literal <}, ==, 3013 * {@literal >}, {@literal >=}, !=, {@literal <=}). The 3014 * suggested idiom for performing these comparisons is: 3015 * {@code (x.compareTo(y)} <<i>op</i>> {@code 0)}, where 3016 * <<i>op</i>> is one of the six comparison operators. 3017 * 3018 * @param val {@code BigDecimal} to which this {@code BigDecimal} is 3019 * to be compared. 3020 * @return -1, 0, or 1 as this {@code BigDecimal} is numerically 3021 * less than, equal to, or greater than {@code val}. 3022 */ 3023 @Override 3024 public int compareTo(BigDecimal val) { 3025 // Quick path for equal scale and non-inflated case. 3026 if (scale == val.scale) { 3027 long xs = intCompact; 3028 long ys = val.intCompact; 3029 if (xs != INFLATED && ys != INFLATED) 3030 return xs != ys ? ((xs > ys) ? 1 : -1) : 0; 3031 } 3032 int xsign = this.signum(); 3033 int ysign = val.signum(); 3034 if (xsign != ysign) 3035 return (xsign > ysign) ? 1 : -1; 3036 if (xsign == 0) 3037 return 0; 3038 int cmp = compareMagnitude(val); 3039 return (xsign > 0) ? cmp : -cmp; 3040 } 3041 3042 /** 3043 * Version of compareTo that ignores sign. 3044 */ 3045 private int compareMagnitude(BigDecimal val) { 3046 // Match scales, avoid unnecessary inflation 3047 long ys = val.intCompact; 3048 long xs = this.intCompact; 3049 if (xs == 0) 3050 return (ys == 0) ? 0 : -1; 3051 if (ys == 0) 3052 return 1; 3053 3054 long sdiff = (long)this.scale - val.scale; 3055 if (sdiff != 0) { 3056 // Avoid matching scales if the (adjusted) exponents differ 3057 long xae = (long)this.precision() - this.scale; // [-1] 3058 long yae = (long)val.precision() - val.scale; // [-1] 3059 if (xae < yae) 3060 return -1; 3061 if (xae > yae) 3062 return 1; 3063 if (sdiff < 0) { 3064 // The cases sdiff <= Integer.MIN_VALUE intentionally fall through. 3065 if ( sdiff > Integer.MIN_VALUE && 3066 (xs == INFLATED || 3067 (xs = longMultiplyPowerTen(xs, (int)-sdiff)) == INFLATED) && 3068 ys == INFLATED) { 3069 BigInteger rb = bigMultiplyPowerTen((int)-sdiff); 3070 return rb.compareMagnitude(val.intVal); 3071 } 3072 } else { // sdiff > 0 3073 // The cases sdiff > Integer.MAX_VALUE intentionally fall through. 3074 if ( sdiff <= Integer.MAX_VALUE && 3075 (ys == INFLATED || 3076 (ys = longMultiplyPowerTen(ys, (int)sdiff)) == INFLATED) && 3077 xs == INFLATED) { 3078 BigInteger rb = val.bigMultiplyPowerTen((int)sdiff); 3079 return this.intVal.compareMagnitude(rb); 3080 } 3081 } 3082 } 3083 if (xs != INFLATED) 3084 return (ys != INFLATED) ? longCompareMagnitude(xs, ys) : -1; 3085 else if (ys != INFLATED) 3086 return 1; 3087 else 3088 return this.intVal.compareMagnitude(val.intVal); 3089 } 3090 3091 /** 3092 * Compares this {@code BigDecimal} with the specified 3093 * {@code Object} for equality. Unlike {@link 3094 * #compareTo(BigDecimal) compareTo}, this method considers two 3095 * {@code BigDecimal} objects equal only if they are equal in 3096 * value and scale (thus 2.0 is not equal to 2.00 when compared by 3097 * this method). 3098 * 3099 * @param x {@code Object} to which this {@code BigDecimal} is 3100 * to be compared. 3101 * @return {@code true} if and only if the specified {@code Object} is a 3102 * {@code BigDecimal} whose value and scale are equal to this 3103 * {@code BigDecimal}'s. 3104 * @see #compareTo(java.math.BigDecimal) 3105 * @see #hashCode 3106 */ 3107 @Override 3108 public boolean equals(Object x) { 3109 if (!(x instanceof BigDecimal)) 3110 return false; 3111 BigDecimal xDec = (BigDecimal) x; 3112 if (x == this) 3113 return true; 3114 if (scale != xDec.scale) 3115 return false; 3116 long s = this.intCompact; 3117 long xs = xDec.intCompact; 3118 if (s != INFLATED) { 3119 if (xs == INFLATED) 3120 xs = compactValFor(xDec.intVal); 3121 return xs == s; 3122 } else if (xs != INFLATED) 3123 return xs == compactValFor(this.intVal); 3124 3125 return this.inflated().equals(xDec.inflated()); 3126 } 3127 3128 /** 3129 * Returns the minimum of this {@code BigDecimal} and 3130 * {@code val}. 3131 * 3132 * @param val value with which the minimum is to be computed. 3133 * @return the {@code BigDecimal} whose value is the lesser of this 3134 * {@code BigDecimal} and {@code val}. If they are equal, 3135 * as defined by the {@link #compareTo(BigDecimal) compareTo} 3136 * method, {@code this} is returned. 3137 * @see #compareTo(java.math.BigDecimal) 3138 */ 3139 public BigDecimal min(BigDecimal val) { 3140 return (compareTo(val) <= 0 ? this : val); 3141 } 3142 3143 /** 3144 * Returns the maximum of this {@code BigDecimal} and {@code val}. 3145 * 3146 * @param val value with which the maximum is to be computed. 3147 * @return the {@code BigDecimal} whose value is the greater of this 3148 * {@code BigDecimal} and {@code val}. If they are equal, 3149 * as defined by the {@link #compareTo(BigDecimal) compareTo} 3150 * method, {@code this} is returned. 3151 * @see #compareTo(java.math.BigDecimal) 3152 */ 3153 public BigDecimal max(BigDecimal val) { 3154 return (compareTo(val) >= 0 ? this : val); 3155 } 3156 3157 // Hash Function 3158 3159 /** 3160 * Returns the hash code for this {@code BigDecimal}. Note that 3161 * two {@code BigDecimal} objects that are numerically equal but 3162 * differ in scale (like 2.0 and 2.00) will generally <em>not</em> 3163 * have the same hash code. 3164 * 3165 * @return hash code for this {@code BigDecimal}. 3166 * @see #equals(Object) 3167 */ 3168 @Override 3169 public int hashCode() { 3170 if (intCompact != INFLATED) { 3171 long val2 = (intCompact < 0)? -intCompact : intCompact; 3172 int temp = (int)( ((int)(val2 >>> 32)) * 31 + 3173 (val2 & LONG_MASK)); 3174 return 31*((intCompact < 0) ?-temp:temp) + scale; 3175 } else 3176 return 31*intVal.hashCode() + scale; 3177 } 3178 3179 // Format Converters 3180 3181 /** 3182 * Returns the string representation of this {@code BigDecimal}, 3183 * using scientific notation if an exponent is needed. 3184 * 3185 * <p>A standard canonical string form of the {@code BigDecimal} 3186 * is created as though by the following steps: first, the 3187 * absolute value of the unscaled value of the {@code BigDecimal} 3188 * is converted to a string in base ten using the characters 3189 * {@code '0'} through {@code '9'} with no leading zeros (except 3190 * if its value is zero, in which case a single {@code '0'} 3191 * character is used). 3192 * 3193 * <p>Next, an <i>adjusted exponent</i> is calculated; this is the 3194 * negated scale, plus the number of characters in the converted 3195 * unscaled value, less one. That is, 3196 * {@code -scale+(ulength-1)}, where {@code ulength} is the 3197 * length of the absolute value of the unscaled value in decimal 3198 * digits (its <i>precision</i>). 3199 * 3200 * <p>If the scale is greater than or equal to zero and the 3201 * adjusted exponent is greater than or equal to {@code -6}, the 3202 * number will be converted to a character form without using 3203 * exponential notation. In this case, if the scale is zero then 3204 * no decimal point is added and if the scale is positive a 3205 * decimal point will be inserted with the scale specifying the 3206 * number of characters to the right of the decimal point. 3207 * {@code '0'} characters are added to the left of the converted 3208 * unscaled value as necessary. If no character precedes the 3209 * decimal point after this insertion then a conventional 3210 * {@code '0'} character is prefixed. 3211 * 3212 * <p>Otherwise (that is, if the scale is negative, or the 3213 * adjusted exponent is less than {@code -6}), the number will be 3214 * converted to a character form using exponential notation. In 3215 * this case, if the converted {@code BigInteger} has more than 3216 * one digit a decimal point is inserted after the first digit. 3217 * An exponent in character form is then suffixed to the converted 3218 * unscaled value (perhaps with inserted decimal point); this 3219 * comprises the letter {@code 'E'} followed immediately by the 3220 * adjusted exponent converted to a character form. The latter is 3221 * in base ten, using the characters {@code '0'} through 3222 * {@code '9'} with no leading zeros, and is always prefixed by a 3223 * sign character {@code '-'} (<code>'\u002D'</code>) if the 3224 * adjusted exponent is negative, {@code '+'} 3225 * (<code>'\u002B'</code>) otherwise). 3226 * 3227 * <p>Finally, the entire string is prefixed by a minus sign 3228 * character {@code '-'} (<code>'\u002D'</code>) if the unscaled 3229 * value is less than zero. No sign character is prefixed if the 3230 * unscaled value is zero or positive. 3231 * 3232 * <p><b>Examples:</b> 3233 * <p>For each representation [<i>unscaled value</i>, <i>scale</i>] 3234 * on the left, the resulting string is shown on the right. 3235 * <pre> 3236 * [123,0] "123" 3237 * [-123,0] "-123" 3238 * [123,-1] "1.23E+3" 3239 * [123,-3] "1.23E+5" 3240 * [123,1] "12.3" 3241 * [123,5] "0.00123" 3242 * [123,10] "1.23E-8" 3243 * [-123,12] "-1.23E-10" 3244 * </pre> 3245 * 3246 * <b>Notes:</b> 3247 * <ol> 3248 * 3249 * <li>There is a one-to-one mapping between the distinguishable 3250 * {@code BigDecimal} values and the result of this conversion. 3251 * That is, every distinguishable {@code BigDecimal} value 3252 * (unscaled value and scale) has a unique string representation 3253 * as a result of using {@code toString}. If that string 3254 * representation is converted back to a {@code BigDecimal} using 3255 * the {@link #BigDecimal(String)} constructor, then the original 3256 * value will be recovered. 3257 * 3258 * <li>The string produced for a given number is always the same; 3259 * it is not affected by locale. This means that it can be used 3260 * as a canonical string representation for exchanging decimal 3261 * data, or as a key for a Hashtable, etc. Locale-sensitive 3262 * number formatting and parsing is handled by the {@link 3263 * java.text.NumberFormat} class and its subclasses. 3264 * 3265 * <li>The {@link #toEngineeringString} method may be used for 3266 * presenting numbers with exponents in engineering notation, and the 3267 * {@link #setScale(int,RoundingMode) setScale} method may be used for 3268 * rounding a {@code BigDecimal} so it has a known number of digits after 3269 * the decimal point. 3270 * 3271 * <li>The digit-to-character mapping provided by 3272 * {@code Character.forDigit} is used. 3273 * 3274 * </ol> 3275 * 3276 * @return string representation of this {@code BigDecimal}. 3277 * @see Character#forDigit 3278 * @see #BigDecimal(java.lang.String) 3279 */ 3280 @Override 3281 public String toString() { 3282 String sc = stringCache; 3283 if (sc == null) { 3284 stringCache = sc = layoutChars(true); 3285 } 3286 return sc; 3287 } 3288 3289 /** 3290 * Returns a string representation of this {@code BigDecimal}, 3291 * using engineering notation if an exponent is needed. 3292 * 3293 * <p>Returns a string that represents the {@code BigDecimal} as 3294 * described in the {@link #toString()} method, except that if 3295 * exponential notation is used, the power of ten is adjusted to 3296 * be a multiple of three (engineering notation) such that the 3297 * integer part of nonzero values will be in the range 1 through 3298 * 999. If exponential notation is used for zero values, a 3299 * decimal point and one or two fractional zero digits are used so 3300 * that the scale of the zero value is preserved. Note that 3301 * unlike the output of {@link #toString()}, the output of this 3302 * method is <em>not</em> guaranteed to recover the same [integer, 3303 * scale] pair of this {@code BigDecimal} if the output string is 3304 * converting back to a {@code BigDecimal} using the {@linkplain 3305 * #BigDecimal(String) string constructor}. The result of this method meets 3306 * the weaker constraint of always producing a numerically equal 3307 * result from applying the string constructor to the method's output. 3308 * 3309 * @return string representation of this {@code BigDecimal}, using 3310 * engineering notation if an exponent is needed. 3311 * @since 1.5 3312 */ 3313 public String toEngineeringString() { 3314 return layoutChars(false); 3315 } 3316 3317 /** 3318 * Returns a string representation of this {@code BigDecimal} 3319 * without an exponent field. For values with a positive scale, 3320 * the number of digits to the right of the decimal point is used 3321 * to indicate scale. For values with a zero or negative scale, 3322 * the resulting string is generated as if the value were 3323 * converted to a numerically equal value with zero scale and as 3324 * if all the trailing zeros of the zero scale value were present 3325 * in the result. 3326 * 3327 * The entire string is prefixed by a minus sign character '-' 3328 * (<code>'\u002D'</code>) if the unscaled value is less than 3329 * zero. No sign character is prefixed if the unscaled value is 3330 * zero or positive. 3331 * 3332 * Note that if the result of this method is passed to the 3333 * {@linkplain #BigDecimal(String) string constructor}, only the 3334 * numerical value of this {@code BigDecimal} will necessarily be 3335 * recovered; the representation of the new {@code BigDecimal} 3336 * may have a different scale. In particular, if this 3337 * {@code BigDecimal} has a negative scale, the string resulting 3338 * from this method will have a scale of zero when processed by 3339 * the string constructor. 3340 * 3341 * (This method behaves analogously to the {@code toString} 3342 * method in 1.4 and earlier releases.) 3343 * 3344 * @return a string representation of this {@code BigDecimal} 3345 * without an exponent field. 3346 * @since 1.5 3347 * @see #toString() 3348 * @see #toEngineeringString() 3349 */ 3350 public String toPlainString() { 3351 if(scale==0) { 3352 if(intCompact!=INFLATED) { 3353 return Long.toString(intCompact); 3354 } else { 3355 return intVal.toString(); 3356 } 3357 } 3358 if(this.scale<0) { // No decimal point 3359 if(signum()==0) { 3360 return "0"; 3361 } 3362 int trailingZeros = checkScaleNonZero((-(long)scale)); 3363 StringBuilder buf; 3364 if(intCompact!=INFLATED) { 3365 buf = new StringBuilder(20+trailingZeros); 3366 buf.append(intCompact); 3367 } else { 3368 String str = intVal.toString(); 3369 buf = new StringBuilder(str.length()+trailingZeros); 3370 buf.append(str); 3371 } 3372 for (int i = 0; i < trailingZeros; i++) { 3373 buf.append('0'); 3374 } 3375 return buf.toString(); 3376 } 3377 String str ; 3378 if(intCompact!=INFLATED) { 3379 str = Long.toString(Math.abs(intCompact)); 3380 } else { 3381 str = intVal.abs().toString(); 3382 } 3383 return getValueString(signum(), str, scale); 3384 } 3385 3386 /* Returns a digit.digit string */ 3387 private String getValueString(int signum, String intString, int scale) { 3388 /* Insert decimal point */ 3389 StringBuilder buf; 3390 int insertionPoint = intString.length() - scale; 3391 if (insertionPoint == 0) { /* Point goes right before intVal */ 3392 return (signum<0 ? "-0." : "0.") + intString; 3393 } else if (insertionPoint > 0) { /* Point goes inside intVal */ 3394 buf = new StringBuilder(intString); 3395 buf.insert(insertionPoint, '.'); 3396 if (signum < 0) 3397 buf.insert(0, '-'); 3398 } else { /* We must insert zeros between point and intVal */ 3399 buf = new StringBuilder(3-insertionPoint + intString.length()); 3400 buf.append(signum<0 ? "-0." : "0."); 3401 for (int i=0; i<-insertionPoint; i++) { 3402 buf.append('0'); 3403 } 3404 buf.append(intString); 3405 } 3406 return buf.toString(); 3407 } 3408 3409 /** 3410 * Converts this {@code BigDecimal} to a {@code BigInteger}. 3411 * This conversion is analogous to the 3412 * <i>narrowing primitive conversion</i> from {@code double} to 3413 * {@code long} as defined in 3414 * <cite>The Java™ Language Specification</cite>: 3415 * any fractional part of this 3416 * {@code BigDecimal} will be discarded. Note that this 3417 * conversion can lose information about the precision of the 3418 * {@code BigDecimal} value. 3419 * <p> 3420 * To have an exception thrown if the conversion is inexact (in 3421 * other words if a nonzero fractional part is discarded), use the 3422 * {@link #toBigIntegerExact()} method. 3423 * 3424 * @return this {@code BigDecimal} converted to a {@code BigInteger}. 3425 * @jls 5.1.3 Narrowing Primitive Conversion 3426 */ 3427 public BigInteger toBigInteger() { 3428 // force to an integer, quietly 3429 return this.setScale(0, ROUND_DOWN).inflated(); 3430 } 3431 3432 /** 3433 * Converts this {@code BigDecimal} to a {@code BigInteger}, 3434 * checking for lost information. An exception is thrown if this 3435 * {@code BigDecimal} has a nonzero fractional part. 3436 * 3437 * @return this {@code BigDecimal} converted to a {@code BigInteger}. 3438 * @throws ArithmeticException if {@code this} has a nonzero 3439 * fractional part. 3440 * @since 1.5 3441 */ 3442 public BigInteger toBigIntegerExact() { 3443 // round to an integer, with Exception if decimal part non-0 3444 return this.setScale(0, ROUND_UNNECESSARY).inflated(); 3445 } 3446 3447 /** 3448 * Converts this {@code BigDecimal} to a {@code long}. 3449 * This conversion is analogous to the 3450 * <i>narrowing primitive conversion</i> from {@code double} to 3451 * {@code short} as defined in 3452 * <cite>The Java™ Language Specification</cite>: 3453 * any fractional part of this 3454 * {@code BigDecimal} will be discarded, and if the resulting 3455 * "{@code BigInteger}" is too big to fit in a 3456 * {@code long}, only the low-order 64 bits are returned. 3457 * Note that this conversion can lose information about the 3458 * overall magnitude and precision of this {@code BigDecimal} value as well 3459 * as return a result with the opposite sign. 3460 * 3461 * @return this {@code BigDecimal} converted to a {@code long}. 3462 * @jls 5.1.3 Narrowing Primitive Conversion 3463 */ 3464 @Override 3465 public long longValue(){ 3466 if (intCompact != INFLATED && scale == 0) { 3467 return intCompact; 3468 } else { 3469 // Fastpath zero and small values 3470 if (this.signum() == 0 || fractionOnly() || 3471 // Fastpath very large-scale values that will result 3472 // in a truncated value of zero. If the scale is -64 3473 // or less, there are at least 64 powers of 10 in the 3474 // value of the numerical result. Since 10 = 2*5, in 3475 // that case there would also be 64 powers of 2 in the 3476 // result, meaning all 64 bits of a long will be zero. 3477 scale <= -64) { 3478 return 0; 3479 } else { 3480 return toBigInteger().longValue(); 3481 } 3482 } 3483 } 3484 3485 /** 3486 * Return true if a nonzero BigDecimal has an absolute value less 3487 * than one; i.e. only has fraction digits. 3488 */ 3489 private boolean fractionOnly() { 3490 assert this.signum() != 0; 3491 return (this.precision() - this.scale) <= 0; 3492 } 3493 3494 /** 3495 * Converts this {@code BigDecimal} to a {@code long}, checking 3496 * for lost information. If this {@code BigDecimal} has a 3497 * nonzero fractional part or is out of the possible range for a 3498 * {@code long} result then an {@code ArithmeticException} is 3499 * thrown. 3500 * 3501 * @return this {@code BigDecimal} converted to a {@code long}. 3502 * @throws ArithmeticException if {@code this} has a nonzero 3503 * fractional part, or will not fit in a {@code long}. 3504 * @since 1.5 3505 */ 3506 public long longValueExact() { 3507 if (intCompact != INFLATED && scale == 0) 3508 return intCompact; 3509 3510 // Fastpath zero 3511 if (this.signum() == 0) 3512 return 0; 3513 3514 // Fastpath numbers less than 1.0 (the latter can be very slow 3515 // to round if very small) 3516 if (fractionOnly()) 3517 throw new ArithmeticException("Rounding necessary"); 3518 3519 // If more than 19 digits in integer part it cannot possibly fit 3520 if ((precision() - scale) > 19) // [OK for negative scale too] 3521 throw new java.lang.ArithmeticException("Overflow"); 3522 3523 // round to an integer, with Exception if decimal part non-0 3524 BigDecimal num = this.setScale(0, ROUND_UNNECESSARY); 3525 if (num.precision() >= 19) // need to check carefully 3526 LongOverflow.check(num); 3527 return num.inflated().longValue(); 3528 } 3529 3530 private static class LongOverflow { 3531 /** BigInteger equal to Long.MIN_VALUE. */ 3532 private static final BigInteger LONGMIN = BigInteger.valueOf(Long.MIN_VALUE); 3533 3534 /** BigInteger equal to Long.MAX_VALUE. */ 3535 private static final BigInteger LONGMAX = BigInteger.valueOf(Long.MAX_VALUE); 3536 3537 public static void check(BigDecimal num) { 3538 BigInteger intVal = num.inflated(); 3539 if (intVal.compareTo(LONGMIN) < 0 || 3540 intVal.compareTo(LONGMAX) > 0) 3541 throw new java.lang.ArithmeticException("Overflow"); 3542 } 3543 } 3544 3545 /** 3546 * Converts this {@code BigDecimal} to an {@code int}. 3547 * This conversion is analogous to the 3548 * <i>narrowing primitive conversion</i> from {@code double} to 3549 * {@code short} as defined in 3550 * <cite>The Java™ Language Specification</cite>: 3551 * any fractional part of this 3552 * {@code BigDecimal} will be discarded, and if the resulting 3553 * "{@code BigInteger}" is too big to fit in an 3554 * {@code int}, only the low-order 32 bits are returned. 3555 * Note that this conversion can lose information about the 3556 * overall magnitude and precision of this {@code BigDecimal} 3557 * value as well as return a result with the opposite sign. 3558 * 3559 * @return this {@code BigDecimal} converted to an {@code int}. 3560 * @jls 5.1.3 Narrowing Primitive Conversion 3561 */ 3562 @Override 3563 public int intValue() { 3564 return (intCompact != INFLATED && scale == 0) ? 3565 (int)intCompact : 3566 (int)longValue(); 3567 } 3568 3569 /** 3570 * Converts this {@code BigDecimal} to an {@code int}, checking 3571 * for lost information. If this {@code BigDecimal} has a 3572 * nonzero fractional part or is out of the possible range for an 3573 * {@code int} result then an {@code ArithmeticException} is 3574 * thrown. 3575 * 3576 * @return this {@code BigDecimal} converted to an {@code int}. 3577 * @throws ArithmeticException if {@code this} has a nonzero 3578 * fractional part, or will not fit in an {@code int}. 3579 * @since 1.5 3580 */ 3581 public int intValueExact() { 3582 long num; 3583 num = this.longValueExact(); // will check decimal part 3584 if ((int)num != num) 3585 throw new java.lang.ArithmeticException("Overflow"); 3586 return (int)num; 3587 } 3588 3589 /** 3590 * Converts this {@code BigDecimal} to a {@code short}, checking 3591 * for lost information. If this {@code BigDecimal} has a 3592 * nonzero fractional part or is out of the possible range for a 3593 * {@code short} result then an {@code ArithmeticException} is 3594 * thrown. 3595 * 3596 * @return this {@code BigDecimal} converted to a {@code short}. 3597 * @throws ArithmeticException if {@code this} has a nonzero 3598 * fractional part, or will not fit in a {@code short}. 3599 * @since 1.5 3600 */ 3601 public short shortValueExact() { 3602 long num; 3603 num = this.longValueExact(); // will check decimal part 3604 if ((short)num != num) 3605 throw new java.lang.ArithmeticException("Overflow"); 3606 return (short)num; 3607 } 3608 3609 /** 3610 * Converts this {@code BigDecimal} to a {@code byte}, checking 3611 * for lost information. If this {@code BigDecimal} has a 3612 * nonzero fractional part or is out of the possible range for a 3613 * {@code byte} result then an {@code ArithmeticException} is 3614 * thrown. 3615 * 3616 * @return this {@code BigDecimal} converted to a {@code byte}. 3617 * @throws ArithmeticException if {@code this} has a nonzero 3618 * fractional part, or will not fit in a {@code byte}. 3619 * @since 1.5 3620 */ 3621 public byte byteValueExact() { 3622 long num; 3623 num = this.longValueExact(); // will check decimal part 3624 if ((byte)num != num) 3625 throw new java.lang.ArithmeticException("Overflow"); 3626 return (byte)num; 3627 } 3628 3629 /** 3630 * Converts this {@code BigDecimal} to a {@code float}. 3631 * This conversion is similar to the 3632 * <i>narrowing primitive conversion</i> from {@code double} to 3633 * {@code float} as defined in 3634 * <cite>The Java™ Language Specification</cite>: 3635 * if this {@code BigDecimal} has too great a 3636 * magnitude to represent as a {@code float}, it will be 3637 * converted to {@link Float#NEGATIVE_INFINITY} or {@link 3638 * Float#POSITIVE_INFINITY} as appropriate. Note that even when 3639 * the return value is finite, this conversion can lose 3640 * information about the precision of the {@code BigDecimal} 3641 * value. 3642 * 3643 * @return this {@code BigDecimal} converted to a {@code float}. 3644 * @jls 5.1.3 Narrowing Primitive Conversion 3645 */ 3646 @Override 3647 public float floatValue(){ 3648 if(intCompact != INFLATED) { 3649 if (scale == 0) { 3650 return (float)intCompact; 3651 } else { 3652 /* 3653 * If both intCompact and the scale can be exactly 3654 * represented as float values, perform a single float 3655 * multiply or divide to compute the (properly 3656 * rounded) result. 3657 */ 3658 if (Math.abs(intCompact) < 1L<<22 ) { 3659 // Don't have too guard against 3660 // Math.abs(MIN_VALUE) because of outer check 3661 // against INFLATED. 3662 if (scale > 0 && scale < FLOAT_10_POW.length) { 3663 return (float)intCompact / FLOAT_10_POW[scale]; 3664 } else if (scale < 0 && scale > -FLOAT_10_POW.length) { 3665 return (float)intCompact * FLOAT_10_POW[-scale]; 3666 } 3667 } 3668 } 3669 } 3670 // Somewhat inefficient, but guaranteed to work. 3671 return Float.parseFloat(this.toString()); 3672 } 3673 3674 /** 3675 * Converts this {@code BigDecimal} to a {@code double}. 3676 * This conversion is similar to the 3677 * <i>narrowing primitive conversion</i> from {@code double} to 3678 * {@code float} as defined in 3679 * <cite>The Java™ Language Specification</cite>: 3680 * if this {@code BigDecimal} has too great a 3681 * magnitude represent as a {@code double}, it will be 3682 * converted to {@link Double#NEGATIVE_INFINITY} or {@link 3683 * Double#POSITIVE_INFINITY} as appropriate. Note that even when 3684 * the return value is finite, this conversion can lose 3685 * information about the precision of the {@code BigDecimal} 3686 * value. 3687 * 3688 * @return this {@code BigDecimal} converted to a {@code double}. 3689 * @jls 5.1.3 Narrowing Primitive Conversion 3690 */ 3691 @Override 3692 public double doubleValue(){ 3693 if(intCompact != INFLATED) { 3694 if (scale == 0) { 3695 return (double)intCompact; 3696 } else { 3697 /* 3698 * If both intCompact and the scale can be exactly 3699 * represented as double values, perform a single 3700 * double multiply or divide to compute the (properly 3701 * rounded) result. 3702 */ 3703 if (Math.abs(intCompact) < 1L<<52 ) { 3704 // Don't have too guard against 3705 // Math.abs(MIN_VALUE) because of outer check 3706 // against INFLATED. 3707 if (scale > 0 && scale < DOUBLE_10_POW.length) { 3708 return (double)intCompact / DOUBLE_10_POW[scale]; 3709 } else if (scale < 0 && scale > -DOUBLE_10_POW.length) { 3710 return (double)intCompact * DOUBLE_10_POW[-scale]; 3711 } 3712 } 3713 } 3714 } 3715 // Somewhat inefficient, but guaranteed to work. 3716 return Double.parseDouble(this.toString()); 3717 } 3718 3719 /** 3720 * Powers of 10 which can be represented exactly in {@code 3721 * double}. 3722 */ 3723 private static final double DOUBLE_10_POW[] = { 3724 1.0e0, 1.0e1, 1.0e2, 1.0e3, 1.0e4, 1.0e5, 3725 1.0e6, 1.0e7, 1.0e8, 1.0e9, 1.0e10, 1.0e11, 3726 1.0e12, 1.0e13, 1.0e14, 1.0e15, 1.0e16, 1.0e17, 3727 1.0e18, 1.0e19, 1.0e20, 1.0e21, 1.0e22 3728 }; 3729 3730 /** 3731 * Powers of 10 which can be represented exactly in {@code 3732 * float}. 3733 */ 3734 private static final float FLOAT_10_POW[] = { 3735 1.0e0f, 1.0e1f, 1.0e2f, 1.0e3f, 1.0e4f, 1.0e5f, 3736 1.0e6f, 1.0e7f, 1.0e8f, 1.0e9f, 1.0e10f 3737 }; 3738 3739 /** 3740 * Returns the size of an ulp, a unit in the last place, of this 3741 * {@code BigDecimal}. An ulp of a nonzero {@code BigDecimal} 3742 * value is the positive distance between this value and the 3743 * {@code BigDecimal} value next larger in magnitude with the 3744 * same number of digits. An ulp of a zero value is numerically 3745 * equal to 1 with the scale of {@code this}. The result is 3746 * stored with the same scale as {@code this} so the result 3747 * for zero and nonzero values is equal to {@code [1, 3748 * this.scale()]}. 3749 * 3750 * @return the size of an ulp of {@code this} 3751 * @since 1.5 3752 */ 3753 public BigDecimal ulp() { 3754 return BigDecimal.valueOf(1, this.scale(), 1); 3755 } 3756 3757 // Private class to build a string representation for BigDecimal object. 3758 // "StringBuilderHelper" is constructed as a thread local variable so it is 3759 // thread safe. The StringBuilder field acts as a buffer to hold the temporary 3760 // representation of BigDecimal. The cmpCharArray holds all the characters for 3761 // the compact representation of BigDecimal (except for '-' sign' if it is 3762 // negative) if its intCompact field is not INFLATED. It is shared by all 3763 // calls to toString() and its variants in that particular thread. 3764 static class StringBuilderHelper { 3765 final StringBuilder sb; // Placeholder for BigDecimal string 3766 final char[] cmpCharArray; // character array to place the intCompact 3767 3768 StringBuilderHelper() { 3769 sb = new StringBuilder(); 3770 // All non negative longs can be made to fit into 19 character array. 3771 cmpCharArray = new char[19]; 3772 } 3773 3774 // Accessors. 3775 StringBuilder getStringBuilder() { 3776 sb.setLength(0); 3777 return sb; 3778 } 3779 3780 char[] getCompactCharArray() { 3781 return cmpCharArray; 3782 } 3783 3784 /** 3785 * Places characters representing the intCompact in {@code long} into 3786 * cmpCharArray and returns the offset to the array where the 3787 * representation starts. 3788 * 3789 * @param intCompact the number to put into the cmpCharArray. 3790 * @return offset to the array where the representation starts. 3791 * Note: intCompact must be greater or equal to zero. 3792 */ 3793 int putIntCompact(long intCompact) { 3794 assert intCompact >= 0; 3795 3796 long q; 3797 int r; 3798 // since we start from the least significant digit, charPos points to 3799 // the last character in cmpCharArray. 3800 int charPos = cmpCharArray.length; 3801 3802 // Get 2 digits/iteration using longs until quotient fits into an int 3803 while (intCompact > Integer.MAX_VALUE) { 3804 q = intCompact / 100; 3805 r = (int)(intCompact - q * 100); 3806 intCompact = q; 3807 cmpCharArray[--charPos] = DIGIT_ONES[r]; 3808 cmpCharArray[--charPos] = DIGIT_TENS[r]; 3809 } 3810 3811 // Get 2 digits/iteration using ints when i2 >= 100 3812 int q2; 3813 int i2 = (int)intCompact; 3814 while (i2 >= 100) { 3815 q2 = i2 / 100; 3816 r = i2 - q2 * 100; 3817 i2 = q2; 3818 cmpCharArray[--charPos] = DIGIT_ONES[r]; 3819 cmpCharArray[--charPos] = DIGIT_TENS[r]; 3820 } 3821 3822 cmpCharArray[--charPos] = DIGIT_ONES[i2]; 3823 if (i2 >= 10) 3824 cmpCharArray[--charPos] = DIGIT_TENS[i2]; 3825 3826 return charPos; 3827 } 3828 3829 static final char[] DIGIT_TENS = { 3830 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', 3831 '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', 3832 '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', 3833 '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', 3834 '4', '4', '4', '4', '4', '4', '4', '4', '4', '4', 3835 '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', 3836 '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', 3837 '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', 3838 '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', 3839 '9', '9', '9', '9', '9', '9', '9', '9', '9', '9', 3840 }; 3841 3842 static final char[] DIGIT_ONES = { 3843 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3844 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3845 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3846 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3847 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3848 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3849 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3850 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3851 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3852 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 3853 }; 3854 } 3855 3856 /** 3857 * Lay out this {@code BigDecimal} into a {@code char[]} array. 3858 * The Java 1.2 equivalent to this was called {@code getValueString}. 3859 * 3860 * @param sci {@code true} for Scientific exponential notation; 3861 * {@code false} for Engineering 3862 * @return string with canonical string representation of this 3863 * {@code BigDecimal} 3864 */ 3865 private String layoutChars(boolean sci) { 3866 if (scale == 0) // zero scale is trivial 3867 return (intCompact != INFLATED) ? 3868 Long.toString(intCompact): 3869 intVal.toString(); 3870 if (scale == 2 && 3871 intCompact >= 0 && intCompact < Integer.MAX_VALUE) { 3872 // currency fast path 3873 int lowInt = (int)intCompact % 100; 3874 int highInt = (int)intCompact / 100; 3875 return (Integer.toString(highInt) + '.' + 3876 StringBuilderHelper.DIGIT_TENS[lowInt] + 3877 StringBuilderHelper.DIGIT_ONES[lowInt]) ; 3878 } 3879 3880 StringBuilderHelper sbHelper = threadLocalStringBuilderHelper.get(); 3881 char[] coeff; 3882 int offset; // offset is the starting index for coeff array 3883 // Get the significand as an absolute value 3884 if (intCompact != INFLATED) { 3885 offset = sbHelper.putIntCompact(Math.abs(intCompact)); 3886 coeff = sbHelper.getCompactCharArray(); 3887 } else { 3888 offset = 0; 3889 coeff = intVal.abs().toString().toCharArray(); 3890 } 3891 3892 // Construct a buffer, with sufficient capacity for all cases. 3893 // If E-notation is needed, length will be: +1 if negative, +1 3894 // if '.' needed, +2 for "E+", + up to 10 for adjusted exponent. 3895 // Otherwise it could have +1 if negative, plus leading "0.00000" 3896 StringBuilder buf = sbHelper.getStringBuilder(); 3897 if (signum() < 0) // prefix '-' if negative 3898 buf.append('-'); 3899 int coeffLen = coeff.length - offset; 3900 long adjusted = -(long)scale + (coeffLen -1); 3901 if ((scale >= 0) && (adjusted >= -6)) { // plain number 3902 int pad = scale - coeffLen; // count of padding zeros 3903 if (pad >= 0) { // 0.xxx form 3904 buf.append('0'); 3905 buf.append('.'); 3906 for (; pad>0; pad--) { 3907 buf.append('0'); 3908 } 3909 buf.append(coeff, offset, coeffLen); 3910 } else { // xx.xx form 3911 buf.append(coeff, offset, -pad); 3912 buf.append('.'); 3913 buf.append(coeff, -pad + offset, scale); 3914 } 3915 } else { // E-notation is needed 3916 if (sci) { // Scientific notation 3917 buf.append(coeff[offset]); // first character 3918 if (coeffLen > 1) { // more to come 3919 buf.append('.'); 3920 buf.append(coeff, offset + 1, coeffLen - 1); 3921 } 3922 } else { // Engineering notation 3923 int sig = (int)(adjusted % 3); 3924 if (sig < 0) 3925 sig += 3; // [adjusted was negative] 3926 adjusted -= sig; // now a multiple of 3 3927 sig++; 3928 if (signum() == 0) { 3929 switch (sig) { 3930 case 1: 3931 buf.append('0'); // exponent is a multiple of three 3932 break; 3933 case 2: 3934 buf.append("0.00"); 3935 adjusted += 3; 3936 break; 3937 case 3: 3938 buf.append("0.0"); 3939 adjusted += 3; 3940 break; 3941 default: 3942 throw new AssertionError("Unexpected sig value " + sig); 3943 } 3944 } else if (sig >= coeffLen) { // significand all in integer 3945 buf.append(coeff, offset, coeffLen); 3946 // may need some zeros, too 3947 for (int i = sig - coeffLen; i > 0; i--) { 3948 buf.append('0'); 3949 } 3950 } else { // xx.xxE form 3951 buf.append(coeff, offset, sig); 3952 buf.append('.'); 3953 buf.append(coeff, offset + sig, coeffLen - sig); 3954 } 3955 } 3956 if (adjusted != 0) { // [!sci could have made 0] 3957 buf.append('E'); 3958 if (adjusted > 0) // force sign for positive 3959 buf.append('+'); 3960 buf.append(adjusted); 3961 } 3962 } 3963 return buf.toString(); 3964 } 3965 3966 /** 3967 * Return 10 to the power n, as a {@code BigInteger}. 3968 * 3969 * @param n the power of ten to be returned (>=0) 3970 * @return a {@code BigInteger} with the value (10<sup>n</sup>) 3971 */ 3972 private static BigInteger bigTenToThe(int n) { 3973 if (n < 0) 3974 return BigInteger.ZERO; 3975 3976 if (n < BIG_TEN_POWERS_TABLE_MAX) { 3977 BigInteger[] pows = BIG_TEN_POWERS_TABLE; 3978 if (n < pows.length) 3979 return pows[n]; 3980 else 3981 return expandBigIntegerTenPowers(n); 3982 } 3983 3984 return BigInteger.TEN.pow(n); 3985 } 3986 3987 /** 3988 * Expand the BIG_TEN_POWERS_TABLE array to contain at least 10**n. 3989 * 3990 * @param n the power of ten to be returned (>=0) 3991 * @return a {@code BigDecimal} with the value (10<sup>n</sup>) and 3992 * in the meantime, the BIG_TEN_POWERS_TABLE array gets 3993 * expanded to the size greater than n. 3994 */ 3995 private static BigInteger expandBigIntegerTenPowers(int n) { 3996 synchronized(BigDecimal.class) { 3997 BigInteger[] pows = BIG_TEN_POWERS_TABLE; 3998 int curLen = pows.length; 3999 // The following comparison and the above synchronized statement is 4000 // to prevent multiple threads from expanding the same array. 4001 if (curLen <= n) { 4002 int newLen = curLen << 1; 4003 while (newLen <= n) { 4004 newLen <<= 1; 4005 } 4006 pows = Arrays.copyOf(pows, newLen); 4007 for (int i = curLen; i < newLen; i++) { 4008 pows[i] = pows[i - 1].multiply(BigInteger.TEN); 4009 } 4010 // Based on the following facts: 4011 // 1. pows is a private local varible; 4012 // 2. the following store is a volatile store. 4013 // the newly created array elements can be safely published. 4014 BIG_TEN_POWERS_TABLE = pows; 4015 } 4016 return pows[n]; 4017 } 4018 } 4019 4020 private static final long[] LONG_TEN_POWERS_TABLE = { 4021 1, // 0 / 10^0 4022 10, // 1 / 10^1 4023 100, // 2 / 10^2 4024 1000, // 3 / 10^3 4025 10000, // 4 / 10^4 4026 100000, // 5 / 10^5 4027 1000000, // 6 / 10^6 4028 10000000, // 7 / 10^7 4029 100000000, // 8 / 10^8 4030 1000000000, // 9 / 10^9 4031 10000000000L, // 10 / 10^10 4032 100000000000L, // 11 / 10^11 4033 1000000000000L, // 12 / 10^12 4034 10000000000000L, // 13 / 10^13 4035 100000000000000L, // 14 / 10^14 4036 1000000000000000L, // 15 / 10^15 4037 10000000000000000L, // 16 / 10^16 4038 100000000000000000L, // 17 / 10^17 4039 1000000000000000000L // 18 / 10^18 4040 }; 4041 4042 private static volatile BigInteger BIG_TEN_POWERS_TABLE[] = { 4043 BigInteger.ONE, 4044 BigInteger.valueOf(10), 4045 BigInteger.valueOf(100), 4046 BigInteger.valueOf(1000), 4047 BigInteger.valueOf(10000), 4048 BigInteger.valueOf(100000), 4049 BigInteger.valueOf(1000000), 4050 BigInteger.valueOf(10000000), 4051 BigInteger.valueOf(100000000), 4052 BigInteger.valueOf(1000000000), 4053 BigInteger.valueOf(10000000000L), 4054 BigInteger.valueOf(100000000000L), 4055 BigInteger.valueOf(1000000000000L), 4056 BigInteger.valueOf(10000000000000L), 4057 BigInteger.valueOf(100000000000000L), 4058 BigInteger.valueOf(1000000000000000L), 4059 BigInteger.valueOf(10000000000000000L), 4060 BigInteger.valueOf(100000000000000000L), 4061 BigInteger.valueOf(1000000000000000000L) 4062 }; 4063 4064 private static final int BIG_TEN_POWERS_TABLE_INITLEN = 4065 BIG_TEN_POWERS_TABLE.length; 4066 private static final int BIG_TEN_POWERS_TABLE_MAX = 4067 16 * BIG_TEN_POWERS_TABLE_INITLEN; 4068 4069 private static final long THRESHOLDS_TABLE[] = { 4070 Long.MAX_VALUE, // 0 4071 Long.MAX_VALUE/10L, // 1 4072 Long.MAX_VALUE/100L, // 2 4073 Long.MAX_VALUE/1000L, // 3 4074 Long.MAX_VALUE/10000L, // 4 4075 Long.MAX_VALUE/100000L, // 5 4076 Long.MAX_VALUE/1000000L, // 6 4077 Long.MAX_VALUE/10000000L, // 7 4078 Long.MAX_VALUE/100000000L, // 8 4079 Long.MAX_VALUE/1000000000L, // 9 4080 Long.MAX_VALUE/10000000000L, // 10 4081 Long.MAX_VALUE/100000000000L, // 11 4082 Long.MAX_VALUE/1000000000000L, // 12 4083 Long.MAX_VALUE/10000000000000L, // 13 4084 Long.MAX_VALUE/100000000000000L, // 14 4085 Long.MAX_VALUE/1000000000000000L, // 15 4086 Long.MAX_VALUE/10000000000000000L, // 16 4087 Long.MAX_VALUE/100000000000000000L, // 17 4088 Long.MAX_VALUE/1000000000000000000L // 18 4089 }; 4090 4091 /** 4092 * Compute val * 10 ^ n; return this product if it is 4093 * representable as a long, INFLATED otherwise. 4094 */ 4095 private static long longMultiplyPowerTen(long val, int n) { 4096 if (val == 0 || n <= 0) 4097 return val; 4098 long[] tab = LONG_TEN_POWERS_TABLE; 4099 long[] bounds = THRESHOLDS_TABLE; 4100 if (n < tab.length && n < bounds.length) { 4101 long tenpower = tab[n]; 4102 if (val == 1) 4103 return tenpower; 4104 if (Math.abs(val) <= bounds[n]) 4105 return val * tenpower; 4106 } 4107 return INFLATED; 4108 } 4109 4110 /** 4111 * Compute this * 10 ^ n. 4112 * Needed mainly to allow special casing to trap zero value 4113 */ 4114 private BigInteger bigMultiplyPowerTen(int n) { 4115 if (n <= 0) 4116 return this.inflated(); 4117 4118 if (intCompact != INFLATED) 4119 return bigTenToThe(n).multiply(intCompact); 4120 else 4121 return intVal.multiply(bigTenToThe(n)); 4122 } 4123 4124 /** 4125 * Returns appropriate BigInteger from intVal field if intVal is 4126 * null, i.e. the compact representation is in use. 4127 */ 4128 private BigInteger inflated() { 4129 if (intVal == null) { 4130 return BigInteger.valueOf(intCompact); 4131 } 4132 return intVal; 4133 } 4134 4135 /** 4136 * Match the scales of two {@code BigDecimal}s to align their 4137 * least significant digits. 4138 * 4139 * <p>If the scales of val[0] and val[1] differ, rescale 4140 * (non-destructively) the lower-scaled {@code BigDecimal} so 4141 * they match. That is, the lower-scaled reference will be 4142 * replaced by a reference to a new object with the same scale as 4143 * the other {@code BigDecimal}. 4144 * 4145 * @param val array of two elements referring to the two 4146 * {@code BigDecimal}s to be aligned. 4147 */ 4148 private static void matchScale(BigDecimal[] val) { 4149 if (val[0].scale < val[1].scale) { 4150 val[0] = val[0].setScale(val[1].scale, ROUND_UNNECESSARY); 4151 } else if (val[1].scale < val[0].scale) { 4152 val[1] = val[1].setScale(val[0].scale, ROUND_UNNECESSARY); 4153 } 4154 } 4155 4156 private static class UnsafeHolder { 4157 private static final jdk.internal.misc.Unsafe unsafe 4158 = jdk.internal.misc.Unsafe.getUnsafe(); 4159 private static final long intCompactOffset 4160 = unsafe.objectFieldOffset(BigDecimal.class, "intCompact"); 4161 private static final long intValOffset 4162 = unsafe.objectFieldOffset(BigDecimal.class, "intVal"); 4163 4164 static void setIntCompact(BigDecimal bd, long val) { 4165 unsafe.putLong(bd, intCompactOffset, val); 4166 } 4167 4168 static void setIntValVolatile(BigDecimal bd, BigInteger val) { 4169 unsafe.putReferenceVolatile(bd, intValOffset, val); 4170 } 4171 } 4172 4173 /** 4174 * Reconstitute the {@code BigDecimal} instance from a stream (that is, 4175 * deserialize it). 4176 * 4177 * @param s the stream being read. 4178 */ 4179 @java.io.Serial 4180 private void readObject(java.io.ObjectInputStream s) 4181 throws java.io.IOException, ClassNotFoundException { 4182 // Read in all fields 4183 s.defaultReadObject(); 4184 // validate possibly bad fields 4185 if (intVal == null) { 4186 String message = "BigDecimal: null intVal in stream"; 4187 throw new java.io.StreamCorruptedException(message); 4188 // [all values of scale are now allowed] 4189 } 4190 UnsafeHolder.setIntCompact(this, compactValFor(intVal)); 4191 } 4192 4193 /** 4194 * Serialize this {@code BigDecimal} to the stream in question 4195 * 4196 * @param s the stream to serialize to. 4197 */ 4198 @java.io.Serial 4199 private void writeObject(java.io.ObjectOutputStream s) 4200 throws java.io.IOException { 4201 // Must inflate to maintain compatible serial form. 4202 if (this.intVal == null) 4203 UnsafeHolder.setIntValVolatile(this, BigInteger.valueOf(this.intCompact)); 4204 // Could reset intVal back to null if it has to be set. 4205 s.defaultWriteObject(); 4206 } 4207 4208 /** 4209 * Returns the length of the absolute value of a {@code long}, in decimal 4210 * digits. 4211 * 4212 * @param x the {@code long} 4213 * @return the length of the unscaled value, in deciaml digits. 4214 */ 4215 static int longDigitLength(long x) { 4216 /* 4217 * As described in "Bit Twiddling Hacks" by Sean Anderson, 4218 * (http://graphics.stanford.edu/~seander/bithacks.html) 4219 * integer log 10 of x is within 1 of (1233/4096)* (1 + 4220 * integer log 2 of x). The fraction 1233/4096 approximates 4221 * log10(2). So we first do a version of log2 (a variant of 4222 * Long class with pre-checks and opposite directionality) and 4223 * then scale and check against powers table. This is a little 4224 * simpler in present context than the version in Hacker's 4225 * Delight sec 11-4. Adding one to bit length allows comparing 4226 * downward from the LONG_TEN_POWERS_TABLE that we need 4227 * anyway. 4228 */ 4229 assert x != BigDecimal.INFLATED; 4230 if (x < 0) 4231 x = -x; 4232 if (x < 10) // must screen for 0, might as well 10 4233 return 1; 4234 int r = ((64 - Long.numberOfLeadingZeros(x) + 1) * 1233) >>> 12; 4235 long[] tab = LONG_TEN_POWERS_TABLE; 4236 // if r >= length, must have max possible digits for long 4237 return (r >= tab.length || x < tab[r]) ? r : r + 1; 4238 } 4239 4240 /** 4241 * Returns the length of the absolute value of a BigInteger, in 4242 * decimal digits. 4243 * 4244 * @param b the BigInteger 4245 * @return the length of the unscaled value, in decimal digits 4246 */ 4247 private static int bigDigitLength(BigInteger b) { 4248 /* 4249 * Same idea as the long version, but we need a better 4250 * approximation of log10(2). Using 646456993/2^31 4251 * is accurate up to max possible reported bitLength. 4252 */ 4253 if (b.signum == 0) 4254 return 1; 4255 int r = (int)((((long)b.bitLength() + 1) * 646456993) >>> 31); 4256 return b.compareMagnitude(bigTenToThe(r)) < 0? r : r+1; 4257 } 4258 4259 /** 4260 * Check a scale for Underflow or Overflow. If this BigDecimal is 4261 * nonzero, throw an exception if the scale is outof range. If this 4262 * is zero, saturate the scale to the extreme value of the right 4263 * sign if the scale is out of range. 4264 * 4265 * @param val The new scale. 4266 * @throws ArithmeticException (overflow or underflow) if the new 4267 * scale is out of range. 4268 * @return validated scale as an int. 4269 */ 4270 private int checkScale(long val) { 4271 int asInt = (int)val; 4272 if (asInt != val) { 4273 asInt = val>Integer.MAX_VALUE ? Integer.MAX_VALUE : Integer.MIN_VALUE; 4274 BigInteger b; 4275 if (intCompact != 0 && 4276 ((b = intVal) == null || b.signum() != 0)) 4277 throw new ArithmeticException(asInt>0 ? "Underflow":"Overflow"); 4278 } 4279 return asInt; 4280 } 4281 4282 /** 4283 * Returns the compact value for given {@code BigInteger}, or 4284 * INFLATED if too big. Relies on internal representation of 4285 * {@code BigInteger}. 4286 */ 4287 private static long compactValFor(BigInteger b) { 4288 int[] m = b.mag; 4289 int len = m.length; 4290 if (len == 0) 4291 return 0; 4292 int d = m[0]; 4293 if (len > 2 || (len == 2 && d < 0)) 4294 return INFLATED; 4295 4296 long u = (len == 2)? 4297 (((long) m[1] & LONG_MASK) + (((long)d) << 32)) : 4298 (((long)d) & LONG_MASK); 4299 return (b.signum < 0)? -u : u; 4300 } 4301 4302 private static int longCompareMagnitude(long x, long y) { 4303 if (x < 0) 4304 x = -x; 4305 if (y < 0) 4306 y = -y; 4307 return (x < y) ? -1 : ((x == y) ? 0 : 1); 4308 } 4309 4310 private static int saturateLong(long s) { 4311 int i = (int)s; 4312 return (s == i) ? i : (s < 0 ? Integer.MIN_VALUE : Integer.MAX_VALUE); 4313 } 4314 4315 /* 4316 * Internal printing routine 4317 */ 4318 private static void print(String name, BigDecimal bd) { 4319 System.err.format("%s:\tintCompact %d\tintVal %d\tscale %d\tprecision %d%n", 4320 name, 4321 bd.intCompact, 4322 bd.intVal, 4323 bd.scale, 4324 bd.precision); 4325 } 4326 4327 /** 4328 * Check internal invariants of this BigDecimal. These invariants 4329 * include: 4330 * 4331 * <ul> 4332 * 4333 * <li>The object must be initialized; either intCompact must not be 4334 * INFLATED or intVal is non-null. Both of these conditions may 4335 * be true. 4336 * 4337 * <li>If both intCompact and intVal and set, their values must be 4338 * consistent. 4339 * 4340 * <li>If precision is nonzero, it must have the right value. 4341 * </ul> 4342 * 4343 * Note: Since this is an audit method, we are not supposed to change the 4344 * state of this BigDecimal object. 4345 */ 4346 private BigDecimal audit() { 4347 if (intCompact == INFLATED) { 4348 if (intVal == null) { 4349 print("audit", this); 4350 throw new AssertionError("null intVal"); 4351 } 4352 // Check precision 4353 if (precision > 0 && precision != bigDigitLength(intVal)) { 4354 print("audit", this); 4355 throw new AssertionError("precision mismatch"); 4356 } 4357 } else { 4358 if (intVal != null) { 4359 long val = intVal.longValue(); 4360 if (val != intCompact) { 4361 print("audit", this); 4362 throw new AssertionError("Inconsistent state, intCompact=" + 4363 intCompact + "\t intVal=" + val); 4364 } 4365 } 4366 // Check precision 4367 if (precision > 0 && precision != longDigitLength(intCompact)) { 4368 print("audit", this); 4369 throw new AssertionError("precision mismatch"); 4370 } 4371 } 4372 return this; 4373 } 4374 4375 /* the same as checkScale where value!=0 */ 4376 private static int checkScaleNonZero(long val) { 4377 int asInt = (int)val; 4378 if (asInt != val) { 4379 throw new ArithmeticException(asInt>0 ? "Underflow":"Overflow"); 4380 } 4381 return asInt; 4382 } 4383 4384 private static int checkScale(long intCompact, long val) { 4385 int asInt = (int)val; 4386 if (asInt != val) { 4387 asInt = val>Integer.MAX_VALUE ? Integer.MAX_VALUE : Integer.MIN_VALUE; 4388 if (intCompact != 0) 4389 throw new ArithmeticException(asInt>0 ? "Underflow":"Overflow"); 4390 } 4391 return asInt; 4392 } 4393 4394 private static int checkScale(BigInteger intVal, long val) { 4395 int asInt = (int)val; 4396 if (asInt != val) { 4397 asInt = val>Integer.MAX_VALUE ? Integer.MAX_VALUE : Integer.MIN_VALUE; 4398 if (intVal.signum() != 0) 4399 throw new ArithmeticException(asInt>0 ? "Underflow":"Overflow"); 4400 } 4401 return asInt; 4402 } 4403 4404 /** 4405 * Returns a {@code BigDecimal} rounded according to the MathContext 4406 * settings; 4407 * If rounding is needed a new {@code BigDecimal} is created and returned. 4408 * 4409 * @param val the value to be rounded 4410 * @param mc the context to use. 4411 * @return a {@code BigDecimal} rounded according to the MathContext 4412 * settings. May return {@code value}, if no rounding needed. 4413 * @throws ArithmeticException if the rounding mode is 4414 * {@code RoundingMode.UNNECESSARY} and the 4415 * result is inexact. 4416 */ 4417 private static BigDecimal doRound(BigDecimal val, MathContext mc) { 4418 int mcp = mc.precision; 4419 boolean wasDivided = false; 4420 if (mcp > 0) { 4421 BigInteger intVal = val.intVal; 4422 long compactVal = val.intCompact; 4423 int scale = val.scale; 4424 int prec = val.precision(); 4425 int mode = mc.roundingMode.oldMode; 4426 int drop; 4427 if (compactVal == INFLATED) { 4428 drop = prec - mcp; 4429 while (drop > 0) { 4430 scale = checkScaleNonZero((long) scale - drop); 4431 intVal = divideAndRoundByTenPow(intVal, drop, mode); 4432 wasDivided = true; 4433 compactVal = compactValFor(intVal); 4434 if (compactVal != INFLATED) { 4435 prec = longDigitLength(compactVal); 4436 break; 4437 } 4438 prec = bigDigitLength(intVal); 4439 drop = prec - mcp; 4440 } 4441 } 4442 if (compactVal != INFLATED) { 4443 drop = prec - mcp; // drop can't be more than 18 4444 while (drop > 0) { 4445 scale = checkScaleNonZero((long) scale - drop); 4446 compactVal = divideAndRound(compactVal, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode); 4447 wasDivided = true; 4448 prec = longDigitLength(compactVal); 4449 drop = prec - mcp; 4450 intVal = null; 4451 } 4452 } 4453 return wasDivided ? new BigDecimal(intVal,compactVal,scale,prec) : val; 4454 } 4455 return val; 4456 } 4457 4458 /* 4459 * Returns a {@code BigDecimal} created from {@code long} value with 4460 * given scale rounded according to the MathContext settings 4461 */ 4462 private static BigDecimal doRound(long compactVal, int scale, MathContext mc) { 4463 int mcp = mc.precision; 4464 if (mcp > 0 && mcp < 19) { 4465 int prec = longDigitLength(compactVal); 4466 int drop = prec - mcp; // drop can't be more than 18 4467 while (drop > 0) { 4468 scale = checkScaleNonZero((long) scale - drop); 4469 compactVal = divideAndRound(compactVal, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode); 4470 prec = longDigitLength(compactVal); 4471 drop = prec - mcp; 4472 } 4473 return valueOf(compactVal, scale, prec); 4474 } 4475 return valueOf(compactVal, scale); 4476 } 4477 4478 /* 4479 * Returns a {@code BigDecimal} created from {@code BigInteger} value with 4480 * given scale rounded according to the MathContext settings 4481 */ 4482 private static BigDecimal doRound(BigInteger intVal, int scale, MathContext mc) { 4483 int mcp = mc.precision; 4484 int prec = 0; 4485 if (mcp > 0) { 4486 long compactVal = compactValFor(intVal); 4487 int mode = mc.roundingMode.oldMode; 4488 int drop; 4489 if (compactVal == INFLATED) { 4490 prec = bigDigitLength(intVal); 4491 drop = prec - mcp; 4492 while (drop > 0) { 4493 scale = checkScaleNonZero((long) scale - drop); 4494 intVal = divideAndRoundByTenPow(intVal, drop, mode); 4495 compactVal = compactValFor(intVal); 4496 if (compactVal != INFLATED) { 4497 break; 4498 } 4499 prec = bigDigitLength(intVal); 4500 drop = prec - mcp; 4501 } 4502 } 4503 if (compactVal != INFLATED) { 4504 prec = longDigitLength(compactVal); 4505 drop = prec - mcp; // drop can't be more than 18 4506 while (drop > 0) { 4507 scale = checkScaleNonZero((long) scale - drop); 4508 compactVal = divideAndRound(compactVal, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode); 4509 prec = longDigitLength(compactVal); 4510 drop = prec - mcp; 4511 } 4512 return valueOf(compactVal,scale,prec); 4513 } 4514 } 4515 return new BigDecimal(intVal,INFLATED,scale,prec); 4516 } 4517 4518 /* 4519 * Divides {@code BigInteger} value by ten power. 4520 */ 4521 private static BigInteger divideAndRoundByTenPow(BigInteger intVal, int tenPow, int roundingMode) { 4522 if (tenPow < LONG_TEN_POWERS_TABLE.length) 4523 intVal = divideAndRound(intVal, LONG_TEN_POWERS_TABLE[tenPow], roundingMode); 4524 else 4525 intVal = divideAndRound(intVal, bigTenToThe(tenPow), roundingMode); 4526 return intVal; 4527 } 4528 4529 /** 4530 * Internally used for division operation for division {@code long} by 4531 * {@code long}. 4532 * The returned {@code BigDecimal} object is the quotient whose scale is set 4533 * to the passed in scale. If the remainder is not zero, it will be rounded 4534 * based on the passed in roundingMode. Also, if the remainder is zero and 4535 * the last parameter, i.e. preferredScale is NOT equal to scale, the 4536 * trailing zeros of the result is stripped to match the preferredScale. 4537 */ 4538 private static BigDecimal divideAndRound(long ldividend, long ldivisor, int scale, int roundingMode, 4539 int preferredScale) { 4540 4541 int qsign; // quotient sign 4542 long q = ldividend / ldivisor; // store quotient in long 4543 if (roundingMode == ROUND_DOWN && scale == preferredScale) 4544 return valueOf(q, scale); 4545 long r = ldividend % ldivisor; // store remainder in long 4546 qsign = ((ldividend < 0) == (ldivisor < 0)) ? 1 : -1; 4547 if (r != 0) { 4548 boolean increment = needIncrement(ldivisor, roundingMode, qsign, q, r); 4549 return valueOf((increment ? q + qsign : q), scale); 4550 } else { 4551 if (preferredScale != scale) 4552 return createAndStripZerosToMatchScale(q, scale, preferredScale); 4553 else 4554 return valueOf(q, scale); 4555 } 4556 } 4557 4558 /** 4559 * Divides {@code long} by {@code long} and do rounding based on the 4560 * passed in roundingMode. 4561 */ 4562 private static long divideAndRound(long ldividend, long ldivisor, int roundingMode) { 4563 int qsign; // quotient sign 4564 long q = ldividend / ldivisor; // store quotient in long 4565 if (roundingMode == ROUND_DOWN) 4566 return q; 4567 long r = ldividend % ldivisor; // store remainder in long 4568 qsign = ((ldividend < 0) == (ldivisor < 0)) ? 1 : -1; 4569 if (r != 0) { 4570 boolean increment = needIncrement(ldivisor, roundingMode, qsign, q, r); 4571 return increment ? q + qsign : q; 4572 } else { 4573 return q; 4574 } 4575 } 4576 4577 /** 4578 * Shared logic of need increment computation. 4579 */ 4580 private static boolean commonNeedIncrement(int roundingMode, int qsign, 4581 int cmpFracHalf, boolean oddQuot) { 4582 switch(roundingMode) { 4583 case ROUND_UNNECESSARY: 4584 throw new ArithmeticException("Rounding necessary"); 4585 4586 case ROUND_UP: // Away from zero 4587 return true; 4588 4589 case ROUND_DOWN: // Towards zero 4590 return false; 4591 4592 case ROUND_CEILING: // Towards +infinity 4593 return qsign > 0; 4594 4595 case ROUND_FLOOR: // Towards -infinity 4596 return qsign < 0; 4597 4598 default: // Some kind of half-way rounding 4599 assert roundingMode >= ROUND_HALF_UP && 4600 roundingMode <= ROUND_HALF_EVEN: "Unexpected rounding mode" + RoundingMode.valueOf(roundingMode); 4601 4602 if (cmpFracHalf < 0 ) // We're closer to higher digit 4603 return false; 4604 else if (cmpFracHalf > 0 ) // We're closer to lower digit 4605 return true; 4606 else { // half-way 4607 assert cmpFracHalf == 0; 4608 4609 switch(roundingMode) { 4610 case ROUND_HALF_DOWN: 4611 return false; 4612 4613 case ROUND_HALF_UP: 4614 return true; 4615 4616 case ROUND_HALF_EVEN: 4617 return oddQuot; 4618 4619 default: 4620 throw new AssertionError("Unexpected rounding mode" + roundingMode); 4621 } 4622 } 4623 } 4624 } 4625 4626 /** 4627 * Tests if quotient has to be incremented according the roundingMode 4628 */ 4629 private static boolean needIncrement(long ldivisor, int roundingMode, 4630 int qsign, long q, long r) { 4631 assert r != 0L; 4632 4633 int cmpFracHalf; 4634 if (r <= HALF_LONG_MIN_VALUE || r > HALF_LONG_MAX_VALUE) { 4635 cmpFracHalf = 1; // 2 * r can't fit into long 4636 } else { 4637 cmpFracHalf = longCompareMagnitude(2 * r, ldivisor); 4638 } 4639 4640 return commonNeedIncrement(roundingMode, qsign, cmpFracHalf, (q & 1L) != 0L); 4641 } 4642 4643 /** 4644 * Divides {@code BigInteger} value by {@code long} value and 4645 * do rounding based on the passed in roundingMode. 4646 */ 4647 private static BigInteger divideAndRound(BigInteger bdividend, long ldivisor, int roundingMode) { 4648 // Descend into mutables for faster remainder checks 4649 MutableBigInteger mdividend = new MutableBigInteger(bdividend.mag); 4650 // store quotient 4651 MutableBigInteger mq = new MutableBigInteger(); 4652 // store quotient & remainder in long 4653 long r = mdividend.divide(ldivisor, mq); 4654 // record remainder is zero or not 4655 boolean isRemainderZero = (r == 0); 4656 // quotient sign 4657 int qsign = (ldivisor < 0) ? -bdividend.signum : bdividend.signum; 4658 if (!isRemainderZero) { 4659 if(needIncrement(ldivisor, roundingMode, qsign, mq, r)) { 4660 mq.add(MutableBigInteger.ONE); 4661 } 4662 } 4663 return mq.toBigInteger(qsign); 4664 } 4665 4666 /** 4667 * Internally used for division operation for division {@code BigInteger} 4668 * by {@code long}. 4669 * The returned {@code BigDecimal} object is the quotient whose scale is set 4670 * to the passed in scale. If the remainder is not zero, it will be rounded 4671 * based on the passed in roundingMode. Also, if the remainder is zero and 4672 * the last parameter, i.e. preferredScale is NOT equal to scale, the 4673 * trailing zeros of the result is stripped to match the preferredScale. 4674 */ 4675 private static BigDecimal divideAndRound(BigInteger bdividend, 4676 long ldivisor, int scale, int roundingMode, int preferredScale) { 4677 // Descend into mutables for faster remainder checks 4678 MutableBigInteger mdividend = new MutableBigInteger(bdividend.mag); 4679 // store quotient 4680 MutableBigInteger mq = new MutableBigInteger(); 4681 // store quotient & remainder in long 4682 long r = mdividend.divide(ldivisor, mq); 4683 // record remainder is zero or not 4684 boolean isRemainderZero = (r == 0); 4685 // quotient sign 4686 int qsign = (ldivisor < 0) ? -bdividend.signum : bdividend.signum; 4687 if (!isRemainderZero) { 4688 if(needIncrement(ldivisor, roundingMode, qsign, mq, r)) { 4689 mq.add(MutableBigInteger.ONE); 4690 } 4691 return mq.toBigDecimal(qsign, scale); 4692 } else { 4693 if (preferredScale != scale) { 4694 long compactVal = mq.toCompactValue(qsign); 4695 if(compactVal!=INFLATED) { 4696 return createAndStripZerosToMatchScale(compactVal, scale, preferredScale); 4697 } 4698 BigInteger intVal = mq.toBigInteger(qsign); 4699 return createAndStripZerosToMatchScale(intVal,scale, preferredScale); 4700 } else { 4701 return mq.toBigDecimal(qsign, scale); 4702 } 4703 } 4704 } 4705 4706 /** 4707 * Tests if quotient has to be incremented according the roundingMode 4708 */ 4709 private static boolean needIncrement(long ldivisor, int roundingMode, 4710 int qsign, MutableBigInteger mq, long r) { 4711 assert r != 0L; 4712 4713 int cmpFracHalf; 4714 if (r <= HALF_LONG_MIN_VALUE || r > HALF_LONG_MAX_VALUE) { 4715 cmpFracHalf = 1; // 2 * r can't fit into long 4716 } else { 4717 cmpFracHalf = longCompareMagnitude(2 * r, ldivisor); 4718 } 4719 4720 return commonNeedIncrement(roundingMode, qsign, cmpFracHalf, mq.isOdd()); 4721 } 4722 4723 /** 4724 * Divides {@code BigInteger} value by {@code BigInteger} value and 4725 * do rounding based on the passed in roundingMode. 4726 */ 4727 private static BigInteger divideAndRound(BigInteger bdividend, BigInteger bdivisor, int roundingMode) { 4728 boolean isRemainderZero; // record remainder is zero or not 4729 int qsign; // quotient sign 4730 // Descend into mutables for faster remainder checks 4731 MutableBigInteger mdividend = new MutableBigInteger(bdividend.mag); 4732 MutableBigInteger mq = new MutableBigInteger(); 4733 MutableBigInteger mdivisor = new MutableBigInteger(bdivisor.mag); 4734 MutableBigInteger mr = mdividend.divide(mdivisor, mq); 4735 isRemainderZero = mr.isZero(); 4736 qsign = (bdividend.signum != bdivisor.signum) ? -1 : 1; 4737 if (!isRemainderZero) { 4738 if (needIncrement(mdivisor, roundingMode, qsign, mq, mr)) { 4739 mq.add(MutableBigInteger.ONE); 4740 } 4741 } 4742 return mq.toBigInteger(qsign); 4743 } 4744 4745 /** 4746 * Internally used for division operation for division {@code BigInteger} 4747 * by {@code BigInteger}. 4748 * The returned {@code BigDecimal} object is the quotient whose scale is set 4749 * to the passed in scale. If the remainder is not zero, it will be rounded 4750 * based on the passed in roundingMode. Also, if the remainder is zero and 4751 * the last parameter, i.e. preferredScale is NOT equal to scale, the 4752 * trailing zeros of the result is stripped to match the preferredScale. 4753 */ 4754 private static BigDecimal divideAndRound(BigInteger bdividend, BigInteger bdivisor, int scale, int roundingMode, 4755 int preferredScale) { 4756 boolean isRemainderZero; // record remainder is zero or not 4757 int qsign; // quotient sign 4758 // Descend into mutables for faster remainder checks 4759 MutableBigInteger mdividend = new MutableBigInteger(bdividend.mag); 4760 MutableBigInteger mq = new MutableBigInteger(); 4761 MutableBigInteger mdivisor = new MutableBigInteger(bdivisor.mag); 4762 MutableBigInteger mr = mdividend.divide(mdivisor, mq); 4763 isRemainderZero = mr.isZero(); 4764 qsign = (bdividend.signum != bdivisor.signum) ? -1 : 1; 4765 if (!isRemainderZero) { 4766 if (needIncrement(mdivisor, roundingMode, qsign, mq, mr)) { 4767 mq.add(MutableBigInteger.ONE); 4768 } 4769 return mq.toBigDecimal(qsign, scale); 4770 } else { 4771 if (preferredScale != scale) { 4772 long compactVal = mq.toCompactValue(qsign); 4773 if (compactVal != INFLATED) { 4774 return createAndStripZerosToMatchScale(compactVal, scale, preferredScale); 4775 } 4776 BigInteger intVal = mq.toBigInteger(qsign); 4777 return createAndStripZerosToMatchScale(intVal, scale, preferredScale); 4778 } else { 4779 return mq.toBigDecimal(qsign, scale); 4780 } 4781 } 4782 } 4783 4784 /** 4785 * Tests if quotient has to be incremented according the roundingMode 4786 */ 4787 private static boolean needIncrement(MutableBigInteger mdivisor, int roundingMode, 4788 int qsign, MutableBigInteger mq, MutableBigInteger mr) { 4789 assert !mr.isZero(); 4790 int cmpFracHalf = mr.compareHalf(mdivisor); 4791 return commonNeedIncrement(roundingMode, qsign, cmpFracHalf, mq.isOdd()); 4792 } 4793 4794 /** 4795 * Remove insignificant trailing zeros from this 4796 * {@code BigInteger} value until the preferred scale is reached or no 4797 * more zeros can be removed. If the preferred scale is less than 4798 * Integer.MIN_VALUE, all the trailing zeros will be removed. 4799 * 4800 * @return new {@code BigDecimal} with a scale possibly reduced 4801 * to be closed to the preferred scale. 4802 */ 4803 private static BigDecimal createAndStripZerosToMatchScale(BigInteger intVal, int scale, long preferredScale) { 4804 BigInteger qr[]; // quotient-remainder pair 4805 while (intVal.compareMagnitude(BigInteger.TEN) >= 0 4806 && scale > preferredScale) { 4807 if (intVal.testBit(0)) 4808 break; // odd number cannot end in 0 4809 qr = intVal.divideAndRemainder(BigInteger.TEN); 4810 if (qr[1].signum() != 0) 4811 break; // non-0 remainder 4812 intVal = qr[0]; 4813 scale = checkScale(intVal,(long) scale - 1); // could Overflow 4814 } 4815 return valueOf(intVal, scale, 0); 4816 } 4817 4818 /** 4819 * Remove insignificant trailing zeros from this 4820 * {@code long} value until the preferred scale is reached or no 4821 * more zeros can be removed. If the preferred scale is less than 4822 * Integer.MIN_VALUE, all the trailing zeros will be removed. 4823 * 4824 * @return new {@code BigDecimal} with a scale possibly reduced 4825 * to be closed to the preferred scale. 4826 */ 4827 private static BigDecimal createAndStripZerosToMatchScale(long compactVal, int scale, long preferredScale) { 4828 while (Math.abs(compactVal) >= 10L && scale > preferredScale) { 4829 if ((compactVal & 1L) != 0L) 4830 break; // odd number cannot end in 0 4831 long r = compactVal % 10L; 4832 if (r != 0L) 4833 break; // non-0 remainder 4834 compactVal /= 10; 4835 scale = checkScale(compactVal, (long) scale - 1); // could Overflow 4836 } 4837 return valueOf(compactVal, scale); 4838 } 4839 4840 private static BigDecimal stripZerosToMatchScale(BigInteger intVal, long intCompact, int scale, int preferredScale) { 4841 if(intCompact!=INFLATED) { 4842 return createAndStripZerosToMatchScale(intCompact, scale, preferredScale); 4843 } else { 4844 return createAndStripZerosToMatchScale(intVal==null ? INFLATED_BIGINT : intVal, 4845 scale, preferredScale); 4846 } 4847 } 4848 4849 /* 4850 * returns INFLATED if oveflow 4851 */ 4852 private static long add(long xs, long ys){ 4853 long sum = xs + ys; 4854 // See "Hacker's Delight" section 2-12 for explanation of 4855 // the overflow test. 4856 if ( (((sum ^ xs) & (sum ^ ys))) >= 0L) { // not overflowed 4857 return sum; 4858 } 4859 return INFLATED; 4860 } 4861 4862 private static BigDecimal add(long xs, long ys, int scale){ 4863 long sum = add(xs, ys); 4864 if (sum!=INFLATED) 4865 return BigDecimal.valueOf(sum, scale); 4866 return new BigDecimal(BigInteger.valueOf(xs).add(ys), scale); 4867 } 4868 4869 private static BigDecimal add(final long xs, int scale1, final long ys, int scale2) { 4870 long sdiff = (long) scale1 - scale2; 4871 if (sdiff == 0) { 4872 return add(xs, ys, scale1); 4873 } else if (sdiff < 0) { 4874 int raise = checkScale(xs,-sdiff); 4875 long scaledX = longMultiplyPowerTen(xs, raise); 4876 if (scaledX != INFLATED) { 4877 return add(scaledX, ys, scale2); 4878 } else { 4879 BigInteger bigsum = bigMultiplyPowerTen(xs,raise).add(ys); 4880 return ((xs^ys)>=0) ? // same sign test 4881 new BigDecimal(bigsum, INFLATED, scale2, 0) 4882 : valueOf(bigsum, scale2, 0); 4883 } 4884 } else { 4885 int raise = checkScale(ys,sdiff); 4886 long scaledY = longMultiplyPowerTen(ys, raise); 4887 if (scaledY != INFLATED) { 4888 return add(xs, scaledY, scale1); 4889 } else { 4890 BigInteger bigsum = bigMultiplyPowerTen(ys,raise).add(xs); 4891 return ((xs^ys)>=0) ? 4892 new BigDecimal(bigsum, INFLATED, scale1, 0) 4893 : valueOf(bigsum, scale1, 0); 4894 } 4895 } 4896 } 4897 4898 private static BigDecimal add(final long xs, int scale1, BigInteger snd, int scale2) { 4899 int rscale = scale1; 4900 long sdiff = (long)rscale - scale2; 4901 boolean sameSigns = (Long.signum(xs) == snd.signum); 4902 BigInteger sum; 4903 if (sdiff < 0) { 4904 int raise = checkScale(xs,-sdiff); 4905 rscale = scale2; 4906 long scaledX = longMultiplyPowerTen(xs, raise); 4907 if (scaledX == INFLATED) { 4908 sum = snd.add(bigMultiplyPowerTen(xs,raise)); 4909 } else { 4910 sum = snd.add(scaledX); 4911 } 4912 } else { //if (sdiff > 0) { 4913 int raise = checkScale(snd,sdiff); 4914 snd = bigMultiplyPowerTen(snd,raise); 4915 sum = snd.add(xs); 4916 } 4917 return (sameSigns) ? 4918 new BigDecimal(sum, INFLATED, rscale, 0) : 4919 valueOf(sum, rscale, 0); 4920 } 4921 4922 private static BigDecimal add(BigInteger fst, int scale1, BigInteger snd, int scale2) { 4923 int rscale = scale1; 4924 long sdiff = (long)rscale - scale2; 4925 if (sdiff != 0) { 4926 if (sdiff < 0) { 4927 int raise = checkScale(fst,-sdiff); 4928 rscale = scale2; 4929 fst = bigMultiplyPowerTen(fst,raise); 4930 } else { 4931 int raise = checkScale(snd,sdiff); 4932 snd = bigMultiplyPowerTen(snd,raise); 4933 } 4934 } 4935 BigInteger sum = fst.add(snd); 4936 return (fst.signum == snd.signum) ? 4937 new BigDecimal(sum, INFLATED, rscale, 0) : 4938 valueOf(sum, rscale, 0); 4939 } 4940 4941 private static BigInteger bigMultiplyPowerTen(long value, int n) { 4942 if (n <= 0) 4943 return BigInteger.valueOf(value); 4944 return bigTenToThe(n).multiply(value); 4945 } 4946 4947 private static BigInteger bigMultiplyPowerTen(BigInteger value, int n) { 4948 if (n <= 0) 4949 return value; 4950 if(n<LONG_TEN_POWERS_TABLE.length) { 4951 return value.multiply(LONG_TEN_POWERS_TABLE[n]); 4952 } 4953 return value.multiply(bigTenToThe(n)); 4954 } 4955 4956 /** 4957 * Returns a {@code BigDecimal} whose value is {@code (xs / 4958 * ys)}, with rounding according to the context settings. 4959 * 4960 * Fast path - used only when (xscale <= yscale && yscale < 18 4961 * && mc.presision<18) { 4962 */ 4963 private static BigDecimal divideSmallFastPath(final long xs, int xscale, 4964 final long ys, int yscale, 4965 long preferredScale, MathContext mc) { 4966 int mcp = mc.precision; 4967 int roundingMode = mc.roundingMode.oldMode; 4968 4969 assert (xscale <= yscale) && (yscale < 18) && (mcp < 18); 4970 int xraise = yscale - xscale; // xraise >=0 4971 long scaledX = (xraise==0) ? xs : 4972 longMultiplyPowerTen(xs, xraise); // can't overflow here! 4973 BigDecimal quotient; 4974 4975 int cmp = longCompareMagnitude(scaledX, ys); 4976 if(cmp > 0) { // satisfy constraint (b) 4977 yscale -= 1; // [that is, divisor *= 10] 4978 int scl = checkScaleNonZero(preferredScale + yscale - xscale + mcp); 4979 if (checkScaleNonZero((long) mcp + yscale - xscale) > 0) { 4980 // assert newScale >= xscale 4981 int raise = checkScaleNonZero((long) mcp + yscale - xscale); 4982 long scaledXs; 4983 if ((scaledXs = longMultiplyPowerTen(xs, raise)) == INFLATED) { 4984 quotient = null; 4985 if((mcp-1) >=0 && (mcp-1)<LONG_TEN_POWERS_TABLE.length) { 4986 quotient = multiplyDivideAndRound(LONG_TEN_POWERS_TABLE[mcp-1], scaledX, ys, scl, roundingMode, checkScaleNonZero(preferredScale)); 4987 } 4988 if(quotient==null) { 4989 BigInteger rb = bigMultiplyPowerTen(scaledX,mcp-1); 4990 quotient = divideAndRound(rb, ys, 4991 scl, roundingMode, checkScaleNonZero(preferredScale)); 4992 } 4993 } else { 4994 quotient = divideAndRound(scaledXs, ys, scl, roundingMode, checkScaleNonZero(preferredScale)); 4995 } 4996 } else { 4997 int newScale = checkScaleNonZero((long) xscale - mcp); 4998 // assert newScale >= yscale 4999 if (newScale == yscale) { // easy case 5000 quotient = divideAndRound(xs, ys, scl, roundingMode,checkScaleNonZero(preferredScale)); 5001 } else { 5002 int raise = checkScaleNonZero((long) newScale - yscale); 5003 long scaledYs; 5004 if ((scaledYs = longMultiplyPowerTen(ys, raise)) == INFLATED) { 5005 BigInteger rb = bigMultiplyPowerTen(ys,raise); 5006 quotient = divideAndRound(BigInteger.valueOf(xs), 5007 rb, scl, roundingMode,checkScaleNonZero(preferredScale)); 5008 } else { 5009 quotient = divideAndRound(xs, scaledYs, scl, roundingMode,checkScaleNonZero(preferredScale)); 5010 } 5011 } 5012 } 5013 } else { 5014 // abs(scaledX) <= abs(ys) 5015 // result is "scaledX * 10^msp / ys" 5016 int scl = checkScaleNonZero(preferredScale + yscale - xscale + mcp); 5017 if(cmp==0) { 5018 // abs(scaleX)== abs(ys) => result will be scaled 10^mcp + correct sign 5019 quotient = roundedTenPower(((scaledX < 0) == (ys < 0)) ? 1 : -1, mcp, scl, checkScaleNonZero(preferredScale)); 5020 } else { 5021 // abs(scaledX) < abs(ys) 5022 long scaledXs; 5023 if ((scaledXs = longMultiplyPowerTen(scaledX, mcp)) == INFLATED) { 5024 quotient = null; 5025 if(mcp<LONG_TEN_POWERS_TABLE.length) { 5026 quotient = multiplyDivideAndRound(LONG_TEN_POWERS_TABLE[mcp], scaledX, ys, scl, roundingMode, checkScaleNonZero(preferredScale)); 5027 } 5028 if(quotient==null) { 5029 BigInteger rb = bigMultiplyPowerTen(scaledX,mcp); 5030 quotient = divideAndRound(rb, ys, 5031 scl, roundingMode, checkScaleNonZero(preferredScale)); 5032 } 5033 } else { 5034 quotient = divideAndRound(scaledXs, ys, scl, roundingMode, checkScaleNonZero(preferredScale)); 5035 } 5036 } 5037 } 5038 // doRound, here, only affects 1000000000 case. 5039 return doRound(quotient,mc); 5040 } 5041 5042 /** 5043 * Returns a {@code BigDecimal} whose value is {@code (xs / 5044 * ys)}, with rounding according to the context settings. 5045 */ 5046 private static BigDecimal divide(final long xs, int xscale, final long ys, int yscale, long preferredScale, MathContext mc) { 5047 int mcp = mc.precision; 5048 if(xscale <= yscale && yscale < 18 && mcp<18) { 5049 return divideSmallFastPath(xs, xscale, ys, yscale, preferredScale, mc); 5050 } 5051 if (compareMagnitudeNormalized(xs, xscale, ys, yscale) > 0) {// satisfy constraint (b) 5052 yscale -= 1; // [that is, divisor *= 10] 5053 } 5054 int roundingMode = mc.roundingMode.oldMode; 5055 // In order to find out whether the divide generates the exact result, 5056 // we avoid calling the above divide method. 'quotient' holds the 5057 // return BigDecimal object whose scale will be set to 'scl'. 5058 int scl = checkScaleNonZero(preferredScale + yscale - xscale + mcp); 5059 BigDecimal quotient; 5060 if (checkScaleNonZero((long) mcp + yscale - xscale) > 0) { 5061 int raise = checkScaleNonZero((long) mcp + yscale - xscale); 5062 long scaledXs; 5063 if ((scaledXs = longMultiplyPowerTen(xs, raise)) == INFLATED) { 5064 BigInteger rb = bigMultiplyPowerTen(xs,raise); 5065 quotient = divideAndRound(rb, ys, scl, roundingMode, checkScaleNonZero(preferredScale)); 5066 } else { 5067 quotient = divideAndRound(scaledXs, ys, scl, roundingMode, checkScaleNonZero(preferredScale)); 5068 } 5069 } else { 5070 int newScale = checkScaleNonZero((long) xscale - mcp); 5071 // assert newScale >= yscale 5072 if (newScale == yscale) { // easy case 5073 quotient = divideAndRound(xs, ys, scl, roundingMode,checkScaleNonZero(preferredScale)); 5074 } else { 5075 int raise = checkScaleNonZero((long) newScale - yscale); 5076 long scaledYs; 5077 if ((scaledYs = longMultiplyPowerTen(ys, raise)) == INFLATED) { 5078 BigInteger rb = bigMultiplyPowerTen(ys,raise); 5079 quotient = divideAndRound(BigInteger.valueOf(xs), 5080 rb, scl, roundingMode,checkScaleNonZero(preferredScale)); 5081 } else { 5082 quotient = divideAndRound(xs, scaledYs, scl, roundingMode,checkScaleNonZero(preferredScale)); 5083 } 5084 } 5085 } 5086 // doRound, here, only affects 1000000000 case. 5087 return doRound(quotient,mc); 5088 } 5089 5090 /** 5091 * Returns a {@code BigDecimal} whose value is {@code (xs / 5092 * ys)}, with rounding according to the context settings. 5093 */ 5094 private static BigDecimal divide(BigInteger xs, int xscale, long ys, int yscale, long preferredScale, MathContext mc) { 5095 // Normalize dividend & divisor so that both fall into [0.1, 0.999...] 5096 if ((-compareMagnitudeNormalized(ys, yscale, xs, xscale)) > 0) {// satisfy constraint (b) 5097 yscale -= 1; // [that is, divisor *= 10] 5098 } 5099 int mcp = mc.precision; 5100 int roundingMode = mc.roundingMode.oldMode; 5101 5102 // In order to find out whether the divide generates the exact result, 5103 // we avoid calling the above divide method. 'quotient' holds the 5104 // return BigDecimal object whose scale will be set to 'scl'. 5105 BigDecimal quotient; 5106 int scl = checkScaleNonZero(preferredScale + yscale - xscale + mcp); 5107 if (checkScaleNonZero((long) mcp + yscale - xscale) > 0) { 5108 int raise = checkScaleNonZero((long) mcp + yscale - xscale); 5109 BigInteger rb = bigMultiplyPowerTen(xs,raise); 5110 quotient = divideAndRound(rb, ys, scl, roundingMode, checkScaleNonZero(preferredScale)); 5111 } else { 5112 int newScale = checkScaleNonZero((long) xscale - mcp); 5113 // assert newScale >= yscale 5114 if (newScale == yscale) { // easy case 5115 quotient = divideAndRound(xs, ys, scl, roundingMode,checkScaleNonZero(preferredScale)); 5116 } else { 5117 int raise = checkScaleNonZero((long) newScale - yscale); 5118 long scaledYs; 5119 if ((scaledYs = longMultiplyPowerTen(ys, raise)) == INFLATED) { 5120 BigInteger rb = bigMultiplyPowerTen(ys,raise); 5121 quotient = divideAndRound(xs, rb, scl, roundingMode,checkScaleNonZero(preferredScale)); 5122 } else { 5123 quotient = divideAndRound(xs, scaledYs, scl, roundingMode,checkScaleNonZero(preferredScale)); 5124 } 5125 } 5126 } 5127 // doRound, here, only affects 1000000000 case. 5128 return doRound(quotient, mc); 5129 } 5130 5131 /** 5132 * Returns a {@code BigDecimal} whose value is {@code (xs / 5133 * ys)}, with rounding according to the context settings. 5134 */ 5135 private static BigDecimal divide(long xs, int xscale, BigInteger ys, int yscale, long preferredScale, MathContext mc) { 5136 // Normalize dividend & divisor so that both fall into [0.1, 0.999...] 5137 if (compareMagnitudeNormalized(xs, xscale, ys, yscale) > 0) {// satisfy constraint (b) 5138 yscale -= 1; // [that is, divisor *= 10] 5139 } 5140 int mcp = mc.precision; 5141 int roundingMode = mc.roundingMode.oldMode; 5142 5143 // In order to find out whether the divide generates the exact result, 5144 // we avoid calling the above divide method. 'quotient' holds the 5145 // return BigDecimal object whose scale will be set to 'scl'. 5146 BigDecimal quotient; 5147 int scl = checkScaleNonZero(preferredScale + yscale - xscale + mcp); 5148 if (checkScaleNonZero((long) mcp + yscale - xscale) > 0) { 5149 int raise = checkScaleNonZero((long) mcp + yscale - xscale); 5150 BigInteger rb = bigMultiplyPowerTen(xs,raise); 5151 quotient = divideAndRound(rb, ys, scl, roundingMode, checkScaleNonZero(preferredScale)); 5152 } else { 5153 int newScale = checkScaleNonZero((long) xscale - mcp); 5154 int raise = checkScaleNonZero((long) newScale - yscale); 5155 BigInteger rb = bigMultiplyPowerTen(ys,raise); 5156 quotient = divideAndRound(BigInteger.valueOf(xs), rb, scl, roundingMode,checkScaleNonZero(preferredScale)); 5157 } 5158 // doRound, here, only affects 1000000000 case. 5159 return doRound(quotient, mc); 5160 } 5161 5162 /** 5163 * Returns a {@code BigDecimal} whose value is {@code (xs / 5164 * ys)}, with rounding according to the context settings. 5165 */ 5166 private static BigDecimal divide(BigInteger xs, int xscale, BigInteger ys, int yscale, long preferredScale, MathContext mc) { 5167 // Normalize dividend & divisor so that both fall into [0.1, 0.999...] 5168 if (compareMagnitudeNormalized(xs, xscale, ys, yscale) > 0) {// satisfy constraint (b) 5169 yscale -= 1; // [that is, divisor *= 10] 5170 } 5171 int mcp = mc.precision; 5172 int roundingMode = mc.roundingMode.oldMode; 5173 5174 // In order to find out whether the divide generates the exact result, 5175 // we avoid calling the above divide method. 'quotient' holds the 5176 // return BigDecimal object whose scale will be set to 'scl'. 5177 BigDecimal quotient; 5178 int scl = checkScaleNonZero(preferredScale + yscale - xscale + mcp); 5179 if (checkScaleNonZero((long) mcp + yscale - xscale) > 0) { 5180 int raise = checkScaleNonZero((long) mcp + yscale - xscale); 5181 BigInteger rb = bigMultiplyPowerTen(xs,raise); 5182 quotient = divideAndRound(rb, ys, scl, roundingMode, checkScaleNonZero(preferredScale)); 5183 } else { 5184 int newScale = checkScaleNonZero((long) xscale - mcp); 5185 int raise = checkScaleNonZero((long) newScale - yscale); 5186 BigInteger rb = bigMultiplyPowerTen(ys,raise); 5187 quotient = divideAndRound(xs, rb, scl, roundingMode,checkScaleNonZero(preferredScale)); 5188 } 5189 // doRound, here, only affects 1000000000 case. 5190 return doRound(quotient, mc); 5191 } 5192 5193 /* 5194 * performs divideAndRound for (dividend0*dividend1, divisor) 5195 * returns null if quotient can't fit into long value; 5196 */ 5197 private static BigDecimal multiplyDivideAndRound(long dividend0, long dividend1, long divisor, int scale, int roundingMode, 5198 int preferredScale) { 5199 int qsign = Long.signum(dividend0)*Long.signum(dividend1)*Long.signum(divisor); 5200 dividend0 = Math.abs(dividend0); 5201 dividend1 = Math.abs(dividend1); 5202 divisor = Math.abs(divisor); 5203 // multiply dividend0 * dividend1 5204 long d0_hi = dividend0 >>> 32; 5205 long d0_lo = dividend0 & LONG_MASK; 5206 long d1_hi = dividend1 >>> 32; 5207 long d1_lo = dividend1 & LONG_MASK; 5208 long product = d0_lo * d1_lo; 5209 long d0 = product & LONG_MASK; 5210 long d1 = product >>> 32; 5211 product = d0_hi * d1_lo + d1; 5212 d1 = product & LONG_MASK; 5213 long d2 = product >>> 32; 5214 product = d0_lo * d1_hi + d1; 5215 d1 = product & LONG_MASK; 5216 d2 += product >>> 32; 5217 long d3 = d2>>>32; 5218 d2 &= LONG_MASK; 5219 product = d0_hi*d1_hi + d2; 5220 d2 = product & LONG_MASK; 5221 d3 = ((product>>>32) + d3) & LONG_MASK; 5222 final long dividendHi = make64(d3,d2); 5223 final long dividendLo = make64(d1,d0); 5224 // divide 5225 return divideAndRound128(dividendHi, dividendLo, divisor, qsign, scale, roundingMode, preferredScale); 5226 } 5227 5228 private static final long DIV_NUM_BASE = (1L<<32); // Number base (32 bits). 5229 5230 /* 5231 * divideAndRound 128-bit value by long divisor. 5232 * returns null if quotient can't fit into long value; 5233 * Specialized version of Knuth's division 5234 */ 5235 private static BigDecimal divideAndRound128(final long dividendHi, final long dividendLo, long divisor, int sign, 5236 int scale, int roundingMode, int preferredScale) { 5237 if (dividendHi >= divisor) { 5238 return null; 5239 } 5240 5241 final int shift = Long.numberOfLeadingZeros(divisor); 5242 divisor <<= shift; 5243 5244 final long v1 = divisor >>> 32; 5245 final long v0 = divisor & LONG_MASK; 5246 5247 long tmp = dividendLo << shift; 5248 long u1 = tmp >>> 32; 5249 long u0 = tmp & LONG_MASK; 5250 5251 tmp = (dividendHi << shift) | (dividendLo >>> 64 - shift); 5252 long u2 = tmp & LONG_MASK; 5253 long q1, r_tmp; 5254 if (v1 == 1) { 5255 q1 = tmp; 5256 r_tmp = 0; 5257 } else if (tmp >= 0) { 5258 q1 = tmp / v1; 5259 r_tmp = tmp - q1 * v1; 5260 } else { 5261 long[] rq = divRemNegativeLong(tmp, v1); 5262 q1 = rq[1]; 5263 r_tmp = rq[0]; 5264 } 5265 5266 while(q1 >= DIV_NUM_BASE || unsignedLongCompare(q1*v0, make64(r_tmp, u1))) { 5267 q1--; 5268 r_tmp += v1; 5269 if (r_tmp >= DIV_NUM_BASE) 5270 break; 5271 } 5272 5273 tmp = mulsub(u2,u1,v1,v0,q1); 5274 u1 = tmp & LONG_MASK; 5275 long q0; 5276 if (v1 == 1) { 5277 q0 = tmp; 5278 r_tmp = 0; 5279 } else if (tmp >= 0) { 5280 q0 = tmp / v1; 5281 r_tmp = tmp - q0 * v1; 5282 } else { 5283 long[] rq = divRemNegativeLong(tmp, v1); 5284 q0 = rq[1]; 5285 r_tmp = rq[0]; 5286 } 5287 5288 while(q0 >= DIV_NUM_BASE || unsignedLongCompare(q0*v0,make64(r_tmp,u0))) { 5289 q0--; 5290 r_tmp += v1; 5291 if (r_tmp >= DIV_NUM_BASE) 5292 break; 5293 } 5294 5295 if((int)q1 < 0) { 5296 // result (which is positive and unsigned here) 5297 // can't fit into long due to sign bit is used for value 5298 MutableBigInteger mq = new MutableBigInteger(new int[]{(int)q1, (int)q0}); 5299 if (roundingMode == ROUND_DOWN && scale == preferredScale) { 5300 return mq.toBigDecimal(sign, scale); 5301 } 5302 long r = mulsub(u1, u0, v1, v0, q0) >>> shift; 5303 if (r != 0) { 5304 if(needIncrement(divisor >>> shift, roundingMode, sign, mq, r)){ 5305 mq.add(MutableBigInteger.ONE); 5306 } 5307 return mq.toBigDecimal(sign, scale); 5308 } else { 5309 if (preferredScale != scale) { 5310 BigInteger intVal = mq.toBigInteger(sign); 5311 return createAndStripZerosToMatchScale(intVal,scale, preferredScale); 5312 } else { 5313 return mq.toBigDecimal(sign, scale); 5314 } 5315 } 5316 } 5317 5318 long q = make64(q1,q0); 5319 q*=sign; 5320 5321 if (roundingMode == ROUND_DOWN && scale == preferredScale) 5322 return valueOf(q, scale); 5323 5324 long r = mulsub(u1, u0, v1, v0, q0) >>> shift; 5325 if (r != 0) { 5326 boolean increment = needIncrement(divisor >>> shift, roundingMode, sign, q, r); 5327 return valueOf((increment ? q + sign : q), scale); 5328 } else { 5329 if (preferredScale != scale) { 5330 return createAndStripZerosToMatchScale(q, scale, preferredScale); 5331 } else { 5332 return valueOf(q, scale); 5333 } 5334 } 5335 } 5336 5337 /* 5338 * calculate divideAndRound for ldividend*10^raise / divisor 5339 * when abs(dividend)==abs(divisor); 5340 */ 5341 private static BigDecimal roundedTenPower(int qsign, int raise, int scale, int preferredScale) { 5342 if (scale > preferredScale) { 5343 int diff = scale - preferredScale; 5344 if(diff < raise) { 5345 return scaledTenPow(raise - diff, qsign, preferredScale); 5346 } else { 5347 return valueOf(qsign,scale-raise); 5348 } 5349 } else { 5350 return scaledTenPow(raise, qsign, scale); 5351 } 5352 } 5353 5354 static BigDecimal scaledTenPow(int n, int sign, int scale) { 5355 if (n < LONG_TEN_POWERS_TABLE.length) 5356 return valueOf(sign*LONG_TEN_POWERS_TABLE[n],scale); 5357 else { 5358 BigInteger unscaledVal = bigTenToThe(n); 5359 if(sign==-1) { 5360 unscaledVal = unscaledVal.negate(); 5361 } 5362 return new BigDecimal(unscaledVal, INFLATED, scale, n+1); 5363 } 5364 } 5365 5366 /** 5367 * Calculate the quotient and remainder of dividing a negative long by 5368 * another long. 5369 * 5370 * @param n the numerator; must be negative 5371 * @param d the denominator; must not be unity 5372 * @return a two-element {@long} array with the remainder and quotient in 5373 * the initial and final elements, respectively 5374 */ 5375 private static long[] divRemNegativeLong(long n, long d) { 5376 assert n < 0 : "Non-negative numerator " + n; 5377 assert d != 1 : "Unity denominator"; 5378 5379 // Approximate the quotient and remainder 5380 long q = (n >>> 1) / (d >>> 1); 5381 long r = n - q * d; 5382 5383 // Correct the approximation 5384 while (r < 0) { 5385 r += d; 5386 q--; 5387 } 5388 while (r >= d) { 5389 r -= d; 5390 q++; 5391 } 5392 5393 // n - q*d == r && 0 <= r < d, hence we're done. 5394 return new long[] {r, q}; 5395 } 5396 5397 private static long make64(long hi, long lo) { 5398 return hi<<32 | lo; 5399 } 5400 5401 private static long mulsub(long u1, long u0, final long v1, final long v0, long q0) { 5402 long tmp = u0 - q0*v0; 5403 return make64(u1 + (tmp>>>32) - q0*v1,tmp & LONG_MASK); 5404 } 5405 5406 private static boolean unsignedLongCompare(long one, long two) { 5407 return (one+Long.MIN_VALUE) > (two+Long.MIN_VALUE); 5408 } 5409 5410 private static boolean unsignedLongCompareEq(long one, long two) { 5411 return (one+Long.MIN_VALUE) >= (two+Long.MIN_VALUE); 5412 } 5413 5414 5415 // Compare Normalize dividend & divisor so that both fall into [0.1, 0.999...] 5416 private static int compareMagnitudeNormalized(long xs, int xscale, long ys, int yscale) { 5417 // assert xs!=0 && ys!=0 5418 int sdiff = xscale - yscale; 5419 if (sdiff != 0) { 5420 if (sdiff < 0) { 5421 xs = longMultiplyPowerTen(xs, -sdiff); 5422 } else { // sdiff > 0 5423 ys = longMultiplyPowerTen(ys, sdiff); 5424 } 5425 } 5426 if (xs != INFLATED) 5427 return (ys != INFLATED) ? longCompareMagnitude(xs, ys) : -1; 5428 else 5429 return 1; 5430 } 5431 5432 // Compare Normalize dividend & divisor so that both fall into [0.1, 0.999...] 5433 private static int compareMagnitudeNormalized(long xs, int xscale, BigInteger ys, int yscale) { 5434 // assert "ys can't be represented as long" 5435 if (xs == 0) 5436 return -1; 5437 int sdiff = xscale - yscale; 5438 if (sdiff < 0) { 5439 if (longMultiplyPowerTen(xs, -sdiff) == INFLATED ) { 5440 return bigMultiplyPowerTen(xs, -sdiff).compareMagnitude(ys); 5441 } 5442 } 5443 return -1; 5444 } 5445 5446 // Compare Normalize dividend & divisor so that both fall into [0.1, 0.999...] 5447 private static int compareMagnitudeNormalized(BigInteger xs, int xscale, BigInteger ys, int yscale) { 5448 int sdiff = xscale - yscale; 5449 if (sdiff < 0) { 5450 return bigMultiplyPowerTen(xs, -sdiff).compareMagnitude(ys); 5451 } else { // sdiff >= 0 5452 return xs.compareMagnitude(bigMultiplyPowerTen(ys, sdiff)); 5453 } 5454 } 5455 5456 private static long multiply(long x, long y){ 5457 long product = x * y; 5458 long ax = Math.abs(x); 5459 long ay = Math.abs(y); 5460 if (((ax | ay) >>> 31 == 0) || (y == 0) || (product / y == x)){ 5461 return product; 5462 } 5463 return INFLATED; 5464 } 5465 5466 private static BigDecimal multiply(long x, long y, int scale) { 5467 long product = multiply(x, y); 5468 if(product!=INFLATED) { 5469 return valueOf(product,scale); 5470 } 5471 return new BigDecimal(BigInteger.valueOf(x).multiply(y),INFLATED,scale,0); 5472 } 5473 5474 private static BigDecimal multiply(long x, BigInteger y, int scale) { 5475 if(x==0) { 5476 return zeroValueOf(scale); 5477 } 5478 return new BigDecimal(y.multiply(x),INFLATED,scale,0); 5479 } 5480 5481 private static BigDecimal multiply(BigInteger x, BigInteger y, int scale) { 5482 return new BigDecimal(x.multiply(y),INFLATED,scale,0); 5483 } 5484 5485 /** 5486 * Multiplies two long values and rounds according {@code MathContext} 5487 */ 5488 private static BigDecimal multiplyAndRound(long x, long y, int scale, MathContext mc) { 5489 long product = multiply(x, y); 5490 if(product!=INFLATED) { 5491 return doRound(product, scale, mc); 5492 } 5493 // attempt to do it in 128 bits 5494 int rsign = 1; 5495 if(x < 0) { 5496 x = -x; 5497 rsign = -1; 5498 } 5499 if(y < 0) { 5500 y = -y; 5501 rsign *= -1; 5502 } 5503 // multiply dividend0 * dividend1 5504 long m0_hi = x >>> 32; 5505 long m0_lo = x & LONG_MASK; 5506 long m1_hi = y >>> 32; 5507 long m1_lo = y & LONG_MASK; 5508 product = m0_lo * m1_lo; 5509 long m0 = product & LONG_MASK; 5510 long m1 = product >>> 32; 5511 product = m0_hi * m1_lo + m1; 5512 m1 = product & LONG_MASK; 5513 long m2 = product >>> 32; 5514 product = m0_lo * m1_hi + m1; 5515 m1 = product & LONG_MASK; 5516 m2 += product >>> 32; 5517 long m3 = m2>>>32; 5518 m2 &= LONG_MASK; 5519 product = m0_hi*m1_hi + m2; 5520 m2 = product & LONG_MASK; 5521 m3 = ((product>>>32) + m3) & LONG_MASK; 5522 final long mHi = make64(m3,m2); 5523 final long mLo = make64(m1,m0); 5524 BigDecimal res = doRound128(mHi, mLo, rsign, scale, mc); 5525 if(res!=null) { 5526 return res; 5527 } 5528 res = new BigDecimal(BigInteger.valueOf(x).multiply(y*rsign), INFLATED, scale, 0); 5529 return doRound(res,mc); 5530 } 5531 5532 private static BigDecimal multiplyAndRound(long x, BigInteger y, int scale, MathContext mc) { 5533 if(x==0) { 5534 return zeroValueOf(scale); 5535 } 5536 return doRound(y.multiply(x), scale, mc); 5537 } 5538 5539 private static BigDecimal multiplyAndRound(BigInteger x, BigInteger y, int scale, MathContext mc) { 5540 return doRound(x.multiply(y), scale, mc); 5541 } 5542 5543 /** 5544 * rounds 128-bit value according {@code MathContext} 5545 * returns null if result can't be repsented as compact BigDecimal. 5546 */ 5547 private static BigDecimal doRound128(long hi, long lo, int sign, int scale, MathContext mc) { 5548 int mcp = mc.precision; 5549 int drop; 5550 BigDecimal res = null; 5551 if(((drop = precision(hi, lo) - mcp) > 0)&&(drop<LONG_TEN_POWERS_TABLE.length)) { 5552 scale = checkScaleNonZero((long)scale - drop); 5553 res = divideAndRound128(hi, lo, LONG_TEN_POWERS_TABLE[drop], sign, scale, mc.roundingMode.oldMode, scale); 5554 } 5555 if(res!=null) { 5556 return doRound(res,mc); 5557 } 5558 return null; 5559 } 5560 5561 private static final long[][] LONGLONG_TEN_POWERS_TABLE = { 5562 { 0L, 0x8AC7230489E80000L }, //10^19 5563 { 0x5L, 0x6bc75e2d63100000L }, //10^20 5564 { 0x36L, 0x35c9adc5dea00000L }, //10^21 5565 { 0x21eL, 0x19e0c9bab2400000L }, //10^22 5566 { 0x152dL, 0x02c7e14af6800000L }, //10^23 5567 { 0xd3c2L, 0x1bcecceda1000000L }, //10^24 5568 { 0x84595L, 0x161401484a000000L }, //10^25 5569 { 0x52b7d2L, 0xdcc80cd2e4000000L }, //10^26 5570 { 0x33b2e3cL, 0x9fd0803ce8000000L }, //10^27 5571 { 0x204fce5eL, 0x3e25026110000000L }, //10^28 5572 { 0x1431e0faeL, 0x6d7217caa0000000L }, //10^29 5573 { 0xc9f2c9cd0L, 0x4674edea40000000L }, //10^30 5574 { 0x7e37be2022L, 0xc0914b2680000000L }, //10^31 5575 { 0x4ee2d6d415bL, 0x85acef8100000000L }, //10^32 5576 { 0x314dc6448d93L, 0x38c15b0a00000000L }, //10^33 5577 { 0x1ed09bead87c0L, 0x378d8e6400000000L }, //10^34 5578 { 0x13426172c74d82L, 0x2b878fe800000000L }, //10^35 5579 { 0xc097ce7bc90715L, 0xb34b9f1000000000L }, //10^36 5580 { 0x785ee10d5da46d9L, 0x00f436a000000000L }, //10^37 5581 { 0x4b3b4ca85a86c47aL, 0x098a224000000000L }, //10^38 5582 }; 5583 5584 /* 5585 * returns precision of 128-bit value 5586 */ 5587 private static int precision(long hi, long lo){ 5588 if(hi==0) { 5589 if(lo>=0) { 5590 return longDigitLength(lo); 5591 } 5592 return (unsignedLongCompareEq(lo, LONGLONG_TEN_POWERS_TABLE[0][1])) ? 20 : 19; 5593 // 0x8AC7230489E80000L = unsigned 2^19 5594 } 5595 int r = ((128 - Long.numberOfLeadingZeros(hi) + 1) * 1233) >>> 12; 5596 int idx = r-19; 5597 return (idx >= LONGLONG_TEN_POWERS_TABLE.length || longLongCompareMagnitude(hi, lo, 5598 LONGLONG_TEN_POWERS_TABLE[idx][0], LONGLONG_TEN_POWERS_TABLE[idx][1])) ? r : r + 1; 5599 } 5600 5601 /* 5602 * returns true if 128 bit number <hi0,lo0> is less than <hi1,lo1> 5603 * hi0 & hi1 should be non-negative 5604 */ 5605 private static boolean longLongCompareMagnitude(long hi0, long lo0, long hi1, long lo1) { 5606 if(hi0!=hi1) { 5607 return hi0<hi1; 5608 } 5609 return (lo0+Long.MIN_VALUE) <(lo1+Long.MIN_VALUE); 5610 } 5611 5612 private static BigDecimal divide(long dividend, int dividendScale, long divisor, int divisorScale, int scale, int roundingMode) { 5613 if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) { 5614 int newScale = scale + divisorScale; 5615 int raise = newScale - dividendScale; 5616 if(raise<LONG_TEN_POWERS_TABLE.length) { 5617 long xs = dividend; 5618 if ((xs = longMultiplyPowerTen(xs, raise)) != INFLATED) { 5619 return divideAndRound(xs, divisor, scale, roundingMode, scale); 5620 } 5621 BigDecimal q = multiplyDivideAndRound(LONG_TEN_POWERS_TABLE[raise], dividend, divisor, scale, roundingMode, scale); 5622 if(q!=null) { 5623 return q; 5624 } 5625 } 5626 BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise); 5627 return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale); 5628 } else { 5629 int newScale = checkScale(divisor,(long)dividendScale - scale); 5630 int raise = newScale - divisorScale; 5631 if(raise<LONG_TEN_POWERS_TABLE.length) { 5632 long ys = divisor; 5633 if ((ys = longMultiplyPowerTen(ys, raise)) != INFLATED) { 5634 return divideAndRound(dividend, ys, scale, roundingMode, scale); 5635 } 5636 } 5637 BigInteger scaledDivisor = bigMultiplyPowerTen(divisor, raise); 5638 return divideAndRound(BigInteger.valueOf(dividend), scaledDivisor, scale, roundingMode, scale); 5639 } 5640 } 5641 5642 private static BigDecimal divide(BigInteger dividend, int dividendScale, long divisor, int divisorScale, int scale, int roundingMode) { 5643 if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) { 5644 int newScale = scale + divisorScale; 5645 int raise = newScale - dividendScale; 5646 BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise); 5647 return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale); 5648 } else { 5649 int newScale = checkScale(divisor,(long)dividendScale - scale); 5650 int raise = newScale - divisorScale; 5651 if(raise<LONG_TEN_POWERS_TABLE.length) { 5652 long ys = divisor; 5653 if ((ys = longMultiplyPowerTen(ys, raise)) != INFLATED) { 5654 return divideAndRound(dividend, ys, scale, roundingMode, scale); 5655 } 5656 } 5657 BigInteger scaledDivisor = bigMultiplyPowerTen(divisor, raise); 5658 return divideAndRound(dividend, scaledDivisor, scale, roundingMode, scale); 5659 } 5660 } 5661 5662 private static BigDecimal divide(long dividend, int dividendScale, BigInteger divisor, int divisorScale, int scale, int roundingMode) { 5663 if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) { 5664 int newScale = scale + divisorScale; 5665 int raise = newScale - dividendScale; 5666 BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise); 5667 return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale); 5668 } else { 5669 int newScale = checkScale(divisor,(long)dividendScale - scale); 5670 int raise = newScale - divisorScale; 5671 BigInteger scaledDivisor = bigMultiplyPowerTen(divisor, raise); 5672 return divideAndRound(BigInteger.valueOf(dividend), scaledDivisor, scale, roundingMode, scale); 5673 } 5674 } 5675 5676 private static BigDecimal divide(BigInteger dividend, int dividendScale, BigInteger divisor, int divisorScale, int scale, int roundingMode) { 5677 if (checkScale(dividend,(long)scale + divisorScale) > dividendScale) { 5678 int newScale = scale + divisorScale; 5679 int raise = newScale - dividendScale; 5680 BigInteger scaledDividend = bigMultiplyPowerTen(dividend, raise); 5681 return divideAndRound(scaledDividend, divisor, scale, roundingMode, scale); 5682 } else { 5683 int newScale = checkScale(divisor,(long)dividendScale - scale); 5684 int raise = newScale - divisorScale; 5685 BigInteger scaledDivisor = bigMultiplyPowerTen(divisor, raise); 5686 return divideAndRound(dividend, scaledDivisor, scale, roundingMode, scale); 5687 } 5688 } 5689 5690 }