Commit ca41567924
Changed files (1)
lib
std
math
big
lib/std/math/big/int.zig
@@ -1360,13 +1360,10 @@ pub const Int = struct {
// They will still run on larger than this and should pass, but the multi-limb code-paths
// may be untested in some cases.
-var buffer: [64 * 8192]u8 = undefined;
-var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]);
-const al = &fixed.allocator;
-
test "big.int comptime_int set" {
comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab;
- var a = try Int.initSet(al, s);
+ var a = try Int.initSet(testing.allocator, s);
+ defer a.deinit();
const s_limb_count = 128 / Limb.bit_count;
@@ -1380,39 +1377,45 @@ test "big.int comptime_int set" {
}
test "big.int comptime_int set negative" {
- var a = try Int.initSet(al, -10);
+ var a = try Int.initSet(testing.allocator, -10);
+ defer a.deinit();
testing.expect(a.limbs[0] == 10);
testing.expect(a.isPositive() == false);
}
test "big.int int set unaligned small" {
- var a = try Int.initSet(al, @as(u7, 45));
+ var a = try Int.initSet(testing.allocator, @as(u7, 45));
+ defer a.deinit();
testing.expect(a.limbs[0] == 45);
testing.expect(a.isPositive() == true);
}
test "big.int comptime_int to" {
- const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);
+ const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab);
+ defer a.deinit();
testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab);
}
test "big.int sub-limb to" {
- const a = try Int.initSet(al, 10);
+ const a = try Int.initSet(testing.allocator, 10);
+ defer a.deinit();
testing.expect((try a.to(u8)) == 10);
}
test "big.int to target too small error" {
- const a = try Int.initSet(al, 0xffffffff);
+ const a = try Int.initSet(testing.allocator, 0xffffffff);
+ defer a.deinit();
testing.expectError(error.TargetTooSmall, a.to(u8));
}
test "big.int normalize" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
try a.ensureCapacity(8);
a.limbs[0] = 1;
@@ -1439,7 +1442,8 @@ test "big.int normalize" {
}
test "big.int normalize multi" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
try a.ensureCapacity(8);
a.limbs[0] = 1;
@@ -1468,7 +1472,9 @@ test "big.int normalize multi" {
}
test "big.int parity" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
+
try a.set(0);
testing.expect(a.isEven());
testing.expect(!a.isOdd());
@@ -1479,7 +1485,8 @@ test "big.int parity" {
}
test "big.int bitcount + sizeInBase" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
try a.set(0b100);
testing.expect(a.bitCountAbs() == 3);
@@ -1506,7 +1513,8 @@ test "big.int bitcount + sizeInBase" {
}
test "big.int bitcount/to" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
try a.set(0);
testing.expect(a.bitCountTwosComp() == 0);
@@ -1536,7 +1544,8 @@ test "big.int bitcount/to" {
}
test "big.int fits" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
try a.set(0);
testing.expect(a.fits(u0));
@@ -1563,82 +1572,100 @@ test "big.int fits" {
}
test "big.int string set" {
- var a = try Int.init(al);
- try a.setString(10, "120317241209124781241290847124");
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
+ try a.setString(10, "120317241209124781241290847124");
testing.expect((try a.to(u128)) == 120317241209124781241290847124);
}
test "big.int string negative" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
+
try a.setString(10, "-1023");
testing.expect((try a.to(i32)) == -1023);
}
test "big.int string set bad char error" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
testing.expectError(error.InvalidCharForDigit, a.setString(10, "x"));
}
test "big.int string set bad base error" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
testing.expectError(error.InvalidBase, a.setString(45, "10"));
}
test "big.int string to" {
- const a = try Int.initSet(al, 120317241209124781241290847124);
+ const a = try Int.initSet(testing.allocator, 120317241209124781241290847124);
+ defer a.deinit();
- const as = try a.toString(al, 10);
+ const as = try a.toString(testing.allocator, 10);
+ defer testing.allocator.free(as);
const es = "120317241209124781241290847124";
testing.expect(mem.eql(u8, as, es));
}
test "big.int string to base base error" {
- const a = try Int.initSet(al, 0xffffffff);
+ const a = try Int.initSet(testing.allocator, 0xffffffff);
+ defer a.deinit();
- testing.expectError(error.InvalidBase, a.toString(al, 45));
+ testing.expectError(error.InvalidBase, a.toString(testing.allocator, 45));
}
test "big.int string to base 2" {
- const a = try Int.initSet(al, -0b1011);
+ const a = try Int.initSet(testing.allocator, -0b1011);
+ defer a.deinit();
- const as = try a.toString(al, 2);
+ const as = try a.toString(testing.allocator, 2);
+ defer testing.allocator.free(as);
const es = "-1011";
testing.expect(mem.eql(u8, as, es));
}
test "big.int string to base 16" {
- const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab);
+ const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab);
+ defer a.deinit();
- const as = try a.toString(al, 16);
+ const as = try a.toString(testing.allocator, 16);
+ defer testing.allocator.free(as);
const es = "efffffff00000001eeeeeeefaaaaaaab";
testing.expect(mem.eql(u8, as, es));
}
test "big.int neg string to" {
- const a = try Int.initSet(al, -123907434);
+ const a = try Int.initSet(testing.allocator, -123907434);
+ defer a.deinit();
- const as = try a.toString(al, 10);
+ const as = try a.toString(testing.allocator, 10);
+ defer testing.allocator.free(as);
const es = "-123907434";
testing.expect(mem.eql(u8, as, es));
}
test "big.int zero string to" {
- const a = try Int.initSet(al, 0);
+ const a = try Int.initSet(testing.allocator, 0);
+ defer a.deinit();
- const as = try a.toString(al, 10);
+ const as = try a.toString(testing.allocator, 10);
+ defer testing.allocator.free(as);
const es = "0";
testing.expect(mem.eql(u8, as, es));
}
test "big.int clone" {
- var a = try Int.initSet(al, 1234);
+ var a = try Int.initSet(testing.allocator, 1234);
+ defer a.deinit();
const b = try a.clone();
+ defer b.deinit();
testing.expect((try a.to(u32)) == 1234);
testing.expect((try b.to(u32)) == 1234);
@@ -1649,8 +1676,10 @@ test "big.int clone" {
}
test "big.int swap" {
- var a = try Int.initSet(al, 1234);
- var b = try Int.initSet(al, 5678);
+ var a = try Int.initSet(testing.allocator, 1234);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 5678);
+ defer b.deinit();
testing.expect((try a.to(u32)) == 1234);
testing.expect((try b.to(u32)) == 5678);
@@ -1662,53 +1691,65 @@ test "big.int swap" {
}
test "big.int to negative" {
- var a = try Int.initSet(al, -10);
+ var a = try Int.initSet(testing.allocator, -10);
+ defer a.deinit();
testing.expect((try a.to(i32)) == -10);
}
test "big.int compare" {
- var a = try Int.initSet(al, -11);
- var b = try Int.initSet(al, 10);
+ var a = try Int.initSet(testing.allocator, -11);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 10);
+ defer b.deinit();
testing.expect(a.cmpAbs(b) == 1);
testing.expect(a.cmp(b) == -1);
}
test "big.int compare similar" {
- var a = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeee);
- var b = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeef);
+ var a = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeee);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeef);
+ defer b.deinit();
testing.expect(a.cmpAbs(b) == -1);
testing.expect(b.cmpAbs(a) == 1);
}
test "big.int compare different limb size" {
- var a = try Int.initSet(al, maxInt(Limb) + 1);
- var b = try Int.initSet(al, 1);
+ var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 1);
+ defer b.deinit();
testing.expect(a.cmpAbs(b) == 1);
testing.expect(b.cmpAbs(a) == -1);
}
test "big.int compare multi-limb" {
- var a = try Int.initSet(al, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);
- var b = try Int.initSet(al, 0x7777777799999999ffffeeeeffffeeeeffffeeeee);
+ var a = try Int.initSet(testing.allocator, -0x7777777799999999ffffeeeeffffeeeeffffeeeef);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x7777777799999999ffffeeeeffffeeeeffffeeeee);
+ defer b.deinit();
testing.expect(a.cmpAbs(b) == 1);
testing.expect(a.cmp(b) == -1);
}
test "big.int equality" {
- var a = try Int.initSet(al, 0xffffffff1);
- var b = try Int.initSet(al, -0xffffffff1);
+ var a = try Int.initSet(testing.allocator, 0xffffffff1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, -0xffffffff1);
+ defer b.deinit();
testing.expect(a.eqAbs(b));
testing.expect(!a.eq(b));
}
test "big.int abs" {
- var a = try Int.initSet(al, -5);
+ var a = try Int.initSet(testing.allocator, -5);
+ defer a.deinit();
a.abs();
testing.expect((try a.to(u32)) == 5);
@@ -1718,7 +1759,8 @@ test "big.int abs" {
}
test "big.int negate" {
- var a = try Int.initSet(al, 5);
+ var a = try Int.initSet(testing.allocator, 5);
+ defer a.deinit();
a.negate();
testing.expect((try a.to(i32)) == -5);
@@ -1728,20 +1770,26 @@ test "big.int negate" {
}
test "big.int add single-single" {
- var a = try Int.initSet(al, 50);
- var b = try Int.initSet(al, 5);
+ var a = try Int.initSet(testing.allocator, 50);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 5);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.add(a, b);
testing.expect((try c.to(u32)) == 55);
}
test "big.int add multi-single" {
- var a = try Int.initSet(al, maxInt(Limb) + 1);
- var b = try Int.initSet(al, 1);
+ var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 1);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.add(a, b);
testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2);
@@ -1753,20 +1801,26 @@ test "big.int add multi-single" {
test "big.int add multi-multi" {
const op1 = 0xefefefef7f7f7f7f;
const op2 = 0xfefefefe9f9f9f9f;
- var a = try Int.initSet(al, op1);
- var b = try Int.initSet(al, op2);
+ var a = try Int.initSet(testing.allocator, op1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, op2);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.add(a, b);
testing.expect((try c.to(u128)) == op1 + op2);
}
test "big.int add zero-zero" {
- var a = try Int.initSet(al, 0);
- var b = try Int.initSet(al, 0);
+ var a = try Int.initSet(testing.allocator, 0);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.add(a, b);
testing.expect((try c.to(u32)) == 0);
@@ -1774,8 +1828,10 @@ test "big.int add zero-zero" {
test "big.int add alias multi-limb nonzero-zero" {
const op1 = 0xffffffff777777771;
- var a = try Int.initSet(al, op1);
- var b = try Int.initSet(al, 0);
+ var a = try Int.initSet(testing.allocator, op1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0);
+ defer b.deinit();
try a.add(a, b);
@@ -1783,12 +1839,17 @@ test "big.int add alias multi-limb nonzero-zero" {
}
test "big.int add sign" {
- var a = try Int.init(al);
-
- const one = try Int.initSet(al, 1);
- const two = try Int.initSet(al, 2);
- const neg_one = try Int.initSet(al, -1);
- const neg_two = try Int.initSet(al, -2);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
+
+ const one = try Int.initSet(testing.allocator, 1);
+ defer one.deinit();
+ const two = try Int.initSet(testing.allocator, 2);
+ defer two.deinit();
+ const neg_one = try Int.initSet(testing.allocator, -1);
+ defer neg_one.deinit();
+ const neg_two = try Int.initSet(testing.allocator, -2);
+ defer neg_two.deinit();
try a.add(one, two);
testing.expect((try a.to(i32)) == 3);
@@ -1804,20 +1865,26 @@ test "big.int add sign" {
}
test "big.int sub single-single" {
- var a = try Int.initSet(al, 50);
- var b = try Int.initSet(al, 5);
+ var a = try Int.initSet(testing.allocator, 50);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 5);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.sub(a, b);
testing.expect((try c.to(u32)) == 45);
}
test "big.int sub multi-single" {
- var a = try Int.initSet(al, maxInt(Limb) + 1);
- var b = try Int.initSet(al, 1);
+ var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 1);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.sub(a, b);
testing.expect((try c.to(Limb)) == maxInt(Limb));
@@ -1827,32 +1894,43 @@ test "big.int sub multi-multi" {
const op1 = 0xefefefefefefefefefefefef;
const op2 = 0xabababababababababababab;
- var a = try Int.initSet(al, op1);
- var b = try Int.initSet(al, op2);
+ var a = try Int.initSet(testing.allocator, op1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, op2);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.sub(a, b);
testing.expect((try c.to(u128)) == op1 - op2);
}
test "big.int sub equal" {
- var a = try Int.initSet(al, 0x11efefefefefefefefefefefef);
- var b = try Int.initSet(al, 0x11efefefefefefefefefefefef);
+ var a = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.sub(a, b);
testing.expect((try c.to(u32)) == 0);
}
test "big.int sub sign" {
- var a = try Int.init(al);
-
- const one = try Int.initSet(al, 1);
- const two = try Int.initSet(al, 2);
- const neg_one = try Int.initSet(al, -1);
- const neg_two = try Int.initSet(al, -2);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
+
+ const one = try Int.initSet(testing.allocator, 1);
+ defer one.deinit();
+ const two = try Int.initSet(testing.allocator, 2);
+ defer two.deinit();
+ const neg_one = try Int.initSet(testing.allocator, -1);
+ defer neg_one.deinit();
+ const neg_two = try Int.initSet(testing.allocator, -2);
+ defer neg_two.deinit();
try a.sub(one, two);
testing.expect((try a.to(i32)) == -1);
@@ -1871,20 +1949,26 @@ test "big.int sub sign" {
}
test "big.int mul single-single" {
- var a = try Int.initSet(al, 50);
- var b = try Int.initSet(al, 5);
+ var a = try Int.initSet(testing.allocator, 50);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 5);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.mul(a, b);
testing.expect((try c.to(u64)) == 250);
}
test "big.int mul multi-single" {
- var a = try Int.initSet(al, maxInt(Limb));
- var b = try Int.initSet(al, 2);
+ var a = try Int.initSet(testing.allocator, maxInt(Limb));
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 2);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.mul(a, b);
testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb));
@@ -1893,18 +1977,23 @@ test "big.int mul multi-single" {
test "big.int mul multi-multi" {
const op1 = 0x998888efefefefefefefef;
const op2 = 0x333000abababababababab;
- var a = try Int.initSet(al, op1);
- var b = try Int.initSet(al, op2);
+ var a = try Int.initSet(testing.allocator, op1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, op2);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.mul(a, b);
testing.expect((try c.to(u256)) == op1 * op2);
}
test "big.int mul alias r with a" {
- var a = try Int.initSet(al, maxInt(Limb));
- var b = try Int.initSet(al, 2);
+ var a = try Int.initSet(testing.allocator, maxInt(Limb));
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 2);
+ defer b.deinit();
try a.mul(a, b);
@@ -1912,8 +2001,10 @@ test "big.int mul alias r with a" {
}
test "big.int mul alias r with b" {
- var a = try Int.initSet(al, maxInt(Limb));
- var b = try Int.initSet(al, 2);
+ var a = try Int.initSet(testing.allocator, maxInt(Limb));
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 2);
+ defer b.deinit();
try a.mul(b, a);
@@ -1921,7 +2012,8 @@ test "big.int mul alias r with b" {
}
test "big.int mul alias r with a and b" {
- var a = try Int.initSet(al, maxInt(Limb));
+ var a = try Int.initSet(testing.allocator, maxInt(Limb));
+ defer a.deinit();
try a.mul(a, a);
@@ -1929,31 +2021,41 @@ test "big.int mul alias r with a and b" {
}
test "big.int mul a*0" {
- var a = try Int.initSet(al, 0xefefefefefefefef);
- var b = try Int.initSet(al, 0);
+ var a = try Int.initSet(testing.allocator, 0xefefefefefefefef);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.mul(a, b);
testing.expect((try c.to(u32)) == 0);
}
test "big.int mul 0*0" {
- var a = try Int.initSet(al, 0);
- var b = try Int.initSet(al, 0);
+ var a = try Int.initSet(testing.allocator, 0);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0);
+ defer b.deinit();
- var c = try Int.init(al);
+ var c = try Int.init(testing.allocator);
+ defer c.deinit();
try c.mul(a, b);
testing.expect((try c.to(u32)) == 0);
}
test "big.int div single-single no rem" {
- var a = try Int.initSet(al, 50);
- var b = try Int.initSet(al, 5);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 50);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 5);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u32)) == 10);
@@ -1961,11 +2063,15 @@ test "big.int div single-single no rem" {
}
test "big.int div single-single with rem" {
- var a = try Int.initSet(al, 49);
- var b = try Int.initSet(al, 5);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 49);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 5);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u32)) == 9);
@@ -1976,11 +2082,15 @@ test "big.int div multi-single no rem" {
const op1 = 0xffffeeeeddddcccc;
const op2 = 34;
- var a = try Int.initSet(al, op1);
- var b = try Int.initSet(al, op2);
+ var a = try Int.initSet(testing.allocator, op1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, op2);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u64)) == op1 / op2);
@@ -1991,11 +2101,15 @@ test "big.int div multi-single with rem" {
const op1 = 0xffffeeeeddddcccf;
const op2 = 34;
- var a = try Int.initSet(al, op1);
- var b = try Int.initSet(al, op2);
+ var a = try Int.initSet(testing.allocator, op1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, op2);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u64)) == op1 / op2);
@@ -2006,11 +2120,15 @@ test "big.int div multi>2-single" {
const op1 = 0xfefefefefefefefefefefefefefefefe;
const op2 = 0xefab8;
- var a = try Int.initSet(al, op1);
- var b = try Int.initSet(al, op2);
+ var a = try Int.initSet(testing.allocator, op1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, op2);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u128)) == op1 / op2);
@@ -2018,11 +2136,15 @@ test "big.int div multi>2-single" {
}
test "big.int div single-single q < r" {
- var a = try Int.initSet(al, 0x0078f432);
- var b = try Int.initSet(al, 0x01000000);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 0x0078f432);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x01000000);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u64)) == 0);
@@ -2030,11 +2152,15 @@ test "big.int div single-single q < r" {
}
test "big.int div single-single q == r" {
- var a = try Int.initSet(al, 10);
- var b = try Int.initSet(al, 10);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 10);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 10);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u64)) == 1);
@@ -2042,8 +2168,10 @@ test "big.int div single-single q == r" {
}
test "big.int div q=0 alias" {
- var a = try Int.initSet(al, 3);
- var b = try Int.initSet(al, 10);
+ var a = try Int.initSet(testing.allocator, 3);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 10);
+ defer b.deinit();
try Int.divTrunc(&a, &b, a, b);
@@ -2054,11 +2182,15 @@ test "big.int div q=0 alias" {
test "big.int div multi-multi q < r" {
const op1 = 0x1ffffffff0078f432;
const op2 = 0x1ffffffff01000000;
- var a = try Int.initSet(al, op1);
- var b = try Int.initSet(al, op2);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, op1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, op2);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u128)) == 0);
@@ -2069,11 +2201,15 @@ test "big.int div trunc single-single +/+" {
const u: i32 = 5;
const v: i32 = 3;
- var a = try Int.initSet(al, u);
- var b = try Int.initSet(al, v);
+ var a = try Int.initSet(testing.allocator, u);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, v);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
// n = q * d + r
@@ -2089,11 +2225,15 @@ test "big.int div trunc single-single -/+" {
const u: i32 = -5;
const v: i32 = 3;
- var a = try Int.initSet(al, u);
- var b = try Int.initSet(al, v);
+ var a = try Int.initSet(testing.allocator, u);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, v);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
// n = q * d + r
@@ -2109,11 +2249,15 @@ test "big.int div trunc single-single +/-" {
const u: i32 = 5;
const v: i32 = -3;
- var a = try Int.initSet(al, u);
- var b = try Int.initSet(al, v);
+ var a = try Int.initSet(testing.allocator, u);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, v);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
// n = q * d + r
@@ -2129,11 +2273,15 @@ test "big.int div trunc single-single -/-" {
const u: i32 = -5;
const v: i32 = -3;
- var a = try Int.initSet(al, u);
- var b = try Int.initSet(al, v);
+ var a = try Int.initSet(testing.allocator, u);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, v);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
// n = q * d + r
@@ -2149,11 +2297,15 @@ test "big.int div floor single-single +/+" {
const u: i32 = 5;
const v: i32 = 3;
- var a = try Int.initSet(al, u);
- var b = try Int.initSet(al, v);
+ var a = try Int.initSet(testing.allocator, u);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, v);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divFloor(&q, &r, a, b);
// n = q * d + r
@@ -2169,11 +2321,15 @@ test "big.int div floor single-single -/+" {
const u: i32 = -5;
const v: i32 = 3;
- var a = try Int.initSet(al, u);
- var b = try Int.initSet(al, v);
+ var a = try Int.initSet(testing.allocator, u);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, v);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divFloor(&q, &r, a, b);
// n = q * d + r
@@ -2189,11 +2345,15 @@ test "big.int div floor single-single +/-" {
const u: i32 = 5;
const v: i32 = -3;
- var a = try Int.initSet(al, u);
- var b = try Int.initSet(al, v);
+ var a = try Int.initSet(testing.allocator, u);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, v);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divFloor(&q, &r, a, b);
// n = q * d + r
@@ -2209,11 +2369,15 @@ test "big.int div floor single-single -/-" {
const u: i32 = -5;
const v: i32 = -3;
- var a = try Int.initSet(al, u);
- var b = try Int.initSet(al, v);
+ var a = try Int.initSet(testing.allocator, u);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, v);
+ defer b.deinit();
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divFloor(&q, &r, a, b);
// n = q * d + r
@@ -2226,11 +2390,15 @@ test "big.int div floor single-single -/-" {
}
test "big.int div multi-multi with rem" {
- var a = try Int.initSet(al, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
- var b = try Int.initSet(al, 0x99990000111122223333);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x99990000111122223333);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
@@ -2238,11 +2406,15 @@ test "big.int div multi-multi with rem" {
}
test "big.int div multi-multi no rem" {
- var a = try Int.initSet(al, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
- var b = try Int.initSet(al, 0x99990000111122223333);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x99990000111122223333);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b);
@@ -2250,11 +2422,15 @@ test "big.int div multi-multi no rem" {
}
test "big.int div multi-multi (2 branch)" {
- var a = try Int.initSet(al, 0x866666665555555588888887777777761111111111111111);
- var b = try Int.initSet(al, 0x86666666555555554444444433333333);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 0x866666665555555588888887777777761111111111111111);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x86666666555555554444444433333333);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u128)) == 0x10000000000000000);
@@ -2262,11 +2438,15 @@ test "big.int div multi-multi (2 branch)" {
}
test "big.int div multi-multi (3.1/3.3 branch)" {
- var a = try Int.initSet(al, 0x11111111111111111111111111111111111111111111111111111111111111);
- var b = try Int.initSet(al, 0x1111111111111111111111111111111111111111171);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x1111111111111111111111111111111111111111171);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u128)) == 0xfffffffffffffffffff);
@@ -2274,145 +2454,189 @@ test "big.int div multi-multi (3.1/3.3 branch)" {
}
test "big.int div multi-single zero-limb trailing" {
- var a = try Int.initSet(al, 0x60000000000000000000000000000000000000000000000000000000000000000);
- var b = try Int.initSet(al, 0x10000000000000000);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 0x60000000000000000000000000000000000000000000000000000000000000000);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x10000000000000000);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
- var expected = try Int.initSet(al, 0x6000000000000000000000000000000000000000000000000);
+ var expected = try Int.initSet(testing.allocator, 0x6000000000000000000000000000000000000000000000000);
+ defer expected.deinit();
testing.expect(q.eq(expected));
testing.expect(r.eqZero());
}
test "big.int div multi-multi zero-limb trailing (with rem)" {
- var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
- var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u128)) == 0x10000000000000000);
- const rs = try r.toString(al, 16);
+ const rs = try r.toString(testing.allocator, 16);
+ defer testing.allocator.free(rs);
testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000"));
}
test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" {
- var a = try Int.initSet(al, 0x8666666655555555888888877777777611111111111111110000000000000000);
- var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
testing.expect((try q.to(u128)) == 0x1);
- const rs = try r.toString(al, 16);
+ const rs = try r.toString(testing.allocator, 16);
+ defer testing.allocator.free(rs);
testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000"));
}
test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" {
- var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
- var b = try Int.initSet(al, 0x866666665555555544444444333333330000000000000000);
-
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0x866666665555555544444444333333330000000000000000);
+ defer b.deinit();
+
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
- const qs = try q.toString(al, 16);
+ const qs = try q.toString(testing.allocator, 16);
+ defer testing.allocator.free(qs);
testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f"));
- const rs = try r.toString(al, 16);
+ const rs = try r.toString(testing.allocator, 16);
+ defer testing.allocator.free(rs);
testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000"));
}
test "big.int div multi-multi fuzz case #1" {
- var a = try Int.init(al);
- var b = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
+ var b = try Int.init(testing.allocator);
+ defer b.deinit();
try a.setString(16, "ffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
try b.setString(16, "3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000000000000000000000000000001ffffffffffffffffffffffffffffffffffffffffffffffffffc000000000000000000000000000000007fffffffffff");
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
- const qs = try q.toString(al, 16);
+ const qs = try q.toString(testing.allocator, 16);
+ defer testing.allocator.free(qs);
testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1"));
- const rs = try r.toString(al, 16);
+ const rs = try r.toString(testing.allocator, 16);
+ defer testing.allocator.free(rs);
testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1"));
}
test "big.int div multi-multi fuzz case #2" {
- var a = try Int.init(al);
- var b = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
+ var b = try Int.init(testing.allocator);
+ defer b.deinit();
try a.setString(16, "3ffffffffe00000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000001fffffffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffc000000000000000000000000000000000000000000000000000000000000000");
try b.setString(16, "ffc0000000000000000000000000000000000000000000000000");
- var q = try Int.init(al);
- var r = try Int.init(al);
+ var q = try Int.init(testing.allocator);
+ defer q.deinit();
+ var r = try Int.init(testing.allocator);
+ defer r.deinit();
try Int.divTrunc(&q, &r, a, b);
- const qs = try q.toString(al, 16);
+ const qs = try q.toString(testing.allocator, 16);
+ defer testing.allocator.free(qs);
testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4"));
- const rs = try r.toString(al, 16);
+ const rs = try r.toString(testing.allocator, 16);
+ defer testing.allocator.free(rs);
testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000"));
}
test "big.int shift-right single" {
- var a = try Int.initSet(al, 0xffff0000);
+ var a = try Int.initSet(testing.allocator, 0xffff0000);
+ defer a.deinit();
try a.shiftRight(a, 16);
testing.expect((try a.to(u32)) == 0xffff);
}
test "big.int shift-right multi" {
- var a = try Int.initSet(al, 0xffff0000eeee1111dddd2222cccc3333);
+ var a = try Int.initSet(testing.allocator, 0xffff0000eeee1111dddd2222cccc3333);
+ defer a.deinit();
try a.shiftRight(a, 67);
testing.expect((try a.to(u64)) == 0x1fffe0001dddc222);
}
test "big.int shift-left single" {
- var a = try Int.initSet(al, 0xffff);
+ var a = try Int.initSet(testing.allocator, 0xffff);
+ defer a.deinit();
try a.shiftLeft(a, 16);
testing.expect((try a.to(u64)) == 0xffff0000);
}
test "big.int shift-left multi" {
- var a = try Int.initSet(al, 0x1fffe0001dddc222);
+ var a = try Int.initSet(testing.allocator, 0x1fffe0001dddc222);
+ defer a.deinit();
try a.shiftLeft(a, 67);
testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000);
}
test "big.int shift-right negative" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
- try a.shiftRight(try Int.initSet(al, -20), 2);
+ try a.shiftRight(try Int.initSet(testing.allocator, -20), 2);
+ defer a.deinit();
testing.expect((try a.to(i32)) == -20 >> 2);
- try a.shiftRight(try Int.initSet(al, -5), 10);
+ try a.shiftRight(try Int.initSet(testing.allocator, -5), 10);
+ defer a.deinit();
testing.expect((try a.to(i32)) == -5 >> 10);
}
test "big.int shift-left negative" {
- var a = try Int.init(al);
+ var a = try Int.init(testing.allocator);
+ defer a.deinit();
- try a.shiftRight(try Int.initSet(al, -10), 1232);
+ try a.shiftRight(try Int.initSet(testing.allocator, -10), 1232);
+ defer a.deinit();
testing.expect((try a.to(i32)) == -10 >> 1232);
}
test "big.int bitwise and simple" {
- var a = try Int.initSet(al, 0xffffffff11111111);
- var b = try Int.initSet(al, 0xeeeeeeee22222222);
+ var a = try Int.initSet(testing.allocator, 0xffffffff11111111);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222);
+ defer b.deinit();
try a.bitAnd(a, b);
@@ -2420,8 +2644,10 @@ test "big.int bitwise and simple" {
}
test "big.int bitwise and multi-limb" {
- var a = try Int.initSet(al, maxInt(Limb) + 1);
- var b = try Int.initSet(al, maxInt(Limb));
+ var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, maxInt(Limb));
+ defer b.deinit();
try a.bitAnd(a, b);
@@ -2429,8 +2655,10 @@ test "big.int bitwise and multi-limb" {
}
test "big.int bitwise xor simple" {
- var a = try Int.initSet(al, 0xffffffff11111111);
- var b = try Int.initSet(al, 0xeeeeeeee22222222);
+ var a = try Int.initSet(testing.allocator, 0xffffffff11111111);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222);
+ defer b.deinit();
try a.bitXor(a, b);
@@ -2438,8 +2666,10 @@ test "big.int bitwise xor simple" {
}
test "big.int bitwise xor multi-limb" {
- var a = try Int.initSet(al, maxInt(Limb) + 1);
- var b = try Int.initSet(al, maxInt(Limb));
+ var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, maxInt(Limb));
+ defer b.deinit();
try a.bitXor(a, b);
@@ -2447,8 +2677,10 @@ test "big.int bitwise xor multi-limb" {
}
test "big.int bitwise or simple" {
- var a = try Int.initSet(al, 0xffffffff11111111);
- var b = try Int.initSet(al, 0xeeeeeeee22222222);
+ var a = try Int.initSet(testing.allocator, 0xffffffff11111111);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222);
+ defer b.deinit();
try a.bitOr(a, b);
@@ -2456,8 +2688,10 @@ test "big.int bitwise or simple" {
}
test "big.int bitwise or multi-limb" {
- var a = try Int.initSet(al, maxInt(Limb) + 1);
- var b = try Int.initSet(al, maxInt(Limb));
+ var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1);
+ defer a.deinit();
+ var b = try Int.initSet(testing.allocator, maxInt(Limb));
+ defer b.deinit();
try a.bitOr(a, b);
@@ -2466,11 +2700,19 @@ test "big.int bitwise or multi-limb" {
}
test "big.int var args" {
- var a = try Int.initSet(al, 5);
+ var a = try Int.initSet(testing.allocator, 5);
+ defer a.deinit();
- try a.add(a, try Int.initSet(al, 6));
+ const b = try Int.initSet(testing.allocator, 6);
+ defer b.deinit();
+ try a.add(a, b);
testing.expect((try a.to(u64)) == 11);
- testing.expect(a.cmp(try Int.initSet(al, 11)) == 0);
- testing.expect(a.cmp(try Int.initSet(al, 14)) <= 0);
+ const c = try Int.initSet(testing.allocator, 11);
+ defer c.deinit();
+ testing.expect(a.cmp(c) == 0);
+
+ const d = try Int.initSet(testing.allocator, 14);
+ defer d.deinit();
+ testing.expect(a.cmp(d) <= 0);
}