MutableDecimal (decimal4j API 1.0.3)

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

All Superinterfaces:

Comparable<Decimal<S>>, Decimal<S>

All Known Implementing Classes:

AbstractMutableDecimal, GenericMutableDecimal, MutableDecimal0f, MutableDecimal10f, MutableDecimal11f, MutableDecimal12f, MutableDecimal13f, MutableDecimal14f, MutableDecimal15f, MutableDecimal16f, MutableDecimal17f, MutableDecimal18f, MutableDecimal1f, MutableDecimal2f, MutableDecimal3f, MutableDecimal4f, MutableDecimal5f, MutableDecimal6f, MutableDecimal7f, MutableDecimal8f, MutableDecimal9f
```
public interface MutableDecimal<S extends ScaleMetrics>
extends Decimal<S>
```
Interface implemented by mutable Decimal classes of different scales. Mutable Decimals modify their state when performing arithmetic operations; they represent the result after the operation. Arithmetic operations therefore return this as return value. Note however that the scale of a Mutable Decimal does not change and remains constant throughout the lifetime of a MutableDecimal instance.
Mutable Decimals may be preferred over ImmutableDecimal descendants e.g. if the allocation of new objects is undesired or if a chain of operations is performed.
Mutable Decimals are NOT thread safe.

Method Summary

