"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;
    
}
​
​