2575 * @param n the exponent power of ten to scale by
2576 * @return a BigDecimal whose numerical value is equal to
2577 * ({@code this} * 10<sup>n</sup>)
2578 * @throws ArithmeticException if the scale would be
2579 * outside the range of a 32-bit integer.
2580 *
2581 * @since 1.5
2582 */
2583 public BigDecimal scaleByPowerOfTen(int n) {
2584 return new BigDecimal(intVal, intCompact,
2585 checkScale((long)scale - n), precision);
2586 }
2587
2588 /**
2589 * Returns a {@code BigDecimal} which is numerically equal to
2590 * this one but with any trailing zeros removed from the
2591 * representation. For example, stripping the trailing zeros from
2592 * the {@code BigDecimal} value {@code 600.0}, which has
2593 * [{@code BigInteger}, {@code scale}] components equals to
2594 * [6000, 1], yields {@code 6E2} with [{@code BigInteger},
2595 * {@code scale}] components equals to [6, -2]
2596 *
2597 * @return a numerically equal {@code BigDecimal} with any
2598 * trailing zeros removed.
2599 * @since 1.5
2600 */
2601 public BigDecimal stripTrailingZeros() {
2602 if(intCompact!=INFLATED) {
2603 return createAndStripZerosToMatchScale(intCompact, scale, Long.MIN_VALUE);
2604 } else {
2605 return createAndStripZerosToMatchScale(intVal, scale, Long.MIN_VALUE);
2606 }
2607 }
2608
2609 // Comparison Operations
2610
2611 /**
2612 * Compares this {@code BigDecimal} with the specified
2613 * {@code BigDecimal}. Two {@code BigDecimal} objects that are
2614 * equal in value but have a different scale (like 2.0 and 2.00)
2615 * are considered equal by this method. This method is provided
2616 * in preference to individual methods for each of the six boolean
2617 * comparison operators ({@literal <}, ==,
2618 * {@literal >}, {@literal >=}, !=, {@literal <=}). The
2619 * suggested idiom for performing these comparisons is:
2620 * {@code (x.compareTo(y)} <<i>op</i>> {@code 0)}, where
2621 * <<i>op</i>> is one of the six comparison operators.
2622 *
|
2575 * @param n the exponent power of ten to scale by
2576 * @return a BigDecimal whose numerical value is equal to
2577 * ({@code this} * 10<sup>n</sup>)
2578 * @throws ArithmeticException if the scale would be
2579 * outside the range of a 32-bit integer.
2580 *
2581 * @since 1.5
2582 */
2583 public BigDecimal scaleByPowerOfTen(int n) {
2584 return new BigDecimal(intVal, intCompact,
2585 checkScale((long)scale - n), precision);
2586 }
2587
2588 /**
2589 * Returns a {@code BigDecimal} which is numerically equal to
2590 * this one but with any trailing zeros removed from the
2591 * representation. For example, stripping the trailing zeros from
2592 * the {@code BigDecimal} value {@code 600.0}, which has
2593 * [{@code BigInteger}, {@code scale}] components equals to
2594 * [6000, 1], yields {@code 6E2} with [{@code BigInteger},
2595 * {@code scale}] components equals to [6, -2]. If
2596 * this BigDecimal is numerically equal to zero, then
2597 * {@code BigDecimal.ZERO} is returned.
2598 *
2599 * @return a numerically equal {@code BigDecimal} with any
2600 * trailing zeros removed.
2601 * @since 1.5
2602 */
2603 public BigDecimal stripTrailingZeros() {
2604 if (intCompact == 0 || (intVal != null && intVal.signum() == 0)) {
2605 return BigDecimal.ZERO;
2606 } else if (intCompact != INFLATED) {
2607 return createAndStripZerosToMatchScale(intCompact, scale, Long.MIN_VALUE);
2608 } else {
2609 return createAndStripZerosToMatchScale(intVal, scale, Long.MIN_VALUE);
2610 }
2611 }
2612
2613 // Comparison Operations
2614
2615 /**
2616 * Compares this {@code BigDecimal} with the specified
2617 * {@code BigDecimal}. Two {@code BigDecimal} objects that are
2618 * equal in value but have a different scale (like 2.0 and 2.00)
2619 * are considered equal by this method. This method is provided
2620 * in preference to individual methods for each of the six boolean
2621 * comparison operators ({@literal <}, ==,
2622 * {@literal >}, {@literal >=}, !=, {@literal <=}). The
2623 * suggested idiom for performing these comparisons is:
2624 * {@code (x.compareTo(y)} <<i>op</i>> {@code 0)}, where
2625 * <<i>op</i>> is one of the six comparison operators.
2626 *
|