Library / Numbers / Numeric types / Number
Number
Fields 2
NumberKind tagNumStore storeConstructors 4
INIT()Default-initialize to zero, INTEGER subtype (constitution I.D.i(b): every
numeric primitive default-inits to zero). Without this the synthesized
zero-init would leave tag at 0 — not the INTEGER case — since kernel
enums start at 1.
INIT(int64 v)
INIT(uint64 v)
Widen-in from an unsigned 64-bit value. Value-classified by the ladder:
a magnitude that still fits the signed arm (v ≤ int64_max) is stored as
INTEGER so it compares/prints identically to the same int literal; only a
value in (int64_max, uint64_max] takes the UNSIGNED arm. This is the total
uint64 INTO number edge (no fallible AS needed — every uint64 fits).
INIT(float64 v)
Methods 12
METHOD kind() RETURNS NumberKindreads
The subtype this number currently holds — INTEGER, UNSIGNED, or FLOAT. The
V1 introspection surface (the typed, MATCH-able stand-in for V2 runtime
WHEN n IS int64). A pure tag read; never touches the union arm.
METHOD equals(number other) RETURNS booleanreads
Value-equality across subtypes (the Equatable surface a == b lowers to).
Any float-subtype operand compares by IEEE value (the integer arm promoted
to double) — so number(3) == number(3.0) is TRUE, number(0.1+0.2) ==
number(0.3) is FALSE. Two integer-kind operands are equal only when they
share an arm: INTEGER (≤ int64_max) and UNSIGNED ((int64_max, uint64_max])
hold DISJOINT value ranges, so a cross-arm compare is FALSE without ever
comparing signed to unsigned bits (no UB). Tolerance is ≈; bit-exact is
BEQUALS.
METHOD isLessThan(number other) RETURNS booleanreads
Ordering by mathematical value across arms (the a < b surface). Mirrors
equals: any float-subtype operand compares by IEEE value, so
number(2) < number(2.5) is TRUE. Two integer-kind operands compare in
the int128 domain, which unifies the INTEGER and UNSIGNED arms into one
signed-wide value — so a cross-arm compare is ORDERED (unlike equality,
where the disjoint ranges make it simply FALSE) and never compares signed
to unsigned bits.
NaN: the float path delegates to float64's own <, so every comparison
against a NaN is FALSE — the same answer float64 gives. That is why the
four operators derive by SWAPPING operands and never by negating: NOT (b
< a) would make NaN <= x TRUE. (I.D.g.v)
METHOD isLessThanOrEqual(number other) RETURNS booleanreads
a <= b. A separate method rather than NOT isLessThan(b, a) for the
NaN reason in isLessThan above: negation flips NaN's correct FALSE into
a wrong TRUE. > and >= are the operand-swapped forms of these two.
METHOD __op_plus__(number other) RETURNS numberreads
Arithmetic. Any float-subtype operand → float result (the integer arm
promoted to double — the common float path, unchanged). Otherwise both are
integer-kind: compute in int128 so int64 overflow is seen, then classify
down the ladder — so number overflow promotes (INTEGER→UNSIGNED→FLOAT)
instead of wrapping. */^ whose result exceeds int128 drop to FLOAT.
METHOD __op_minus__(number other) RETURNS numberreads
METHOD negate() RETURNS numberreads
Negation — -n lowers to this (number has no C++ unary operator-).
A FLOAT negates in float64, so -0.0 stays a signed zero; an integer kind
negates in int128 and classifies back down the ladder, so negating a
uint64 past int64's range promotes instead of wrapping — the same rule
0 - n follows.
METHOD __op_times__(number other) RETURNS numberreads
Multiply. Integer-kind operands compute in int128; the one integer op whose
product can exceed int128 (near-uint64_max × near-uint64_max ≈ 2^128), so a
recover-and-check (a≠0 ∧ p/a≠b ⇒ the multiply wrapped) drops to FLOAT.
METHOD __op_divide__(number other) RETURNS numberreads
METHOD __op_floordiv__(number other) RETURNS numberreads
Floor division (~/) — floors toward negative infinity (vs / which
truncates). Integer-kind → int128 floor then classify; any float → float
floor. Division shrinks magnitude so it never overflows the int128 domain
(int64_min ~/ -1 lands at 2^63, which the ladder classifies UNSIGNED).
METHOD __op_power__(number other) RETURNS numberreads
Power (^). Any float operand → float result. Integer-kind: a negative
exponent is fractional → FLOAT; otherwise iterate in int128, dropping to
FLOAT the moment a multiply would exceed int128. Bases 0/1/−1 are handled
directly so a huge exponent can't spin the loop (|base|≥2 overflows within
~127 steps).
METHOD isClose(number other, float64 rtol, float64 atol) RETURNS booleanreads
Approximate equality (the ≈ / ≉ operator lowers to this). Two
int-subtype operands compare EXACTLY — integers carry no representation
error, so ≈ adds nothing there. Otherwise (any float involved) the
principled tolerance applies: |a − b| ≤ max(rtol·max(|a|,|b|), atol).
The atol floor is what makes comparison to zero work. Operator defaults
come from the desugar; this method is also the explicit-tolerance surface.