def pre_calc(self, x, y, beta, n_order, center_x, center_y): """ calculates the H_n(x) and H_n(y) for a given x-array and y-array :param x: :param y: :param amp: :param beta: :param n_order: :param center_x: :param center_y: :return: list of H_n(x) and H_n(y) """ n = len(np.atleast_1d(x)) x_ = x - center_x y_ = y - center_y H_x = np.empty((n_order+1, n)) H_y = np.empty((n_order+1, n)) for n in range(0,n_order+1): prefactor = 1./np.sqrt(2**n*np.sqrt(np.pi)*math.factorial(n)) n_array = np.zeros(n+1) n_array[n] = 1 H_x[n] = hermite.hermval(x_/beta, n_array) * prefactor * np.exp(-(x_/beta)**2/2.) H_y[n] = hermite.hermval(y_/beta, n_array) * prefactor * np.exp(-(y_/beta)**2/2.) return H_x, H_y
def d2psi(x, c): """Second derivative of psi""" from numpy.polynomial.hermite import hermval, hermder yp = hermval(x, hermder(hermder(c))) * np.exp(-x**2 / 2) yp += -x * hermval(x, hermder(c)) * np.exp(-x**2 / 2) yp += -psi(x, c) - x * dpsi(x, c) return yp
def getA(self, coords, z): # Unpack the coordinates x, px, y, py, theta, gamma = coords # Compute the Hermite-Gauss coefficients, which have some # z-dependence that requires they be computed for every time step. # This multiplies the base laser mode coefficients, and therefore # has to be created as a temporary variable to avoid modifying the # original laser parameters. This assumes a 2D laser qxz = (z - self.zWaistX) + self.qx0 xrFac = 0.5 * self.k0 / qxz xzFac = (np.sqrt(2)/self.waistX)/\ np.sqrt(1+((z-self.zWaistX)/self.zRx)**2) qyz = (z - self.zWaistY) + self.qy0 yrFac = 0.5 * self.k0 / qyz yzFac = (np.sqrt(2)/self.waistY)/\ np.sqrt(1+((z-self.zWaistY)/self.zRy)**2) # Iterate over the coefficients, computing the particle-dependent # normalization coefficients for the Hermite-Gauss series # Have to compute the Hermite-Gauss series explicitly for optimal # control -- recommend against attempting to use hermval2d ptclCoefs = copy.deepcopy(self.hermCoeffs) for nidx in range(0,self.hermCoeffs.shape[0]): for midx in range(0,self.hermCoeffs.shape[1]): ptclCoefs[nidx,midx] *= (self.piWxFac)*np.sqrt( self.qx0/qxz) ptclCoefs[nidx,midx] *= (self.qx0*qxz.conjugate()/ self.qx0.conjugate()/qxz)**(0.5*(midx)) ptclCoefs[nidx,midx] *= (self.piWyFac)*np.sqrt( self.qy0/qyz) ptclCoefs[nidx,midx] *= (self.qy0*qxz.conjugate()/ self.qy0.conjugate()/qyz)**(0.5*(nidx)) # Explicitly iterate through the particles, since this seems to be # the only way to keep control over the Hermite functions myNewCoeffs = np.zeros(self.hermCoeffs.shape[0], dtype=complex) for xidx in range(0, self.hermCoeffs.shape[0]): myNewCoeffs[xidx] = hermval(yzFac*y,ptclCoefs[xidx]) Alaser = hermval(xzFac*x, myNewCoeffs) Alaser *= np.exp(-(xrFac*(x**2)*1j)) Alaser *= np.exp(-(yrFac*(y**2)*1j)) Alaser /= self.omega*1j Alaser *= np.sqrt(np.dot(self.polVector, self.polVector)) return abs(Alaser)
def test_hermmul(self): # check values of result for i in range(5): pol1 = [0] * i + [1] val1 = herm.hermval(self.x, pol1) for j in range(5): msg = f"At i={i}, j={j}" pol2 = [0] * j + [1] val2 = herm.hermval(self.x, pol2) pol3 = herm.hermmul(pol1, pol2) val3 = herm.hermval(self.x, pol3) assert_(len(pol3) == i + j + 1, msg) assert_almost_equal(val3, val1 * val2, err_msg=msg)
def test_hermmul(self) : # check values of result for i in range(5) : pol1 = [0]*i + [1] val1 = herm.hermval(self.x, pol1) for j in range(5) : msg = "At i=%d, j=%d" % (i,j) pol2 = [0]*j + [1] val2 = herm.hermval(self.x, pol2) pol3 = herm.hermmul(pol1, pol2) val3 = herm.hermval(self.x, pol3) assert_(len(pol3) == i + j + 1, msg) assert_almost_equal(val3, val1*val2, err_msg=msg)
def test_hermmul(self): # get_inds values of result for i in range(5): pol1 = [0] * i + [1] val1 = herm.hermval(self.x, pol1) for j in range(5): msg = "At i=%d, j=%d" % (i, j) pol2 = [0] * j + [1] val2 = herm.hermval(self.x, pol2) pol3 = herm.hermmul(pol1, pol2) val3 = herm.hermval(self.x, pol3) assert_(len(pol3) == i + j + 1, msg) assert_almost_equal(val3, val1 * val2, err_msg=msg)
def forward(self, x, coef): x = self.conv1(x) x = x.detach().numpy() x = hermval(x, coef, tensor=True) x = self.pool1(torch.from_numpy(x)) x = x.float() x = self.conv2(x) x = x.detach().numpy() x = hermval(x, coef, tensor=True) x = self.pool2(torch.from_numpy(x)) x = x.view(-1, x.shape[1] * x.shape[2] * x.shape[3]) x = hermval(self.fc1(x), coef, tensor=True) x = x.float() out = self.fc2(x) return out
def harmonic_osc(x, n, omega=1.0): # Returns the n^th exited state of a 1D harmonic # oscillator evaluated at x xs = np.sqrt(omega) * x c = [1.0 if i == n else 0.0 for i in range(0, n + 1)] norm = (2**n * factorial(n))**(-0.5) * (omega / np.pi)**(0.25) return norm * np.exp(-0.5 * xs**2) * hermval(xs, c)
def eval(self, x, u, output_array=None): if output_array is None: output_array = np.zeros(x.shape) w = u*self.factor(np.arange(self.N)) y = hermite.hermval(x, w) output_array[:] = y * np.exp(-x**2/2) return output_array
def psi (alpha,eqgeom,R,state): n=state prefactor=pow(alpha/pi,0.25)/(sqrt(pow(2.0,n)*factorial(n))) coeffs=zeros(n+1,float) coeffs[n]=1.0 hermpoly=hermval(sqrt(alpha)*(R-eqgeom),coeffs) return prefactor*exp(-0.5*alpha*(R-eqgeom)**2)*hermpoly
def test_hermvander(self) : # check for 1d x x = np.arange(3) v = herm.hermvander(x, 3) assert_(v.shape == (3, 4)) for i in range(4) : coef = [0]*i + [1] assert_almost_equal(v[..., i], herm.hermval(x, coef)) # check for 2d x x = np.array([[1, 2], [3, 4], [5, 6]]) v = herm.hermvander(x, 3) assert_(v.shape == (3, 2, 4)) for i in range(4) : coef = [0]*i + [1] assert_almost_equal(v[..., i], herm.hermval(x, coef))
def test_hermitefunction(self): '''Test routines to compute using Hermite polynomials.''' from scipy.linalg import funm from numpy.polynomial.hermite import hermfit, hermval from numpy import cos, linspace, sin # Starting Matrix matrix1 = self.create_matrix(scaled=True) self.write_matrix(matrix1, self.input_file) # Function x = linspace(-1.0, 1.0, 200) y = [cos(i) + sin(i) for i in x] coef = hermfit(x, y, 10) # Check Matrix dense_check = funm(matrix1.todense(), lambda x: hermval(x, coef)) self.CheckMat = csr_matrix(dense_check) # Result Matrix input_matrix = nt.Matrix_ps(self.input_file, False) poly_matrix = nt.Matrix_ps(self.mat_dim) polynomial = nt.HermitePolynomial(len(coef)) for j in range(0, len(coef)): polynomial.SetCoefficient(j, coef[j]) permutation = nt.Permutation(input_matrix.GetLogicalDimension()) permutation.SetRandomPermutation() self.fsp.SetLoadBalance(permutation) polynomial.Compute(input_matrix, poly_matrix, self.fsp) poly_matrix.WriteToMatrixMarket(result_file) comm.barrier() self.check_result()
def squeezed_coherent_state(series_length=DEF_SERIES_LEN, alpha=1, squeezing_amp=1, squeezing_phase=0): """ Generating a squezed coherent state in a Fock basis. :param series_length: Lenght of the state. :param alpha: Coheret parameter alpha. :param squeezing_amp: Squeezing parameter amplitude. :param squeezing_phase: Squeezing parameter phase. :return: Squezed coherent state as an array. """ if series_length < 1: raise ValueError('The series length should be a positive integer') state = np.zeros(series_length, dtype=np.complex128) const = (1 / sqrt(np.cosh(squeezing_amp)) ) * cm.exp(-0.5 * abs(alpha)**2 - 0.5 * np.conj(alpha)**2 * cm.exp(1j * squeezing_phase) * np.tanh(squeezing_amp)) for n in range(series_length): herm_coeff_arr = np.zeros(series_length) herm_coeff_arr[n] = 1 gamma = alpha * np.cosh(squeezing_amp) + np.conj(alpha) * cm.exp( 1j * squeezing_phase) * np.sinh(squeezing_amp) state[n] = 1 / sqrt(factorial(n)) * const * ( 0.5 * cm.exp(1j * squeezing_phase) * np.tanh(squeezing_amp) )**(n / 2) / cm.sqrt(factorial(n)) * herm.hermval((gamma / cm.sqrt( cm.exp(1j * squeezing_phase) * np.sinh(2 * squeezing_amp))), herm_coeff_arr) return state
def kernel(self, x: np.ndarray) -> np.ndarray: """Creates convolution kernel for LOSVD. Args: x: x Array to create kernel on. Returns: Kernel on given x values. """ # get values v, sig = self._losvd[:2] herm = self._losvd[2:] # helpers t = (x - v) / sig t2 = t * t # calculate Gaussian kernel k = np.exp(-0.5 * t2) / (np.sqrt(2. * np.pi) * sig) # Hermite polynomials normalized as in Appendix A of van der Marel & # Franx (1993). They are given e.g. in Appendix C of Cappellari et al. (2002) n = np.arange(3 + len(herm)) nrm = np.sqrt(scipy.special.factorial(n) * 2**n) # normalize coefficients c = np.array([1., 0., 0.] + herm) / nrm # add hermites k *= hermite.hermval(t, c) # normalize kernel return k / np.sum(k)
def test_hermvander(self): # get_inds for 1d x x = np.arange(3) v = herm.hermvander(x, 3) assert_(v.shape == (3, 4)) for i in range(4): coef = [0] * i + [1] assert_almost_equal(v[..., i], herm.hermval(x, coef)) # get_inds for 2d x x = np.array([[1, 2], [3, 4], [5, 6]]) v = herm.hermvander(x, 3) assert_(v.shape == (3, 2, 4)) for i in range(4): coef = [0] * i + [1] assert_almost_equal(v[..., i], herm.hermval(x, coef))
def wavefunc(n, x): ns = np.zeros(n + 1) ns[n] = 1 pre = 1 / np.sqrt(2**n * np.math.factorial(n)) * np.pi**(-0.25) wfunc = pre * np.exp(-x**2 / 2) * hermval(x, ns) return wfunc
def count_hermvals(n, x, dtype=torch.float64, device=torch.device('cpu')): """Returns tensor of shape [len(x), len(n)] with hermitian polynomes values H_n(x).""" hermvals = torch.zeros(len(x), len(n), dtype=dtype, device=device) for i, nval in enumerate(n): coef = torch.zeros(n[-1] + 1, dtype=dtype, device=device) coef[nval] = 1 hermvals[:, i] = hermval(x, coef) return hermvals
def H2p_psi(self, x, n): # n'th harmonic wavefunction for H2+ tmp = self.reduced_mass * self.omega_p prefactor = pow(tmp / np.pi, 0.25) / np.sqrt(2.0**n * factorial(n)) coeffs = np.zeros(n + 1, float) coeffs[n] = 1.0 hermpoly = hermval(np.sqrt(tmp) * (x - self.x_eq_p), coeffs) return prefactor * np.exp(-0.5 * tmp * (x - self.x_eq_p)**2) * hermpoly
def psi(x, t, n): global b, B, ω a = np.exp(-1j * ω * t / 2. - b * x**2 / 2.) c = np.array([ np.exp(-1j * k * ω * t) / np.sqrt(float(2**k * factorial(k))) for k in range(n + 1) ]) ret = a * hermval(x * B, c, tensor=False) return ret
def get_psi_n(self, n): psi = np.sqrt(1 / float(np.math.factorial(n - 1) * 2**(n - 1))) * ( self.m * self.omega / np.pi)**(0.25) * np.exp( -self.m * self.omega * self.x**2 / 2) * hermite.hermval( np.sqrt(self.m * self.omega) * self.x, [0] * (n - 1) + [1.0]) psi[self.x > self.L / 2.0] = 0 psi[self.x < -self.L / 2.0] = 0 return psi
def Hermite(n, x): cn = [] for i in xrange(n): cn.append(0.0) cn.append(1.0) Hnx = hermval(x, cn) return Hnx
def generate_eigenstates(self, n): self.eigenstates = np.zeros((n,self.x.size), dtype=np.complex128) self.En = hbar*self.w*(np.arange(n) + 0.5) tmp = self.M*self.w/hbar gauss = (tmp/np.pi)**0.25*np.exp(-1/2*tmp*(self.x-self.x0)**2) for i in range(n): pre_factor = sqrt(1/(2**i * np.math.factorial(i))) self.eigenstates[i,:] = pre_factor*gauss*hermval(sqrt(tmp)*(self.x-self.x0), [int(i == j) for j in range(i+1)]) self.generate_initial_cn(n)
def test_hermfit(self) : def f(x) : return x*(x - 1)*(x - 2) # Test exceptions assert_raises(ValueError, herm.hermfit, [1], [1], -1) assert_raises(TypeError, herm.hermfit, [[1]], [1], 0) assert_raises(TypeError, herm.hermfit, [], [1], 0) assert_raises(TypeError, herm.hermfit, [1], [[[1]]], 0) assert_raises(TypeError, herm.hermfit, [1, 2], [1], 0) assert_raises(TypeError, herm.hermfit, [1], [1, 2], 0) assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[[1]]) assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[1,1]) # Test fit x = np.linspace(0,2) y = f(x) # coef3 = herm.hermfit(x, y, 3) assert_equal(len(coef3), 4) assert_almost_equal(herm.hermval(x, coef3), y) # coef4 = herm.hermfit(x, y, 4) assert_equal(len(coef4), 5) assert_almost_equal(herm.hermval(x, coef4), y) # coef2d = herm.hermfit(x, np.array([y,y]).T, 3) assert_almost_equal(coef2d, np.array([coef3,coef3]).T) # test weighting w = np.zeros_like(x) yw = y.copy() w[1::2] = 1 y[0::2] = 0 wcoef3 = herm.hermfit(x, yw, 3, w=w) assert_almost_equal(wcoef3, coef3) # wcoef2d = herm.hermfit(x, np.array([yw,yw]).T, 3, w=w) assert_almost_equal(wcoef2d, np.array([coef3,coef3]).T) # test scaling with complex values x points whose square # is zero when summed. x = [1, 1j, -1, -1j] assert_almost_equal(herm.hermfit(x, x, 1), [0, .5])
def test_hermfit(self): def f(x): return x * (x - 1) * (x - 2) # Test exceptions assert_raises(ValueError, herm.hermfit, [1], [1], -1) assert_raises(TypeError, herm.hermfit, [[1]], [1], 0) assert_raises(TypeError, herm.hermfit, [], [1], 0) assert_raises(TypeError, herm.hermfit, [1], [[[1]]], 0) assert_raises(TypeError, herm.hermfit, [1, 2], [1], 0) assert_raises(TypeError, herm.hermfit, [1], [1, 2], 0) assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[[1]]) assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[1, 1]) # Test fit x = np.linspace(0, 2) y = f(x) # coef3 = herm.hermfit(x, y, 3) assert_equal(len(coef3), 4) assert_almost_equal(herm.hermval(x, coef3), y) # coef4 = herm.hermfit(x, y, 4) assert_equal(len(coef4), 5) assert_almost_equal(herm.hermval(x, coef4), y) # coef2d = herm.hermfit(x, np.array([y, y]).T, 3) assert_almost_equal(coef2d, np.array([coef3, coef3]).T) # test weighting w = np.zeros_like(x) yw = y.copy() w[1::2] = 1 y[0::2] = 0 wcoef3 = herm.hermfit(x, yw, 3, w=w) assert_almost_equal(wcoef3, coef3) # wcoef2d = herm.hermfit(x, np.array([yw, yw]).T, 3, w=w) assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T) # test scaling with complex values x points whose square # is zero when summed. x = [1, 1j, -1, -1j] assert_almost_equal(herm.hermfit(x, x, 1), [0, .5])
def test_hermval(self): #check empty input assert_equal(herm.hermval([], [1]).size, 0) #check normal input) x = np.linspace(-1, 1) y = [polyval(x, c) for c in Hlist] for i in range(10): msg = "At i=%d" % i tgt = y[i] res = herm.hermval(x, [0]*i + [1]) assert_almost_equal(res, tgt, err_msg=msg) #check that shape is preserved for i in range(3): dims = [2]*i x = np.zeros(dims) assert_equal(herm.hermval(x, [1]).shape, dims) assert_equal(herm.hermval(x, [1, 0]).shape, dims) assert_equal(herm.hermval(x, [1, 0, 0]).shape, dims)
def test_hermfromroots(self) : res = herm.hermfromroots([]) assert_almost_equal(trim(res), [1]) for i in range(1,5) : roots = np.cos(np.linspace(-np.pi, 0, 2*i + 1)[1::2]) pol = herm.hermfromroots(roots) res = herm.hermval(roots, pol) tgt = 0 assert_(len(pol) == i + 1) assert_almost_equal(herm.herm2poly(pol)[-1], 1) assert_almost_equal(res, tgt)
def basis(order, stamp_sz, beta, origin_shift=(0.5, 0.5)): stamp_origin = np.array(stamp_sz) / 2.0 + np.array(origin_shift) x, y = np.meshgrid(range(stamp_sz[0]), range(stamp_sz[1])) x = (x - stamp_origin[0]) / beta y = (y - stamp_origin[1]) / beta basis_ = np.zeros(np.hstack((order, stamp_sz))) W = np.exp(-(x**2 + y**2) / 2.0) for i in range(order[0]): for j in range(order[1]): coeff_x = [0] * (i + 1) coeff_y = [0] * (j + 1) coeff_x[i] = 1.0 coeff_y[j] = 1.0 Hx = hermval(x, coeff_x) Hy = hermval(y, coeff_y) norm = (2**(i + j) * ma.factorial(i) * ma.factorial(j) * ma.pi)**(-0.5) basis_[i, j, :, :] = Hx * Hy * W * norm / beta return basis_
def test_hermval(self): #get_inds empty input assert_equal(herm.hermval([], [1]).size, 0) #get_inds normal input) x = np.linspace(-1, 1) y = [polyval(x, c) for c in Hlist] for i in range(10): msg = "At i=%d" % i tgt = y[i] res = herm.hermval(x, [0] * i + [1]) assert_almost_equal(res, tgt, err_msg=msg) #get_inds that shape is preserved for i in range(3): dims = [2] * i x = np.zeros(dims) assert_equal(herm.hermval(x, [1]).shape, dims) assert_equal(herm.hermval(x, [1, 0]).shape, dims) assert_equal(herm.hermval(x, [1, 0, 0]).shape, dims)
def __call__(self,X): ''' Evaluates the fit at x ''' X = np.atleast_2d(X) if X.shape[1] != self.N: X = X.T assert X.shape[1] == self.N #evaluate basis fuctionslong each rowof X B = np.vstack(map(lambda x:np.prod(hermval(x,self.coef,False),1),X)) return B.dot(self.c)
def test_hermfromroots(self): res = herm.hermfromroots([]) assert_almost_equal(trim(res), [1]) for i in range(1, 5): roots = np.cos(np.linspace(-np.pi, 0, 2 * i + 1)[1::2]) pol = herm.hermfromroots(roots) res = herm.hermval(roots, pol) tgt = 0 assert_(len(pol) == i + 1) assert_almost_equal(herm.herm2poly(pol)[-1], 1) assert_almost_equal(res, tgt)
def funcion_de_onda(self, x, n): import numpy as np from numpy.polynomial.hermite import hermval from math import factorial m = 9.10938291e-31 #kg meff = 0.067 * m #masa efectiva GaAs hbar = 1.05457e-34 #J*s x0 = np.sqrt((hbar**2) / (meff * self.omegaHbar)) c = np.zeros(n + 1) c[n] = np.exp(-(x**2) / (2 * (x0**2))) / (np.sqrt( np.sqrt(np.pi) * x0 * factorial(n) * 2**n)) return hermval(x / x0, c)
def LastnaFunkcija(N, x): return float( np.multiply( np.multiply( Decimal(hermval(x, [0 if d != N else 1 for d in range(N + 1)])), np.multiply( Decimal(np.exp(-Decimal(x)**2 / Decimal(2))), np.sqrt( np.reciprocal( np.multiply(Decimal(math.pow(2, N)), Decimal(math.factorial(N))))))), np.reciprocal(pi4)))
def OneDSol(n, w, x): b = np.sqrt(m * w / hbar) #So, hermval calls the Hermite polynomial corresponding to a set of #coefficients c. If you only want on term of a Hermite polynomial, #you make an array of all 0 with the last term being 1 to grab the #nth term c = np.zeros(n+1) c[-1] = 1 psi =( (b**2 / math.pi)**0.25 * 1 / math.sqrt(2**(n) * math.factorial(n)) * np.exp(-0.5 * b**2 * x**2) * hermval(b * x, c, tensor=False) ) return psi
def fit(self,X,y): ''' Fits the data usng the bais functions ''' #first get Phi matrix bt evaluating basis functions allong each row of X Phi = np.vstack(map(lambda x:np.prod(hermval(x,self.coef,False),1),X)) if self.eta == 0.: self.c = np.linalg.lstsq(Phi,y)[0] else: A = Phi.T.dot(Phi) A -= self.eta*np.eye(len(A)) b = Phi.T.dot(y) self.c = np.linalg.solve(A,b)
def test_hermval(self) : def f(x) : return x*(x**2 - 1) #check empty input assert_equal(herm.hermval([], [1]).size, 0) #check normal input) for i in range(10) : msg = "At i=%d" % i ser = np.zeros tgt = self.y[i] res = herm.hermval(self.x, [0]*i + [1]) assert_almost_equal(res, tgt, err_msg=msg) #check that shape is preserved for i in range(3) : dims = [2]*i x = np.zeros(dims) assert_equal(herm.hermval(x, [1]).shape, dims) assert_equal(herm.hermval(x, [1,0]).shape, dims) assert_equal(herm.hermval(x, [1,0,0]).shape, dims)
def pdf_mvsk(x,pdf0,dm=0.,dv=.99,ds=0.,dk=0.,p6=False): from numpy.polynomial.hermite import hermval from scipy.stats import norm from astropy.convolution import convolve v,m=norm.fit(pdf0) if dv>=1.: if dv==1: dv+=1e-4 pdf2=norm.pdf(x,loc=np.median(x)-dm,scale=np.sqrt((dv*v)**2-v**2)) pdf=convolve(pdf0,pdf2,normalize_kernel=True) else: v2=np.sqrt(1./(1./(v*dv)**2-1./v**2)) m2=v2**2*((m+dm)/(v*dv)**2-m/v**2) pdf2=norm.pdf(x,loc=m2,scale=v2) norm=1./np.sqrt(2.*np.pi*v**2*v2**2/(v*dv)**2)*np.exp(-(v*dv)**2*(m-m2)**2/v2**2/v**2/2.) pdf=pdf0*pdf2/norm if p6: return hermval(x-m,[1.,0.,0.,ds/6.,dk/24.,0.,ds**2./72.])*pdf else: return hermval(x-m,[1.,0.,0.,ds/6.,dk/24.])*pdf
def test_hermval(self): def f(x): return x * (x**2 - 1) #check empty input assert_equal(herm.hermval([], [1]).size, 0) #check normal input) for i in range(10): msg = "At i=%d" % i ser = np.zeros tgt = self.y[i] res = herm.hermval(self.x, [0] * i + [1]) assert_almost_equal(res, tgt, err_msg=msg) #check that shape is preserved for i in range(3): dims = [2] * i x = np.zeros(dims) assert_equal(herm.hermval(x, [1]).shape, dims) assert_equal(herm.hermval(x, [1, 0]).shape, dims) assert_equal(herm.hermval(x, [1, 0, 0]).shape, dims)
def test_hermval(self): x = np.linspace(0, 2000, 2001) n_array = [1, 2, 3, 0, 1] import numpy.polynomial.hermite as hermite out_true = hermite.hermval(x, n_array) out_approx = self.shapelets.hermval(x, n_array) shape_true = out_true * np.exp(-x**2 / 2.) shape_approx = out_approx * np.exp(-x**2 / 2.) npt.assert_almost_equal(shape_approx, shape_true, decimal=6) x = 2 n_array = [1, 2, 3, 0, 1] out_true = hermite.hermval(x, n_array) out_approx = self.shapelets.hermval(x, n_array) npt.assert_almost_equal(out_approx, out_true, decimal=6) x = 2001 n_array = [1, 2, 3, 0, 1] out_true = hermite.hermval(x, n_array) out_approx = self.shapelets.hermval(x, n_array) shape_true = out_true * np.exp(-x**2 / 2.) shape_approx = out_approx * np.exp(-x**2 / 2.) npt.assert_almost_equal(shape_approx, shape_true, decimal=6)
def eigenFunction(self, n=0): """ Parameters -------- n : int, quantum number of eigenstate -------- """ if n > 0: coeff = [0 for _ in range(n)] coeff.append(1) else: coeff = [1] return (self.alpha / np.pi)**(0.25) * (2**n * factorial(n))**( -0.5) * hermval(self.y, coeff) * np.exp(-0.5 * self.y**2)
def phi_gaussian(e, n, X): """ Evaluates the desired eigenfunction of the gaussian kernel Usage Phi = phi_gaussian(e, n, X) Arguments e = scaling coefficient in K(x, y) = exp(-e**2 * (x - y)**2) n = index X = array of function input points Returns Phi = array of function values References Gregory E. Fasshauer, "Positive Definite Kernels: Past, Present and Future" """ c = 1 + power(2 * e / alp, 2) k = power(c, 0.125) / sqrt(2**n * factorial(n)) * \ exp(-(sqrt(c) - 1) * alp**2 * power(X, 2) / 2.) Xi = power(c, 0.25) * alp * X return k * hermite.hermval(Xi, [0] * (n - 1) + [1])
def psi(n, xs): return 0.4 * sqrt(1. / (2**n * factorial(n)) * sqrt(pi)) \ * numpy.exp(-xs**2 / 2) \ * hermval(xs, [0] * n + [1])
def test_hermfit(self) : def f(x) : return x*(x - 1)*(x - 2) # Test exceptions assert_raises(ValueError, herm.hermfit, [1], [1], -1) assert_raises(TypeError, herm.hermfit, [[1]], [1], 0) assert_raises(TypeError, herm.hermfit, [], [1], 0) assert_raises(TypeError, herm.hermfit, [1], [[[1]]], 0) assert_raises(TypeError, herm.hermfit, [1, 2], [1], 0) assert_raises(TypeError, herm.hermfit, [1], [1, 2], 0) assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[[1]]) assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[1,1]) # Test fit x = np.linspace(0,2) y = f(x) # coef3 = herm.hermfit(x, y, 3) assert_equal(len(coef3), 4) assert_almost_equal(herm.hermval(x, coef3), y) # coef4 = herm.hermfit(x, y, 4) assert_equal(len(coef4), 5) assert_almost_equal(herm.hermval(x, coef4), y) # coef2d = herm.hermfit(x, np.array([y,y]).T, 3) assert_almost_equal(coef2d, np.array([coef3,coef3]).T) # test weighting w = np.zeros_like(x) yw = y.copy() w[1::2] = 1 y[0::2] = 0 wcoef3 = herm.hermfit(x, yw, 3, w=w) assert_almost_equal(wcoef3, coef3) # wcoef2d = herm.hermfit(x, np.array([yw,yw]).T, 3, w=w) assert_almost_equal(wcoef2d, np.array([coef3,coef3]).T) #test NA y = f(x) y[10] = 100 xm = x.view(maskna=1) xm[10] = np.NA res = herm.hermfit(xm, y, 3) assert_almost_equal(res, coef3) ym = y.view(maskna=1) ym[10] = np.NA res = herm.hermfit(x, ym, 3) assert_almost_equal(res, coef3) y2 = np.vstack((y,y)).T y2[10,0] = 100 y2[15,1] = 100 y2m = y2.view(maskna=1) y2m[10,0] = np.NA y2m[15,1] = np.NA res = herm.hermfit(x, y2m, 3).T assert_almost_equal(res[0], coef3) assert_almost_equal(res[1], coef3) wm = np.ones_like(x, maskna=1) wm[10] = np.NA res = herm.hermfit(x, y, 3, w=wm) assert_almost_equal(res, coef3)
def evalEnvelopeEx(self, xArray, yArray, z): # assume array input; try to create temporary array try: numVals = xArray.size result = np.zeros(numVals, complex) except AttributeError: # above failed, so input must be a float result = 0.0 # rotate and shift the x,y coordinates as necessary rotArg = (xArray - self.xShift) * math.cos(self.wRotAngle) + (yArray - self.yShift) * math.sin(self.wRotAngle) # z-dependent temporary variables qxz = (z - self.zWaistX) + self.qx0 xrFac = 0.5 * self.k0 / qxz xzFac = math.sqrt(2) / self.waistX / math.sqrt(1 + ((z - self.zWaistX) / self.zRx) ** 2) # load up array of mode-dependent factors xCoefs = np.zeros(self.mMax, complex) for mMode in range(self.mMax): xCoefs[mMode] = ( self.hCoefs[mMode] * self.piWxFac * cmath.sqrt(self.qx0 / qxz) / math.sqrt(math.factorial(mMode) * (2.0 ** mMode)) * (self.qx0 * qxz.conjugate() / self.qx0.conjugate() / qxz) ** (0.5 * mMode) ) # evaluate the product of Hermite series result = hermval(xzFac * rotArg, xCoefs) result *= np.exp(-(xrFac * rotArg ** 2) * 1j) # # rinse and repeat: do the same for the y-dependent Hermite series -- # # rotate and shift the x,y coordinates as necessary rotArg = (yArray - self.yShift) * math.cos(self.wRotAngle) - (xArray - self.xShift) * math.sin(self.wRotAngle) # z-dependent temporary variables qyz = (z - self.zWaistY) + self.qy0 yrFac = 0.5 * self.k0 / qyz yzFac = math.sqrt(2) / self.waistY / math.sqrt(1 + ((z - self.zWaistY) / self.zRy) ** 2) # load up array of mode-dependent factors xCoefs = np.zeros(self.mMax, complex) for mMode in range(self.mMax): xCoefs[mMode] = ( self.hCoefs[mMode] * self.piWxFac * cmath.sqrt(self.qx0 / qxz) / math.sqrt(math.factorial(mMode) * (2.0 ** mMode)) * (self.qx0 * qxz.conjugate() / self.qx0.conjugate() / qxz) ** (0.5 * mMode) ) # load up array of mode-dependent factors (y-dependence) yCoefs = np.zeros(self.nMax, complex) for nMode in range(self.nMax): yCoefs[nMode] = ( self.vCoefs[nMode] * self.piWyFac * cmath.sqrt(self.qy0 / qyz) / math.sqrt(math.factorial(nMode) * (2.0 ** nMode)) * (self.qy0 * qyz.conjugate() / self.qy0.conjugate() / qyz) ** (0.5 * nMode) ) # evaluate product of Hermite series (multiplying into previous value) result *= hermval(yzFac * rotArg, yCoefs) result *= np.exp(-(yrFac * rotArg ** 2) * 1j) # return the complex valued result return result
def test_hermint(self) : # check exceptions assert_raises(ValueError, herm.hermint, [0], .5) assert_raises(ValueError, herm.hermint, [0], -1) assert_raises(ValueError, herm.hermint, [0], 1, [0,0]) # test integration of zero polynomial for i in range(2, 5): k = [0]*(i - 2) + [1] res = herm.hermint([0], m=i, k=k) assert_almost_equal(res, [0, .5]) # check single integration with integration constant for i in range(5) : scl = i + 1 pol = [0]*i + [1] tgt = [i] + [0]*i + [1/scl] hermpol = herm.poly2herm(pol) hermint = herm.hermint(hermpol, m=1, k=[i]) res = herm.herm2poly(hermint) assert_almost_equal(trim(res), trim(tgt)) # check single integration with integration constant and lbnd for i in range(5) : scl = i + 1 pol = [0]*i + [1] hermpol = herm.poly2herm(pol) hermint = herm.hermint(hermpol, m=1, k=[i], lbnd=-1) assert_almost_equal(herm.hermval(-1, hermint), i) # check single integration with integration constant and scaling for i in range(5) : scl = i + 1 pol = [0]*i + [1] tgt = [i] + [0]*i + [2/scl] hermpol = herm.poly2herm(pol) hermint = herm.hermint(hermpol, m=1, k=[i], scl=2) res = herm.herm2poly(hermint) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with default k for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = herm.hermint(tgt, m=1) res = herm.hermint(pol, m=j) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with defined k for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = herm.hermint(tgt, m=1, k=[k]) res = herm.hermint(pol, m=j, k=list(range(j))) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with lbnd for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = herm.hermint(tgt, m=1, k=[k], lbnd=-1) res = herm.hermint(pol, m=j, k=list(range(j)), lbnd=-1) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with scaling for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = herm.hermint(tgt, m=1, k=[k], scl=2) res = herm.hermint(pol, m=j, k=list(range(j)), scl=2) assert_almost_equal(trim(res), trim(tgt))
def test_hermfit(self): def f(x): return x*(x - 1)*(x - 2) def f2(x): return x**4 + x**2 + 1 # Test exceptions assert_raises(ValueError, herm.hermfit, [1], [1], -1) assert_raises(TypeError, herm.hermfit, [[1]], [1], 0) assert_raises(TypeError, herm.hermfit, [], [1], 0) assert_raises(TypeError, herm.hermfit, [1], [[[1]]], 0) assert_raises(TypeError, herm.hermfit, [1, 2], [1], 0) assert_raises(TypeError, herm.hermfit, [1], [1, 2], 0) assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[[1]]) assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[1, 1]) assert_raises(ValueError, herm.hermfit, [1], [1], [-1,]) assert_raises(ValueError, herm.hermfit, [1], [1], [2, -1, 6]) assert_raises(TypeError, herm.hermfit, [1], [1], []) # Test fit x = np.linspace(0, 2) y = f(x) # coef3 = herm.hermfit(x, y, 3) assert_equal(len(coef3), 4) assert_almost_equal(herm.hermval(x, coef3), y) coef3 = herm.hermfit(x, y, [0, 1, 2, 3]) assert_equal(len(coef3), 4) assert_almost_equal(herm.hermval(x, coef3), y) # coef4 = herm.hermfit(x, y, 4) assert_equal(len(coef4), 5) assert_almost_equal(herm.hermval(x, coef4), y) coef4 = herm.hermfit(x, y, [0, 1, 2, 3, 4]) assert_equal(len(coef4), 5) assert_almost_equal(herm.hermval(x, coef4), y) # check things still work if deg is not in strict increasing coef4 = herm.hermfit(x, y, [2, 3, 4, 1, 0]) assert_equal(len(coef4), 5) assert_almost_equal(herm.hermval(x, coef4), y) # coef2d = herm.hermfit(x, np.array([y, y]).T, 3) assert_almost_equal(coef2d, np.array([coef3, coef3]).T) coef2d = herm.hermfit(x, np.array([y, y]).T, [0, 1, 2, 3]) assert_almost_equal(coef2d, np.array([coef3, coef3]).T) # test weighting w = np.zeros_like(x) yw = y.copy() w[1::2] = 1 y[0::2] = 0 wcoef3 = herm.hermfit(x, yw, 3, w=w) assert_almost_equal(wcoef3, coef3) wcoef3 = herm.hermfit(x, yw, [0, 1, 2, 3], w=w) assert_almost_equal(wcoef3, coef3) # wcoef2d = herm.hermfit(x, np.array([yw, yw]).T, 3, w=w) assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T) wcoef2d = herm.hermfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w) assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T) # test scaling with complex values x points whose square # is zero when summed. x = [1, 1j, -1, -1j] assert_almost_equal(herm.hermfit(x, x, 1), [0, .5]) assert_almost_equal(herm.hermfit(x, x, [0, 1]), [0, .5]) # test fitting only even Legendre polynomials x = np.linspace(-1, 1) y = f2(x) coef1 = herm.hermfit(x, y, 4) assert_almost_equal(herm.hermval(x, coef1), y) coef2 = herm.hermfit(x, y, [0, 2, 4]) assert_almost_equal(herm.hermval(x, coef2), y) assert_almost_equal(coef1, coef2)
def get_hermite_polynomial(self, n, x): return hermval(x, [0]*n+[1])
def evaluateEField(self, coords, t): """ Calculate the electric field for an array of particles with positions x at time t in a Hermite-Gauss laser field :param x: numpy array of particle positions :param t: time as a float :return: numpy array of electric field 3-component vectors """ # Create empty electric field holder theEFields = np.zeros(coords.shape[0] * 3, dtype=complex)\ .reshape(coords.shape[0], 3) # Create a temporary variable to store rotated coordinates. This # prevents accidental re-assignment. Only access the rotatedCoords # from here on out #rotatedCoords = np.zeros(coords.shape[0]*3).reshape(coords.shape[ # 0], 3) rotatedCoords = np.dot(self.rotationMatrix, coords.T).T # Compute the Hermite-Gauss coefficients, which have some # z-dependence that requires they be computed for every time step. # This multiplies the base laser mode coefficients, and therefore # has to be created as a temporary variable to avoid modifying the # original laser parameters. This assumes a 2D laser qxz = np.zeros(rotatedCoords.shape[0], dtype=complex) qxz[:] = (rotatedCoords[:,2] - self.zWaistX) + self.qx0 xrFac = 0.5 * self.k0 / qxz xzFac = (np.sqrt(2)/self.waistX)/\ np.sqrt(1+((coords[:,2]-self.zWaistX)/self.zRx)**2) qyz = np.zeros(rotatedCoords.shape[0], dtype=complex) qyz[:] = (rotatedCoords[:,2] - self.zWaistY) + self.qy0 yrFac = 0.5 * self.k0 / qyz yzFac = (np.sqrt(2)/self.waistY)/\ np.sqrt(1+((coords[:,2]-self.zWaistY)/self.zRy)**2) # Iterate over the coefficients, computing the particle-dependent # normalization coefficients for the Hermite-Gauss series # Have to compute the Hermite-Gauss series explicitly for optimal # control -- recommend against attempting to use hermval2d ptclCoefs = copy.deepcopy([self.hermCoeffs]*coords.shape[0]) for idx in range(0,coords.shape[0]): for nidx in range(0,self.hermCoeffs.shape[0]): for midx in range(0,self.hermCoeffs.shape[1]): ptclCoefs[idx][nidx,midx] /=\ np.sqrt(np.math.factorial(midx)*(2.**midx)* np.math.factorial(nidx)*(2.**nidx)) ptclCoefs[idx][nidx,midx] *= (self.piWxFac)*np.sqrt( self.qx0/qxz[idx]) ptclCoefs[idx][nidx,midx] *= (self.qx0*qxz[idx].conjugate()/ self.qx0.conjugate()/qxz[idx])**(0.5*(midx)) ptclCoefs[idx][nidx,midx] *= (self.piWyFac)*np.sqrt( self.qy0/qyz[idx]) ptclCoefs[idx][nidx,midx] *= (self.qy0*qxz[idx].conjugate()/ self.qy0.conjugate()/qyz[idx])**(0.5*(nidx)) # Explicitly iterate through the particles, since this seems to be # the only way to keep control over the Hermite functions myNewCoeffs = np.zeros(self.hermCoeffs.shape[0], dtype=complex) for idx in range(0,coords.shape[0]): for xidx in range(0, self.hermCoeffs.shape[0]): myNewCoeffs[xidx] = hermval(yzFac[idx]*coords[idx,1], ptclCoefs[idx][xidx]) theEFields[idx,:] = self.polVector[:]* \ hermval(xzFac[idx]*coords[idx,0], myNewCoeffs) theEFields[idx]*=\ np.exp(-(xrFac[idx]*(coords[idx,0]**2+coords[idx,1]**2)*1j)) theEFields[idx,:] *= \ np.exp(-(yrFac[idx]*(coords[idx,0]**2+coords[idx,1]**2)*1j)) theEFields[idx]*=\ np.exp((self.omega * t - self.k0 * coords[idx,2])*1j) return theEFields.real