Decimal (decimal4j API 1.0.3)

Type Parameters:
S - the scale metrics type associated with this Decimal

All Superinterfaces:

Comparable<Decimal<S>>

All Known Subinterfaces:

ImmutableDecimal<S>, MutableDecimal<S>

All Known Implementing Classes:

AbstractDecimal, AbstractImmutableDecimal, AbstractMutableDecimal, Decimal0f, Decimal10f, Decimal11f, Decimal12f, Decimal13f, Decimal14f, Decimal15f, Decimal16f, Decimal17f, Decimal18f, Decimal1f, Decimal2f, Decimal3f, Decimal4f, Decimal5f, Decimal6f, Decimal7f, Decimal8f, Decimal9f, GenericImmutableDecimal, GenericMutableDecimal, MutableDecimal0f, MutableDecimal10f, MutableDecimal11f, MutableDecimal12f, MutableDecimal13f, MutableDecimal14f, MutableDecimal15f, MutableDecimal16f, MutableDecimal17f, MutableDecimal18f, MutableDecimal1f, MutableDecimal2f, MutableDecimal3f, MutableDecimal4f, MutableDecimal5f, MutableDecimal6f, MutableDecimal7f, MutableDecimal8f, MutableDecimal9f
```
public interface Decimal<S extends ScaleMetrics>
extends Comparable<Decimal<S>>
```
Signed fixed-point decimal number similar to BigDecimal. A Decimal number can be immutable or mutable and it is based on an underlying unscaled long value and a fixed scale. The scale defines the number of digits to the right of the decimal point. If the scale is f then the value represented by a Decimal instance is (unscaledValue × 10^-f).
Scale of Result and Operands
The result of an arithmetic operation is generally of the same scale as this Decimal unless otherwise indicated. Decimal operands of arithmetic operations are typically also of the same scale as this Decimal. Scale compatibility of Decimal operands is enforced through the generic ScaleMetrics parameter <S>.
Operands involving Type Conversion
For convenience, arithmetic operations with other data types are sometimes also provided. Such operations usually perform a value conversion into a Decimal of the current scale before performing the actual operation.
Rounding
If the result of an arithmetic operation cannot be represented exactly in the scale of this Decimal, it is rounded to the least significant digit. HALF_UP rounding is used by default if no other rounding mode is explicitly specified. Note that in a few exceptional cases HALF_EVEN rounding is used by default to comply with inherited specification constraints (e.g. see doubleValue(), floatValue() etc.). The documentation of operations which involve rounding indicate the rounding mode that is applied.
Overflows
Operations with Decimal values can lead to overflows in marked contrast to the BigDecimal. This is a direct consequence of the construction of a Decimal value on the basis of a long value. Unless otherwise indicated operations silently truncate overflows by default. This choice has been made for performance reasons and because Java programmers are already familiar with this behavior from operations with primitive integer types. If this behavior is inappropriate for an application, exceptions in overflow situations can be enforced through an optional OverflowMode or TruncationPolicy argument. Some operations like conversion operations or arithmetic operations involving conversion always throw an exception if an overflow occurs. The documentation of operations which can cause an overflow always indicates the exact overflow behavior.
All methods for this interface throw NullPointerException when passed a null object reference for any input parameter.

Method Summary

