"Abstraction of numeric types with the usual binary operations: - addition, `x + y`, - subtraction, `x - y`, - multiplication, `x * y`, and - division, `x / y`, along with - additive inverse `-x`. A concrete class which implements this interface should be a mathematical _ring_. That is: - both addition, `+`, and multiplication, `*`, should be associative and commutative, - there should be additive and multiplicative identities, denoted `0` and `1` respectively, satisfying `x+0 == x` and `x*1 == x`, - every instance `x` should have an additive inverse `-x`, satisfying `x + -x == 0`, and - multiplication should distribute over addition, satisfying `x*(y+z) == x*y + x*z`. It is preferred, but not required, that the class be a mathematical _field_. That is, in addition to the above: - every instance `x` such that `x!=0` should have a multiplicative inverse `1/x`, satisfying `x * 1/x == 1`. For numeric types which are not fields, for example, [[Integer]], there is still a division operation, which is understood to produce a [[remainder|Integral.remainder]]. The division operation should satisfy: - `x*y / y == x` for any instance `y` other than `0`. For numeric types which _are_ fields, division never produces a remainder, and division should additionally satisfy: - `x/y * y == x` for any instance `y` other than `0`. Some numeric types, for example complex numbers, do not have a [[total order|Comparable]]. Numeric types with a total order also satisfy [[Number]]." see (`interface Number`) by ("Gavin") tagged("Numbers") shared interface Numeric<Other> of Other satisfies Invertible<Other> given Other satisfies Numeric<Other> { "The product of this number and the given number." shared formal Other times(Other other); "The quotient obtained by dividing this number by the given number. For [[integral|Integral]] numeric types, this operation rounds toward `0`, the additive identity, and results in a [[remainder|Integral.remainder]]. When the given [[divisor|other]] is exactly `0`, the additive identity, the behavior depends on the numeric type: - For some numeric types, including [[Integer]], division by `0` results in an exception. - For others, including [[Float]], it results in a special value of the type, for example, [[infinity]]." see (`function Integral.remainder`, `value infinity`) shared formal Other divided(Other other); }