def test_neg(self):
vi = VInteger(325)
assert (-vi).get_digits() == [-3, -2, -5]
vi = VInteger(0)
assert (-vi).get_digits() == [0]
vi = VInteger(-325)
assert (-vi).get_digits() == [3, 2, 5]
def test_from_vinculum(self):
for _ in range(100):
a = random.randint(-1000000000, 1000000000)
ads = VInteger(a).get_digits()
vads = VProp.to_vinculum(VInteger(a))
vads = VProp.from_vinculum(vads).get_digits()
assert ads == vads
def test_sub(self):
for _ in range(100):
i1 = random.randint(-1000000000, 1000000000)
i2 = random.randint(-1000000000, 1000000000)
v1 = VInteger(i1)
v2 = VInteger(i2)
assert (v1 - v2).get_digits() == VInteger(i1 - i2).get_digits()
def test_vert_cross(self):
for _ in range (100):
i1 = random.randint(-999999999, 999999999)
i2 = random.randint(-999999999, 999999999)
v1 = VInteger(i1)
v2 = VInteger(i2)
mv1v2 = VMul.vert_cross(v1, v2)
assert mv1v2.get_digits() == VInteger(i1 * i2).get_digits()
def test_vert_cross_product(self):
for _ in range(100):
i1 = random.randint(-999999999, 999999999)
i2 = random.randint(-999999999, 999999999)
v1 = VInteger(i1)
v2 = VInteger(i2)
mv1v2 = v1.vert_cross_product(v2)
assert mv1v2 == VInteger(i1 * i2)
def test_near_base(self):
for _ in range (10):
i1 = random.randint(81, 120)
i2 = random.randint(81, 120)
v1 = VInteger(i1)
v2 = VInteger(i2)
mv1v2 = VMul.near_base(v1, v2, base=VInteger(100))
assert mv1v2.get_digits() == VInteger(i1 * i2).get_digits()
for _ in range (10):
i1 = random.randint(801, 1200)
i2 = random.randint(801, 1200)
v1 = VInteger(i1)
v2 = VInteger(i2)
mv1v2 = VMul.near_base(v1, v2, base=VInteger(1000))
assert mv1v2.get_digits() == VInteger(i1 * i2).get_digits()
def test_under_base(self):
for _ in range (5):
i1 = random.randint(87, 99)
i2 = random.randint(87, 99)
v1 = VInteger(i1)
v2 = VInteger(i2)
mv1v2 = VMul.under_base(v1, v2)
assert mv1v2.get_digits() == VInteger(i1 * i2).get_digits()
for _ in range (5):
i1 = random.randint(870, 999)
i2 = random.randint(870, 999)
v1 = VInteger(i1)
v2 = VInteger(i2)
mv1v2 = VMul.under_base(v1, v2)
assert mv1v2.get_digits() == VInteger(i1 * i2).get_digits()
def test_over_base(self):
for _ in range (5):
i1 = random.randint(101, 120)
i2 = random.randint(101, 120)
v1 = VInteger(i1)
v2 = VInteger(i2)
mv1v2 = VMul.over_base(v1, v2)
assert mv1v2.get_digits() == VInteger(i1 * i2).get_digits()
for _ in range (5):
i1 = random.randint(1001, 1200)
i2 = random.randint(1001, 1200)
v1 = VInteger(i1)
v2 = VInteger(i2)
mv1v2 = VMul.over_base(v1, v2)
assert mv1v2.get_digits() == VInteger(i1 * i2).get_digits()
def test_comparisons(self):
c = (VInteger(123) == VInteger(123))
assert c == True
c = (VInteger(123) == VInteger(124))
assert c == False
c = (VInteger(123) != VInteger(124))
assert c == True
c = (VInteger(123) < VInteger(124))
assert c == True
c = (VInteger(123) <= VInteger(124))
assert c == True
c = (VInteger(123) > VInteger(124))
assert c == False
c = (VInteger(123) >= VInteger(124))
assert c == False
def test_int(self):
assert int(VInteger(665)) == 665
assert int(VInteger(-665)) == -665
assert int(VInteger.fromints([-6, 4, -5])) == -565
def test_deficit(self):
assert VProp.deficit(VInteger(825)).get_digits() == [-1, -7, -5]
assert VProp.deficit(VInteger(-825)).get_digits() == [1, 7, 5]
assert VProp.deficit(VInteger.fromints([3, 4, 5])).get_digits() == [-6, -5, -5]
assert VProp.deficit(VInteger.fromints([3, -4, 5])).get_digits() == [-7, -3, -5]
assert VProp.deficit(VInteger(100)).get_digits() == [0]
def test_surplus(self):
assert VProp.surplus(VInteger(113)).get_digits() == [1, 3]
assert VProp.surplus(VInteger(-113)).get_digits() == [-1, -3]
assert VProp.surplus(VInteger.fromints([1, 2, 3, 7])).get_digits() == [2, 3, 7]
assert VProp.surplus(VInteger.fromints([1, 2, -3, -7])).get_digits() == [1, 6, 3]
assert VProp.surplus(VInteger(100)).get_digits() == [0]
def test_padlr_zero(self):
vi = VInteger(325)
assert vi.padl_zero(3).get_digits() == [0, 0, 0, 3, 2, 5]
vi = VInteger(325)
assert vi.padr_zero(3).get_digits() == [3, 2, 5, 0, 0, 0]
vi = VInteger(325)
assert vi.padl_zero(3).unpadl_zero().get_digits() == [3, 2, 5]
vi = VInteger(0)
assert vi.padl_zero(3).unpadl_zero().get_digits() == [0]
def test_duplex_square(self):
m = VMonomial([VInteger(3)])
assert m.duplex() == VInteger(9)
m = VMonomial([VInteger(4), VInteger(3)])
assert m.duplex() == VInteger(24)
m = VMonomial([VInteger(5), VInteger(2), VInteger(3)])
assert m.duplex() == VInteger(34)
m = VMonomial([VInteger(3)])
assert m.square() == VMonomial([VInteger(9)])
m = VMonomial([VInteger(4), VInteger(3)])
assert m.square() == VMonomial(
[VInteger(16), VInteger(24),
VInteger(9)])
m = VMonomial([VInteger(5), VInteger(2), VInteger(3)])
assert m.square() == VMonomial([
VInteger(25),
VInteger(20),
VInteger(34),
VInteger(12),
VInteger(9)
])
def test_as_vinteger(self):
assert VDigit(3).as_vinteger().get_digits() == VInteger(3).get_digits()
assert VDigit(-3).as_vinteger().get_digits() == VInteger(
-3).get_digits()
def test_duplex_square(self):
assert VInteger(3).duplex() == VInteger(9)
assert VInteger(43).duplex() == VInteger(24)
assert VInteger(523).duplex() == VInteger(34)
assert VInteger(3).square() == VInteger(9)
assert VInteger(43).square() == VInteger(1849)
assert VInteger(523).square() == VInteger(273529)
def test_nikhilam_by_9_two_digit(self):
ans = VDiv.nikhilam_by_9_two_digit(VInteger(12))
assert ans == {'quotient': VInteger(1), 'remainder': VInteger(3)}
ans = VDiv.nikhilam_by_9_two_digit(VInteger(62))
assert ans == {'quotient': VInteger(6), 'remainder': VInteger(8)}
ans = VDiv.nikhilam_by_9_two_digit(VInteger(65))
assert ans == {'quotient': VInteger(7), 'remainder': VInteger(2)}
ans = VDiv.nikhilam_by_9_two_digit(VInteger(72))
assert ans == {'quotient': VInteger(8), 'remainder': VInteger(0)}
def test_nikhilam_by_9_three_digit(self):
ans = VDiv.nikhilam_by_9_three_digit(VInteger(103))
assert ans == {'quotient': VInteger(11), 'remainder': VInteger(4)}
ans = VDiv.nikhilam_by_9_three_digit(VInteger(211))
assert ans == {'quotient': VInteger(23), 'remainder': VInteger(4)}
ans = VDiv.nikhilam_by_9_three_digit(VInteger(871))
assert ans == {'quotient': VInteger(96), 'remainder': VInteger(7)}
ans = VDiv.nikhilam_by_9_three_digit(VInteger(877))
assert ans == {'quotient': VInteger(97), 'remainder': VInteger(4)}
for _ in range(20):
i = VInteger(random.randint(101, 999))
ans = VDiv.nikhilam_by_9_three_digit(i)
assert ans['quotient']*VInteger(9) + ans['remainder'] == i
def test_nikhilam_by_9_many_digit(self):
for _ in range(20):
i = VInteger(random.randint(101, 9999999))
ans = VDiv.nikhilam_by_9_many_digit(i)
assert ans['quotient']*VInteger(9) + ans['remainder'] == i
def test_to_vinculum(self):
assert VInteger(4).to_vinculum().get_digits() == [4]
assert VInteger(8).to_vinculum().get_digits() == [1, -2]
assert VInteger(35).to_vinculum().get_digits() == [3, 5]
assert VInteger(38).to_vinculum().get_digits() == [4, -2]
assert VInteger(62).to_vinculum().get_digits() == [1, -4, 2]
assert VInteger(67).to_vinculum().get_digits() == [1, -3, -3]
assert VInteger(243).to_vinculum().get_digits() == [2, 4, 3]
assert VInteger(207).to_vinculum().get_digits() == [2, 1, -3]
assert VInteger(267).to_vinculum().get_digits() == [3, -3, -3]
assert VInteger(627).to_vinculum().get_digits() == [1, -4, 3, -3]
assert VInteger(672).to_vinculum().get_digits() == [1, -3, -3, 2]
assert VInteger(19802476).to_vinculum().get_digits() == [
2, 0, -2, 0, 2, 5, -2, -4
]
assert VInteger(91287625).to_vinculum().get_digits() == [
1, -1, 1, 3, -1, -2, -4, 2, 5
]
def test_to_vinculum(self):
assert VProp.to_vinculum(VInteger(19802476)).get_digits() == [2, 0, -2, 0, 2, 5, -2, -4]
assert VProp.to_vinculum(VInteger(91287625)).get_digits() == [1, -1, 1, 3, -1, -2, -4, 2, 5]