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)