def test_method__rmul__(self): self.tp_A = pm.Polynomial((-1, 0, 2, 3)) self.tp_B = pm.Polynomial((1, 0, -1)) self.assertEqual((self.tp_B * self.tp_A).__str__(), "-x^5+3x^3+3x^2-2x-3") self.assertEqual((-1 * self.tp_B).__str__(), "-x^2+1")
def test_method__mul__long_coeffs_num(self): self.pm1 = pm.Polynomial("1.00001, 2.999999, 3.44, 2.01, 0.00001, 1") self.pm2 = pm.Polynomial("9.00001, 3.0, 1.56, 10.01, 0.00001, 1") self.pm3 = self.pm1 * self.pm2 self.assertEqual( self.pm3.__str__(), "9x^10+30x^9+41.52x^8+43.1x^7+41.43x^6+47.57x^5+26.12x^4+5x^3+12.02x^2+1" )
def test_method__sub__(self): self.tp_A = pm.Polynomial("3, 3, 3") self.tp_B = pm.Polynomial("2, 2, 2") self.assertEqual((self.tp_A - self.tp_B).__str__(), "x^2+x+1") self.tp_C = pm.Polynomial("3, 3") self.assertEqual((self.tp_A - self.tp_C).__str__(), "3x^2") self.assertEqual((self.tp_A - [-1, 3, 3, 3]).__str__(), "x^3")
def test_method__str__negative(self): self.tp_A = pm.Polynomial((1, 5.5, -1)) self.assertNotEqual(self.tp_A.__str__(), "1x^2+5.5x-1") self.tp_B = pm.Polynomial((1, 5.0, -1)) self.assertNotEqual(self.tp_A.__str__(), "x^2+5.0x-1") self.tp_C = pm.Polynomial((1, 5.001, 1)) self.assertNotEqual(self.tp_A.__str__(), "x^2+5.001x+1")
def test_method__isub__positive(self): self.tp_B -= (1.23, 0.34, -2, 1) self.assertEqual(self.tp_B.__str__(), "2x^2+2x-6") self.tp_tmp = pm.Polynomial(1) self.tp_tmp -= 1 self.assertEqual(self.tp_tmp.__str__(), "0")
def calc_term(points, i): print("-> calc_term: %s, %i" % (points, i)) term = polynomial.Polynomial([1.]) xi, yi = points[i] for j, p in enumerate(points): print("i: %s j: %s p: %s" % (i, j, p)) if j == i: continue xj = p[0] term = term * polynomial.Polynomial([-xj / (xi - xj), 1.0 / (xi - xj)]) term = term * polynomial.Polynomial([yi]) print("<- calc_term: %s" % (term)) return term
def test_method__add__(self): self.assertEqual((self.tp_A + self.tp_B).__str__(), "2.23x^3+4.34x^2-8") self.assertEqual((self.tp_A + 3).__str__(), "x^3+2x^2") self.tp_tmp = pm.Polynomial("-1, -2, 0, 4") self.assertEqual((self.tp_tmp + self.tp_A).__str__(), "1")
def test_method__iadd__negative(self): self.tp_A += pm.Polynomial([-2, 0, 3]) self.assertNotEqual((self.tp_A).__str__(), "1") self.tp_B += (0.77, -2.34, 0, 5) self.assertNotEqual((self.tp_B).__str__(), "2.0x^4") self.tp_tmp += 1.0 self.assertNotEqual((self.tp_tmp).__str__(), "1.0")
def test_method__radd__(self): self.assertEqual((2.1 + self.tp_A).__str__(), "x^3+2x^2-0.9") self.assertEqual((self.tp_B + self.tp_A).__str__(), "2.23x^3+4.34x^2-8") self.assertEqual((3 + self.tp_A).__str__(), "x^3+2x^2") self.tp_tmp = pm.Polynomial("-1, -2, 0, 3") self.assertEqual((self.tp_A + self.tp_tmp).__str__(), "0")
def test_method__iadd__positive(self): self.tp_A += (0.77, 1, 2) self.assertEqual((self.tp_A).__str__(), "x^3+2.77x^2+x-1") self.tp_A += (1, 3, 0.23, 2, 1) self.assertEqual((self.tp_A).__str__(), "x^4+4x^3+3x^2+3x") self.tp_A += pm.Polynomial("-3, 1") self.assertEqual((self.tp_A).__str__(), "x^4+4x^3+3x^2+1") self.tp_tmp += 1 self.assertEqual((self.tp_tmp).__str__(), "1")
def uniform_selection(n, d, coef_max): """ Generate a binomial using uniform selection. @param n: The number of variables in the binomial. @param d: The maximum degree of the binomial. @param coef_max: The maximum coefficient for both monomials in the binomial. @return: Generated binomial represented as a polynomial object. """ coef_1, coef_2 = random.randint(1, coef_max - 1), random.randint(1, coef_max - 1) monomial_1, monomial_2 = random.sample(list(all_monomials_up_to(n, d)), 2) monomial_1 = np.concatenate([np.array([coef_1]), np.array(monomial_1)]) monomial_2 = np.concatenate([np.array([coef_2]), np.array(monomial_2)]) return poly.Polynomial(np.array([monomial_1, monomial_2]))
def test_method__eq__(self): self.tp_A = pm.Polynomial((1, 2.34, -1, 12)) self.tp_B = pm.Polynomial((1, 2.34, -1, 12)) self.assertTrue(self.tp_A == self.tp_B, "Error! Polynomials is not equals") self.tp_C = pm.Polynomial((1, 2.3, -1, 23)) self.assertFalse(self.tp_A == self.tp_C, "Error! Polynomials is equals") self.tp_tmp = pm.Polynomial([0, 0, 0]) self.assertTrue(self.tp_tmp == pm.Polynomial([0]), "Error! 0 == 0") self.tp_tmp = pm.Polynomial([0, 0, 3, 5]) self.assertTrue(self.tp_tmp == pm.Polynomial([3, 5]), "Error! 0x^3 + 0x^2 + 3x + 5 == 3x + 5")
def test_method__mul__(self): self.tp_A = pm.Polynomial((1, 1)) self.tp_B = pm.Polynomial((1, -1)) self.assertEqual((self.tp_A * self.tp_B).__str__(), "x^2-1") self.tp_A = pm.Polynomial(-5) self.tp_B = pm.Polynomial((-2, 1, 2, 0)) self.assertEqual((self.tp_A * self.tp_B).__str__(), "10x^3-5x^2-10x") self.tp_A = pm.Polynomial((1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0)) self.tp_B = pm.Polynomial(-1) self.assertEqual((self.tp_A * self.tp_B).__str__(), "-x^10-2x^9-3x^8") self.tp_B = 0 self.assertEqual((self.tp_A * self.tp_B).__str__(), '0') self.tp_A = pm.Polynomial((1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0)) self.tp_B = pm.Polynomial((1, 0, -4, 0)) self.assertEqual((self.tp_A * self.tp_B).__str__(), "x^13-4x^11+5x^5-20x^3")
def weighted_selection(n, d, coef_max): """ Generate a binomial using weighted selection. @param n: The number of variables in the binomial. @param d: The maximum degree of the binomial. @param coef_max: The maximum coefficient for both monomials in the binomial. @return: Generated binomial represented as a polynomial object. """ polynomial = [] degree_1, degree_2 = random.randint(1, d), random.randint(1, d) coef_1, coef_2 = random.randint(1, coef_max - 1), random.randint(1, coef_max - 1) if degree_1 != degree_2: monomial_1 = np.concatenate([np.array([coef_1]), np.array(random.choice(list(all_monomials(n, degree_1))))]) monomial_2 = np.concatenate([np.array([coef_2]), np.array(random.choice(list(all_monomials(n, degree_2))))]) else: monomial_1, monomial_2 = random.sample(list(all_monomials(n, degree_1)), 2) monomial_1 = np.concatenate([np.array([coef_1]), np.array(monomial_1)]) monomial_2 = np.concatenate([np.array([coef_2]), np.array(monomial_2)]) return poly.Polynomial(np.array([monomial_1, monomial_2]))
def interpolate(points): print("->interpolate: %s" % (points)) if len(points) == 0: raise ValueError("Need at least one point") # extract all x from x,y pairs x_s = [p[0] for p in points] # check that all x_s are unique if len(set(x_s)) != len(x_s): raise ValueError("All x must be unique") # check that all x_s are larger than previous for i in range(1, len(x_s)): if x_s[i] <= x_s[i - 1]: raise ValueError("x n must be larger tha x n-1") # Calcluate the terms of the polynomial # Loop through all points terms = [calc_term(points, i) for i in range(0, len(points))] s = sum(terms, polynomial.Polynomial([])) print("<-interpolate: %s" % s) return s
def test_method__str__positive(self): self.tp_A = pm.Polynomial(range(11)) self.assertEqual(self.tp_A.__str__(), "x^9+2x^8+3x^7+4x^6+5x^5+6x^4+7x^3+8x^2+9x+10") self.tp_B = pm.Polynomial((1.2345, 0.0001, -1)) self.assertEqual(self.tp_B.__str__(), "1.23x^2-1") self.tp_C = pm.Polynomial((1, 0, 1, 0, -1, 0, 1)) self.assertEqual(self.tp_C.__str__(), "x^6+x^4-x^2+1") self.tp_A = pm.Polynomial((1.2, 1.0001, -1)) self.assertEqual(self.tp_A.__str__(), "1.2x^2+x-1") self.tp_B = pm.Polynomial((1.2, 1.0101, -1)) self.assertEqual(self.tp_B.__str__(), "1.2x^2+1.01x-1") self.tp_C = pm.Polynomial() self.assertEqual(self.tp_C.__str__(), "0") self.tp_A = pm.Polynomial(3) self.assertEqual(self.tp_A.__str__(), "3")
import os, sys sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir)) import polynomial as ply p = ply.Polynomial(['x', 'y'], [(1, [2, 0]), (2, [0, 2])]) q = ply.Polynomial(['x', 'y', 'z'], [(1, [2, 1, 0]), (2, [0, 2, 1])]) print 'p =', p print 'q =', q print ply.constant_poly(-1) c = ply.Polynomial(['x', 'y', 'z'], [(5, [0, 0, 0])]) print 'c =', c print 'p constant?', p.is_constant() print 'c constant?', c.is_constant() print 'coef of x^2 in p =', p.coef_of(dict(x=2)) print 'coef in z in q =', q.coef_of(dict(z=1)) print 'partial coef of z in q =', q.coef_of(dict(z=1), True) print 'coef in y^2*z^0 in p =', p.coef_of(dict(y=2, z=0)) print 'coef in y^2*z^1 in p =', p.coef_of(dict(y=2, z=1)) x, y, z = ply.init_poly_vars('xyz') print zip('xyz', map(str, [x, y, z]))
def test_addPolynomialNegative(self): self.assertEqual( polynomial.Polynomial([1, 2, 3, 4]) + polynomial.Polynomial([1, 0, -1, 1]), polynomial.Polynomial([2, 2, 2, 5]))
def test_addPolynomial(self): self.assertEqual( polynomial.Polynomial([1, 2, 3]) + polynomial.Polynomial([1, 1, 1]), polynomial.Polynomial([2, 3, 4]))
def test_supportedType(self): polynomial.Polynomial([1, 2, 3]) polynomial.Polynomial((1, 2, 3))
def test_initZeros(self): self.assertEqual(polynomial.Polynomial([0, 0, 0]), polynomial.Polynomial(0))
def test_eqCoeffSide(self): self.assertEqual(1, polynomial.Polynomial([1]))
def test_eqCoeff(self): self.assertEqual(polynomial.Polynomial([1]), 1)
def test_neqString(self): with self.assertRaises(Exception): polynomial.Polynomial(0) == "0"
def test_neq(self): self.assertFalse( polynomial.Polynomial([1, 1, 1]) == polynomial.Polynomial( [0, 1, 1]))
def test_eq(self): self.assertTrue( polynomial.Polynomial([1, 1, 1]) == polynomial.Polynomial( [1, 1, 1]))
def test_badZeros(self): self.assertEqual(str(polynomial.Polynomial([0, 0, 0, 1, 2, 3])), str(polynomial.Polynomial([1, 2, 3])))
def test_zeroCoeffsMixed(self): self.assertEqual(str(polynomial.Polynomial([1, 0, 0, 4])), "x^3 + 4")
def test_boundZeroInTheStart(self): self.assertEqual(str(polynomial.Polynomial([0, 0, 0, 0, 0, 1])), "1")
def test_boundZeroOnTheEnd(self): self.assertEqual(str(polynomial.Polynomial([1, 0, 0, 0, 0, 0])), "x^5")