def test_subtract(self):
"h. subtract"
q1 = Polynomial([4, 1])
q2 = Polynomial([2, 4])
p1 = Polynomial([4, 0, 1])
p2 = Polynomial([2, 4])
self.assertEqual(q1 - q2, Polynomial([2, -3]))
def test_Get(self):
"m. get"
q1 = Polynomial([4, 1])
p1 = Polynomial([4, 0, 1])
self.assertEqual(p1[2], 4)
self.assertEqual(q1[1], 4)
self.assertEqual(q1[1], 4) # check it has not changed
def test_Mul(self):
"k. multiply"
q1 = Polynomial([4, 1])
q2 = Polynomial([2, 4])
w = q1 * q2
self.assertEqual(w, Polynomial([8, 18, 4]))
self.assertEqual(q1, Polynomial([4, 1]))
def test_uneven_sub(self):
"i. subtract different sizes"
q1 = Polynomial([4, 1])
q2 = Polynomial([2, 4])
p1 = Polynomial([4, 0, 1])
p2 = Polynomial([2, 4])
self.assertEqual(p1 - p2, Polynomial([4, -2, -3]))
def test_init(self):
"b. create polynomials from sequences"
list_p = Polynomial([5, 4, 3])
tuple_p = Polynomial((3, 4, 5))
range_p = Polynomial(range(5))
empty_q = Polynomial()
z = Polynomial([])
def test_derivative_neg(self):
"r. negative derivatives"
z = Polynomial()
z[-1] = 2
w = Polynomial()
w[-2] = -2
self.assertEqual(z.deriv(), w)
def test_add_consistent(self):
"f. add same two polynomials twice"
q1 = Polynomial([4, 1])
q2 = Polynomial([2, 4])
self.assertEqual(q1 + q2, Polynomial([6, 5]))
self.assertEqual(
q1 + q2,
Polynomial([6, 5]),
msg="it seems you are modifying one of the operators of +")
def test_nomods(self):
"w. input sequence independent of created polynomial"
L = [3,2,1]
p = Polynomial(L)
L.clear()
self.assertEqual(p,Polynomial([3,2,1]),msg="you must not link to the sequence")
L = [2,1]
p = Polynomial(L)
p[1]=3
self.assertEqual(L,[2,1],msg="you must not modify the passed sequence")
def test_add_long(self):
"v. long polynomials add efficiency"
g = list(range(2, 1000, 3))
h = list(range(3, 2000, 2))
tot = Polynomial(g) + Polynomial(h)
st = time.time()
self.assertEqual(tot, Polynomial(LongAdd))
add_time = time.time() - st
if add_time > 0.002:
self.fail("Your add is not efficient")
def test_Neg_sub(self):
"o. negative powers"
q = Polynomial([])
p = Polynomial([])
q[-4] = 2
p[-5] = 1
w = p + q
self.assertEqual(w.eval(2), 0.15625)
z1 = p * q
z2 = Polynomial([])
z2[-9] = 2
self.assertEqual(z1, z2)
def test_derivative_pos(self):
"q. derivatives"
p1 = Polynomial([4,0,1])
self.assertEqual(p1.deriv(),Polynomial([8,0]))
self.assertEqual(p1.deriv(),Polynomial([8,0]))
self.assertEqual(Polynomial([1,2,3,0,5]).deriv(),Polynomial([4,6,6,0]))
def test_eval(self):
"d. eval"
p = Polynomial([5, 4, 3])
self.assertAlmostEqual(31, p.eval(2))
self.assertAlmostEqual(12, p.eval(1))
self.assertAlmostEqual(6.25, p.eval(0.5))
q = Polynomial([3, 0, 0])
self.assertAlmostEqual(6.75, q.eval(1.5))
def test_speed(self):
"t. efficient multiply "
q = Polynomial()
p = Polynomial()
q[440] = 1
q[0] = 1
p[460] = 2
p[0] = 3
w = Polynomial()
w[900] = 2
w[440] = 3
w[460] = 2
w[0] = 3
st = time.time()
self.assertEqual(p * q, w)
multiply_time = time.time() - st
if multiply_time > 0.0001:
logging.info('inefficient multiply')
self.fail("Your multiply is not efficient")
def test_sparse(self):
"u. efficiency with lots of zeros."
q = Polynomial()
p = Polynomial()
w = Polynomial()
q[20000] = 5
q[10000] = 1
p[30000] = 4
p[1] = 3
w[50000] = 20
w[40000] = 4
w[10001] = 3
w[20001] = 15
st = time.time()
self.assertEqual(p * q, w)
multiply_time = time.time() - st
if multiply_time > 0.0001:
self.fail("Your multiply is not efficient")
def test_floating(self):
"j. floating point numbers"
p1 = Polynomial([1.2, 0, 9.5])
p2 = Polynomial([0.1, 5, 1.1])
self.assertEqual(p1 + p2, Polynomial([1.3, 5, 10.6]))
def test_Limits(self):
"s. polynomial unlimited in size"
longpoly = Polynomial([1] * 10000)
self.assertAlmostEqual(longpoly.eval(1), 10000)
from modeling import Polynomial list_p = Polynomial([3, 2, 1]) #list_p[-1]=2 print(list_p)
def test_complex(self):
"p. handle complex coefficients"
self.assertAlmostEqual(
Polynomial([1j, 5 + 2j, 6, -0.5j]).eval(0.2j), -0.192 + 0.62j)
def test_eq(self):
"c. equal and not equal"
self.assertEqual(Polynomial([1]), Polynomial([1]))
self.assertEqual(Polynomial([2, 1, 0]), Polynomial([2, 1, 0]))
self.assertNotEqual(Polynomial([1, 1, 0]), Polynomial([2, 1, 0]))
self.assertNotEqual(Polynomial(), Polynomial([2, 0, 0]))
def test_Get_missing_value(self):
"n. get with missing"
p1 = Polynomial([4, 0, 1])
self.assertEqual(p1[1], 0)
self.assertEqual(p1[10], 0)
self.assertEqual(p1[100000], 0)
def test_UnevenMul(self):
"l. multiply different lengths"
p1 = Polynomial([4, 0, 1])
p2 = Polynomial([2, 4])
z = p1 * p2
self.assertEqual(z, Polynomial([8, 16, 2, 4]))
def test_add(self):
"e. add"
q1 = Polynomial([4, 1])
q2 = Polynomial([2, 4])
self.assertEqual(q1 + q2, Polynomial([6, 5]))
self.assertNotEqual(q1 + q2, Polynomial([5, 6]))
def test_uneven_add(self):
"g. add different lengths"
p1 = Polynomial([4, 0, 1])
p2 = Polynomial([2, 4])
self.assertEqual(p1 + p2, Polynomial([4, 2, 5]))
