def min_moments(param):
v = param[0]
sigma = param[1]
k = v**2 / (2 * sigma**2)
a = np.sqrt(np.pi / 2)
moments = np.zeros(6, dtype=float)
moments[0] = sigma * a * eval_laguerre(1 / 2, -k)
moments[1] = 2 * sigma**2 + v**2
moments[2] = 3 * (sigma**3) * a * eval_laguerre(3 / 2, -k)
moments[3] = 8 * (sigma**4) + 8 * (sigma**2) * (v**2) + (v**4)
moments[4] = 15 * (sigma**5) * a * eval_laguerre(5 / 2, -k)
moments[5] = 48 * (sigma**6) + 72 * (sigma**4) * (v**2) + 18 * (
sigma**2) * (v**4) + (v**6)
sample_moments = np.array(
[raw_moment(data, moment=i + 1) for i in range(6)])
weights = [6 - i for i in range(6)]
moments = weights * moments
sample_moments = weights * sample_moments
cost = (np.sum(sample_moments) - np.sum(moments))**2
return cost
def evaluate_basis(self, x, i=0, output_array=None):
x = np.atleast_1d(x)
if output_array is None:
output_array = np.zeros(x.shape)
output_array[:] = eval_laguerre(i, x) - eval_laguerre(i+1, x)
output_array *= np.exp(-x/2)
return output_array
def test_laguerre():
allTrue = True
for order in range(ORDER_MAX):
x = np.random.rand(1).item()
valuePy = sp.eval_laguerre(order, x)
valueCpp = NumCpp.laguerre_Scaler1(order, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(valueCpp, DECIMALS_ROUND):
allTrue = False
assert allTrue
allTrue = True
for order in range(ORDER_MAX):
shapeInput = np.random.randint(10, 100, [2, ], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_laguerre(order, x)
valueCpp = NumCpp.laguerre_Array1(order, cArray)
if not np.array_equal(np.round(valuePy, DECIMALS_ROUND), np.round(valueCpp, DECIMALS_ROUND)):
allTrue = False
assert allTrue
allTrue = True
for order in range(ORDER_MAX):
degree = np.random.randint(0, 10, [1, ]).item()
x = np.random.rand(1).item()
valuePy = sp.eval_genlaguerre(degree, order, x)
valueCpp = NumCpp.laguerre_Scaler2(order, degree, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(valueCpp, DECIMALS_ROUND):
allTrue = False
assert allTrue
allTrue = True
for order in range(ORDER_MAX):
degree = np.random.randint(0, 10, [1, ]).item()
shapeInput = np.random.randint(10, 100, [2, ], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_genlaguerre(degree, order, x)
valueCpp = NumCpp.laguerre_Array2(order, degree, cArray)
if not np.array_equal(np.round(valuePy, DECIMALS_ROUND), np.round(valueCpp, DECIMALS_ROUND)):
allTrue = False
assert allTrue
def test_laguerre():
if NumCpp.NO_USE_BOOST and not NumCpp.STL_SPECIAL_FUNCTIONS:
return
for order in range(ORDER_MAX):
x = np.random.rand(1).item()
valuePy = sp.eval_laguerre(order, x)
valueCpp = NumCpp.laguerre_Scaler1(order, x)
assert np.round(valuePy,
DECIMALS_ROUND) == np.round(valueCpp, DECIMALS_ROUND)
for order in range(ORDER_MAX):
shapeInput = np.random.randint(10, 100, [
2,
], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_laguerre(order, x)
valueCpp = NumCpp.laguerre_Array1(order, cArray)
assert np.array_equal(np.round(valuePy, DECIMALS_ROUND),
np.round(valueCpp, DECIMALS_ROUND))
for order in range(ORDER_MAX):
degree = np.random.randint(0, 10, [
1,
]).item()
x = np.random.rand(1).item()
valuePy = sp.eval_genlaguerre(degree, order, x)
valueCpp = NumCpp.laguerre_Scaler2(order, degree, x)
assert np.round(valuePy,
DECIMALS_ROUND) == np.round(valueCpp, DECIMALS_ROUND)
for order in range(ORDER_MAX):
degree = np.random.randint(0, 10, [
1,
]).item()
shapeInput = np.random.randint(10, 100, [
2,
], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_genlaguerre(degree, order, x)
valueCpp = NumCpp.laguerre_Array2(order, degree, cArray)
assert np.array_equal(np.round(valuePy, DECIMALS_ROUND),
np.round(valueCpp, DECIMALS_ROUND))
def omega_ij(self,ni,nj):
ki, li, mi = self.basis_numbers(ni)
kj, lj, mj = self.basis_numbers(nj)
vi = self.nu(ni)
vj = self.nu(nj)
z_int = lambda z: np.exp(-1*z)*sp.eval_laguerre(ki,z)*sp.eval_laguerre(kj,z)/z**2
t_int = lambda t: 1/np.sin(t)**3*(-1*vi*(vi*np.cos(t)**2+vi+1)*sp.lpmv(mi,vi,np.cos(t))+vi*(vi+mi)*np.cos(t)*sp.lpmv(mi,vi-1,np.cos(t))+vi*(vi-mi+1)*np.cos(t)*sp.lpmv(mi,vi+1,np.cos(t)))*(-1*vj*(vj*np.cos(t)**2+vj+1)*sp.lpmv(mj,vj,np.cos(t))+vj*(vj+mj)*np.cos(t)*sp.lpmv(mj,vj-1,np.cos(t))+vj*(vj-mj+1)*np.cos(t)*sp.lpmv(mj,vj+1,np.cos(t)))
p_int = lambda p: self.Az(vi,mi,p)*self.Az(vj,mj,p)
Iz = scipy.integrate.quad(z_int, 0., self.max_z_int)
It = scipy.integrate.quad(t_int, 0., self.cap_lim)
Ip = scipy.integrate.quad(p_int, 0., 2*np.pi)
O = Iz[0]*It[0]*Ip[0]
return O
def ham_parity(dim, params):
a, x = params
H = np.zeros((dim,dim))
for i in range(dim):
H[i,i] += i
H[i,i] -= a*np.exp(-0.5*x**2)*special.eval_laguerre(int(0.25*x**2),x**2)*np.cos(np.pi*i)
return H
def psi_ij(self, ni, nj):
ki, li, mi = self.basis_numbers(ni)
kj, lj, mj = self.basis_numbers(nj)
vi = self.nu(ni)
vj = self.nu(nj)
z_int = lambda z: np.exp(-1*z)*sp.eval_laguerre(ki,z)*sp.eval_laguerre(kj,z)*z**2
t_int = lambda t: sp.lpmv(mi,vi,np.cos(t))*sp.lpmv(mj,vj,np.cos(t))*np.sin(t)
p_int = lambda p: self.Az(vi,mi,p)*self.Az(vj,mj,p)
Iz = scipy.integrate.quad(z_int, 0., self.max_z_int)
It = scipy.integrate.quad(t_int, 0., self.cap_lim)
Ip = scipy.integrate.quad(p_int, 0., 2*np.pi)
P = Iz[0]*It[0]*Ip[0]
return P
def basis(self, gdlat, gdlon, gdalt):
"""
Calculates a matrix of the basis functions evaluated at all input points
Parameters:
R: [ndarray(3,npoints)]
array of input coordinates
R = [[z coordinates (m)],[theta coordinates (rad)],[phi coordinates (rad)]]
if input points are expressed as a list of r,t,p points, eg. points = [[r1,t1,p1],[r2,t2,p2],...], R = np.array(points).T
Returns:
A: [ndarray(npoints,nbasis)]
array of basis functions evaluated at all input points
Notes:
- Something clever could probably be done to not recalculate the full expression when incrimenting n does not result in a change in k, or similar.
All the evaluations of special functions here make it one of the slowest parts of the code.
"""
z, theta, phi = self.transform_coord(gdlat.flatten(), gdlon.flatten(), gdalt.flatten())
A = []
for n in range(self.nbasis):
k, l, m = self.basis_numbers(n)
v = self.nu(n)
A.append(np.exp(-0.5*z)*sp.eval_laguerre(k,z)*self.Az(v,m,phi)*sp.lpmv(m,v,np.cos(theta)))
nax = list(np.arange(gdlat.ndim)+1)
nax.append(0)
A0 = np.transpose(np.array(A).reshape((-1,)+gdlat.shape), axes=nax)
return A0
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)
v = eval_laguerre(i, x, out=output_array)
X = x[:, np.newaxis]
if k == 1:
D = np.zeros((self.N, self.N))
D[:-1, :] = lag.lagder(np.eye(self.N), 1)
V = np.dot(v, D)
V -= 0.5 * v
V *= np.exp(-X / 2)
v[:] = V
elif k == 2:
D = np.zeros((self.N, self.N))
D[:-2, :] = lag.lagder(np.eye(self.N), 2)
D[:-1, :] -= lag.lagder(np.eye(self.N), 1)
V = np.dot(v, D)
V += 0.25 * v
V *= np.exp(-X / 2)
v[:] = V
elif k == 0:
v *= np.exp(-X / 2)
else:
raise NotImplementedError
return v
def tau_i(self, n, reg_func):
k, l, m = self.basis_numbers(n)
v = self.nu(n)
z_int = lambda z: np.exp(-0.5*z)*sp.eval_laguerre(k,z)*reg_func(z)*z**2
t_int = lambda t: sp.lpmv(m,v,np.cos(t))*np.sin(t)
p_int = lambda p: self.Az(v,m,p)
Iz = scipy.integrate.quad(z_int, 0., self.max_z_int)
It = scipy.integrate.quad(t_int, 0., self.cap_lim)
Ip = scipy.integrate.quad(p_int, 0., 2*np.pi)
T = Iz[0]*It[0]*Ip[0]
return T
def min_first_two_moments(param):
v = param[0]
sigma = param[1]
k = v**2 / (2 * sigma**2)
a = np.sqrt(np.pi / 2)
moments = np.zeros(2, dtype=float)
moments[0] = sigma * a * eval_laguerre(1 / 2, -k)
moments[1] = 2 * sigma**2 + v**2
sample_moments = [raw_moment(data, moment=i + 1) for i in range(2)]
cost = (np.sum(moments) - np.sum(sample_moments))**2
return cost
def sphprod_gauss(n):
'''
Spherical product Gauss rule:
A rule of order 2*n-1 making use of the separation of variables in
polar coordinates. If n is even, it uses n**2 points, lying on n/2
regular 2n-gons; if n is odd, it uses n**2 - n + 1 points, with
n*(n-1) of them lying on (n-1)/2 regular 2n-gons and one lying at
the origin.
'''
theta = np.linspace(-(1 - 1 / (2 * n)) * pi, (1 - 1 / (2 * n)) * pi, 2 * n)
theta_weights = np.full(2 * n, pi / n)
if n % 2 == 1:
rsquared = ray.gauss_genlaguerre(n // 2, 1)[0]
r = sqrt(rsquared)
even_orders = np.arange(0, (n + 1) // 2)
rsquared = np.concatenate((np.zeros(1), rsquared))
rsquared = rsquared[:, np.newaxis]
evens = special.eval_laguerre(even_orders, rsquared)**2
evens = np.sum(evens, axis=1)
odd_orders = np.arange(0, (n - 1) // 2)
odds = special.eval_genlaguerre(odd_orders, 1, rsquared)**2
odds = np.sum(rsquared / (odd_orders + 1) * odds, axis=1)
r_weights = 1 / (evens + odds)
x_nodes = np.tile(r, 2 * n) * np.repeat(cos(theta), n // 2)
x_nodes = np.concatenate((np.zeros(1), x_nodes))
y_nodes = np.tile(r, 2 * n) * np.repeat(sin(theta), n // 2)
y_nodes = np.concatenate((np.zeros(1), y_nodes))
weights = np.tile(r_weights[1:], 2 * n) * np.repeat(
theta_weights, n // 2)
weights = np.concatenate((pi * r_weights[0:1], weights))
else:
rsquared, rsquared_weights = ray.gauss_laguerre(n // 2)
r = sqrt(rsquared)
r_weights = rsquared_weights / 2
x_nodes = np.tile(r, 2 * n) * np.repeat(cos(theta), n // 2)
y_nodes = np.tile(r, 2 * n) * np.repeat(sin(theta), n // 2)
weights = np.tile(r_weights, 2 * n) * np.repeat(theta_weights, n // 2)
return (x_nodes, y_nodes), weights
def grad_basis(self, gdlat, gdlon, gdalt):
"""
Calculates a matrix of the gradient of basis functions evaluated at all input points
Parameters:
R: [ndarray(3,npoints)]
array of input coordinates
R = [[z coordinates (m)],[theta coordinates (rad)],[phi coordinates (rad)]]
if input points are expressed as a list of r,t,p points, eg. points = [[r1,t1,p1],[r2,t2,p2],...], R = np.array(points).T
Returns:
A: [ndarray(npoints,nbasis,3)]
array of gradient of basis functions evaluated at all input points
Notes:
- Something clever could probably be done to not recalculate the full expression when incrimenting n does not result in a change in k, or similar.
All the evaluations of special functions here make it one of the slowest parts of the code.
"""
z, theta, phi = self.transform_coord(gdlat, gdlon, gdalt)
Ag = []
x = np.cos(theta)
y = np.sin(theta)
e = np.exp(-0.5*z)
for n in range(self.nbasis):
k, l, m = self.basis_numbers(n)
v = self.nu(n)
L0 = sp.eval_laguerre(k,z)
L1 = sp.eval_genlaguerre(k-1,1,z)
Pmv = sp.lpmv(m,v,x)
Pmv1 = sp.lpmv(m,v+1,x)
A = self.Az(v,m,phi)
zhat = -0.5*e*(L0+2*L1)*Pmv*A*100./RE
that = e*L0*(-(v+1)*x*Pmv+(v-m+1)*Pmv1)*A/(y*(z/100.+1)*RE)
phat = e*L0*Pmv*self.dAz(v,m,phi)/(y*(z/100.+1)*RE)
Ag.append([zhat,that,phat])
# print np.shape(np.array(Ag).T)
return np.array(Ag).T
def eval_laguerre_dd(n, x):
return eval_laguerre(n.astype('d'), x)
def eval_laguerre_ld(n, x):
return eval_laguerre(n.astype('l'), x)
def mesanalag(x, y):
return spec.eval_laguerre(p1, x + 200) * spec.eval_laguerre(
p2, y + 200)
def lag(x):
return spec.eval_laguerre(p, x + 200)
def H_approx_Par(phi):
H = -np.exp(-phi**2 / 2) * sum(
eval_laguerre(n, phi**2) * qt.fock_dm(NFock, n) for n in range(NFock))
return H
def fit(x, M, test=False):
"""
Find corrected parameters for flow distribution `x` with multiplicity `M`.
Returns various parameters depending on the test option.
The likelihood function of a Rice distribution often has two local maxima
with different signal-to-noise ratios (SNR):
-- high-SNR: (A, s) both finite
-- low-SNR: (epsilon, s1) with epsilon nearly zero and s1 > s
In the context of flow distributions, the high-SNR case corresponds to
systematically driven flow (e.g. peripheral v_2) and the low-SNR case means
fluctuation-only (e.g. central v_2).
Finite multiplicity smearing reduces the SNR and makes it difficult to
distinguish the two cases.
The following prescription seems to work in nearly all cases:
-- perform the high-SNR fit
-- if the distribution is "noisy", also do the low-SNR fit
-- compare the likelihoods of the two fits
-- if they are very close, choose low-SNR
When the likelihoods are similar, the low-SNR option tends to provide more
sensible results after finite-multiplicity correction.
The "noisy" criterion is based on the following observations
-- The signal (Rice `A` parameter) cannot be reliably measured below
the multiplicity flutuation 1/sqrt(M).
-- SNR cannot be reliably determined below ~1.
A distribution is "noisy" if the signal and SNR are small.
Even in the noisy case, the multiplicity fluctuation can still be as large
as the observed distribution. This means effectively zero flow was
observed within statistical error. In this case, flow is reverted to a
reasonable minimum.
"""
# estimate parameters using sample moments
# sigma ~ standard deviation
# mu_2 = A^2 + 2*sigma^2
s0 = x.std()
A0 = max(np.square(x).mean()-2.*s0*s0, 0.)**.5
x0 = np.array((A0, s0))
# high-SNR fit
res = _fit(x, x0)
A, s = res.x
# check if this is a "noisy" distribution
if A < M**(-.5) and A/s < 1.2:
# low-SNR fit
s1 = (s**2. + .5*A**2.)**.5
res1 = _fit(x, (1e-3, s1))
ll = res.fun
ll1 = res1.fun
# choose low-SNR if the two likelihoods are very close
if abs((ll-ll1)/ll) < 5.e-3:
res = res1
# extract flow dist. params
vnrp, dvnobs = res.x
# correct for finite multiplicity
# revert to a sensible minimum in the zero-flow scenario
dvn2 = dvnobs*dvnobs - .5/M
if dvn2 < 0:
dvn2 = 1.e-5
vnrp = 0.
dvn = dvn2**.5
vnrp2 = vnrp * vnrp
# calculate mean and width
mean = (.5*np.pi)**.5 * dvn * spc.eval_laguerre(.5, -.5*vnrp2/dvn2)
if np.isnan(mean):
mean = vnrp + .5*dvn2/vnrp
width = np.sqrt(2.*dvn2 + vnrp2 - mean*mean)
if test:
return vnrp, dvnobs, dvn, mean, width
else:
return mean, width
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Apr 25 21:59:55 2019
@author: gustavo
"""
import numpy as np
import matplotlib.pyplot as plt
from scipy.special import eval_laguerre
x = np.linspace(0, 5, 200)
for i in range(6):
plt.plot(x, eval_laguerre(i, x), color='k')
plt.title('Polinomios de Laguerre $L_{n}(x)$')
plt.text(1, 1.2, '$L_{0}$')
plt.text(3, -1.8, '$L_{1}$')
plt.text(3.2, -0.8, '$L_{2}$')
plt.text(4, 2.7, '$L_{3}$')
plt.text(4.5, 0.4, '$L_{4}$')
plt.text(4.2, -1.2, '$L_{5}$')
plt.axhline(y=0, lw=0.8, ls='dashed', color='k')
plt.xlim(0, 5)
#plt.ylim(-5, 5)
plt.show()
def eval_laguerre_ld(n, x):
return eval_laguerre(n.astype('l'), x)
def testFunctions():
print(colored('Testing Polynomial functions', 'magenta'))
ORDER_MAX = 5
DECIMALS_ROUND = 7
print(colored('Testing chebyshev_t_Scaler', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
x = np.random.rand(1).item()
valuePy = sp.eval_chebyt(order, x)
valueCpp = NumCpp.chebyshev_t_Scaler(order, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing chebyshev_t_Array', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
shapeInput = np.random.randint(10, 100, [
2,
], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_chebyt(order, x)
valueCpp = NumCpp.chebyshev_t_Array(order, cArray)
if not np.array_equal(np.round(valuePy, DECIMALS_ROUND),
np.round(valueCpp, DECIMALS_ROUND)):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored('Testing chebyshev_u_Scaler', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
x = np.random.rand(1).item()
valuePy = sp.eval_chebyu(order, x)
valueCpp = NumCpp.chebyshev_u_Scaler(order, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing chebyshev_u_Array', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
shapeInput = np.random.randint(10, 100, [
2,
], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_chebyu(order, x)
valueCpp = NumCpp.chebyshev_u_Array(order, cArray)
if not np.array_equal(np.round(valuePy, DECIMALS_ROUND),
np.round(valueCpp, DECIMALS_ROUND)):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored('Testing hermite_Scaler', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
x = np.random.rand(1).item()
valuePy = sp.eval_hermite(order, x)
valueCpp = NumCpp.hermite_Scaler(order, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing hermite_Array', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
shapeInput = np.random.randint(10, 100, [
2,
], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_hermite(order, x)
valueCpp = NumCpp.hermite_Array(order, cArray)
if not np.array_equal(np.round(valuePy, DECIMALS_ROUND),
np.round(valueCpp, DECIMALS_ROUND)):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored('Testing laguerre_Scaler1', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
x = np.random.rand(1).item()
valuePy = sp.eval_laguerre(order, x)
valueCpp = NumCpp.laguerre_Scaler1(order, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing laguerre_Array1', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
shapeInput = np.random.randint(10, 100, [
2,
], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_laguerre(order, x)
valueCpp = NumCpp.laguerre_Array1(order, cArray)
if not np.array_equal(np.round(valuePy, DECIMALS_ROUND),
np.round(valueCpp, DECIMALS_ROUND)):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored('Testing laguerre_Scaler2', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
degree = np.random.randint(0, 10, [
1,
]).item()
x = np.random.rand(1).item()
valuePy = sp.eval_genlaguerre(degree, order, x)
valueCpp = NumCpp.laguerre_Scaler2(order, degree, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing laguerre_Array2', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
degree = np.random.randint(0, 10, [
1,
]).item()
shapeInput = np.random.randint(10, 100, [
2,
], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_genlaguerre(degree, order, x)
valueCpp = NumCpp.laguerre_Array2(order, degree, cArray)
if not np.array_equal(np.round(valuePy, DECIMALS_ROUND),
np.round(valueCpp, DECIMALS_ROUND)):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored('Testing legendre_p_Scaler1', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
x = np.random.rand(1).item()
valuePy = sp.eval_legendre(order, x)
valueCpp = NumCpp.legendre_p_Scaler1(order, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing legendre_p_Array1', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
shapeInput = np.random.randint(10, 100, [
2,
], dtype=np.uint32)
shape = NumCpp.Shape(*shapeInput)
cArray = NumCpp.NdArray(shape)
x = np.random.rand(*shapeInput)
cArray.setArray(x)
valuePy = sp.eval_legendre(order, x)
valueCpp = NumCpp.legendre_p_Array1(order, cArray)
if not np.array_equal(np.round(valuePy, DECIMALS_ROUND),
np.round(valueCpp, DECIMALS_ROUND)):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(colored('Testing legendre_p_Scaler2', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
x = np.random.rand(1).item()
degree = np.random.randint(order, ORDER_MAX)
valuePy = sp.lpmn(order, degree, x)[0][order, degree]
valueCpp = NumCpp.legendre_p_Scaler2(order, degree, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing legendre_q_Scaler', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
x = np.random.rand(1).item()
valuePy = sp.lqn(order, x)[0][order]
valueCpp = NumCpp.legendre_q_Scaler(order, x)
if np.round(valuePy, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing spherical_harmonic', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
degree = np.random.randint(order, ORDER_MAX)
theta = np.random.rand(1).item() * np.pi * 2
phi = np.random.rand(1).item() * np.pi
valuePy = sp.sph_harm(order, degree, theta, phi)
valueCpp = NumCpp.spherical_harmonic(order, degree, theta, phi)
if (np.round(valuePy.real, DECIMALS_ROUND) != np.round(
valueCpp[0], DECIMALS_ROUND)
or np.round(valuePy.imag, DECIMALS_ROUND) != np.round(
valueCpp[1], DECIMALS_ROUND)):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing spherical_harmonic_r', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
degree = np.random.randint(order, ORDER_MAX)
theta = np.random.rand(1).item() * np.pi * 2
phi = np.random.rand(1).item() * np.pi
valuePy = sp.sph_harm(order, degree, theta, phi)
valueCpp = NumCpp.spherical_harmonic_r(order, degree, theta, phi)
if np.round(valuePy.real, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
print(colored('Testing spherical_harmonic_i', 'cyan'))
allTrue = True
for order in range(ORDER_MAX):
degree = np.random.randint(order, ORDER_MAX)
theta = np.random.rand(1).item() * np.pi * 2
phi = np.random.rand(1).item() * np.pi
valuePy = sp.sph_harm(order, degree, theta, phi)
valueCpp = NumCpp.spherical_harmonic_i(order, degree, theta, phi)
if np.round(valuePy.imag, DECIMALS_ROUND) != np.round(
valueCpp, DECIMALS_ROUND):
allTrue = False
if allTrue:
print(colored('\tPASS', 'green'))
else:
print(colored('\tFAIL', 'red'))
print(f'valuePy = {valuePy}, valueCpp = {valueCpp}')
def R3(r):
#return( 0.5*((2*z*r/(n*a0))**2 - 4*(2*z*r/(n*a0)) + 2) )
return (eval_laguerre(n + l, 2 * z * r / (n * a0)))
def eval_laguerre_dd(n, x):
return eval_laguerre(n.astype('d'), x)
def L(N, x): #eval laguerre function
a = eval_laguerre(N, x)
return a
