```import ceylon.whole {
Whole
}

shared class DividedWithRemainder(divided, remainder) {
shared Decimal divided;
shared Decimal remainder;
shared [Decimal,Decimal] pair => [divided,remainder];
}

"A decimal floating point number. This class provides support
for fixed and arbitrary precision numbers. Values are immutable
and represented as `unscaled * 10^(-scale)`. Methods without
an explicit [[Rounding]] parameter use [[unlimitedPrecision]]
(unless documented otherwise) except for `plus()`, `minus()`,
`times()`, `divided()` and `power()` whose implicit rounding
is subject to the rounding specified in [[implicitlyRounded]]."
see(`function implicitlyRounded`)
see(`class Rounding`)
see(`value unlimitedPrecision`)
shared interface Decimal
of DecimalImpl
satisfies Number<Decimal> &
Exponentiable<Decimal,Integer> {

"The platform-specific implementation object, if any. This
is provided for interoperation with the runtime platform."
shared formal Object? implementation;

"Determine whether two instances have equal value.`equals()`
considers `1` and `1.0` to be the same, `strictlyEquals()`
considers them to be different."
see(`function strictlyEquals`)
shared formal actual Boolean equals(Object that);

"Determine whether two instances have equal value _and
scale_. `strictlyEquals()` considers `1` and `1.0` to
be different, `equals()` considers them to be the same."
see(`function equals`)
shared formal Boolean strictlyEquals(Decimal that);

"The hash value of this `Decimal`. Due to the definition
of `equals()` trailing zeros do not contribute to the
hash calculation so `1` and `1.0` have the same `hash."
shared formal actual Integer hash;

"The quotient obtained by dividing this `Decimal` by the
given `Decimal`. Unless invoked within `implicitlyRounded()`
the preferred scale of the result is the difference between
this `Decimal`'s scale and the given `Decimal`'s scale; it
may be larger if necessary; an exception is thrown if the
result would have a nonterminating decimal representation."
see(`function dividedRounded`)
see(`function dividedTruncated`)
see(`function implicitlyRounded`)
shared formal actual Decimal divided(Decimal other);

"The quotient obtained by dividing this `Decimal` by the given
`Decimal` with the given rounding."
see(`function divided`)
see(`function dividedTruncated`)
shared formal Decimal dividedRounded(Decimal other,
Rounding? rounding = null);

"The product of this `Decimal` and the given `Decimal`. Unless
invoked within `implicitlyRounded()` the scale of the result
is the sum of the scales of the operands."
see(`function timesRounded`)
see(`function implicitlyRounded`)
shared formal actual Decimal times(Decimal other);

"The product of this `Decimal` and the given `Decimal` with
the given rounding."
see(`function times`)
shared formal Decimal timesRounded(Decimal other,
Rounding? rounding = null);

"The sum of this `Decimal` and the given `Decimal`. Unless
invoked within `implicitlyRounded()` the scale of the result
is the greater of the scales of the operands."
see(`function plusRounded`)
see(`function implicitlyRounded`)
shared formal actual Decimal plus(Decimal other);

"The sum of this `Decimal` and the given `Decimal` with the
given rounding."
see(`function plus`)
shared formal Decimal plusRounded(Decimal other,
Rounding? rounding = null);

"The difference between this `Decimal` and the given `Decimal`.
Unless invoked within `implicitlyRounded()` the scale of the
result is the greater of the scales of the operands."
see(`function minusRounded`)
see(`function implicitlyRounded`)
shared formal actual Decimal minus(Decimal other);

"The difference between this `Decimal` and the given `Decimal`
with the given rounding."
see(`function minus`)
shared formal Decimal minusRounded(Decimal other,
Rounding? rounding = null);

"The result of raising this number to the given power.
Unless invoked within
`implicitlyRounded()` the result is computed to unlimited
precision and negative powers are not supported."
see(`function powerRounded`)
throws(`class Exception`, "The exponent has a non-zero fractional part")
throws(`class Exception`, "The exponent is too large or too small")
throws(`class Exception`, "The exponent was negative when attempting to
compute a result to unlimited precision")
shared formal actual Decimal power(Integer other);

"The result of raising this number to the given power with
the given rounding. Fractional powers are not supported."
see(`function power`)
shared formal Decimal powerRounded(Integer other,
Rounding? rounding = null);

"The integer part of the quotient obtained by dividing this
`Decimal` by the given `Decimal` and truncating the result.
The scale of the result is the difference of the scales of
the operands."
throws(`class Exception`, "The integer part of the quotient requires
more than the given precision.")
throws(`class Exception`, "The given divisor is zero")
see(`function dividedTruncated`)
see(`function divided`)
shared formal Decimal dividedTruncated(Decimal other,
Rounding? rounding = null);

"The Decimal remainder after the division of this `Decimal`
by the given `Decimal`, that is:

`this - this.dividedTruncated(other, rounding) * other

This is not equivalent to the `%` operator (`Decimal` does
not satisfy `Integral`), and the result may be negative."
throws(`class Exception`, "The integer part of the quotient requires more
than the given precision.")
throws(`class Exception`, "The given divisor is zero")
shared formal Decimal remainderRounded(Decimal other,
Rounding? rounding = null);

"A pair containing the same results as calling
`dividedTruncated()` and `remainderRounded()` with the given
arguments, except the division is only performed once."
throws(`class Exception`, "The given divisor is zero")
see(`function dividedTruncated`, `function remainderRounded`)
shared formal DividedWithRemainder dividedAndRemainder(Decimal other,
Rounding? rounding = null);

"The precision of this decimal. This is the number of digits
in the unscaled value."
see(`value scale`)
shared formal Integer precision;

"The scale of this decimal. This is the number of digits to
the right of the decimal point (for a positive scale) or
the power of ten by which the unscaled value is multiplied
(for a negative scale)."
see(`value unscaled`)
see(`value precision`)
shared formal Integer scale;

"The unscaled value of this `Decimal`."
see(`value scale`)
shared formal Whole unscaled;

"This value rounded according to the given context."
shared formal Decimal round(Rounding rounding);

"The number, represented as a `Whole`, after truncation of
any fractional part."
see(`interface Whole`)
see(`value integer`)
shared formal Whole whole;

"The number, represented as an [[Integer]]. If the number is too
big to fit in an Integer then an Integer corresponding to the
lower order bits is returned."
shared formal Integer integer;

"The number, represented as a [[Float]]. If the magnitude of this number
is too large the result will be `infinity` or `-infinity`. If the result
is finite, precision may still be lost."
shared formal Float float;

}

```