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]))