def test_add_sub(self):
# M + (-M) = 0
self.assertEqual(self.m[5] + (-self.m[5]), M(0))
# M + 0 = M
self.assertEqual(self.m[3] + 0, self.m[3])
# The sum of two similar monomials is a monomial
self.assertEqual(self.m[0] + self.m[2], M(10, x=1, y=4))
# The sum of two NON similar monomials is a polynomial
self.assertEqual(self.m[1] + self.m[3], P(self.m[1], self.m[3]))
# The sum of a monomial and a number is a polynomial
self.assertEqual(self.m[4] + 6.28, P(self.m[4], M(6.28)))
# m[1] - m[2] = m[1] + (-m[2])
self.assertEqual(self.m[0] - self.m[3], self.m[0] + (-self.m[3]))
# only works with monomials and numbers
self.assertRaises(TypeError, lambda: self.m[1] + [])
self.assertRaises(TypeError, lambda: self.m[4] - "")
# works with polynomial
self.assertEqual(self.m[0] + P(self.m[3]), P(self.m[0], self.m[3]))
self.assertEqual(self.m[2] - P(self.m[4]), P(self.m[2], -self.m[4]))
def test_eval(self):
# test value
self.assertEqual(self.m[5].eval(y=2), -72)
# if a variable value isn't specified
# it will stay there
self.assertEqual(self.m[0].eval(x=5), M(10, y=4))
# if there are no variables left returns a fraction
self.assertIsInstance(self.m[5].eval(y=2), F)
# otherwise it return a monomial
self.assertIsInstance(self.m[2].eval(x=3), M)
# if a variable isn't in the monomial, nothing change
self.assertEqual(self.m[4].eval(b=7), self.m[4])
# works only with number and monomials
self.assertRaises(TypeError, self.m[0].eval, x="")
# it's not case sensitive
self.assertEqual(self.m[0].eval(x=2), self.m[0].eval(X=2))
# a variable's value can be a monomial
self.assertEqual(self.m[2].eval(y=M(2, x=3)), M(128, x=13))
def test_binomial_square(self):
# works only with polynomials
self.assertRaises(TypeError, binomial_square, 'a number')
# raise ValueError if polynomial's length isn't 3
self.assertRaises(ValueError, binomial_square, self.p[0])
# raise ValueError if there aren't two squares in polynomial
self.assertRaises(ValueError, binomial_square, P(*self.p[2], 5))
# raise ValueError if the third term isn't the product of the first two
self.assertRaises(ValueError, binomial_square, P(M(4, x=2), M(9, y=4), 3))
# test with a binomial square
polynomial = self.p[2]*self.p[2]
self.assertEqual(binomial_square(polynomial), (self.p[2], self.p[2]))
# test with a negative binomial square
polynomial -= M(24, x=2, y=1)
factorized = self.p[2][0] -self.p[2][1], self.p[2][0] -self.p[2][1]
self.assertEqual(binomial_square(polynomial), factorized)
# commutative property
polynomial = P(*polynomial[::-1])
factorized = self.p[2][1] -self.p[2][0], self.p[2][1] -self.p[2][0]
self.assertEqual(binomial_square(polynomial), factorized)
def test_gcd_lcm(self):
# only works with numbers and monomials
self.assertRaises(TypeError, self.m[0].gcd, "")
self.assertRaises(TypeError, self.m[0].lcm, [])
# can work with numbers
self.assertEqual(self.m[1].gcd(3), self.m[1].gcd(M(3)))
# only integer coefficient
self.assertRaises(ValueError, self.m[3].gcd, self.m[4])
self.assertRaises(ValueError, self.m[4].gcd, self.m[3])
# always positive result
self.assertGreater(self.m[0].gcd(self.m[5]).coefficient, 0)
self.assertGreater(self.m[2].lcm(self.m[3]).coefficient, 0)
# return 0 if one term is 0
self.assertRaises(ValueError, self.m[5].gcd, 0)
self.assertRaises(ValueError, M(0).gcd, self.m[3])
# values
self.assertEqual(self.m[1].gcd(self.m[2]), M(2, x=1, y=3))
self.assertEqual(self.m[0].lcm(self.m[5]), M(18, x=1, y=4))
# commutative property
self.assertEqual(self.m[0].gcd(self.m[2]), self.m[2].gcd(self.m[0]))
self.assertEqual(self.m[0].lcm(self.m[2]), self.m[2].lcm(self.m[0]))
# test shorthands
self.assertEqual(gcd(3, self.m[1], self.m[5]), 3)
self.assertEqual(lcm(6, self.m[2], self.m[3]), M(24, x=1, y=4))
def test_neg_abs(self):
# neg
self.assertEqual(-self.m[0],
M(-self.m[0].coefficient, self.m[0].variables))
# abs
self.assertEqual(abs(self.m[1]),
M(abs(self.m[1].coefficient), self.m[1].variables))
def test_reverses(self):
# reverse add
self.assertEqual(19 + P(M(3)), P(22))
self.assertRaises(TypeError, lambda: "" + self.p[0])
# reverse sub
self.assertEqual(8 - P(M(3)), P(5))
self.assertRaises(TypeError, lambda: "" - self.p[1])
# reverse mul
self.assertEqual(18 * P(M(3)), P(54))
self.assertRaises(TypeError, lambda: "" * self.p[1])
def setUp(self):
# Polynomials
self.p = [
P(M(2, x=1), 3), # 2x + 3
P(M(10, x=1), 15), # 10x + 15
P(M(2, x=2), M(3, y=1)) # 2x**2 + 3y
]
# FPolynomials
self.fp = [
FP(self.p[1], self.p[0]), # (10x + 15)(2x + 3)
FP(5, self.p[0]) # 5(2x + 3)
]
def test_eq_hash(self):
# two polynomials are not equal if
# they have not the same length
self.assertFalse(self.p[2] == P(self.m[5]))
# two polynomials can be equals but with
# the terms in a different order
self.assertEqual(self.p[2], P(self.m[1], self.m[3]))
# a polynomial with a single term can be
# compared to a monomial
self.assertEqual(P(M(3, a=2, b=2)), M(3, a=2, b=2))
self.assertEqual(P(M(6)), 6)
# otherwise the result is false
self.assertFalse(self.p[1] == {1, 7, 9})
def test_mul_div(self):
# only works with monomials and numbers
self.assertRaises(TypeError, lambda: self.m[2] * [])
self.assertRaises(TypeError, lambda: self.m[3] / {})
# works with monomials
self.assertEqual(self.m[5] * self.m[1], M(54, x=1, y=6))
self.assertEqual(self.m[1] / self.m[5], M(F(2, 3), x=1))
# works with numbers
self.assertEqual(self.m[0] * self.m[3], self.m[0] * 3)
self.assertEqual(self.m[0] / 2, M(x=1, y=4))
# multiplication works with polynomials
self.assertEqual(self.m[5] * P(self.m[1]), P(self.m[5] * self.m[1]))
# second operator's exponent must be lower than first's
self.assertRaises(ValueError, lambda: self.m[3] / self.m[4])
def test_zeros_eval(self):
# test eval
self.assertEqual(self.p[0].eval(a=1), 6 + M(7, y=1))
self.assertEqual(self.p[0].eval({'y': 3}), 21 + M(6, a=4))
# test zeros
self.assertEqual(
P(M(3, x=3), M(2, x=2), M(-3, x=1), -2).zeros, {F(-2, 3), 1, -1})
self.assertRaises(ValueError, lambda: self.p[0].zeros)
self.assertRaises(ValueError, lambda: P(M(3, x=3), M(2, x=2)).zeros)
def test_fpolynomial(self):
# FPolynomial is an instance of tuple
self.assertIsInstance(self.fp[1], tuple)
# factors that are equal to 1 aren't inserted
self.assertEqual(len(FP(self.p[1], 1)), 1)
# There must be at least a polynomial
self.assertRaises(TypeError, FP, M(17, z=1), 5)
# Factors must be polynomials, monomials or numbers
self.assertRaises(TypeError, FP, "", self.p[1])
# default string representation
self.assertEqual(str(self.fp[0]), '(2x + 3)(10x + 15)')
# repr is the same of str
self.assertEqual(str(self.fp[0]), repr(self.fp[0]))
# if the first factor is a monomial there are no brackets
self.assertEqual(str(self.fp[1]), '5(2x + 3)')
self.assertEqual(str(FP(M(2, x=1), self.p[0])), '2x(2x + 3)')
# with factors that appears two times
self.assertEqual(str(FP(self.p[1], self.p[1])), '(10x + 15)**2')
self.assertEqual(str(FP(self.p[0], M(2, x=1), M(2, x=1))), '(2x)**2(2x + 3)')
# with factors that appears more times and a monomial
self.assertEqual(str(FP(self.p[0], self.p[0], 5)), '5(2x + 3)**2')
# if there is only a factor with exponent 1, str() returns that factor
self.assertEqual(str(FP(self.p[0])), str(self.p[0]))
# eval
self.assertEqual(self.fp[1].eval(), P(M(10, x=1), 15))
# eq
self.assertEqual(FP(self.p[1], 5), FP(5, self.p[1]))
self.assertFalse(self.fp[0] == {'a', 'b', 'x'})
def test_mul(self):
# works only with monomials, polynomials and numbers
self.assertRaises(TypeError, lambda: self.p[0] * "something")
# works with monomial
self.assertEqual(self.p[0] * self.m[2], P(M(42, a=4, y=1), M(49, y=2)))
# works with number
self.assertEqual(self.p[0] * 3, P(M(18, a=4), M(21, y=1)))
# works with polynomial
self.assertEqual(self.p[0] * self.p[1],
P(M(-8, a=4, y=1), M(60, a=8), M(-91, y=2)))
def test_gcf(self):
# works only with polynomials
self.assertRaises(TypeError, gcf, 'a number')
# always return a tuple
self.assertIsInstance(gcf(self.p[1]), tuple)
# return the same polynomial if it's not factorizable with gcf
self.assertEqual(gcf(self.p[0]), (self.p[0], ))
# otherwise return the gcf and the polynomial reduced
self.assertEqual(gcf(self.p[1]), (5, M(2, x=1) + 3))
# commutative property
self.assertEqual(gcf(self.p[1]), gcf(P(*self.p[1][::-1])))
def setUp(self):
# Monomials
self.m = [
M(2, x=1, y=4),
M(-6, x=1, y=3),
M(8, x=1, y=4),
M(3),
M(1.16, a=4),
M(-9, y=3)
]
def test_new_init(self):
# terms must be monomials or number
self.assertRaises(TypeError, P, "lol")
# terms instance of int or float are
# converted to monomial
self.assertIsInstance(P(3)[0], M)
# if more terms have the same variables
# they are summed together
self.assertEqual(self.p[0].term_coefficient(a=4), 6)
self.assertEqual(self.p[0].term_coefficient({'a': 4}), 6)
# if term_coefficient find nothing, the result is 0
self.assertEqual(self.p[0].term_coefficient(k=2, b=1), 0)
# term_coefficient argument can be a monomial with coefficient 1
self.assertEqual(P(M(2, x=1), 3).term_coefficient(Variable('x')), 2)
def test_eq(self):
# same coefficient, same variables
self.assertTrue(self.m[4] == self.m[4])
# same variables, different coefficient
self.assertFalse(self.m[0] == self.m[2])
# same coefficient, different variables
self.assertFalse(self.m[1] == M(-6, a=2))
# different coefficient, different variables
self.assertFalse(self.m[4] == self.m[3])
# if there aren't variables, it can be compared
# to a number
self.assertTrue(self.m[3] == 3)
self.assertFalse(self.m[3] == 17)
# can compare only to monomials and numbers
self.assertEqual(self.m[4].__eq__({}), False)
def setUp(self):
# Monomials
self.m = [
M(10, a=4),
M(-4, a=4),
M(7, y=1),
M(9, x=1),
M(-13, y=1),
M(-1, x=1)
]
# Polynomials
self.p = [
P(self.m[0], self.m[1], self.m[2]), # 6a**4 + 7y
P(self.m[4], self.m[0]), # -13y +10a**4
P(self.m[3], self.m[1]), # 9x -4a**4
]
def test_init(self):
# can be initialized with a dict
self.assertEqual(M({'x': 2}), M(x=2))
# Coefficient must be int or float
self.assertRaises(TypeError, M, "3")
# default coefficient is 1
self.assertEqual(M().coefficient, 1)
# default variables is empty
self.assertTrue(M().variables.is_empty)
# check the degree
self.assertEqual(M(2, x=2, y=7).degree, 9)
# test variable()
self.assertEqual(Variable('x'), M(1, x=1))
def test_str_repr(self):
# normal monomial
self.assertEqual(str(M(5, x=1, y=4)), '5xy**4')
# coefficient == 1 w/ variables
self.assertEqual(str(M(a=2)), 'a**2')
# coefficient == -1 and w/ variables
self.assertEqual(str(M(-1, k=3)), '-k**3')
# coefficient == 0
self.assertEqual(str(M(0, s=5)), '0')
# w/o variables
self.assertEqual(str(M(7)), '7')
# coefficient == 1 w/o variables
self.assertEqual(str(M()), '1')
# coefficient == -1 w/o variables
self.assertEqual(str(M(-1)), '-1')
# repr is the same as str
self.assertEqual(str(self.m[2]), repr(self.m[2]))
def test_add_sub(self):
# works only with monomials, polynomials and numbers
self.assertRaises(TypeError, lambda: self.p[0] + "something")
self.assertRaises(TypeError, lambda: self.p[0] - [])
# works with monomial
self.assertEqual(self.p[0] + self.m[2], P(M(6, a=4), M(14, y=1)))
self.assertEqual(self.p[0] - self.m[4], P(M(6, a=4), M(20, y=1)))
# works with number
self.assertEqual(self.p[0] + 3, P(M(6, a=4), M(7, y=1), M(3)))
self.assertEqual(self.p[0] - 18, P(M(6, a=4), M(7, y=1), M(-18)))
# works with polynomial
self.assertEqual(self.p[0] + self.p[1], P(M(16, a=4), M(-6, y=1)))
self.assertEqual(self.p[0] - self.p[1], P(M(20, y=1), M(-4, a=4)))
def test_pow_root(self):
### has_root()
# check even roots' indexes
self.assertFalse(self.m[0].has_root(2))
self.assertTrue(M(4, a=2, b=4).has_root(2))
self.assertFalse(M(-4, a=2, b=4).has_root(2))
self.assertTrue(M(0).has_root(2))
# check odd roots' indexes
self.assertFalse(self.m[1].has_root(3))
self.assertTrue(M(27, a=3).has_root(3))
self.assertTrue(M(-27, a=3).has_root(3))
self.assertTrue(M(0).has_root(3))
### __pow__()
# works only with whole positive exponents
self.assertRaises(ValueError, lambda: M(5)**(-3))
self.assertRaises(TypeError, lambda: M(17)**2.14)
# if the exponentn is 0, the result is 1
self.assertEqual(self.m[5]**0, 1)
# test result
self.assertEqual(self.m[5]**3, M(-729, y=9))
### root()
self.assertEqual(M(4, x=2).root(2), M(2, x=1))
self.assertEqual(M(8, y=9).root(3), M(2, y=3))
# raises TypeError if index is not int
self.assertRaises(TypeError, self.m[2].root, 'blob')
# raises ValueError if that monomial hasn't that root
self.assertRaises(ValueError, self.m[3].root, 5)
# root of 0
self.assertEqual(M(0).root(7), 0)
# root of odd index
self.assertEqual(M(-27, x=3).root(3), M(-3, x=1))
def test_factorization(self):
# test shorthand
self.assertEqual(self.p[0].factorize(), factorize(self.p[0]))
# can factorize only polynomials
self.assertRaises(TypeError, factorize, 159)
# test gcf + binomial_square
polynomial = self.p[2] * self.p[2] * 5
factorization = FP(5, P(M(2, x=2), M(3, y=1)), P(M(2, x=2), M(3, y=1)))
self.assertEqual(polynomial.factorize(), factorization)
self.assertEqual(factorize(M(x=2) + 1 - M(2, x=1)), FP(M(x=1) - 1, M(x=1) - 1))
self.assertEqual(factorize(M(8, x=2) + M(2, x=1) - 3), FP(8, M(x=1) - 1/2, M(x=1) + 3/4))
self.assertEqual(factorize(M(10, x=1) + 5), FP(5, M(2, x=1) + 1))
self.assertEqual(factorize(M(3, x=3) + M(2, x=2) - M(3, x=1) -2), FP(M(x=1) - 1, M(x=1) + 1, M(3, x=1) + 2))