Methods
Modifier and Type	Method and Description
`Decimal<S>`	`abs()` Returns a `Decimal` whose value is the absolute value of this `Decimal`.
`Decimal<S>`	`abs(OverflowMode overflowMode)` Returns a `Decimal` whose value is the absolute value of this `Decimal`.
`Decimal<S>`	`add(Decimal<?> augend, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + augend)`.
`Decimal<S>`	`add(Decimal<?> augend, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this + augend)`.
`Decimal<S>`	`add(Decimal<S> augend)` Returns a `Decimal` whose value is `(this + augend)`.
`Decimal<S>`	`add(Decimal<S> augend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this + augend)`.
`Decimal<S>`	`add(double augend)` Returns a `Decimal` whose value is `(this + augend)` after converting the given `double` argument into a Decimal value of the same scale as `this` Decimal.
`Decimal<S>`	`add(double augend, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + augend)` after converting the given `double` argument into a Decimal value of the same scale as `this` Decimal.
`Decimal<S>`	`add(long augend)` Returns a `Decimal` whose value is `(this + augend)` after converting the given `long` value to the scale of `this` Decimal.
`Decimal<S>`	`add(long augend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this + augend)` after converting the given `long` value to the scale of `this` Decimal.
`Decimal<S>`	`addSquared(Decimal<S> value)` Returns a `Decimal` whose value is `(this + value²)`.
`Decimal<S>`	`addSquared(Decimal<S> value, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + value²)`.
`Decimal<S>`	`addSquared(Decimal<S> value, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this + value²)`.
`Decimal<S>`	`addUnscaled(long unscaledAugend)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)` with the `scale` of this Decimal.
`Decimal<S>`	`addUnscaled(long unscaledAugend, int scale)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)`.
`Decimal<S>`	`addUnscaled(long unscaledAugend, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)`.
`Decimal<S>`	`addUnscaled(long unscaledAugend, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)`.
`Decimal<S>`	`addUnscaled(long unscaledAugend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)` with the `scale` of this Decimal.
`Decimal<S>`	`avg(Decimal<S> val)` Returns the average of this `Decimal` and `val`.
`Decimal<S>`	`avg(Decimal<S> val, RoundingMode roundingMode)` Returns the average of this `Decimal` and `val`.
`byte`	`byteValue()` Returns the value of this `Decimal` as a `byte` after a narrowing primitive conversion.
`byte`	`byteValueExact()` Converts this `Decimal` to a `byte`, checking for lost information.
`int`	`compareTo(Decimal<S> other)` Compares two `Decimal` objects numerically.
`int`	`compareToNumerically(Decimal<?> other)` Compares this `Decimal` with the specified `Decimal`.
`Decimal<S>`	`divide(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)`.
`Decimal<S>`	`divide(Decimal<S> divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)`.
`Decimal<S>`	`divide(Decimal<S> divisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / divisor)`.
`Decimal<S>`	`divide(double divisor)` Returns a `Decimal` whose value is `(this / divisor)` after converting the given `double` argument into a Decimal value of the same scale as `this` Decimal.
`Decimal<S>`	`divide(double divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)` after converting the given `double` argument into a Decimal value of the same scale as `this` Decimal.
`Decimal<S>`	`divide(long divisor)` Returns a `Decimal` whose value is `(this / divisor)`.
`Decimal<S>`	`divide(long divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)`.
`Decimal<S>`	`divide(long divisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / divisor)`.
`Decimal<S>[]`	`divideAndRemainder(Decimal<S> divisor)` Returns a two-element `Decimal` array containing the result of `divideToIntegralValue` followed by the result of `remainder` on the two operands.
`Decimal<S>[]`	`divideAndRemainder(Decimal<S> divisor, OverflowMode overflowMode)` Returns a two-element `Decimal` array containing the result of `divideToIntegralValue` followed by the result of `remainder` on the two operands.
`Decimal<S>`	`divideBy(Decimal<?> divisor)` Returns a `Decimal` whose value is `(this / divisor)`.
`Decimal<S>`	`divideBy(Decimal<?> divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)`.
`Decimal<S>`	`divideBy(Decimal<?> divisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / divisor)`.
`Decimal<S>`	`divideByPowerOfTen(int n)` Returns a `Decimal` whose value is `(this / 10ⁿ)` .
`Decimal<S>`	`divideByPowerOfTen(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / 10ⁿ)` .
`Decimal<S>`	`divideByPowerOfTen(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / 10ⁿ)` .
`Decimal<S>`	`divideExact(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)`, checking for lost information.
`Decimal<S>`	`divideToIntegralValue(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)` rounded down to the next integer.
`Decimal<S>`	`divideToIntegralValue(Decimal<S> divisor, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this / divisor)` rounded down to the next integer.
`long`	`divideToLongValue(Decimal<S> divisor)` Returns a `Decimal` whose value `(this / divisor)` rounded down to the next `long` value.
`long`	`divideToLongValue(Decimal<S> divisor, OverflowMode overflowMode)` Returns a `Decimal` whose value `(this / divisor)` rounded down to the next `long` value.
`Decimal<S>`	`divideTruncate(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)` rounded down.
`Decimal<S>`	`divideUnscaled(long unscaledDivisor)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))` with the `scale` of this Decimal.
`Decimal<S>`	`divideUnscaled(long unscaledDivisor, int scale)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))`.
`Decimal<S>`	`divideUnscaled(long unscaledDivisor, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))`.
`Decimal<S>`	`divideUnscaled(long unscaledDivisor, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))`.
`Decimal<S>`	`divideUnscaled(long unscaledDivisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))` with the `scale` of this Decimal.
`Decimal<S>`	`divideUnscaled(long unscaledDivisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))` with the `scale` of this Decimal.
`double`	`doubleValue()` Converts this `Decimal` to a `double`.
`double`	`doubleValue(RoundingMode roundingMode)` Converts this `Decimal` to a `double` using the specified rounding mode if the Decimal value can not be exactly represented as a double value.
`boolean`	`equals(Object obj)` Compares this Decimal to the specified object.
`float`	`floatValue()` Converts this `Decimal` to a `float`.
`float`	`floatValue(RoundingMode roundingMode)` Converts this `Decimal` to a `float` using the specified rounding mode if the Decimal value can not be exactly represented as a float value.
`Decimal<S>`	`fractionalPart()` Returns a `Decimal` whose value represents the fractional part of `(this)` value.
`DecimalFactory<S>`	`getFactory()` Returns the factory that can be used to create other Decimal values of the same scale as `this` Decimal.
`int`	`getScale()` Returns the scale associated with this Decimal.
`S`	`getScaleMetrics()` Returns the metrics associated with the scale of this Decimal.
`int`	`hashCode()` Returns a hash code for this `Decimal`.
`Decimal<S>`	`integralPart()` Returns a `Decimal` whose value represents the integral part of `this` Decimal.
`int`	`intValue()` Converts this `Decimal` to an `int`.
`int`	`intValueExact()` Converts this `Decimal` to an `int`, checking for lost information.
`Decimal<S>`	`invert()` Returns a `Decimal` whose value is `(1 / this)`.
`Decimal<S>`	`invert(RoundingMode roundingMode)` Returns a `Decimal` whose value is `(1 / this)`.
`Decimal<S>`	`invert(TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(1 / this)`.
`boolean`	`isBetweenZeroAndMinusOne()` Returns true if this `Decimal` is between zero (inclusive) and minus one (exclusive).
`boolean`	`isBetweenZeroAndOne()` Returns true if this `Decimal` is between zero (inclusive) and one (exclusive).
`boolean`	`isEqualTo(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if the two are numerically equal.
`boolean`	`isEqualToNumerically(Decimal<?> other)` Compares this `Decimal` with the specified `Decimal` and returns true if the two are numerically equal.
`boolean`	`isGreaterThan(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if this Decimal is numerically greater than `other`.
`boolean`	`isGreaterThanOrEqualTo(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if this Decimal is numerically greater than or equal to `other`.
`boolean`	`isIntegral()` Returns true if this `Decimal` number is integral, or equivalently if its `fractional part` is zero.
`boolean`	`isIntegralPartZero()` Returns true if the `integral part` of this `Decimal` number is zero.
`boolean`	`isLessThan(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if this Decimal is numerically less than `other`.
`boolean`	`isLessThanOrEqualTo(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if this Decimal is numerically less than or equal to `other`.
`boolean`	`isMinusOne()` Returns true if this `Decimal` is minus one.
`boolean`	`isNegative()` Returns true if this `Decimal` is negative.
`boolean`	`isNonNegative()` Returns true if this `Decimal` is not negative.
`boolean`	`isNonPositive()` Returns true if this `Decimal` is not positive.
`boolean`	`isOne()` Returns true if this `Decimal` is one.
`boolean`	`isPositive()` Returns true if this `Decimal` is strictly positive.
`boolean`	`isUlp()` Returns true if this `Decimal` is equal to the smallest positive number representable by a Decimal with the current `scale`.
`boolean`	`isZero()` Returns true if this `Decimal` is zero.
`long`	`longValue()` Converts this `Decimal` to a `long`.
`long`	`longValue(RoundingMode roundingMode)` Converts this `Decimal` to a `long` using the specified rounding mode if necessary.
`long`	`longValueExact()` Converts this `Decimal` to a `long`, checking for lost information.
`Decimal<S>`	`max(Decimal<S> val)` Returns the maximum of this `Decimal` and `val`.
`Decimal<S>`	`min(Decimal<S> val)` Returns the minimum of this `Decimal` and `val`.
`Decimal<S>`	`multiply(Decimal<S> multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`Decimal<S>`	`multiply(Decimal<S> multiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`Decimal<S>`	`multiply(Decimal<S> multiplicand, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`Decimal<S>`	`multiply(double multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)` after converting the given `double` argument into a Decimal value of the same scale as `this` Decimal.
`Decimal<S>`	`multiply(double multiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * multiplicand)` after converting the given `double` argument into a Decimal value of the same scale as `this` Decimal.
`Decimal<S>`	`multiply(long multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`Decimal<S>`	`multiply(long multiplicand, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`Decimal<S>`	`multiplyBy(Decimal<?> multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`Decimal<S>`	`multiplyBy(Decimal<?> multiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`Decimal<S>`	`multiplyBy(Decimal<?> multiplicand, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`Decimal<S>`	`multiplyByPowerOfTen(int n)` Returns a `Decimal` whose value is `(this * 10ⁿ)` .
`Decimal<S>`	`multiplyByPowerOfTen(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * 10ⁿ)` .
`Decimal<S>`	`multiplyByPowerOfTen(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * 10ⁿ)` .
`Decimal<?>`	`multiplyExact(Decimal<?> multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`Decimal<S>`	`multiplyUnscaled(long unscaledMultiplicand)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)` with the `scale` of this Decimal.
`Decimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, int scale)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)`.
`Decimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)`.
`Decimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)`.
`Decimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)` with the `scale` of this Decimal.
`Decimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)` with the `scale` of this Decimal.
`Decimal<S>`	`negate()` Returns a `Decimal` whose value is `(-this)`.
`Decimal<S>`	`negate(OverflowMode overflowMode)` Returns a `Decimal` whose value is `(-this)`.
`Decimal<S>`	`pow(int n)` Returns a `Decimal` whose value is `(thisⁿ)` using default `HALF_UP` rounding.
`Decimal<S>`	`pow(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(thisⁿ)` applying the specified `roundingMode`.
`Decimal<S>`	`pow(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(thisⁿ)` applying the `RoundingMode` specified by `truncationPolicy`.
`Decimal<S>`	`remainder(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this % divisor)`.
`Decimal<S>`	`round(int precision)` Returns a `Decimal` value rounded to the specified `precision` using `HALF_UP` rounding.
`Decimal<S>`	`round(int precision, RoundingMode roundingMode)` Returns a `Decimal` value rounded to the specified `precision` using the given rounding mode.
`Decimal<S>`	`round(int precision, TruncationPolicy truncationPolicy)` Returns a `Decimal` value rounded to the specified `precision` using the given truncation policy.
`Decimal<?>`	`scale(int scale)` Returns a `Decimal` value whose `scale` is changed to the given `scale` value.
`Decimal<?>`	`scale(int scale, RoundingMode roundingMode)` Returns a `Decimal` value whose `scale` is changed to the given `scale` value.
`<S extends ScaleMetrics> Decimal<S>`	`scale(S scaleMetrics)` Returns a `Decimal` value whose `scale` is changed to the scale given by the `scaleMetrics` argument.
`<S extends ScaleMetrics> Decimal<S>`	`scale(S scaleMetrics, RoundingMode roundingMode)` Returns a `Decimal` value whose `scale` is changed to the scale given by the `scaleMetrics` argument.
`Decimal<S>`	`shiftLeft(int n)` Returns a `Decimal` whose value is `(this << n)`.
`Decimal<S>`	`shiftLeft(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this << n)`.
`Decimal<S>`	`shiftLeft(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this << n)`.
`Decimal<S>`	`shiftRight(int n)` Returns a BigInteger whose value is `(this >> n)`.
`Decimal<S>`	`shiftRight(int n, RoundingMode roundingMode)` Returns a BigInteger whose value is `(this >> n)`.
`Decimal<S>`	`shiftRight(int n, TruncationPolicy truncationPolicy)` Returns a BigInteger whose value is `(this >> n)`.
`short`	`shortValue()` Returns the value of this `Decimal` as a `short` after a narrowing primitive conversion.
`short`	`shortValueExact()` Converts this `Decimal` to a `short`, checking for lost information.
`int`	`signum()` Returns the signum function of this `Decimal`.
`Decimal<S>`	`sqrt()` Returns a `Decimal` whose value is the square root of `this` Decimal value.
`Decimal<S>`	`sqrt(RoundingMode roundingMode)` Returns a `Decimal` whose value is the square root of `this` Decimal value.
`Decimal<S>`	`square()` Returns a `Decimal` whose value is `(this²)`.
`Decimal<S>`	`square(RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this²)`.
`Decimal<S>`	`square(TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this²)`.
`Decimal<S>`	`subtract(Decimal<?> subtrahend, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this - subtrahend)` after converting the given `subtrahend` argument to the scale of `this` Decimal.
`Decimal<S>`	`subtract(Decimal<?> subtrahend, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this - subtrahend)` after converting the given `subtrahend` argument to the scale of `this` Decimal.
`Decimal<S>`	`subtract(Decimal<S> subtrahend)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`Decimal<S>`	`subtract(Decimal<S> subtrahend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`Decimal<S>`	`subtract(double subtrahend)` Returns a `Decimal` whose value is `(this - subtrahend)` after converting the given `double` argument into a Decimal value of the same scale as `this` Decimal.
`Decimal<S>`	`subtract(double subtrahend, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this - subtrahend)` after converting the given `double` argument into a Decimal value of the same scale as `this` Decimal.
`Decimal<S>`	`subtract(long subtrahend)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`Decimal<S>`	`subtract(long subtrahend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`Decimal<S>`	`subtractSquared(Decimal<S> value)` Returns a `Decimal` whose value is `(this - value²)`.
`Decimal<S>`	`subtractSquared(Decimal<S> value, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this - value²)`.
`Decimal<S>`	`subtractSquared(Decimal<S> value, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this - value²)`.
`Decimal<S>`	`subtractUnscaled(long unscaledSubtrahend)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)` with the `scale` of this Decimal.
`Decimal<S>`	`subtractUnscaled(long unscaledSubtrahend, int scale)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)`.
`Decimal<S>`	`subtractUnscaled(long unscaledSubtrahend, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)`.
`Decimal<S>`	`subtractUnscaled(long unscaledSubtrahend, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)`.
`Decimal<S>`	`subtractUnscaled(long unscaledSubtrahend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)` with the `scale` of this Decimal.
`BigDecimal`	`toBigDecimal()` Converts this `Decimal` to a `BigDecimal` using the same `scale` as this Decimal value.
`BigDecimal`	`toBigDecimal(int scale, RoundingMode roundingMode)` Returns a `BigDecimal` value of the given scale using the specified rounding mode if necessary.
`BigInteger`	`toBigInteger()` Converts this `Decimal` to a `BigInteger`.
`BigInteger`	`toBigInteger(RoundingMode roundingMode)` Converts this `Decimal` to a `BigInteger` value using the specified rounding mode if necessary.
`BigInteger`	`toBigIntegerExact()` Converts this `Decimal` to a `BigInteger`, checking for lost information.
`ImmutableDecimal<S>`	`toImmutableDecimal()` If this `Decimal` value is already an `ImmutableDecimal` it is simply returned.
`MutableDecimal<S>`	`toMutableDecimal()` If this `Decimal` value is already a `MutableDecimal` it is simply returned.
`String`	`toString()` Returns a string representation of this `Decimal` object as fixed-point Decimal always showing all Decimal places (also trailing zeros) and a leading sign character if negative.
`long`	`unscaledValue()` Returns the unscaled value underlying this `Decimal`.

- Method Detail
  - getScaleMetrics
```
S getScaleMetrics()
```
    Returns the metrics associated with the scale of this Decimal. Scale defines the number of fraction digits and the scale factor applied to the long value underlying this Decimal.
    
    Returns:
    the scale metrics object
    See Also:
    ScaleMetrics.getScale(), ScaleMetrics.getScaleFactor()
  - getScale
```
int getScale()
```
    Returns the scale associated with this Decimal. The scale defines the number of fraction digits and the scale factor applied to the long value underlying this Decimal.
    If the scale is f then the value represented by a Decimal instance is (unscaledValue × 10^-f).
    This method is a shortcut for getScaleMetrics().getScale().
    
    Returns:
    the scale
    See Also:
    getScaleMetrics(), ScaleMetrics.getScale(), unscaledValue()
  - unscaledValue
```
long unscaledValue()
```
    Returns the unscaled value underlying this Decimal. This Decimal is (unscaledValue × 10^-f) with f representing the scale, hence the returned value equals (10^f × this).
    
    Returns:
    the unscaled numeric value, the same as this Decimal but without applying the scale factor
    See Also:
    getScale(), ScaleMetrics.getScaleFactor()
  - getFactory
```
DecimalFactory<S> getFactory()
```
    Returns the factory that can be used to create other Decimal values of the same scale as this Decimal.
    
    Returns:
    the factory to create other Decimal values of the same scale as this Decimal
  - integralPart
```
Decimal<S> integralPart()
```
    Returns a Decimal whose value represents the integral part of this Decimal. The integral part corresponds to digits at the left of the decimal point. The result is this Decimal rounded to precision zero with RoundingMode.DOWN.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the operation.
    
    Returns:
    ⌊this⌋ for non-negative and ⌈this⌉ for negative values
    See Also:
    fractionalPart(), isIntegral(), isIntegralPartZero(), round(int, RoundingMode)
  - fractionalPart
```
Decimal<S> fractionalPart()
```
    Returns a Decimal whose value represents the fractional part of (this) value. The fractional part corresponds to digits at the right of the decimal point. The result is this minus the integral part of this Decimal.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the operation.
    
    Returns:
    this-integralPart() which is always less than one and greater than minus one
    See Also:
    integralPart(), isIntegral(), isIntegralPartZero()
  - byteValue
```
byte byteValue()
```
    Returns the value of this Decimal as a byte after a narrowing primitive conversion.
    
    Returns:
    this Decimal converted to an byte.
    See Also:
    Number.byteValue(), byteValueExact()
  - byteValueExact
```
byte byteValueExact()
```
    Converts this Decimal to a byte, checking for lost information. If this Decimal has a nonzero fractional part or is out of the possible range for a byte result then an ArithmeticException is thrown.
    
    Returns:
    this Decimal converted to a byte.
    
    Throws:
    
    ArithmeticException - if this has a nonzero fractional part, or will not fit in a byte.
    See Also:
    byteValue()
  - shortValue
```
short shortValue()
```
    Returns the value of this Decimal as a short after a narrowing primitive conversion.
    
    Returns:
    this Decimal converted to an short.
    See Also:
    Number.shortValue(), shortValueExact()
  - shortValueExact
```
short shortValueExact()
```
    Converts this Decimal to a short, checking for lost information. If this Decimal has a nonzero fractional part or is out of the possible range for a short result then an ArithmeticException is thrown.
    
    Returns:
    this Decimal converted to a short.
    
    Throws:
    
    ArithmeticException - if this has a nonzero fractional part, or will not fit in a short.
    See Also:
    shortValue()
  - intValue
```
int intValue()
```
    Converts this Decimal to an int. This conversion is analogous to the narrowing primitive conversion from double to short as defined in section 5.1.3 of The Java™ Language Specification: any fractional part of this Decimal will be discarded, and if the resulting "long" is too big to fit in an int, only the low-order 32 bits are returned. Note that this conversion can lose information about the overall magnitude and precision of this Decimal value as well as return a result with the opposite sign.
    
    Returns:
    this Decimal converted to an int.
    See Also:
    Number.intValue(), intValueExact()
  - intValueExact
```
int intValueExact()
```
    Converts this Decimal to an int, checking for lost information. If this Decimal has a nonzero fractional part or is out of the possible range for an int result then an ArithmeticException is thrown.
    
    Returns:
    this Decimal converted to an int.
    
    Throws:
    
    ArithmeticException - if this has a nonzero fractional part, or will not fit in an int.
    See Also:
    intValue()
  - longValue
```
long longValue()
```
    Converts this Decimal to a long. This conversion is analogous to the narrowing primitive conversion from double to short as defined in section 5.1.3 of The Java™ Language Specification: any fractional part of this Decimal will be discarded. Note that this conversion can lose information about the precision of the Decimal value.
    Note that this method uses RoundingMode.DOWN as defined by The Java™Language Specification. Other rounding modes are supported via longValue(RoundingMode).
    
    Returns:
    this Decimal converted to a long.
    See Also:
    Number.longValue(), longValue(RoundingMode), longValueExact()
  - longValueExact
```
long longValueExact()
```
    Converts this Decimal to a long, checking for lost information. If this Decimal has a nonzero fractional part or is out of the possible range for a long result then an ArithmeticException is thrown.
    
    Returns:
    this Decimal converted to a long.
    
    Throws:
    
    ArithmeticException - if this has a nonzero fractional part
    See Also:
    longValue(), longValue(RoundingMode)
  - floatValue
```
float floatValue()
```
    Converts this Decimal to a float. This conversion is similar to the narrowing primitive conversion from double to float as defined in section 5.1.3 of The Java™ Language Specification. Note that this conversion can lose information about the precision of the Decimal value.
    Note that this method uses RoundingMode.HALF_EVEN as defined by The Java™Language Specification. Other rounding modes are supported via floatValue(RoundingMode).
    
    Returns:
    this Decimal converted to a float.
    See Also:
    Number.floatValue(), floatValue(RoundingMode)
  - doubleValue
```
double doubleValue()
```
    Converts this Decimal to a double. This conversion is similar to the narrowing primitive conversion from double to float as defined in section 5.1.3 of The Java™ Language Specification. Note that this conversion can lose information about the precision of the Decimal value.
    Note that this method uses RoundingMode.HALF_EVEN as defined by The Java™Language Specification. Other rounding modes are supported via doubleValue(RoundingMode).
    
    Returns:
    this Decimal converted to a double.
    See Also:
    Number.doubleValue(), doubleValue(RoundingMode)
  - toBigInteger
```
BigInteger toBigInteger()
```
    Converts this Decimal to a BigInteger. This conversion is analogous to the narrowing primitive conversion from double to long as defined in section 5.1.3 of The Java™ Language Specification: any fractional part of this Decimal will be discarded. Note that this conversion can lose information about the precision of the Decimal value.
    To have an exception thrown if the conversion is inexact (in other words if a nonzero fractional part is discarded), use the toBigIntegerExact() method.
    Note that this method uses RoundingMode.DOWN to be consistent with other integer conversion methods as defined by The Java™Language Specification. Other rounding modes are supported via toBigInteger(RoundingMode).
    
    Returns:
    this Decimal converted to a BigInteger.
    See Also:
    toBigIntegerExact(), toBigInteger(RoundingMode), longValue()
  - toBigIntegerExact
```
BigInteger toBigIntegerExact()
```
    Converts this Decimal to a BigInteger, checking for lost information. An exception is thrown if this Decimal has a nonzero fractional part.
    
    Returns:
    this Decimal converted to a BigInteger.
    
    Throws:
    
    ArithmeticException - if this has a nonzero fractional part.
    See Also:
    toBigInteger(), toBigInteger(RoundingMode), longValueExact()
  - toBigDecimal
```
BigDecimal toBigDecimal()
```
    Converts this Decimal to a BigDecimal using the same scale as this Decimal value.
    
    Returns:
    this Decimal converted to a BigDecimal with the same scale as this Decimal value.
    See Also:
    toBigDecimal(int, RoundingMode)
  - toImmutableDecimal
```
ImmutableDecimal<S> toImmutableDecimal()
```
    If this Decimal value is already an ImmutableDecimal it is simply returned. Otherwise a new immutable value with the same scale and numerical value as this Decimal is created and returned.
    
    Returns:
    this if immutable and a new ImmutableDecimal with the same scale and value as this Decimal otherwise
  - toMutableDecimal
```
MutableDecimal<S> toMutableDecimal()
```
    If this Decimal value is already a MutableDecimal it is simply returned. Otherwise a new mutable value with the same scale and numerical value as this Decimal is created and returned.
    
    Returns:
    this if mutable and a new MutableDecimal with the same scale and value as this Decimal otherwise
  - longValue
```
long longValue(RoundingMode roundingMode)
```
    Converts this Decimal to a long using the specified rounding mode if necessary. Rounding is applied if the Decimal value can not be represented as a long value, that is, if it has a nonzero fractional part. Note that this conversion can lose information about the precision of the Decimal value.
    
    Parameters:
    roundingMode - the rounding mode to apply when rounding is necessary to convert this Decimal into a long
    
    Returns:
    this Decimal converted to a long.
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
    See Also:
    longValue(), longValueExact()
  - floatValue
```
float floatValue(RoundingMode roundingMode)
```
    Converts this Decimal to a float using the specified rounding mode if the Decimal value can not be exactly represented as a float value. Note that this conversion can lose information about the precision of the Decimal value.
    
    Parameters:
    roundingMode - the rounding mode to apply when rounding is necessary to convert this Decimal into a float value
    
    Returns:
    this Decimal converted to a float.
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
    See Also:
    floatValue()
  - doubleValue
```
double doubleValue(RoundingMode roundingMode)
```
    Converts this Decimal to a double using the specified rounding mode if the Decimal value can not be exactly represented as a double value. Note that this conversion can lose information about the precision of the Decimal value.
    
    Parameters:
    roundingMode - the rounding mode to apply when rounding is necessary to convert this Decimal into a double value
    
    Returns:
    this Decimal converted to a double.
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
    See Also:
    doubleValue()
  - toBigInteger
```
BigInteger toBigInteger(RoundingMode roundingMode)
```
    Converts this Decimal to a BigInteger value using the specified rounding mode if necessary. Rounding is applied if the Decimal value can not be represented as a BigInteger, that is, if it has a nonzero fractional part. Note that this conversion can lose information about the precision of the Decimal value.
    
    Parameters:
    roundingMode - the rounding mode to apply when rounding is necessary to convert this Decimal into a BigInteger
    
    Returns:
    this Decimal converted to a BigInteger.
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
    See Also:
    toBigInteger(), toBigIntegerExact()
  - toBigDecimal
```
BigDecimal toBigDecimal(int scale,
                      RoundingMode roundingMode)
```
    Returns a BigDecimal value of the given scale using the specified rounding mode if necessary.
    
    Parameters:
    scale - the scale used for the returned BigDecimal
    roundingMode - the rounding mode to apply when rounding is necessary to convert from the this Decimal's scale to the target scale
    
    Returns:
    a BigDecimal instance of the specified scale
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
    See Also:
    toBigDecimal()
  - round
```
Decimal<S> round(int precision)
```
    Returns a Decimal value rounded to the specified precision using HALF_UP rounding. If an overflow occurs due to the rounding operation, the result is silently truncated.
    Note that contrary to the scale(..) operations this method does not change the scale of the value --- extra digits are simply zeroised.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the rounded value.
    Examples and special cases:
    - precision = 0
      value is rounded to an integer value
    - precision = 2
      value is rounded to the second digit after the decimal point
    - precision = -3
      value is rounded to the thousands
    - precision ≥ scale
      values is returned unchanged
    - precision < scale - 18
      IllegalArgumentException is thrown
    Parameters:
    precision - the precision to use for the rounding, for instance 2 to round to the second digit after the decimal point; must be at least (scale - 18)
    
    Returns:
    a Decimal instance rounded to the given precision
    
    Throws:
    
    IllegalArgumentException - if precision < scale - 18
    See Also:
    round(int, RoundingMode), round(int, TruncationPolicy), scale(int)
  - round
```
Decimal<S> round(int precision,
               RoundingMode roundingMode)
```
    Returns a Decimal value rounded to the specified precision using the given rounding mode. If an overflow occurs due to the rounding operation, the result is silently truncated.
    Note that contrary to the scale(..) operations this method does not change the scale of the value --- extra digits are simply zeroised.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the rounded value.
    Examples and special cases:
    - precision = 0
      value is rounded to an integer value
    - precision = 2
      value is rounded to the second digit after the decimal point
    - precision = -3
      value is rounded to the thousands
    - precision ≥ scale
      values is returned unchanged
    - precision < scale - 18
      IllegalArgumentException is thrown
    Parameters:
    precision - the precision to use for the rounding, for instance 2 to round to the second digit after the decimal point; must be at least (scale - 18)
    roundingMode - the rounding mode to apply when rounding to the desired precision
    
    Returns:
    a Decimal instance rounded to the given precision
    
    Throws:
    
    IllegalArgumentException - if precision < scale - 18
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
    See Also:
    round(int), round(int, TruncationPolicy), scale(int, RoundingMode)
  - round
```
Decimal<S> round(int precision,
               TruncationPolicy truncationPolicy)
```
    Returns a Decimal value rounded to the specified precision using the given truncation policy.
    Note that contrary to the scale(..) operations this method does not change the scale of the value --- extra digits are simply zeroised.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the rounded value.
    Examples and special cases:
    - precision = 0
      value is rounded to an integer value
    - precision = 2
      value is rounded to the second digit after the decimal point
    - precision = -3
      value is rounded to the thousands
    - precision ≥ scale
      values is returned unchanged
    - precision < scale - 18
      IllegalArgumentException is thrown
    Parameters:
    precision - the precision to use for the rounding, for instance 2 to round to the second digit after the decimal point; must be at least (scale - 18)
    truncationPolicy - the truncation policy defining RoundingMode and OverflowMode for the rounding operation
    
    Returns:
    a Decimal instance rounded to the given precision
    
    Throws:
    
    IllegalArgumentException - if precision < scale - 18
    
    ArithmeticException - if truncationPolicy specifies RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
    See Also:
    round(int), round(int, RoundingMode), scale(int, RoundingMode)
  - scale
```
Decimal<?> scale(int scale)
```
    Returns a Decimal value whose scale is changed to the given scale value. HALF_UP rounding is used if the scale change involves rounding.
    An exception is thrown if the scale conversion leads to an overflow.
    
    Parameters:
    scale - the scale to use for the result, must be in [0,18]
    
    Returns:
    a Decimal instance with the given new scale
    
    Throws:
    
    IllegalArgumentException - if scale < 0 or scale > 18
    
    ArithmeticException - if an overflow occurs during the scale conversion
    See Also:
    scale(ScaleMetrics), scale(int, RoundingMode), round(int)
  - scale
```
<S extends ScaleMetrics> Decimal<S> scale(S scaleMetrics)
```
    Returns a Decimal value whose scale is changed to the scale given by the scaleMetrics argument. HALF_UP rounding is used if the scale change involves rounding.
    An exception is thrown if the scale conversion leads to an overflow.
    
    Type Parameters:
    S - the scale metrics type of the result
    Parameters:
    scaleMetrics - the scale metrics to use for the result
    
    Returns:
    a Decimal instance with the given new scale metrics
    
    Throws:
    
    ArithmeticException - if an overflow occurs during the scale conversion
    See Also:
    scale(int), scale(ScaleMetrics, RoundingMode), round(int)
  - scale
```
Decimal<?> scale(int scale,
               RoundingMode roundingMode)
```
    Returns a Decimal value whose scale is changed to the given scale value. The specified roundingMode is used if the scale change involves rounding.
    An exception is thrown if the scale conversion leads to an overflow.
    
    Parameters:
    scale - the scale to use for the result, must be in [0,18]
    roundingMode - the rounding mode to apply if the scale change involves rounding
    
    Returns:
    a Decimal instance with the given new scale
    
    Throws:
    
    IllegalArgumentException - if scale < 0 or scale > 18
    
    ArithmeticException - if roundingMode is UNNESSESSARY and rounding is necessary, or if an overflow occurs during the scale conversion
    See Also:
    scale(int), scale(ScaleMetrics, RoundingMode), round(int, RoundingMode)
  - scale
```
<S extends ScaleMetrics> Decimal<S> scale(S scaleMetrics,
                                        RoundingMode roundingMode)
```
    Returns a Decimal value whose scale is changed to the scale given by the scaleMetrics argument. The specified roundingMode is used if the scale change involves rounding.
    An exception is thrown if the scale conversion leads to an overflow.
    
    Type Parameters:
    S - the scale metrics type of the result
    Parameters:
    scaleMetrics - the scale metrics to use for the result
    roundingMode - the rounding mode to apply if the scale change involves rounding
    
    Returns:
    a Decimal instance with the given new scale metrics
    
    Throws:
    
    ArithmeticException - if roundingMode is UNNESSESSARY and rounding is necessary, or if an overflow occurs during the scale conversion
    See Also:
    scale(ScaleMetrics), scale(int, RoundingMode), round(int, RoundingMode)
  - add
```
Decimal<S> add(Decimal<S> augend)
```
    Returns a Decimal whose value is (this + augend). If the addition causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    augend - value to be added to this Decimal
    
    Returns:
    this + augend
  - add
```
Decimal<S> add(Decimal<S> augend,
             OverflowMode overflowMode)
```
    Returns a Decimal whose value is (this + augend). The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    augend - value to be added to this Decimal
    overflowMode - the overflow mode to apply if the addition leads to an overflow
    
    Returns:
    this + augend
    
    Throws:
    
    ArithmeticException - if overflowMode==CHECKED and an overflow occurs
  - add
```
Decimal<S> add(Decimal<?> augend,
             RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this + augend). The result of the addition is rounded if necessary using the specified roundingMode. Overflows during scale conversion or subtraction are silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    augend - value to be added to this Decimal
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    round_{HALF_UP}(this + augend)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - add
```
Decimal<S> add(Decimal<?> augend,
             TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this + augend). The result of the addition is rounded if necessary using the RoundingMode defined by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if the operation causes an overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    augend - value to be added to this Decimal
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs during the addition
    
    Returns:
    round(this + augend)
    
    Throws:
    
    ArithmeticException - if truncationPolicy specifies RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - add
```
Decimal<S> add(long augend)
```
    Returns a Decimal whose value is (this + augend) after converting the given long value to the scale of this Decimal. If the operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    augend - long value to be added to this Decimal
    
    Returns:
    this + augend
  - add
```
Decimal<S> add(long augend,
             OverflowMode overflowMode)
```
    Returns a Decimal whose value is (this + augend) after converting the given long value to the scale of this Decimal. The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    augend - long value to be added to this Decimal
    overflowMode - the overflow mode to apply if the addition leads to an overflow
    
    Returns:
    this + augend
    
    Throws:
    
    ArithmeticException - if overflowMode==CHECKED and an overflow occurs
  - add
```
Decimal<S> add(double augend)
```
    Returns a Decimal whose value is (this + augend) after converting the given double argument into a Decimal value of the same scale as this Decimal. If rounding is necessary, HALF_UP rounding mode is used and applied during the conversion step before the addition operation. Overflows due to conversion or addition result in an exception.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    augend - value to be added to this Decimal
    
    Returns:
    this + round_{HALF_UP}(augend)
    
    Throws:
    
    IllegalArgumentException - if augend is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal
    
    ArithmeticException - if an overflow occurs during the addition operation
  - add
```
Decimal<S> add(double augend,
             RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this + augend) after converting the given double argument into a Decimal value of the same scale as this Decimal. If rounding is necessary, the specified roundingMode is used and applied during the conversion step before the addition operation. Overflows due to conversion or addition result in an exception.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    augend - value to be added to this Decimal
    roundingMode - the rounding mode to apply if the augend argument needs to be rounded when converted into a Decimal number of the same scale as this Decimal
    
    Returns:
    this + round(augend)
    
    Throws:
    
    IllegalArgumentException - if augend is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary or if an overflow occurs during the addition operation
  - addUnscaled
```
Decimal<S> addUnscaled(long unscaledAugend)
```
    Returns a Decimal whose value is (this + unscaledAugend × 10^-scale) with the scale of this Decimal. If the addition causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    unscaledAugend - value to be added to this Decimal
    
    Returns:
    round_{HALF_UP}(this + unscaledAugend × 10^-scale)
  - addUnscaled
```
Decimal<S> addUnscaled(long unscaledAugend,
                     OverflowMode overflowMode)
```
    Returns a Decimal whose value is (this + unscaledAugend × 10^-scale) with the scale of this Decimal. The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    unscaledAugend - value to be added to this Decimal
    overflowMode - the overflow mode to apply if the addition leads to an overflow
    
    Returns:
    round(this + unscaledAugend × 10^-scale)
    
    Throws:
    
    ArithmeticException - if overflowMode==CHECKED and an overflow occurs
  - addUnscaled
```
Decimal<S> addUnscaled(long unscaledAugend,
                     int scale)
```
    Returns a Decimal whose value is (this + unscaledAugend × 10^-scale). The result of the addition is rounded if necessary using HALF_UP rounding. If the operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    unscaledAugend - value to be added to this Decimal
    scale - the scale to apply to unscaledAugend, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    
    Returns:
    round_{HALF_UP}(this + unscaledAugend × 10^-scale)
  - addUnscaled
```
Decimal<S> addUnscaled(long unscaledAugend,
                     int scale,
                     RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this + unscaledAugend × 10^-scale). The result of the addition is rounded if necessary using the specified roundingMode. If the operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    unscaledAugend - value to be added to this Decimal
    scale - the scale to apply to unscaledAugend, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    round(this + unscaledAugend × 10^-scale)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - addUnscaled
```
Decimal<S> addUnscaled(long unscaledAugend,
                     int scale,
                     TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this + unscaledAugend × 10^-scale). The result of the addition is rounded if necessary using the RoundingMode defined by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if the operation causes an overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    unscaledAugend - value to be added to this Decimal
    scale - the scale to apply to unscaledAugend, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs during the addition
    
    Returns:
    round(this + unscaledAugend × 10^-scale)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - addSquared
```
Decimal<S> addSquared(Decimal<S> value)
```
    Returns a Decimal whose value is (this + value²). The squared value is rounded before the addition if necessary using default HALF_UP rounding. Overflows during squaring or addition are silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    value - value to be squared and added to this Decimal
    
    Returns:
    this + round_{HALF_UP}(value*value)
  - addSquared
```
Decimal<S> addSquared(Decimal<S> value,
                    RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this + value²). The squared value is rounded before the addition if necessary using the specified roundingMode. Overflows during squaring or addition are silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    value - value to be squared and added to this Decimal
    roundingMode - the rounding mode to apply if necessary when squaring the value
    
    Returns:
    this + round(value*value)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - addSquared
```
Decimal<S> addSquared(Decimal<S> value,
                    TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this + value²). The squared value is rounded before the addition if necessary using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during square or add operation.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the addition.
    
    Parameters:
    value - value to be squared and added to this Decimal
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary when squaring the value or if an overflow occurs during the square or add operation
    
    Returns:
    this + round(value*value)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - subtract
```
Decimal<S> subtract(Decimal<S> subtrahend)
```
    Returns a Decimal whose value is (this - subtrahend). If the subtraction causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    subtrahend - value to be subtracted from this Decimal
    
    Returns:
    this - subtrahend
  - subtract
```
Decimal<S> subtract(Decimal<S> subtrahend,
                  OverflowMode overflowMode)
```
    Returns a Decimal whose value is (this - subtrahend). The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    subtrahend - value to be subtracted from this Decimal
    overflowMode - the overflow mode to apply if the subtraction leads to an overflow
    
    Returns:
    this - subtrahend
    
    Throws:
    
    ArithmeticException - if overflowMode==CHECKED and an overflow occurs
  - subtract
```
Decimal<S> subtract(Decimal<?> subtrahend,
                  RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this - subtrahend) after converting the given subtrahend argument to the scale of this Decimal. The result of the subtraction is rounded if necessary using the specified roundingMode. Overflows during scale conversion or subtraction are silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    subtrahend - value to be subtracted from this Decimal
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    round_{HALF_UP}(this - subtrahend)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - subtract
```
Decimal<S> subtract(Decimal<?> subtrahend,
                  TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this - subtrahend) after converting the given subtrahend argument to the scale of this Decimal. The result of the subtraction is rounded if necessary using the RoundingMode defined by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if the operation causes an overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    subtrahend - value to be subtracted from this Decimal
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs during the subtraction
    
    Returns:
    round(this - subtrahend)
    
    Throws:
    
    ArithmeticException - if truncationPolicy specifies RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - subtract
```
Decimal<S> subtract(long subtrahend)
```
    Returns a Decimal whose value is (this - subtrahend). If the subtraction causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    subtrahend - long value to be subtracted from this Decimal
    
    Returns:
    this - subtrahend
  - subtract
```
Decimal<S> subtract(long subtrahend,
                  OverflowMode overflowMode)
```
    Returns a Decimal whose value is (this - subtrahend). The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    subtrahend - long value to be subtracted from this Decimal
    overflowMode - the overflow mode to apply if the subtraction leads to an overflow
    
    Returns:
    this - subtrahend
    
    Throws:
    
    ArithmeticException - if overflowMode==CHECKED and an overflow occurs
  - subtract
```
Decimal<S> subtract(double subtrahend)
```
    Returns a Decimal whose value is (this - subtrahend) after converting the given double argument into a Decimal value of the same scale as this Decimal. If rounding is necessary, HALF_UP rounding mode is used and applied during the conversion step before the subtraction operation. Overflows due to conversion or subtraction result in an exception.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    subtrahend - value to be subtracted from this Decimal
    
    Returns:
    this - round_{HALF_UP}(subtrahend)
    
    Throws:
    
    IllegalArgumentException - if subtrahend is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal
    
    ArithmeticException - if an overflow occurs during the subtraction operation
  - subtract
```
Decimal<S> subtract(double subtrahend,
                  RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this - subtrahend) after converting the given double argument into a Decimal value of the same scale as this Decimal. If rounding is necessary, the specified roundingMode is used and applied during the conversion step before the subtraction operation. Overflows due to conversion or subtraction result in an exception.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    subtrahend - value to be subtracted from this Decimal
    roundingMode - the rounding mode to apply if the subtrahend argument needs to be rounded when converted into a Decimal number of the same scale as this Decimal
    
    Returns:
    this - round(subtrahend)
    
    Throws:
    
    IllegalArgumentException - if subtrahend is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary or if an overflow occurs during the subtraction operation
  - subtractUnscaled
```
Decimal<S> subtractUnscaled(long unscaledSubtrahend)
```
    Returns a Decimal whose value is (this - unscaledSubtrahend × 10^-scale) with the scale of this Decimal. If the subtraction causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    unscaledSubtrahend - value to be subtracted from this Decimal
    
    Returns:
    this - unscaledSubtrahend × 10^-scale
  - subtractUnscaled
```
Decimal<S> subtractUnscaled(long unscaledSubtrahend,
                          OverflowMode overflowMode)
```
    Returns a Decimal whose value is (this - unscaledSubtrahend × 10^-scale) with the scale of this Decimal. The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    unscaledSubtrahend - value to be subtracted from this Decimal
    overflowMode - the overflow mode to apply if the subtraction leads to an overflow
    
    Returns:
    this - unscaledSubtrahend × 10^-scale
    
    Throws:
    
    ArithmeticException - if overflowMode==CHECKED and an overflow occurs
  - subtractUnscaled
```
Decimal<S> subtractUnscaled(long unscaledSubtrahend,
                          int scale)
```
    Returns a Decimal whose value is (this - unscaledSubtrahend × 10^-scale). The result of the subtraction is rounded if necessary using HALF_UP rounding. If the operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    unscaledSubtrahend - value to be subtracted from this Decimal
    scale - the scale to apply to unscaledSubtrahend, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    
    Returns:
    round_{HALF_UP}(this - unscaledSubtrahend × 10^-scale)
  - subtractUnscaled
```
Decimal<S> subtractUnscaled(long unscaledSubtrahend,
                          int scale,
                          RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this - unscaledSubtrahend × 10^-scale). The result of the subtraction is rounded if necessary using the specified roundingMode. If the operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    unscaledSubtrahend - value to be subtracted from this Decimal
    scale - the scale to apply to unscaledSubtrahend, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    round(this - unscaledSubtrahend × 10^-scale)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - subtractUnscaled
```
Decimal<S> subtractUnscaled(long unscaledSubtrahend,
                          int scale,
                          TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this - unscaledSubtrahend × 10^-scale). The result of the subtraction is rounded if necessary using the RoundingMode defined by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if the operation causes an overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    unscaledSubtrahend - value to be subtracted from this Decimal
    scale - the scale to apply to unscaledSubtrahend, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs during the subtraction
    
    Returns:
    round(this - unscaledSubtrahend × 10^-scale)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - subtractSquared
```
Decimal<S> subtractSquared(Decimal<S> value)
```
    Returns a Decimal whose value is (this - value²). The squared value is rounded before the subtraction if necessary using default HALF_UP rounding. Overflows during squaring or subtraction are silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    value - value to be squared and subtracted from this Decimal
    
    Returns:
    this - round_{HALF_UP}(value*value)
  - subtractSquared
```
Decimal<S> subtractSquared(Decimal<S> value,
                         RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this - value²). The squared value is rounded before the subtraction if necessary using the specified roundingMode. Overflows during squaring or subtraction are silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    value - value to be squared and subtracted from this Decimal
    roundingMode - the rounding mode to apply if necessary when squaring the value
    
    Returns:
    this - round(value*value)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - subtractSquared
```
Decimal<S> subtractSquared(Decimal<S> value,
                         TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this - value²). The squared value is rounded before the subtraction if necessary using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during square or subtract operation.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the subtraction.
    
    Parameters:
    value - value to be squared and subtracted from this Decimal
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary when squaring the value or if an overflow occurs during the square or subtract operation
    
    Returns:
    this - round(value*value)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - multiply
```
Decimal<S> multiply(Decimal<S> multiplicand)
```
    Returns a Decimal whose value is (this * multiplicand). The result is rounded to the scale of this Decimal using default HALF_UP rounding. If the multiplication causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * multiplicand)
  - multiply
```
Decimal<S> multiply(Decimal<S> multiplicand,
                  RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this * multiplicand). The result is rounded to the scale of this Decimal using the specified roundingMode. If the multiplication causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(this * multiplicand)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - multiply
```
Decimal<S> multiply(Decimal<S> multiplicand,
                  TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this * multiplicand). The result is rounded to the scale of this Decimal using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during the multiply operation.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this * multiplicand)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - multiplyBy
```
Decimal<S> multiplyBy(Decimal<?> multiplicand)
```
    Returns a Decimal whose value is (this * multiplicand). The result is rounded to the scale of this Decimal using HALF_UP rounding. If the multiplication causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * multiplicand)
  - multiplyBy
```
Decimal<S> multiplyBy(Decimal<?> multiplicand,
                    RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this * multiplicand). The result is rounded to the scale of this Decimal using the specified roundingMode. If the multiplication causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    round(this * multiplicand)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - multiplyBy
```
Decimal<S> multiplyBy(Decimal<?> multiplicand,
                    TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this * multiplicand). The result is rounded to the scale of this Decimal using the RoundingMode defined by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if the operation causes an overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this * multiplicand)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - multiplyExact
```
Decimal<?> multiplyExact(Decimal<?> multiplicand)
```
    Returns a Decimal whose value is (this * multiplicand). The scale of the returned value is the sum of the scales of this Decimal and the multiplicand argument. If the result scale exceeds 18, an IllegalArgumentException is thrown. An ArithmeticException is thrown if the product is out of the possible range for a Decimal with the result scale.
    Note that the result is always a new instance --- immutable if this Decimal is an ImmutableDecimal and mutable if it is a MutableDecimal.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    (this * multiplicand) with scale equal to the sum of scales of this and multiplicand
    
    Throws:
    
    IllegalArgumentException - if the sum of the scales of this Decimal and the multiplicand argument exceeds 18
    
    ArithmeticException - if an overflow occurs and product is out of the possible range for a Decimal with the result scale
  - multiply
```
Decimal<S> multiply(long multiplicand)
```
    Returns a Decimal whose value is (this * multiplicand). If the multiplication causes an overflow, the result is silently truncated.
    This method performs multiplication of this Decimal with a long value which is usually more efficient than multiplication of two Decimal values.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    (this * multiplicand)
  - multiply
```
Decimal<S> multiply(long multiplicand,
                  OverflowMode overflowMode)
```
    Returns a Decimal whose value is (this * multiplicand). The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    This method performs multiplication of this Decimal with a long value which is usually more efficient than multiplication of two Decimal values.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    overflowMode - the overflow mode to apply if the multiplication leads to an overflow
    
    Returns:
    (this * multiplicand)
    
    Throws:
    
    ArithmeticException - if overflowMode==CHECKED and an overflow occurs
  - multiply
```
Decimal<S> multiply(double multiplicand)
```
    Returns a Decimal whose value is (this * multiplicand) after converting the given double argument into a Decimal value of the same scale as this Decimal. HALF_UP rounding mode is used if necessary and applied twice during the conversion step before the multiplication and again when rounding the product to the scale of this Decimal. Overflows due to conversion or multiplication result in an exception.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * round_{HALF_UP}(multiplicand))
    
    Throws:
    
    IllegalArgumentException - if multiplicand is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal
    
    ArithmeticException - if an overflow occurs during the multiply operation
  - multiply
```
Decimal<S> multiply(double multiplicand,
                  RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this * multiplicand) after converting the given double argument into a Decimal value of the same scale as this Decimal. Rounding, if necessary, uses the specified roundingMode and is applied during the conversion step before the multiplication and again when rounding the product to the scale of this Decimal. Overflows due to conversion or multiplication result in an exception.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    roundingMode - the rounding mode to apply if the converted multiplicand or the resulting product needs to be rounded
    
    Returns:
    round(this * round(multiplicand))
    
    Throws:
    
    IllegalArgumentException - if multiplicand is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary or if an overflow occurs during the multiply operation
  - multiplyUnscaled
```
Decimal<S> multiplyUnscaled(long unscaledMultiplicand)
```
    Returns a Decimal whose value is (this * unscaledMultiplicand × 10^-scale) with the scale of this Decimal. The result is rounded to the scale of this Decimal using default HALF_UP rounding. If the multiplication causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    unscaledMultiplicand - factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * unscaledMultiplicand × 10^-scale)
  - multiplyUnscaled
```
Decimal<S> multiplyUnscaled(long unscaledMultiplicand,
                          RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this * unscaledMultiplicand × 10^-scale) with the scale of this Decimal. The result is rounded to the scale of this Decimal using the specified roundingMode. If the multiplication causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    unscaledMultiplicand - factor to multiply with this Decimal
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(this * unscaledMultiplicand × 10^-scale)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - multiplyUnscaled
```
Decimal<S> multiplyUnscaled(long unscaledMultiplicand,
                          TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this * unscaledMultiplicand × 10^-scale) with the scale of this Decimal. The result is rounded to the scale of this Decimal using the using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during the multiplication.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    unscaledMultiplicand - factor to multiply with this Decimal
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this * unscaledMultiplicand × 10^-scale)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - multiplyUnscaled
```
Decimal<S> multiplyUnscaled(long unscaledMultiplicand,
                          int scale)
```
    Returns a Decimal whose value is (this * unscaledMultiplicand × 10^-scale). The result of the multiplication is rounded to the scale of this Decimal using HALF_UP rounding. If the operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    unscaledMultiplicand - factor to multiply with this Decimal
    scale - the scale to apply to unscaledMultiplicand, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    
    Returns:
    round_{HALF_UP}(this * unscaledMultiplicand × 10^-scale)
  - multiplyUnscaled
```
Decimal<S> multiplyUnscaled(long unscaledMultiplicand,
                          int scale,
                          RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this * unscaledMultiplicand × 10^-scale). The result of the multiplication is rounded to the scale of this Decimal using the specified roundingMode. If the operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    unscaledMultiplicand - factor to multiply with this Decimal
    scale - the scale to apply to unscaledMultiplicand, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    round(this * unscaledMultiplicand × 10^-scale)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - multiplyUnscaled
```
Decimal<S> multiplyUnscaled(long unscaledMultiplicand,
                          int scale,
                          TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this * unscaledMultiplicand × 10^-scale). The result of the multiplication is rounded to the scale of this Decimal using the RoundingMode defined by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if the operation causes an overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    unscaledMultiplicand - factor to multiply with this Decimal
    scale - the scale to apply to unscaledMultiplicand, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this * unscaledMultiplicand × 10^-scale)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - multiplyByPowerOfTen
```
Decimal<S> multiplyByPowerOfTen(int n)
```
    Returns a Decimal whose value is (this * 10ⁿ) . For negative n the multiplication turns into a de-facto division and the result is rounded to the scale of this Decimal using default HALF_UP rounding. If the multiplication causes an overflow, the result is silently truncated.
    The result of this operation is the same as for divideByPowerOfTen(-n) given n > Integer.MIN_VALUE.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    n - the exponent of the power-of-ten factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * 10ⁿ)
  - multiplyByPowerOfTen
```
Decimal<S> multiplyByPowerOfTen(int n,
                              RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this * 10ⁿ) . For negative n the multiplication turns into a de-facto division and the result is rounded to the scale of this Decimal using the specified roundingMode. If the multiplication causes an overflow, the result is silently truncated.
    The result of this operation is the same as for divideByPowerOfTen(-n, roundingMode) given n > Integer.MIN_VALUE.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    n - the exponent of the power-of-ten factor to multiply with this Decimal
    roundingMode - the rounding mode to apply if the result needs to be rounded for the case n < 0
    
    Returns:
    round(this * 10ⁿ)
    
    Throws:
    
    ArithmeticException - if n < 0 and roundingMode==UNNECESSARY and rounding is necessary
  - multiplyByPowerOfTen
```
Decimal<S> multiplyByPowerOfTen(int n,
                              TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this * 10ⁿ) . For negative n the multiplication turns into a de-facto division and the result is rounded to the scale of this Decimal using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during the multiplication.
    The result of this operation is the same as for divideByPowerOfTen(-n, truncationPolicy) given n > Integer.MIN_VALUE.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the multiplication.
    
    Parameters:
    n - the exponent of the power-of-ten factor to multiply with this Decimal
    truncationPolicy - the truncation policy specifying RoundingMode to apply if rounding is necessary when n < 0 as well OverflowMode to use if n > 0 and an overflow occurs during the multiplication
    
    Returns:
    round(this * 10ⁿ)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary when n < 0, or if an overflow occurs and the policy declares OverflowMode.CHECKED for the case n > 0
  - divide
```
Decimal<S> divide(Decimal<S> divisor)
```
    Returns a Decimal whose value is (this / divisor). The result is rounded to the scale of this Decimal using HALF_UP rounding. If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0
  - divide
```
Decimal<S> divide(Decimal<S> divisor,
                RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this / divisor). The result is rounded to the scale of this Decimal using the specified roundingMode. If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0 or if roundingMode==UNNECESSARY and rounding is necessary
  - divide
```
Decimal<S> divide(Decimal<S> divisor,
                TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this / divisor). The result is rounded to the scale of this Decimal using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during the divide operation.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0, or if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - divideBy
```
Decimal<S> divideBy(Decimal<?> divisor)
```
    Returns a Decimal whose value is (this / divisor). The result is rounded to the scale of this Decimal using HALF_UP rounding. If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0
  - divideBy
```
Decimal<S> divideBy(Decimal<?> divisor,
                  RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this / divisor). The result is rounded to the scale of this Decimal using the specified roundingMode. If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    round(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0 or if roundingMode==UNNECESSARY and rounding is necessary
  - divideBy
```
Decimal<S> divideBy(Decimal<?> divisor,
                  TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this / divisor). The result is rounded to the scale of this Decimal using the RoundingMode defined by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if the operation causes an overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0, or if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary, or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - divideTruncate
```
Decimal<S> divideTruncate(Decimal<S> divisor)
```
    Returns a Decimal whose value is (this / divisor) rounded down. This method is a shortcut for calling divide(divisor, RoundingMode.DOWN). If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_DOWN(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0
  - divideExact
```
Decimal<S> divideExact(Decimal<S> divisor)
```
    Returns a Decimal whose value is (this / divisor), checking for lost information. If the quotient cannot be represented exactly with the scale of this Decimal then an ArithmeticException is thrown.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    this / divisor
    
    Throws:
    
    ArithmeticException - if divisor==0, or if the result does not fit in a Decimal with the scale of this Decimal without rounding and without exceeding the the possible range of such a Decimal
  - divide
```
Decimal<S> divide(long divisor)
```
    Returns a Decimal whose value is (this / divisor). The result is rounded to the scale of this Decimal using HALF_UP rounding. If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - long value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0
  - divide
```
Decimal<S> divide(long divisor,
                RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this / divisor). The result is rounded to the scale of this Decimal using the specified roundingMode. If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - long value by which this Decimal is to be divided
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0 or if roundingMode==UNNECESSARY and rounding is necessary
  - divide
```
Decimal<S> divide(long divisor,
                TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this / divisor). The result is rounded to the scale of this Decimal using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during the divide operation.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - long value by which this Decimal is to be divided
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this / divisor)
    
    Throws:
    
    ArithmeticException - if divisor==0, or if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary, or if the policy declares OverflowMode.CHECKED an overflow occurs
  - divide
```
Decimal<S> divide(double divisor)
```
    Returns a Decimal whose value is (this / divisor) after converting the given double argument into a Decimal value of the same scale as this Decimal. HALF_UP rounding mode is used if necessary and applied twice during the conversion step before the division and again when rounding the quotient to the scale of this Decimal. Overflows due to conversion or division result in an exception.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / round_{HALF_UP}(divisor))
    
    Throws:
    
    IllegalArgumentException - if divisor is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal
    
    ArithmeticException - if divisor==0 or if an overflow occurs during the divide operation
  - divide
```
Decimal<S> divide(double divisor,
                RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this / divisor) after converting the given double argument into a Decimal value of the same scale as this Decimal. Rounding, if necessary, uses the specified roundingMode and is applied during the conversion step before the division and again when rounding the quotient to the scale of this Decimal. Overflows due to conversion or division result in an exception.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    roundingMode - the rounding mode to apply if the converted divisor or the resulting quotient needs to be rounded
    
    Returns:
    round(this / round(divisor))
    
    Throws:
    
    IllegalArgumentException - if divisor is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal
    
    ArithmeticException - if divisor==0, if roundingMode==UNNECESSARY and rounding is necessary or if an overflow occurs during the divide operation
  - divideUnscaled
```
Decimal<S> divideUnscaled(long unscaledDivisor)
```
    Returns a Decimal whose value is (this / (unscaledDivisor × 10^-scale)) with the scale of this Decimal. The result is rounded to the scale of this Decimal using default HALF_UP rounding. If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    unscaledDivisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / (unscaledDivisor × 10^-scale))
    
    Throws:
    
    ArithmeticException - if unscaledDivisor==0
  - divideUnscaled
```
Decimal<S> divideUnscaled(long unscaledDivisor,
                        RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this / (unscaledDivisor × 10^-scale)) with the scale of this Decimal. The result is rounded to the scale of this Decimal using the specified roundingMode. If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    unscaledDivisor - divisor value by which this Decimal is to be divided
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(this / (unscaledDivisor × 10^-scale))
    
    Throws:
    
    ArithmeticException - if unscaledDivisor==0 or if roundingMode==UNNECESSARY and rounding is necessary
  - divideUnscaled
```
Decimal<S> divideUnscaled(long unscaledDivisor,
                        TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this / (unscaledDivisor × 10^-scale)) with the scale of this Decimal. The result is rounded to the scale of this Decimal using the using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during the division.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    unscaledDivisor - divisor value by which this Decimal is to be divided
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this / (unscaledDivisor × 10^-scale))
    
    Throws:
    
    ArithmeticException - if unscaledDivisor==0, if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - divideUnscaled
```
Decimal<S> divideUnscaled(long unscaledDivisor,
                        int scale)
```
    Returns a Decimal whose value is (this / (unscaledDivisor × 10^-scale)). The result is rounded to the scale of this Decimal using HALF_UP rounding. If the operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    unscaledDivisor - divisor value by which this Decimal is to be divided
    scale - the scale to apply to unscaledDivisor, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    
    Returns:
    round_{HALF_UP}(this / (unscaledDivisor × 10^-scale))
    
    Throws:
    
    ArithmeticException - if unscaledDivisor==0
  - divideUnscaled
```
Decimal<S> divideUnscaled(long unscaledDivisor,
                        int scale,
                        RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this / (unscaledDivisor × 10^-scale)). The result is rounded to the scale of this Decimal using the specified roundingMode. If the operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    unscaledDivisor - divisor value by which this Decimal is to be divided
    scale - the scale to apply to unscaledDivisor, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(this / (unscaledDivisor × 10^-scale))
    
    Throws:
    
    ArithmeticException - if unscaledDivisor==0 or if roundingMode==UNNECESSARY and rounding is necessary
  - divideUnscaled
```
Decimal<S> divideUnscaled(long unscaledDivisor,
                        int scale,
                        TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this / (unscaledDivisor × 10^-scale)). The result is rounded to the scale of this Decimal using the RoundingMode defined by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if the operation causes an overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    unscaledDivisor - divisor value by which this Decimal is to be divided
    scale - the scale to apply to unscaledDivisor, positive to indicate the number of fraction digits to the right of the Decimal point and negative to indicate up-scaling with a power of ten
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this / (unscaledDivisor × 10^-scale))
    
    Throws:
    
    ArithmeticException - if unscaledDivisor==0, if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - divideByPowerOfTen
```
Decimal<S> divideByPowerOfTen(int n)
```
    Returns a Decimal whose value is (this / 10ⁿ) . The result is rounded to the scale of this Decimal using HALF_UP rounding.
    For negative n the division turns into a de-facto multiplication. If the multiplication causes an overflow, the result is silently truncated.
    The result of this operation is the same as for multiplyByPowerOfTen(-n) (unless n == Integer.MIN_VALUE).
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    n - the exponent of the power-of-ten divisor by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / 10ⁿ)
  - divideByPowerOfTen
```
Decimal<S> divideByPowerOfTen(int n,
                            RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this / 10ⁿ) . The result is rounded to the scale of this Decimal using the specified roudningMode.
    For negative n the division turns into a de-facto multiplication. If the multiplication causes an overflow, the result is silently truncated.
    The result of this operation is the same as for multiplyByPowerOfTen(-n, roundingMode) (unless n == Integer.MIN_VALUE).
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    n - the exponent of the power-of-ten divisor by which this Decimal is to be divided
    roundingMode - the rounding mode to apply if the result needs to be rounded for the case n > 0
    
    Returns:
    round(this / 10ⁿ)
    
    Throws:
    
    ArithmeticException - if n > 0 and roundingMode==UNNECESSARY and rounding is necessary
  - divideByPowerOfTen
```
Decimal<S> divideByPowerOfTen(int n,
                            TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this / 10ⁿ) . The result is rounded to the scale of this Decimal using the RoundingMode specified by the truncationPolicy argument.
    For negative n the division turns into a de-facto multiplication and truncationPolicy defines the OverflowMode to apply if an overflow occurs during the multiplication.
    The result of this operation is the same as for multiplyByPowerOfTen(-n, truncationPolicy) (unless n == Integer.MIN_VALUE).
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    n - the exponent of the power-of-ten divisor by which this Decimal is to be divided
    truncationPolicy - the truncation policy specifying RoundingMode to apply if rounding is necessary when n > 0 as well OverflowMode to use if n < 0 and an overflow occurs during the de-facto multiplication
    
    Returns:
    round(this / 10ⁿ)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary when n > 0, or if an overflow occurs and the policy declares OverflowMode.CHECKED for the case n < 0
  - divideToIntegralValue
```
Decimal<S> divideToIntegralValue(Decimal<S> divisor)
```
    Returns a Decimal whose value is (this / divisor) rounded down to the next integer. If the division causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - value by which this Decimal is to be divided.
    
    Returns:
    The integer part of (this / divisor).
    
    Throws:
    
    ArithmeticException - if divisor==0
    See Also:
    divideToIntegralValue(Decimal, OverflowMode), divideToLongValue(Decimal), remainder(Decimal)
  - divideToIntegralValue
```
Decimal<S> divideToIntegralValue(Decimal<S> divisor,
                               OverflowMode overflowMode)
```
    Returns a Decimal whose value is (this / divisor) rounded down to the next integer. The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    divisor - value by which this Decimal is to be divided.
    overflowMode - the overflow mode to apply if the division leads to an overflow
    
    Returns:
    The integer part of (this / divisor).
    
    Throws:
    
    ArithmeticException - if divisor==0 or if overflowMode==CHECKED and an overflow occurs
    See Also:
    divideToIntegralValue(Decimal), divideToLongValue(Decimal), remainder(Decimal)
  - divideToLongValue
```
long divideToLongValue(Decimal<S> divisor)
```
    Returns a Decimal whose value (this / divisor) rounded down to the next long value. If the division causes an overflow, the result is silently truncated.
    
    Parameters:
    divisor - value by which this Decimal is to be divided.
    
    Returns:
    The integer part of (this / divisor) returned as long
    
    Throws:
    
    ArithmeticException - if divisor==0
    See Also:
    divideToLongValue(Decimal, OverflowMode), divideToIntegralValue(Decimal), remainder(Decimal)
  - divideToLongValue
```
long divideToLongValue(Decimal<S> divisor,
                     OverflowMode overflowMode)
```
    Returns a Decimal whose value (this / divisor) rounded down to the next long value. The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    
    Parameters:
    divisor - value by which this Decimal is to be divided.
    overflowMode - the overflow mode to apply if the division leads to an overflow
    
    Returns:
    The integer part of (this / divisor) returned as long
    
    Throws:
    
    ArithmeticException - if divisor==0 or if overflowMode==CHECKED and an overflow occurs
    See Also:
    divideToLongValue(Decimal), divideToIntegralValue(Decimal), remainder(Decimal)
  - divideAndRemainder
```
Decimal<S>[] divideAndRemainder(Decimal<S> divisor)
```
    Returns a two-element Decimal array containing the result of divideToIntegralValue followed by the result of remainder on the two operands. If the division causes an overflow, the result is silently truncated.
    Note that if both the integer quotient and remainder are needed, this method is faster than using the divideToIntegralValue and remainder methods separately because the division need only be carried out once.
    
    Parameters:
    divisor - value by which this Decimal is to be divided, and the remainder computed.
    
    Returns:
    a two element Decimal array: the quotient (the result of divideToIntegralValue) is the initial element and the remainder is the final element.
    
    Throws:
    
    ArithmeticException - if divisor==0
    See Also:
    divideAndRemainder(Decimal, OverflowMode), divideToIntegralValue(Decimal), remainder(Decimal)
  - divideAndRemainder
```
Decimal<S>[] divideAndRemainder(Decimal<S> divisor,
                              OverflowMode overflowMode)
```
    Returns a two-element Decimal array containing the result of divideToIntegralValue followed by the result of remainder on the two operands. The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    Note that if both the integer quotient and remainder are needed, this method is faster than using the divideToIntegralValue and remainder methods separately because the division need only be carried out once.
    
    Parameters:
    divisor - value by which this Decimal is to be divided, and the remainder computed.
    overflowMode - the overflow mode to apply if the division leads to an overflow
    
    Returns:
    a two element Decimal array: the quotient (the result of divideToIntegralValue) is the initial element and the remainder is the final element.
    
    Throws:
    
    ArithmeticException - if divisor==0 or if overflowMode==CHECKED and an overflow occurs
    See Also:
    divideAndRemainder(Decimal), divideToIntegralValue(Decimal), remainder(Decimal)
  - remainder
```
Decimal<S> remainder(Decimal<S> divisor)
```
    Returns a Decimal whose value is (this % divisor).
    The remainder is given by this.subtract(this.divideToIntegralValue(divisor).multiply(divisor)) . Note that this is not the modulo operation (the result can be negative).
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the operation.
    
    Parameters:
    divisor - value by which this Decimal is to be divided.
    
    Returns:
    this % divisor.
    
    Throws:
    
    ArithmeticException - if divisor==0
    See Also:
    divideToIntegralValue(Decimal), divideAndRemainder(Decimal)
  - negate
```
Decimal<S> negate()
```
    Returns a Decimal whose value is (-this).
    If an overflow occurs (which is true iff this.unscaledValue()==Long.MIN_VALUE) then the result is still negative and numerically equal to this value.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Returns:
    -this
  - negate
```
Decimal<S> negate(OverflowMode overflowMode)
```
    Returns a Decimal whose value is (-this).
    The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs (which is true iff this.unscaledValue()==Long.MIN_VALUE).
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    overflowMode - the overflow mode to apply
    
    Returns:
    -this
    
    Throws:
    
    ArithmeticException - if overflowMode==CHECKED and an overflow occurs (which is true iff this.unscaledValue()==Long.MIN_VALUE)
  - abs
```
Decimal<S> abs()
```
    Returns a Decimal whose value is the absolute value of this Decimal.
    If an overflow occurs (which is true iff this.unscaledValue()==Long.MIN_VALUE) then the result is still negative and numerically equal to this value.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Returns:
    abs(this)
  - abs
```
Decimal<S> abs(OverflowMode overflowMode)
```
    Returns a Decimal whose value is the absolute value of this Decimal.
    The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs (which is true iff this.unscaledValue()==Long.MIN_VALUE).
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the division.
    
    Parameters:
    overflowMode - the overflow mode to apply
    
    Returns:
    abs(this)
    
    Throws:
    
    ArithmeticException - if overflowMode==CHECKED and an overflow occurs (which is true iff this.unscaledValue()==Long.MIN_VALUE)
  - invert
```
Decimal<S> invert()
```
    Returns a Decimal whose value is (1 / this). The result is rounded to the scale of this Decimal using default HALF_UP rounding. If the inversion causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the inversion.
    
    Returns:
    round_{HALF_UP}(1 / this)
    
    Throws:
    
    ArithmeticException - if this==0
  - invert
```
Decimal<S> invert(RoundingMode roundingMode)
```
    Returns a Decimal whose value is (1 / this). The result is rounded to the scale of this Decimal using the specified roundingMode. If the inversion causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the inversion.
    
    Parameters:
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(1 / this)
    
    Throws:
    
    ArithmeticException - if this==0 or if roundingMode==UNNECESSARY and rounding is necessary
  - invert
```
Decimal<S> invert(TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (1 / this). The result is rounded to the scale of this Decimal using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during the invert operation.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the inversion.
    
    Parameters:
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(1 / this)
    
    Throws:
    
    ArithmeticException - if this==0, if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - square
```
Decimal<S> square()
```
    Returns a Decimal whose value is (this²). The result is rounded to the scale of this Decimal using default HALF_UP rounding. If the square operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the square operation.
    
    Returns:
    round_{HALF_UP}(this * this)
  - square
```
Decimal<S> square(RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this²). The result is rounded to the scale of this Decimal using the specified roundingMode. If the square operation causes an overflow, the result is silently truncated.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the square operation.
    
    Parameters:
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(this * this)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - square
```
Decimal<S> square(TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this²). The result is rounded to the scale of this Decimal using the RoundingMode specified by the truncationPolicy argument. The truncationPolicy also defines the OverflowMode to apply if an overflow occurs during the square operation.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the square operation.
    
    Parameters:
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this * this)
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - sqrt
```
Decimal<S> sqrt()
```
    Returns a Decimal whose value is the square root of this Decimal value. The result is rounded to the scale of this Decimal using default HALF_UP rounding.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the operation.
    
    Returns:
    sqrt(this)
    
    Throws:
    
    ArithmeticException - if this < 0
  - sqrt
```
Decimal<S> sqrt(RoundingMode roundingMode)
```
    Returns a Decimal whose value is the square root of this Decimal value. The result is rounded to the scale of this Decimal using the specified roundingMode.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the operation.
    
    Parameters:
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    sqrt(this)
    
    Throws:
    
    ArithmeticException - if this < 0 or if roundingMode==UNNECESSARY and rounding is necessary
  - signum
```
int signum()
```
    Returns the signum function of this Decimal.
    
    Returns:
    -1, 0, or 1 as the value of this Decimal is negative, zero, or positive.
  - shiftLeft
```
Decimal<S> shiftLeft(int n)
```
    Returns a Decimal whose value is (this << n). The shift distance, n, may be negative, in which case this method performs a right shift.
    Computes floor(this * 2ⁿ).
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the shift operation.
    
    Parameters:
    n - shift distance, in bits.
    
    Returns:
    this << n
    See Also:
    shiftRight(int)
  - shiftLeft
```
Decimal<S> shiftLeft(int n,
                   RoundingMode roundingMode)
```
    Returns a Decimal whose value is (this << n). The shift distance, n, may be negative, in which case this method performs a right shift.
    Computes round(this * 2ⁿ) using the specified roundingMode.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the shift operation.
    
    Parameters:
    n - shift distance, in bits.
    roundingMode - the rounding mode to use if truncation is involved for negative n, that is, for right shifts
    
    Returns:
    this << n
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
    See Also:
    shiftRight(int)
  - shiftLeft
```
Decimal<S> shiftLeft(int n,
                   TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (this << n). The shift distance, n, may be negative, in which case this method performs a right shift.
    Computes round(this * 2ⁿ) using the RoundingMode specified by the truncationPolicy argument.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the shift operation.
    
    Parameters:
    n - shift distance, in bits.
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    this << n
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
    See Also:
    shiftRight(int)
  - shiftRight
```
Decimal<S> shiftRight(int n)
```
    Returns a BigInteger whose value is (this >> n). Sign extension is performed. The shift distance, n, may be negative, in which case this method performs a left shift.
    Computes floor(this / 2ⁿ).
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the shift operation.
    
    Parameters:
    n - shift distance, in bits.
    
    Returns:
    this >> n
    See Also:
    shiftLeft(int)
  - shiftRight
```
Decimal<S> shiftRight(int n,
                    RoundingMode roundingMode)
```
    Returns a BigInteger whose value is (this >> n). Sign extension is performed. The shift distance, n, may be negative, in which case this method performs a left shift.
    Computes round(this / 2ⁿ) using the specified roundingMode.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the shift operation.
    
    Parameters:
    n - shift distance, in bits.
    roundingMode - the rounding mode to use if truncation is involved
    
    Returns:
    this >> n
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
    See Also:
    shiftLeft(int)
  - shiftRight
```
Decimal<S> shiftRight(int n,
                    TruncationPolicy truncationPolicy)
```
    Returns a BigInteger whose value is (this >> n). Sign extension is performed. The shift distance, n, may be negative, in which case this method performs a left shift.
    Computes round(this / 2ⁿ) using the RoundingMode specified by the truncationPolicy argument.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the shift operation.
    
    Parameters:
    n - shift distance, in bits.
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    this >> n
    
    Throws:
    
    ArithmeticException - if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
    See Also:
    shiftLeft(int)
  - pow
```
Decimal<S> pow(int n)
```
    Returns a Decimal whose value is (thisⁿ) using default HALF_UP rounding.
    The current implementation uses the core algorithm defined in ANSI standard X3.274-1996. For n >= 0, the returned numerical value is within 1 ULP of the exact numerical value. No precision is guaranteed for n < 0 but the result is usually exact up to 10-20 ULP.
    Properties of the X3.274-1996 algorithm are:
    - An IllegalArgumentException is thrown if abs(n) > 999999999
    - if n is zero, one is returned even if this is zero, otherwise
      
      if n is positive, the result is calculated via the repeated squaring technique into a single accumulator
      
      if n is negative, the result is calculated as if n were positive; this value is then divided into one
      
      The final value from either the positive or negative case is then rounded using HALF_UP rounding
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the shift operation.
    Parameters:
    n - power to raise this Decimal to
    
    Returns:
    thisⁿ using the ANSI standard X3.274-1996 algorithm
    
    Throws:
    
    IllegalArgumentException - if abs(n) > 999999999
    
    ArithmeticException - if n is negative and this equals zero
  - pow
```
Decimal<S> pow(int n,
             RoundingMode roundingMode)
```
    Returns a Decimal whose value is (thisⁿ) applying the specified roundingMode.
    The current implementation uses the core algorithm defined in ANSI standard X3.274-1996. For n >= 0, the returned numerical value is within 1 ULP of the exact numerical value; the result is actually exact for all rounding modes other than HALF_UP, HALF_EVEN and HALF_DOWN. No precision is guaranteed for n < 0 but the result is usually exact up to 10-20 ULP.
    Properties of the X3.274-1996 algorithm are:
    - An IllegalArgumentException is thrown if abs(n) > 999999999
    - if n is zero, one is returned even if this is zero, otherwise
      
      if n is positive, the result is calculated via the repeated squaring technique into a single accumulator
      
      if n is negative, the result is calculated as if n were positive; this value is then divided into one
      
      The final value from either the positive or negative case is then rounded using the specified roundingMode
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the shift operation.
    Parameters:
    n - power to raise this Decimal to
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    thisⁿ using the ANSI standard X3.274-1996 algorithm
    
    Throws:
    
    IllegalArgumentException - if abs(n) > 999999999
    
    ArithmeticException - if n is negative and this equals zero or if roundingMode equals RoundingMode.UNNECESSARY and rounding is necessary
  - pow
```
Decimal<S> pow(int n,
             TruncationPolicy truncationPolicy)
```
    Returns a Decimal whose value is (thisⁿ) applying the RoundingMode specified by truncationPolicy. The truncationPolicy argument also defines the OverflowMode to apply if an overflow occurs during the power operation.
    The current implementation uses the core algorithm defined in ANSI standard X3.274-1996. For n >= 0, the returned numerical value is within 1 ULP of the exact numerical value; the result is actually exact for all rounding modes other than HALF_UP, HALF_EVEN and HALF_DOWN. No precision is guaranteed for n < 0 but the result is usually exact up to 10-20 ULP.
    Properties of the X3.274-1996 algorithm are:
    - An IllegalArgumentException is thrown if abs(n) > 999999999
    - if n is zero, one is returned even if this is zero, otherwise
      
      if n is positive, the result is calculated via the repeated squaring technique into a single accumulator
      
      if n is negative, the result is calculated as if n were positive; this value is then divided into one
      
      The final value from either the positive or negative case is then rounded using the RoundingMode specified by truncationPolicy
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the shift operation.
    Parameters:
    n - power to raise this Decimal to
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    thisⁿ using the ANSI standard X3.274-1996 algorithm
    
    Throws:
    
    IllegalArgumentException - if abs(n) > 999999999
    
    ArithmeticException - if n is negative and this equals zero; if truncationPolicy defines RoundingMode.UNNECESSARY and rounding is necessary or if an overflow occurs and the policy declares OverflowMode.CHECKED
  - compareTo
```
int compareTo(Decimal<S> other)
```
    Compares two Decimal objects numerically.
    
    Specified by:
    
    compareTo in interface Comparable<Decimal<S extends ScaleMetrics>>
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    the value 0 if this Decimal is equal to the argument Decimal; a value less than 0 if this Decimal is numerically less than the argument Decimal; and a value greater than 0 if this Decimal is numerically greater than the argument Decimal
  - isEqualTo
```
boolean isEqualTo(Decimal<S> other)
```
    Compares this Decimal with the specified Decimal and returns true if the two are numerically equal.
    Returns true iff compareTo(Decimal) returns 0.
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    true this Decimal is numerically equal to other and false otherwise
  - isGreaterThan
```
boolean isGreaterThan(Decimal<S> other)
```
    Compares this Decimal with the specified Decimal and returns true if this Decimal is numerically greater than other.
    Returns true iff compareTo(Decimal) returns a value greater than 0.
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    true if this > other
  - isGreaterThanOrEqualTo
```
boolean isGreaterThanOrEqualTo(Decimal<S> other)
```
    Compares this Decimal with the specified Decimal and returns true if this Decimal is numerically greater than or equal to other.
    Returns true iff compareTo(Decimal) returns a non-negative value.
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    true if this >= other
  - isLessThan
```
boolean isLessThan(Decimal<S> other)
```
    Compares this Decimal with the specified Decimal and returns true if this Decimal is numerically less than other.
    Returns true iff compareTo(Decimal) returns a negative value.
    
    Parameters:
    other - Decimal to which this Decimal is to be compared.
    
    Returns:
    true if this < other
  - isLessThanOrEqualTo
```
boolean isLessThanOrEqualTo(Decimal<S> other)
```
    Compares this Decimal with the specified Decimal and returns true if this Decimal is numerically less than or equal to other.
    Returns true iff compareTo(Decimal) returns a non-positive value.
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    true if this <= other
  - min
```
Decimal<S> min(Decimal<S> val)
```
    Returns the minimum of this Decimal and val.
    
    Parameters:
    val - value with which the minimum is to be computed.
    
    Returns:
    the Decimal whose value is the lesser of this Decimal and val. If they are equal, as defined by the compareTo method, this is returned.
    See Also:
    compareTo(Decimal)
  - max
```
Decimal<S> max(Decimal<S> val)
```
    Returns the maximum of this Decimal and val.
    
    Parameters:
    val - value with which the maximum is to be computed.
    
    Returns:
    the Decimal whose value is the greater of this Decimal and val. If they are equal, as defined by the compareTo method, this is returned.
    See Also:
    compareTo(Decimal)
  - avg
```
Decimal<S> avg(Decimal<S> val)
```
    Returns the average of this Decimal and val. The result is rounded to the scale of this Decimal using default HALF_UP rounding. The method is much more efficient than an addition and subsequent long division and is guaranteed not to overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the average operation.
    
    Parameters:
    val - value with which the average is to be computed.
    
    Returns:
    round_{HALF_UP}((this + val) / 2)
  - avg
```
Decimal<S> avg(Decimal<S> val,
             RoundingMode roundingMode)
```
    Returns the average of this Decimal and val. The result is rounded to the scale of this Decimal using the specified roundingMode. The method is much more efficient than an addition and subsequent long division and is guaranteed not to overflow.
    The returned value is a new instance if this Decimal is an ImmutableDecimal. If it is a MutableDecimal then its internal state is altered and this is returned as result now representing the outcome of the average operation.
    
    Parameters:
    val - value with which the average is to be computed.
    roundingMode - the rounding mode to use if rounding is necessary
    
    Returns:
    round((this + val) / 2)
    
    Throws:
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - isZero
```
boolean isZero()
```
    Returns true if this Decimal is zero.
    
    Returns:
    true if this == 0
  - isOne
```
boolean isOne()
```
    Returns true if this Decimal is one.
    
    Returns:
    true if this == 1
  - isMinusOne
```
boolean isMinusOne()
```
    Returns true if this Decimal is minus one.
    
    Returns:
    true if this == -1
  - isUlp
```
boolean isUlp()
```
    Returns true if this Decimal is equal to the smallest positive number representable by a Decimal with the current scale.
    
    Returns:
    true if unscaledValue() == 1
  - isPositive
```
boolean isPositive()
```
    Returns true if this Decimal is strictly positive.
    
    Returns:
    true if this > 0
  - isNonNegative
```
boolean isNonNegative()
```
    Returns true if this Decimal is not negative.
    
    Returns:
    true if this >= 0
  - isNegative
```
boolean isNegative()
```
    Returns true if this Decimal is negative.
    
    Returns:
    true if this < 0
  - isNonPositive
```
boolean isNonPositive()
```
    Returns true if this Decimal is not positive.
    
    Returns:
    true if this <= 0
  - isIntegral
```
boolean isIntegral()
```
    Returns true if this Decimal number is integral, or equivalently if its fractional part is zero.
    
    Returns:
    true if this is an integer number
  - isIntegralPartZero
```
boolean isIntegralPartZero()
```
    Returns true if the integral part of this Decimal number is zero.
    
    Returns:
    true if -1 < this < 1
  - isBetweenZeroAndOne
```
boolean isBetweenZeroAndOne()
```
    Returns true if this Decimal is between zero (inclusive) and one (exclusive). The result value is true if and only if this Decimal is not negative and its integral part is zero.
    
    Returns:
    true if 0 <= this < 1
  - isBetweenZeroAndMinusOne
```
boolean isBetweenZeroAndMinusOne()
```
    Returns true if this Decimal is between zero (inclusive) and minus one (exclusive). The result value is true if and only if this Decimal is not positive and its integral part is zero.
    
    Returns:
    true if -1 < this <= 0
  - compareToNumerically
```
int compareToNumerically(Decimal<?> other)
```
    Compares this Decimal with the specified Decimal. Two Decimal objects that are equal in value but have a different scale (like 2.0 and 2.00) are considered equal by this method.
    
    Parameters:
    other - Decimal to which this Decimal is to be compared.
    
    Returns:
    the value 0 if this Decimal is equal to the argument Decimal; a value less than 0 if this Decimal is numerically less than the argument Decimal; and a value greater than 0 if this Decimal is numerically greater than the argument Decimal
    See Also:
    isEqualToNumerically(Decimal), compareTo(Decimal)
  - isEqualToNumerically
```
boolean isEqualToNumerically(Decimal<?> other)
```
    Compares this Decimal with the specified Decimal and returns true if the two are numerically equal. Two Decimal objects that are equal in value but have a different scale (like 2.0 and 2.00) are considered equal by this method as opposed to the equals method which requires identical scales of the compared values.
    Returns true iff compareToNumerically(Decimal) returns 0.
    
    Parameters:
    other - Decimal to which this Decimal is to be compared.
    
    Returns:
    true if this Decimal is numerically equal to other and false otherwise.
    See Also:
    compareToNumerically(Decimal), compareTo(Decimal)
  - hashCode
```
int hashCode()
```
    Returns a hash code for this Decimal. The hash code is calculated from scale and unscaled value.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    a hash code value for this object
  - equals
```
boolean equals(Object obj)
```
    Compares this Decimal to the specified object. The result is true if and only if the argument is a Decimal value with the same scale and unscaled value as this Decimal.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    obj - the object to compare with
    
    Returns:
    true if the argument is a Decimal object that contains the same value and scale as this object; false otherwise
    See Also:
    isEqualTo(Decimal), isEqualToNumerically(Decimal), hashCode()
  - toString
```
String toString()
```
    Returns a string representation of this Decimal object as fixed-point Decimal always showing all Decimal places (also trailing zeros) and a leading sign character if negative.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    a String Decimal representation of this Decimal object with all the fraction digits (including trailing zeros)

Interface Decimal<S extends ScaleMetrics>

Method Summary

Method Detail

getScaleMetrics

getScale

unscaledValue

getFactory

integralPart

fractionalPart

byteValue

byteValueExact

shortValue

shortValueExact

intValue

intValueExact

longValue

longValueExact

floatValue

doubleValue

toBigInteger

toBigIntegerExact

toBigDecimal

toImmutableDecimal

toMutableDecimal

longValue

floatValue

doubleValue

toBigInteger

toBigDecimal

round

round

round

scale

scale

scale

scale

add

add

add

add

add

add

add

add

addUnscaled

addUnscaled

addUnscaled

addUnscaled

addUnscaled

addSquared

addSquared

addSquared

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtractUnscaled

subtractUnscaled

subtractUnscaled

subtractUnscaled

subtractUnscaled

subtractSquared

subtractSquared

subtractSquared

multiply

multiply

multiply

multiplyBy

multiplyBy

multiplyBy

multiplyExact

multiply

multiply

multiply

multiply

multiplyUnscaled