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