def test_polymulx(self):
assert_equal(poly.polymulx([0]), [0])
assert_equal(poly.polymulx([1]), [0, 1])
for i in range(1, 5):
ser = [0]*i + [1]
tgt = [0]*(i + 1) + [1]
assert_equal(poly.polymulx(ser), tgt)
def gen_poly(self, n):
self.order = n
# zeroth polynomial
self.poly = [nppoly.polyone]
alpha = [self.get_alpha(self.poly[0])]
beta = [1.]
# first polynomial
self.poly.append(nppoly.polymulx(self.poly[0]))
self.poly[1] = nppoly.polyadd(self.poly[1], -alpha[0] * self.poly[0])
alpha.append(self.get_alpha(self.poly[1]))
beta.append(self.get_beta(self.poly[1], self.poly[0]))
# reccurence relation for other polynomials
for i in range(2, n + 1):
p_i = nppoly.polymulx(self.poly[i - 1])
p_i = nppoly.polyadd(p_i, -alpha[i - 1] * self.poly[i - 1])
p_i = nppoly.polyadd(p_i, -beta[i - 1] * self.poly[i - 2])
self.poly.append(p_i)
alpha.append(self.get_alpha(self.poly[i]))
beta.append(self.get_beta(self.poly[i], self.poly[i - 1]))
# normalise polynomials
for i in range(len(self.poly)):
self.poly[i] = self.poly[i] / np.prod(beta[:i])
# create Jacobi matrix
self.jacobi = (np.diag(np.sqrt(beta[1:]), -1) + np.diag(alpha, 0) +
np.diag(np.sqrt(beta[1:]), 1))
def test_polymulx(self):
assert_equal(poly.polymulx([0]), [0])
assert_equal(poly.polymulx([1]), [0, 1])
for i in range(1, 5):
ser = [0] * i + [1]
tgt = [0] * (i + 1) + [1]
assert_equal(poly.polymulx(ser), tgt)
def make_hermite():
# Hermite polynomials, recursion p_n(x)=x*p_(n-1)(x)-(n-1)*p_(n-2), p_0(x)=1, p_1(x)=x
# _poly_function_basis_recursive((lambda x: 1, lambda x: x), (lambda n, x: x, lambda n, x: 1 - n)) # as example
basis = PolyBasis(
"Hermite",
_poly_basis_recursive(
[np.array([1.]), np.array([0., 1.])], # starting values
[(0, lambda n, c: npoly.polymulx(c)), (1, lambda n, c: c *
(1. - n))]),
lambda degree: calculate_nodes_and_weights(np.zeros(degree),
np.arange(1, degree)))
basis.polys = lambda degree: poly_by_roots(
basis.nodes_and_weights(degree)[0], 1)
return basis
def make_legendre():
# Legendre polynomials, interval assumed to be [-1,1], recursion p_n(x)=x(2n-1)/n * p_(n-1)(x)-(n-1)/n*p_(n-2)(x)
# http://math.stackexchange.com/questions/12160/roots-of-legendre-polynomial gives the monic version of the legendre
# polynomials: p_n(x)=x*p_(n-1)(x)-(n-1)^2/(4(n-1)^2-1)p_(n-2), to get the normal polynomial divide by
# (n!)^2 * 2^n / (2n)!
basis = PolyBasis(
"Legendre",
_poly_basis_recursive(
[np.array([1.]), np.array([0., 1.])], # starting values
[(0, lambda n, c: (2. * n - 1) / n * npoly.polymulx(c)),
(1, lambda n, c: (1. - n) / n * c)]),
lambda degree: calculate_nodes_and_weights(
np.zeros(degree),
np.arange(1, degree)**2 / (4 * (np.arange(1, degree)**2) - 1)))
return basis
def jacobi_basis():
def get_factor(n):
return (2 * n + alpha + beta -
1) * (2 * n + alpha + beta) / (2 * n * (n + alpha + beta))
# this doesn't even look nice on paper
return _poly_basis_recursive(
[
np.array([1.]),
np.array([0.5 * (alpha - beta), 0.5 * (alpha + beta + 2)])
], # starting values
[(0, lambda n, c: npoly.polyadd(
npoly.polymulx(c) * get_factor(n), -c * get_factor(n) *
(beta**2 - alpha**2) / ((2 * n + alpha + beta - 2) *
(2 * n + alpha + beta)))),
(1, lambda n, c: c *
(-2 * get_factor(n) * (n + alpha - 1) * (n + beta - 1) /
((2 * n + alpha + beta - 2) * (2 * n + alpha + beta - 1))))])
def make_laguerre(alpha):
assert alpha > 0
# normalized recurrence relation: q_n=xq_(n-1) - (2(n-1) + alpha)q_(n-1) - (n-1)(n - 2 + alpha)q_(n-2)
# to obtain the regular polynomials multiply by (-1)^n / n!
basis = PolyBasis(
"Laguerre",
_poly_basis_recursive(
[np.array([1.]), np.array([alpha, -1.])],
[(0, lambda n, c: npoly.polyadd(c * (2 * (n - 1) + alpha) / n,
-npoly.polymulx(c) / n)),
(1, lambda n, c: -(n - 1 + alpha - 1) / n * c)]),
lambda degree: calculate_nodes_and_weights(
2 * np.arange(0, degree) + alpha,
np.arange(1, degree) * (np.arange(1, degree) - 1 + alpha)),
params=(alpha, ))
basis.polys = lambda degree: poly_by_roots(
basis.nodes_and_weights(degree)[0],
(1, -1)[degree % 2] / math.sqrt(rising_factorial(
alpha, degree)) / math.sqrt(math.factorial(degree))) # (-1)^n/n!
return basis
def polymulx(cs):
from numpy.polynomial.polynomial import polymulx
return polymulx(cs)
def polymulx(cs):
from numpy.polynomial.polynomial import polymulx
return polymulx(cs)
def get_alpha(self, p):
p2 = nppoly.polypow(p, 2)
xp2 = nppoly.polymulx(p2)
return (self.integrate(xp2, self.intlims[0], self.intlims[1]) /
self.integrate(p2, self.intlims[0], self.intlims[1]))
