def lnProb_rhoA2rhoB2_given_rhoA2orhoB2o( rhoA2, rhoB2, rhoA2o, rhoB2o ):
'''
return ln( p(rhoA2,rhoB2|rhoA2o,rhoB2o) )
NOTE: essentially 2 independent chi2 distributions
'''
types = (int,float)
if isinstance(rhoA2, types) and isinstance(rhoB2, types) \
and isinstance(rhoA2o, types) and isinstance(rhoB2o, types):
return np.log(0.25) - 0.5*(rhoA2 + rhoB2 + rhoA2o + rhoB2o) \
+ float(mpmath.log(mpmath.besseli(0, (rhoA2*rhoA2o)**0.5))) \
+ float(mpmath.log(mpmath.besseli(0, (rhoB2*rhoB2o)**0.5)))
else:
N = len(rhoA2)
assert N==len(rhoB2), 'rhoA2 and rhoB2 do not have the same length'
assert N==len(rhoA2o), 'rhoA2 and rhoA2o do not have the same length'
assert N==len(rhoB2o), 'rhoA2 and rhoB2o do not have the same length'
log25 = np.log(0.25)
ans = [log25 - 0.5*(rhoa2 + rhob2 + rhoa2o + rhob2o) \
+ float(mpmath.log(mpmath.besseli(0, (rhoa2*rhoa2o)**0.5))) \
+ float(mpmath.log(mpmath.besseli(0, (rhob2*rhob2o)**0.5))) \
for rhoa2, rhob2, rhoa2o, rhob2o in zip(rhoA2, rhoB2, rhoA2o, rhoB2o)
]
if isinstance(rhoA2, np.ndarray) or isinstance(rhoB2, np.ndarray) or isinstance(rhoA2o, np.ndarray) or isinstance(rhoB2o, np.ndarray):
ans = np.array(ans)
ans[ans!=ans] = -np.infty ### get rid of nans
### FIXME we may want to be smarter about this and
### prevent nans from showing up in the first place
return ans
def inlineeval(INLINE_INPUTS_, INLINE_INPUTEXPR_, INLINE_EXPR_):
import numpy as np
from mpmath import besseli
INLINE_OUT_ = []
print(INLINE_INPUTS_)
k = INLINE_INPUTS_[0]
print(k[1])
J = INLINE_INPUTS_[1]
kb_m = 0
alpha = 14.04
kb_m_bi = abs(kb_m)
ii = np.abs(k) < J / 2
f = np.sqrt(1 - (k[ii] / (J / 2))**2)
f = np.expand_dims(f, axis=1)
denom = besseli(kb_m_bi, alpha)
kb = np.zeros(np.shape(f))
for j in range(0, len(kb)):
kb[j] = np.float(besseli(kb_m_bi, alpha * f[j][0]))
kb_1 = np.zeros(np.shape(k)).flatten()
ii = ii.flatten()
a = ((f**kb_m) * kb) / np.float(denom)
d = 0
for u in range(0, len(ii)):
if ii[u] != 0:
kb_1[u] = a[d]
d = d + 1
kb = np.reshape(kb_1, np.shape(k))
return kb
def test_bounds_for_Q1():
"""
These bounds are from:
Jiangping Wang and Dapeng Wu,
"Tight bounds for the first order Marcum Q-function"
Wireless Communications and Mobile Computing,
Volume 12, Issue 4, March 2012, Pages 293-301.
"""
with mpmath.workdps(50):
sqrt2 = mpmath.sqrt(2)
sqrthalfpi = mpmath.sqrt(mpmath.pi / 2)
for b in [mpmath.mp.mpf(1), mpmath.mp.mpf(10)]:
for a in [b / 16, 0.5 * b, 0.875 * b, b]:
q1 = marcumq(1, a, b)
sinhab = mpmath.sinh(a * b)
i0ab = mpmath.besseli(0, a * b)
# lower bound when 0 <= a <= b
lb = (mpmath.sqrt(mpmath.pi / 8) * b * i0ab / sinhab *
(mpmath.erfc((b - a) / sqrt2) - mpmath.erfc(
(b + a) / sqrt2)))
assert lb < q1
# upper bound when 0 <= a <= b
ub = ((i0ab + 3) / (mpmath.exp(a * b) + 3) * (
mpmath.exp(-(b - a)**2 / 2) + a * sqrthalfpi * mpmath.erfc(
(b - a) / sqrt2) + 3 * mpmath.exp(-(a**2 + b**2) / 2)))
assert q1 < ub, ("marcumq(1, a, b) < ub for a = %s, b = %s" %
(a, b))
for a in [mpmath.mp.mpf(1), mpmath.mp.mpf(10)]:
for b in [b / 16, 0.5 * b, 0.875 * b, b]:
q1 = marcumq(1, a, b)
sinhab = mpmath.sinh(a * b)
i0ab = mpmath.besseli(0, a * b)
# lower bound when 0 <= b <= a
lb = (1 - sqrthalfpi * b * i0ab / sinhab *
(mpmath.erf(a / sqrt2) - mpmath.erf(
(a - b) / sqrt2) / 2 - mpmath.erf(
(a + b) / sqrt2) / 2))
assert lb < q1
# upper bound when 0 <= b <= a
ub = (
1 - i0ab / (mpmath.exp(a * b) + 3) *
(4 * mpmath.exp(-a**2 / 2) - mpmath.exp(-(b - a)**2 / 2) -
3 * mpmath.exp(-(a**2 + b**2) / 2) + a * sqrthalfpi *
(mpmath.erfc(-a / sqrt2) - mpmath.erfc((b - a) / sqrt2))))
assert q1 < ub, ("marcumq(1, a, b) < ub for a = %s, b = %s" %
(a, b))
def test_Q1_identities():
with mpmath.workdps(50):
for a in [mpmath.mp.mpf(1), mpmath.mp.mpf(13)]:
q1 = marcumq(1, a, a)
expected = 0.5 * (1 + mpmath.exp(-a**2) * mpmath.besseli(0, a**2))
assert mpmath.almosteq(q1, expected)
for a, b in [(1, 2), (10, 3.5)]:
total = marcumq(1, a, b) + marcumq(1, b, a)
expected = 1 + mpmath.exp(-(a**2 + b**2) / 2) * mpmath.besseli(
0, a * b)
assert mpmath.almosteq(total, expected)
def dpint(f,snr): '''Integrand of the detection probability of single sources. Since it contains a modified Bessel function, which gets very big values, it has to be defined in a special way.''' big=mpmath.log(mpmath.besseli(1,snr*np.sqrt(2.*f))) small=mpmath.mpf(-f-0.5*snr**2.) normal=mpmath.log(np.sqrt(2.*f)*1./snr) result=mpmath.exp(mpmath.fsum([big,small,normal])) return float(result) #In the end the result should be between 0 and some sizeable number, so a float should be enough.
def filtro(wp, wr):
wc = (wp + wr) / 2
d = 0.01
Ap = 20 * math.log10((1 + d) / (1 - d))
Ar = -20 * math.log10(d)
if Ar < 21:
b = 0
D = .9222
elif Ar < 50:
b = 0.5842 * (Ar - 21)**0.4 + 0.07886 * (Ar - 21)
D = (Ar - 7.95) / 14.36
else:
b = .1102 * (Ar - 8.7)
D = (Ar - 7.95) / 14.36
k = math.ceil(math.pi * D / (wr - wp) - .5)
M = 2 * k + 1
n = np.arange(-k, k + 1, 1)
#w = besseli(0,b*np.sqrt(1-(4/M**2)*n**2))
w = np.i0(b * np.sqrt(1 - (4 / M**2) * n**2))
w = np.divide(w, besseli(0, b))
h = wc / math.pi * np.sinc(wc * n / math.pi) * w
return h
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 Newton_kappa_log(kappa0,D,R, Niter = None):
kappa = kappa0
D = float(D)
# print "Init kappa: ", kappa, "Init R: " , R
for i in range(Niter):
# print kappa
Ap_num = mpmath.besseli(D/2,float(kappa))
Ap_den = mpmath.besseli(D/2-1,float(kappa))
Ap = Ap_num/Ap_den
# print Ap
num = Ap - R
den = 1 - Ap*Ap - ((D-1)/kappa)*Ap
# print "delta_kappa:", num/den
kappa = kappa - num/den
return np.array(float(kappa))
def VMFMeanDirDensity(x, k, p):
for i in range(0, len(x)):
if (x[i] < -1.0 or x[i] > 1.0):
sys.exit('Input of x must be within -1 to 1')
coeff = float((k / 2)**(p / 2 - 1) * (mpmath.gamma(
(p - 1) / 2) * mpmath.gamma(1 / 2) * mpmath.besseli(p / 2 - 1, k))
**(-1))
#sp.special.gamma((p-1)/2) becoming infinity
y = coeff * np.exp(k * x) * np.power((1 - np.square(x)), ((p - 2) / 2))
return y
def lnProb_rhoA2_given_rhoA2o( rhoA2, rhoA2o ):
'''
return ln( p(rhoA2 | rhoA2o) )
NOTE: essentially a chi2 distribution
'''
if isinstance(rhoA2, (int,float)) and isinstance(rhoA2o, (int,float)):
return np.log(0.5) - 0.5*(rhoA2 + rhoA2o) \
+ float(mpmath.log(mpmath.besseli(0, (rhoA2*rhoA2o)**0.5)))
else:
assert len(rhoA2)==len(rhoA2o), 'rhoA2 and rhoA2o do not have the same length'
log5 = np.log(0.5)
ans = [log5 - 0.5*(rhoa2 + rhoa2o) \
+ float(mpmath.log(mpmath.besseli(0, (rhoa2*rhoa2o)**0.5))) \
for rhoa2, rhoa2o in zip(rhoA2, rhoA2o)
]
if isinstance(rhoA2, np.ndarray) or isinstance(rhoA2o, np.ndarray):
ans = np.array(ans)
return ans
def dist_vs_time_golo_exp(x, t, x0, n0, b):
res = np.zeros(len(x), dtype=np.float128)
for n in range(len(x)):
t = np.where(t < 1E-12, 1E-12, t)
x_x0 = x[n] / x0
x = np.where(x_x0 < 1E-8, x0 * 1E-8, x)
x_x0 = x[n] / x0
T = 1. - np.exp(-b * n0 * x0 * t)
T_sqrt = np.sqrt(T)
z = 2. * x_x0 * T_sqrt
res[n] = n0 / x0 * (1. - T) * 2.\
* mpm.exp( -0.5 * (1. + T) * z / T_sqrt )\
* mpm.besseli(1,z) / z
return res
def get_cp_log(p,kappa):
p = float(p)
cp = (p/2-1)*np.log(kappa)
# bessel_func = ive (p/2-1,kappa) * np.exp(kappa)
# print ".............."
# print bessel_func
bessel_func = mpmath.besseli(p/2-1,float(kappa))
# bessel_func = float(bessel_func)
# print bessel_func
bessel_func_log = float(mpmath.log(bessel_func))
# print bessel_func_log
cp += -(p/2)*np.log(2*pi)-bessel_func_log
return cp
def get_cp_log(p, kappa):
p = float(p)
cp = (p / 2 - 1) * np.log(kappa)
# bessel_func = ive (p/2-1,kappa) * np.exp(kappa)
# print ".............."
# print bessel_func
bessel_func = mpmath.besseli(p / 2 - 1, float(kappa))
# bessel_func = float(bessel_func)
# print bessel_func
bessel_func_log = float(mpmath.log(bessel_func))
# print bessel_func_log
cp += -(p / 2) * np.log(2 * pi) - bessel_func_log
return cp
def pdf(x, k, lam):
"""
PDF for the noncentral chi-square distribution.
"""
if x < 0:
return mpmath.mp.zero
with mpmath.extradps(5):
x = mpmath.mpf(x)
k = mpmath.mpf(k)
lam = mpmath.mpf(lam)
p = (mpmath.exp(-(x + lam) / 2) * mpmath.power(x / lam,
(k / 2 - 1) / 2) *
mpmath.besseli(k / 2 - 1, mpmath.sqrt(lam * x)) / 2)
return p
def pdf(x, nu, sigma):
"""
PDF for the Rice distribution.
"""
if x <= 0:
return mpmath.mp.zero
with mpmath.extradps(5):
x = mpmath.mpf(x)
nu = mpmath.mpf(nu)
sigma = mpmath.mpf(sigma)
sigma2 = sigma**2
p = ((x / sigma2) * mpmath.exp(-(x**2 + nu**2) / (2 * sigma2)) *
mpmath.besseli(0, x * nu / sigma2))
return p
def circ_vmpdf(alpha, thetahat, kappa):
alpha = alpha;
C = 1/(2*math.pi*mpmath.besseli(0,kappa));
aas = [];
for i in range(len(alpha)):
a = alpha[i]-thetahat
aa = math.exp(kappa*math.cos(a));
aas.append(aa);
aas = np.array(aas);
b = aas;
#b = float( math.exp(kappa*aas));
p = C * b;
return p ;
def mean(chi, c):
"""
Mean of the ARGUS distribution.
"""
if c <= 0:
raise ValueError('c must be positive')
if chi <= 0:
raise ValueError('chi must be positive')
with mpmath.extradps(5):
chi = mpmath.mpf(chi)
c = mpmath.mpf(c)
chi2o4 = chi**2 / 4
p1 = c * mpmath.sqrt(mpmath.pi / 8)
p2 = chi * mpmath.exp(-chi2o4)
p3 = mpmath.besseli(1, chi2o4)
return p1 * p2 * p3 / _psi(chi)
def VMFMeanDirDensity(x, k, p):
"""
This function is the tangent direction density of VMF distribution.
The inputs are:
x=Tangent value between [-1 1]
k=kappa parameter
p=Dimension of the VMF distribution
The output is y=density of the VMF tangent density
"""
for i in range(0, len(x)):
if (x[i] < -1.0 or x[i] > 1.0):
sys.exit('Input of x must be within -1 to 1')
coeff = float((k / 2)**(p / 2 - 1) * (mpmath.gamma(
(p - 1) / 2) * mpmath.gamma(1 / 2) * mpmath.besseli(p / 2 - 1, k))
**(-1))
#sp.special.gamma((p-1)/2) becoming infinity
y = coeff * np.exp(k * x) * np.power((1 - np.square(x)), ((p - 2) / 2))
return y
def psi(index, variable, b, a, beta):
if b == 0:
if beta < 0:
return math.pow(variable, 0.5) * besseli(
v(beta), sqrt(2 * index * q(a, beta, variable)))
else:
return math.pow(variable, 0.5) * besselk(
v(beta), sqrt(2 * index * q(a, beta, variable)))
else:
if beta < 0:
return math.pow(variable, beta + 0.5) * math.exp(
0.5 * eps(b, beta) * h(b, a, beta, variable)) * whitm(
k(b, beta, index), m(beta), h(b, a, beta, variable))
else:
return math.pow(variable, beta + 0.5) * math.exp(
0.5 * eps(b, beta) * h(b, a, beta, variable)) * whitw(
k(b, beta, index), m(beta), h(b, a, beta, variable))
def _noncentral_chi_pdf(t, df, nc):
res = mpmath.besseli(df/2 - 1, mpmath.sqrt(nc*t))
res *= mpmath.exp(-(t + nc)/2)*(t/nc)**(df/4 - 1/2)/2
return res
def test_besseli_complex(self):
assert_mpmath_equal(
lambda v, z: sc.iv(v.real, z),
_exception_to_nan(lambda v, z: mpmath.besseli(v, z, **HYPERKW)),
[Arg(-1e100, 1e100), ComplexArg()])
def test_besseli(self):
assert_mpmath_equal(
sc.iv,
_exception_to_nan(lambda v, z: mpmath.besseli(v, z, **HYPERKW)),
[Arg(-1e100, 1e100), Arg()],
n=1000)
def hp_ive(n,x):
return mpm.exp(-x)*mpm.besseli(n, x)
def f14(x):
# bessel_I0_scaled
scale = mpmath.exp(-abs(x))
y = mpmath.besseli(0, x) * scale
return y
def sph_i1n_bessel(n, z):
out = besseli(n + mpf(1)/2, z)*sqrt(pi/(2*z))
if mpmathify(z).imag == 0:
return out.real
else:
return out
def test_besseli_complex(self):
assert_mpmath_equal(lambda v, z: sc.iv(v.real, z),
_exception_to_nan(lambda v, z: mpmath.besseli(v, z, **HYPERKW)),
[Arg(-1e100, 1e100), ComplexArg()])
def f28(x):
# bessel_i2_scaled
x = mpmath.mpf(x)
y = mpmath.sqrt(mpmath.pi /
(2 * x)) * mpmath.besseli(2.5, x) * mpmath.exp(-abs(x))
def f27(x):
# bessel_i1_scaled
x = mpmath.mpf(x)
y = mpmath.sqrt(mpmath.pi /
(2 * x)) * mpmath.besseli(1.5, x) * mpmath.exp(-abs(x))
return y
def _noncentral_chi_pdf(t, df, nc):
res = mpmath.besseli(df/2 - 1, mpmath.sqrt(nc*t))
res *= mpmath.exp(-(t + nc)/2)*(t/nc)**(df/4 - 1/2)/2
return res
def Gamma0(b):
return mp.besseli(0, b) * mp.exp(-b)
def Gamma0(b) : return mp.besseli(0,b)*mp.exp(-b) def Gamma1(b) : return mp.besseli(1,b)*mp.exp(-b)
def Gamma0(b) : return mp.besseli(0,b)*mp.exp(-b) # Plasma Dispersion function def Z(x): return (1.j * mp.sqrt(mp.pi) * mp.exp(- x**2) * (1 + mp.erf(1.j * x)))
def f12(x):
# bessel_I0
return mpmath.besseli(0, x)
def test_besseli(self):
assert_mpmath_equal(sc.iv,
_exception_to_nan(lambda v, z: mpmath.besseli(v, z, **HYPERKW)),
[Arg(-1e100, 1e100), Arg()],
n=1000)
def f13(x):
# bessel_I1
return mpmath.besseli(1, x)
def von_Mises_pdf(x,kappa,mu=mpmath.pi):
return (mpmath.exp(kappa*mpmath.cos(x-mu))/
(2*mpmath.pi*mpmath.besseli(0,kappa)))
def Gamma1(b) : return mp.besseli(1,b)*mp.exp(-b) #def Gamma1(b) : return #mp.besseli(1,b)*mp.exp(-b) def getZero(Func, init=(1.+1.j, 1.1+1.j, 1.+1.1j), solver='muller', ftol=1.e-3, tol=1.e-3, maxsteps=600):
def Gamma1(b):
return mp.besseli(1, b) * mp.exp(-b)
@author: jdesk
"""
import numpy as np
#from mpmath import *
import mpmath as mpm
mpm.mp.dps = 25; mpm.mp.pretty = True
A = mpm.hyp1f1(2, (-1,3), 3.25)
print(A)
print(mpm.hyp1f1(3, 4, 1E20))
B = np.ones(100, dtype = np.float128)
print(B)
for n in range(100):
B[n] = mpm.exp(10*n)
print(mpm.exp(20*(-n)))
print(mpm.exp(20*(-n))*mpm.exp(20*(n)))
print(B)
C = np.arange(10)
#print(mpm.exp(C))
D = mpm.besseli()
def sph_i2n_bessel(n, z):
out = besseli(- n - mpf(1)/2, z)*sqrt(pi/(2*z))
return out
def f15(x):
# bessel_I1_scaled
scale = mpmath.exp(-abs(x))
y = mpmath.besseli(1, x) * scale
return y
from math import gamma # Been there a while
#has_scipy = False
if has_scipy:
from scipy.special import lambertw, ellipe, gammaincc, gamma # fluids
from scipy.special import i1, i0, k1, k0, iv # ht
from scipy.special import hyp2f1
if erf is None:
from scipy.special import erf
else:
import mpmath
# scipy is not available... fall back to mpmath as a Pure-Python implementation
from mpmath import lambertw # Same branches as scipy, supports .real
from mpmath import ellipe # seems the same so far
# Figured out this definition from test_precompute_gammainc.py in scipy
gammaincc = lambda a, x: mpmath.gammainc(a, a=x, regularized=True)
iv = mpmath.besseli
i1 = lambda x: mpmath.besseli(1, x)
i0 = lambda x: mpmath.besseli(0, x)
k1 = lambda x: mpmath.besselk(1, x)
k0 = lambda x: mpmath.besselk(0, x)
if erf is None:
from mpmath import erf
def von_Mises_entropy_fraction(kappa):
I0_kappa = mpmath.besseli(0,kappa)
I1_kappa = mpmath.besseli(1,kappa)
kappa_entropy = mpmath.ln(2*mpmath.pi*I0_kappa) - kappa*(I1_kappa/I0_kappa)
return 1-(kappa_entropy/von_Mises_entropy_max())
