Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.46.0

0.46.0 / src / support / decimal.lucb

#==============================================================================================
#
#   decimal - Decimal float literals to IEEE bits, correctly rounded
#
#   DESCRIPTION:
#       §4.3: a literal is a digit string D and a decimal exponent E, D * 10^E. With big
#       integers Num and Den, Num = D * 10^E and Den = 1 for a non-negative E, else Num = D and
#       Den = 10^-E, so the value is Num / Den exactly. Scaling by a power of two, which only
#       moves the binary exponent, puts the quotient in [2^(p+2), 2^(p+4)), p the width's
#       precision; that quotient, its remainder as a sticky bit, and the exponent are rounded
#       once to the width, ties to even. A literal keeps at most 800 significant digits: every
#       float and every midpoint between two floats has a shorter decimal expansion, so what
#       follows can only decide a tie, which the sticky bit records.
#
#==============================================================================================

# mark: Big integers ==========================================================================

## Big unsigned integers of up to 6144 bits, in 32-bit limbs, least significant first. The
## widest value here is Num scaled up to the length of Den = 10^1200, under 4100 bits.
struct Big:
    var limb: u32[192]
    ## Limbs in use; the last is not zero, or `used` is zero for zero.
    var used: usize

    static func of(value: u64) -> Big:
        var b: Big
        var v = value
        while v != 0:
            b.limb[b.used] = (u32)v
            b.used += 1
            v >>= 32
        return b

    func is_zero() -> bool:
        return self.used == 0

    ## `self * m + a`; false when the capacity is exceeded.
    func mul_add(m: u32, a: u32) -> bool:
        var carry: u64 = (u64)a
        var i: usize = 0
        while i < self.used:
            let t = (u64)self.limb[i] * (u64)m + carry
            self.limb[i] = (u32)t
            carry = t >> 32
            i += 1
        if carry != 0:
            if self.used == self.limb.length:
                return false
            self.limb[self.used] = (u32)carry
            self.used += 1
        return true

    func bit_length() -> usize:
        if self.used == 0:
            return 0
        var top = self.limb[self.used - 1]
        var n: usize = 0
        while top != 0:
            n += 1
            top >>= 1
        return (self.used - 1) * 32 + n

    func trim():
        while self.used > 0 and self.limb[self.used - 1] == 0:
            self.used -= 1

    func shift_left(count: usize) -> bool:
        if count == 0 or self.used == 0:
            return true
        let words = count // 32
        let rest = (u64)(count % 32)
        if self.used + words + 1 > self.limb.length:
            return false
        var i = self.used
        while i > 0:
            i -= 1
            let t = (u64)self.limb[i] << rest
            self.limb[i + words + 1] |= (u32)(t >> 32)
            self.limb[i + words] = (u32)t
        var k: usize = 0
        while k < words:
            self.limb[k] = 0
            k += 1
        self.used += words + 1
        self.trim()
        return true

    func shift_right_one():
        var i: usize = 0
        while i < self.used:
            let low: u32 = self.limb[i + 1] & 1 if i + 1 < self.used else 0
            self.limb[i] = (self.limb[i] >> 1) | (low << 31)
            i += 1
        self.trim()

    ## `self >= other`.
    func at_least(other: const Big*) -> bool:
        if self.used != other.used:
            return self.used > other.used
        var i = self.used
        while i > 0:
            i -= 1
            if self.limb[i] != other.limb[i]:
                return self.limb[i] > other.limb[i]
        return true

    ## `self -= other`, with `self >= other`.
    func subtract(other: const Big*):
        var borrow: u64 = 0
        var i: usize = 0
        while i < self.used:
            let taken: u64 = (u64)other.limb[i] if i < other.used else 0
            let t = (u64)self.limb[i] -% taken -% borrow
            borrow = 1 if (u64)self.limb[i] < taken + borrow else 0
            self.limb[i] = (u32)t
            i += 1
        self.trim()