Methods
Modifier and Type	Method and Description
`MutableDecimal<S>`	`abs()` Returns a `Decimal` whose value is the absolute value of this `Decimal`.
`MutableDecimal<S>`	`abs(OverflowMode overflowMode)` Returns a `Decimal` whose value is the absolute value of this `Decimal`.
`MutableDecimal<S>`	`add(Decimal<?> augend, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + augend)`.
`MutableDecimal<S>`	`add(Decimal<?> augend, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this + augend)`.
`MutableDecimal<S>`	`add(Decimal<S> augend)` Returns a `Decimal` whose value is `(this + augend)`.
`MutableDecimal<S>`	`add(Decimal<S> augend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this + augend)`.
`MutableDecimal<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.
`MutableDecimal<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.
`MutableDecimal<S>`	`add(long augend)` Returns a `Decimal` whose value is `(this + augend)` after converting the given `long` value to the scale of `this` Decimal.
`MutableDecimal<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.
`MutableDecimal<S>`	`addSquared(Decimal<S> value)` Returns a `Decimal` whose value is `(this + value²)`.
`MutableDecimal<S>`	`addSquared(Decimal<S> value, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + value²)`.
`MutableDecimal<S>`	`addSquared(Decimal<S> value, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this + value²)`.
`MutableDecimal<S>`	`addUnscaled(long unscaledAugend)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)` with the `scale` of this Decimal.
`MutableDecimal<S>`	`addUnscaled(long unscaledAugend, int scale)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)`.
`MutableDecimal<S>`	`addUnscaled(long unscaledAugend, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)`.
`MutableDecimal<S>`	`addUnscaled(long unscaledAugend, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)`.
`MutableDecimal<S>`	`addUnscaled(long unscaledAugend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)` with the `scale` of this Decimal.
`MutableDecimal<S>`	`avg(Decimal<S> val)` Returns the average of this `Decimal` and `val`.
`MutableDecimal<S>`	`avg(Decimal<S> val, RoundingMode roundingMode)` Returns the average of this `Decimal` and `val`.
`MutableDecimal<S>`	`clone()` Returns a clone of this mutable Decimal numerically identical to this value.
`MutableDecimal<S>`	`divide(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)`.
`MutableDecimal<S>`	`divide(Decimal<S> divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)`.
`MutableDecimal<S>`	`divide(Decimal<S> divisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / divisor)`.
`MutableDecimal<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.
`MutableDecimal<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.
`MutableDecimal<S>`	`divide(long divisor)` Returns a `Decimal` whose value is `(this / divisor)`.
`MutableDecimal<S>`	`divide(long divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)`.
`MutableDecimal<S>`	`divide(long divisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / divisor)`.
`MutableDecimal<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.
`MutableDecimal<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.
`MutableDecimal<S>`	`divideBy(Decimal<?> divisor)` Returns a `Decimal` whose value is `(this / divisor)`.
`MutableDecimal<S>`	`divideBy(Decimal<?> divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)`.
`MutableDecimal<S>`	`divideBy(Decimal<?> divisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / divisor)`.
`MutableDecimal<S>`	`divideByPowerOfTen(int n)` Returns a `Decimal` whose value is `(this / 10ⁿ)` .
`MutableDecimal<S>`	`divideByPowerOfTen(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / 10ⁿ)` .
`MutableDecimal<S>`	`divideByPowerOfTen(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / 10ⁿ)` .
`MutableDecimal<S>`	`divideExact(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)`, checking for lost information.
`MutableDecimal<S>`	`divideToIntegralValue(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)` rounded down to the next integer.
`MutableDecimal<S>`	`divideToIntegralValue(Decimal<S> divisor, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this / divisor)` rounded down to the next integer.
`MutableDecimal<S>`	`divideTruncate(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)` rounded down.
`MutableDecimal<S>`	`divideUnscaled(long unscaledDivisor)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))` with the `scale` of this Decimal.
`MutableDecimal<S>`	`divideUnscaled(long unscaledDivisor, int scale)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))`.
`MutableDecimal<S>`	`divideUnscaled(long unscaledDivisor, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))`.
`MutableDecimal<S>`	`divideUnscaled(long unscaledDivisor, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))`.
`MutableDecimal<S>`	`divideUnscaled(long unscaledDivisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))` with the `scale` of this Decimal.
`MutableDecimal<S>`	`divideUnscaled(long unscaledDivisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))` with the `scale` of this Decimal.
`MutableDecimal<S>`	`fractionalPart()` Returns a `Decimal` whose value represents the fractional part of `(this)` value.
`MutableDecimal<S>`	`integralPart()` Returns a `Decimal` whose value represents the integral part of `this` Decimal.
`MutableDecimal<S>`	`invert()` Returns a `Decimal` whose value is `(1 / this)`.
`MutableDecimal<S>`	`invert(RoundingMode roundingMode)` Returns a `Decimal` whose value is `(1 / this)`.
`MutableDecimal<S>`	`invert(TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(1 / this)`.
`MutableDecimal<S>`	`max(MutableDecimal<S> val)` Returns the maximum of this `Decimal` and `val`.
`MutableDecimal<S>`	`min(MutableDecimal<S> val)` Returns the minimum of this `Decimal` and `val`.
`MutableDecimal<S>`	`multiply(Decimal<S> multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`MutableDecimal<S>`	`multiply(Decimal<S> multiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`MutableDecimal<S>`	`multiply(Decimal<S> multiplicand, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`MutableDecimal<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.
`MutableDecimal<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.
`MutableDecimal<S>`	`multiply(long multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`MutableDecimal<S>`	`multiply(long multiplicand, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`MutableDecimal<S>`	`multiplyBy(Decimal<?> multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`MutableDecimal<S>`	`multiplyBy(Decimal<?> multiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`MutableDecimal<S>`	`multiplyBy(Decimal<?> multiplicand, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`MutableDecimal<S>`	`multiplyByPowerOfTen(int n)` Returns a `Decimal` whose value is `(this * 10ⁿ)` .
`MutableDecimal<S>`	`multiplyByPowerOfTen(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * 10ⁿ)` .
`MutableDecimal<S>`	`multiplyByPowerOfTen(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * 10ⁿ)` .
`MutableDecimal<?>`	`multiplyExact(Decimal<?> multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`MutableDecimal<S>`	`multiplyUnscaled(long unscaledMultiplicand)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)` with the `scale` of this Decimal.
`MutableDecimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, int scale)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)`.
`MutableDecimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)`.
`MutableDecimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)`.
`MutableDecimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)` with the `scale` of this Decimal.
`MutableDecimal<S>`	`multiplyUnscaled(long unscaledMultiplicand, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)` with the `scale` of this Decimal.
`MutableDecimal<S>`	`negate()` Returns a `Decimal` whose value is `(-this)`.
`MutableDecimal<S>`	`negate(OverflowMode overflowMode)` Returns a `Decimal` whose value is `(-this)`.
`MutableDecimal<S>`	`pow(int n)` Returns a `Decimal` whose value is `(thisⁿ)` using default `HALF_UP` rounding.
`MutableDecimal<S>`	`pow(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(thisⁿ)` applying the specified `roundingMode`.
`MutableDecimal<S>`	`pow(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(thisⁿ)` applying the `RoundingMode` specified by `truncationPolicy`.
`MutableDecimal<S>`	`remainder(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this % divisor)`.
`MutableDecimal<S>`	`round(int precision)` Returns a `Decimal` value rounded to the specified `precision` using `HALF_UP` rounding.
`MutableDecimal<S>`	`round(int precision, RoundingMode roundingMode)` Returns a `Decimal` value rounded to the specified `precision` using the given rounding mode.
`MutableDecimal<S>`	`round(int precision, TruncationPolicy truncationPolicy)` Returns a `Decimal` value rounded to the specified `precision` using the given truncation policy.
`MutableDecimal<?>`	`scale(int scale)` Returns a `Decimal` value whose `scale` is changed to the given `scale` value.
`MutableDecimal<?>`	`scale(int scale, RoundingMode roundingMode)` Returns a `Decimal` value whose `scale` is changed to the given `scale` value.
`<S extends ScaleMetrics> MutableDecimal<S>`	`scale(S scaleMetrics)` Returns a `Decimal` value whose `scale` is changed to the scale given by the `scaleMetrics` argument.
`<S extends ScaleMetrics> MutableDecimal<S>`	`scale(S scaleMetrics, RoundingMode roundingMode)` Returns a `Decimal` value whose `scale` is changed to the scale given by the `scaleMetrics` argument.
`MutableDecimal<S>`	`set(BigDecimal value)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(BigDecimal value, RoundingMode roundingMode)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(BigInteger value)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(Decimal<?> value, RoundingMode roundingMode)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(Decimal<S> value)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(double value)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(double value, RoundingMode roundingMode)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(float value)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(float value, RoundingMode roundingMode)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(long value)` Sets `this` Decimal to the specified `value` and returns `this` now representing `value`.
`MutableDecimal<S>`	`set(String value)` Parses the given string value and sets `this` Decimal to the parsed `value`.
`MutableDecimal<S>`	`set(String value, RoundingMode roundingMode)` Parses the given string value and sets `this` Decimal to the parsed `value`.
`MutableDecimal<S>`	`setMinusOne()` Sets `this` Decimal to -1 and returns `this` now representing minus one.
`MutableDecimal<S>`	`setOne()` Sets `this` Decimal to 1 and returns `this` now representing one.
`MutableDecimal<S>`	`setUlp()` Sets `this` Decimal to the smallest positive value representable by this Mutable Decimal and returns `this` now representing one ULP.
`MutableDecimal<S>`	`setUnscaled(long unscaledValue)` Sets `this` Decimal to the specified `unscaledValue` and returns `this` now representing `(unscaledValue * 10 ^-scale)` where scale refers to the `scale` of this mutable Decimal.
`MutableDecimal<S>`	`setUnscaled(long unscaledValue, int scale)` Sets `this` Decimal to the specified `unscaledValue` with the given `scale` and returns `this` now representing `(unscaledValue * 10^-scale)`.
`MutableDecimal<S>`	`setUnscaled(long unscaledValue, int scale, RoundingMode roundingMode)` Sets `this` Decimal to the specified `unscaledValue` with the given `scale` and returns `this` now representing `(unscaledValue * 10^-scale)`.
`MutableDecimal<S>`	`setZero()` Sets `this` Decimal to 0 and returns `this` now representing zero.
`MutableDecimal<S>`	`shiftLeft(int n)` Returns a `Decimal` whose value is `(this << n)`.
`MutableDecimal<S>`	`shiftLeft(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this << n)`.
`MutableDecimal<S>`	`shiftLeft(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this << n)`.
`MutableDecimal<S>`	`shiftRight(int n)` Returns a BigInteger whose value is `(this >> n)`.
`MutableDecimal<S>`	`shiftRight(int n, RoundingMode roundingMode)` Returns a BigInteger whose value is `(this >> n)`.
`MutableDecimal<S>`	`shiftRight(int n, TruncationPolicy truncationPolicy)` Returns a BigInteger whose value is `(this >> n)`.
`MutableDecimal<S>`	`sqrt()` Returns a `Decimal` whose value is the square root of `this` Decimal value.
`MutableDecimal<S>`	`sqrt(RoundingMode roundingMode)` Returns a `Decimal` whose value is the square root of `this` Decimal value.
`MutableDecimal<S>`	`square()` Returns a `Decimal` whose value is `(this²)`.
`MutableDecimal<S>`	`square(RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this²)`.
`MutableDecimal<S>`	`square(TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this²)`.
`MutableDecimal<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.
`MutableDecimal<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.
`MutableDecimal<S>`	`subtract(Decimal<S> subtrahend)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`MutableDecimal<S>`	`subtract(Decimal<S> subtrahend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`MutableDecimal<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.
`MutableDecimal<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.
`MutableDecimal<S>`	`subtract(long subtrahend)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`MutableDecimal<S>`	`subtract(long subtrahend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`MutableDecimal<S>`	`subtractSquared(Decimal<S> value)` Returns a `Decimal` whose value is `(this - value²)`.
`MutableDecimal<S>`	`subtractSquared(Decimal<S> value, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this - value²)`.
`MutableDecimal<S>`	`subtractSquared(Decimal<S> value, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this - value²)`.
`MutableDecimal<S>`	`subtractUnscaled(long unscaledSubtrahend)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)` with the `scale` of this Decimal.
`MutableDecimal<S>`	`subtractUnscaled(long unscaledSubtrahend, int scale)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)`.
`MutableDecimal<S>`	`subtractUnscaled(long unscaledSubtrahend, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)`.
`MutableDecimal<S>`	`subtractUnscaled(long unscaledSubtrahend, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)`.
`MutableDecimal<S>`	`subtractUnscaled(long unscaledSubtrahend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)` with the `scale` of this Decimal.

- Method Detail
  - setZero
```
MutableDecimal<S> setZero()
```
    Sets this Decimal to 0 and returns this now representing zero.
    
    Returns:
    this Decimal after assigning the value 0
  - setOne
```
MutableDecimal<S> setOne()
```
    Sets this Decimal to 1 and returns this now representing one.
    
    Returns:
    this Decimal after assigning the value 1
  - setMinusOne
```
MutableDecimal<S> setMinusOne()
```
    Sets this Decimal to -1 and returns this now representing minus one.
    
    Returns:
    this Decimal after assigning the value -1
  - setUlp
```
MutableDecimal<S> setUlp()
```
    Sets this Decimal to the smallest positive value representable by this Mutable Decimal and returns this now representing one ULP.
    
    Returns:
    this Decimal after assigning the value ULP=10^-scale
  - set
```
MutableDecimal<S> set(Decimal<S> value)
```
    Sets this Decimal to the specified value and returns this now representing value.
    
    Parameters:
    value - value to be set
    
    Returns:
    this Decimal after assigning the given value
  - set
```
MutableDecimal<S> set(Decimal<?> value,
                    RoundingMode roundingMode)
```
    Sets this Decimal to the specified value and returns this now representing value. The specified Decimal argument is rounded to the scale of this mutable Decimal using RoundingMode.HALF_UP rounding. An exception is thrown if the specified value is too large to be represented as a Decimal of this mutable Decimal's scale.
    
    Parameters:
    value - value to be set
    roundingMode - the rounding mode to apply during the conversion if necessary
    
    Returns:
    this Decimal after assigning: round_{HALF_UP}(value)
    
    Throws:
    
    IllegalArgumentException - if value is too large to be represented as a Decimal with the scale of this mutable Decimal
    
    ArithmeticException - if roundingMode is UNNESSESSARY and rounding is necessary
  - set
```
MutableDecimal<S> set(long value)
```
    Sets this Decimal to the specified value and returns this now representing value. An exception is thrown if the specified value is too large to be represented as a Decimal of this mutable Decimal's scale.
    
    Parameters:
    value - value to be set
    
    Returns:
    this Decimal after assigning the given value
    
    Throws:
    
    IllegalArgumentException - if value is too large to be represented as a Decimal with the scale of this mutable Decimal
  - set
```
MutableDecimal<S> set(BigInteger value)
```
    Sets this Decimal to the specified value and returns this now representing value. An exception is thrown if the specified value is too large to be represented as a Decimal of this mutable Decimal's scale.
    
    Parameters:
    value - value to be set
    
    Returns:
    this Decimal after assigning the given value
    
    Throws:
    
    IllegalArgumentException - if value is too large to be represented as a Decimal with the scale of this mutable Decimal
  - set
```
MutableDecimal<S> set(float value)
```
    Sets this Decimal to the specified value and returns this now representing value. The specified float argument is rounded to the scale of this mutable Decimal using RoundingMode.HALF_UP rounding. An exception is thrown if the specified value is too large to be represented as a Decimal of this mutable Decimal's scale.
    
    Parameters:
    value - value to be set
    
    Returns:
    this Decimal after assigning: round_{HALF_UP}(value)
    
    Throws:
    
    IllegalArgumentException - if value is NaN or infinite or if the magnitude is too large for the float to be represented as a Decimal with the scale of this mutable Decimal
  - set
```
MutableDecimal<S> set(float value,
                    RoundingMode roundingMode)
```
    Sets this Decimal to the specified value and returns this now representing value. The specified float argument is rounded to the scale of this mutable Decimal using the specified roundingMode. An exception is thrown if the specified value is too large to be represented as a Decimal of this mutable Decimal's scale.
    
    Parameters:
    value - value to be set
    roundingMode - the rounding mode to apply during the conversion if necessary
    
    Returns:
    this Decimal after assigning: round(value)
    
    Throws:
    
    IllegalArgumentException - if value is NaN or infinite or if the magnitude is too large for the float to be represented as a Decimal with the scale of this mutable Decimal
    
    ArithmeticException - if roundingMode is UNNESSESSARY and rounding is necessary
  - set
```
MutableDecimal<S> set(double value)
```
    Sets this Decimal to the specified value and returns this now representing value. The specified double argument is rounded to the scale of this mutable Decimal using RoundingMode.HALF_UP rounding. An exception is thrown if the specified value is too large to be represented as a Decimal of this mutable Decimal's scale.
    
    Parameters:
    value - value to be set
    
    Returns:
    this Decimal after assigning: round_{HALF_UP}(value)
    
    Throws:
    
    IllegalArgumentException - if value is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal with the scale of this mutable Decimal
  - set
```
MutableDecimal<S> set(double value,
                    RoundingMode roundingMode)
```
    Sets this Decimal to the specified value and returns this now representing value. The specified double argument is rounded to the scale of this mutable Decimal using the specified roundingMode. An exception is thrown if the specified value is too large to be represented as a Decimal of this mutable Decimal's scale.
    
    Parameters:
    value - value to be set
    roundingMode - the rounding mode to apply during the conversion if necessary
    
    Returns:
    this Decimal after assigning: round(value)
    
    Throws:
    
    IllegalArgumentException - if value is NaN or infinite or if the magnitude is too large for the double to be represented as a Decimal with the scale of this mutable Decimal
    
    ArithmeticException - if roundingMode is UNNESSESSARY and rounding is necessary
  - set
```
MutableDecimal<S> set(BigDecimal value)
```
    Sets this Decimal to the specified value and returns this now representing value. The specified BigDecimal argument is rounded to the scale of this mutable Decimal using RoundingMode.HALF_UP rounding. An exception is thrown if the specified value is too large to be represented as a Decimal of this mutable Decimal's scale.
    
    Parameters:
    value - value to be set
    
    Returns:
    this Decimal after assigning: round_{HALF_UP}(value)
    
    Throws:
    
    IllegalArgumentException - if value is too large to be represented as a Decimal with the scale of this mutable Decimal
  - set
```
MutableDecimal<S> set(BigDecimal value,
                    RoundingMode roundingMode)
```
    Sets this Decimal to the specified value and returns this now representing value. The specified BigDecimal argument is rounded to the scale of this mutable Decimal using the specified roundingMode. An exception is thrown if the specified value is too large to be represented as a Decimal of this mutable Decimal's scale.
    
    Parameters:
    value - value to be set
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    this Decimal after assigning: round(value)
    
    Throws:
    
    IllegalArgumentException - if value is too large to be represented as a Decimal with the scale of this mutable Decimal
    
    ArithmeticException - if roundingMode is UNNESSESSARY and rounding is necessary
  - setUnscaled
```
MutableDecimal<S> setUnscaled(long unscaledValue)
```
    Sets this Decimal to the specified unscaledValue and returns this now representing (unscaledValue * 10 ^-scale) where scale refers to the scale of this mutable Decimal.
    
    Parameters:
    unscaledValue - value to be set
    
    Returns:
    this Decimal after assigning: unscaledValue * 10^-scale.
  - setUnscaled
```
MutableDecimal<S> setUnscaled(long unscaledValue,
                            int scale)
```
    Sets this Decimal to the specified unscaledValue with the given scale and returns this now representing (unscaledValue * 10^-scale). The value is rounded to the scale of this mutable Decimal using HALF_UP rounding. An exception is thrown if the specified value is too large to be represented as a Decimal of this of this mutable Decimal's scale.
    
    Parameters:
    unscaledValue - value to be set
    scale - the scale used for unscaledValue
    
    Returns:
    this Decimal after assigning: round_{HALF_UP}(unscaledValue * 10^-scale)
    
    Throws:
    
    IllegalArgumentException - if the value is too large to be represented as a Decimal with the scale of this mutable Decimal
  - setUnscaled
```
MutableDecimal<S> setUnscaled(long unscaledValue,
                            int scale,
                            RoundingMode roundingMode)
```
    Sets this Decimal to the specified unscaledValue with the given scale and returns this now representing (unscaledValue * 10^-scale). The value is rounded to the scale of this mutable Decimal using the specified roundingMode. An exception is thrown if the specified value is too large to be represented as a Decimal of this of this mutable Decimal's scale.
    
    Parameters:
    unscaledValue - value to be set
    scale - the scale used for unscaledValue
    roundingMode - the rounding mode to apply during the conversion if necessary
    
    Returns:
    this Decimal after assigning: round(unscaledValue * 10^-scale)
    
    Throws:
    
    IllegalArgumentException - if the value is too large to be represented as a Decimal with the scale of this mutable Decimal
    
    ArithmeticException - if roundingMode is UNNESSESSARY and rounding is necessary
  - set
```
MutableDecimal<S> set(String value)
```
    Parses the given string value and sets this Decimal to the parsed value.
    The string representation of a Decimal consists of an optional sign, '+' or '-' , followed by a sequence of zero or more decimal digits ("the integer"), optionally followed by a fraction.
    The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. If the fraction contains more digits than this mutable Decimal's scale, the value is rounded using HALF_UP rounding. An exception is thrown if the value is too large to be represented as a Decimal of this mutable Decimals's scale.
    
    Parameters:
    value - the string value to parse and assign
    
    Returns:
    this Decimal after assigning the parsed value
    
    Throws:
    
    NumberFormatException - if value does not represent a valid Decimal or if the value is too large to be represented as a Decimal with the scale of this mutable Decimal's scale
  - set
```
MutableDecimal<S> set(String value,
                    RoundingMode roundingMode)
```
    Parses the given string value and sets this Decimal to the parsed value.
    The string representation of a Decimal consists of an optional sign, '+' or '-' , followed by a sequence of zero or more decimal digits ("the integer"), optionally followed by a fraction.
    The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. If the fraction contains more digits than this mutable Decimal's scale, the value is rounded using the specified roundingMode. An exception is thrown if the value is too large to be represented as a Decimal of this mutable Decimals's scale.
    
    Parameters:
    value - the string value to parse and assign
    roundingMode - the rounding mode to apply if the fraction contains more digits than the scale of this mutable Decimal
    
    Returns:
    this Decimal after assigning the parsed value
    
    Throws:
    
    NumberFormatException - if value does not represent a valid Decimal or if the value is too large to be represented as a Decimal with the scale of this mutable Decimal's scale
    
    ArithmeticException - if roundingMode==UNNECESSARY and rounding is necessary
  - min
```
MutableDecimal<S> min(MutableDecimal<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:
    Decimal.compareTo(Decimal)
  - max
```
MutableDecimal<S> max(MutableDecimal<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:
    Decimal.compareTo(Decimal)
  - clone
```
MutableDecimal<S> clone()
```
    Returns a clone of this mutable Decimal numerically identical to this value.
    
    Returns:
    a numerically identical clone of this value
  - integralPart
```
MutableDecimal<S> integralPart()
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    integralPart in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    ⌊this⌋ for non-negative and ⌈this⌉ for negative values
    See Also:
    Decimal.fractionalPart(), Decimal.isIntegral(), Decimal.isIntegralPartZero(), Decimal.round(int, RoundingMode)
  - fractionalPart
```
MutableDecimal<S> fractionalPart()
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    fractionalPart in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    this-integralPart() which is always less than one and greater than minus one
    See Also:
    Decimal.integralPart(), Decimal.isIntegral(), Decimal.isIntegralPartZero()
  - round
```
MutableDecimal<S> round(int precision)
```
    Description copied from interface: Decimal
    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
    Specified by:
    
    round in interface Decimal<S extends ScaleMetrics>
    
    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
    See Also:
    Decimal.round(int, RoundingMode), Decimal.round(int, TruncationPolicy), Decimal.scale(int)
  - round
```
MutableDecimal<S> round(int precision,
                      RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    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
    Specified by:
    
    round in interface Decimal<S extends ScaleMetrics>
    
    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
    See Also:
    Decimal.round(int), Decimal.round(int, TruncationPolicy), Decimal.scale(int, RoundingMode)
  - round
```
MutableDecimal<S> round(int precision,
                      TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    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
    Specified by:
    
    round in interface Decimal<S extends ScaleMetrics>
    
    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
    See Also:
    Decimal.round(int), Decimal.round(int, RoundingMode), Decimal.scale(int, RoundingMode)
  - scale
```
MutableDecimal<?> scale(int scale)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    scale in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    scale - the scale to use for the result, must be in [0,18]
    
    Returns:
    a Decimal instance with the given new scale
    See Also:
    Decimal.scale(ScaleMetrics), Decimal.scale(int, RoundingMode), Decimal.round(int)
  - scale
```
<S extends ScaleMetrics> MutableDecimal<S> scale(S scaleMetrics)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    scale in interface Decimal<S extends ScaleMetrics>
    
    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
    See Also:
    Decimal.scale(int), Decimal.scale(ScaleMetrics, RoundingMode), Decimal.round(int)
  - scale
```
MutableDecimal<?> scale(int scale,
                      RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    scale in interface Decimal<S extends ScaleMetrics>
    
    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
    See Also:
    Decimal.scale(int), Decimal.scale(ScaleMetrics, RoundingMode), Decimal.round(int, RoundingMode)
  - scale
```
<S extends ScaleMetrics> MutableDecimal<S> scale(S scaleMetrics,
                                               RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    scale in interface Decimal<S extends ScaleMetrics>
    
    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
    See Also:
    Decimal.scale(ScaleMetrics), Decimal.scale(int, RoundingMode), Decimal.round(int, RoundingMode)
  - add
```
MutableDecimal<S> add(Decimal<S> augend)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    add in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    augend - value to be added to this Decimal
    
    Returns:
    this + augend
  - add
```
MutableDecimal<S> add(Decimal<S> augend,
                    OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    add in interface Decimal<S extends ScaleMetrics>
    
    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
  - add
```
MutableDecimal<S> add(Decimal<?> augend,
                    RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    add in interface Decimal<S extends ScaleMetrics>
    
    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)
  - add
```
MutableDecimal<S> add(Decimal<?> augend,
                    TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    add in interface Decimal<S extends ScaleMetrics>
    
    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)
  - add
```
MutableDecimal<S> add(long augend)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    add in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    augend - long value to be added to this Decimal
    
    Returns:
    this + augend
  - add
```
MutableDecimal<S> add(long augend,
                    OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    add in interface Decimal<S extends ScaleMetrics>
    
    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
  - add
```
MutableDecimal<S> add(double augend)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    add in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    augend - value to be added to this Decimal
    
    Returns:
    this + round_{HALF_UP}(augend)
  - add
```
MutableDecimal<S> add(double augend,
                    RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    add in interface Decimal<S extends ScaleMetrics>
    
    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)
  - addUnscaled
```
MutableDecimal<S> addUnscaled(long unscaledAugend)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    addUnscaled in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    unscaledAugend - value to be added to this Decimal
    
    Returns:
    round_{HALF_UP}(this + unscaledAugend × 10^-scale)
  - addUnscaled
```
MutableDecimal<S> addUnscaled(long unscaledAugend,
                            OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    addUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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)
  - addUnscaled
```
MutableDecimal<S> addUnscaled(long unscaledAugend,
                            int scale)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    addUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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
```
MutableDecimal<S> addUnscaled(long unscaledAugend,
                            int scale,
                            RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    addUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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)
  - addUnscaled
```
MutableDecimal<S> addUnscaled(long unscaledAugend,
                            int scale,
                            TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    addUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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)
  - addSquared
```
MutableDecimal<S> addSquared(Decimal<S> value)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    addSquared in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    value - value to be squared and added to this Decimal
    
    Returns:
    this + round_{HALF_UP}(value*value)
  - addSquared
```
MutableDecimal<S> addSquared(Decimal<S> value,
                           RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    addSquared in interface Decimal<S extends ScaleMetrics>
    
    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)
  - addSquared
```
MutableDecimal<S> addSquared(Decimal<S> value,
                           TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    addSquared in interface Decimal<S extends ScaleMetrics>
    
    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)
  - subtract
```
MutableDecimal<S> subtract(Decimal<S> subtrahend)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtract in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    subtrahend - value to be subtracted from this Decimal
    
    Returns:
    this - subtrahend
  - subtract
```
MutableDecimal<S> subtract(Decimal<S> subtrahend,
                         OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtract in interface Decimal<S extends ScaleMetrics>
    
    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
  - subtract
```
MutableDecimal<S> subtract(Decimal<?> subtrahend,
                         RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtract in interface Decimal<S extends ScaleMetrics>
    
    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)
  - subtract
```
MutableDecimal<S> subtract(Decimal<?> subtrahend,
                         TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtract in interface Decimal<S extends ScaleMetrics>
    
    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)
  - subtract
```
MutableDecimal<S> subtract(long subtrahend)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtract in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    subtrahend - long value to be subtracted from this Decimal
    
    Returns:
    this - subtrahend
  - subtract
```
MutableDecimal<S> subtract(long subtrahend,
                         OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtract in interface Decimal<S extends ScaleMetrics>
    
    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
  - subtract
```
MutableDecimal<S> subtract(double subtrahend)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtract in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    subtrahend - value to be subtracted from this Decimal
    
    Returns:
    this - round_{HALF_UP}(subtrahend)
  - subtract
```
MutableDecimal<S> subtract(double subtrahend,
                         RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtract in interface Decimal<S extends ScaleMetrics>
    
    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)
  - subtractUnscaled
```
MutableDecimal<S> subtractUnscaled(long unscaledSubtrahend)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtractUnscaled in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    unscaledSubtrahend - value to be subtracted from this Decimal
    
    Returns:
    this - unscaledSubtrahend × 10^-scale
  - subtractUnscaled
```
MutableDecimal<S> subtractUnscaled(long unscaledSubtrahend,
                                 OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtractUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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
  - subtractUnscaled
```
MutableDecimal<S> subtractUnscaled(long unscaledSubtrahend,
                                 int scale)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtractUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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
```
MutableDecimal<S> subtractUnscaled(long unscaledSubtrahend,
                                 int scale,
                                 RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtractUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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)
  - subtractUnscaled
```
MutableDecimal<S> subtractUnscaled(long unscaledSubtrahend,
                                 int scale,
                                 TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtractUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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)
  - subtractSquared
```
MutableDecimal<S> subtractSquared(Decimal<S> value)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtractSquared in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    value - value to be squared and subtracted from this Decimal
    
    Returns:
    this - round_{HALF_UP}(value*value)
  - subtractSquared
```
MutableDecimal<S> subtractSquared(Decimal<S> value,
                                RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtractSquared in interface Decimal<S extends ScaleMetrics>
    
    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)
  - subtractSquared
```
MutableDecimal<S> subtractSquared(Decimal<S> value,
                                TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    subtractSquared in interface Decimal<S extends ScaleMetrics>
    
    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)
  - multiply
```
MutableDecimal<S> multiply(Decimal<S> multiplicand)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiply in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * multiplicand)
  - multiply
```
MutableDecimal<S> multiply(Decimal<S> multiplicand,
                         RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiply in interface Decimal<S extends ScaleMetrics>
    
    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)
  - multiply
```
MutableDecimal<S> multiply(Decimal<S> multiplicand,
                         TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiply in interface Decimal<S extends ScaleMetrics>
    
    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)
  - multiplyBy
```
MutableDecimal<S> multiplyBy(Decimal<?> multiplicand)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyBy in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * multiplicand)
  - multiplyBy
```
MutableDecimal<S> multiplyBy(Decimal<?> multiplicand,
                           RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyBy in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    roundingMode - the rounding mode to apply if rounding is necessary
    
    Returns:
    round(this * multiplicand)
  - multiplyBy
```
MutableDecimal<S> multiplyBy(Decimal<?> multiplicand,
                           TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyBy in interface Decimal<S extends ScaleMetrics>
    
    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)
  - multiplyExact
```
MutableDecimal<?> multiplyExact(Decimal<?> multiplicand)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyExact in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    (this * multiplicand) with scale equal to the sum of scales of this and multiplicand
  - multiply
```
MutableDecimal<S> multiply(long multiplicand)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiply in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    (this * multiplicand)
  - multiply
```
MutableDecimal<S> multiply(long multiplicand,
                         OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiply in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    overflowMode - the overflow mode to apply if the multiplication leads to an overflow
    
    Returns:
    (this * multiplicand)
  - multiply
```
MutableDecimal<S> multiply(double multiplicand)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiply in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    multiplicand - factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * round_{HALF_UP}(multiplicand))
  - multiply
```
MutableDecimal<S> multiply(double multiplicand,
                         RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiply in interface Decimal<S extends ScaleMetrics>
    
    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))
  - multiplyUnscaled
```
MutableDecimal<S> multiplyUnscaled(long unscaledMultiplicand)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyUnscaled in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    unscaledMultiplicand - factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * unscaledMultiplicand × 10^-scale)
  - multiplyUnscaled
```
MutableDecimal<S> multiplyUnscaled(long unscaledMultiplicand,
                                 RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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)
  - multiplyUnscaled
```
MutableDecimal<S> multiplyUnscaled(long unscaledMultiplicand,
                                 TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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)
  - multiplyUnscaled
```
MutableDecimal<S> multiplyUnscaled(long unscaledMultiplicand,
                                 int scale)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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
```
MutableDecimal<S> multiplyUnscaled(long unscaledMultiplicand,
                                 int scale,
                                 RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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)
  - multiplyUnscaled
```
MutableDecimal<S> multiplyUnscaled(long unscaledMultiplicand,
                                 int scale,
                                 TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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)
  - multiplyByPowerOfTen
```
MutableDecimal<S> multiplyByPowerOfTen(int n)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyByPowerOfTen in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    n - the exponent of the power-of-ten factor to multiply with this Decimal
    
    Returns:
    round_{HALF_UP}(this * 10ⁿ)
  - multiplyByPowerOfTen
```
MutableDecimal<S> multiplyByPowerOfTen(int n,
                                     RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyByPowerOfTen in interface Decimal<S extends ScaleMetrics>
    
    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ⁿ)
  - multiplyByPowerOfTen
```
MutableDecimal<S> multiplyByPowerOfTen(int n,
                                     TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    multiplyByPowerOfTen in interface Decimal<S extends ScaleMetrics>
    
    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ⁿ)
  - divide
```
MutableDecimal<S> divide(Decimal<S> divisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divide in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / divisor)
  - divide
```
MutableDecimal<S> divide(Decimal<S> divisor,
                       RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divide in interface Decimal<S extends ScaleMetrics>
    
    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)
  - divide
```
MutableDecimal<S> divide(Decimal<S> divisor,
                       TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divide in interface Decimal<S extends ScaleMetrics>
    
    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)
  - divideBy
```
MutableDecimal<S> divideBy(Decimal<?> divisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideBy in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / divisor)
  - divideBy
```
MutableDecimal<S> divideBy(Decimal<?> divisor,
                         RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideBy in interface Decimal<S extends ScaleMetrics>
    
    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)
  - divideBy
```
MutableDecimal<S> divideBy(Decimal<?> divisor,
                         TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideBy in interface Decimal<S extends ScaleMetrics>
    
    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)
  - divideTruncate
```
MutableDecimal<S> divideTruncate(Decimal<S> divisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideTruncate in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_DOWN(this / divisor)
  - divideExact
```
MutableDecimal<S> divideExact(Decimal<S> divisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideExact in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    this / divisor
  - divide
```
MutableDecimal<S> divide(long divisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divide in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    divisor - long value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / divisor)
  - divide
```
MutableDecimal<S> divide(long divisor,
                       RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divide in interface Decimal<S extends ScaleMetrics>
    
    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)
  - divide
```
MutableDecimal<S> divide(long divisor,
                       TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divide in interface Decimal<S extends ScaleMetrics>
    
    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)
  - divide
```
MutableDecimal<S> divide(double divisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divide in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    divisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / round_{HALF_UP}(divisor))
  - divide
```
MutableDecimal<S> divide(double divisor,
                       RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divide in interface Decimal<S extends ScaleMetrics>
    
    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))
  - divideUnscaled
```
MutableDecimal<S> divideUnscaled(long unscaledDivisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideUnscaled in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    unscaledDivisor - divisor value by which this Decimal is to be divided
    
    Returns:
    round_{HALF_UP}(this / (unscaledDivisor × 10^-scale))
  - divideUnscaled
```
MutableDecimal<S> divideUnscaled(long unscaledDivisor,
                               RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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))
  - divideUnscaled
```
MutableDecimal<S> divideUnscaled(long unscaledDivisor,
                               TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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))
  - divideUnscaled
```
MutableDecimal<S> divideUnscaled(long unscaledDivisor,
                               int scale)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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))
  - divideUnscaled
```
MutableDecimal<S> divideUnscaled(long unscaledDivisor,
                               int scale,
                               RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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))
  - divideUnscaled
```
MutableDecimal<S> divideUnscaled(long unscaledDivisor,
                               int scale,
                               TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideUnscaled in interface Decimal<S extends ScaleMetrics>
    
    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))
  - divideByPowerOfTen
```
MutableDecimal<S> divideByPowerOfTen(int n)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideByPowerOfTen in interface Decimal<S extends ScaleMetrics>
    
    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
```
MutableDecimal<S> divideByPowerOfTen(int n,
                                   RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideByPowerOfTen in interface Decimal<S extends ScaleMetrics>
    
    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ⁿ)
  - divideByPowerOfTen
```
MutableDecimal<S> divideByPowerOfTen(int n,
                                   TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideByPowerOfTen in interface Decimal<S extends ScaleMetrics>
    
    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ⁿ)
  - divideToIntegralValue
```
MutableDecimal<S> divideToIntegralValue(Decimal<S> divisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideToIntegralValue in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    divisor - value by which this Decimal is to be divided.
    
    Returns:
    The integer part of (this / divisor).
    See Also:
    Decimal.divideToIntegralValue(Decimal, OverflowMode), Decimal.divideToLongValue(Decimal), Decimal.remainder(Decimal)
  - divideToIntegralValue
```
MutableDecimal<S> divideToIntegralValue(Decimal<S> divisor,
                                      OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideToIntegralValue in interface Decimal<S extends ScaleMetrics>
    
    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).
    See Also:
    Decimal.divideToIntegralValue(Decimal), Decimal.divideToLongValue(Decimal), Decimal.remainder(Decimal)
  - divideAndRemainder
```
MutableDecimal<S>[] divideAndRemainder(Decimal<S> divisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideAndRemainder in interface Decimal<S extends ScaleMetrics>
    
    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.
    See Also:
    Decimal.divideAndRemainder(Decimal, OverflowMode), Decimal.divideToIntegralValue(Decimal), Decimal.remainder(Decimal)
  - divideAndRemainder
```
MutableDecimal<S>[] divideAndRemainder(Decimal<S> divisor,
                                     OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    divideAndRemainder in interface Decimal<S extends ScaleMetrics>
    
    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.
    See Also:
    Decimal.divideAndRemainder(Decimal), Decimal.divideToIntegralValue(Decimal), Decimal.remainder(Decimal)
  - remainder
```
MutableDecimal<S> remainder(Decimal<S> divisor)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    remainder in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    divisor - value by which this Decimal is to be divided.
    
    Returns:
    this % divisor.
    See Also:
    Decimal.divideToIntegralValue(Decimal), Decimal.divideAndRemainder(Decimal)
  - negate
```
MutableDecimal<S> negate()
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    negate in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    -this
  - negate
```
MutableDecimal<S> negate(OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    negate in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    overflowMode - the overflow mode to apply
    
    Returns:
    -this
  - abs
```
MutableDecimal<S> abs()
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    abs in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    abs(this)
  - abs
```
MutableDecimal<S> abs(OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    abs in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    overflowMode - the overflow mode to apply
    
    Returns:
    abs(this)
  - invert
```
MutableDecimal<S> invert()
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    invert in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    round_{HALF_UP}(1 / this)
  - invert
```
MutableDecimal<S> invert(RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    invert in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(1 / this)
  - invert
```
MutableDecimal<S> invert(TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    invert in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(1 / this)
  - square
```
MutableDecimal<S> square()
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    square in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    round_{HALF_UP}(this * this)
  - square
```
MutableDecimal<S> square(RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    square in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    round(this * this)
  - square
```
MutableDecimal<S> square(TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    square in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    truncationPolicy - the truncation policy specifying RoundingMode and OverflowMode to apply if rounding is necessary or if an overflow occurs
    
    Returns:
    round(this * this)
  - sqrt
```
MutableDecimal<S> sqrt()
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    sqrt in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    sqrt(this)
  - sqrt
```
MutableDecimal<S> sqrt(RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    sqrt in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    roundingMode - the rounding mode to apply if the result needs to be rounded
    
    Returns:
    sqrt(this)
  - shiftLeft
```
MutableDecimal<S> shiftLeft(int n)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    shiftLeft in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    n - shift distance, in bits.
    
    Returns:
    this << n
    See Also:
    Decimal.shiftRight(int)
  - shiftLeft
```
MutableDecimal<S> shiftLeft(int n,
                          RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    shiftLeft in interface Decimal<S extends ScaleMetrics>
    
    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
    See Also:
    Decimal.shiftRight(int)
  - shiftLeft
```
MutableDecimal<S> shiftLeft(int n,
                          TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    shiftLeft in interface Decimal<S extends ScaleMetrics>
    
    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
    See Also:
    Decimal.shiftRight(int)
  - shiftRight
```
MutableDecimal<S> shiftRight(int n)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    shiftRight in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    n - shift distance, in bits.
    
    Returns:
    this >> n
    See Also:
    Decimal.shiftLeft(int)
  - shiftRight
```
MutableDecimal<S> shiftRight(int n,
                           RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    shiftRight in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    n - shift distance, in bits.
    roundingMode - the rounding mode to use if truncation is involved
    
    Returns:
    this >> n
    See Also:
    Decimal.shiftLeft(int)
  - shiftRight
```
MutableDecimal<S> shiftRight(int n,
                           TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    shiftRight in interface Decimal<S extends ScaleMetrics>
    
    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
    See Also:
    Decimal.shiftLeft(int)
  - pow
```
MutableDecimal<S> pow(int n)
```
    Description copied from interface: Decimal
    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.
    Specified by:
    
    pow in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    n - power to raise this Decimal to
    
    Returns:
    thisⁿ using the ANSI standard X3.274-1996 algorithm
  - pow
```
MutableDecimal<S> pow(int n,
                    RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    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.
    Specified by:
    
    pow in interface Decimal<S extends ScaleMetrics>
    
    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
  - pow
```
MutableDecimal<S> pow(int n,
                    TruncationPolicy truncationPolicy)
```
    Description copied from interface: Decimal
    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.
    Specified by:
    
    pow in interface Decimal<S extends ScaleMetrics>
    
    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
  - avg
```
MutableDecimal<S> avg(Decimal<S> val)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    avg in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    val - value with which the average is to be computed.
    
    Returns:
    round_{HALF_UP}((this + val) / 2)
  - avg
```
MutableDecimal<S> avg(Decimal<S> val,
                    RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    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.
    
    Specified by:
    
    avg in interface Decimal<S extends ScaleMetrics>
    
    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)

Interface MutableDecimal<S extends ScaleMetrics>

Method Summary

Methods inherited from interface org.decimal4j.api.Decimal

Method Detail

setZero

setOne

setMinusOne

setUlp

set

set

set

set

set

set

set

set

set

set

setUnscaled

setUnscaled

setUnscaled

set

set

min

max

clone

integralPart

fractionalPart

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

multiplyUnscaled