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