## One IEEE width.
struct Format:
    ## Significant bits, the hidden one included.
    var precision: u64
    ## Of the smallest normal.
    var min_exponent: i64
    ## Of the largest finite.
    var max_exponent: i64
    var exponent_bits: u64

    static func of(width: u32) -> Format?:
        if width == 64:
            return Format(precision = 53, min_exponent = -1022, max_exponent = 1023, exponent_bits = 11)
        if width == 32:
            return Format(precision = 24, min_exponent = -126, max_exponent = 127, exponent_bits = 8)
        if width == 16:
            return Format(precision = 11, min_exponent = -14, max_exponent = 15, exponent_bits = 5)
        return none

    func infinity() -> u64:
        let one: u64 = 1
        return ((one << self.exponent_bits) - 1) << (self.precision - 1)

let digit_cap: usize = 800

# mark: Literals to bits ======================================================================

## The bits of `text` (digits, one optional point, an optional exponent, `_` separators,
## no sign and no suffix) as a float of `width` bits, 16, 32, or 64; `none` when the text
## is not such a literal.
pub func bits(text: str, width: u32) -> u64?:
    let f = Format.of(width) else return none
    let d = Digits.read(text) else return none
    if d.count == 0:
        return 0
    # the value is in [10^(count + exponent - 1), 10^(count + exponent)): past the largest
    # double it is an infinity, below half the smallest subnormal it is zero
    if (i64)d.count + d.exponent > 310:
        return f.infinity()
    if (i64)d.count + d.exponent < -400:
        return 0
    let q = d.quotient(f.precision) else return none
    return f.round(q)

## A literal's significant digits, leading and trailing zeros dropped, and the decimal
## exponent of the digit after the last one: the value is `digit * 10^exponent`, and a
## little more when `sticky`.
struct Digits:
    var digit: u8[800]
    var count: usize
    ## A digit past the cap that is not zero: only a tie needs it.
    var sticky: bool
    var exponent: i64

    ## The digits of `text`; `none` when it is not a literal.
    static func read(text: str) -> Digits?:
        let b = text.bytes
        var d: Digits
        var seen_digit = false
        var seen_point = false
        var i: usize = 0
        while i < b.length and b[i] != 'e' and b[i] != 'E':
            let c = b[i]
            i += 1
            if c == '_':
                continue
            if c == '.':
                if seen_point:
                    return none
                seen_point = true
                continue
            if c < '0' or c > '9':
                return none
            seen_digit = true
            if seen_point:
                d.exponent -= 1
            if d.count == 0 and c == '0':
                # a leading zero has no weight
                continue
            d.keep(c)
        if not seen_digit:
            return none
        if i < b.length:
            # past the `e`
            let given = exponent_part(text, i + 1) else return none
            d.exponent += given
        # trailing zeros carry no information: fold them into the exponent
        while d.count > 0 and d.digit[d.count - 1] == '0':
            d.count -= 1
            d.exponent += 1
        return d

    ## Keeps the digit `c`, or past the cap moves its weight into the exponent; its value
    ## only matters for a tie.
    func keep(c: u8):
        if self.count < digit_cap:
            self.digit[self.count] = c
            self.count += 1
        else:
            self.exponent += 1
            if c != '0':
                self.sticky = true

    ## The quotient Num / Den (see the header), scaled to p + 3 or p + 4 bits for a
    ## precision of p; `none` when a big integer overflows.
    func quotient(precision: u64) -> Quotient?:
        var num = Big.of(0)
        var k: usize = 0
        while k < self.count:
            if not num.mul_add(10, (u32)(self.digit[k] - '0')):
                return none
            k += 1
        var den = Big.of(1)
        var e = self.exponent
        while e > 0:
            if not num.mul_add(10, 0):
                return none
            e -= 1
        while e < 0:
            if not den.mul_add(10, 0):
                return none
            e += 1
        # scale so that the quotient has p + 3 or p + 4 bits
        let scale = (i64)den.bit_length() - (i64)num.bit_length() + (i64)precision + 3
        if scale >= 0:
            if not num.shift_left((usize)scale):
                return none
        elif not den.shift_left((usize)(-scale)):
            return none
        # restoring division: the quotient bit by bit, from its highest
        let top = num.bit_length() - den.bit_length()
        if not den.shift_left(top):
            return none
        var quotient: u64 = 0
        var j = top + 1
        while j > 0:
            j -= 1
            quotient <<= 1
            if num.at_least(&den):
                num.subtract(&den)
                quotient |= 1
            den.shift_right_one()
        return Quotient(value = quotient, scale = scale, sticky = self.sticky or not num.is_zero())

