Add big unsigned integers

Author: appgurueu

.spec/math/uint_spec.lua

@@ -0,0 +1,277 @@
+describe("Unsigned integers", function()
+local uint = require("math.uint")
+local hex = uint(16) -- use a small base for testing
+
+local function randuint(uint_cls)
+uint_cls = uint_cls or hex
+local n_digits = math.random(0, 50)
+local digits = {}
+for i = 1, n_digits - 1 do
+digits[i] = math.random(0, uint_cls.base - 1)
+end
+if n_digits > 0 then
+digits[n_digits] = math.random(1, uint_cls.base - 1)
+end
+return uint_cls.from_digits(digits)
+end
+
+it("class tables are cached", function()
+assert.equal(hex, uint(16))
+end)
+
+describe("constructors & equality testing", function()
+assert.equal(hex.from_number(0), hex.zero())
+assert.equal(hex.from_number(1), hex.one())
+assert.equal(hex.from_number(0xF), hex.from_digits({ 0xF }))
+assert.equal(hex.from_number(hex.base), hex.from_digits({ 0, 1 }))
+assert.equal(hex.from_number(0xC0FFEE), hex.from_digits({ 0xE, 0xE, 0xF, 0xF, 0x0, 0xC }))
+end)
+
+it("copy (from)", function()
+local n = hex.from_number(42)
+local m = n:copy()
+m:increment()
+assert.equal(hex.from_number(42), n)
+assert.equal(hex.from_number(43), m)
+m:copy_from(n)
+assert.equal(hex.from_number(42), m)
+end)
+
+describe("to number", function()
+it("works for exactly representable uints", function()
+assert.equal(123456789, hex.from_number(123456789):to_number())
+end)
+it("returns nothing for not exactly representable uints if exact=true", function()
+assert.equal(nil, ((hex.from_number(2 ^ 53) + 1):to_number()))
+end)
+it("returns rounded uint if exact=false", function()
+assert.equal(2 ^ 53, (hex.from_number(2 ^ 53) + 1):to_number(false))
+end)
+end)
+
+describe("base conversions", function()
+local dec = uint(10)
+it("small numbers", function()
+assert.equal(hex.from_number(1234), dec.from_number(1234):convert_base_to(hex))
+for _ = 1, 100 do
+-- Workaround for a limitation of Lua random, which uses 32-bit ints internally
+local n = math.random(2 ^ 26) * 2 ^ 26 + math.random(0, 2 ^ 26 - 1)
+assert.equal(hex.from_number(n), dec.from_number(n):convert_base_to(hex))
+assert.equal(dec.from_number(n), hex.from_number(n):convert_base_to(dec))
+end
+end)
+it("round-trip random numbers", function()
+for _ = 1, 100 do
+local n, m = randuint(), randuint(dec)
+assert.equal(n, n:convert_base_to(dec):convert_base_to(hex))
+assert.equal(m, m:convert_base_to(hex):convert_base_to(dec))
+end
+end)
+end)
+
+describe("comparisons", function()
+local function test_compare(name, fn)
+local function rand_uint()
+return math.random(0, 2 ^ 30)
+end
+local function test(a, b)
+assert.equal(fn(a, b), fn(hex.from_number(a), hex.from_number(b)))
+end
+it(name, function()
+for _ = 1, 100 do
+local a = rand_uint()
+test(a, a)
+test(rand_uint(), rand_uint())
+end
+end)
+end
+test_compare("less than", function(a, b)
+return a < b
+end)
+test_compare("less than or equal", function(a, b)
+return a <= b
+end)
+test_compare("equal to", function(a, b)
+return a == b
+end)
+test_compare("compare", function(a, b)
+if type(a) == "number" then
+if a < b then
+return -1
+elseif b < a then
+return 1
+end
+return 0
+end
+return a:compare(b)
+end)
+end)
+
+describe("arithmetic", function()
+local function test_law(name, n_params, f)
+it(name, function()
+local params = {}
+for _ = 1, 100 do
+for i = 1, n_params do
+params[i] = randuint()
+end
+assert(f(unpack(params)))
+end
+end)
+end
+describe("addition", function()
+it("is consistent with Lua numbers", function()
+local function rand_uint()
+return math.random(0, 2 ^ 50)
+end
+local function test(a, b)
+assert.equal(hex.from_number(a + b), hex.from_number(a) + hex.from_number(b))
+end
+for _ = 1, 100 do
+local a = rand_uint()
+test(a, a)
+test(rand_uint(), 0)
+test(0, rand_uint())
+test(rand_uint(), rand_uint())
+end
+end)
+test_law("associativity", 3, function(a, b, c)
+return a + (b + c) == (a + b) + c
+end)
+test_law("commutativity", 2, function(a, b)
+return a + b == b + a
+end)
+test_law("neutral element", 1, function(a)
+return a + 0 == a
+end)
+test_law("a + b - b = a", 2, function(a, b)
+return a + b - b == a
+end)
+end)
+describe("subtraction", function()
+it("is consistent with Lua numbers", function()
+local function rand_uint()
+return math.random(0, 2 ^ 50)
+end
+local function test(a, b)
+assert.equal(hex.from_number(a - b), hex.from_number(a) - hex.from_number(b))
+end
+for _ = 1, 100 do
+local a = rand_uint()
+test(a, a)
+test(rand_uint(), 0)
+test(a + rand_uint(), a)
+end
+end)
+test_law("a - a = 0", 1, function(a)
+return a - a == hex.zero()
+end)
+test_law("a - 0 = a", 1, function(a)
+return a - 0 == a
+end)
+end)
+describe("multiplication", function()
+it("is consistent with Lua numbers", function()
+local function rand_uint()
+return math.random(0, 2 ^ 24)
+end
+local function test(a, b)
+assert.equal(hex.from_number(a * b), hex.from_number(a) * hex.from_number(b))
+end
+for _ = 1, 100 do
+local a = rand_uint()
+test(a, a)
+test(rand_uint(), 0)
+test(0, rand_uint())
+test(rand_uint(), 1)
+test(1, rand_uint())
+test(rand_uint(), rand_uint())
+end
+end)
+test_law("distributivity", 3, function(a, b, c)
+return a * (b + c) == a * b + a * c
+end)
+test_law("associativity", 3, function(a, b, c)
+return a * (b * c) == (a * b) * c
+end)
+test_law("commutativity", 2, function(a, b)
+return a * b == b * a
+end)
+test_law("neutral element", 1, function(a)
+return a * 1 == a
+end)
+end)
+describe("exponentiation", function()
+it("throws on 0^0", function()
+assert.has_error(function()
+return hex.zero() ^ hex.zero()
+end)
+end)
+it("0^n = 0", function()
+assert.equal(hex.zero(), hex.zero() ^ 42)
+end)
+it("1^n = 1", function()
+assert.equal(hex.one(), hex.one() ^ 42)
+end)
+it("supports small uint exponents", function()
+assert.equal(hex.from_number(13 ^ 7), 13 ^ hex.from_number(7))
+end)
+it("is consistent with naive implementation", function()
+for _ = 1, 10 do
+local base = randuint()
+local exp = math.random(1, 10)
+local pow = hex.one()
+for _ = 1, exp do
+pow = pow * base
+end
+assert.equal(pow, base ^ exp)
+end
+end)
+end)
+end)
+describe("updates", function()
+local function test_unary(initial, expected, update)
+local n = hex.from_number(initial)
+update(n)
+assert.equal(n, hex.from_number(expected))
+end
+describe("increment", function()
+it("without carry", function()
+test_unary(1234, 1235, hex.increment)
+end)
+it("with carry", function()
+test_unary(hex.base - 1, hex.base, hex.increment)
+end)
+end)
+describe("decrement", function()
+it("without carry", function()
+test_unary(1235, 1234, hex.decrement)
+end)
+it("with carry", function()
+test_unary(hex.base - 1, hex.base, hex.increment)
+end)
+end)
+local function test_binary(name, fn)
+it(name, function()
+for _ = 1, 100 do
+local n, m = randuint(), randuint()
+if name == "subtract" then
+n = n + m
+end
+local res = fn(n, m)
+n[name](n, m)
+assert.equal(res, n)
+end
+end)
+end
+test_binary("add", function(a, b)
+return a + b
+end)
+test_binary("subtract", function(a, b)
+return a - b
+end)
+test_binary("multiply", function(a, b)
+return a * b
+end)
+end)
+end)