def testTruncation(self, divisor, dividend, base, precision):
"""
Test just truncating division result to some precision.
Integer parts of truncated and non-truncated are always the same.
The length of repeating and non-repeating is always less than the
precision.
If precision limit was reached before repeating portion was
calculated, then the non-repeating portion has ``precision`` digits
and is a prefix of non-repeating-part + repeating part when
precision is not bounded.
"""
(integer_part, non_repeating_part, repeating_part, rel) = \
NatDivision.division(divisor, dividend, base, precision=precision)
(integer_part_2, non_repeating_part_2, repeating_part_2, rel_2) = \
NatDivision.division(divisor, dividend, base, precision=None)
assert rel_2 == 0
assert integer_part == integer_part_2
assert len(repeating_part) + len(non_repeating_part) <= precision
assert repeating_part_2 == repeating_part or rel < 0
assert not(repeating_part_2 != [] and repeating_part == []) or \
(len(non_repeating_part) == precision and \
non_repeating_part == \
(non_repeating_part_2 + repeating_part_2)[:precision])
def test_truncation(self, strategy, precision):
"""
Test just truncating division result to some precision.
Integer parts of truncated and non-truncated are always the same.
The length of repeating and non-repeating is always less than the
precision.
If precision limit was reached before repeating portion was
calculated, then the non-repeating portion has ``precision`` digits
and is a prefix of non-repeating-part + repeating part when
precision is not bounded.
"""
(divisor, dividend, base) = strategy
(integer_part, non_repeating_part, repeating_part,
rel) = NatDivision.division(divisor, dividend, base, precision)
(
integer_part_2,
non_repeating_part_2,
repeating_part_2,
rel_2,
) = NatDivision.division(divisor, dividend, base, None)
self.assertEqual(rel_2, 0)
self.assertEqual(integer_part, integer_part_2)
self.assertLessEqual(
len(repeating_part) + len(non_repeating_part), precision)
self.assertTrue(repeating_part_2 == repeating_part or rel == -1)
self.assertTrue(
not (repeating_part_2 != [] and repeating_part == [])
or (len(non_repeating_part) == precision and non_repeating_part
== (non_repeating_part_2 + repeating_part_2)[:precision]))
def test_inverses(self, strategy):
"""
Test that division and undivision are inverses.
"""
(divisor, dividend, base) = strategy
(
integer_part,
non_repeating_part,
repeating_part,
relation,
) = NatDivision.division(divisor, dividend, base)
self.assertEqual(relation, 0)
(denominator,
numerator) = NatDivision.undivision(integer_part, non_repeating_part,
repeating_part, base)
self.assertTrue(
isinstance(numerator, list)
and (not numerator or numerator[0] != 0))
self.assertNotEqual(denominator, [])
self.assertNotEqual(denominator[0], 0)
original = fractions.Fraction(Nats.convert_to_int(dividend, base),
Nats.convert_to_int(divisor, base))
result = fractions.Fraction(Nats.convert_to_int(numerator, base),
Nats.convert_to_int(denominator, base))
self.assertEqual(original, result)
def testExceptionsUndivision(self):
"""
Test undivision exceptions.
"""
with self.assertRaises(BasesError):
NatDivision.undivision([1], [1], [1], -2)
with self.assertRaises(BasesError):
NatDivision.undivision([1], [1], [-1], 2)
with self.assertRaises(BasesError):
NatDivision.undivision([1], [-1], [1], 2)
with self.assertRaises(BasesError):
NatDivision.undivision([-1], [1], [1], 2)
with self.assertRaises(BasesError):
NatDivision.undivision([2], [1], [1], 2)
def testExceptionsDivision(self):
"""
Test division exceptions.
"""
with self.assertRaises(BasesError):
NatDivision.division(1, 1, -2)
with self.assertRaises(BasesError):
NatDivision.division(1, -1, 3)
with self.assertRaises(BasesError):
NatDivision.division(-1, 1, 3)
with self.assertRaises(BasesError):
NatDivision.division(0, 1, 3)
with self.assertRaises(BasesError):
NatDivision.division(2, 1, 3, -1)
def test_exceptions_undivision(self):
"""
Test undivision exceptions.
"""
with self.assertRaises(BasesError):
NatDivision.undivision([1], [1], [1], -2)
with self.assertRaises(BasesError):
NatDivision.undivision([1], [1], [-1], 2)
with self.assertRaises(BasesError):
NatDivision.undivision([1], [-1], [1], 2)
with self.assertRaises(BasesError):
NatDivision.undivision([-1], [1], [1], 2)
with self.assertRaises(BasesError):
NatDivision.undivision([2], [1], [1], 2)
def testInverses(self, divisor, dividend, base):
"""
Test that division and undivision are inverses.
"""
(integer_part, non_repeating_part, repeating_part, relation) = \
NatDivision.division(divisor, dividend, base)
assert relation == 0
(denominator, numerator) = NatDivision.undivision(
integer_part,
non_repeating_part,
repeating_part,
base
)
assert denominator != 0
original = fractions.Fraction(dividend, divisor)
result = fractions.Fraction(numerator, denominator)
assert original == result
def testUpDown(self, divisor, dividend, base, precision):
"""
Test that rounding up and rounding down have the right relationship.
"""
# pylint: disable=too-many-locals
(integer_part, non_repeating_part, repeating_part, rel) = \
NatDivision.division(
divisor,
dividend,
base,
precision=precision,
method=RoundingMethods.ROUND_UP
)
(integer_part_2, non_repeating_part_2, repeating_part_2, rel_2) = \
NatDivision.division(
divisor,
dividend,
base,
precision=precision,
method=RoundingMethods.ROUND_DOWN
)
(integer_part_3, non_repeating_part_3, repeating_part_3, rel_3) = \
NatDivision.division(
divisor,
dividend,
base,
precision=precision,
method=RoundingMethods.ROUND_TO_ZERO
)
assert integer_part_2 == integer_part_3 and \
non_repeating_part_2 == non_repeating_part_3 and \
repeating_part_2 == repeating_part_3
assert repeating_part != [] or repeating_part_2 == []
assert rel >= rel_2 and rel_2 == rel_3
round_up_int = \
Nats.convert_to_int(integer_part + non_repeating_part, base)
round_down_int = \
Nats.convert_to_int(integer_part_2 + non_repeating_part_2, base)
if repeating_part == []:
assert round_up_int - round_down_int in (0, 1)
if rel == 0:
assert round_up_int == round_down_int
assert rel_2 == 0
assert rel_3 == 0
for method in RoundingMethods.CONDITIONAL_METHODS():
(integer_part_c, non_repeating_part_c, _, rel) = \
NatDivision.division(
divisor,
dividend,
base,
precision=precision,
method=method
)
rounded_int = \
Nats.convert_to_int(integer_part_c + non_repeating_part_c, base)
if repeating_part == []:
assert rounded_int <= round_up_int and \
rounded_int >= round_down_int
if rel == 0:
assert round_up_int == round_down_int
elif rel < 0:
assert rounded_int == round_down_int
else:
assert rounded_int == round_up_int
def test_exceptions_division(self):
"""
Test division exceptions.
"""
with self.assertRaises(BasesError):
NatDivision.division([1], [1], -2)
with self.assertRaises(BasesError):
NatDivision.division([1], [-1], 3)
with self.assertRaises(BasesError):
NatDivision.division([-1], [1], 3)
with self.assertRaises(BasesError):
NatDivision.division([], [1], 3)
with self.assertRaises(BasesError):
NatDivision.division([0], [1], 3)
with self.assertRaises(BasesError):
NatDivision.division([2], [1], 3, -1)
with self.assertRaises(BasesError):
NatDivision.division([3], [1], 10, 0, None)
def test_up_down(self, divisor, dividend, base, precision):
"""
Test that rounding up and rounding down have the right relationship.
"""
# pylint: disable=too-many-locals
divisor = Nats.convert_from_int(divisor, base)
dividend = Nats.convert_from_int(dividend, base)
(integer_part, non_repeating_part, repeating_part,
rel) = NatDivision.division(divisor, dividend, base, precision,
RoundingMethods.ROUND_UP)
(
integer_part_2,
non_repeating_part_2,
repeating_part_2,
rel_2,
) = NatDivision.division(divisor, dividend, base, precision,
RoundingMethods.ROUND_DOWN)
(
integer_part_3,
non_repeating_part_3,
repeating_part_3,
rel_3,
) = NatDivision.division(divisor, dividend, base, precision,
RoundingMethods.ROUND_TO_ZERO)
self.assertEqual(integer_part_2, integer_part_3)
self.assertEqual(non_repeating_part_2, non_repeating_part_3)
self.assertEqual(repeating_part_2, repeating_part_3)
self.assertTrue(repeating_part != [] or repeating_part_2 == [])
self.assertGreaterEqual(rel, rel_2)
self.assertEqual(rel_2, rel_3)
round_up_int = Nats.convert_to_int(integer_part + non_repeating_part,
base)
round_down_int = Nats.convert_to_int(
integer_part_2 + non_repeating_part_2, base)
if repeating_part == []:
self.assertIn(round_up_int - round_down_int, (0, 1))
if rel == 0:
self.assertEqual(round_up_int, round_down_int)
self.assertEqual(rel_2, 0)
self.assertEqual(rel_3, 0)
for method in RoundingMethods.CONDITIONAL_METHODS():
(integer_part_c, non_repeating_part_c, _,
rel) = NatDivision.division(divisor, dividend, base, precision,
method)
rounded_int = Nats.convert_to_int(
integer_part_c + non_repeating_part_c, base)
if repeating_part == []:
self.assertLessEqual(round_down_int, rounded_int)
self.assertLessEqual(rounded_int, round_up_int)
if rel == 0:
self.assertEqual(round_up_int, round_down_int)
elif rel == -1:
self.assertEqual(rounded_int, round_down_int)
else:
self.assertEqual(rounded_int, round_up_int)
