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