def test_multiterm_addition(self):
        term1 = Term("x")
        term2 = Term("y", 3)


        term3 = Term("x", 2)
        term4 = Term("y")
        
        multiTerm1 = MultiTerm([term1, term2], 6)
        multiTerm2 = MultiTerm([term1, term2], 75)

        with self.assertRaises(ValueError):
            multiTerm3 = MultiTerm([term3, term4], 2)
            multiTerm3 + multiTerm1

        multiSum = multiTerm1 + multiTerm2

        # make sure we don't mutate any exponents while creating or adding
        self.assertEqual(term1.exponent, 1)
        self.assertEqual(term2.exponent, 3)

        # make sure none of the contents change
        for multiTerm in [multiTerm1, multiTerm2, multiSum]:
            self.assertEqual(len(multiTerm.terms), 2)
            self.assertEqual(term1 in multiTerm.terms, True)
            self.assertEqual(term2 in multiTerm.terms, True)

        self.assertEqual(multiTerm1.constant, 6)
        self.assertEqual(multiTerm2.constant, 75)
        self.assertEqual(multiSum.constant, multiTerm1.constant + multiTerm2.constant)
    def test_normal_multiterm(self):
        term1 = Term("bar")
        term2 = Term("foo", 3)

        multiTerm = MultiTerm([term1, term2], 2)

        self.assertEqual(len(multiTerm.terms), 2)
        self.assertEqual(term1 in multiTerm.terms, True)
        self.assertEqual(term2 in multiTerm.terms, True)
Пример #3
0
    def test_get_coefficient(self):

        expression1 = Expression([MultiTerm(Term("x")), Scalar()])
        expression2 = Expression([MultiTerm(Term("x")), Scalar(-1)])

        expressionProduct = expression1 * expression2

        self.assertEqual(len(expressionProduct.multiTerms), 2)

        self.assertEqual(
            expressionProduct.getCoefficient(MultiTerm(Term("x^2"))), 1)
        self.assertEqual(
            expressionProduct.getCoefficient(MultiTerm(Term("x"))), 0)
        self.assertEqual(expressionProduct.getCoefficient(Scalar()), -1)
Пример #4
0
    def test_multiply_by_two_expressions(self):

        expression1 = Expression([MultiTerm(Term("x")), Scalar()])
        expression2 = Expression([MultiTerm(Term("x")), Scalar(-1)])

        expressionProduct = expression1 * expression2

        self.assertEqual(len(expressionProduct.multiTerms), 2)

        xSquaredMultiTerm = expressionProduct.multiTerms[(MultiTerm(
            Term("x^2")))]
        scalarMultiTerm = expressionProduct.multiTerms[Scalar()]

        self.assertEqual(xSquaredMultiTerm.constant, 1)
        self.assertEqual(scalarMultiTerm.constant, -1)
    def test_multiterm_multiplication(self):
        term1 = Term("x")
        term2 = Term("y", 3)
        term3 = Term("z", 4)

        term4 = Term("w")
        term5 = Term("x", 2)
        term6 = Term("z", 3)
        
        multiTerm1 = MultiTerm([term1, term2, term3], 6)
        multiTerm2 = MultiTerm([term4, term5, term6], 75)
        multiProduct = multiTerm1 * multiTerm2

        # make sure we don't mutate any exponents while creating or adding
        self.assertEqual(term1.exponent, 1)
        self.assertEqual(term2.exponent, 3)
        self.assertEqual(term3.exponent, 4)
        self.assertEqual(term4.exponent, 1)
        self.assertEqual(term5.exponent, 2)
        self.assertEqual(term6.exponent, 3)

        for term in [term1, term2, term3]:
            self.assertEqual(term in multiTerm1.terms, True)
        self.assertEqual(len(multiTerm1.terms), 3)
        self.assertEqual(multiTerm1.constant, 6)

        for term in [term4, term5, term6]:
            self.assertEqual(term in multiTerm2.terms, True)

        self.assertEqual(len(multiTerm2.terms), 3)
        self.assertEqual(multiTerm2.constant, 75)

        self.assertEqual(multiProduct.constant, multiTerm1.constant * multiTerm2.constant)
        self.assertEqual(len(multiProduct.terms), 4)

        self.assertEqual((multiProduct.terms[Term("w")]).exponent, 1)
        self.assertEqual((multiProduct.terms[Term("x")]).exponent, 3)
        self.assertEqual((multiProduct.terms[Term("y")]).exponent, 3)
        self.assertEqual((multiProduct.terms[Term("z")]).exponent, 7)
    def test_multiterm_identity_multiplication(self):
        term1 = Term("x")
        term2 = Term("y", 3)
        term3 = Term("z", 4)

        i = MultiTerm([])
        multiTerm = MultiTerm([term1, term2, term3], 4)

        identityProduct = i * multiTerm

        self.assertEqual(term1.exponent, 1)
        self.assertEqual(term2.exponent, 3)
        self.assertEqual(term3.exponent, 4)

        for someMultiTerm in [multiTerm, identityProduct]:
            self.assertEqual(len(someMultiTerm.terms), 3)
            self.assertEqual(someMultiTerm.constant, 4)
            self.assertEqual((someMultiTerm.terms[Term("x")]).exponent, 1)
            self.assertEqual((someMultiTerm.terms[Term("y")]).exponent, 3)
            self.assertEqual((someMultiTerm.terms[Term("z")]).exponent, 4)
Пример #7
0
    def test_multiply_by_multiterm(self):
        singleMultiTerm = MultiTerm([Term("x")], 1)

        multiTerm1 = Scalar()
        multiTerm2 = MultiTerm(Term("x"), 3)
        multiTerm3 = MultiTerm(Term("x", 2))

        expression = Expression([multiTerm1, multiTerm2, multiTerm3])

        expressionProduct = expression * singleMultiTerm

        self.assertEqual(len(expressionProduct.multiTerms), 3)

        xMultiTerm = expressionProduct.multiTerms[(MultiTerm(Term("x")))]
        xSquaredMultiTerm = expressionProduct.multiTerms[(MultiTerm(
            Term("x", 2)))]
        xCubedMultiTerm = expressionProduct.multiTerms[(MultiTerm(Term("x",
                                                                       3)))]

        self.assertEqual(xMultiTerm.constant, 1)
        self.assertEqual(xSquaredMultiTerm.constant, 3)
        self.assertEqual(xCubedMultiTerm.constant, 1)
    def test_creation_failure_with_redundant_terms(self):
        term1 = Term("default")
        term2 = Term("default")

        with self.assertRaises(ValueError):
            MultiTerm([term1, term2])
 def test_default_constant(self):
     term1 = Term("default")
     multiTerm = MultiTerm(term1)
     self.assertEqual(multiTerm.constant, 1)
Пример #10
0
 def test_creation_with_default_exponent(self):
     term = Term("default")
     self.assertEqual(term.exponent, 1)
Пример #11
0
    def test_no_exponents_less_than_one(self):
        with self.assertRaises(ValueError):
            Term("abc", 0)

        with self.assertRaises(ValueError):
            Term("abc", -1)
Пример #12
0
    def test_hash(self):
        term1 = Term("abc")
        self.assertEqual(hash(term1), hash("abc"))

        term2 = Term("abc", 100)
        self.assertEqual(hash(term1), hash(term2))
Пример #13
0
 def test_creation_with_manual_exponent(self):
     term = Term("hello", 5)
     self.assertEqual(term.exponent, 5)