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_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_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 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 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_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_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()
