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