| ... | @@ -1360,13 +1360,10 @@ pub const Int = struct { | ... | @@ -1360,13 +1360,10 @@ pub const Int = struct { |
| 1360 | // They will still run on larger than this and should pass, but the multi-limb code-paths | 1360 | // They will still run on larger than this and should pass, but the multi-limb code-paths |
| 1361 | // may be untested in some cases. | 1361 | // may be untested in some cases. |
| 1362 | | 1362 | |
| 1363 | var buffer: [64 * 8192]u8 = undefined; | | |
| 1364 | var fixed = std.heap.FixedBufferAllocator.init(buffer[0..]); | | |
| 1365 | const al = &fixed.allocator; | | |
| 1366 | | | |
| 1367 | test "big.int comptime_int set" { | 1363 | test "big.int comptime_int set" { |
| 1368 | comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab; | 1364 | comptime var s = 0xefffffff00000001eeeeeeefaaaaaaab; |
| 1369 | var a = try Int.initSet(al, s); | 1365 | var a = try Int.initSet(testing.allocator, s); |
| | 1366 | defer a.deinit(); |
| 1370 | | 1367 | |
| 1371 | const s_limb_count = 128 / Limb.bit_count; | 1368 | const s_limb_count = 128 / Limb.bit_count; |
| 1372 | | 1369 | |
| ... | @@ -1380,39 +1377,45 @@ test "big.int comptime_int set" { | ... | @@ -1380,39 +1377,45 @@ test "big.int comptime_int set" { |
| 1380 | } | 1377 | } |
| 1381 | | 1378 | |
| 1382 | test "big.int comptime_int set negative" { | 1379 | test "big.int comptime_int set negative" { |
| 1383 | var a = try Int.initSet(al, -10); | 1380 | var a = try Int.initSet(testing.allocator, -10); |
| | 1381 | defer a.deinit(); |
| 1384 | | 1382 | |
| 1385 | testing.expect(a.limbs[0] == 10); | 1383 | testing.expect(a.limbs[0] == 10); |
| 1386 | testing.expect(a.isPositive() == false); | 1384 | testing.expect(a.isPositive() == false); |
| 1387 | } | 1385 | } |
| 1388 | | 1386 | |
| 1389 | test "big.int int set unaligned small" { | 1387 | test "big.int int set unaligned small" { |
| 1390 | var a = try Int.initSet(al, @as(u7, 45)); | 1388 | var a = try Int.initSet(testing.allocator, @as(u7, 45)); |
| | 1389 | defer a.deinit(); |
| 1391 | | 1390 | |
| 1392 | testing.expect(a.limbs[0] == 45); | 1391 | testing.expect(a.limbs[0] == 45); |
| 1393 | testing.expect(a.isPositive() == true); | 1392 | testing.expect(a.isPositive() == true); |
| 1394 | } | 1393 | } |
| 1395 | | 1394 | |
| 1396 | test "big.int comptime_int to" { | 1395 | test "big.int comptime_int to" { |
| 1397 | const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab); | 1396 | const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab); |
| | 1397 | defer a.deinit(); |
| 1398 | | 1398 | |
| 1399 | testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab); | 1399 | testing.expect((try a.to(u128)) == 0xefffffff00000001eeeeeeefaaaaaaab); |
| 1400 | } | 1400 | } |
| 1401 | | 1401 | |
| 1402 | test "big.int sub-limb to" { | 1402 | test "big.int sub-limb to" { |
| 1403 | const a = try Int.initSet(al, 10); | 1403 | const a = try Int.initSet(testing.allocator, 10); |
| | 1404 | defer a.deinit(); |
| 1404 | | 1405 | |
| 1405 | testing.expect((try a.to(u8)) == 10); | 1406 | testing.expect((try a.to(u8)) == 10); |
| 1406 | } | 1407 | } |
| 1407 | | 1408 | |
| 1408 | test "big.int to target too small error" { | 1409 | test "big.int to target too small error" { |
| 1409 | const a = try Int.initSet(al, 0xffffffff); | 1410 | const a = try Int.initSet(testing.allocator, 0xffffffff); |
| | 1411 | defer a.deinit(); |
| 1410 | | 1412 | |
| 1411 | testing.expectError(error.TargetTooSmall, a.to(u8)); | 1413 | testing.expectError(error.TargetTooSmall, a.to(u8)); |
| 1412 | } | 1414 | } |
| 1413 | | 1415 | |
| 1414 | test "big.int normalize" { | 1416 | test "big.int normalize" { |
| 1415 | var a = try Int.init(al); | 1417 | var a = try Int.init(testing.allocator); |
| | 1418 | defer a.deinit(); |
| 1416 | try a.ensureCapacity(8); | 1419 | try a.ensureCapacity(8); |
| 1417 | | 1420 | |
| 1418 | a.limbs[0] = 1; | 1421 | a.limbs[0] = 1; |
| ... | @@ -1439,7 +1442,8 @@ test "big.int normalize" { | ... | @@ -1439,7 +1442,8 @@ test "big.int normalize" { |
| 1439 | } | 1442 | } |
| 1440 | | 1443 | |
| 1441 | test "big.int normalize multi" { | 1444 | test "big.int normalize multi" { |
| 1442 | var a = try Int.init(al); | 1445 | var a = try Int.init(testing.allocator); |
| | 1446 | defer a.deinit(); |
| 1443 | try a.ensureCapacity(8); | 1447 | try a.ensureCapacity(8); |
| 1444 | | 1448 | |
| 1445 | a.limbs[0] = 1; | 1449 | a.limbs[0] = 1; |
| ... | @@ -1468,7 +1472,9 @@ test "big.int normalize multi" { | ... | @@ -1468,7 +1472,9 @@ test "big.int normalize multi" { |
| 1468 | } | 1472 | } |
| 1469 | | 1473 | |
| 1470 | test "big.int parity" { | 1474 | test "big.int parity" { |
| 1471 | var a = try Int.init(al); | 1475 | var a = try Int.init(testing.allocator); |
| | 1476 | defer a.deinit(); |
| | 1477 | |
| 1472 | try a.set(0); | 1478 | try a.set(0); |
| 1473 | testing.expect(a.isEven()); | 1479 | testing.expect(a.isEven()); |
| 1474 | testing.expect(!a.isOdd()); | 1480 | testing.expect(!a.isOdd()); |
| ... | @@ -1479,7 +1485,8 @@ test "big.int parity" { | ... | @@ -1479,7 +1485,8 @@ test "big.int parity" { |
| 1479 | } | 1485 | } |
| 1480 | | 1486 | |
| 1481 | test "big.int bitcount + sizeInBase" { | 1487 | test "big.int bitcount + sizeInBase" { |
| 1482 | var a = try Int.init(al); | 1488 | var a = try Int.init(testing.allocator); |
| | 1489 | defer a.deinit(); |
| 1483 | | 1490 | |
| 1484 | try a.set(0b100); | 1491 | try a.set(0b100); |
| 1485 | testing.expect(a.bitCountAbs() == 3); | 1492 | testing.expect(a.bitCountAbs() == 3); |
| ... | @@ -1506,7 +1513,8 @@ test "big.int bitcount + sizeInBase" { | ... | @@ -1506,7 +1513,8 @@ test "big.int bitcount + sizeInBase" { |
| 1506 | } | 1513 | } |
| 1507 | | 1514 | |
| 1508 | test "big.int bitcount/to" { | 1515 | test "big.int bitcount/to" { |
| 1509 | var a = try Int.init(al); | 1516 | var a = try Int.init(testing.allocator); |
| | 1517 | defer a.deinit(); |
| 1510 | | 1518 | |
| 1511 | try a.set(0); | 1519 | try a.set(0); |
| 1512 | testing.expect(a.bitCountTwosComp() == 0); | 1520 | testing.expect(a.bitCountTwosComp() == 0); |
| ... | @@ -1536,7 +1544,8 @@ test "big.int bitcount/to" { | ... | @@ -1536,7 +1544,8 @@ test "big.int bitcount/to" { |
| 1536 | } | 1544 | } |
| 1537 | | 1545 | |
| 1538 | test "big.int fits" { | 1546 | test "big.int fits" { |
| 1539 | var a = try Int.init(al); | 1547 | var a = try Int.init(testing.allocator); |
| | 1548 | defer a.deinit(); |
| 1540 | | 1549 | |
| 1541 | try a.set(0); | 1550 | try a.set(0); |
| 1542 | testing.expect(a.fits(u0)); | 1551 | testing.expect(a.fits(u0)); |
| ... | @@ -1563,82 +1572,100 @@ test "big.int fits" { | ... | @@ -1563,82 +1572,100 @@ test "big.int fits" { |
| 1563 | } | 1572 | } |
| 1564 | | 1573 | |
| 1565 | test "big.int string set" { | 1574 | test "big.int string set" { |
| 1566 | var a = try Int.init(al); | 1575 | var a = try Int.init(testing.allocator); |
| 1567 | try a.setString(10, "120317241209124781241290847124"); | 1576 | defer a.deinit(); |
| 1568 | | 1577 | |
| | 1578 | try a.setString(10, "120317241209124781241290847124"); |
| 1569 | testing.expect((try a.to(u128)) == 120317241209124781241290847124); | 1579 | testing.expect((try a.to(u128)) == 120317241209124781241290847124); |
| 1570 | } | 1580 | } |
| 1571 | | 1581 | |
| 1572 | test "big.int string negative" { | 1582 | test "big.int string negative" { |
| 1573 | var a = try Int.init(al); | 1583 | var a = try Int.init(testing.allocator); |
| | 1584 | defer a.deinit(); |
| | 1585 | |
| 1574 | try a.setString(10, "-1023"); | 1586 | try a.setString(10, "-1023"); |
| 1575 | testing.expect((try a.to(i32)) == -1023); | 1587 | testing.expect((try a.to(i32)) == -1023); |
| 1576 | } | 1588 | } |
| 1577 | | 1589 | |
| 1578 | test "big.int string set bad char error" { | 1590 | test "big.int string set bad char error" { |
| 1579 | var a = try Int.init(al); | 1591 | var a = try Int.init(testing.allocator); |
| | 1592 | defer a.deinit(); |
| 1580 | testing.expectError(error.InvalidCharForDigit, a.setString(10, "x")); | 1593 | testing.expectError(error.InvalidCharForDigit, a.setString(10, "x")); |
| 1581 | } | 1594 | } |
| 1582 | | 1595 | |
| 1583 | test "big.int string set bad base error" { | 1596 | test "big.int string set bad base error" { |
| 1584 | var a = try Int.init(al); | 1597 | var a = try Int.init(testing.allocator); |
| | 1598 | defer a.deinit(); |
| 1585 | testing.expectError(error.InvalidBase, a.setString(45, "10")); | 1599 | testing.expectError(error.InvalidBase, a.setString(45, "10")); |
| 1586 | } | 1600 | } |
| 1587 | | 1601 | |
| 1588 | test "big.int string to" { | 1602 | test "big.int string to" { |
| 1589 | const a = try Int.initSet(al, 120317241209124781241290847124); | 1603 | const a = try Int.initSet(testing.allocator, 120317241209124781241290847124); |
| | 1604 | defer a.deinit(); |
| 1590 | | 1605 | |
| 1591 | const as = try a.toString(al, 10); | 1606 | const as = try a.toString(testing.allocator, 10); |
| | 1607 | defer testing.allocator.free(as); |
| 1592 | const es = "120317241209124781241290847124"; | 1608 | const es = "120317241209124781241290847124"; |
| 1593 | | 1609 | |
| 1594 | testing.expect(mem.eql(u8, as, es)); | 1610 | testing.expect(mem.eql(u8, as, es)); |
| 1595 | } | 1611 | } |
| 1596 | | 1612 | |
| 1597 | test "big.int string to base base error" { | 1613 | test "big.int string to base base error" { |
| 1598 | const a = try Int.initSet(al, 0xffffffff); | 1614 | const a = try Int.initSet(testing.allocator, 0xffffffff); |
| | 1615 | defer a.deinit(); |
| 1599 | | 1616 | |
| 1600 | testing.expectError(error.InvalidBase, a.toString(al, 45)); | 1617 | testing.expectError(error.InvalidBase, a.toString(testing.allocator, 45)); |
| 1601 | } | 1618 | } |
| 1602 | | 1619 | |
| 1603 | test "big.int string to base 2" { | 1620 | test "big.int string to base 2" { |
| 1604 | const a = try Int.initSet(al, -0b1011); | 1621 | const a = try Int.initSet(testing.allocator, -0b1011); |
| | 1622 | defer a.deinit(); |
| 1605 | | 1623 | |
| 1606 | const as = try a.toString(al, 2); | 1624 | const as = try a.toString(testing.allocator, 2); |
| | 1625 | defer testing.allocator.free(as); |
| 1607 | const es = "-1011"; | 1626 | const es = "-1011"; |
| 1608 | | 1627 | |
| 1609 | testing.expect(mem.eql(u8, as, es)); | 1628 | testing.expect(mem.eql(u8, as, es)); |
| 1610 | } | 1629 | } |
| 1611 | | 1630 | |
| 1612 | test "big.int string to base 16" { | 1631 | test "big.int string to base 16" { |
| 1613 | const a = try Int.initSet(al, 0xefffffff00000001eeeeeeefaaaaaaab); | 1632 | const a = try Int.initSet(testing.allocator, 0xefffffff00000001eeeeeeefaaaaaaab); |
| | 1633 | defer a.deinit(); |
| 1614 | | 1634 | |
| 1615 | const as = try a.toString(al, 16); | 1635 | const as = try a.toString(testing.allocator, 16); |
| | 1636 | defer testing.allocator.free(as); |
| 1616 | const es = "efffffff00000001eeeeeeefaaaaaaab"; | 1637 | const es = "efffffff00000001eeeeeeefaaaaaaab"; |
| 1617 | | 1638 | |
| 1618 | testing.expect(mem.eql(u8, as, es)); | 1639 | testing.expect(mem.eql(u8, as, es)); |
| 1619 | } | 1640 | } |
| 1620 | | 1641 | |
| 1621 | test "big.int neg string to" { | 1642 | test "big.int neg string to" { |
| 1622 | const a = try Int.initSet(al, -123907434); | 1643 | const a = try Int.initSet(testing.allocator, -123907434); |
| | 1644 | defer a.deinit(); |
| 1623 | | 1645 | |
| 1624 | const as = try a.toString(al, 10); | 1646 | const as = try a.toString(testing.allocator, 10); |
| | 1647 | defer testing.allocator.free(as); |
| 1625 | const es = "-123907434"; | 1648 | const es = "-123907434"; |
| 1626 | | 1649 | |
| 1627 | testing.expect(mem.eql(u8, as, es)); | 1650 | testing.expect(mem.eql(u8, as, es)); |
| 1628 | } | 1651 | } |
| 1629 | | 1652 | |
| 1630 | test "big.int zero string to" { | 1653 | test "big.int zero string to" { |
| 1631 | const a = try Int.initSet(al, 0); | 1654 | const a = try Int.initSet(testing.allocator, 0); |
| | 1655 | defer a.deinit(); |
| 1632 | | 1656 | |
| 1633 | const as = try a.toString(al, 10); | 1657 | const as = try a.toString(testing.allocator, 10); |
| | 1658 | defer testing.allocator.free(as); |
| 1634 | const es = "0"; | 1659 | const es = "0"; |
| 1635 | | 1660 | |
| 1636 | testing.expect(mem.eql(u8, as, es)); | 1661 | testing.expect(mem.eql(u8, as, es)); |
| 1637 | } | 1662 | } |
| 1638 | | 1663 | |
| 1639 | test "big.int clone" { | 1664 | test "big.int clone" { |
| 1640 | var a = try Int.initSet(al, 1234); | 1665 | var a = try Int.initSet(testing.allocator, 1234); |
| | 1666 | defer a.deinit(); |
| 1641 | const b = try a.clone(); | 1667 | const b = try a.clone(); |
| | 1668 | defer b.deinit(); |
| 1642 | | 1669 | |
| 1643 | testing.expect((try a.to(u32)) == 1234); | 1670 | testing.expect((try a.to(u32)) == 1234); |
| 1644 | testing.expect((try b.to(u32)) == 1234); | 1671 | testing.expect((try b.to(u32)) == 1234); |
| ... | @@ -1649,8 +1676,10 @@ test "big.int clone" { | ... | @@ -1649,8 +1676,10 @@ test "big.int clone" { |
| 1649 | } | 1676 | } |
| 1650 | | 1677 | |
| 1651 | test "big.int swap" { | 1678 | test "big.int swap" { |
| 1652 | var a = try Int.initSet(al, 1234); | 1679 | var a = try Int.initSet(testing.allocator, 1234); |
| 1653 | var b = try Int.initSet(al, 5678); | 1680 | defer a.deinit(); |
| | 1681 | var b = try Int.initSet(testing.allocator, 5678); |
| | 1682 | defer b.deinit(); |
| 1654 | | 1683 | |
| 1655 | testing.expect((try a.to(u32)) == 1234); | 1684 | testing.expect((try a.to(u32)) == 1234); |
| 1656 | testing.expect((try b.to(u32)) == 5678); | 1685 | testing.expect((try b.to(u32)) == 5678); |
| ... | @@ -1662,53 +1691,65 @@ test "big.int swap" { | ... | @@ -1662,53 +1691,65 @@ test "big.int swap" { |
| 1662 | } | 1691 | } |
| 1663 | | 1692 | |
| 1664 | test "big.int to negative" { | 1693 | test "big.int to negative" { |
| 1665 | var a = try Int.initSet(al, -10); | 1694 | var a = try Int.initSet(testing.allocator, -10); |
| | 1695 | defer a.deinit(); |
| 1666 | | 1696 | |
| 1667 | testing.expect((try a.to(i32)) == -10); | 1697 | testing.expect((try a.to(i32)) == -10); |
| 1668 | } | 1698 | } |
| 1669 | | 1699 | |
| 1670 | test "big.int compare" { | 1700 | test "big.int compare" { |
| 1671 | var a = try Int.initSet(al, -11); | 1701 | var a = try Int.initSet(testing.allocator, -11); |
| 1672 | var b = try Int.initSet(al, 10); | 1702 | defer a.deinit(); |
| | 1703 | var b = try Int.initSet(testing.allocator, 10); |
| | 1704 | defer b.deinit(); |
| 1673 | | 1705 | |
| 1674 | testing.expect(a.cmpAbs(b) == 1); | 1706 | testing.expect(a.cmpAbs(b) == 1); |
| 1675 | testing.expect(a.cmp(b) == -1); | 1707 | testing.expect(a.cmp(b) == -1); |
| 1676 | } | 1708 | } |
| 1677 | | 1709 | |
| 1678 | test "big.int compare similar" { | 1710 | test "big.int compare similar" { |
| 1679 | var a = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeee); | 1711 | var a = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeee); |
| 1680 | var b = try Int.initSet(al, 0xffffffffeeeeeeeeffffffffeeeeeeef); | 1712 | defer a.deinit(); |
| | 1713 | var b = try Int.initSet(testing.allocator, 0xffffffffeeeeeeeeffffffffeeeeeeef); |
| | 1714 | defer b.deinit(); |
| 1681 | | 1715 | |
| 1682 | testing.expect(a.cmpAbs(b) == -1); | 1716 | testing.expect(a.cmpAbs(b) == -1); |
| 1683 | testing.expect(b.cmpAbs(a) == 1); | 1717 | testing.expect(b.cmpAbs(a) == 1); |
| 1684 | } | 1718 | } |
| 1685 | | 1719 | |
| 1686 | test "big.int compare different limb size" { | 1720 | test "big.int compare different limb size" { |
| 1687 | var a = try Int.initSet(al, maxInt(Limb) + 1); | 1721 | var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); |
| 1688 | var b = try Int.initSet(al, 1); | 1722 | defer a.deinit(); |
| | 1723 | var b = try Int.initSet(testing.allocator, 1); |
| | 1724 | defer b.deinit(); |
| 1689 | | 1725 | |
| 1690 | testing.expect(a.cmpAbs(b) == 1); | 1726 | testing.expect(a.cmpAbs(b) == 1); |
| 1691 | testing.expect(b.cmpAbs(a) == -1); | 1727 | testing.expect(b.cmpAbs(a) == -1); |
| 1692 | } | 1728 | } |
| 1693 | | 1729 | |
| 1694 | test "big.int compare multi-limb" { | 1730 | test "big.int compare multi-limb" { |
| 1695 | var a = try Int.initSet(al, -0x7777777799999999ffffeeeeffffeeeeffffeeeef); | 1731 | var a = try Int.initSet(testing.allocator, -0x7777777799999999ffffeeeeffffeeeeffffeeeef); |
| 1696 | var b = try Int.initSet(al, 0x7777777799999999ffffeeeeffffeeeeffffeeeee); | 1732 | defer a.deinit(); |
| | 1733 | var b = try Int.initSet(testing.allocator, 0x7777777799999999ffffeeeeffffeeeeffffeeeee); |
| | 1734 | defer b.deinit(); |
| 1697 | | 1735 | |
| 1698 | testing.expect(a.cmpAbs(b) == 1); | 1736 | testing.expect(a.cmpAbs(b) == 1); |
| 1699 | testing.expect(a.cmp(b) == -1); | 1737 | testing.expect(a.cmp(b) == -1); |
| 1700 | } | 1738 | } |
| 1701 | | 1739 | |
| 1702 | test "big.int equality" { | 1740 | test "big.int equality" { |
| 1703 | var a = try Int.initSet(al, 0xffffffff1); | 1741 | var a = try Int.initSet(testing.allocator, 0xffffffff1); |
| 1704 | var b = try Int.initSet(al, -0xffffffff1); | 1742 | defer a.deinit(); |
| | 1743 | var b = try Int.initSet(testing.allocator, -0xffffffff1); |
| | 1744 | defer b.deinit(); |
| 1705 | | 1745 | |
| 1706 | testing.expect(a.eqAbs(b)); | 1746 | testing.expect(a.eqAbs(b)); |
| 1707 | testing.expect(!a.eq(b)); | 1747 | testing.expect(!a.eq(b)); |
| 1708 | } | 1748 | } |
| 1709 | | 1749 | |
| 1710 | test "big.int abs" { | 1750 | test "big.int abs" { |
| 1711 | var a = try Int.initSet(al, -5); | 1751 | var a = try Int.initSet(testing.allocator, -5); |
| | 1752 | defer a.deinit(); |
| 1712 | | 1753 | |
| 1713 | a.abs(); | 1754 | a.abs(); |
| 1714 | testing.expect((try a.to(u32)) == 5); | 1755 | testing.expect((try a.to(u32)) == 5); |
| ... | @@ -1718,7 +1759,8 @@ test "big.int abs" { | ... | @@ -1718,7 +1759,8 @@ test "big.int abs" { |
| 1718 | } | 1759 | } |
| 1719 | | 1760 | |
| 1720 | test "big.int negate" { | 1761 | test "big.int negate" { |
| 1721 | var a = try Int.initSet(al, 5); | 1762 | var a = try Int.initSet(testing.allocator, 5); |
| | 1763 | defer a.deinit(); |
| 1722 | | 1764 | |
| 1723 | a.negate(); | 1765 | a.negate(); |
| 1724 | testing.expect((try a.to(i32)) == -5); | 1766 | testing.expect((try a.to(i32)) == -5); |
| ... | @@ -1728,20 +1770,26 @@ test "big.int negate" { | ... | @@ -1728,20 +1770,26 @@ test "big.int negate" { |
| 1728 | } | 1770 | } |
| 1729 | | 1771 | |
| 1730 | test "big.int add single-single" { | 1772 | test "big.int add single-single" { |
| 1731 | var a = try Int.initSet(al, 50); | 1773 | var a = try Int.initSet(testing.allocator, 50); |
| 1732 | var b = try Int.initSet(al, 5); | 1774 | defer a.deinit(); |
| | 1775 | var b = try Int.initSet(testing.allocator, 5); |
| | 1776 | defer b.deinit(); |
| 1733 | | 1777 | |
| 1734 | var c = try Int.init(al); | 1778 | var c = try Int.init(testing.allocator); |
| | 1779 | defer c.deinit(); |
| 1735 | try c.add(a, b); | 1780 | try c.add(a, b); |
| 1736 | | 1781 | |
| 1737 | testing.expect((try c.to(u32)) == 55); | 1782 | testing.expect((try c.to(u32)) == 55); |
| 1738 | } | 1783 | } |
| 1739 | | 1784 | |
| 1740 | test "big.int add multi-single" { | 1785 | test "big.int add multi-single" { |
| 1741 | var a = try Int.initSet(al, maxInt(Limb) + 1); | 1786 | var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); |
| 1742 | var b = try Int.initSet(al, 1); | 1787 | defer a.deinit(); |
| | 1788 | var b = try Int.initSet(testing.allocator, 1); |
| | 1789 | defer b.deinit(); |
| 1743 | | 1790 | |
| 1744 | var c = try Int.init(al); | 1791 | var c = try Int.init(testing.allocator); |
| | 1792 | defer c.deinit(); |
| 1745 | | 1793 | |
| 1746 | try c.add(a, b); | 1794 | try c.add(a, b); |
| 1747 | testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2); | 1795 | testing.expect((try c.to(DoubleLimb)) == maxInt(Limb) + 2); |
| ... | @@ -1753,20 +1801,26 @@ test "big.int add multi-single" { | ... | @@ -1753,20 +1801,26 @@ test "big.int add multi-single" { |
| 1753 | test "big.int add multi-multi" { | 1801 | test "big.int add multi-multi" { |
| 1754 | const op1 = 0xefefefef7f7f7f7f; | 1802 | const op1 = 0xefefefef7f7f7f7f; |
| 1755 | const op2 = 0xfefefefe9f9f9f9f; | 1803 | const op2 = 0xfefefefe9f9f9f9f; |
| 1756 | var a = try Int.initSet(al, op1); | 1804 | var a = try Int.initSet(testing.allocator, op1); |
| 1757 | var b = try Int.initSet(al, op2); | 1805 | defer a.deinit(); |
| | 1806 | var b = try Int.initSet(testing.allocator, op2); |
| | 1807 | defer b.deinit(); |
| 1758 | | 1808 | |
| 1759 | var c = try Int.init(al); | 1809 | var c = try Int.init(testing.allocator); |
| | 1810 | defer c.deinit(); |
| 1760 | try c.add(a, b); | 1811 | try c.add(a, b); |
| 1761 | | 1812 | |
| 1762 | testing.expect((try c.to(u128)) == op1 + op2); | 1813 | testing.expect((try c.to(u128)) == op1 + op2); |
| 1763 | } | 1814 | } |
| 1764 | | 1815 | |
| 1765 | test "big.int add zero-zero" { | 1816 | test "big.int add zero-zero" { |
| 1766 | var a = try Int.initSet(al, 0); | 1817 | var a = try Int.initSet(testing.allocator, 0); |
| 1767 | var b = try Int.initSet(al, 0); | 1818 | defer a.deinit(); |
| | 1819 | var b = try Int.initSet(testing.allocator, 0); |
| | 1820 | defer b.deinit(); |
| 1768 | | 1821 | |
| 1769 | var c = try Int.init(al); | 1822 | var c = try Int.init(testing.allocator); |
| | 1823 | defer c.deinit(); |
| 1770 | try c.add(a, b); | 1824 | try c.add(a, b); |
| 1771 | | 1825 | |
| 1772 | testing.expect((try c.to(u32)) == 0); | 1826 | testing.expect((try c.to(u32)) == 0); |
| ... | @@ -1774,8 +1828,10 @@ test "big.int add zero-zero" { | ... | @@ -1774,8 +1828,10 @@ test "big.int add zero-zero" { |
| 1774 | | 1828 | |
| 1775 | test "big.int add alias multi-limb nonzero-zero" { | 1829 | test "big.int add alias multi-limb nonzero-zero" { |
| 1776 | const op1 = 0xffffffff777777771; | 1830 | const op1 = 0xffffffff777777771; |
| 1777 | var a = try Int.initSet(al, op1); | 1831 | var a = try Int.initSet(testing.allocator, op1); |
| 1778 | var b = try Int.initSet(al, 0); | 1832 | defer a.deinit(); |
| | 1833 | var b = try Int.initSet(testing.allocator, 0); |
| | 1834 | defer b.deinit(); |
| 1779 | | 1835 | |
| 1780 | try a.add(a, b); | 1836 | try a.add(a, b); |
| 1781 | | 1837 | |
| ... | @@ -1783,12 +1839,17 @@ test "big.int add alias multi-limb nonzero-zero" { | ... | @@ -1783,12 +1839,17 @@ test "big.int add alias multi-limb nonzero-zero" { |
| 1783 | } | 1839 | } |
| 1784 | | 1840 | |
| 1785 | test "big.int add sign" { | 1841 | test "big.int add sign" { |
| 1786 | var a = try Int.init(al); | 1842 | var a = try Int.init(testing.allocator); |
| 1787 | | 1843 | defer a.deinit(); |
| 1788 | const one = try Int.initSet(al, 1); | 1844 | |
| 1789 | const two = try Int.initSet(al, 2); | 1845 | const one = try Int.initSet(testing.allocator, 1); |
| 1790 | const neg_one = try Int.initSet(al, -1); | 1846 | defer one.deinit(); |
| 1791 | const neg_two = try Int.initSet(al, -2); | 1847 | const two = try Int.initSet(testing.allocator, 2); |
| | 1848 | defer two.deinit(); |
| | 1849 | const neg_one = try Int.initSet(testing.allocator, -1); |
| | 1850 | defer neg_one.deinit(); |
| | 1851 | const neg_two = try Int.initSet(testing.allocator, -2); |
| | 1852 | defer neg_two.deinit(); |
| 1792 | | 1853 | |
| 1793 | try a.add(one, two); | 1854 | try a.add(one, two); |
| 1794 | testing.expect((try a.to(i32)) == 3); | 1855 | testing.expect((try a.to(i32)) == 3); |
| ... | @@ -1804,20 +1865,26 @@ test "big.int add sign" { | ... | @@ -1804,20 +1865,26 @@ test "big.int add sign" { |
| 1804 | } | 1865 | } |
| 1805 | | 1866 | |
| 1806 | test "big.int sub single-single" { | 1867 | test "big.int sub single-single" { |
| 1807 | var a = try Int.initSet(al, 50); | 1868 | var a = try Int.initSet(testing.allocator, 50); |
| 1808 | var b = try Int.initSet(al, 5); | 1869 | defer a.deinit(); |
| | 1870 | var b = try Int.initSet(testing.allocator, 5); |
| | 1871 | defer b.deinit(); |
| 1809 | | 1872 | |
| 1810 | var c = try Int.init(al); | 1873 | var c = try Int.init(testing.allocator); |
| | 1874 | defer c.deinit(); |
| 1811 | try c.sub(a, b); | 1875 | try c.sub(a, b); |
| 1812 | | 1876 | |
| 1813 | testing.expect((try c.to(u32)) == 45); | 1877 | testing.expect((try c.to(u32)) == 45); |
| 1814 | } | 1878 | } |
| 1815 | | 1879 | |
| 1816 | test "big.int sub multi-single" { | 1880 | test "big.int sub multi-single" { |
| 1817 | var a = try Int.initSet(al, maxInt(Limb) + 1); | 1881 | var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); |
| 1818 | var b = try Int.initSet(al, 1); | 1882 | defer a.deinit(); |
| | 1883 | var b = try Int.initSet(testing.allocator, 1); |
| | 1884 | defer b.deinit(); |
| 1819 | | 1885 | |
| 1820 | var c = try Int.init(al); | 1886 | var c = try Int.init(testing.allocator); |
| | 1887 | defer c.deinit(); |
| 1821 | try c.sub(a, b); | 1888 | try c.sub(a, b); |
| 1822 | | 1889 | |
| 1823 | testing.expect((try c.to(Limb)) == maxInt(Limb)); | 1890 | testing.expect((try c.to(Limb)) == maxInt(Limb)); |
| ... | @@ -1827,32 +1894,43 @@ test "big.int sub multi-multi" { | ... | @@ -1827,32 +1894,43 @@ test "big.int sub multi-multi" { |
| 1827 | const op1 = 0xefefefefefefefefefefefef; | 1894 | const op1 = 0xefefefefefefefefefefefef; |
| 1828 | const op2 = 0xabababababababababababab; | 1895 | const op2 = 0xabababababababababababab; |
| 1829 | | 1896 | |
| 1830 | var a = try Int.initSet(al, op1); | 1897 | var a = try Int.initSet(testing.allocator, op1); |
| 1831 | var b = try Int.initSet(al, op2); | 1898 | defer a.deinit(); |
| | 1899 | var b = try Int.initSet(testing.allocator, op2); |
| | 1900 | defer b.deinit(); |
| 1832 | | 1901 | |
| 1833 | var c = try Int.init(al); | 1902 | var c = try Int.init(testing.allocator); |
| | 1903 | defer c.deinit(); |
| 1834 | try c.sub(a, b); | 1904 | try c.sub(a, b); |
| 1835 | | 1905 | |
| 1836 | testing.expect((try c.to(u128)) == op1 - op2); | 1906 | testing.expect((try c.to(u128)) == op1 - op2); |
| 1837 | } | 1907 | } |
| 1838 | | 1908 | |
| 1839 | test "big.int sub equal" { | 1909 | test "big.int sub equal" { |
| 1840 | var a = try Int.initSet(al, 0x11efefefefefefefefefefefef); | 1910 | var a = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef); |
| 1841 | var b = try Int.initSet(al, 0x11efefefefefefefefefefefef); | 1911 | defer a.deinit(); |
| | 1912 | var b = try Int.initSet(testing.allocator, 0x11efefefefefefefefefefefef); |
| | 1913 | defer b.deinit(); |
| 1842 | | 1914 | |
| 1843 | var c = try Int.init(al); | 1915 | var c = try Int.init(testing.allocator); |
| | 1916 | defer c.deinit(); |
| 1844 | try c.sub(a, b); | 1917 | try c.sub(a, b); |
| 1845 | | 1918 | |
| 1846 | testing.expect((try c.to(u32)) == 0); | 1919 | testing.expect((try c.to(u32)) == 0); |
| 1847 | } | 1920 | } |
| 1848 | | 1921 | |
| 1849 | test "big.int sub sign" { | 1922 | test "big.int sub sign" { |
| 1850 | var a = try Int.init(al); | 1923 | var a = try Int.init(testing.allocator); |
| 1851 | | 1924 | defer a.deinit(); |
| 1852 | const one = try Int.initSet(al, 1); | 1925 | |
| 1853 | const two = try Int.initSet(al, 2); | 1926 | const one = try Int.initSet(testing.allocator, 1); |
| 1854 | const neg_one = try Int.initSet(al, -1); | 1927 | defer one.deinit(); |
| 1855 | const neg_two = try Int.initSet(al, -2); | 1928 | const two = try Int.initSet(testing.allocator, 2); |
| | 1929 | defer two.deinit(); |
| | 1930 | const neg_one = try Int.initSet(testing.allocator, -1); |
| | 1931 | defer neg_one.deinit(); |
| | 1932 | const neg_two = try Int.initSet(testing.allocator, -2); |
| | 1933 | defer neg_two.deinit(); |
| 1856 | | 1934 | |
| 1857 | try a.sub(one, two); | 1935 | try a.sub(one, two); |
| 1858 | testing.expect((try a.to(i32)) == -1); | 1936 | testing.expect((try a.to(i32)) == -1); |
| ... | @@ -1871,20 +1949,26 @@ test "big.int sub sign" { | ... | @@ -1871,20 +1949,26 @@ test "big.int sub sign" { |
| 1871 | } | 1949 | } |
| 1872 | | 1950 | |
| 1873 | test "big.int mul single-single" { | 1951 | test "big.int mul single-single" { |
| 1874 | var a = try Int.initSet(al, 50); | 1952 | var a = try Int.initSet(testing.allocator, 50); |
| 1875 | var b = try Int.initSet(al, 5); | 1953 | defer a.deinit(); |
| | 1954 | var b = try Int.initSet(testing.allocator, 5); |
| | 1955 | defer b.deinit(); |
| 1876 | | 1956 | |
| 1877 | var c = try Int.init(al); | 1957 | var c = try Int.init(testing.allocator); |
| | 1958 | defer c.deinit(); |
| 1878 | try c.mul(a, b); | 1959 | try c.mul(a, b); |
| 1879 | | 1960 | |
| 1880 | testing.expect((try c.to(u64)) == 250); | 1961 | testing.expect((try c.to(u64)) == 250); |
| 1881 | } | 1962 | } |
| 1882 | | 1963 | |
| 1883 | test "big.int mul multi-single" { | 1964 | test "big.int mul multi-single" { |
| 1884 | var a = try Int.initSet(al, maxInt(Limb)); | 1965 | var a = try Int.initSet(testing.allocator, maxInt(Limb)); |
| 1885 | var b = try Int.initSet(al, 2); | 1966 | defer a.deinit(); |
| | 1967 | var b = try Int.initSet(testing.allocator, 2); |
| | 1968 | defer b.deinit(); |
| 1886 | | 1969 | |
| 1887 | var c = try Int.init(al); | 1970 | var c = try Int.init(testing.allocator); |
| | 1971 | defer c.deinit(); |
| 1888 | try c.mul(a, b); | 1972 | try c.mul(a, b); |
| 1889 | | 1973 | |
| 1890 | testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb)); | 1974 | testing.expect((try c.to(DoubleLimb)) == 2 * maxInt(Limb)); |
| ... | @@ -1893,18 +1977,23 @@ test "big.int mul multi-single" { | ... | @@ -1893,18 +1977,23 @@ test "big.int mul multi-single" { |
| 1893 | test "big.int mul multi-multi" { | 1977 | test "big.int mul multi-multi" { |
| 1894 | const op1 = 0x998888efefefefefefefef; | 1978 | const op1 = 0x998888efefefefefefefef; |
| 1895 | const op2 = 0x333000abababababababab; | 1979 | const op2 = 0x333000abababababababab; |
| 1896 | var a = try Int.initSet(al, op1); | 1980 | var a = try Int.initSet(testing.allocator, op1); |
| 1897 | var b = try Int.initSet(al, op2); | 1981 | defer a.deinit(); |
| | 1982 | var b = try Int.initSet(testing.allocator, op2); |
| | 1983 | defer b.deinit(); |
| 1898 | | 1984 | |
| 1899 | var c = try Int.init(al); | 1985 | var c = try Int.init(testing.allocator); |
| | 1986 | defer c.deinit(); |
| 1900 | try c.mul(a, b); | 1987 | try c.mul(a, b); |
| 1901 | | 1988 | |
| 1902 | testing.expect((try c.to(u256)) == op1 * op2); | 1989 | testing.expect((try c.to(u256)) == op1 * op2); |
| 1903 | } | 1990 | } |
| 1904 | | 1991 | |
| 1905 | test "big.int mul alias r with a" { | 1992 | test "big.int mul alias r with a" { |
| 1906 | var a = try Int.initSet(al, maxInt(Limb)); | 1993 | var a = try Int.initSet(testing.allocator, maxInt(Limb)); |
| 1907 | var b = try Int.initSet(al, 2); | 1994 | defer a.deinit(); |
| | 1995 | var b = try Int.initSet(testing.allocator, 2); |
| | 1996 | defer b.deinit(); |
| 1908 | | 1997 | |
| 1909 | try a.mul(a, b); | 1998 | try a.mul(a, b); |
| 1910 | | 1999 | |
| ... | @@ -1912,8 +2001,10 @@ test "big.int mul alias r with a" { | ... | @@ -1912,8 +2001,10 @@ test "big.int mul alias r with a" { |
| 1912 | } | 2001 | } |
| 1913 | | 2002 | |
| 1914 | test "big.int mul alias r with b" { | 2003 | test "big.int mul alias r with b" { |
| 1915 | var a = try Int.initSet(al, maxInt(Limb)); | 2004 | var a = try Int.initSet(testing.allocator, maxInt(Limb)); |
| 1916 | var b = try Int.initSet(al, 2); | 2005 | defer a.deinit(); |
| | 2006 | var b = try Int.initSet(testing.allocator, 2); |
| | 2007 | defer b.deinit(); |
| 1917 | | 2008 | |
| 1918 | try a.mul(b, a); | 2009 | try a.mul(b, a); |
| 1919 | | 2010 | |
| ... | @@ -1921,7 +2012,8 @@ test "big.int mul alias r with b" { | ... | @@ -1921,7 +2012,8 @@ test "big.int mul alias r with b" { |
| 1921 | } | 2012 | } |
| 1922 | | 2013 | |
| 1923 | test "big.int mul alias r with a and b" { | 2014 | test "big.int mul alias r with a and b" { |
| 1924 | var a = try Int.initSet(al, maxInt(Limb)); | 2015 | var a = try Int.initSet(testing.allocator, maxInt(Limb)); |
| | 2016 | defer a.deinit(); |
| 1925 | | 2017 | |
| 1926 | try a.mul(a, a); | 2018 | try a.mul(a, a); |
| 1927 | | 2019 | |
| ... | @@ -1929,31 +2021,41 @@ test "big.int mul alias r with a and b" { | ... | @@ -1929,31 +2021,41 @@ test "big.int mul alias r with a and b" { |
| 1929 | } | 2021 | } |
| 1930 | | 2022 | |
| 1931 | test "big.int mul a*0" { | 2023 | test "big.int mul a*0" { |
| 1932 | var a = try Int.initSet(al, 0xefefefefefefefef); | 2024 | var a = try Int.initSet(testing.allocator, 0xefefefefefefefef); |
| 1933 | var b = try Int.initSet(al, 0); | 2025 | defer a.deinit(); |
| | 2026 | var b = try Int.initSet(testing.allocator, 0); |
| | 2027 | defer b.deinit(); |
| 1934 | | 2028 | |
| 1935 | var c = try Int.init(al); | 2029 | var c = try Int.init(testing.allocator); |
| | 2030 | defer c.deinit(); |
| 1936 | try c.mul(a, b); | 2031 | try c.mul(a, b); |
| 1937 | | 2032 | |
| 1938 | testing.expect((try c.to(u32)) == 0); | 2033 | testing.expect((try c.to(u32)) == 0); |
| 1939 | } | 2034 | } |
| 1940 | | 2035 | |
| 1941 | test "big.int mul 0*0" { | 2036 | test "big.int mul 0*0" { |
| 1942 | var a = try Int.initSet(al, 0); | 2037 | var a = try Int.initSet(testing.allocator, 0); |
| 1943 | var b = try Int.initSet(al, 0); | 2038 | defer a.deinit(); |
| | 2039 | var b = try Int.initSet(testing.allocator, 0); |
| | 2040 | defer b.deinit(); |
| 1944 | | 2041 | |
| 1945 | var c = try Int.init(al); | 2042 | var c = try Int.init(testing.allocator); |
| | 2043 | defer c.deinit(); |
| 1946 | try c.mul(a, b); | 2044 | try c.mul(a, b); |
| 1947 | | 2045 | |
| 1948 | testing.expect((try c.to(u32)) == 0); | 2046 | testing.expect((try c.to(u32)) == 0); |
| 1949 | } | 2047 | } |
| 1950 | | 2048 | |
| 1951 | test "big.int div single-single no rem" { | 2049 | test "big.int div single-single no rem" { |
| 1952 | var a = try Int.initSet(al, 50); | 2050 | var a = try Int.initSet(testing.allocator, 50); |
| 1953 | var b = try Int.initSet(al, 5); | 2051 | defer a.deinit(); |
| 1954 | | 2052 | var b = try Int.initSet(testing.allocator, 5); |
| 1955 | var q = try Int.init(al); | 2053 | defer b.deinit(); |
| 1956 | var r = try Int.init(al); | 2054 | |
| | 2055 | var q = try Int.init(testing.allocator); |
| | 2056 | defer q.deinit(); |
| | 2057 | var r = try Int.init(testing.allocator); |
| | 2058 | defer r.deinit(); |
| 1957 | try Int.divTrunc(&q, &r, a, b); | 2059 | try Int.divTrunc(&q, &r, a, b); |
| 1958 | | 2060 | |
| 1959 | testing.expect((try q.to(u32)) == 10); | 2061 | testing.expect((try q.to(u32)) == 10); |
| ... | @@ -1961,11 +2063,15 @@ test "big.int div single-single no rem" { | ... | @@ -1961,11 +2063,15 @@ test "big.int div single-single no rem" { |
| 1961 | } | 2063 | } |
| 1962 | | 2064 | |
| 1963 | test "big.int div single-single with rem" { | 2065 | test "big.int div single-single with rem" { |
| 1964 | var a = try Int.initSet(al, 49); | 2066 | var a = try Int.initSet(testing.allocator, 49); |
| 1965 | var b = try Int.initSet(al, 5); | 2067 | defer a.deinit(); |
| 1966 | | 2068 | var b = try Int.initSet(testing.allocator, 5); |
| 1967 | var q = try Int.init(al); | 2069 | defer b.deinit(); |
| 1968 | var r = try Int.init(al); | 2070 | |
| | 2071 | var q = try Int.init(testing.allocator); |
| | 2072 | defer q.deinit(); |
| | 2073 | var r = try Int.init(testing.allocator); |
| | 2074 | defer r.deinit(); |
| 1969 | try Int.divTrunc(&q, &r, a, b); | 2075 | try Int.divTrunc(&q, &r, a, b); |
| 1970 | | 2076 | |
| 1971 | testing.expect((try q.to(u32)) == 9); | 2077 | testing.expect((try q.to(u32)) == 9); |
| ... | @@ -1976,11 +2082,15 @@ test "big.int div multi-single no rem" { | ... | @@ -1976,11 +2082,15 @@ test "big.int div multi-single no rem" { |
| 1976 | const op1 = 0xffffeeeeddddcccc; | 2082 | const op1 = 0xffffeeeeddddcccc; |
| 1977 | const op2 = 34; | 2083 | const op2 = 34; |
| 1978 | | 2084 | |
| 1979 | var a = try Int.initSet(al, op1); | 2085 | var a = try Int.initSet(testing.allocator, op1); |
| 1980 | var b = try Int.initSet(al, op2); | 2086 | defer a.deinit(); |
| | 2087 | var b = try Int.initSet(testing.allocator, op2); |
| | 2088 | defer b.deinit(); |
| 1981 | | 2089 | |
| 1982 | var q = try Int.init(al); | 2090 | var q = try Int.init(testing.allocator); |
| 1983 | var r = try Int.init(al); | 2091 | defer q.deinit(); |
| | 2092 | var r = try Int.init(testing.allocator); |
| | 2093 | defer r.deinit(); |
| 1984 | try Int.divTrunc(&q, &r, a, b); | 2094 | try Int.divTrunc(&q, &r, a, b); |
| 1985 | | 2095 | |
| 1986 | testing.expect((try q.to(u64)) == op1 / op2); | 2096 | testing.expect((try q.to(u64)) == op1 / op2); |
| ... | @@ -1991,11 +2101,15 @@ test "big.int div multi-single with rem" { | ... | @@ -1991,11 +2101,15 @@ test "big.int div multi-single with rem" { |
| 1991 | const op1 = 0xffffeeeeddddcccf; | 2101 | const op1 = 0xffffeeeeddddcccf; |
| 1992 | const op2 = 34; | 2102 | const op2 = 34; |
| 1993 | | 2103 | |
| 1994 | var a = try Int.initSet(al, op1); | 2104 | var a = try Int.initSet(testing.allocator, op1); |
| 1995 | var b = try Int.initSet(al, op2); | 2105 | defer a.deinit(); |
| | 2106 | var b = try Int.initSet(testing.allocator, op2); |
| | 2107 | defer b.deinit(); |
| 1996 | | 2108 | |
| 1997 | var q = try Int.init(al); | 2109 | var q = try Int.init(testing.allocator); |
| 1998 | var r = try Int.init(al); | 2110 | defer q.deinit(); |
| | 2111 | var r = try Int.init(testing.allocator); |
| | 2112 | defer r.deinit(); |
| 1999 | try Int.divTrunc(&q, &r, a, b); | 2113 | try Int.divTrunc(&q, &r, a, b); |
| 2000 | | 2114 | |
| 2001 | testing.expect((try q.to(u64)) == op1 / op2); | 2115 | testing.expect((try q.to(u64)) == op1 / op2); |
| ... | @@ -2006,11 +2120,15 @@ test "big.int div multi>2-single" { | ... | @@ -2006,11 +2120,15 @@ test "big.int div multi>2-single" { |
| 2006 | const op1 = 0xfefefefefefefefefefefefefefefefe; | 2120 | const op1 = 0xfefefefefefefefefefefefefefefefe; |
| 2007 | const op2 = 0xefab8; | 2121 | const op2 = 0xefab8; |
| 2008 | | 2122 | |
| 2009 | var a = try Int.initSet(al, op1); | 2123 | var a = try Int.initSet(testing.allocator, op1); |
| 2010 | var b = try Int.initSet(al, op2); | 2124 | defer a.deinit(); |
| | 2125 | var b = try Int.initSet(testing.allocator, op2); |
| | 2126 | defer b.deinit(); |
| 2011 | | 2127 | |
| 2012 | var q = try Int.init(al); | 2128 | var q = try Int.init(testing.allocator); |
| 2013 | var r = try Int.init(al); | 2129 | defer q.deinit(); |
| | 2130 | var r = try Int.init(testing.allocator); |
| | 2131 | defer r.deinit(); |
| 2014 | try Int.divTrunc(&q, &r, a, b); | 2132 | try Int.divTrunc(&q, &r, a, b); |
| 2015 | | 2133 | |
| 2016 | testing.expect((try q.to(u128)) == op1 / op2); | 2134 | testing.expect((try q.to(u128)) == op1 / op2); |
| ... | @@ -2018,11 +2136,15 @@ test "big.int div multi>2-single" { | ... | @@ -2018,11 +2136,15 @@ test "big.int div multi>2-single" { |
| 2018 | } | 2136 | } |
| 2019 | | 2137 | |
| 2020 | test "big.int div single-single q < r" { | 2138 | test "big.int div single-single q < r" { |
| 2021 | var a = try Int.initSet(al, 0x0078f432); | 2139 | var a = try Int.initSet(testing.allocator, 0x0078f432); |
| 2022 | var b = try Int.initSet(al, 0x01000000); | 2140 | defer a.deinit(); |
| 2023 | | 2141 | var b = try Int.initSet(testing.allocator, 0x01000000); |
| 2024 | var q = try Int.init(al); | 2142 | defer b.deinit(); |
| 2025 | var r = try Int.init(al); | 2143 | |
| | 2144 | var q = try Int.init(testing.allocator); |
| | 2145 | defer q.deinit(); |
| | 2146 | var r = try Int.init(testing.allocator); |
| | 2147 | defer r.deinit(); |
| 2026 | try Int.divTrunc(&q, &r, a, b); | 2148 | try Int.divTrunc(&q, &r, a, b); |
| 2027 | | 2149 | |
| 2028 | testing.expect((try q.to(u64)) == 0); | 2150 | testing.expect((try q.to(u64)) == 0); |
| ... | @@ -2030,11 +2152,15 @@ test "big.int div single-single q < r" { | ... | @@ -2030,11 +2152,15 @@ test "big.int div single-single q < r" { |
| 2030 | } | 2152 | } |
| 2031 | | 2153 | |
| 2032 | test "big.int div single-single q == r" { | 2154 | test "big.int div single-single q == r" { |
| 2033 | var a = try Int.initSet(al, 10); | 2155 | var a = try Int.initSet(testing.allocator, 10); |
| 2034 | var b = try Int.initSet(al, 10); | 2156 | defer a.deinit(); |
| 2035 | | 2157 | var b = try Int.initSet(testing.allocator, 10); |
| 2036 | var q = try Int.init(al); | 2158 | defer b.deinit(); |
| 2037 | var r = try Int.init(al); | 2159 | |
| | 2160 | var q = try Int.init(testing.allocator); |
| | 2161 | defer q.deinit(); |
| | 2162 | var r = try Int.init(testing.allocator); |
| | 2163 | defer r.deinit(); |
| 2038 | try Int.divTrunc(&q, &r, a, b); | 2164 | try Int.divTrunc(&q, &r, a, b); |
| 2039 | | 2165 | |
| 2040 | testing.expect((try q.to(u64)) == 1); | 2166 | testing.expect((try q.to(u64)) == 1); |
| ... | @@ -2042,8 +2168,10 @@ test "big.int div single-single q == r" { | ... | @@ -2042,8 +2168,10 @@ test "big.int div single-single q == r" { |
| 2042 | } | 2168 | } |
| 2043 | | 2169 | |
| 2044 | test "big.int div q=0 alias" { | 2170 | test "big.int div q=0 alias" { |
| 2045 | var a = try Int.initSet(al, 3); | 2171 | var a = try Int.initSet(testing.allocator, 3); |
| 2046 | var b = try Int.initSet(al, 10); | 2172 | defer a.deinit(); |
| | 2173 | var b = try Int.initSet(testing.allocator, 10); |
| | 2174 | defer b.deinit(); |
| 2047 | | 2175 | |
| 2048 | try Int.divTrunc(&a, &b, a, b); | 2176 | try Int.divTrunc(&a, &b, a, b); |
| 2049 | | 2177 | |
| ... | @@ -2054,11 +2182,15 @@ test "big.int div q=0 alias" { | ... | @@ -2054,11 +2182,15 @@ test "big.int div q=0 alias" { |
| 2054 | test "big.int div multi-multi q < r" { | 2182 | test "big.int div multi-multi q < r" { |
| 2055 | const op1 = 0x1ffffffff0078f432; | 2183 | const op1 = 0x1ffffffff0078f432; |
| 2056 | const op2 = 0x1ffffffff01000000; | 2184 | const op2 = 0x1ffffffff01000000; |
| 2057 | var a = try Int.initSet(al, op1); | 2185 | var a = try Int.initSet(testing.allocator, op1); |
| 2058 | var b = try Int.initSet(al, op2); | 2186 | defer a.deinit(); |
| 2059 | | 2187 | var b = try Int.initSet(testing.allocator, op2); |
| 2060 | var q = try Int.init(al); | 2188 | defer b.deinit(); |
| 2061 | var r = try Int.init(al); | 2189 | |
| | 2190 | var q = try Int.init(testing.allocator); |
| | 2191 | defer q.deinit(); |
| | 2192 | var r = try Int.init(testing.allocator); |
| | 2193 | defer r.deinit(); |
| 2062 | try Int.divTrunc(&q, &r, a, b); | 2194 | try Int.divTrunc(&q, &r, a, b); |
| 2063 | | 2195 | |
| 2064 | testing.expect((try q.to(u128)) == 0); | 2196 | testing.expect((try q.to(u128)) == 0); |
| ... | @@ -2069,11 +2201,15 @@ test "big.int div trunc single-single +/+" { | ... | @@ -2069,11 +2201,15 @@ test "big.int div trunc single-single +/+" { |
| 2069 | const u: i32 = 5; | 2201 | const u: i32 = 5; |
| 2070 | const v: i32 = 3; | 2202 | const v: i32 = 3; |
| 2071 | | 2203 | |
| 2072 | var a = try Int.initSet(al, u); | 2204 | var a = try Int.initSet(testing.allocator, u); |
| 2073 | var b = try Int.initSet(al, v); | 2205 | defer a.deinit(); |
| | 2206 | var b = try Int.initSet(testing.allocator, v); |
| | 2207 | defer b.deinit(); |
| 2074 | | 2208 | |
| 2075 | var q = try Int.init(al); | 2209 | var q = try Int.init(testing.allocator); |
| 2076 | var r = try Int.init(al); | 2210 | defer q.deinit(); |
| | 2211 | var r = try Int.init(testing.allocator); |
| | 2212 | defer r.deinit(); |
| 2077 | try Int.divTrunc(&q, &r, a, b); | 2213 | try Int.divTrunc(&q, &r, a, b); |
| 2078 | | 2214 | |
| 2079 | // n = q * d + r | 2215 | // n = q * d + r |
| ... | @@ -2089,11 +2225,15 @@ test "big.int div trunc single-single -/+" { | ... | @@ -2089,11 +2225,15 @@ test "big.int div trunc single-single -/+" { |
| 2089 | const u: i32 = -5; | 2225 | const u: i32 = -5; |
| 2090 | const v: i32 = 3; | 2226 | const v: i32 = 3; |
| 2091 | | 2227 | |
| 2092 | var a = try Int.initSet(al, u); | 2228 | var a = try Int.initSet(testing.allocator, u); |
| 2093 | var b = try Int.initSet(al, v); | 2229 | defer a.deinit(); |
| | 2230 | var b = try Int.initSet(testing.allocator, v); |
| | 2231 | defer b.deinit(); |
| 2094 | | 2232 | |
| 2095 | var q = try Int.init(al); | 2233 | var q = try Int.init(testing.allocator); |
| 2096 | var r = try Int.init(al); | 2234 | defer q.deinit(); |
| | 2235 | var r = try Int.init(testing.allocator); |
| | 2236 | defer r.deinit(); |
| 2097 | try Int.divTrunc(&q, &r, a, b); | 2237 | try Int.divTrunc(&q, &r, a, b); |
| 2098 | | 2238 | |
| 2099 | // n = q * d + r | 2239 | // n = q * d + r |
| ... | @@ -2109,11 +2249,15 @@ test "big.int div trunc single-single +/-" { | ... | @@ -2109,11 +2249,15 @@ test "big.int div trunc single-single +/-" { |
| 2109 | const u: i32 = 5; | 2249 | const u: i32 = 5; |
| 2110 | const v: i32 = -3; | 2250 | const v: i32 = -3; |
| 2111 | | 2251 | |
| 2112 | var a = try Int.initSet(al, u); | 2252 | var a = try Int.initSet(testing.allocator, u); |
| 2113 | var b = try Int.initSet(al, v); | 2253 | defer a.deinit(); |
| | 2254 | var b = try Int.initSet(testing.allocator, v); |
| | 2255 | defer b.deinit(); |
| 2114 | | 2256 | |
| 2115 | var q = try Int.init(al); | 2257 | var q = try Int.init(testing.allocator); |
| 2116 | var r = try Int.init(al); | 2258 | defer q.deinit(); |
| | 2259 | var r = try Int.init(testing.allocator); |
| | 2260 | defer r.deinit(); |
| 2117 | try Int.divTrunc(&q, &r, a, b); | 2261 | try Int.divTrunc(&q, &r, a, b); |
| 2118 | | 2262 | |
| 2119 | // n = q * d + r | 2263 | // n = q * d + r |
| ... | @@ -2129,11 +2273,15 @@ test "big.int div trunc single-single -/-" { | ... | @@ -2129,11 +2273,15 @@ test "big.int div trunc single-single -/-" { |
| 2129 | const u: i32 = -5; | 2273 | const u: i32 = -5; |
| 2130 | const v: i32 = -3; | 2274 | const v: i32 = -3; |
| 2131 | | 2275 | |
| 2132 | var a = try Int.initSet(al, u); | 2276 | var a = try Int.initSet(testing.allocator, u); |
| 2133 | var b = try Int.initSet(al, v); | 2277 | defer a.deinit(); |
| | 2278 | var b = try Int.initSet(testing.allocator, v); |
| | 2279 | defer b.deinit(); |
| 2134 | | 2280 | |
| 2135 | var q = try Int.init(al); | 2281 | var q = try Int.init(testing.allocator); |
| 2136 | var r = try Int.init(al); | 2282 | defer q.deinit(); |
| | 2283 | var r = try Int.init(testing.allocator); |
| | 2284 | defer r.deinit(); |
| 2137 | try Int.divTrunc(&q, &r, a, b); | 2285 | try Int.divTrunc(&q, &r, a, b); |
| 2138 | | 2286 | |
| 2139 | // n = q * d + r | 2287 | // n = q * d + r |
| ... | @@ -2149,11 +2297,15 @@ test "big.int div floor single-single +/+" { | ... | @@ -2149,11 +2297,15 @@ test "big.int div floor single-single +/+" { |
| 2149 | const u: i32 = 5; | 2297 | const u: i32 = 5; |
| 2150 | const v: i32 = 3; | 2298 | const v: i32 = 3; |
| 2151 | | 2299 | |
| 2152 | var a = try Int.initSet(al, u); | 2300 | var a = try Int.initSet(testing.allocator, u); |
| 2153 | var b = try Int.initSet(al, v); | 2301 | defer a.deinit(); |
| | 2302 | var b = try Int.initSet(testing.allocator, v); |
| | 2303 | defer b.deinit(); |
| 2154 | | 2304 | |
| 2155 | var q = try Int.init(al); | 2305 | var q = try Int.init(testing.allocator); |
| 2156 | var r = try Int.init(al); | 2306 | defer q.deinit(); |
| | 2307 | var r = try Int.init(testing.allocator); |
| | 2308 | defer r.deinit(); |
| 2157 | try Int.divFloor(&q, &r, a, b); | 2309 | try Int.divFloor(&q, &r, a, b); |
| 2158 | | 2310 | |
| 2159 | // n = q * d + r | 2311 | // n = q * d + r |
| ... | @@ -2169,11 +2321,15 @@ test "big.int div floor single-single -/+" { | ... | @@ -2169,11 +2321,15 @@ test "big.int div floor single-single -/+" { |
| 2169 | const u: i32 = -5; | 2321 | const u: i32 = -5; |
| 2170 | const v: i32 = 3; | 2322 | const v: i32 = 3; |
| 2171 | | 2323 | |
| 2172 | var a = try Int.initSet(al, u); | 2324 | var a = try Int.initSet(testing.allocator, u); |
| 2173 | var b = try Int.initSet(al, v); | 2325 | defer a.deinit(); |
| | 2326 | var b = try Int.initSet(testing.allocator, v); |
| | 2327 | defer b.deinit(); |
| 2174 | | 2328 | |
| 2175 | var q = try Int.init(al); | 2329 | var q = try Int.init(testing.allocator); |
| 2176 | var r = try Int.init(al); | 2330 | defer q.deinit(); |
| | 2331 | var r = try Int.init(testing.allocator); |
| | 2332 | defer r.deinit(); |
| 2177 | try Int.divFloor(&q, &r, a, b); | 2333 | try Int.divFloor(&q, &r, a, b); |
| 2178 | | 2334 | |
| 2179 | // n = q * d + r | 2335 | // n = q * d + r |
| ... | @@ -2189,11 +2345,15 @@ test "big.int div floor single-single +/-" { | ... | @@ -2189,11 +2345,15 @@ test "big.int div floor single-single +/-" { |
| 2189 | const u: i32 = 5; | 2345 | const u: i32 = 5; |
| 2190 | const v: i32 = -3; | 2346 | const v: i32 = -3; |
| 2191 | | 2347 | |
| 2192 | var a = try Int.initSet(al, u); | 2348 | var a = try Int.initSet(testing.allocator, u); |
| 2193 | var b = try Int.initSet(al, v); | 2349 | defer a.deinit(); |
| | 2350 | var b = try Int.initSet(testing.allocator, v); |
| | 2351 | defer b.deinit(); |
| 2194 | | 2352 | |
| 2195 | var q = try Int.init(al); | 2353 | var q = try Int.init(testing.allocator); |
| 2196 | var r = try Int.init(al); | 2354 | defer q.deinit(); |
| | 2355 | var r = try Int.init(testing.allocator); |
| | 2356 | defer r.deinit(); |
| 2197 | try Int.divFloor(&q, &r, a, b); | 2357 | try Int.divFloor(&q, &r, a, b); |
| 2198 | | 2358 | |
| 2199 | // n = q * d + r | 2359 | // n = q * d + r |
| ... | @@ -2209,11 +2369,15 @@ test "big.int div floor single-single -/-" { | ... | @@ -2209,11 +2369,15 @@ test "big.int div floor single-single -/-" { |
| 2209 | const u: i32 = -5; | 2369 | const u: i32 = -5; |
| 2210 | const v: i32 = -3; | 2370 | const v: i32 = -3; |
| 2211 | | 2371 | |
| 2212 | var a = try Int.initSet(al, u); | 2372 | var a = try Int.initSet(testing.allocator, u); |
| 2213 | var b = try Int.initSet(al, v); | 2373 | defer a.deinit(); |
| | 2374 | var b = try Int.initSet(testing.allocator, v); |
| | 2375 | defer b.deinit(); |
| 2214 | | 2376 | |
| 2215 | var q = try Int.init(al); | 2377 | var q = try Int.init(testing.allocator); |
| 2216 | var r = try Int.init(al); | 2378 | defer q.deinit(); |
| | 2379 | var r = try Int.init(testing.allocator); |
| | 2380 | defer r.deinit(); |
| 2217 | try Int.divFloor(&q, &r, a, b); | 2381 | try Int.divFloor(&q, &r, a, b); |
| 2218 | | 2382 | |
| 2219 | // n = q * d + r | 2383 | // n = q * d + r |
| ... | @@ -2226,11 +2390,15 @@ test "big.int div floor single-single -/-" { | ... | @@ -2226,11 +2390,15 @@ test "big.int div floor single-single -/-" { |
| 2226 | } | 2390 | } |
| 2227 | | 2391 | |
| 2228 | test "big.int div multi-multi with rem" { | 2392 | test "big.int div multi-multi with rem" { |
| 2229 | var a = try Int.initSet(al, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999); | 2393 | var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeeddddccccbbbbaaaa9999); |
| 2230 | var b = try Int.initSet(al, 0x99990000111122223333); | 2394 | defer a.deinit(); |
| 2231 | | 2395 | var b = try Int.initSet(testing.allocator, 0x99990000111122223333); |
| 2232 | var q = try Int.init(al); | 2396 | defer b.deinit(); |
| 2233 | var r = try Int.init(al); | 2397 | |
| | 2398 | var q = try Int.init(testing.allocator); |
| | 2399 | defer q.deinit(); |
| | 2400 | var r = try Int.init(testing.allocator); |
| | 2401 | defer r.deinit(); |
| 2234 | try Int.divTrunc(&q, &r, a, b); | 2402 | try Int.divTrunc(&q, &r, a, b); |
| 2235 | | 2403 | |
| 2236 | testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); | 2404 | testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); |
| ... | @@ -2238,11 +2406,15 @@ test "big.int div multi-multi with rem" { | ... | @@ -2238,11 +2406,15 @@ test "big.int div multi-multi with rem" { |
| 2238 | } | 2406 | } |
| 2239 | | 2407 | |
| 2240 | test "big.int div multi-multi no rem" { | 2408 | test "big.int div multi-multi no rem" { |
| 2241 | var a = try Int.initSet(al, 0x8888999911110000ffffeeeedb4fec200ee3a4286361); | 2409 | var a = try Int.initSet(testing.allocator, 0x8888999911110000ffffeeeedb4fec200ee3a4286361); |
| 2242 | var b = try Int.initSet(al, 0x99990000111122223333); | 2410 | defer a.deinit(); |
| 2243 | | 2411 | var b = try Int.initSet(testing.allocator, 0x99990000111122223333); |
| 2244 | var q = try Int.init(al); | 2412 | defer b.deinit(); |
| 2245 | var r = try Int.init(al); | 2413 | |
| | 2414 | var q = try Int.init(testing.allocator); |
| | 2415 | defer q.deinit(); |
| | 2416 | var r = try Int.init(testing.allocator); |
| | 2417 | defer r.deinit(); |
| 2246 | try Int.divTrunc(&q, &r, a, b); | 2418 | try Int.divTrunc(&q, &r, a, b); |
| 2247 | | 2419 | |
| 2248 | testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); | 2420 | testing.expect((try q.to(u128)) == 0xe38f38e39161aaabd03f0f1b); |
| ... | @@ -2250,11 +2422,15 @@ test "big.int div multi-multi no rem" { | ... | @@ -2250,11 +2422,15 @@ test "big.int div multi-multi no rem" { |
| 2250 | } | 2422 | } |
| 2251 | | 2423 | |
| 2252 | test "big.int div multi-multi (2 branch)" { | 2424 | test "big.int div multi-multi (2 branch)" { |
| 2253 | var a = try Int.initSet(al, 0x866666665555555588888887777777761111111111111111); | 2425 | var a = try Int.initSet(testing.allocator, 0x866666665555555588888887777777761111111111111111); |
| 2254 | var b = try Int.initSet(al, 0x86666666555555554444444433333333); | 2426 | defer a.deinit(); |
| 2255 | | 2427 | var b = try Int.initSet(testing.allocator, 0x86666666555555554444444433333333); |
| 2256 | var q = try Int.init(al); | 2428 | defer b.deinit(); |
| 2257 | var r = try Int.init(al); | 2429 | |
| | 2430 | var q = try Int.init(testing.allocator); |
| | 2431 | defer q.deinit(); |
| | 2432 | var r = try Int.init(testing.allocator); |
| | 2433 | defer r.deinit(); |
| 2258 | try Int.divTrunc(&q, &r, a, b); | 2434 | try Int.divTrunc(&q, &r, a, b); |
| 2259 | | 2435 | |
| 2260 | testing.expect((try q.to(u128)) == 0x10000000000000000); | 2436 | testing.expect((try q.to(u128)) == 0x10000000000000000); |
| ... | @@ -2262,11 +2438,15 @@ test "big.int div multi-multi (2 branch)" { | ... | @@ -2262,11 +2438,15 @@ test "big.int div multi-multi (2 branch)" { |
| 2262 | } | 2438 | } |
| 2263 | | 2439 | |
| 2264 | test "big.int div multi-multi (3.1/3.3 branch)" { | 2440 | test "big.int div multi-multi (3.1/3.3 branch)" { |
| 2265 | var a = try Int.initSet(al, 0x11111111111111111111111111111111111111111111111111111111111111); | 2441 | var a = try Int.initSet(testing.allocator, 0x11111111111111111111111111111111111111111111111111111111111111); |
| 2266 | var b = try Int.initSet(al, 0x1111111111111111111111111111111111111111171); | 2442 | defer a.deinit(); |
| 2267 | | 2443 | var b = try Int.initSet(testing.allocator, 0x1111111111111111111111111111111111111111171); |
| 2268 | var q = try Int.init(al); | 2444 | defer b.deinit(); |
| 2269 | var r = try Int.init(al); | 2445 | |
| | 2446 | var q = try Int.init(testing.allocator); |
| | 2447 | defer q.deinit(); |
| | 2448 | var r = try Int.init(testing.allocator); |
| | 2449 | defer r.deinit(); |
| 2270 | try Int.divTrunc(&q, &r, a, b); | 2450 | try Int.divTrunc(&q, &r, a, b); |
| 2271 | | 2451 | |
| 2272 | testing.expect((try q.to(u128)) == 0xfffffffffffffffffff); | 2452 | testing.expect((try q.to(u128)) == 0xfffffffffffffffffff); |
| ... | @@ -2274,145 +2454,189 @@ test "big.int div multi-multi (3.1/3.3 branch)" { | ... | @@ -2274,145 +2454,189 @@ test "big.int div multi-multi (3.1/3.3 branch)" { |
| 2274 | } | 2454 | } |
| 2275 | | 2455 | |
| 2276 | test "big.int div multi-single zero-limb trailing" { | 2456 | test "big.int div multi-single zero-limb trailing" { |
| 2277 | var a = try Int.initSet(al, 0x60000000000000000000000000000000000000000000000000000000000000000); | 2457 | var a = try Int.initSet(testing.allocator, 0x60000000000000000000000000000000000000000000000000000000000000000); |
| 2278 | var b = try Int.initSet(al, 0x10000000000000000); | 2458 | defer a.deinit(); |
| 2279 | | 2459 | var b = try Int.initSet(testing.allocator, 0x10000000000000000); |
| 2280 | var q = try Int.init(al); | 2460 | defer b.deinit(); |
| 2281 | var r = try Int.init(al); | 2461 | |
| | 2462 | var q = try Int.init(testing.allocator); |
| | 2463 | defer q.deinit(); |
| | 2464 | var r = try Int.init(testing.allocator); |
| | 2465 | defer r.deinit(); |
| 2282 | try Int.divTrunc(&q, &r, a, b); | 2466 | try Int.divTrunc(&q, &r, a, b); |
| 2283 | | 2467 | |
| 2284 | var expected = try Int.initSet(al, 0x6000000000000000000000000000000000000000000000000); | 2468 | var expected = try Int.initSet(testing.allocator, 0x6000000000000000000000000000000000000000000000000); |
| | 2469 | defer expected.deinit(); |
| 2285 | testing.expect(q.eq(expected)); | 2470 | testing.expect(q.eq(expected)); |
| 2286 | testing.expect(r.eqZero()); | 2471 | testing.expect(r.eqZero()); |
| 2287 | } | 2472 | } |
| 2288 | | 2473 | |
| 2289 | test "big.int div multi-multi zero-limb trailing (with rem)" { | 2474 | test "big.int div multi-multi zero-limb trailing (with rem)" { |
| 2290 | var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); | 2475 | var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); |
| 2291 | var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000); | 2476 | defer a.deinit(); |
| 2292 | | 2477 | var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000); |
| 2293 | var q = try Int.init(al); | 2478 | defer b.deinit(); |
| 2294 | var r = try Int.init(al); | 2479 | |
| | 2480 | var q = try Int.init(testing.allocator); |
| | 2481 | defer q.deinit(); |
| | 2482 | var r = try Int.init(testing.allocator); |
| | 2483 | defer r.deinit(); |
| 2295 | try Int.divTrunc(&q, &r, a, b); | 2484 | try Int.divTrunc(&q, &r, a, b); |
| 2296 | | 2485 | |
| 2297 | testing.expect((try q.to(u128)) == 0x10000000000000000); | 2486 | testing.expect((try q.to(u128)) == 0x10000000000000000); |
| 2298 | | 2487 | |
| 2299 | const rs = try r.toString(al, 16); | 2488 | const rs = try r.toString(testing.allocator, 16); |
| | 2489 | defer testing.allocator.free(rs); |
| 2300 | testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000")); | 2490 | testing.expect(std.mem.eql(u8, rs, "4444444344444443111111111111111100000000000000000000000000000000")); |
| 2301 | } | 2491 | } |
| 2302 | | 2492 | |
| 2303 | test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" { | 2493 | test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count > divisor zero-limb count" { |
| 2304 | var a = try Int.initSet(al, 0x8666666655555555888888877777777611111111111111110000000000000000); | 2494 | var a = try Int.initSet(testing.allocator, 0x8666666655555555888888877777777611111111111111110000000000000000); |
| 2305 | var b = try Int.initSet(al, 0x8666666655555555444444443333333300000000000000000000000000000000); | 2495 | defer a.deinit(); |
| 2306 | | 2496 | var b = try Int.initSet(testing.allocator, 0x8666666655555555444444443333333300000000000000000000000000000000); |
| 2307 | var q = try Int.init(al); | 2497 | defer b.deinit(); |
| 2308 | var r = try Int.init(al); | 2498 | |
| | 2499 | var q = try Int.init(testing.allocator); |
| | 2500 | defer q.deinit(); |
| | 2501 | var r = try Int.init(testing.allocator); |
| | 2502 | defer r.deinit(); |
| 2309 | try Int.divTrunc(&q, &r, a, b); | 2503 | try Int.divTrunc(&q, &r, a, b); |
| 2310 | | 2504 | |
| 2311 | testing.expect((try q.to(u128)) == 0x1); | 2505 | testing.expect((try q.to(u128)) == 0x1); |
| 2312 | | 2506 | |
| 2313 | const rs = try r.toString(al, 16); | 2507 | const rs = try r.toString(testing.allocator, 16); |
| | 2508 | defer testing.allocator.free(rs); |
| 2314 | testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000")); | 2509 | testing.expect(std.mem.eql(u8, rs, "444444434444444311111111111111110000000000000000")); |
| 2315 | } | 2510 | } |
| 2316 | | 2511 | |
| 2317 | test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" { | 2512 | test "big.int div multi-multi zero-limb trailing (with rem) and dividend zero-limb count < divisor zero-limb count" { |
| 2318 | var a = try Int.initSet(al, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); | 2513 | var a = try Int.initSet(testing.allocator, 0x86666666555555558888888777777776111111111111111100000000000000000000000000000000); |
| 2319 | var b = try Int.initSet(al, 0x866666665555555544444444333333330000000000000000); | 2514 | defer a.deinit(); |
| 2320 | | 2515 | var b = try Int.initSet(testing.allocator, 0x866666665555555544444444333333330000000000000000); |
| 2321 | var q = try Int.init(al); | 2516 | defer b.deinit(); |
| 2322 | var r = try Int.init(al); | 2517 | |
| | 2518 | var q = try Int.init(testing.allocator); |
| | 2519 | defer q.deinit(); |
| | 2520 | var r = try Int.init(testing.allocator); |
| | 2521 | defer r.deinit(); |
| 2323 | try Int.divTrunc(&q, &r, a, b); | 2522 | try Int.divTrunc(&q, &r, a, b); |
| 2324 | | 2523 | |
| 2325 | const qs = try q.toString(al, 16); | 2524 | const qs = try q.toString(testing.allocator, 16); |
| | 2525 | defer testing.allocator.free(qs); |
| 2326 | testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f")); | 2526 | testing.expect(std.mem.eql(u8, qs, "10000000000000000820820803105186f")); |
| 2327 | | 2527 | |
| 2328 | const rs = try r.toString(al, 16); | 2528 | const rs = try r.toString(testing.allocator, 16); |
| | 2529 | defer testing.allocator.free(rs); |
| 2329 | testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000")); | 2530 | testing.expect(std.mem.eql(u8, rs, "4e11f2baa5896a321d463b543d0104e30000000000000000")); |
| 2330 | } | 2531 | } |
| 2331 | | 2532 | |
| 2332 | test "big.int div multi-multi fuzz case #1" { | 2533 | test "big.int div multi-multi fuzz case #1" { |
| 2333 | var a = try Int.init(al); | 2534 | var a = try Int.init(testing.allocator); |
| 2334 | var b = try Int.init(al); | 2535 | defer a.deinit(); |
| | 2536 | var b = try Int.init(testing.allocator); |
| | 2537 | defer b.deinit(); |
| 2335 | | 2538 | |
| 2336 | try a.setString(16, "ffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"); | 2539 | try a.setString(16, "ffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"); |
| 2337 | try b.setString(16, "3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000000000000000000000000000001ffffffffffffffffffffffffffffffffffffffffffffffffffc000000000000000000000000000000007fffffffffff"); | 2540 | try b.setString(16, "3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000000000000000000000000000001ffffffffffffffffffffffffffffffffffffffffffffffffffc000000000000000000000000000000007fffffffffff"); |
| 2338 | | 2541 | |
| 2339 | var q = try Int.init(al); | 2542 | var q = try Int.init(testing.allocator); |
| 2340 | var r = try Int.init(al); | 2543 | defer q.deinit(); |
| | 2544 | var r = try Int.init(testing.allocator); |
| | 2545 | defer r.deinit(); |
| 2341 | try Int.divTrunc(&q, &r, a, b); | 2546 | try Int.divTrunc(&q, &r, a, b); |
| 2342 | | 2547 | |
| 2343 | const qs = try q.toString(al, 16); | 2548 | const qs = try q.toString(testing.allocator, 16); |
| | 2549 | defer testing.allocator.free(qs); |
| 2344 | testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1")); | 2550 | testing.expect(std.mem.eql(u8, qs, "3ffffffffffffffffffffffffffff0000000000000000000000000000000000001ffffffffffffffffffffffffffff7fffffffe000000000000000000000000000180000000000000000000003fffffbfffffffdfffffffffffffeffff800000100101000000100000000020003fffffdfbfffffe3ffffffffffffeffff7fffc00800a100000017ffe000002000400007efbfff7fe9f00000037ffff3fff7fffa004006100000009ffe00000190038200bf7d2ff7fefe80400060000f7d7f8fbf9401fe38e0403ffc0bdffffa51102c300d7be5ef9df4e5060007b0127ad3fa69f97d0f820b6605ff617ddf7f32ad7a05c0d03f2e7bc78a6000e087a8bbcdc59e07a5a079128a7861f553ddebed7e8e56701756f9ead39b48cd1b0831889ea6ec1fddf643d0565b075ff07e6caea4e2854ec9227fd635ed60a2f5eef2893052ffd54718fa08604acbf6a15e78a467c4a3c53c0278af06c4416573f925491b195e8fd79302cb1aaf7caf4ecfc9aec1254cc969786363ac729f914c6ddcc26738d6b0facd54eba026580aba2eb6482a088b0d224a8852420b91ec1")); |
| 2345 | | 2551 | |
| 2346 | const rs = try r.toString(al, 16); | 2552 | const rs = try r.toString(testing.allocator, 16); |
| | 2553 | defer testing.allocator.free(rs); |
| 2347 | testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1")); | 2554 | testing.expect(std.mem.eql(u8, rs, "310d1d4c414426b4836c2635bad1df3a424e50cbdd167ffccb4dfff57d36b4aae0d6ca0910698220171a0f3373c1060a046c2812f0027e321f72979daa5e7973214170d49e885de0c0ecc167837d44502430674a82522e5df6a0759548052420b91ec1")); |
| 2348 | } | 2555 | } |
| 2349 | | 2556 | |
| 2350 | test "big.int div multi-multi fuzz case #2" { | 2557 | test "big.int div multi-multi fuzz case #2" { |
| 2351 | var a = try Int.init(al); | 2558 | var a = try Int.init(testing.allocator); |
| 2352 | var b = try Int.init(al); | 2559 | defer a.deinit(); |
| | 2560 | var b = try Int.init(testing.allocator); |
| | 2561 | defer b.deinit(); |
| 2353 | | 2562 | |
| 2354 | try a.setString(16, "3ffffffffe00000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000001fffffffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffc000000000000000000000000000000000000000000000000000000000000000"); | 2563 | try a.setString(16, "3ffffffffe00000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000000000000000001fffffffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffc000000000000000000000000000000000000000000000000000000000000000"); |
| 2355 | try b.setString(16, "ffc0000000000000000000000000000000000000000000000000"); | 2564 | try b.setString(16, "ffc0000000000000000000000000000000000000000000000000"); |
| 2356 | | 2565 | |
| 2357 | var q = try Int.init(al); | 2566 | var q = try Int.init(testing.allocator); |
| 2358 | var r = try Int.init(al); | 2567 | defer q.deinit(); |
| | 2568 | var r = try Int.init(testing.allocator); |
| | 2569 | defer r.deinit(); |
| 2359 | try Int.divTrunc(&q, &r, a, b); | 2570 | try Int.divTrunc(&q, &r, a, b); |
| 2360 | | 2571 | |
| 2361 | const qs = try q.toString(al, 16); | 2572 | const qs = try q.toString(testing.allocator, 16); |
| | 2573 | defer testing.allocator.free(qs); |
| 2362 | testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4")); | 2574 | testing.expect(std.mem.eql(u8, qs, "40100400fe3f8fe3f8fe3f8fe3f8fe3f8fe4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f93e4f91e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4992649926499264991e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4791e4792e4b92e4b92e4b92e4b92a4a92a4a92a4")); |
| 2363 | | 2575 | |
| 2364 | const rs = try r.toString(al, 16); | 2576 | const rs = try r.toString(testing.allocator, 16); |
| | 2577 | defer testing.allocator.free(rs); |
| 2365 | testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000")); | 2578 | testing.expect(std.mem.eql(u8, rs, "a900000000000000000000000000000000000000000000000000")); |
| 2366 | } | 2579 | } |
| 2367 | | 2580 | |
| 2368 | test "big.int shift-right single" { | 2581 | test "big.int shift-right single" { |
| 2369 | var a = try Int.initSet(al, 0xffff0000); | 2582 | var a = try Int.initSet(testing.allocator, 0xffff0000); |
| | 2583 | defer a.deinit(); |
| 2370 | try a.shiftRight(a, 16); | 2584 | try a.shiftRight(a, 16); |
| 2371 | | 2585 | |
| 2372 | testing.expect((try a.to(u32)) == 0xffff); | 2586 | testing.expect((try a.to(u32)) == 0xffff); |
| 2373 | } | 2587 | } |
| 2374 | | 2588 | |
| 2375 | test "big.int shift-right multi" { | 2589 | test "big.int shift-right multi" { |
| 2376 | var a = try Int.initSet(al, 0xffff0000eeee1111dddd2222cccc3333); | 2590 | var a = try Int.initSet(testing.allocator, 0xffff0000eeee1111dddd2222cccc3333); |
| | 2591 | defer a.deinit(); |
| 2377 | try a.shiftRight(a, 67); | 2592 | try a.shiftRight(a, 67); |
| 2378 | | 2593 | |
| 2379 | testing.expect((try a.to(u64)) == 0x1fffe0001dddc222); | 2594 | testing.expect((try a.to(u64)) == 0x1fffe0001dddc222); |
| 2380 | } | 2595 | } |
| 2381 | | 2596 | |
| 2382 | test "big.int shift-left single" { | 2597 | test "big.int shift-left single" { |
| 2383 | var a = try Int.initSet(al, 0xffff); | 2598 | var a = try Int.initSet(testing.allocator, 0xffff); |
| | 2599 | defer a.deinit(); |
| 2384 | try a.shiftLeft(a, 16); | 2600 | try a.shiftLeft(a, 16); |
| 2385 | | 2601 | |
| 2386 | testing.expect((try a.to(u64)) == 0xffff0000); | 2602 | testing.expect((try a.to(u64)) == 0xffff0000); |
| 2387 | } | 2603 | } |
| 2388 | | 2604 | |
| 2389 | test "big.int shift-left multi" { | 2605 | test "big.int shift-left multi" { |
| 2390 | var a = try Int.initSet(al, 0x1fffe0001dddc222); | 2606 | var a = try Int.initSet(testing.allocator, 0x1fffe0001dddc222); |
| | 2607 | defer a.deinit(); |
| 2391 | try a.shiftLeft(a, 67); | 2608 | try a.shiftLeft(a, 67); |
| 2392 | | 2609 | |
| 2393 | testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000); | 2610 | testing.expect((try a.to(u128)) == 0xffff0000eeee11100000000000000000); |
| 2394 | } | 2611 | } |
| 2395 | | 2612 | |
| 2396 | test "big.int shift-right negative" { | 2613 | test "big.int shift-right negative" { |
| 2397 | var a = try Int.init(al); | 2614 | var a = try Int.init(testing.allocator); |
| | 2615 | defer a.deinit(); |
| 2398 | | 2616 | |
| 2399 | try a.shiftRight(try Int.initSet(al, -20), 2); | 2617 | try a.shiftRight(try Int.initSet(testing.allocator, -20), 2); |
| | 2618 | defer a.deinit(); |
| 2400 | testing.expect((try a.to(i32)) == -20 >> 2); | 2619 | testing.expect((try a.to(i32)) == -20 >> 2); |
| 2401 | | 2620 | |
| 2402 | try a.shiftRight(try Int.initSet(al, -5), 10); | 2621 | try a.shiftRight(try Int.initSet(testing.allocator, -5), 10); |
| | 2622 | defer a.deinit(); |
| 2403 | testing.expect((try a.to(i32)) == -5 >> 10); | 2623 | testing.expect((try a.to(i32)) == -5 >> 10); |
| 2404 | } | 2624 | } |
| 2405 | | 2625 | |
| 2406 | test "big.int shift-left negative" { | 2626 | test "big.int shift-left negative" { |
| 2407 | var a = try Int.init(al); | 2627 | var a = try Int.init(testing.allocator); |
| | 2628 | defer a.deinit(); |
| 2408 | | 2629 | |
| 2409 | try a.shiftRight(try Int.initSet(al, -10), 1232); | 2630 | try a.shiftRight(try Int.initSet(testing.allocator, -10), 1232); |
| | 2631 | defer a.deinit(); |
| 2410 | testing.expect((try a.to(i32)) == -10 >> 1232); | 2632 | testing.expect((try a.to(i32)) == -10 >> 1232); |
| 2411 | } | 2633 | } |
| 2412 | | 2634 | |
| 2413 | test "big.int bitwise and simple" { | 2635 | test "big.int bitwise and simple" { |
| 2414 | var a = try Int.initSet(al, 0xffffffff11111111); | 2636 | var a = try Int.initSet(testing.allocator, 0xffffffff11111111); |
| 2415 | var b = try Int.initSet(al, 0xeeeeeeee22222222); | 2637 | defer a.deinit(); |
| | 2638 | var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222); |
| | 2639 | defer b.deinit(); |
| 2416 | | 2640 | |
| 2417 | try a.bitAnd(a, b); | 2641 | try a.bitAnd(a, b); |
| 2418 | | 2642 | |
| ... | @@ -2420,8 +2644,10 @@ test "big.int bitwise and simple" { | ... | @@ -2420,8 +2644,10 @@ test "big.int bitwise and simple" { |
| 2420 | } | 2644 | } |
| 2421 | | 2645 | |
| 2422 | test "big.int bitwise and multi-limb" { | 2646 | test "big.int bitwise and multi-limb" { |
| 2423 | var a = try Int.initSet(al, maxInt(Limb) + 1); | 2647 | var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); |
| 2424 | var b = try Int.initSet(al, maxInt(Limb)); | 2648 | defer a.deinit(); |
| | 2649 | var b = try Int.initSet(testing.allocator, maxInt(Limb)); |
| | 2650 | defer b.deinit(); |
| 2425 | | 2651 | |
| 2426 | try a.bitAnd(a, b); | 2652 | try a.bitAnd(a, b); |
| 2427 | | 2653 | |
| ... | @@ -2429,8 +2655,10 @@ test "big.int bitwise and multi-limb" { | ... | @@ -2429,8 +2655,10 @@ test "big.int bitwise and multi-limb" { |
| 2429 | } | 2655 | } |
| 2430 | | 2656 | |
| 2431 | test "big.int bitwise xor simple" { | 2657 | test "big.int bitwise xor simple" { |
| 2432 | var a = try Int.initSet(al, 0xffffffff11111111); | 2658 | var a = try Int.initSet(testing.allocator, 0xffffffff11111111); |
| 2433 | var b = try Int.initSet(al, 0xeeeeeeee22222222); | 2659 | defer a.deinit(); |
| | 2660 | var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222); |
| | 2661 | defer b.deinit(); |
| 2434 | | 2662 | |
| 2435 | try a.bitXor(a, b); | 2663 | try a.bitXor(a, b); |
| 2436 | | 2664 | |
| ... | @@ -2438,8 +2666,10 @@ test "big.int bitwise xor simple" { | ... | @@ -2438,8 +2666,10 @@ test "big.int bitwise xor simple" { |
| 2438 | } | 2666 | } |
| 2439 | | 2667 | |
| 2440 | test "big.int bitwise xor multi-limb" { | 2668 | test "big.int bitwise xor multi-limb" { |
| 2441 | var a = try Int.initSet(al, maxInt(Limb) + 1); | 2669 | var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); |
| 2442 | var b = try Int.initSet(al, maxInt(Limb)); | 2670 | defer a.deinit(); |
| | 2671 | var b = try Int.initSet(testing.allocator, maxInt(Limb)); |
| | 2672 | defer b.deinit(); |
| 2443 | | 2673 | |
| 2444 | try a.bitXor(a, b); | 2674 | try a.bitXor(a, b); |
| 2445 | | 2675 | |
| ... | @@ -2447,8 +2677,10 @@ test "big.int bitwise xor multi-limb" { | ... | @@ -2447,8 +2677,10 @@ test "big.int bitwise xor multi-limb" { |
| 2447 | } | 2677 | } |
| 2448 | | 2678 | |
| 2449 | test "big.int bitwise or simple" { | 2679 | test "big.int bitwise or simple" { |
| 2450 | var a = try Int.initSet(al, 0xffffffff11111111); | 2680 | var a = try Int.initSet(testing.allocator, 0xffffffff11111111); |
| 2451 | var b = try Int.initSet(al, 0xeeeeeeee22222222); | 2681 | defer a.deinit(); |
| | 2682 | var b = try Int.initSet(testing.allocator, 0xeeeeeeee22222222); |
| | 2683 | defer b.deinit(); |
| 2452 | | 2684 | |
| 2453 | try a.bitOr(a, b); | 2685 | try a.bitOr(a, b); |
| 2454 | | 2686 | |
| ... | @@ -2456,8 +2688,10 @@ test "big.int bitwise or simple" { | ... | @@ -2456,8 +2688,10 @@ test "big.int bitwise or simple" { |
| 2456 | } | 2688 | } |
| 2457 | | 2689 | |
| 2458 | test "big.int bitwise or multi-limb" { | 2690 | test "big.int bitwise or multi-limb" { |
| 2459 | var a = try Int.initSet(al, maxInt(Limb) + 1); | 2691 | var a = try Int.initSet(testing.allocator, maxInt(Limb) + 1); |
| 2460 | var b = try Int.initSet(al, maxInt(Limb)); | 2692 | defer a.deinit(); |
| | 2693 | var b = try Int.initSet(testing.allocator, maxInt(Limb)); |
| | 2694 | defer b.deinit(); |
| 2461 | | 2695 | |
| 2462 | try a.bitOr(a, b); | 2696 | try a.bitOr(a, b); |
| 2463 | | 2697 | |
| ... | @@ -2466,11 +2700,19 @@ test "big.int bitwise or multi-limb" { | ... | @@ -2466,11 +2700,19 @@ test "big.int bitwise or multi-limb" { |
| 2466 | } | 2700 | } |
| 2467 | | 2701 | |
| 2468 | test "big.int var args" { | 2702 | test "big.int var args" { |
| 2469 | var a = try Int.initSet(al, 5); | 2703 | var a = try Int.initSet(testing.allocator, 5); |
| | 2704 | defer a.deinit(); |
| 2470 | | 2705 | |
| 2471 | try a.add(a, try Int.initSet(al, 6)); | 2706 | const b = try Int.initSet(testing.allocator, 6); |
| | 2707 | defer b.deinit(); |
| | 2708 | try a.add(a, b); |
| 2472 | testing.expect((try a.to(u64)) == 11); | 2709 | testing.expect((try a.to(u64)) == 11); |
| 2473 | | 2710 | |
| 2474 | testing.expect(a.cmp(try Int.initSet(al, 11)) == 0); | 2711 | const c = try Int.initSet(testing.allocator, 11); |
| 2475 | testing.expect(a.cmp(try Int.initSet(al, 14)) <= 0); | 2712 | defer c.deinit(); |
| | 2713 | testing.expect(a.cmp(c) == 0); |
| | 2714 | |
| | 2715 | const d = try Int.initSet(testing.allocator, 14); |
| | 2716 | defer d.deinit(); |
| | 2717 | testing.expect(a.cmp(d) <= 0); |
| 2476 | } | 2718 | } |
daurnimator <quae@daurnimator.com> 2020-02-14 18:59:40+11:00
Commit is signed but in an unrecognized format.
lib