def legendrePolynomial(order, x):
coef = []
if type(x) is float:
if x <= 0 or x > 1:
return 0
else:
for n in range(0, order + 1):
if(n == order):
coef.append(1)
else:
coef.append(0)
return (2.*order + 1.)**.5 \
* leg.Legendre(coef, domain=[-1, 1])(2.0*x - 1)
else:
y = np.zeros(x.size)
for i in range(x.size):
if x[i] <= 0 or x[i] > 1:
y[i] = 0
else:
for n in range(0, order+1):
if(n == order):
coef.append(1)
else:
coef.append(0)
y[i] = (2.*order + 1.)**.5 \
* leg.Legendre(coef, domain=[-1, 1])(2.0*x[i] - 1)
coef.clear()
return y
def test_divmod(self):
tquo = leg.Legendre([1])
trem = leg.Legendre([2])
quo, rem = divmod(self.p5, self.p1)
assert_(quo == tquo and rem == trem)
quo, rem = divmod(self.p5, [1, 2, 3])
assert_(quo == tquo and rem == trem)
quo, rem = divmod([3, 2, 3], self.p1)
assert_(quo == tquo and rem == trem)
def draw_electrostatic(E):
#points of the polynomials.
xaxis = np.arange(-1, 1, 0.01)
#vector which F(X) = 0
X = nr.Newton_Raphson(energy_electrostatic, jacobian_electrostatic, E,
iteration_number, epsilon)
#elements of the vector X
charges = plt.scatter(X, np.full(len(X), 0))
colors = "red", "blue", "green", "cyan", "purple", "orange", "magenta"
#drawing the 8 first polynomials.
for n in range(3, 8, 1):
#array of 0.
T = np.zeros(n)
#put the coefficient relate to the polynomial wanted to 1
T[n - 1] = 1
#give the polynomial
L = npl.Legendre(T)
#the derivative of the polynomial
D = npl.Legendre.deriv(L)
yaxis = D(xaxis)
plt.plot(xaxis, yaxis, color=colors[n - 1])
plt.show()
def normlegAl(self, coefs):
d = 0.0
for i in range(len(coefs)):
d += (coefs[i]**2) / (2 * i + 1)
d = np.sqrt(d)
coefs = np.divide(coefs, d)
#print coefs
return L.Legendre(coefs)
def hamiltonian(coefs, func=BASIS_FUNC, V=V, C=C):
'''hamiltonian operator acting on wavefunction'''
if func == 'legendre':
ham = -C * L.legder(L.legder(coefs)) + V * L.Legendre(coefs)
return ham
elif func == 'fourier':
ham = [V] + [(i**2) * C * coefs[i] for i in range(1, len(coefs))]
return ham
def evaluate_basis_derivative(self, x=None, i=0, k=0, output_array=None):
if x is None:
x = self.mesh(False, False)
x = np.atleast_1d(x)
basis = np.zeros(self.shape(True))
basis[i] = 1
basis = leg.Legendre(basis)
if k > 0:
basis = basis.deriv(k)
return basis(x)
def plot(U0, epsilon, N, a_min=0.001):
fig=plt.figure()
coeff=np.zeros(len(U0)+2)
coeff[len(U0)+1]=1
plt.plot(resolve(U0, epsilon, N, a_min),np.zeros((len(U0))),'+',color='b',label='Electrostatic equilibrium positions')
plt.plot(leg.Legendre(coeff).deriv().roots(),np.zeros((len(U0))),'x',color='r',label='Legendre polynomial\'s derivative roots')
plt.legend()
plt.title("Roots of Legendre polynomial derivative of order {}\n and the electrostatic equilibrium's positions of the system".format(len(U0)))
plt.savefig("img/roots_{}".format(len(U0)), dpi=fig.dpi)
print("creating img/roots_{}\n".format(len(U0)))
def test_collocation_points_legendre_gauss_lobatto(self):
for num_coll_points in range(2, 13):
coefs = np.zeros(num_coll_points)
coefs[-1] = 1.
coll_points_numpy = np.concatenate(
([-1.], legendre.Legendre(coefs).deriv().roots(), [1.]))
mesh = Mesh1D(num_coll_points, Basis.Legendre,
Quadrature.GaussLobatto)
coll_points_spectre = collocation_points(mesh)
np.testing.assert_allclose(coll_points_numpy, coll_points_spectre,
1e-12, 1e-12)
def weights(order):
x = roots(order)
w = np.empty(order)
coef = []
for n in range(0, order+1):
if(n == order):
coef.append(1)
else:
coef.append(0)
derivative_coefficients = leg.legder(coef)
del coef[-1]
del coef[-1]
coef.append(1)
for i in range(0, order):
tmp = leg.Legendre(derivative_coefficients, domain=[-1, 1])(2*x[i] - 1)
tmp2 = leg.Legendre(coef, domain=[-1, 1])(2.0*x[i] - 1)
w[i] = 1/(order*tmp*tmp2)
# Possibly some bug here, get a factor 2 different using mathematica
return w
def evaluate_basis_derivative(self, x=None, i=0, k=0, output_array=None):
if x is None:
x = self.mesh(False, False)
if output_array is None:
output_array = np.zeros(x.shape)
x = np.atleast_1d(x)
basis = np.zeros(self.shape(True))
basis[np.array([i, i + 2])] = (1, -i * (i + 1.) / (i + 2.) / (i + 3.))
basis = leg.Legendre(basis)
if k > 0:
basis = basis.deriv(k)
output_array[:] = basis(x)
return output_array
def get_orthpoly(n_deg,
f_weighting,
n_extra_point=10,
return_coef=True,
representation='chebyshev',
integral_method='legendre'):
"""
Get orthogonal polynomials with respect to the weighting (f_weighting).
The polynomials are represented by coefficients of Chebyshev polynomials.
Evaluate it as: np.dot(cheb.chebvander(set_of_x, n_deg), repr_coef)
See weighted_orthpoly1.py for validation of this algorithm.
"""
n_sampling = n_deg + 1 + n_extra_point
# Do the intergration by discrete sampling at good points.
if integral_method == 'chebyshev':
# Here we use (first kind) Chebyshev points.
x_sampling = chebyshev_roots(n_sampling)
# Put together the weighting and the weighting of the Gauss-Chebyshev quadrature.
diag_weight = np.array(
[f_weighting(x) / cheb.chebweight(x)
for x in x_sampling]) * (pi / n_sampling)
elif integral_method == 'legendre':
# Use Gauss-Legendre quadrature.
x_sampling, int_weight = lege.leggauss(n_sampling)
diag_weight = np.array(
[f_weighting(x) * w for x, w in zip(x_sampling, int_weight)])
if representation == 'chebyshev':
V = cheb.chebvander(x_sampling, n_deg)
else:
V = lege.legvander(x_sampling, n_deg)
# Get basis from chol of the Gramian matrix.
# inner_prod_matrix = dot(V.T, diag_weight[:, np.newaxis] * V)
# repr_coef = inv(cholesky(inner_prod_matrix).T)
# QR decomposition should give more accurate result.
repr_coef = inv(qr(sqrt(diag_weight[:, np.newaxis]) * V, mode='r'))
repr_coef = repr_coef * sign(sum(repr_coef, axis=0))
if return_coef:
return repr_coef
else:
if representation == 'chebyshev':
polys = [cheb.Chebyshev(repr_coef[:, i]) for i in range(n_deg + 1)]
else:
polys = [lege.Legendre(repr_coef[:, i]) for i in range(n_deg + 1)]
return polys
def legendre_roots(n, n_iter=3):
"""
Get roots of legendre polynomial of degree n, by Newton's iteration.
n_iter is the number of iteration.
Accurate to machine epsilon, although le(ar) may significantly \
deviate from zero (e.g. 1e-11).
Effectively ar = lege.legroots(1*(arange(n+1)==n)), but faster for large n.
"""
# Approximation of roots
# https://math.stackexchange.com/questions/12160/roots-of-legendre-polynomial/12270
ar = (1 - 1 / (8 * n * n) + 1 /
(8 * n * n * n)) * cos(pi * (4 * arange(1, n + 1) - 1) /
(4 * n + 2) - pi)
# Newton's iteration
le = lege.Legendre(1 * (arange(n + 1) == n))
dle = le.deriv()
for i in range(n_iter):
ar = ar - le(ar) / dle(ar)
return ar
def evaluate_basis_derivative(self, x=None, i=0, k=0, output_array=None):
if x is None:
x = self.mesh(False, False)
if output_array is None:
output_array = np.zeros(x.shape)
x = np.atleast_1d(x)
if i < self.N - 4:
basis = np.zeros(self.shape(True))
basis[np.array([i, i + 2,
i + 4])] = (1, -2 * (2 * i + 5.) / (2 * i + 7.),
((2 * i + 3.) / (2 * i + 7.)))
basis = leg.Legendre(basis)
if k > 0:
basis = basis.deriv(k)
output_array[:] = basis(x)
else:
output_array[:] = sympy.lambdify(
sympy.symbols('x'),
self.sympy_basis(i).diff(sympy.symbols('x'), k))(x)
return output_array
def _get_single_element(self):
"""Calculate local grid nodes, corresponding weights and differentiation matrix
using numpy.polynomial.legendre module
Sets
----
x_, w_, dmat_
"""
# Interested in Legendre polynomial #(Np-1):
coefs = np.append(np.zeros(self.Np - 1), 1)
# Calculate grid points:
self.x_ = np.append(
np.append(-1,
legendre.Legendre(coefs).deriv().roots()), 1)
# Need legendre polynomial at grid points:
Ln = legendre.legval(self.x_, coefs)
# Calculate weights:
self.w_ = 2 / ((self.Np - 1) * self.Np * Ln**2)
# Calculate differentiation matrix:
self.dmat_ = np.zeros((len(Ln), len(Ln)))
for i in range(self.Np):
for j in range(self.Np):
if i != j:
self.dmat_[i][j] = Ln[i] / \
(Ln[j] * (self.x_[i] - self.x_[j]))
else:
self.dmat_[i][i] = 0
self.dmat_[0, 0] = -(self.Np - 1) * (self.Np) / 4
self.dmat_[-1, -1] = (self.Np - 1) * (self.Np) / 4
# Scale locals:
self.x_ *= self.ele_scale_
self.w_ *= self.ele_scale_
self.dmat_ /= self.ele_scale_
def __init__(self, fitparams):
# handed a list or tuple of firparams (which includes flags
# for type of fit) sets up the irafcurve instance.
# should be an int but it i'nt sometimes
typecode = int(fitparams[0] + 0.001)
if typecode == 1: self.curvetype = 'chebyshev'
elif typecode == 2: self.curvetype = 'legendre'
elif typecode == 3: self.curvetype = 'spline3'
else:
print("Unknown fit type: ", fitparams[0])
# the 'iraforder' is not the conventional order; it's
# the number of coefficients for a polynomial, so a
# a straight line has iraforder = 2. For a spline3 it is
# the number of spline segments.
self.iraforder = int(fitparams[1] + 0.001)
self.xrange = (fitparams[2], fitparams[3])
self.span = self.xrange[1] - self.xrange[0]
self.sumrange = self.xrange[0] + self.xrange[1]
self.fitcoeffs = np.array(fitparams[4:])
# Numpy provides built-in legendre and chebyshev apparatuses that make
# this trivial. The numpy spline3 is apparently oriented toward interpolation,
# and wasn't as easy to adapt, though I'm probably missing something. My own
# spline3 stuff works correctly though it's more awkward.
if self.curvetype == 'legendre':
self.lpoly = leg.Legendre(self.fitcoeffs, domain = [self.xrange[0], self.xrange[1]])
if self.curvetype == 'chebyshev':
self.chpoly = cheb.Chebyshev(self.fitcoeffs, domain = [self.xrange[0], self.xrange[1]])
def leg_gauss_quad(field_data, rings=3, arms=6, obs=0.0, symm=False):
"""Calculate normalised pupil coordinates for Legendre-Gauss quadrature
rayset selection.
Parameters
----------
field_data : list of fieldData named tuples
The field coordinates to use for generation of the coordinates. Must
be a list as returned from Zemax by zGetFieldTuple().
rings : int
The number of rings of rays for which to compute radial pupil coordinates.
Minimum of 3, which is the default.
arms : int
The number of radial arms along which to calculate the pupil coordinates.
Default is 6. Minimum is 6. Must be even.
obs : float
The fractional radius of the pupil which is obscured. Defaults to 0.0
symm : boolean
Will reduce the number of returned points if the provided field points
are found to lie only along the x axis or only along the y axis.
Default is False, symmetry not to be assumed.
Returns
-------
hx : array of float
Relative field x coordinates of the ray list.
hy : array of float
Relative field y coordinates of the ray list.
px : array of float
Relative pupil x coordinates of the ray list.
py : array of float
Relative pupil y coodinates of the ray list.
weights : array of float
Legendre-Gauss weighting factors for each ray.
Reference:
Brian J. Bauman and Hong Xiao,
Gaussian quadrature for optical design with non-circular pupils and fields,
and broad wavelength ranges, https://doi.org/10.1117/12.872773
Notes
-----
This function only handles circular pupils with centered circular obscurations.
"""
# Check that arms is even
if arms < 6 or (arms // 2 != arms / 2.0):
raise ValueError('Input parameter arms must be even and 6 or more.')
if rings < 3:
raise ValueError('Input parameter rings must be 3 or more.')
hx = np.array([])
hy = np.array([])
px = np.array([])
py = np.array([])
weights = np.array([]) # LGQ weights
order_tuple = tuple([0] * rings + [1])
order_tuple1 = tuple([0] * (rings + 1) + [1])
# Get the Legendre polynomial of order equal to the number of rings
leg_poly = leg.Legendre(order_tuple)
# And the one after that for calculating the weights below
leg_poly1 = leg.Legendre(order_tuple1)
# Get the roots of the polynomial
leg_roots = leg_poly.roots()
# The relative radii of the rings are computed as follows (see Bauman Eq. 6)
ring_radii = np.sqrt(obs**2.0 + (1.0 + leg_roots) * (1.0 - obs**2.0) / 2.0)
# Get the weights, see e.g. https://mathworld.wolfram.com/Legendre-GaussQuadrature.html
leg_weights = 2.0 * (1.0 - leg_roots**2.0) / ((rings + 1.0)**2.0 *
(leg_poly1(leg_roots)**2.0))
if obs > 0.0:
pupil_weights = (1.0 - obs) * leg_weights / 2.0
else:
pupil_weights = leg_weights / 2.0
# Run through the field points
theta_inc = 360.0 / arms # degrees. Angular increment between arms
for field_point in field_data:
# Get the coordinates and weighting factor for this field point
xf, yf, wgt = field_point.xf, field_point.yf, field_point.wgt
# Generate the relative pupil coordinates for this field position
# Takes symmetry flag into account
if xf == 0.0:
if symm: # Generate polar angles that are symmetric only across the y-axis
if yf == 0.0: # On axis
theta = 0.0 # A single arm is enough if the system is symmetric
else:
theta = np.linspace(-90.0 + theta_inc / 2.0,
90.0 - theta_inc / 2.0, arms // 2)
else:
theta = np.linspace(0.0, 360.0 - theta_inc, arms)
elif yf == 0.0:
if symm: # Generate polar angles that are symmetric only cross the x-axis
theta = np.linspace(theta_inc / 2.0, 180.0 - theta_inc / 2.0,
arms // 2)
else:
theta = np.linspace(-180.0 + theta_inc / 2.0,
180.0 - theta_inc / 2.0, arms)
theta_rad = np.deg2rad(theta)
# Meshgrid the radii and the angles, variables fp_ are for this field point
fp_ring_radii, fp_theta_rad = np.meshgrid(ring_radii, theta_rad)
# pup_weights are meshgridded to make an array corresponding to the radius
fp_pupil_weights, fp_theta_rad = np.meshgrid(pupil_weights, theta_rad)
fp_px, fp_py = fp_ring_radii * np.cos(
fp_theta_rad), fp_ring_radii * np.sin(fp_theta_rad)
# Flatten arrays, should now all be the same length
fp_px, fp_py, fp_pupil_weights = fp_px.flatten(), fp_py.flatten(
), fp_pupil_weights.flatten()
fp_len = np.ones(fp_px.size)
# Replicate up the field points and field weights to the correct length
fp_hx, fp_hy, fp_wgt = xf * fp_len, yf * fp_len, wgt * fp_pupil_weights
# The field weigts
hx, hy, weights = np.hstack((hx, fp_hx)), np.hstack(
(hy, fp_hy)), np.hstack((weights, fp_wgt))
px, py = np.hstack((px, fp_px)), np.hstack((py, fp_py))
# Get the maximum field radial position to perform field normalisation
max_field_radius = np.sqrt(hx**2.0 + hy**2.0).max()
hx /= max_field_radius
hy /= max_field_radius
return hx, hy, px, py, weights
def test_mul(self):
tgt = leg.Legendre([4.13333333, 8.8, 11.23809524, 7.2, 4.62857143])
assert_poly_almost_equal(self.p1 * self.p1, tgt)
assert_poly_almost_equal(self.p1 * [1, 2, 3], tgt)
assert_poly_almost_equal([1, 2, 3] * self.p1, tgt)
def normlegExpect(self, coefs):
lOrig = L.Legendre(coefs)
d = (stats.uniform.expect(lOrig**2, loc=-1, scale=2))**0.5
return lOrig / d
def normlegInteg(self, coefs):
lOrig = L.Legendre(coefs)
l2integ = (lOrig**2).integ()
d = ((l2integ(1) - l2integ(-1)) / 2)**0.5
return lOrig / d
def test_add(self):
tgt = leg.Legendre([2, 4, 6])
assert_(self.p1 + self.p1 == tgt)
assert_(self.p1 + [1, 2, 3] == tgt)
assert_([1, 2, 3] + self.p1 == tgt)
class TestLegendreClass(TestCase):
p1 = leg.Legendre([1, 2, 3])
p2 = leg.Legendre([1, 2, 3], [0, 1])
p3 = leg.Legendre([1, 2])
p4 = leg.Legendre([2, 2, 3])
p5 = leg.Legendre([3, 2, 3])
def test_equal(self):
assert_(self.p1 == self.p1)
assert_(self.p2 == self.p2)
assert_(not self.p1 == self.p2)
assert_(not self.p1 == self.p3)
assert_(not self.p1 == [1, 2, 3])
def test_not_equal(self):
assert_(not self.p1 != self.p1)
assert_(not self.p2 != self.p2)
assert_(self.p1 != self.p2)
assert_(self.p1 != self.p3)
assert_(self.p1 != [1, 2, 3])
def test_add(self):
tgt = leg.Legendre([2, 4, 6])
assert_(self.p1 + self.p1 == tgt)
assert_(self.p1 + [1, 2, 3] == tgt)
assert_([1, 2, 3] + self.p1 == tgt)
def test_sub(self):
tgt = leg.Legendre([1])
assert_(self.p4 - self.p1 == tgt)
assert_(self.p4 - [1, 2, 3] == tgt)
assert_([2, 2, 3] - self.p1 == tgt)
def test_mul(self):
tgt = leg.Legendre([4.13333333, 8.8, 11.23809524, 7.2, 4.62857143])
assert_poly_almost_equal(self.p1 * self.p1, tgt)
assert_poly_almost_equal(self.p1 * [1, 2, 3], tgt)
assert_poly_almost_equal([1, 2, 3] * self.p1, tgt)
def test_floordiv(self):
tgt = leg.Legendre([1])
assert_(self.p4 // self.p1 == tgt)
assert_(self.p4 // [1, 2, 3] == tgt)
assert_([2, 2, 3] // self.p1 == tgt)
def test_mod(self):
tgt = leg.Legendre([1])
assert_((self.p4 % self.p1) == tgt)
assert_((self.p4 % [1, 2, 3]) == tgt)
assert_(([2, 2, 3] % self.p1) == tgt)
def test_divmod(self):
tquo = leg.Legendre([1])
trem = leg.Legendre([2])
quo, rem = divmod(self.p5, self.p1)
assert_(quo == tquo and rem == trem)
quo, rem = divmod(self.p5, [1, 2, 3])
assert_(quo == tquo and rem == trem)
quo, rem = divmod([3, 2, 3], self.p1)
assert_(quo == tquo and rem == trem)
def test_pow(self):
tgt = leg.Legendre([1])
for i in range(5):
res = self.p1**i
assert_(res == tgt)
tgt = tgt * self.p1
def test_call(self):
# domain = [-1, 1]
x = np.linspace(-1, 1)
tgt = 3 * (1.5 * x**2 - .5) + 2 * x + 1
assert_almost_equal(self.p1(x), tgt)
# domain = [0, 1]
x = np.linspace(0, 1)
xx = 2 * x - 1
assert_almost_equal(self.p2(x), self.p1(xx))
def test_degree(self):
assert_equal(self.p1.degree(), 2)
def test_trimdeg(self):
assert_raises(ValueError, self.p1.cutdeg, .5)
assert_raises(ValueError, self.p1.cutdeg, -1)
assert_equal(len(self.p1.cutdeg(3)), 3)
assert_equal(len(self.p1.cutdeg(2)), 3)
assert_equal(len(self.p1.cutdeg(1)), 2)
assert_equal(len(self.p1.cutdeg(0)), 1)
def test_convert(self):
x = np.linspace(-1, 1)
p = self.p1.convert(domain=[0, 1])
assert_almost_equal(p(x), self.p1(x))
def test_mapparms(self):
parms = self.p2.mapparms()
assert_almost_equal(parms, [-1, 2])
def test_trim(self):
coef = [1, 1e-6, 1e-12, 0]
p = leg.Legendre(coef)
assert_equal(p.trim().coef, coef[:3])
assert_equal(p.trim(1e-10).coef, coef[:2])
assert_equal(p.trim(1e-5).coef, coef[:1])
def test_truncate(self):
assert_raises(ValueError, self.p1.truncate, .5)
assert_raises(ValueError, self.p1.truncate, 0)
assert_equal(len(self.p1.truncate(4)), 3)
assert_equal(len(self.p1.truncate(3)), 3)
assert_equal(len(self.p1.truncate(2)), 2)
assert_equal(len(self.p1.truncate(1)), 1)
def test_copy(self):
p = self.p1.copy()
assert_(self.p1 == p)
def test_integ(self):
p = self.p2.integ()
assert_almost_equal(p.coef, leg.legint([1, 2, 3], 1, 0, scl=.5))
p = self.p2.integ(lbnd=0)
assert_almost_equal(p(0), 0)
p = self.p2.integ(1, 1)
assert_almost_equal(p.coef, leg.legint([1, 2, 3], 1, 1, scl=.5))
p = self.p2.integ(2, [1, 2])
assert_almost_equal(p.coef, leg.legint([1, 2, 3], 2, [1, 2], scl=.5))
def test_deriv(self):
p = self.p2.integ(2, [1, 2])
assert_almost_equal(p.deriv(1).coef, self.p2.integ(1, [1]).coef)
assert_almost_equal(p.deriv(2).coef, self.p2.coef)
def test_roots(self):
p = leg.Legendre(leg.poly2leg([0, -1, 0, 1]), [0, 1])
res = p.roots()
tgt = [0, .5, 1]
assert_almost_equal(res, tgt)
def test_linspace(self):
xdes = np.linspace(0, 1, 20)
ydes = self.p2(xdes)
xres, yres = self.p2.linspace(20)
assert_almost_equal(xres, xdes)
assert_almost_equal(yres, ydes)
def test_fromroots(self):
roots = [0, .5, 1]
p = leg.Legendre.fromroots(roots, domain=[0, 1])
res = p.coef
tgt = leg.poly2leg([0, -1, 0, 1])
assert_almost_equal(res, tgt)
def test_fit(self):
def f(x):
return x * (x - 1) * (x - 2)
x = np.linspace(0, 3)
y = f(x)
# test default value of domain
p = leg.Legendre.fit(x, y, 3)
assert_almost_equal(p.domain, [0, 3])
# test that fit works in given domains
p = leg.Legendre.fit(x, y, 3, None)
assert_almost_equal(p(x), y)
assert_almost_equal(p.domain, [0, 3])
p = leg.Legendre.fit(x, y, 3, [])
assert_almost_equal(p(x), y)
assert_almost_equal(p.domain, [-1, 1])
# test that fit accepts weights.
w = np.zeros_like(x)
yw = y.copy()
w[1::2] = 1
yw[0::2] = 0
p = leg.Legendre.fit(x, yw, 3, w=w)
assert_almost_equal(p(x), y)
def test_identity(self):
x = np.linspace(0, 3)
p = leg.Legendre.identity()
assert_almost_equal(p(x), x)
p = leg.Legendre.identity([1, 3])
assert_almost_equal(p(x), x)
def test_roots(self):
p = leg.Legendre(leg.poly2leg([0, -1, 0, 1]), [0, 1])
res = p.roots()
tgt = [0, .5, 1]
assert_almost_equal(res, tgt)
def legendreToNewton(legCoeffs):
return leg.Legendre(legCoeffs).convert(kind=np.polynomial.polynomial.Polynomial)
def test_trim(self):
coef = [1, 1e-6, 1e-12, 0]
p = leg.Legendre(coef)
assert_equal(p.trim().coef, coef[:3])
assert_equal(p.trim(1e-10).coef, coef[:2])
assert_equal(p.trim(1e-5).coef, coef[:1])
def test_pow(self):
tgt = leg.Legendre([1])
for i in range(5):
res = self.p1**i
assert_(res == tgt)
tgt = tgt * self.p1
def test_sub(self):
tgt = leg.Legendre([1])
assert_(self.p4 - self.p1 == tgt)
assert_(self.p4 - [1, 2, 3] == tgt)
assert_([2, 2, 3] - self.p1 == tgt)
def test_mod(self):
tgt = leg.Legendre([1])
assert_((self.p4 % self.p1) == tgt)
assert_((self.p4 % [1, 2, 3]) == tgt)
assert_(([2, 2, 3] % self.p1) == tgt)
def test_hamiltonian():
'''checks if hamiltonian is calculated correctly'''
haml = schrod.hamiltonian((1,1), 'legendre', 1, 0)
assert haml == L.Legendre((1,1))
hamf = schrod.hamiltonian((1,2,3), 'fourier', 1, 0)
def legfit(xs, ys, deg):
coeffs = leg.legfit(xs, ys, deg)
p = leg.Legendre(coeffs)
return mkseries(xs, ys, p)
def test_floordiv(self):
tgt = leg.Legendre([1])
assert_(self.p4 // self.p1 == tgt)
assert_(self.p4 // [1, 2, 3] == tgt)
assert_([2, 2, 3] // self.p1 == tgt)
