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