AbstractDecimal (decimal4j API 1.0.3)

java.lang.Object
- java.lang.Number
- - org.decimal4j.base.AbstractDecimal<S,D>

Type Parameters:
S - the scale metrics type associated with this decimal
D - the concrete class implementing this decimal

All Implemented Interfaces:

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

Direct Known Subclasses:

AbstractImmutableDecimal, AbstractMutableDecimal
```
public abstract class AbstractDecimal<S extends ScaleMetrics,D extends AbstractDecimal<S,D>>
extends Number
implements Decimal<S>
```
Common base class for immutable and mutable Decimal numbers of different scales.

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description

AbstractDecimal()

Constructors
Constructor and Description
`AbstractDecimal()`

Method Summary

Methods
Modifier and Type	Method and Description
`D`	`abs()` Returns a `Decimal` whose value is the absolute value of this `Decimal`.
`D`	`abs(OverflowMode overflowMode)` Returns a `Decimal` whose value is the absolute value of this `Decimal`.
`D`	`add(Decimal<?> augend, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + augend)`.
`D`	`add(Decimal<?> augend, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this + augend)`.
`D`	`add(Decimal<S> augend)` Returns a `Decimal` whose value is `(this + augend)`.
`D`	`add(Decimal<S> augend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this + augend)`.
`D`	`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.
`D`	`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.
`D`	`add(long augend)` Returns a `Decimal` whose value is `(this + augend)` after converting the given `long` value to the scale of `this` Decimal.
`D`	`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.
`D`	`addSquared(Decimal<S> value)` Returns a `Decimal` whose value is `(this + value²)`.
`D`	`addSquared(Decimal<S> value, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + value²)`.
`D`	`addSquared(Decimal<S> value, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this + value²)`.
`D`	`addUnscaled(long unscaledAugend)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)` with the `scale` of this Decimal.
`D`	`addUnscaled(long unscaledAugend, int scale)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)`.
`D`	`addUnscaled(long unscaledAugend, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)`.
`D`	`addUnscaled(long unscaledAugend, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)`.
`D`	`addUnscaled(long unscaledAugend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this + unscaledAugend × 10^-scale)` with the `scale` of this Decimal.
`D`	`avg(Decimal<S> val)` Returns the average of this `Decimal` and `val`.
`D`	`avg(Decimal<S> val, RoundingMode roundingMode)` Returns the average of this `Decimal` and `val`.
`byte`	`byteValueExact()` Converts this `Decimal` to a `byte`, checking for lost information.
`int`	`compareTo(Decimal<S> other)` Compares two `Decimal` objects numerically.
`int`	`compareToNumerically(Decimal<?> other)` Compares this `Decimal` with the specified `Decimal`.
`protected abstract D`	`create(long unscaled)` Returns a new `Decimal` whose value is `(unscaled × 10^-scale)`.
`protected abstract D[]`	`createArray(int length)` Returns a new `Decimal` array of the specified `length`.
`protected abstract D`	`createOrAssign(long unscaled)` Returns this or a new `Decimal` whose value is `(unscaled × 10^-scale)`.
`D`	`divide(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)`.
`D`	`divide(Decimal<S> divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)`.
`D`	`divide(Decimal<S> divisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / divisor)`.
`D`	`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.
`D`	`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.
`D`	`divide(long divisor)` Returns a `Decimal` whose value is `(this / divisor)`.
`D`	`divide(long divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)`.
`D`	`divide(long divisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / divisor)`.
`D[]`	`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.
`D[]`	`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.
`D`	`divideBy(Decimal<?> divisor)` Returns a `Decimal` whose value is `(this / divisor)`.
`D`	`divideBy(Decimal<?> divisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / divisor)`.
`D`	`divideBy(Decimal<?> divisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / divisor)`.
`D`	`divideByPowerOfTen(int n)` Returns a `Decimal` whose value is `(this / 10ⁿ)` .
`D`	`divideByPowerOfTen(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / 10ⁿ)` .
`D`	`divideByPowerOfTen(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / 10ⁿ)` .
`D`	`divideExact(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)`, checking for lost information.
`D`	`divideToIntegralValue(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)` rounded down to the next integer.
`D`	`divideToIntegralValue(Decimal<S> divisor, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this / divisor)` rounded down to the next integer.
`long`	`divideToLongValue(Decimal<S> divisor)` Returns a `Decimal` whose value `(this / divisor)` rounded down to the next `long` value.
`long`	`divideToLongValue(Decimal<S> divisor, OverflowMode overflowMode)` Returns a `Decimal` whose value `(this / divisor)` rounded down to the next `long` value.
`D`	`divideTruncate(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this / divisor)` rounded down.
`D`	`divideUnscaled(long unscaledDivisor)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))` with the `scale` of this Decimal.
`D`	`divideUnscaled(long unscaledDivisor, int scale)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))`.
`D`	`divideUnscaled(long unscaledDivisor, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))`.
`D`	`divideUnscaled(long unscaledDivisor, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))`.
`D`	`divideUnscaled(long unscaledDivisor, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))` with the `scale` of this Decimal.
`D`	`divideUnscaled(long unscaledDivisor, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this / (unscaledDivisor × 10^-scale))` with the `scale` of this Decimal.
`double`	`doubleValue()` Converts this `Decimal` to a `double`.
`double`	`doubleValue(RoundingMode roundingMode)` Converts this `Decimal` to a `double` using the specified rounding mode if the Decimal value can not be exactly represented as a double value.
`boolean`	`equals(Object obj)` Compares this Decimal to the specified object.
`float`	`floatValue()` Converts this `Decimal` to a `float`.
`float`	`floatValue(RoundingMode roundingMode)` Converts this `Decimal` to a `float` using the specified rounding mode if the Decimal value can not be exactly represented as a float value.
`D`	`fractionalPart()` Returns a `Decimal` whose value represents the fractional part of `(this)` value.
`protected DecimalArithmetic`	`getArithmeticFor(OverflowMode overflowMode)` Returns the default arithmetic performing checked operations with rounding mode `HALF_UP` and the specified `overflowMode`.
`protected DecimalArithmetic`	`getArithmeticFor(RoundingMode roundingMode)` Returns the arithmetic performing unchecked operations with the specified `RoundingMode`.
`protected DecimalArithmetic`	`getArithmeticFor(TruncationPolicy truncationPolicy)` Returns the arithmetic for the specified `truncationPolicy`.
`protected DecimalArithmetic`	`getCheckedArithmeticFor(RoundingMode roundingMode)` Returns the arithmetic performing checked operations with the specified `RoundingMode`.
`protected DecimalArithmetic`	`getDefaultArithmetic()` Returns the default arithmetic performing unchecked operations with rounding mode `HALF_UP`.
`protected DecimalArithmetic`	`getDefaultCheckedArithmetic()` Returns the default arithmetic performing checked operations with rounding mode `HALF_UP`.
`protected DecimalArithmetic`	`getRoundingDownArithmetic()` Returns the arithmetic performing unchecked operations with rounding mode `DOWN`.
`protected DecimalArithmetic`	`getRoundingFloorArithmetic()` Returns the arithmetic performing unchecked operations with rounding mode `FLOOR`.
`protected DecimalArithmetic`	`getRoundingHalfEvenArithmetic()` Returns the arithmetic performing unchecked operations with rounding mode `HALF_EVEN`.
`protected DecimalArithmetic`	`getRoundingUnnecessaryArithmetic()` Returns the arithmetic performing unchecked operations with rounding mode `UNNECESSARY`.
`int`	`hashCode()` Returns a hash code for this `Decimal`.
`D`	`integralPart()` Returns a `Decimal` whose value represents the integral part of `this` Decimal.
`int`	`intValue()` Converts this `Decimal` to an `int`.
`int`	`intValueExact()` Converts this `Decimal` to an `int`, checking for lost information.
`D`	`invert()` Returns a `Decimal` whose value is `(1 / this)`.
`D`	`invert(RoundingMode roundingMode)` Returns a `Decimal` whose value is `(1 / this)`.
`D`	`invert(TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(1 / this)`.
`boolean`	`isBetweenZeroAndMinusOne()` Returns true if this `Decimal` is between zero (inclusive) and minus one (exclusive).
`boolean`	`isBetweenZeroAndOne()` Returns true if this `Decimal` is between zero (inclusive) and one (exclusive).
`boolean`	`isEqualTo(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if the two are numerically equal.
`boolean`	`isEqualToNumerically(Decimal<?> other)` Compares this `Decimal` with the specified `Decimal` and returns true if the two are numerically equal.
`boolean`	`isGreaterThan(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if this Decimal is numerically greater than `other`.
`boolean`	`isGreaterThanOrEqualTo(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if this Decimal is numerically greater than or equal to `other`.
`boolean`	`isIntegral()` Returns true if this `Decimal` number is integral, or equivalently if its `fractional part` is zero.
`boolean`	`isIntegralPartZero()` Returns true if the `integral part` of this `Decimal` number is zero.
`boolean`	`isLessThan(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if this Decimal is numerically less than `other`.
`boolean`	`isLessThanOrEqualTo(Decimal<S> other)` Compares this `Decimal` with the specified `Decimal` and returns true if this Decimal is numerically less than or equal to `other`.
`boolean`	`isMinusOne()` Returns true if this `Decimal` is minus one.
`boolean`	`isNegative()` Returns true if this `Decimal` is negative.
`boolean`	`isNonNegative()` Returns true if this `Decimal` is not negative.
`boolean`	`isNonPositive()` Returns true if this `Decimal` is not positive.
`boolean`	`isOne()` Returns true if this `Decimal` is one.
`boolean`	`isPositive()` Returns true if this `Decimal` is strictly positive.
`boolean`	`isUlp()` Returns true if this `Decimal` is equal to the smallest positive number representable by a Decimal with the current `scale`.
`boolean`	`isZero()` Returns true if this `Decimal` is zero.
`long`	`longValue()` Converts this `Decimal` to a `long`.
`long`	`longValue(RoundingMode roundingMode)` Converts this `Decimal` to a `long` using the specified rounding mode if necessary.
`long`	`longValueExact()` Converts this `Decimal` to a `long`, checking for lost information.
`D`	`max(D val)` Returns the maximum of this `Decimal` and `val`.
`Decimal<S>`	`max(Decimal<S> val)` Returns the maximum of this `Decimal` and `val`.
`D`	`min(D val)` Returns the minimum of this `Decimal` and `val`.
`Decimal<S>`	`min(Decimal<S> val)` Returns the minimum of this `Decimal` and `val`.
`D`	`multiply(Decimal<S> multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`D`	`multiply(Decimal<S> multiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`D`	`multiply(Decimal<S> multiplicand, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`D`	`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.
`D`	`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.
`D`	`multiply(long multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`D`	`multiply(long multiplicand, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`D`	`multiplyBy(Decimal<?> multiplicand)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`D`	`multiplyBy(Decimal<?> multiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`D`	`multiplyBy(Decimal<?> multiplicand, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * multiplicand)`.
`D`	`multiplyByPowerOfTen(int n)` Returns a `Decimal` whose value is `(this * 10ⁿ)` .
`D`	`multiplyByPowerOfTen(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * 10ⁿ)` .
`D`	`multiplyByPowerOfTen(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * 10ⁿ)` .
`D`	`multiplyUnscaled(long unscaledMultiplicand)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)` with the `scale` of this Decimal.
`D`	`multiplyUnscaled(long unscaledMultiplicand, int scale)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)`.
`D`	`multiplyUnscaled(long unscaledMultiplicand, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)`.
`D`	`multiplyUnscaled(long unscaledMultiplicand, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)`.
`D`	`multiplyUnscaled(long unscaledMultiplicand, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)` with the `scale` of this Decimal.
`D`	`multiplyUnscaled(long unscaledMultiplicand, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this * unscaledMultiplicand × 10^-scale)` with the `scale` of this Decimal.
`D`	`negate()` Returns a `Decimal` whose value is `(-this)`.
`D`	`negate(OverflowMode overflowMode)` Returns a `Decimal` whose value is `(-this)`.
`D`	`pow(int n)` Returns a `Decimal` whose value is `(thisⁿ)` using default `HALF_UP` rounding.
`D`	`pow(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(thisⁿ)` applying the specified `roundingMode`.
`D`	`pow(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(thisⁿ)` applying the `RoundingMode` specified by `truncationPolicy`.
`D`	`remainder(Decimal<S> divisor)` Returns a `Decimal` whose value is `(this % divisor)`.
`D`	`round(int precision)` Returns a `Decimal` value rounded to the specified `precision` using `HALF_UP` rounding.
`D`	`round(int precision, RoundingMode roundingMode)` Returns a `Decimal` value rounded to the specified `precision` using the given rounding mode.
`D`	`round(int precision, TruncationPolicy truncationPolicy)` Returns a `Decimal` value rounded to the specified `precision` using the given truncation policy.
`protected abstract D`	`self()` Returns `this` decimal value as concrete implementation subtype.
`D`	`shiftLeft(int n)` Returns a `Decimal` whose value is `(this << n)`.
`D`	`shiftLeft(int n, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this << n)`.
`D`	`shiftLeft(int n, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this << n)`.
`D`	`shiftRight(int n)` Returns a BigInteger whose value is `(this >> n)`.
`D`	`shiftRight(int n, RoundingMode roundingMode)` Returns a BigInteger whose value is `(this >> n)`.
`D`	`shiftRight(int n, TruncationPolicy truncationPolicy)` Returns a BigInteger whose value is `(this >> n)`.
`short`	`shortValueExact()` Converts this `Decimal` to a `short`, checking for lost information.
`int`	`signum()` Returns the signum function of this `Decimal`.
`D`	`sqrt()` Returns a `Decimal` whose value is the square root of `this` Decimal value.
`D`	`sqrt(RoundingMode roundingMode)` Returns a `Decimal` whose value is the square root of `this` Decimal value.
`D`	`square()` Returns a `Decimal` whose value is `(this²)`.
`D`	`square(RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this²)`.
`D`	`square(TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this²)`.
`D`	`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.
`D`	`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.
`D`	`subtract(Decimal<S> subtrahend)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`D`	`subtract(Decimal<S> subtrahend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`D`	`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.
`D`	`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.
`D`	`subtract(long subtrahend)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`D`	`subtract(long subtrahend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this - subtrahend)`.
`D`	`subtractSquared(Decimal<S> value)` Returns a `Decimal` whose value is `(this - value²)`.
`D`	`subtractSquared(Decimal<S> value, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this - value²)`.
`D`	`subtractSquared(Decimal<S> value, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this - value²)`.
`D`	`subtractUnscaled(long unscaledSubtrahend)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)` with the `scale` of this Decimal.
`D`	`subtractUnscaled(long unscaledSubtrahend, int scale)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)`.
`D`	`subtractUnscaled(long unscaledSubtrahend, int scale, RoundingMode roundingMode)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)`.
`D`	`subtractUnscaled(long unscaledSubtrahend, int scale, TruncationPolicy truncationPolicy)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)`.
`D`	`subtractUnscaled(long unscaledSubtrahend, OverflowMode overflowMode)` Returns a `Decimal` whose value is `(this - unscaledSubtrahend × 10^-scale)` with the `scale` of this Decimal.
`BigDecimal`	`toBigDecimal()` Converts this `Decimal` to a `BigDecimal` using the same `scale` as this Decimal value.
`BigDecimal`	`toBigDecimal(int scale, RoundingMode roundingMode)` Returns a `BigDecimal` value of the given scale using the specified rounding mode if necessary.
`BigInteger`	`toBigInteger()` Converts this `Decimal` to a `BigInteger`.
`BigInteger`	`toBigInteger(RoundingMode roundingMode)` Converts this `Decimal` to a `BigInteger` value using the specified rounding mode if necessary.
`BigInteger`	`toBigIntegerExact()` Converts this `Decimal` to a `BigInteger`, checking for lost information.
`String`	`toString()` Returns a string representation of this `Decimal` object as fixed-point Decimal always showing all Decimal places (also trailing zeros) and a leading sign character if negative.

Methods inherited from class java.lang.Number
byteValue, shortValue

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.decimal4j.api.Decimal
byteValue, getFactory, getScale, getScaleMetrics, multiplyExact, scale, scale, scale, scale, shortValue, toImmutableDecimal, toMutableDecimal, unscaledValue

- Constructor Detail
  - AbstractDecimal
```
public AbstractDecimal()
```
- Method Detail
  - createOrAssign
```
protected abstract D createOrAssign(long unscaled)
```
    Returns this or a new Decimal whose value is (unscaled × 10^-scale).
    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 (unscaled × 10^-scale).
    
    Parameters:
    unscaled - unscaled value to be returned as a Decimal
    
    Returns:
    unscaled × 10^-scale
  - create
```
protected abstract D create(long unscaled)
```
    Returns a new Decimal whose value is (unscaled × 10^-scale).
    
    Parameters:
    unscaled - unscaled value to be returned as a Decimal
    
    Returns:
    unscaled × 10^-scale
  - createArray
```
protected abstract D[] createArray(int length)
```
    Returns a new Decimal array of the specified length.
    
    Parameters:
    length - the length of the array to return
    
    Returns:
    new D[length]
  - self
```
protected abstract D self()
```
    Returns this decimal value as concrete implementation subtype.
    
    Returns:
    this
  - getDefaultArithmetic
```
protected DecimalArithmetic getDefaultArithmetic()
```
    Returns the default arithmetic performing unchecked operations with rounding mode HALF_UP.
    
    Returns:
    default arithmetic with HALF_UP rounding and UNCHECKED overflow mode
  - getDefaultCheckedArithmetic
```
protected DecimalArithmetic getDefaultCheckedArithmetic()
```
    Returns the default arithmetic performing checked operations with rounding mode HALF_UP.
    
    Returns:
    default arithmetic with HALF_UP rounding and CHECKED overflow mode
  - getArithmeticFor
```
protected DecimalArithmetic getArithmeticFor(OverflowMode overflowMode)
```
    Returns the default arithmetic performing checked operations with rounding mode HALF_UP and the specified overflowMode.
    
    Parameters:
    overflowMode - the overflow for the returned arithmetic
    
    Returns:
    default arithmetic with HALF_UP rounding and the given overflowMode
  - getRoundingDownArithmetic
```
protected DecimalArithmetic getRoundingDownArithmetic()
```
    Returns the arithmetic performing unchecked operations with rounding mode DOWN.
    
    Returns:
    arithmetic with DOWN rounding and UNCHECKED overflow mode
  - getRoundingFloorArithmetic
```
protected DecimalArithmetic getRoundingFloorArithmetic()
```
    Returns the arithmetic performing unchecked operations with rounding mode FLOOR.
    
    Returns:
    arithmetic with FLOOR rounding and UNCHECKED overflow mode
  - getRoundingHalfEvenArithmetic
```
protected DecimalArithmetic getRoundingHalfEvenArithmetic()
```
    Returns the arithmetic performing unchecked operations with rounding mode HALF_EVEN.
    
    Returns:
    arithmetic with HALF_UP rounding and UNCHECKED overflow mode
  - getRoundingUnnecessaryArithmetic
```
protected DecimalArithmetic getRoundingUnnecessaryArithmetic()
```
    Returns the arithmetic performing unchecked operations with rounding mode UNNECESSARY.
    
    Returns:
    arithmetic with UNNECESSARY rounding and UNCHECKED overflow mode
  - getArithmeticFor
```
protected DecimalArithmetic getArithmeticFor(RoundingMode roundingMode)
```
    Returns the arithmetic performing unchecked operations with the specified RoundingMode.
    
    Parameters:
    roundingMode - the rounding for the returned arithmetic
    
    Returns:
    arithmetic with specified roundingMode and UNCHECKED overflow mode
  - getCheckedArithmeticFor
```
protected DecimalArithmetic getCheckedArithmeticFor(RoundingMode roundingMode)
```
    Returns the arithmetic performing checked operations with the specified RoundingMode.
    
    Parameters:
    roundingMode - the rounding for the returned arithmetic
    
    Returns:
    arithmetic with specified roundingMode and CHECKED overflow mode
  - getArithmeticFor
```
protected DecimalArithmetic getArithmeticFor(TruncationPolicy truncationPolicy)
```
    Returns the arithmetic for the specified truncationPolicy.
    
    Parameters:
    truncationPolicy - the truncation policy for the returned arithmetic
    
    Returns:
    arithmetic performing operations according to the given truncationPolicy
  - byteValueExact
```
public byte byteValueExact()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a byte, checking for lost information. If this Decimal has a nonzero fractional part or is out of the possible range for a byte result then an ArithmeticException is thrown.
    
    Specified by:
    
    byteValueExact in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    this Decimal converted to a byte.
    See Also:
    Decimal.byteValue()
  - shortValueExact
```
public short shortValueExact()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a short, checking for lost information. If this Decimal has a nonzero fractional part or is out of the possible range for a short result then an ArithmeticException is thrown.
    
    Specified by:
    
    shortValueExact in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    this Decimal converted to a short.
    See Also:
    Decimal.shortValue()
  - intValue
```
public int intValue()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to an int. This conversion is analogous to the narrowing primitive conversion from double to short as defined in section 5.1.3 of The Java™ Language Specification: any fractional part of this Decimal will be discarded, and if the resulting "long" is too big to fit in an int, only the low-order 32 bits are returned. Note that this conversion can lose information about the overall magnitude and precision of this Decimal value as well as return a result with the opposite sign.
    
    Specified by:
    
    intValue in interface Decimal<S extends ScaleMetrics>
    
    Specified by:
    
    intValue in class Number
    
    Returns:
    this Decimal converted to an int.
    See Also:
    Number.intValue(), Decimal.intValueExact()
  - intValueExact
```
public int intValueExact()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to an int, checking for lost information. If this Decimal has a nonzero fractional part or is out of the possible range for an int result then an ArithmeticException is thrown.
    
    Specified by:
    
    intValueExact in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    this Decimal converted to an int.
    See Also:
    Decimal.intValue()
  - longValue
```
public long longValue()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a long. This conversion is analogous to the narrowing primitive conversion from double to short as defined in section 5.1.3 of The Java™ Language Specification: any fractional part of this Decimal will be discarded. Note that this conversion can lose information about the precision of the Decimal value.
    Note that this method uses RoundingMode.DOWN as defined by The Java™Language Specification. Other rounding modes are supported via Decimal.longValue(RoundingMode).
    
    Specified by:
    
    longValue in interface Decimal<S extends ScaleMetrics>
    
    Specified by:
    
    longValue in class Number
    
    Returns:
    this Decimal converted to a long.
    See Also:
    Number.longValue(), Decimal.longValue(RoundingMode), Decimal.longValueExact()
  - longValueExact
```
public long longValueExact()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a long, checking for lost information. If this Decimal has a nonzero fractional part or is out of the possible range for a long result then an ArithmeticException is thrown.
    
    Specified by:
    
    longValueExact in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    this Decimal converted to a long.
    See Also:
    Decimal.longValue(), Decimal.longValue(RoundingMode)
  - longValue
```
public long longValue(RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a long using the specified rounding mode if necessary. Rounding is applied if the Decimal value can not be represented as a long value, that is, if it has a nonzero fractional part. Note that this conversion can lose information about the precision of the Decimal value.
    
    Specified by:
    
    longValue in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    roundingMode - the rounding mode to apply when rounding is necessary to convert this Decimal into a long
    
    Returns:
    this Decimal converted to a long.
    See Also:
    Decimal.longValue(), Decimal.longValueExact()
  - floatValue
```
public float floatValue()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a float. This conversion is similar to the narrowing primitive conversion from double to float as defined in section 5.1.3 of The Java™ Language Specification. Note that this conversion can lose information about the precision of the Decimal value.
    Note that this method uses RoundingMode.HALF_EVEN as defined by The Java™Language Specification. Other rounding modes are supported via Decimal.floatValue(RoundingMode).
    
    Specified by:
    
    floatValue in interface Decimal<S extends ScaleMetrics>
    
    Specified by:
    
    floatValue in class Number
    
    Returns:
    this Decimal converted to a float.
    See Also:
    Number.floatValue(), Decimal.floatValue(RoundingMode)
  - floatValue
```
public float floatValue(RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a float using the specified rounding mode if the Decimal value can not be exactly represented as a float value. Note that this conversion can lose information about the precision of the Decimal value.
    
    Specified by:
    
    floatValue in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    roundingMode - the rounding mode to apply when rounding is necessary to convert this Decimal into a float value
    
    Returns:
    this Decimal converted to a float.
    See Also:
    Decimal.floatValue()
  - doubleValue
```
public double doubleValue()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a double. This conversion is similar to the narrowing primitive conversion from double to float as defined in section 5.1.3 of The Java™ Language Specification. Note that this conversion can lose information about the precision of the Decimal value.
    Note that this method uses RoundingMode.HALF_EVEN as defined by The Java™Language Specification. Other rounding modes are supported via Decimal.doubleValue(RoundingMode).
    
    Specified by:
    
    doubleValue in interface Decimal<S extends ScaleMetrics>
    
    Specified by:
    
    doubleValue in class Number
    
    Returns:
    this Decimal converted to a double.
    See Also:
    Number.doubleValue(), Decimal.doubleValue(RoundingMode)
  - doubleValue
```
public double doubleValue(RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a double using the specified rounding mode if the Decimal value can not be exactly represented as a double value. Note that this conversion can lose information about the precision of the Decimal value.
    
    Specified by:
    
    doubleValue in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    roundingMode - the rounding mode to apply when rounding is necessary to convert this Decimal into a double value
    
    Returns:
    this Decimal converted to a double.
    See Also:
    Decimal.doubleValue()
  - toBigInteger
```
public BigInteger toBigInteger()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a BigInteger. This conversion is analogous to the narrowing primitive conversion from double to long as defined in section 5.1.3 of The Java™ Language Specification: any fractional part of this Decimal will be discarded. Note that this conversion can lose information about the precision of the Decimal value.
    To have an exception thrown if the conversion is inexact (in other words if a nonzero fractional part is discarded), use the Decimal.toBigIntegerExact() method.
    Note that this method uses RoundingMode.DOWN to be consistent with other integer conversion methods as defined by The Java™Language Specification. Other rounding modes are supported via Decimal.toBigInteger(RoundingMode).
    
    Specified by:
    
    toBigInteger in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    this Decimal converted to a BigInteger.
    See Also:
    Decimal.toBigIntegerExact(), Decimal.toBigInteger(RoundingMode), Decimal.longValue()
  - toBigIntegerExact
```
public BigInteger toBigIntegerExact()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a BigInteger, checking for lost information. An exception is thrown if this Decimal has a nonzero fractional part.
    
    Specified by:
    
    toBigIntegerExact in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    this Decimal converted to a BigInteger.
    See Also:
    Decimal.toBigInteger(), Decimal.toBigInteger(RoundingMode), Decimal.longValueExact()
  - toBigInteger
```
public BigInteger toBigInteger(RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a BigInteger value using the specified rounding mode if necessary. Rounding is applied if the Decimal value can not be represented as a BigInteger, that is, if it has a nonzero fractional part. Note that this conversion can lose information about the precision of the Decimal value.
    
    Specified by:
    
    toBigInteger in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    roundingMode - the rounding mode to apply when rounding is necessary to convert this Decimal into a BigInteger
    
    Returns:
    this Decimal converted to a BigInteger.
    See Also:
    Decimal.toBigInteger(), Decimal.toBigIntegerExact()
  - toBigDecimal
```
public BigDecimal toBigDecimal()
```
    Description copied from interface: Decimal
    
    Converts this Decimal to a BigDecimal using the same scale as this Decimal value.
    
    Specified by:
    
    toBigDecimal in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    this Decimal converted to a BigDecimal with the same scale as this Decimal value.
    See Also:
    Decimal.toBigDecimal(int, RoundingMode)
  - toBigDecimal
```
public BigDecimal toBigDecimal(int scale,
                      RoundingMode roundingMode)
```
    Description copied from interface: Decimal
    
    Returns a BigDecimal value of the given scale using the specified rounding mode if necessary.
    
    Specified by:
    
    toBigDecimal in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    scale - the scale used for the returned BigDecimal
    roundingMode - the rounding mode to apply when rounding is necessary to convert from the this Decimal's scale to the target scale
    
    Returns:
    a BigDecimal instance of the specified scale
    See Also:
    Decimal.toBigDecimal()
  - integralPart
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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)
  - add
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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)
  - multiply
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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)
  - divide
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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))
  - divideExact
```
public D 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
  - divideTruncate
```
public D 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)
  - divideByPowerOfTen
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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)
  - divideToLongValue
```
public long divideToLongValue(Decimal<S> divisor)
```
    Description copied from interface: Decimal
    
    Returns a Decimal whose value (this / divisor) rounded down to the next long value. If the division causes an overflow, the result is silently truncated.
    
    Specified by:
    
    divideToLongValue in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    divisor - value by which this Decimal is to be divided.
    
    Returns:
    The integer part of (this / divisor) returned as long
    See Also:
    Decimal.divideToLongValue(Decimal, OverflowMode), Decimal.divideToIntegralValue(Decimal), Decimal.remainder(Decimal)
  - divideToLongValue
```
public long divideToLongValue(Decimal<S> divisor,
                     OverflowMode overflowMode)
```
    Description copied from interface: Decimal
    
    Returns a Decimal whose value (this / divisor) rounded down to the next long value. The specified overflowMode determines whether to truncate the result silently or to throw an exception if an overflow occurs.
    
    Specified by:
    
    divideToLongValue 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) returned as long
    See Also:
    Decimal.divideToLongValue(Decimal), Decimal.divideToIntegralValue(Decimal), Decimal.remainder(Decimal)
  - divideAndRemainder
```
public D[] 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
```
public D[] 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
```
public D 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)
  - signum
```
public int signum()
```
    Description copied from interface: Decimal
    
    Returns the signum function of this Decimal.
    
    Specified by:
    
    signum in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    -1, 0, or 1 as the value of this Decimal is negative, zero, or positive.
  - negate
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
```
public D 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
  - compareTo
```
public int compareTo(Decimal<S> other)
```
    Description copied from interface: Decimal
    
    Compares two Decimal objects numerically.
    
    Specified by:
    
    compareTo in interface Comparable<Decimal<S extends ScaleMetrics>>
    
    Specified by:
    
    compareTo in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    the value 0 if this Decimal is equal to the argument Decimal; a value less than 0 if this Decimal is numerically less than the argument Decimal; and a value greater than 0 if this Decimal is numerically greater than the argument Decimal
  - isEqualTo
```
public boolean isEqualTo(Decimal<S> other)
```
    Description copied from interface: Decimal
    
    Compares this Decimal with the specified Decimal and returns true if the two are numerically equal.
    Returns true iff Decimal.compareTo(Decimal) returns 0.
    
    Specified by:
    
    isEqualTo in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    true this Decimal is numerically equal to other and false otherwise
  - isGreaterThan
```
public boolean isGreaterThan(Decimal<S> other)
```
    Description copied from interface: Decimal
    
    Compares this Decimal with the specified Decimal and returns true if this Decimal is numerically greater than other.
    Returns true iff Decimal.compareTo(Decimal) returns a value greater than 0.
    
    Specified by:
    
    isGreaterThan in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    true if this > other
  - isGreaterThanOrEqualTo
```
public boolean isGreaterThanOrEqualTo(Decimal<S> other)
```
    Description copied from interface: Decimal
    
    Compares this Decimal with the specified Decimal and returns true if this Decimal is numerically greater than or equal to other.
    Returns true iff Decimal.compareTo(Decimal) returns a non-negative value.
    
    Specified by:
    
    isGreaterThanOrEqualTo in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    true if this >= other
  - isLessThan
```
public boolean isLessThan(Decimal<S> other)
```
    Description copied from interface: Decimal
    
    Compares this Decimal with the specified Decimal and returns true if this Decimal is numerically less than other.
    Returns true iff Decimal.compareTo(Decimal) returns a negative value.
    
    Specified by:
    
    isLessThan in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    other - Decimal to which this Decimal is to be compared.
    
    Returns:
    true if this < other
  - isLessThanOrEqualTo
```
public boolean isLessThanOrEqualTo(Decimal<S> other)
```
    Description copied from interface: Decimal
    
    Compares this Decimal with the specified Decimal and returns true if this Decimal is numerically less than or equal to other.
    Returns true iff Decimal.compareTo(Decimal) returns a non-positive value.
    
    Specified by:
    
    isLessThanOrEqualTo in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    other - Decimal to which this Decimal is to be compared
    
    Returns:
    true if this <= other
  - isZero
```
public boolean isZero()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is zero.
    
    Specified by:
    
    isZero in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if this == 0
  - isOne
```
public boolean isOne()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is one.
    
    Specified by:
    
    isOne in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if this == 1
  - isUlp
```
public boolean isUlp()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is equal to the smallest positive number representable by a Decimal with the current scale.
    
    Specified by:
    
    isUlp in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if unscaledValue() == 1
  - isMinusOne
```
public boolean isMinusOne()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is minus one.
    
    Specified by:
    
    isMinusOne in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if this == -1
  - isPositive
```
public boolean isPositive()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is strictly positive.
    
    Specified by:
    
    isPositive in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if this > 0
  - isNonNegative
```
public boolean isNonNegative()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is not negative.
    
    Specified by:
    
    isNonNegative in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if this >= 0
  - isNegative
```
public boolean isNegative()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is negative.
    
    Specified by:
    
    isNegative in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if this < 0
  - isNonPositive
```
public boolean isNonPositive()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is not positive.
    
    Specified by:
    
    isNonPositive in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if this <= 0
  - isIntegral
```
public boolean isIntegral()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal number is integral, or equivalently if its fractional part is zero.
    
    Specified by:
    
    isIntegral in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if this is an integer number
  - isIntegralPartZero
```
public boolean isIntegralPartZero()
```
    Description copied from interface: Decimal
    
    Returns true if the integral part of this Decimal number is zero.
    
    Specified by:
    
    isIntegralPartZero in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if -1 < this < 1
  - isBetweenZeroAndOne
```
public boolean isBetweenZeroAndOne()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is between zero (inclusive) and one (exclusive). The result value is true if and only if this Decimal is not negative and its integral part is zero.
    
    Specified by:
    
    isBetweenZeroAndOne in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if 0 <= this < 1
  - isBetweenZeroAndMinusOne
```
public boolean isBetweenZeroAndMinusOne()
```
    Description copied from interface: Decimal
    
    Returns true if this Decimal is between zero (inclusive) and minus one (exclusive). The result value is true if and only if this Decimal is not positive and its integral part is zero.
    
    Specified by:
    
    isBetweenZeroAndMinusOne in interface Decimal<S extends ScaleMetrics>
    
    Returns:
    true if -1 < this <= 0
  - compareToNumerically
```
public int compareToNumerically(Decimal<?> other)
```
    Description copied from interface: Decimal
    
    Compares this Decimal with the specified Decimal. Two Decimal objects that are equal in value but have a different scale (like 2.0 and 2.00) are considered equal by this method.
    
    Specified by:
    
    compareToNumerically in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    other - Decimal to which this Decimal is to be compared.
    
    Returns:
    the value 0 if this Decimal is equal to the argument Decimal; a value less than 0 if this Decimal is numerically less than the argument Decimal; and a value greater than 0 if this Decimal is numerically greater than the argument Decimal
    See Also:
    Decimal.isEqualToNumerically(Decimal), Decimal.compareTo(Decimal)
  - isEqualToNumerically
```
public boolean isEqualToNumerically(Decimal<?> other)
```
    Description copied from interface: Decimal
    
    Compares this Decimal with the specified Decimal and returns true if the two are numerically equal. Two Decimal objects that are equal in value but have a different scale (like 2.0 and 2.00) are considered equal by this method as opposed to the equals method which requires identical scales of the compared values.
    Returns true iff Decimal.compareToNumerically(Decimal) returns 0.
    
    Specified by:
    
    isEqualToNumerically in interface Decimal<S extends ScaleMetrics>
    
    Parameters:
    other - Decimal to which this Decimal is to be compared.
    
    Returns:
    true if this Decimal is numerically equal to other and false otherwise.
    See Also:
    Decimal.compareToNumerically(Decimal), Decimal.compareTo(Decimal)
  - min
```
public Decimal<S> min(Decimal<S> val)
```
    Description copied from interface: Decimal
    
    Returns the minimum of this Decimal and val.
    
    Specified by:
    
    min in interface Decimal<S extends ScaleMetrics>
    
    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
```
public Decimal<S> max(Decimal<S> val)
```
    Description copied from interface: Decimal
    
    Returns the maximum of this Decimal and val.
    
    Specified by:
    
    max in interface Decimal<S extends ScaleMetrics>
    
    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)
  - min
```
public D min(D val)
```
    Returns the minimum of this Decimal and val.
    
    Parameters:
    val - value with which the minimum is to be computed.
    
    Returns:
    the Decimal whose value is the lesser of this Decimal and val. If they are equal, as defined by the compareTo method, this is returned.
    See Also:
    compareTo(Decimal)
  - max
```
public D max(D val)
```
    Returns the maximum of this Decimal and val.
    
    Parameters:
    val - value with which the maximum is to be computed.
    
    Returns:
    the Decimal whose value is the greater of this Decimal and val. If they are equal, as defined by the compareTo method, this is returned.
    See Also:
    compareTo(Decimal)
  - avg
```
public D 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
```
public D 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)
  - hashCode
```
public int hashCode()
```
    Description copied from interface: Decimal
    
    Returns a hash code for this Decimal. The hash code is calculated from scale and unscaled value.
    
    Specified by:
    
    hashCode in interface Decimal<S extends ScaleMetrics>
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    a hash code value for this object
  - equals
```
public boolean equals(Object obj)
```
    Description copied from interface: Decimal
    
    Compares this Decimal to the specified object. The result is true if and only if the argument is a Decimal value with the same scale and unscaled value as this Decimal.
    
    Specified by:
    
    equals in interface Decimal<S extends ScaleMetrics>
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    obj - the object to compare with
    
    Returns:
    true if the argument is a Decimal object that contains the same value and scale as this object; false otherwise
    See Also:
    Decimal.isEqualTo(Decimal), Decimal.isEqualToNumerically(Decimal), Decimal.hashCode()
  - toString
```
public String toString()
```
    Description copied from interface: Decimal
    
    Returns a string representation of this Decimal object as fixed-point Decimal always showing all Decimal places (also trailing zeros) and a leading sign character if negative.
    
    Specified by:
    
    toString in interface Decimal<S extends ScaleMetrics>
    
    Overrides:
    
    toString in class Object
    
    Returns:
    a String Decimal representation of this Decimal object with all the fraction digits (including trailing zeros)

Class AbstractDecimal<S extends ScaleMetrics,D extends AbstractDecimal<S,D>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Methods inherited from interface org.decimal4j.api.Decimal

Constructor Detail

AbstractDecimal

Method Detail

createOrAssign

create

createArray

self

getDefaultArithmetic

getDefaultCheckedArithmetic

getArithmeticFor

getRoundingDownArithmetic

getRoundingFloorArithmetic

getRoundingHalfEvenArithmetic

getRoundingUnnecessaryArithmetic

getArithmeticFor

getCheckedArithmeticFor

getArithmeticFor

byteValueExact

shortValueExact

intValue

intValueExact

longValue

longValueExact

longValue

floatValue

floatValue

doubleValue

doubleValue

toBigInteger

toBigIntegerExact

toBigInteger

toBigDecimal

toBigDecimal

integralPart

fractionalPart

round

round

round

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