def parseExpressionFromStr(expr_str, fieldTower=None):
a = time.time()
sqrt = Number.sqrt
if fieldTower == None:
fieldTower = FE.BASEFIELD
variables = [
fieldTower.getFieldExtension(i).variable
for i in range(fieldTower.towerHeight)
] #[(fieldTower.getFieldExtension(i).variable, fieldTower.getStrippedTower(i+1)) for i in range(fieldTower.towerHeight)]
for variable in variables:
poly = Pol.Polynomial([Number.ZERO, Number.ONE],
variable=variable) #fieldTower=tower)
exec(variable.stringRepr + "=poly")
i = complex(0, 1)
try:
expr = eval(expr_str)
if isNumber(expr):
expr = Pol.Polynomial([expr], variable=FE.BASEVARIABLE)
# if isNumber(expr) or expr.fieldTower.towerHeight<fieldTower.towerHeight:
# expr = Pol.Polynomial([expr],fieldTower=fieldTower)
expr.replaceNumbersWithRationals()
b = time.time()
#print("parsing expression took: {}s".format(b-a))
return expr
except (SyntaxError, NameError, ZeroDivisionError, TypeError) as e:
print(type(e), e)
return None
def test_real(self):
p = Polynomial(1, terms={Powers((0,)): 1.5,
Powers((5,)): -3.6})
re = p.real()
im = p.imag()
self.check_polynomial(p, re, im)
self.assert_(not im)
def test_Exceptions_ValueError(self):
print("test_Exceptions_ValueError")
polyA = pl.Polynomial(self.seq1_args_list[0])
save_polyA = pl.Polynomial(polyA)
args_list_VE = self.exception_args_list_ValueError[:]
num_polynimials = len(args_list_VE)
for i in range(0, num_polynimials, 1):
something = args_list_VE[i]
with self.assertRaises(ValueError):
polyA+something
with self.assertRaises(ValueError):
something+polyA
with self.assertRaises(ValueError):
polyA-something
with self.assertRaises(ValueError):
something-polyA
with self.assertRaises(ValueError):
polyA*something
with self.assertRaises(ValueError):
something*polyA
with self.assertRaises(ValueError):
polyA == something
with self.assertRaises(ValueError):
polyA != something
# polynomials must remain unchanged after tests!!!
self.assertEqual(save_polyA, save_polyA, "The Polynomial must not mutable after these operations!!!")
self.assertEqual(something, args_list_VE[i], "The sequence must not mutable after these operations!!!")
def test_example(self):
p = Polynomial(5)
p += 0.1*Polynomial.Monomial((1, 0, 1, 1, 0))
p -= 0.2*Polynomial.Monomial((1, 7, 1, 1, 0))
p += 0.3*Polynomial.Monomial((0, 0, 1, 1, 2))
p -= 0.4*Polynomial.Monomial((1, 0, 9, 1, 0))
self.assertEquals(p.degree(), 11)
def test_diff_pow0(self):
for vars in xrange(1, 100):
triangle = Powers(tuple(range(1, vars + 1)))
t = Polynomial(vars, terms={triangle: -1.0})
for i in xrange(vars):
u = t.diff_pow(i, 0)
self.assertEquals(u, t)
def test_example(self):
p = Polynomial(5)
p += 0.1 * Polynomial.Monomial((1, 0, 1, 1, 0))
p -= 0.2 * Polynomial.Monomial((1, 7, 1, 1, 0))
p += 0.3 * Polynomial.Monomial((0, 0, 1, 1, 2))
p -= 0.4 * Polynomial.Monomial((1, 0, 9, 1, 0))
self.assertEquals(p.degree(), 11)
def test_imag(self):
p = Polynomial(1, terms={Powers((2,)): 2.3J,
Powers((7,)): -0.2J})
re = p.real()
im = p.imag()
self.check_polynomial(p, re, im)
self.assert_(not re)
def test_too_many_terms(self):
p = Polynomial(6,
terms={
Powers((0, 0, 0, 0, 0, 0)): -0.5,
Powers((1, 0, 0, 0, 0, 0)): 0.2
})
self.assert_(not p.is_constant())
def asFunction(self):
func = 0
for p in self.poly_rational_partExpressions:
func += p
#if self.logExpressions!=[]:
# raise NotImplementedError()
newFieldTower = FE.fieldTower.copy()
for log in self.logExpressions:
tower = FE.hasFieldExtension(FE.TRANS_LOG, log.argFunction,
FE.fieldTower)
if tower == None:
newFieldTower = newFieldTower.addFieldExtension(
FE.FieldExtension(
FE.TRANS_LOG, log.argFunction,
FE.Variable("a" + str(FE.tempVariableNum))))
newTower = newFieldTower.copy()
logExpr = Pol.Polynomial([0, log.factor],
newFieldTower.getLastVariable())
func += logExpr
#raise NotImplementedError("")
else:
logExpr = Pol.Polynomial([0, log.factor],
tower.getLastVariable())
func += logExpr
if self.rootSums != []:
raise NotImplementedError()
return func
def test_diff_pow0(self):
for vars in xrange(1, 100):
triangle = Powers(tuple(range(1, vars+1)))
t = Polynomial(vars, terms={triangle: -1.0})
for i in xrange(vars):
u = t.diff_pow(i, 0)
self.assertEquals(u, t)
def solve(self):
self.left = self.left - self.right
print("TESTING self.left " + str(self.left))
if self.left.countOfVariables() == 1:
self.right = Polynomial.Polymial()
self.right += Polynomial.Monomial(0, "", 1)
actEquation = self.left
if actEquation.degree() == 1:
_tempCalcResult = 0
_tempMon = Polynomial.Monomial(0,
actEquation.getVariableSymbol(),
1)
print("TESTING symbol " + actEquation.getVariableSymbol())
for mon in actEquation.monomials:
if mon.symbol == "" and mon.scalar != 0:
self.left -= mon
self.right += mon
elif mon.symbol == actEquation.getVariableSymbol():
_tempMon = mon
if _tempMon.scalar != 0:
_tempCalcResult /= _tempMon.scalar
self.left -= Polynomial.Monomial(_tempMon.scalar - 1,
_tempMon.symbol, 1)
print(self.left)
self.right += Polynomial.Monomial(_tempCalcResult, "", 1)
print(self.right)
else:
print("Error: monomial with variable not found")
return -1
def _euclidian(self, T):
old_r = Polynomial(1) * (2 * self._t)
old_r = old_r.getAlphaMap()
r = copy.deepcopy(T)
old_t = {}
t = {0 : 0}
old_s = { 0 : 0}
s = {}
while Polynomial.getMapMaxKey(r) >= self._t:
(result, remainder) = Polynomial.divideUsingAlphaMap(old_r, r, self._field)
quotient = result
old_r = r
r = remainder
temp = copy.deepcopy(old_s)
old_s = s
s = Polynomial.multiplyUsingAlphaMap(s, quotient, self._field)
s = Polynomial.addUsingAlphaMap(s, temp, self._field)
temp = copy.deepcopy(old_t)
old_t = t
t = Polynomial.multiplyUsingAlphaMap(t, quotient, self._field)
t = Polynomial.addUsingAlphaMap(t, temp, self._field)
# print "Bezout coefficients:"
# print old_s, old_t
# print "greatest common divisor:"
# print old_r
# print "quotients by the gcd:"
# print t,
return t
def test_constructor_scalars(self):
print(" test_constructor_scalars")
test_list_args = [1, 1.75, 120000, 0.0000021, 120000.00031]
test_list_args1 = [+item for item in test_list_args]
test_list_args2 = [-item for item in test_list_args]
for args in test_list_args:
poly = pl.Polynomial(args)
self.assertFalse(poly.IsEmpty())
self.assertEqual(len(poly.coeffs),1)
self.assertEqual(poly.__str__(),str(args))
self.assertNotEqual(poly, self.polyE)
for args in test_list_args1:
poly = pl.Polynomial(args)
self.assertFalse(poly.IsEmpty())
self.assertEqual(len(poly.coeffs),1)
self.assertEqual(poly.__str__(),str(args))
self.assertNotEqual(poly, self.polyE)
for args in test_list_args2:
poly = pl.Polynomial(args)
self.assertFalse(poly.IsEmpty())
self.assertEqual(len(poly.coeffs), 1)
self.assertEqual(poly.__str__(), str(args))
self.assertNotEqual(poly, self.polyE)
def __helperSolve(p, q, degree):
if degree == 0:
c = q.getLeadingCoefficient() / p.getLeadingCoefficient()
pn = c * p
if pn == q:
return Pol.Polynomial([c])
else:
return None
a = p.getLeadingCoefficient()
b = q.getLeadingCoefficient()
y_lc = b / a
mon = Pol.Monomial(degree, y_lc)
qn = q + (-mon.differentiate()) + (-p * mon)
deg = qn.degree - p.degree
if deg < 0:
return None
#Ansatz: y=a_l *x^l+a_(l-1)*x^(l-1)+...+a_0, l=deg
s = __helperSolve(p, qn, deg)
#s = __helperSolve(p, qn, degree-1)
if s == None:
return None
else:
return s + mon
def test_sub_identity(self):
vars = 3
p = Polynomial(vars)
p[Powers((2, 1, 0))] = -0.3+0.2J
p[Powers((1, 1, 0))] = 0.995
ids = [self._identity(vars, i) for i in xrange(vars)]
q = p.substitute(ids)
self.assert_(p==q)
def __sub__(self, other):
if type(other) is Monomial:
if self.power == other.power:
return Monomial(self.coeff - other.coeff, self.power)
else:
return Polynomial([self, -other])
elif type(other) is float or type(other) is int:
return Polynomial([self, Monomial(-other, 0)])
def test_one(self):
for j in xrange(5):
for i in xrange(6):
pows = [0,]*6
pows[i] = j
p = Polynomial(6)
p = 1.0*Polynomial.Monomial(tuple(pows))
self.assertEquals(p.degree(), j)
def removeCommonFactors(self):
"""
cancels common factors, so that: numerator/denominator = p/q with gcd(p,q)=1
"""
gcd = Pol.PolyGCD(self.numerator, self.denominator)
if not gcd == 1:
self.numerator = Pol.PolyDiv(self.numerator, gcd)[0]
self.denominator = Pol.PolyDiv(self.denominator, gcd)[0]
def test_l1_example(self):
p = Polynomial(3)
p += 1.0*Polynomial.Monomial((1, 2, 3))
self.assertEquals(p.l1_norm(), 1.0)
p -= 2.0*Polynomial.Monomial((0, 2, 0))
self.assertEquals(p.l1_norm(), 3.0)
p += (0.0+5.0J)*Polynomial.Monomial((0, 1, 1))
self.assertEquals(p.l1_norm(), 8.0)
def test_equality_with_complex_coeffs(self):
common_powers = Powers((1, 2, 3))
coeff = 1.0 - 0.5j
p = Polynomial(3)
q = Polynomial(3)
for pol in q, p:
pol[common_powers] = coeff
self.assert_(q == p)
def test_sub_identity(self):
vars = 3
p = Polynomial(vars)
p[Powers((2, 1, 0))] = -0.3 + 0.2J
p[Powers((1, 1, 0))] = 0.995
ids = [self._identity(vars, i) for i in xrange(vars)]
q = p.substitute(ids)
self.assert_(p == q)
def setUp(self):
print(f"Set up for [{self.id()}]")
values_a = [(1, 2), (13, 3), (-20, 5), (5, 7), (-10, 10)]
self.a = Polynomial.Polinom(values_a, 10)
values_b = [(13, 1), (1, 2), (23, 5)]
self.b = Polynomial.Polinom(values_b, len(values_b))
def test_l1_example(self):
p = Polynomial(3)
p += 1.0 * Polynomial.Monomial((1, 2, 3))
self.assertEquals(p.l1_norm(), 1.0)
p -= 2.0 * Polynomial.Monomial((0, 2, 0))
self.assertEquals(p.l1_norm(), 3.0)
p += (0.0 + 5.0J) * Polynomial.Monomial((0, 1, 1))
self.assertEquals(p.l1_norm(), 8.0)
def test_inverse_eg2(self):
p1 = Polynomial(6, terms={Powers((1, 0, 0, 0, 0, 0)): 1.0})
p3 = Polynomial(6, terms={Powers((0, 1, 1, 1, 0, 0)): 1.0J})
z = Polynomial(6)
p_poly = p1 + p3
p_list = self.iso.poly_to_list(p_poly)
self.assert_(p_list == [(1)*p1, (1*1)*z, (1*1*2)*p3], p_list)
q_poly = self.iso.list_to_poly(p_list)
self.assert_(q_poly == p_poly)
def test_diff_pow1_sum(self):
for vars in xrange(1, 100):
triangle = Powers(tuple(range(1, vars + 1)))
t = Polynomial(vars, terms={triangle: -1.0})
u = Polynomial(vars)
for i in xrange(vars):
u += t.diff_pow(i, 1)
self.assertEquals(len(u), vars)
ones = (1.0, ) * vars
self.assertEquals(u(ones), -float((vars * (vars + 1)) / 2))
def test_diff_pow1_sum(self):
for vars in xrange(1, 100):
triangle = Powers(tuple(range(1, vars+1)))
t = Polynomial(vars, terms={triangle: -1.0})
u = Polynomial(vars)
for i in xrange(vars):
u += t.diff_pow(i, 1)
self.assertEquals(len(u), vars)
ones = (1.0, )*vars
self.assertEquals(u(ones), -float((vars*(vars+1))/2))
def test_one(self):
for j in xrange(5):
for i in xrange(6):
pows = [
0,
] * 6
pows[i] = j
p = Polynomial(6)
p = 1.0 * Polynomial.Monomial(tuple(pows))
self.assertEquals(p.degree(), j)
def test_EmptyPolynomial(self):
print("test_EmptyPolynomial")
test_list_args = ('', [], (), 0, (0,0), [0], [0,0,0], pl.Polynomial())
for args in test_list_args:
poly = pl.Polynomial(args)
self.assertTrue(poly.IsEmpty())
self.assertTrue(len(poly.coeffs)==0)
self.assertEqual(poly, self.polyE)
self.assertEqual(poly.__str__(),'0')
def test_Negative(self):
print("test_Negative")
num_tests = len(self.seq1_args_list)
for i in range(0,num_tests,1):
poly = pl.Polynomial(self.seq1_args_list[i])
negation_args = [ -item for item in self.seq1_args_list[i] ]
negation_poly = pl.Polynomial(negation_args)
self.assertEqual(-poly, negation_poly, "iteration = {0} of {1}".format(i, num_tests))
def test_constructor_copy(self):
print("test_constructor_copy")
args_list = self.empty_args_list + self.scalar_args_list + self.seq1_args_list + self.seq2_args_list
test_list_args = [pl.Polynomial(item) for item in args_list]
for args in test_list_args:
copy_poly = pl.Polynomial(args)
self.assertEqual(copy_poly, args)
self.assertTrue(copy_poly.__str__()==args.__str__())
self.assertEqual(copy_poly.coeffs, args.coeffs)
def test_sub_squares(self):
vars = 3
p = Polynomial(vars)
p[Powers((2, 1, 0))] = -0.3 + 0.2J
p[Powers((1, 1, 0))] = 0.995
sqs = [self._square(vars, i) for i in xrange(vars)]
q = p.substitute(sqs)
self.assertEquals(len(q), len(p))
for m, c in p.powers_and_coefficients():
doubled = Powers(tuple([2 * i for i in m]))
self.assertEquals(q[doubled], c)
def test_sub_squares(self):
vars = 3
p = Polynomial(vars)
p[Powers((2, 1, 0))] = -0.3+0.2J
p[Powers((1, 1, 0))] = 0.995
sqs = [self._square(vars, i) for i in xrange(vars)]
q = p.substitute(sqs)
self.assertEquals(len(q), len(p))
for m, c in p.powers_and_coefficients():
doubled = Powers(tuple([2*i for i in m]))
self.assertEquals(q[doubled], c)
def test_sub_neg(self):
vars = 3
p = Polynomial(vars)
a = -0.3 + 0.2J
b = 0.995
p += a * Polynomial.Monomial((2, 2, 3))
p += b * Polynomial.Monomial((1, 1, 0))
neg_ids = [-self._identity(vars, i) for i in xrange(vars)]
q = p.substitute(neg_ids)
self.assertEquals(len(q), len(p))
self.assertEquals(q[Powers((2, 2, 3))], -a)
self.assertEquals(q[Powers((1, 1, 0))], b)
def test_sub_neg(self):
vars = 3
p = Polynomial(vars)
a = -0.3+0.2J
b = 0.995
p += a*Polynomial.Monomial((2, 2, 3))
p += b*Polynomial.Monomial((1, 1, 0))
neg_ids = [-self._identity(vars, i) for i in xrange(vars)]
q = p.substitute(neg_ids)
self.assertEquals(len(q), len(p))
self.assertEquals(q[Powers((2, 2, 3))], -a)
self.assertEquals(q[Powers((1, 1, 0))], b)
def test_SubSequenceOfScalar(self):
print("test_SubSequenceOfScalar")
sequenceOfScalar_list = self.seq1_args_list + self.seq2_args_list
num_polynimials = len(sequenceOfScalar_list)
for i in range(0, num_polynimials, 1):
poly = pl.Polynomial(sequenceOfScalar_list[i])
sequenceOfScalar = sequenceOfScalar_list[i][:]
save_poly = pl.Polynomial(poly)
self.assertEqual(-poly+sequenceOfScalar, sequenceOfScalar-poly, "iteration = {0} of {1}".format(i, num_polynimials))
self.assertEqual(poly, -(sequenceOfScalar-(poly*2)), "iteration = {0} of {1}".format(i, num_polynimials))
self.assertEqual(save_poly, poly, "The Polynomial must not mutable after these operations!!!")
def test_constructor_multi_scalars(self):
print("test_constructor_multi_scalars")
test_list_args = [[1,2,3], [0,0,1,2,3], (1,2,3), (0,0,1,2,3), list([0,1,2,3])]
polyExpect = pl.Polynomial(1,2,3)
polyNotExpect = pl.Polynomial(3,2,1)
for args in test_list_args:
poly = pl.Polynomial(args)
self.assertTrue(len(poly.coeffs)==3)
self.assertEqual(poly, polyExpect)
self.assertNotEqual(poly, polyNotExpect)
def makeDenominatorMonicInPlace(self):
if isNumber(self.denominator):
return
lcoeff = self.denominator.getLeadingCoefficient()
lcoeff_poly = Pol.Polynomial(coefficients=[lcoeff],
variable=self.variable)
if isNumber(self.numerator):
self.numerator = Pol.Polynomial(
[self.numerator], variable=self.variable) / lcoeff_poly
else:
self.numerator = self.numerator / lcoeff_poly
self.denominator = self.denominator / lcoeff_poly
def makeDenominatorMonic(self):
if isNumber(self.denominator):
return
lcoeff = self.denominator.getLeadingCoefficient()
lcoeff_poly = Pol.Polynomial(coefficients=[lcoeff],
variable=self.variable)
if isNumber(self.numerator):
newNumerator = Pol.Polynomial([self.numerator],
variable=self.variable) / lcoeff_poly
else:
newNumerator = self.numerator / lcoeff_poly
newDenominator = self.denominator / lcoeff_poly
return RationalFunction(newNumerator, newDenominator)
def test_NotEqualEmpty(self):
print("test_NotEqualEmpty")
#The test for tuple
lastList = self.seq1_args_list[-1][:]
lastList[-2] -= 110 # random number not equal 0
lastPoly = pl.Polynomial(lastList)
#The test for empty
self.assertTrue(lastPoly != [], "lastPoly != []")
self.assertTrue([] != lastPoly, "[] != lastPoly")
self.assertTrue(lastPoly != (), "lastPoly != ()")
self.assertTrue(() != lastPoly, "() != lastPoly")
self.assertFalse(pl.Polynomial([]) != [], "pl.Polynomial([]) != []")
def experimentWithRidgeRegression(lamda, plotCounter, thetaZero, N, noiseVar):
trueModel = pl.Polynomial(len(thetaZero) - 1)
#create the N true points
x_true = np.arange(0, 2, 2 / float(N))
y_true = trueModel.produce_set(x_true, thetaZero)
#create training set of N points
noise = mod.createNoise(0, noiseVar, N)
y_training = y_true + noise
theta = RidgeRegression(trueModel.X, y_training, lamda, thetaZero, N,
noiseVar)
#create test set
xTest = (np.random.uniform(0.0, 2.0, 1000)).tolist()
#print(xTest)
testModel = pl.Polynomial(len(thetaZero) - 1)
ytest = testModel.produce_set(xTest, thetaZero)
noiseT = mod.createNoise(0, 0.1, 1000)
ytest = ytest + noiseT
#create y from regression model for test set
predictedModel = pl.Polynomial(len(thetaZero) - 1)
ypre = predictedModel.produce_set(xTest, theta)
#create y from regression model for training set
predictedModelT = pl.Polynomial(len(thetaZero) - 1)
ypreT = predictedModelT.produce_set(x_true, theta)
MSEtraining = mod.calculateMSE(y_training, ypreT, 20)
MSEtest = mod.calculateMSE(ytest, ypre, 1000)
#print( MSEtraining)
#print( MSEtest)
#Plot the training set of 20 points and the curves
_ = plt.figure(plotCounter)
_ = plt.plot(0,
label='MSEtraining=' + str("%.5f" % MSEtraining),
color='white')
_ = plt.plot(0, label='MSEtest=' + str("%.5f" % MSEtest), color='white')
_ = plt.xlabel('x')
_ = plt.ylabel('y')
_ = plt.plot(x_true, y_training, 'o', label='Training Set')
_ = trueModel.graph(thetaZero, "True Model", 0, 2)
_ = pl.Polynomial(len(thetaZero) - 1).graph(theta, "Fitted Model", 0, 2)
_ = plt.title('Ridge Regression over 20 points training set with λ = ' +
str(lamda))
_ = plt.legend(fontsize='small')
_ = plt.show()
def test_at_value(self):
self.assertEqual(Polynomial(1, -3, 0, 2).at_value(2), 11, "Test 17 - Spatny vypocet at_value(x)")
self.assertEqual(Polynomial(1, -3, 0, 2).at_value(2, 3), 35, "Test 18 - Spatny vypocet at_value(x, y)")
self.assertEqual(Polynomial(1, -3, 0, 2).at_value(1, 1), 0, "Test 19 - Spatny vypocet at_value(1, 1)")
self.assertEqual(Polynomial(1, -3, 0, 2).at_value(1, 0), 1, "Test 19 - Spatny vypocet at_value(1, 0)")
test1 = Polynomial(x0=1, x1=1)
test2 = test1.at_value(2)
self.assertIsNot(test1, test2,
"Test 20 - Spatne provedeni metody derivative(). Nemela by menit originalni polynom")
self.assertEqual(str(test1), "x + 1",
"Test 21 - Spatne provedeni metody derivative(). Nemela by menit originalni polynom")
self.assertEqual(test2, 3, "Test 22 - Spatny vypocet at_value #2")
def test_sub_sum(self):
vars = 3
p = Polynomial(vars)
a = -0.3+0.2J
b = 0.995
p += a*Polynomial.Monomial((2, 1, 3))
p += b*Polynomial.Monomial((1, 1, 0))
ids = [self._identity(vars, i) for i in xrange(vars)]
ids[0] = self._identity(vars, 0)+2.0*self._identity(vars, 2)
q = p.substitute(ids)
self.assertEquals(len(q), 5)
self.assertEquals(q[Powers((2, 1, 3))], a)
self.assertEquals(q[Powers((1, 1, 4))], 4.0*a)
self.assertEquals(q[Powers((0, 1, 5))], 4.0*a)
self.assertEquals(q[Powers((1, 1, 0))], b)
self.assertEquals(q[Powers((0, 1, 1))], 2.0*b)
def test_derivative(self):
obj1 = Polynomial(1, -3, 0, 2)
obj2 = obj1.derivative()
obj3 = obj2.derivative()
obj4 = obj3.derivative()
self.assertEqual(str(obj1.derivative()), "6x^2 - 3", "Test 10 - Spatny vypocet derivace")
self.assertEqual(str(obj2.derivative()), "12x", "Test 11 - Spatny vypocet derivace z Testu 10")
self.assertEqual(str(obj3.derivative()), "12", "Test 12 - Spatny vypocet derivace z Testu 11")
self.assertEqual(str(obj4.derivative()), "0", "Test 13 - Spatny vypocet derivace z Testu 12")
test1 = Polynomial(x0=1, x1=1)
test2 = test1.derivative()
self.assertIsNot(test1, test2,
"Test 14 - Spatne provedeni metody derivative(). Nemela by menit originalni polynom")
self.assertEqual(str(test1), "x + 1",
"Test 15 - Spatne provedeni metody derivative(). Nemela by menit originalni polynom")
self.assertEqual(str(test2), "1", "Test 16 - Spatny vypocet derivace #2")
def test_one_is(self):
p = Polynomial(2, terms={Powers((1, 2)): 0.5,
Powers((1, 1)): 0.0})
self.assert_(p.is_homogeneous())
self.assert_(not p.is_homogeneous(0))
self.assert_(not p.is_homogeneous(1))
self.assert_(not p.is_homogeneous(2))
self.assert_(p.is_homogeneous(3))
self.assert_(not p.is_homogeneous(4))
self.assert_(not p.is_homogeneous(5))
self.assert_(not p.is_homogeneous(6))
def fitPolynomial(self, order):
"""
@param order: the order of the X{polynomial} to be fitted
@type order: C{int}
@returns: a polynomial whose coefficients have been obtained
by a X{least-squares} fit to the grid values
@rtype: L{Scientific.Functions.Polynomial}
"""
for p in self.period:
if p is not None:
raise ValueError('Polynomial fit not possible ' +
'for periodic function')
points = _combinations(self.axes)
return Polynomial._fitPolynomial(order, points,
N.ravel(self.values))
def fitPolynomial(self, order):
"""Returns a polynomial of |order| with parameters obtained from
a least-squares fit to the grid values."""
points = _combinations(self.axes)
return Polynomial.fitPolynomial(order, points,
Numeric.ravel(self.values))
def test_l1_zero(self):
p = Polynomial(3)
self.assertEquals(p.l1_norm(), 0.0)
def test_zero(self):
p = Polynomial(6)
self.assertEquals(p.degree(), 0)
def test_example(self):
p = Polynomial(6, terms={Powers((0,0,0,0,0,0)): -0.5})
self.assert_(p.is_constant())
def test_too_many_terms(self):
p = Polynomial(6, terms={Powers((0,0,0,0,0,0)): -0.5,
Powers((1,0,0,0,0,0)): 0.2})
self.assert_(not p.is_constant())
def test_non_constant_single_term(self):
p = Polynomial(6, terms={Powers((0,0,0,2,0,0)): -0.5})
self.assert_(not p.is_constant())
def test_poly_with_no_terms_is_constant(self):
p = Polynomial(6)
self.assert_(p.is_constant())
def test_poly_with_no_terms_is_zero_degree(self):
p = Polynomial(6)
self.assertEquals(p.degree(), 0)