## The exponent after a literal's `e` at `start`, its sign included; `none` when it is
## malformed. Any exponent past 100000 is already an overflow or a zero, and is kept there.
func exponent_part(text: str, start: usize) -> i64?:
    let b = text.bytes
    var i = start
    var negative = false
    if i < b.length and (b[i] == '+' or b[i] == '-'):
        negative = b[i] == '-'
        i += 1
    if i == b.length:
        return none
    var given: i64 = 0
    while i < b.length:
        let c = b[i]
        i += 1
        if c == '_':
            continue
        if c < '0' or c > '9':
            return none
        if given < 100000:
            given = given * 10 + (i64)(c - '0')
    return -given if negative else given

# mark: Rounding ==============================================================================

## A literal's value as `value * 2^-scale`, and more when `sticky`.
struct Quotient:
    var value: u64
    var scale: i64
    var sticky: bool

extend Format:
    ## `q` rounded once to this width, ties to even: its bits.
    func round(q: Quotient) -> u64:
        let quotient = q.value
        var length: u64 = 0
        var v = quotient
        while v != 0:
            length += 1
            v >>= 1
        # of the leading bit
        var exponent2 = (i64)length - 1 - q.scale
        if exponent2 > self.max_exponent:
            return self.infinity()
        var keep = (i64)self.precision
        if exponent2 < self.min_exponent:
            keep = (i64)self.precision - (self.min_exponent - exponent2)
        let one: u64 = 1
        if keep <= 0:
            # at most half the smallest subnormal: exactly half is a tie, and even is zero
            if keep == 0:
                let half = one << (length - 1)
                return 1 if quotient > half or (quotient == half and q.sticky) else 0
            return 0
        let shift = length - (u64)keep
        var kept = quotient >> shift
        let dropped = quotient & ((one << shift) - 1)
        let half = one << (shift - 1)
        if dropped > half or (dropped == half and (q.sticky or (kept & 1) != 0)):
            kept += 1
        let hidden = one << (self.precision - 1)
        if kept == hidden << 1:
            kept = hidden
            exponent2 += 1
            if exponent2 > self.max_exponent:
                return self.infinity()
        if exponent2 < self.min_exponent:
            # a subnormal's bits are its mantissa; one that rounded up to the hidden bit is
            # the smallest normal, whose bits are that same number
            return kept
        let bias = (one << (self.exponent_bits - 1)) - 1
        return (((u64)(exponent2 + (i64)bias)) << (self.precision - 1)) | (kept - hidden)

## Whether the literal is beyond the width's largest finite value, so that its rounding
## would be an infinity, which is not a literal (§4.3).
pub func overflows(text: str, width: u32) -> bool:
    let f = Format.of(width) else return false
    let value = bits(text, width) else return false
    return value == f.infinity()

func bits_of(text: str, width: u32) -> u64:
    let v = bits(text, width) else return ~(u64)0
    return v

