def setUp(self):
"""
setUp is run before each test method run.
"""
self.f = multivar.BasicPolynomial({(1, 2, 3): 4})
self.g = multivar.BasicPolynomial({(1, 2, 3): 9})
self.h = multivar.BasicPolynomial({(1, 1, 1): 1})
def testAdd(self):
"""
addition
"""
sum1 = multivar.BasicPolynomial({(1, 2, 3): 13})
sum2 = multivar.BasicPolynomial({(1, 1, 1): 1, (1, 2, 3): 4})
self.assertEqual(sum1, self.f + self.g)
self.assertEqual(sum2, self.f + self.h)
def testMul(self):
"""
multiplication
"""
prod1 = multivar.BasicPolynomial({(2, 4, 6): 36})
self.assertEqual(prod1, self.f * self.g)
sprod = multivar.BasicPolynomial({(1, 2, 3): 28})
self.assertEqual(sprod, self.f * 7)
self.assertEqual(sprod, 7 * self.f)
def testCall(self):
"""
substitution
"""
zero = multivar.BasicPolynomial({}, number_of_variables=3)
self.assertEqual(zero, self.f(0, 0))
self.assertEqual(zero, self.f(1, 0))
self.assertEqual(zero, self.f(2, 0))
self.assertRaises(IndexError, self.f.__call__, 3, 0)
subst1 = multivar.BasicPolynomial({(0, 2, 3): 4})
self.assertEqual(subst1, self.f(0, 1))
def testCombineSimilarTerm(self):
p = multivar.BasicPolynomial({(1, 0): 1, (2, 0): 2, (1, 1): -2})
p0 = [(1, multivar.BasicPolynomial({
(0, ): 1,
(1, ): -2
})), (2, multivar.BasicPolynomial({(0, ): 2}))]
p1 = [(0, multivar.BasicPolynomial({
(1, ): 1,
(2, ): 2
})), (1, multivar.BasicPolynomial({(1, ): -2}))]
self.assertEqual(p0, p.combine_similar_terms(0))
self.assertEqual(p1, p.combine_similar_terms(1))
def testTermMul(self):
"""
multiplication by a term.
"""
prod1 = multivar.BasicPolynomial({(2, 4, 6): 36})
self.assertEqual(prod1, self.f.term_mul(self.g))
self.assertEqual(prod1, self.f.term_mul(((1, 2, 3), 9)))
def testFormatMinusOne(self):
"""
format works for null terms polynomials.
"""
f = multivar.BasicPolynomial({(0, 2): -1, (1, 1): 0, (1, 0): 0})
flex = "- Y ** 2"
self.assertEqual(flex, self.lex.format(f, varnames=("X", "Y")))
def testMultCall(self):
"""
substitution simultaneous
"""
subst12 = multivar.BasicPolynomial({(
0,
0,
3,
): 16})
self.assertEqual(subst12, self.f((0, 1), (1, 2)))
def testFormatConst(self):
"""
format works for constant.
"""
f = multivar.BasicPolynomial({(0, 0): 4})
self.assertRaises(TypeError, self.lex.format, f)
const4 = "4"
self.assertEqual(const4, self.lex.format(f, varnames=("X", "Y")))
self.assertEqual(const4, self.deglex.format(f, varnames=("X", "Y")))
self.assertEqual(const4, self.degrevlex.format(f, varnames=("X", "Y")))
def testFormatHomogeneousTwoVars(self):
"""
format works for homogeneous polynomials.
"""
f = multivar.BasicPolynomial({(0, 2): 4, (1, 1): 1, (2, 0): 3})
qf = "4 * Y ** 2 + X * Y + 3 * X ** 2"
self.assertEqual(qf, self.lex.format(f, varnames=("X", "Y")))
self.assertEqual(qf, self.deglex.format(f, varnames=("X", "Y")))
self.assertEqual(qf, self.degrevlex.format(f, varnames=("X", "Y")))
qfr = "3 * X ** 2 + X * Y + 4 * Y ** 2"
self.assertEqual(qfr,
self.lex.format(f, varnames=("X", "Y"), reverse=True))
def testSquare(self):
"""
squaring
"""
hsquare = multivar.BasicPolynomial({(2, 2, 2): 1})
self.assertEqual(hsquare, self.h**2)
self.assertEqual(hsquare, self.h.square())
ssquare = multivar.BasicPolynomial({
(2, 2, 2): 1,
(2, 3, 4): 8,
(2, 4, 6): 16
})
self.assertEqual(ssquare, (self.f + self.h)**2)
self.assertEqual(ssquare, (self.f + self.h).square())
qsquare = multivar.BasicPolynomial({
(4, 4, 4): 1,
(4, 5, 6): 16,
(4, 6, 8): 96,
(4, 7, 10): 256,
(4, 8, 12): 256
})
self.assertEqual(qsquare, (self.f + self.h)**4)
self.assertEqual(qsquare, ssquare**2)
self.assertEqual(qsquare, ssquare.square())
def testFormatInhomogeneous(self):
"""
format works for inhomogeneous polynomials.
"""
f = multivar.BasicPolynomial({
(1, 1, 2): 2,
(1, 2, 0): 1,
(2, 0, 1): 3
})
fl = "2 * X * Y * Z ** 2 + X * Y ** 2 + 3 * X ** 2 * Z"
self.assertEqual(fl, self.lex.format(f, varnames=("X", "Y", "Z")))
fdl = "X * Y ** 2 + 3 * X ** 2 * Z + 2 * X * Y * Z ** 2"
self.assertEqual(fdl, self.deglex.format(f, varnames=("X", "Y", "Z")))
flr = "3 * X ** 2 * Z + X * Y ** 2 + 2 * X * Y * Z ** 2"
self.assertEqual(
flr, self.lex.format(f, varnames=("X", "Y", "Z"), reverse=True))
self.assertEqual(flr, self.degrevlex.format(f,
varnames=("X", "Y", "Z")))
def testFormatHomogeneous(self):
"""
format works for homogeneous polynomials.
"""
f = multivar.BasicPolynomial({
(1, 0, 2): 4,
(0, 2, 1): 1,
(2, 1, 0): 3
})
fl = "Y ** 2 * Z + 4 * X * Z ** 2 + 3 * X ** 2 * Y"
self.assertEqual(fl, self.lex.format(f, varnames=("X", "Y", "Z")))
self.assertEqual(fl, self.deglex.format(f, varnames=("X", "Y", "Z")))
flr = "3 * X ** 2 * Y + 4 * X * Z ** 2 + Y ** 2 * Z"
self.assertEqual(
flr, self.lex.format(f, varnames=("X", "Y", "Z"), reverse=True))
frl = "4 * X * Z ** 2 + Y ** 2 * Z + 3 * X ** 2 * Y"
self.assertEqual(frl, self.degrevlex.format(f,
varnames=("X", "Y", "Z")))
def testEraseVariable(self):
fxy = multivar.BasicPolynomial({(1, 2): 4})
fxz = multivar.BasicPolynomial({(1, 3): 4})
fyz = multivar.BasicPolynomial({(2, 3): 4})
self.assertEqual(fxy, self.f.erase_variable(2))
self.assertEqual(fxz, self.f.erase_variable(1))
self.assertEqual(fyz, self.f.erase_variable(0))
self.assertEqual(fyz, self.f.erase_variable()) # default
p = multivar.BasicPolynomial({(1, 0): 1, (2, 0): 2, (1, 1): -2})
q = multivar.BasicPolynomial({(0, ): 3, (1, ): -2})
self.assertEqual(q, p.erase_variable())
r = multivar.BasicPolynomial({(): 1})
self.assertEqual(r, p.erase_variable().erase_variable())
def testNeg(self):
"""
unary -
"""
neg = multivar.BasicPolynomial({(1, 2, 3): -4})
self.assertEqual(neg, -self.f)
