def test_setitem_is_ok(self):
"""Test that setitem is fine for valid inputs."""
x = Constant(5)
x.a = 1
self._assert_polynomials_are_the_same(Constant(1), x)
x[0] = 0
self._assert_polynomials_are_the_same(Constant(0), x)
def test_integral_constant(self):
"""Test that integrating against a constant is correct."""
c = Constant(2)
p = Polynomial(3)
m = Monomial(1.2, 0)
self.assertEqual(20, c.integral(-5, 5))
self.assertEqual(45, p.integral(-10, 5))
self.assertAlmostEqual(48, m.integral(-50.5, -10.5))
def test_mul_constant_returns_most_permissive(self):
"""Test that multiplication never reduces permissiveness."""
a = Polynomial(1, 2, 3) * Constant(3)
b = Monomial(1, 3) * Constant(1)
c = Constant(5) * Constant(4)
d = ZeroPolynomial() * Constant(2)
self.assertIsInstance(a, Polynomial)
self.assertIsInstance(b, Monomial)
self.assertIsInstance(c, Constant)
self.assertIsInstance(d, Constant)
def test_constant_equality(self):
"""Test that Constant(1) is equal to other instances of 1."""
to_test = [
Polynomial(1),
Monomial(1, 0),
Constant(1),
1
]
for val in to_test:
self.assertEqual(Constant(1), val)
def test_pow_monomial(self):
"""Test power against various Monomial subclasses."""
c = Constant(5)
ec = Constant(25)
m = Monomial(5, 10)
em = Monomial(25, 20)
z = ZeroPolynomial()
ez = ZeroPolynomial()
self._assert_polynomials_are_the_same(ec, c**2)
self._assert_polynomials_are_the_same(em, m**2)
self._assert_polynomials_are_the_same(ez, z**2)
def test_lshift_zero_monomial(self):
"""Test that lshift on a zero monomial behaves correctly."""
m = Monomial(0, 1) << 5
c = Constant(0) << 10
z = ZeroPolynomial() << 2
em = Monomial(0, 0)
ec = Constant(0)
ez = ZeroPolynomial()
self._assert_polynomials_are_the_same(em, m)
self._assert_polynomials_are_the_same(ec, c)
self._assert_polynomials_are_the_same(ez, z)
def test_zero_instance_mutable(self):
"""Test that zero instances are mutable."""
zp = Polynomial.zero_instance()
zm = Monomial.zero_instance()
zc = Constant.zero_instance()
zp.a = 1
zm.a = 1
zc.const = 1
self._assert_polynomials_are_the_same(Polynomial(1), zp)
self._assert_polynomials_are_the_same(Monomial(1, 0), zm)
self._assert_polynomials_are_the_same(Constant(1), zc)
def test_permissive_zero_constant(self):
"""Test that permissiveness doesn't decrease with Constant zero."""
a = Polynomial(1, 2, 3)
b = Monomial(1, 2)
c = Constant(5)
d = ZeroPolynomial()
zc = Constant(0)
self.assertIsInstance(a * zc, Polynomial)
self.assertIsInstance(b * zc, Monomial)
self.assertIsInstance(c * zc, Constant)
self.assertIsInstance(d * zc, Constant)
def test_pow_zero_case(self):
"""Test pow ** 0 returns 1."""
one = Constant(1)
m_one = Monomial(1, 0)
c = Constant(5)
m = Monomial(5, 10)
mz = Monomial(0, 1)
z = ZeroPolynomial()
p = Polynomial(1, 2, 3)
self._assert_polynomials_are_the_same(one, c**0)
self._assert_polynomials_are_the_same(m_one, m**0)
self._assert_polynomials_are_the_same(m_one, mz**0)
self._assert_polynomials_are_the_same(one, z**0)
self._assert_polynomials_are_the_same(one, p**0)
def test_shifting_constant_not_inplace(self):
"""Test that constant objects are not modified in place."""
c = Constant(5)
c1 = c
c1 <<= 5
self.assertIsNot(c, c1)
def test_constant_repr(self):
"""Test that repr() output of a Constant is valid."""
expect = "Constant(5)"
r = repr(Constant(5))
self.assertEqual(expect, r)
def test_constant_can_be_cast_to_complex(self):
"""Test Constant(number) == number where type(number) is complex."""
number = 4.20 - 69j
c = Constant(number)
self.assertEqual(number, complex(c))
self.assertEqual(number, c)
self.assertEqual(number, c.const)
def test_constant_can_be_cast_to_float(self):
"""Test Constant(number) == number where type(number) is float."""
number = 4.20
c = Constant(number)
self.assertEqual(number, float(c))
self.assertEqual(number, c)
self.assertEqual(number, c.const)
def test_constant_can_be_cast_to_int(self):
"""Test Constant(number) == number where type(number) is int."""
number = 69
c = Constant(number)
self.assertEqual(number, int(c))
self.assertEqual(number, c)
self.assertEqual(number, c.const)
def test_derivative_of_constant_equals_zero(self):
"""Test that the derivative of a Constant is equal to the zero poly."""
c = Constant(1)
expect = ZeroPolynomial()
result = c.derivative
self.assertEqual(expect, result)
def test_zero_polynomial_equals_zero(self):
"""Test that ZeroPolynomial() == Polynomial() == Constant(0) == 0."""
z = ZeroPolynomial()
p = Polynomial()
c = Constant(0)
self.assertTrue(c == p == z == 0)
self.assertTrue(c == p == z == 0.0)
self.assertTrue(c == p == z == 0.0j)
def test_divmod_against_constant(self):
"""Test that Polynomial(*) divmod a Constant leaves no remainder."""
p1 = Polynomial(1, 2, 3)
p2 = Constant(5)
p3, remainder = divmod(p1, p2)
self.assertEqual(p3, Polynomial(1 / 5, 2 / 5, 3 / 5))
self.assertEqual(remainder, Polynomial())
def test_binomial_constant_addition(self):
"""Test that Constant behaves as expected."""
a = LinearBinomial(1, 2)
b = Constant(3)
e = LinearBinomial(1, 5)
ep = Polynomial(e)
# a + b is safe because a's degree does not change.
self._assert_polynomials_are_the_same(e, a + b)
# b + a requires a cast since b's degree does change.
self._assert_polynomials_are_the_same(ep, b + a)
def test_degree_of_zero_is_minus_infinity(self):
"""Test that the degree of the zero poly is minus infinity."""
z = ZeroPolynomial()
p = Polynomial()
c = Constant(0)
expect = -inf
self.assertEqual(expect, z.degree)
self.assertEqual(expect, p.degree)
self.assertEqual(expect, c.degree)
def test_mul_polymial_returns_most_permissive(self):
"""Test that multiplication never reduces permissiveness."""
a = Polynomial(1, 2, 3) * Polynomial(3, 4, 1)
b = Monomial(1, 3) * Polynomial(5, 1, 2)
c = Constant(5) * Polynomial(6, 8, 1)
d = ZeroPolynomial() * Polynomial(9, 2, 7)
self.assertIsInstance(a, Polynomial)
self.assertIsInstance(b, Polynomial)
self.assertIsInstance(c, Polynomial)
self.assertIsInstance(d, Polynomial)
def test_pow_two_case(self):
"""Test pow ** 2."""
c = Constant(5)
m = Monomial(5, 10)
z = ZeroPolynomial()
p = Polynomial(1, 2, 3)
self._assert_polynomials_are_the_same(c * c, c**2)
self._assert_polynomials_are_the_same(m * m, m**2)
self._assert_polynomials_are_the_same(z * z, z**2)
self._assert_polynomials_are_the_same(p * p, p**2)
def test_pow_one_case(self):
"""Tests pow ** 1 returns a copy of the polynomial."""
c = Constant(5)
m = Monomial(5, 10)
z = ZeroPolynomial()
p = Polynomial(1, 2, 3)
self._assert_polynomials_are_the_same(c, c**1)
self._assert_polynomials_are_the_same(m, m**1)
self._assert_polynomials_are_the_same(z, z**1)
self._assert_polynomials_are_the_same(p, p**1)
def test_permissive_zero_polynomial(self):
"""Test that permissiveness doesn't decrease with Polynomial zero."""
a = Polynomial(1, 2, 3)
b = Monomial(1, 2)
c = Constant(5)
d = ZeroPolynomial()
zp = Polynomial()
self.assertIsInstance(a * zp, Polynomial)
self.assertIsInstance(b * zp, Polynomial)
self.assertIsInstance(c * zp, Polynomial)
self.assertIsInstance(d * zp, Polynomial)
def test_lshift_monomial(self):
"""Test that lshift on a monomial behaves correctly."""
m1 = Monomial(1, 5) << 10
m2 = Monomial(1, 15) << -10
m3 = Constant(5) << 10
m4 = Monomial(1, 15)
m4 <<= -10
self._assert_polynomials_are_the_same(Monomial(1, 15), m1)
self._assert_polynomials_are_the_same(Monomial(1, 5), m2)
self._assert_polynomials_are_the_same(Monomial(5, 10), m3)
self._assert_polynomials_are_the_same(Monomial(1, 5), m4)
def test_ipow_matches_pow(self):
"""Test that x **= y behaves as expected."""
to_test = [
Polynomial(1, 2, 3),
Monomial(1, 2),
Constant(5),
ZeroPolynomial(),
]
for val in to_test:
copy_val = deepcopy(val)
copy_val **= 5
self._assert_polynomials_are_the_same(val**5, copy_val)
def test_pow_by_non_integer(self):
"""Test that pow by non-integer type is not possible."""
to_test = [
Polynomial(1, 2, 3),
Monomial(1, 2),
Constant(5),
ZeroPolynomial(),
QuadraticTrinomial(1, 3, 7),
LinearBinomial(9, 2),
]
for val in to_test:
self.assertRaises(ValueError, val.__pow__, 1.2)
self.assertRaises(ValueError, val.__ipow__, 1.5)
def test_pos(self):
"""Test that a Polynomial is equal to its positive version."""
a = Polynomial(1, 2, 3)
b = Monomial(1, 2)
c = Constant(5)
d = ZeroPolynomial()
e = QuadraticTrinomial(1, 3, 7)
f = LinearBinomial(9, 2)
self._assert_polynomials_are_the_same(a, +a)
self._assert_polynomials_are_the_same(b, +b)
self._assert_polynomials_are_the_same(c, +c)
self._assert_polynomials_are_the_same(d, +d)
self._assert_polynomials_are_the_same(e, +e)
self._assert_polynomials_are_the_same(f, +f)
def test_ipow_zero_gives_one(self):
"""Test that x **= 0 returns an appropriate 1 polynomial."""
to_test = [
Polynomial(1, 2, 3),
Monomial(1, 2),
Constant(5),
ZeroPolynomial(),
QuadraticTrinomial(1, 3, 7),
LinearBinomial(9, 2),
]
one_maps = {
Polynomial: Polynomial(1),
Monomial: Monomial(1, 0),
Constant: Constant(1),
ZeroPolynomial: Constant(1),
QuadraticTrinomial: Polynomial(1),
LinearBinomial: Polynomial(1),
}
for val in to_test:
expected = one_maps[type(val)]
val **= 0
self._assert_polynomials_are_the_same(expected, val)
def test_setting_empty_terms_immutable_degree(self):
"""Test setting empty terms."""
immutable = [
QuadraticTrinomial(1, 2, 3),
LinearBinomial(1, 2),
]
for val in immutable:
self.assertRaises(DegreeError, val.__setattr__, "terms", [])
try:
a = Constant(0)
a.terms = []
a = Constant(5)
a.terms = []
except DegreeError:
self.assertFalse(True,
"Should be able to set Constant(0).terms to []")
a = Constant(1)
a.terms = []
def test_div_by_zero(self):
"""Test that division by 0 is not possible."""
to_test = [
Polynomial(1, 2, 3),
Monomial(1, 2),
Constant(5),
ZeroPolynomial(),
QuadraticTrinomial(1, 3, 7),
LinearBinomial(9, 2),
]
for val in to_test:
self.assertRaises(ZeroDivisionError, val.__floordiv__, 0)
self.assertRaises(ZeroDivisionError, val.__ifloordiv__, 0)
self.assertRaises(ZeroDivisionError, val.__mod__, 0)
self.assertRaises(ZeroDivisionError, val.__imod__, 0)
self.assertRaises(ZeroDivisionError, val.__divmod__, 0)
