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