```"Abstraction of [[numeric|Numeric]] types with a natural
[[total order|Comparable]], including the built-in numeric
types [[Integer]] and [[Float]].

A `Number` has a well-defined [[magnitude]] together with a
[[sign]] of type [[Integer]], defined for any instance `x`
as follows:

- if `x==0` then `x.sign==0` and `x.magnitude==0`,
- if `x>0` then `x.sign==1` and `x.magnitude==x`, or
- if `x<0` then `x.sign==-1` and `x.magnitude==-x`,

where `0` is the additive identity of the numeric type.

Not every value commonly considered to be a \"number\" is
a `Number`. For example, complex numbers aren't `Number`s
since they don't have a total order."
see (`class Integer`, `class Float`)
by ("Gavin")
tagged("Numbers")
shared interface Number<Other> of Other
satisfies Numeric<Other> &
Comparable<Other>
given Other satisfies Number<Other> {

"The magnitude of this number, defined for any instance
`x` as:

- `-x` if `x<0`, or
- `x` otherwise,

where `0` is the additive identity. Hence:

- `x.magnitude >= 0` for any `x`, and
- `x.magnitude == 0` if and only if `x==0`."
aliased("absolute")
shared default Other magnitude
=> negative
then negated
else this of Other;

"The sign of this number:

- `1` if the number is [[positive]],
- `-1` if it is [[negative]], or
- `0` if it is the additive identity.

Must satisfy:

x.magnitude.timesInteger(x.sign) == x"
shared default Integer sign
=> if (positive) then 1
else if (negative) then -1
else 0;

"Determine if the number is strictly positive, that is,
if `this>0`, where `0` is the additive identity."
shared formal Boolean positive;

"Determine if the number is strictly negative, that is,
if `this<0`, where `0` is the additive identity."
shared formal Boolean negative;

"The fractional part of this number, after truncation of
the integral part. For [[Integral]] numeric types, the
fractional part is always zero."
shared formal Other fractionalPart;

"The integral value of the number after truncation of
the fractional part. For [[Integral]] numeric types,
the integral value of a number is the number itself."
shared formal Other wholePart;

"The result of multiplying this number by the given
[[Integer]]."
since("1.1.0")
shared formal Other timesInteger(Integer integer);

"The result of adding this number to the given
[[Integer]]."
since("1.1.0")
shared formal Other plusInteger(Integer integer);

"The result of raising this number to the given
non-negative [[Integer]] power. For a negative power,
the behavior is implementation-dependent."
throws (`class AssertionError`,
"if the exponent is a negative power and this is
an integral numeric type")
since("1.1.0")
shared formal Other powerOfInteger(Integer integer);

"Compares this number with the given number, returning:

- [[larger]], if the [[difference|minus]] `this-other`
between the numbers is [[positive]],
- [[smaller]], if the difference `this-other` between
the numbers is [[negative]], or
- [[equal]] otherwise."
shared actual default Comparison compare(Other other)
=> let (diff = this - other)
if (diff.positive) then larger
else if (diff.negative) then smaller
else equal;

}

```