예제 #1
0
 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)
예제 #2
0
 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)
예제 #3
0
    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)
예제 #4
0
    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