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)