def cheb_sum(x): s = p0()*SP.eval_chebyt(0,x) +\ p1()*SP.eval_chebyt(1,x) +\ p2()*SP.eval_chebyt(2,x) +\ p3()*SP.eval_chebyt(3,x) +\ p4()*SP.eval_chebyt(4,x) return s
def cheb_one_pressure(alpha, tlim, plim, temps, pressure): """ Calculates T,P-dependent rate constants [k(T,P)]s using a Chebyshev functional expression, at a given pressure, across several temperatures. """ tmin, tmax = tlim pmin, pmax = plim alpha_nrows, alpha_ncols = alpha.shape ktps = np.zeros(len(temps)) for i, temp in enumerate(temps): ctemp = ((2.0 * temp**(-1) - tmin**(-1) - tmax**(-1)) / (tmax**(-1) - tmin**(-1))) cpress = ( (2.0 * np.log10(pressure) - np.log10(pmin) - np.log10(pmax)) / (np.log10(pmax) - np.log10(pmin))) logktp = 0.0 for j in range(alpha_nrows): for k in range(alpha_ncols): logktp += (alpha[j][k] * eval_chebyt(j, ctemp) * eval_chebyt(k, cpress)) ktps[i] = 10**(logktp) return ktps
def cheby_band(w, w1, w2, N, ripple=1, scale=0.95): """ Simple Chebyshev Type I bandpass filter function in wavelength space. Parameters ---------- w : astropy.units.Quantity Wavelength w1 : astropy.units.Quantity Wavelength of short wavelength edge of bandpass w2 : astropy.units.Quantity Wavelength of long wavelength edge of bandpass N : int Order of the Chebyshev function ripple : float, optional Scaling to apply to the ripple of the Chebyshev function, default 1.0 scale : float, optional Scaling to apply to the transmission of the Chebyshev function, default 0.95 Returns ------- transmission : astropy.units.Quantity Filter transmission at wavelength `w`. """ # Bandpass implemented as low pass and high pass in series w = ensure_unit(w, u.nm) g1 = 1 / np.sqrt(1 + ripple**2 * eval_chebyt(N, (w1/w).to(u.dimensionless_unscaled).value)**2) g2 = 1 / np.sqrt(1 + ripple**2 * eval_chebyt(N, (w/w2).to(u.dimensionless_unscaled).value)**2) return scale * g1 * g2
def Em_cheb_der(x): s = np.sign(cheb_sum(x)) return 2.*s*np.array([\ SP.eval_chebyt(0,x) ,\ SP.eval_chebyt(1,x) ,\ SP.eval_chebyt(2,x) ,\ SP.eval_chebyt(3,x) ,\ SP.eval_chebyt(4,x) ])
def test_chebyshev(): 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 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_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 assert allTrue 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 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_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 assert allTrue
def cheby_band(w, w1, w2, N, ripple=1, peak=0.95): """ Simple Chebyshev Type I bandpass filter function in wavelength space To be more realistic this should definitely include cone angle effect but at f/5.34 (Space Eye focal ratio) that is pretty insignficant """ # Bandpass implemented as low pass and high pass in series g1 = 1 / np.sqrt(1 + ripple**2 * eval_chebyt(N, ( w1 / w).to(u.dimensionless_unscaled).value)**2) g2 = 1 / np.sqrt(1 + ripple**2 * eval_chebyt(N, ( w / w2).to(u.dimensionless_unscaled).value)**2) return peak * g1 * g2
def chebyshev_one_pressure(alpha, tmin, tmax, pmin, pmax, temps, pressure): """ Calculates T,P-dependent rate constants [k(T,P)]s using a Chebyshev functional expression, at a given pressure, across several temperatures. :param alpha: Chebyshev coefficient matrix :type alpha: numpy.ndarray :param tmin: minimum temperature Chebyshev model is defined :type tmin: float :param tmax: maximum temperature Chebyshev model is defined :type tmax: float :param pmin: minimum pressure Chebyshev model is defined :type pmin: float :param pmax: maximum pressure Chebyshev model is defined :type pmax: float :param temps: Temps used to calculate high- and low-k(T)s :type temps: numpy.ndarray :param pressure: Pressure used to calculate k(T,P)s :type pressure: float :return ktps: Set of k(T,P)s at given pressure :rtype numpy.ndarray """ alpha_nrows, alpha_ncols = alpha.shape ktps = np.zeros(len(temps)) for i, temp in enumerate(temps): ctemp = ( (2.0 * 1/temp - 1/tmin - 1/tmax) / (1/tmax - 1/tmin) ) cpress = ( (2.0 * np.log10(pressure) - np.log10(pmin) - np.log10(pmax)) / (np.log10(pmax) - np.log10(pmin)) ) logktp = 0.0 for j in range(alpha_nrows): for k in range(alpha_ncols): logktp += ( alpha[j][k] * eval_chebyt(j, ctemp) * eval_chebyt(k, cpress) ) ktps[i] = 10**(logktp) return ktps
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[:] = np.cos(i*np.arccos(x)) output_array[:] = eval_chebyt(i, x) return output_array
def test_chebyshev_matrices(self): # test that it works on matrices too key = jax.random.PRNGKey(0) xx = jax.random.normal(key, shape=(5, 10)) for i in range(10): poly0 = chebyshev.eval_chebyt(i, xx) poly1 = special.eval_chebyt(i, xx) np.testing.assert_allclose(poly0, poly1, rtol=1E-4)
def test_chebyshev(): if NumCpp.NO_USE_BOOST: return 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) 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_chebyt(order, x) valueCpp = NumCpp.chebyshev_t_Array(order, cArray) assert np.array_equal(np.round(valuePy, DECIMALS_ROUND), np.round(valueCpp, DECIMALS_ROUND)) 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) 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_chebyu(order, x) valueCpp = NumCpp.chebyshev_u_Array(order, cArray) assert np.array_equal(np.round(valuePy, DECIMALS_ROUND), np.round(valueCpp, DECIMALS_ROUND))
def evaluate(cheby1d, x): """ チェビシェフ辞書にxの値を代入した結果を評価する. 引数: cheby1d 評価対象のチェビシェフ辞書. x xの値.floatを想定(多分sympy値でも動く). 返り値: floatまたはsympy値型の評価結果. """ return sum(eval_chebyt(i, x) * v for i, v in cheby1d.items())
def approx_weights(self): """ Returns the weights of the Chebyshev regression using Chebyshev polynomials up to 'order'. Number of approximation nodes = gridsize. Returns an array of order + 1 floats. """ theta = np.zeros(self.order + 1) theta[0] = np.mean(self.func_vals) for j in range(1, self.order + 1): tj = eval_chebyt(j, self.roots) theta[j] = (2.0 / self.gridsize) * np.sum(tj * self.func_vals) return theta
def chebyshev_basis_2D(x, y, n): a = np.array([]) b = np.array([]) for i in range(n + 1): for j in range(n + 1): if (i + j) < (n + 1): a = np.append(a, i) b = np.append(b, j) A = np.zeros((len(x), len(a))) xx = x.copy() - x.min() xx /= xx.max() / 2 xx -= 1 yy = y.copy() - y.min() yy /= yy.max() / 2 yy -= 1 for i in range(len(a)): A[:, i] = special.eval_chebyt(a[i], xx) * special.eval_chebyt(b[i], yy) return A
def __call__(self, eval_grid): """ Evaluate the approximation at the points in array eval_grid. Returns an array of floats. """ z_vec = self.to_regular(eval_grid) j = np.array(range(self.order + 1), dtype=int) K = len(z_vec) vals = np.empty(K) for k in range(K): y = np.sum(self.theta * eval_chebyt(j, z_vec[k])) vals[k] = y return np.array(vals)
def chebyshev_rate_constants(temps, pressure, alpha, tmin, tmax, pmin, pmax): """ computes the rate constants using the chebyshev polynomials """ alpha_nrows, alpha_ncols = alpha.shape ktps = np.zeros(len(temps)) for i, temp in enumerate(temps): ctemp = ((2.0 * temp**(-1) - tmin**(-1) - tmax**(-1)) / (tmax**(-1) - tmin**(-1))) cpress = ( (2.0 * np.log10(pressure) - np.log10(pmin) - np.log10(pmax)) / (np.log10(pmax) - np.log10(pmin))) logktp = 0.0 for j in range(alpha_nrows): for k in range(alpha_ncols): logktp += (alpha[j][k] * eval_chebyt(j, ctemp) * eval_chebyt(k, cpress)) ktps[i] = 10**(logktp) return ktps
def value_at_a_point(x, An): """Evaluates a spectral function at a given spectral point given the value of the Spectral Coordinate and the set of Spectral Coefficients of the Function.""" # Estimating the Number of Spectral Coefficients/Collocation Points: N = An.size - 1 # Initializing the value value_at_point = 0.0 # Adding the contribution of each Spectral Mode: for ns in range(0, N + 1): # Value of the n-th Chebyshev Polynomial at the given spectral coordinate: T_nn_x = special.eval_chebyt(ns, x) value_at_point += An[ns] * T_nn_x return value_at_point
def _eval_numpy_(self, n, x): """ Evaluate ``self`` using numpy. EXAMPLES:: sage: import numpy sage: z = numpy.array([1,2]) sage: z2 = numpy.array([[1,2],[1,2]]) sage: z3 = numpy.array([1,2,3.]) sage: chebyshev_T(1,z) array([ 1., 2.]) sage: chebyshev_T(1,z2) array([[ 1., 2.], [ 1., 2.]]) sage: chebyshev_T(1,z3) array([ 1., 2., 3.]) sage: chebyshev_T(z,0.1) array([ 0.1 , -0.98]) """ from scipy.special import eval_chebyt return eval_chebyt(n, x)
def eval_basis(ind, x): result = 1 for i in range(self.dim): coord = (x[i] - self.center[i]) / (self.h / 2) result *= eval_chebyt(ind[i], coord) return result
def ceb2(x): return spec.eval_chebyt(p, x / 95)
def approx_integral(i): """ Approximates the integral by taking the mean value of n sample points """ return sum(eval_chebyt(i, 2. * xj - 1.) for xj in x) / n
def T(j,u,N,x1,x2): m = get_slope_intercept(x1,x2)[0] b = get_slope_intercept(x1,x2)[1] return eval_chebyt(j,m*u+b)
q1 = q2 q2 = q3 moments = np.mean(G, axis=0) inputs = np.insert(moments, 0, 1) pickle.dump(inputs, open('chebyshevmoments' + str(K), "wb")) #% compute Chebyshev polynomial x = np.linspace(gmin, gmax, gridlength) v = np.diff(x) v = np.append(v, 0) n = len(inputs) chebarray = np.zeros((n, int(gridlength))) for i1 in range(0, n): q = (special.eval_chebyt(i1, x, out=None)) chebarray[i1, :] = q typec = 'chebyshev' #% MaxEnt Algorithm entr = [] momnum = [] sharpness = (1e-3) #% store datas #Y = np.zeros((m,int(gridlength))) MaxEntdistri = np.zeros((m, int(gridlength))) MaxEntCoefficient = [] Xbound = np.zeros(m) Prediction = np.zeros(m)
def cons(alpha): j = 1 + np.dot(alpha, chebarray[:-(n - m)]) q = np.exp(-j) u = sum(q * ((special.eval_chebyt(alpha, x, out=None))) * v) return u
def eval_basis(ind, x): result = 1 for i in range(self.dim): coord = (x[i] - self.center[i])/(self.h/2) result *= eval_chebyt(ind[i], coord) return result
# -*- coding: utf-8 -*- import os import scipy from scipy.special import airy, jn, eval_chebyt, eval_legendre subplot(2, 2, 3) x = linspace(-1, 1) for i in range(6): plot(x, eval_chebyt(i, x)) title("Chebyshev polynomials of the first kind") os.system("pause")
def test_chebyt_int(self): assert_mpmath_equal(lambda n, x: sc.eval_chebyt(int(n), x), _exception_to_nan(lambda n, x: mpmath.chebyt(n, x, **HYPERKW)), [IntArg(), Arg()], n=2000)
def mesanaceb(x, y): return spec.eval_chebyt(p1, x / 200) * spec.eval_chebyt(p2, y / 200)
def kfit(temps, ktp_dct, tdeg=6, pdeg=4, a_conv_factor=1): """ Fits T,P-dependent rate constants [k(T,P)]s to a a Chebyshev functional expression. :param alpha: Chebyshev coefficient matrix :type alpha: np.ndarray :param tdeg: degree of the temp component of Chebyshev polynomial :type tdeg: int :param pdeg: degree of the pressure component of Chebyshev polynomial :type pdeg: int :param temps: Temps used to calculate high- and low-k(T)s :type temps: np.ndarray :param pressure: Pressure used to calculate k(T,P)s :type pressure: float :return alpha: alpha fitting coefficients :rtype np.ndarray """ # Get the pressures from the ktp_dct pressures = tuple(pressure for pressure in ktp_dct.keys() if pressure != 'high') # Determine the number and range of temperatures and pressures tnum, pnum = len(temps), len(pressures) tmin, tmax = min(temps), max(temps) pmin, pmax = min(pressures), max(pressures) # Calculate the reduced temperatures and pressures tred = [] for temp in temps: tred.append( (2.0 * temp**(-1) - tmin**(-1) - tmax**(-1)) / (tmax**(-1) - tmin**(-1)) ) pred = [] for pressure in pressures: pred.append( (2.0 * np.log10(pressure) - np.log10(pmin) - np.log10(pmax)) / (np.log10(pmax) - np.log10(pmin)) ) # Build a numpy array for the fits ktps = conv_dct_to_array(ktp_dct, temps, a_conv_factor=a_conv_factor) # Create matrices for fits A = np.zeros((tnum * pnum, tdeg * pdeg), np.float64) b = np.zeros((tnum * pnum), np.float64) nzero = 0 for t1, T in enumerate(tred): for p1, P in enumerate(pred): for t2 in range(tdeg): for p2 in range(pdeg): idx1, idx2 = (p1 * tnum + t1), (p2 * tdeg + t2) A[idx1, idx2] = eval_chebyt(t2, T) * eval_chebyt(p2, P) if ktps[t1, p1] is not None: b[idx1] = np.log10(ktps[t1, p1]) else: b[idx1] = None nzero += 1 nnonzero = tnum * pnum - nzero idxp = -1 Ap = np.zeros((nnonzero, tdeg * pdeg), np.float64) bp = np.zeros((nnonzero), np.float64) for idx in range(tnum*pnum): if not np.isnan(b[idx]): idxp += 1 bp[idxp] = b[idx] for idx2 in range(tdeg*pdeg): Ap[idxp,idx2] = A[idx,idx2] # Perform least-squares fit to get alpha coefficients theta = np.linalg.lstsq(Ap, bp, rcond=RCOND)[0] alpha = np.zeros((tdeg, pdeg), np.float64) for t2 in range(tdeg): for p2 in range(pdeg): alpha[t2, p2] = theta[p2 * tdeg + t2] return alpha, (tmin, tmax), (pmin, pmax)
def test_chebyt_int(self): assert_mpmath_equal( lambda n, x: sc.eval_chebyt(int(n), x), _exception_to_nan(lambda n, x: mpmath.chebyt(n, x, **HYPERKW)), [IntArg(), Arg()], n=2000)
def test_chebyshev(self): xx = jnp.linspace(-5, 5) for i in range(10): poly0 = chebyshev.eval_chebyt(i, xx) poly1 = special.eval_chebyt(i, xx) np.testing.assert_allclose(poly0, poly1, rtol=1E-5)
def ceb(x): return spec.eval_chebyt(p, x / 200)
svdo[i] = np.array([(tov[i]) * 0.0010000] * nlat) svd[i] = np.array([(sv.speed[i]) * 0.0010000] * nlat) svpo = [svdo[0]] svp = [svd[0]] for i in range(1, ndep): svpo = np.append(svpo, [svdo[i]], axis=0) svp = np.append(svp, [svd[i]], axis=0) o0 = np.array([svpo] * nlon) a0 = np.array([svp] * nlon) ########## com model svp = [[] for s in range(nlon)] chet = np.arange(o_chet + 1, dtype=float) for s in range(nlon): achet = 0 for c in range(o_chet + 1): chet[c] = eval_chebyt(c, (s - slon) / slon) achet = c_chet[c] * chet[c] + achet achet = achet / d_chet svc = [[] for i in range(ndep)] for i in range(0, m_s_dp[0]): svc[i] = np.array([m_s_km[0] * 0.001 * 0.1 * 0.5 * achet] * nlat) # svc[i] = np.array([m_s_km[0]*0.001*0.1*(1./float(2*slon))*float(s-slon)] * nlat) for i in range(m_s_dp[0], m_s_dp[1]): svc[i] = np.array([m_s_km[1] * 0.001 * 0.1 * 0.5 * achet] * nlat) # svc[i] = np.array([m_s_km[1]*0.001*0.1*(1./float(2*slon))*float(s-slon)] * nlat) for i in range(m_s_dp[1], ndep): svc[i] = np.array([m_s_km[2] * 0.001 * 0.1 * 0.5 * achet] * nlat) # svc[i] = np.array([m_s_km[2]*0.001*0.1*(1./float(2*slon))*float(s-slon)] * nlat) svp[s] = [svc[0]] for i in range(1, ndep): svp[s] = np.append(svp[s], [svc[i]], axis=0)
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 reaction(ktp_dct, temps, tdeg=6, pdeg=4, a_conv_factor=1.0): """ Fits T,P-dependent rate constants [k(T,P)]s to a a Chebyshev functional expression. :param ktp_dct: k(T,P)s :type ktp_dct: k(T,P) dictionary :param temps: Temps used to calculate high- and low-k(T)s :type temps: np.ndarray :param tdeg: degree of the temp component of Chebyshev polynomial :type tdeg: int :param pdeg: degree of the pressure component of Chebyshev polynomial :type pdeg: int :rtype: (np.ndarray, tuple(float), tuple(float)) """ # Get the pressures from the ktp_dct pressures = tuple(pressure for pressure in ktp_dct.keys() if pressure != 'high') # Determine the number and range of temperatures and pressures tnum, pnum = len(temps), len(pressures) tmin, tmax = min(temps), max(temps) pmin, pmax = min(pressures), max(pressures) # Calculate the reduced temperatures and pressures tred = [] for temp in temps: tred.append( (2.0 * temp**(-1) - tmin**(-1) - tmax**(-1)) / (tmax**(-1) - tmin**(-1)) ) pred = [] for pressure in pressures: pred.append( (2.0 * np.log10(pressure) - np.log10(pmin) - np.log10(pmax)) / (np.log10(pmax) - np.log10(pmin)) ) # Build a numpy array for the fits ktps = conv_dct_to_array(ktp_dct, temps, a_conv_factor=a_conv_factor) # Create matrices for fits amat = np.zeros((tnum * pnum, tdeg * pdeg), np.float64) bvec = np.zeros((tnum * pnum), np.float64) nzero = 0 for tidx1, temp in enumerate(tred): for pidx1, press in enumerate(pred): for tidx2 in range(tdeg): for pidx2 in range(pdeg): idx1 = (pidx1 * tnum + tidx1) idx2 = (pidx2 * tdeg + tidx2) amat[idx1, idx2] = ( eval_chebyt(tidx2, temp) * eval_chebyt(pidx2, press) ) if ktps[tidx1, pidx1] is not None: bvec[idx1] = np.log10(ktps[tidx1, pidx1]) else: bvec[idx1] = None nzero += 1 nnonzero = tnum * pnum - nzero idxp = -1 amatp = np.zeros((nnonzero, tdeg * pdeg), np.float64) bvecp = np.zeros((nnonzero), np.float64) for idx in range(tnum*pnum): if not np.isnan(bvec[idx]): idxp += 1 bvecp[idxp] = bvec[idx] for idx2 in range(tdeg*pdeg): amatp[idxp, idx2] = amat[idx, idx2] # Perform least-squares fit to get alpha coefficients theta = np.linalg.lstsq(amatp, bvecp, rcond=RCOND)[0] alpha = np.zeros((tdeg, pdeg), np.float64) for tidx2 in range(tdeg): for pidx2 in range(pdeg): alpha[tidx2, pidx2] = theta[pidx2 * tdeg + tidx2] return alpha, (tmin, tmax), (pmin, pmax)
def Tn(n, x): return np.where(np.asarray(n) >= 0, eval_chebyt(n, x), 0)
import numpy as np import matplotlib.pyplot as plt from scipy.special import eval_chebyt fig = plt.figure() xvalues = np.linspace(-1, 1, 300) nmax = 5 for n in range(nmax+1): yvalues = eval_chebyt(n, xvalues) plt.plot(xvalues, yvalues) plt.title('Chebyshev polynomials $T_n(x)$ for $n=0,\\ldots,{}$'.format(nmax)) plt.axhline(0, color='gray') plt.axvline(0, color='gray') plt.xlabel('$x$') plt.ylabel('$T_n(x)$') print('Displaying graph') plt.show()