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