test "decimal literals round once at every width":
    assert(bits_of("1e-10", 64) == 4457293557087583675)
    assert(bits_of("1e-10", 32) == 786163455)
    assert(bits_of("1e-10", 16) == 0)
    assert(bits_of("1e-20", 64) == 4307583784117748259)
    assert(bits_of("1e-20", 32) == 507307272)
    assert(bits_of("1e-20", 16) == 0)
    assert(bits_of("1e-100", 64) == 3110860544497550640)
    assert(bits_of("1e-100", 32) == 0)
    assert(bits_of("1e-100", 16) == 0)
    assert(bits_of("2.2250738585072014e-308", 64) == 4503599627370496)
    assert(bits_of("2.2250738585072014e-308", 32) == 0)
    assert(bits_of("2.2250738585072014e-308", 16) == 0)
    assert(bits_of("1.7976931348623157e308", 64) == 9218868437227405311)
    assert(bits_of("1.7976931348623157e308", 32) == 2139095040)
    assert(bits_of("1.7976931348623157e308", 16) == 31744)
    assert(bits_of("0.1", 64) == 4591870180066957722)
    assert(bits_of("0.1", 32) == 1036831949)
    assert(bits_of("0.1", 16) == 11878)
    assert(bits_of("0.29", 64) == 4598895795485655695)
    assert(bits_of("0.29", 32) == 1049918177)
    assert(bits_of("0.29", 16) == 13476)
    assert(bits_of("1.2345678901234567", 64) == 4608238818662570491)
    assert(bits_of("1.2345678901234567", 32) == 1067320914)
    assert(bits_of("1.2345678901234567", 16) == 15600)
    assert(bits_of("5e-324", 64) == 1)
    assert(bits_of("5e-324", 32) == 0)
    assert(bits_of("5e-324", 16) == 0)
    assert(bits_of("2.4703282292062327e-324", 64) == 0)
    assert(bits_of("2.4703282292062327e-324", 32) == 0)
    assert(bits_of("2.4703282292062327e-324", 16) == 0)
    assert(bits_of("2.4703282292062328e-324", 64) == 1)
    assert(bits_of("2.4703282292062328e-324", 32) == 0)
    assert(bits_of("2.4703282292062328e-324", 16) == 0)
    assert(bits_of("1.7976931348623158e308", 64) == 9218868437227405311)
    assert(bits_of("1.7976931348623158e308", 32) == 2139095040)
    assert(bits_of("1.7976931348623158e308", 16) == 31744)
    assert(bits_of("1.7976931348623159e308", 64) == 9218868437227405312)
    assert(bits_of("1.7976931348623159e308", 32) == 2139095040)
    assert(bits_of("1.7976931348623159e308", 16) == 31744)
    assert(bits_of("1e309", 64) == 9218868437227405312)
    assert(bits_of("1e309", 32) == 2139095040)
    assert(bits_of("1e309", 16) == 31744)
    assert(bits_of("1e-400", 64) == 0)
    assert(bits_of("1e-400", 32) == 0)
    assert(bits_of("1e-400", 16) == 0)
    assert(bits_of("9007199254740993", 64) == 4845873199050653696)
    assert(bits_of("9007199254740993", 32) == 1509949440)
    assert(bits_of("9007199254740993", 16) == 31744)
    assert(bits_of("9007199254740993.0000000000000000000001", 64) == 4845873199050653697)
    assert(bits_of("9007199254740993.0000000000000000000001", 32) == 1509949440)
    assert(bits_of("9007199254740993.0000000000000000000001", 16) == 31744)
    assert(bits_of("10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 64) == 9218868437227405312)
    assert(bits_of("10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 32) == 2139095040)
    assert(bits_of("10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 16) == 31744)
    assert(bits_of("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", 64) == 103904837566199265)
    assert(bits_of("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", 32) == 0)
    assert(bits_of("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", 16) == 0)
    assert(bits_of("65504", 64) == 4679235614791434240)
    assert(bits_of("65504", 32) == 1199562752)
    assert(bits_of("65504", 16) == 31743)
    assert(bits_of("65505", 64) == 4679235752230387712)
    assert(bits_of("65505", 32) == 1199563008)
    assert(bits_of("65505", 16) == 31743)
    assert(bits_of("65519", 64) == 4679237676375736320)
    assert(bits_of("65519", 32) == 1199566592)
    assert(bits_of("65519", 16) == 31743)
    assert(bits_of("65519.00000000000000001", 64) == 4679237676375736320)
    assert(bits_of("65519.00000000000000001", 32) == 1199566592)
    assert(bits_of("65519.00000000000000001", 16) == 31743)
    assert(bits_of("65520", 64) == 4679237813814689792)
    assert(bits_of("65520", 32) == 1199566848)
    assert(bits_of("65520", 16) == 31744)
    assert(bits_of("2049", 64) == 4656724213724348416)
    assert(bits_of("2049", 32) == 1157632000)
    assert(bits_of("2049", 16) == 26624)
    assert(bits_of("2049.0000000000000000001", 64) == 4656724213724348416)
    assert(bits_of("2049.0000000000000000001", 32) == 1157632000)
    assert(bits_of("2049.0000000000000000001", 16) == 26625)
    assert(bits_of("2051", 64) == 4656728611770859520)
    assert(bits_of("2051", 32) == 1157640192)
    assert(bits_of("2051", 16) == 26626)
    assert(bits_of("2050.0000000000000001", 64) == 4656726412747603968)
    assert(bits_of("2050.0000000000000001", 32) == 1157636096)
    assert(bits_of("2050.0000000000000001", 16) == 26625)
    assert(bits_of("0.000000059604644775390625", 64) == 4499096027743125504)
    assert(bits_of("0.000000059604644775390625", 32) == 864026624)
    assert(bits_of("0.000000059604644775390625", 16) == 1)
    assert(bits_of("0.0000000298023223876953125", 64) == 4494592428115755008)
    assert(bits_of("0.0000000298023223876953125", 32) == 855638016)
    assert(bits_of("0.0000000298023223876953125", 16) == 0)
    assert(bits_of("0.00000002980232238769531250000001", 64) == 4494592428115755008)
    assert(bits_of("0.00000002980232238769531250000001", 32) == 855638016)
    assert(bits_of("0.00000002980232238769531250000001", 16) == 1)
    assert(bits_of("3.4028235e38", 64) == 5183643170655547384)
    assert(bits_of("3.4028235e38", 32) == 2139095039)
    assert(bits_of("3.4028235e38", 16) == 31744)
    assert(bits_of("3.4028236e38", 64) == 5183643170920245180)
    assert(bits_of("3.4028236e38", 32) == 2139095040)
    assert(bits_of("3.4028236e38", 16) == 31744)
    assert(bits_of("3.4028235677973366e38", 64) == 5183643170835005440)
    assert(bits_of("3.4028235677973366e38", 32) == 2139095039)
    assert(bits_of("3.4028235677973366e38", 16) == 31744)
    assert(bits_of("3.4028235677973367e38", 64) == 5183643170835005440)
    assert(bits_of("3.4028235677973367e38", 32) == 2139095040)
    assert(bits_of("3.4028235677973367e38", 16) == 31744)
    assert(bits_of("1.4e-45", 64) == 3936137728114922858)
    assert(bits_of("1.4e-45", 32) == 1)
    assert(bits_of("1.4e-45", 16) == 0)
    assert(bits_of("7.006492321624085e-46", 64) == 3931642474694443008)
    assert(bits_of("7.006492321624085e-46", 32) == 0)
    assert(bits_of("7.006492321624085e-46", 16) == 0)
    assert(bits_of("7.0064923216240854e-46", 64) == 3931642474694443008)
    assert(bits_of("7.0064923216240854e-46", 32) == 1)
    assert(bits_of("7.0064923216240854e-46", 16) == 0)
    assert(bits_of("1.1754943508222875e-38", 64) == 4039728865751334912)
    assert(bits_of("1.1754943508222875e-38", 32) == 8388608)
    assert(bits_of("1.1754943508222875e-38", 16) == 0)
    assert(bits_of("1.1754942106924411e-38", 64) == 4039728864677593088)
    assert(bits_of("1.1754942106924411e-38", 32) == 8388607)
    assert(bits_of("1.1754942106924411e-38", 16) == 0)
    assert(bits_of("6.103515625e-05", 64) == 4544132024016830464)
    assert(bits_of("6.103515625e-05", 32) == 947912704)
    assert(bits_of("6.103515625e-05", 16) == 1024)
    assert(bits_of("6.097555160522461e-05", 64) == 4544123227923808256)
    assert(bits_of("6.097555160522461e-05", 32) == 947896320)
    assert(bits_of("6.097555160522461e-05", 16) == 1023)
    assert(bits_of("1_000.5e-1", 64) == 4636740809791845171)
    assert(bits_of("1_000.5e-1", 32) == 1120410010)
    assert(bits_of("1_000.5e-1", 16) == 22081)
    assert(bits_of("0.5", 64) == 4602678819172646912)
    assert(bits_of("0.5", 32) == 1056964608)
    assert(bits_of("0.5", 16) == 14336)
    assert(bits_of("2.5", 64) == 4612811918334230528)
    assert(bits_of("2.5", 32) == 1075838976)
    assert(bits_of("2.5", 16) == 16640)
    assert(bits_of("100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", 64) == 9218868437227405312)
    assert(bits_of("100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", 32) == 2139095040)
    assert(bits_of("100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", 16) == 31744)
    assert(bits_of("0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", 64) == 4607182418800017408)
    assert(bits_of("0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", 32) == 1065353216)
    assert(bits_of("0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", 16) == 15360)
    assert(bits_of("16777217", 64) == 4715268810125344768)
    assert(bits_of("16777217", 32) == 1266679808)
    assert(bits_of("16777217", 16) == 31744)
    assert(bits_of("16777217.00000000000000000000001", 64) == 4715268810125344768)
    assert(bits_of("16777217.00000000000000000000001", 32) == 1266679809)
    assert(bits_of("16777217.00000000000000000000001", 16) == 31744)
    assert(bits_of("0.3", 64) == 4599075939470750515)
    assert(bits_of("0.3", 32) == 1050253722)
    assert(bits_of("0.3", 16) == 13517)
    assert(bits_of("1e23", 64) == 4950912855330343670)
    assert(bits_of("1e23", 32) == 1705601046)
    assert(bits_of("1e23", 16) == 31744)
    assert(bits_of("8.98846567431158e307", 64) == 9214364837600034816)
    assert(bits_of("8.98846567431158e307", 32) == 2139095040)
    assert(bits_of("8.98846567431158e307", 16) == 31744)
    assert(bits_of("4.9e-324", 64) == 1)
    assert(bits_of("4.9e-324", 32) == 0)
    assert(bits_of("4.9e-324", 16) == 0)
    assert(bits_of("3.0e-324", 64) == 1)
    assert(bits_of("3.0e-324", 32) == 0)
    assert(bits_of("3.0e-324", 16) == 0)

test "long digit strings decide ties, and the ends of the range":
    var past: u8[904]
    past[0] = '2'
    past[1] = '0'
    past[2] = '4'
    past[3] = '9'
    past[4] = '.'
    var i: usize = 5
    while i < 903:
        past[i] = '0'
        i += 1
    past[903] = '1'
    assert(bits_of((str)past[..<904], 16) == 26625)
    assert(bits_of((str)past[..<903], 16) == 26624)
    var huge: u8[5001]
    huge[0] = '1'
    i = 1
    while i < 5001:
        huge[i] = '0'
        i += 1
    assert(bits_of((str)huge[..<5001], 64) == 9218868437227405312)
    assert(bits_of("1e-99999999999999999999", 64) == 0)
    assert(bits_of("1e99999999999999999999", 32) == 2139095040)

test "what is not a literal is refused":
    let refused = ~(u64)0
    assert(bits_of("", 64) == refused)
    assert(bits_of(".", 64) == refused)
    assert(bits_of("1.2.3", 64) == refused)
    assert(bits_of("1e", 64) == refused)
    assert(bits_of("1e+", 64) == refused)
    assert(bits_of("1x", 64) == refused)
    assert(bits_of("1.5", 48) == refused)
    assert(bits_of("1_000.5", 64) == 4652011706887700480)