Numbers

Abstraction of integral numeric types. That is, types with no fractional part, including `Integer`.

The division operation for integral numeric types results in a remainder. Therefore, integral numeric types have an operation, denoted by the remainder operator `%`, to determine the remainder of any division operation.

    if (n%2==0) {
        print("Even!");
    }

Division and the remainder operation should satisfy:

- `x == (x/y)*y + x%y`

for any instance `x` and any instance `y` other than `0`.

All `Integral` numeric types are also `Enumerable`, so ranges of integral values may be produced using the `measure()` and `span()` operators.

    // Iterate from 0 to 100 inclusive
    for (i in 0..100) {
        print("The square of ``i`` is ``i^2``");
    }

    // Iterate all indices of the array,
    // from 0 to array.size-1
    for (i in 0:array.size) {
        print(array[i]);
    }

By: Gavin
See also `Integer`

no type hierarchy

- `Integral`
  - `Enumerable`
    - `Ordinal`
  - `Number`
    - `Comparable`
    - `Numeric`
      - `Invertible`
        - `Summable`

- `Integral` of
  - `Integer`

Attributes
`unit` | Source Code `shared formal Boolean unit` Determine if the number is the multiplicative identity.
`zero` | Source Code `shared formal Boolean zero` Determine if the number is the additive identity.

Inherited Attributes
Attributes inherited from: `Object` `hash`, `string`
Attributes inherited from: `Enumerable<Other>` `predecessor`, `successor`
Attributes inherited from: `Invertible<Other>` `negated`
Attributes inherited from: `Number<Other>` `absolute`, `fractionalPart`, `magnitude`, `negative`, `positive`, `sign`, `wholePart`
Attributes inherited from: `Ordinal<Other>` `predecessor`, `successor`

Methods
`divides` | Source Code `shared default Boolean divides(Other other)` Determine if this number is a factor of the given number, that is, if `remainder(other).zero` evaluates to `true`.
`modulo` | Source Code `shared default Other modulo(Other modulus)` The modulo, after dividing this number by the given number. This differs from `remainder()` in that the result is always positive or `0`. Throws `AssertionError` If the modulus is not strictly positive See also `Numeric.divided()`, `remainder()`
`remainder` | Source Code `shared formal Other remainder(Other other)` The remainder, after dividing this number by the given number. The sign of the remainder depends upon the sign of this number, and of the argument divisor: if this dividend is positive, the remainder has the opposite sign as the divisor, or is `0`, if this dividend is negative, the remainder has the same sign as the divisor, or is `0`, or if this dividend is zero, the remainder is always `0`. Thus, in order to satisfy the identity `x == (x/y)*y + x%y`, division for an integral numeric type must round toward `0`, the additive identity. See also `Numeric.divided()`, `modulo()`

Inherited Methods
Methods inherited from: `Object` `equals()`
Methods inherited from: `Comparable<Other>` `compare()`, `largerThan()`, `notLargerThan()`, `notSmallerThan()`, `smallerThan()`
Methods inherited from: `Enumerable<Other>` `neighbour()`, `offset()`, `offsetSign()`
Methods inherited from: `Invertible<Other>` `minus()`
Methods inherited from: `Number<Other>` `compare()`, `plusInteger()`, `powerOfInteger()`, `timesInteger()`
Methods inherited from: `Numeric<Other>` `divided()`, `times()`
Methods inherited from: `Summable<Other>` `plus()`