def n_l_one_half_j(self,j): etha=self.etha l=self.l rootlist=self.rootlist res=2/(pi*rootlist[j])**2\ *(mp.besselj(l+mp.mpf(1)/mp.mpf(2),rootlist[j]*etha)**2/mp.besselj(l+mp.mpf(1)/mp.mpf(2),rootlist[j])**2 -1) return(res)
def ila_integrand_lp1(self, eta, rloc): k, p, l = self.k, self.p, self.l kz = mpmath.sqrt(k**2 - eta**2) res = mpmath.power(eta, np.abs(l) + 1) / mpmath.sqrt(kz) \ * mpmath.laguerre(p, l, self.a(eta) ** 2) * mpmath.exp(-self.a(eta) ** 2 / 2) \ * ((1 - kz / k) * mpmath.besselj(l + 2, eta * rloc / k) + (1 + kz / k) * mpmath.besselj(l, eta * rloc / k)) return res
def C_prime_l_one_half(self,j): # define a function to coumpute the C_prime_l_one_half according to # (eq. (139)) alpha=self.rootlist[j] l=self.l etha=self.etha res=-1**l*2.0/(pi*alpha)*mp.besselj(l+mp.mpf(1)/mp.mpf(2),etha*alpha)/mp.besselj(l+mp.mpf(1)/mp.mpf(2),alpha) return(res)
def make_bessel_j0_vals(): from mpmath import besselj x = linspace(-5, 15, 21) j0 = [besselj(0, val) for val in x] return make_special_vals('bessel_j0_vals', ('x', x), ('j0', j0))
def make_bessel_j_vals(): from mpmath import besselj nu = [ mpf('0.5'), mpf('1.25'), mpf('1.5'), mpf('1.75'), mpf(2), mpf('2.75'), mpf(5), mpf(10), mpf(20) ] x = [ mpf('0.2'), mpf(1), mpf(2), mpf('2.5'), mpf(3), mpf(5), mpf(10), mpf(50) ] nu, x = list(zip(*outer(nu, x))) j = [besselj(*vals) for vals in zip(nu, x)] return make_special_vals('bessel_j_vals', ('nu', nu), ('x', x), ('j', j))
def kaiser_bessel_ft(u,J,alpha,kb_m,d): import numpy as np import math from mpmath import besselj, besseli import cmath z = map(cmath.sqrt,( (2*math.pi*(J/2)*u)**2 - alpha**2 )) print(J) nu = d/2.0 + kb_m a = np.shape(z)[0] bslj = np.zeros(a,np.complex128) for i in range(0,a): bslj[i] = np.array(np.complex(besselj(nu,z[i]))) z_sqrt = map(cmath.sqrt, z) a = (2*math.pi)**(d/2.0)*(J/2)**d*alpha**kb_m b = a/float(besseli(kb_m,alpha))*bslj y = b/(z_sqrt) y = reale(y) return y
def make_bessel_j1_vals(): from mpmath import besselj x = linspace(-5, 15, 21) j1 = [besselj(1, val) for val in x] return make_special_vals('bessel_j1_vals', ('x', x), ('j1', j1))
def random_h_batch(): h_batch = None temp = 2 * np.pi * NORMALIZED_DOPPLER_FREQUENCY rho_h = float(besselj(0, temp)) prev_h = None for _ in range(PACKETS_PER_BATCH): for t in range(TRANSMIT_TIMES_PER_PACKET): # 由于tensorflow不支持复数直接运算,所以我们需要分割为实部和虚部的形式 real = np.random.randn(NUM_ANT, NUM_ANT) imag = np.random.randn(NUM_ANT, NUM_ANT) h = np.row_stack(( np.column_stack((real, -imag)), np.column_stack((imag, real)), )) h = h.reshape([1, 2 * NUM_ANT, 2 * NUM_ANT]) if t == 0: h_batch = concatenate(h_batch, h) prev_h = h else: doppler_h = rho_h * prev_h + np.sqrt(1 - rho_h * rho_h) * h h_batch = concatenate(h_batch, doppler_h) prev_h = doppler_h return h_batch
def bessel_initial_guess(m, N, S_guess): bessel_j_zeros = [mpmath.besseljzero(m, i) for i in xrange(1, N+1)] abscissas = [zero / S_guess for zero in bessel_j_zeros] weights = [2.0 / (S_guess * mpmath.besselj(m + 1, bessel_j_zeros[i]))**2 for i in xrange(N)] weights = numpy.reshape(numpy.double(weights), (N,)) abscissas = numpy.reshape(numpy.double(abscissas), (N,)) return weights, abscissas
def radial_integrand_lm1(self, eta, r, theta, phi): k = self.k kz = mpmath.sqrt(k**2 - eta**2) l, p = self.l, self.p a, b = self.alpha, self.beta result = (mpmath.power(eta, np.abs(l) + 1) / mpmath.sqrt(kz) \ * mpmath.laguerre(p, l, self.a(eta) ** 2) \ * mpmath.exp(-self.a(eta) ** 2 / 2 + 1j * (l - 1) * phi \ + 1j * kz * r * np.cos(theta)) \ * ((a + 1j * b) / 2 * (1 - kz / k) \ * mpmath.besselj(l - 2, eta * r * np.sin(theta)) \ * np.sin(theta) \ + eta / k * (1j * a - b) \ * mpmath.besselj(l - 1, eta * r * np.sin(theta)) \ * np.cos(theta) \ + (a + 1j * b) / 2 * (1 + kz / k) \ * mpmath.besselj(l, eta * r * np.sin(theta)) * np.sin(theta))) return result
def besselJZeros(m, a, b): require_mpmath() if not hasattr(mpmath, 'besseljzero'): besseljn = lambda x: mpmath.besselj(m, x) results = [mpmath.findroot(besseljn, mpmath.pi*(kp - 1./4 + 0.5*m)) for kp in range(a, b+1)] else: results = [mpmath.besseljzero(m, i) for i in xrange(a, b+1)] # Check that we haven't found double roots or missed a root. All roots should be separated by approximately pi assert all([0.6*mpmath.pi < (b - a) < 1.4*mpmath.pi for a, b in zip(results[:-1], results[1:])]), "Separation of Bessel zeros was incorrect." return results
def sphbesselj(nu, x): from mpmath import besselj if (x == 0): if (nu == 0): return mpf(1) else: return mpf(0) return sqrt(pi / (2 * x)) * besselj(nu + mpf('0.5'), x)
def make_bessel_j_vals(): from mpmath import besselj nu = [mpf('0.5'), mpf('1.25'), mpf('1.5'), mpf('1.75'), mpf(2), mpf('2.75'), mpf(5), mpf(10), mpf(20)] x = [mpf('0.2'), mpf(1), mpf(2), mpf('2.5'), mpf(3), mpf(5), mpf(10), mpf(50)] nu, x = zip(*outer(nu, x)) j = [besselj(*vals) for vals in zip(nu, x)] return make_special_vals('bessel_j_vals', ('nu', nu), ('x', x), ('j', j))
def bessel_neumann_kspace_initial_guess(m, N, S_guess): bessel_j_zeros = [mpmath.besseljzero(m, i, derivative=True) for i in xrange(1, N+1)] abscissas = [zero / S_guess for zero in bessel_j_zeros] additional_factor = (lambda i: 1.0) if m == 0 else (lambda i: 1.0 - (m/bessel_j_zeros[i])**2) weights = [2.0 / (S_guess * additional_factor(i) * mpmath.besselj(m, bessel_j_zeros[i]))**2 for i in xrange(N)] weights = numpy.reshape(numpy.double(weights), (N,)) abscissas = numpy.reshape(numpy.double(abscissas), (N,)) return weights, abscissas
def f(self, ksi, omega): alpha2 = self.rho * omega**2 / (self.l + 2 * self.mu) - ksi**2 beta2 = self.rho * omega**2 / self.mu - ksi**2 alpha = mm.sqrt(alpha2) beta = mm.sqrt(beta2) rez = 2. * alpha / self.r0 * (beta2 + ksi**2) * mm.besselj( 1, alpha * self.r0) * mm.besselj(1, beta * self.r0) rez -= (beta2 - ksi**2)**2 * mm.besselj( 0, alpha * self.r0) * mm.besselj( 1, beta * self.r0) + 4 * ksi**2 * alpha * beta * mm.besselj( 1, alpha * self.r0) * mm.besselj(0, beta * self.r0) return abs(rez)
def test_besselj(self): assert_mpmath_equal(sc.jv, _exception_to_nan(lambda v, z: mpmath.besselj(v, z, **HYPERKW)), [Arg(-1e100, 1e100), Arg(-1e8, 1e8)], ignore_inf_sign=True)
def test_besselj_complex(self): assert_mpmath_equal(lambda v, z: sc.jv(v.real, z), _exception_to_nan(lambda v, z: mpmath.besselj(v, z, **HYPERKW)), [Arg(), ComplexArg()])
def integrand(u): return u * mp.exp(-(u / T)**2) * mp.besselj(0, mp.pi * u * rn)
def j1(w): jay=al*(w**dd)/(wc**(dd-1))*exp(-(w/wc)) jay=jay*(1-[0,cos(R*w),besselj(0,R*w),sinc(R*w)][dd]) return jay
def test_besselj(self): assert_mpmath_equal(sc.jv, _exception_to_nan(lambda v, z: mpmath.besselj(v, z, **HYPERKW)), [Arg(-1e100, 1e100), Arg()], n=1000)
def test_besselj(self): assert_mpmath_equal( sc.jv, _exception_to_nan(lambda v, z: mpmath.besselj(v, z, **HYPERKW)), [Arg(-1e100, 1e100), Arg(-1e8, 1e8)], ignore_inf_sign=True)
def f8(x): # bessel_J0 return mpmath.besselj(0, x)
def test_besselj(self): assert_mpmath_equal( sc.jv, _exception_to_nan(lambda v, z: mpmath.besselj(v, z, **HYPERKW)), [Arg(-1e100, 1e100), Arg()], n=1000)
def seq(s): return (-1)**s * (u / v)**(-n - 2 * s) * \ mp.besselj(-n - 2 * s, v) return mp.nsum(seq, [0, mp.inf])
def mp_rho_N(l,kr): if l==1 and kr==0.0: return 0.0 v1 = ((l+1.0)/(2.0*l+1.0)) * (mpmath.besselj(l-0.5,kr)**2 - mpmath.besselj(l+0.5,kr)*mpmath.besselj(l-1.5,kr)) v2 = (l/(2.0*l+1.0)) * (mpmath.besselj(l+1.5,kr)**2 - mpmath.besselj(l+0.5,kr)*mpmath.besselj(l+2.5,kr)) return 0.25*mp.pi*kr**2 * (v1+v2)
# 使用上面求结果的方程检验实现的正确性: # In[6]: zeroin(lambda x: x**3 - x - 1, 1, 2), zeroin(lambda x: -x**3 + 5 * x, 2, 3) # 可见算法能够正确进行迭代求解,并且所需的迭代步骤均较少。 # # 下面使用其进行 Bessel 曲线的零点求解。首先定义函数并绘制曲线: # In[7]: from mpmath import besselj import matplotlib.pyplot as plt j0 = lambda x: besselj(0, x) x = np.arange(2, 40, 0.001) y = list(map(j0, x)) fig, ax = plt.subplots(figsize=(10, 8)) ax.set_ylabel('Bessel Function') plt.plot(x, y, zorder=2) plt.grid(True) plt.axhline(0, color='black', zorder=1) plt.show() # 从图中可以估测前 10 个零点的存在区间,在这些区间上运行 `zeroin` 算法得到准确零点: # In[8]:
def mp_spherical_djn(l, z): return mpmath.sqrt(mpmath.pi / (2 * z)) * (mpmath.besselj(l + 0.5, z, 1) - mpmath.besselj(l + 0.5, z) / (2 * z))
def mp_spherical_jn(l, z): return mpmath.sqrt(mpmath.pi / 2.0 / z) * mpmath.besselj(l + 0.5, z)
def seq(s): return (-1)**s * (u / v)**(n + 2 * s) * mp.besselj(n + 2 * s, v)
def sph_jn_bessel(n, z): out = besselj(n + mpf(1)/2, z)*sqrt(pi/(2*z)) if mpmathify(z).imag == 0: return out.real # Small imaginary parts are spurious else: return out
def f9(x): # bessel_J1 return mpmath.besselj(1, x)
def x_exponential_spectrum(z,wvnb,L,n,xx): tmp = math.exp(-abs(z) ** xx) * besselj(0, z*wvnb*L/(n**(1/xx)))*z return(tmp)
def test_besselj_complex(self): assert_mpmath_equal(lambda v, z: sc.jv(v.real, z), lambda v, z: mpmath.besselj(v, z, **HYPERKW), [Arg(), ComplexArg()], n=2000)
def test_jvx_smallx(v, z): assert np.isclose(jvz.jvx(v, z), float(besselj(v, z)), rtol=5e-15)
def test_jvz_smallz(v, z): test = jvz.jvz(v, z) ref = np.complex128(besselj(v, z)) # assert np.isclose(test.real, ref.real, rtol=5e-13) assert np.isclose(test.imag, ref.imag, rtol=5e-13, atol=1e-15)
def mp_rho_M(l,kr): return 0.25*mp.pi*kr**2 * (mpmath.besselj(l+0.5,kr)**2 - mpmath.besselj(l-0.5,kr)*mpmath.besselj(l+1.5,kr))
def test_besselj_complex(self): assert_mpmath_equal( lambda v, z: sc.jv(v.real, z), _exception_to_nan(lambda v, z: mpmath.besselj(v, z, **HYPERKW)), [Arg(), ComplexArg()])
def sph_jn_bessel(n, z): out = besselj(n + mpf(1) / 2, z) * sqrt(pi / (2 * z)) if mpmathify(z).imag == 0: return out.real # Small imaginary parts are spurious else: return out
y2_i = fft.ifft(A1) tmpx1_i = 1.0/a.IB_i tmpy1_i = y2_i.real tmpy_i = numpy.take( tmpy1_i, numpy.argsort(tmpx1_i) ) tmpx_i = numpy.sort(tmpx1_i) dx = tmpx_i[1] - tmpx_i[0] - .000001 x3_i,y3_i = dhva_routines.even_interpolate(tmpx_i,tmpy_i,tmpx_i[0],tmpx_i[-1],dx) outfile = open("./"+name[0:-3]+"flt","w") h = 0.0125 # modulation field in teslas bessarg = 2.0*pi*h*1.1e3 for i in range(0,len(x3_i)): ibess = abs( 1.0/besselj( 2, bessarg/pow(x3_i[i],2) ) ) if ibess>10.0: ibess = 10.0 # this to avoid infinities; it's rather awkward, to be sure y3_i[i] *= ibess outstr = str(x3_i[i]) + " " + str(y3_i[i]) + '\n' outfile.write(outstr) # # # now do the rectification and low pass filtering: # a.B_i = numpy.array( x3_i ) tmp_i = numpy.absolute( y3_i ) offset = numpy.average( tmp_i) a.x_i = tmp_i - offset a.get_sweep_dirn() a.field_invert() amplitude_i,A = a.take_fft()