def noisy_shot_noise(X, g, e):
"""
Returns the pdf of a normalized gamma distributed process with additive noise.
Let z ~ Gamma(g,A), y ~ Normal(0,s^2), x = z+y.
Input:
X: The normalized variable X = (x-<x>)/x_rms, 1d numpy array
g: shape parameter
e: noise parameter, e=y_rms^2 / z_rms^2.
Output:
F: The pdf of X.
"""
F = np.zeros(len(X))
# print 'g = ', g, ', type(g) = ', type(g)
# print 'e = ', e, ', type(e) = ', type(e)
assert (g > 0)
assert (e > 0)
g = mm.mpf(g)
e = mm.mpf(e)
for i in range(len(X)):
x = mm.mpf(X[i])
# F[i] = (g/2)**(g/2)*e**(g/2-1)*(1+e)**(1/2)*mm.exp( - ((1+e)**(1/2)*x+g**(1/2))**2 / (2*e) ) *\
#( e**(1/2)*mm.hyp1f1(g/2,1/2, ((1+e)**(1/2)*x+g**(1/2)*(1-e))**2 / (2*e) ) / (2**(1/2) * mm.gamma((1+g)/2)) +\
#( (1+e)**(1/2)*x+g**(1/2)*(1-e) )*mm.hyp1f1((1+g)/2,3/2, ((1+e)**(1/2)*x+g**(1/2)*(1-e))**2 / (2*e) ) / mm.gamma(g/2) )
F[i] = (g * 0.5)**(g * 0.5) * e**(g * 0.5 - 1.) * (1. + e)**(0.5) * mm.exp(-((1. + e)**(0.5) * x + g**(0.5))**(2.0) / (2.0 * e) ) *\
(e ** (0.5) * mm.hyp1f1(0.5 * g, 0.5, ((1. + e)**(0.5) * x + g**(0.5) * (1. - e))**2 / (2. * e)) / (2.**(0.5) * mm.gamma((1. + g) * 0.5)) +
((1. + e)**(0.5) * x + g**(0.5) * (1. - e)) * mm.hyp1f1((1. + g) * 0.5, 1.5, ((1. + e)**(0.5) * x + g**(0.5) * (1. - e))**2 / (2. * e)) / mm.gamma(g * 0.5))
return F
def dump_reference_json():
sys.path.insert(0, os.path.join(root, "build/"))
sys.path.insert(0, os.path.join(root, "tests/"))
mp.dps = 200
data = []
for l in range(20):
for n in range(20):
# z > 660 will lead to larger than double::max() values for a > 19
for z in [
1e-2,
1e-1,
1,
10,
20,
30,
40,
60,
80,
100,
150,
200,
500,
660,
]:
a = 0.5 * (n + l + 3)
b = l + 1.5
val = float(hyp1f1(a, b, z))
der = float(a / b * hyp1f1(a + 1, b + 1, z))
data.append(dict(a=a, b=b, z=z, val=val, der=der))
print(len(data))
with open(os.path.join(root, dump_path, "hyp1f1_reference.ubjson"),
"wb") as f:
ubjson.dump(data, f)
def U_Kummer_mpmath(a, x):
factor = np.sqrt(np.pi) * 2**(-0.25 - 1 / 2. * a)
factor_2 = np.sqrt(np.pi) * 2**(0.25 - 1 / 2. * a) * x
first_term = factor * mpmath.hyp1f1(
0.5 * a + 0.25, 0.5, 0.5 * x**2) / mpmath.gamma(0.75 + 0.5 * a)
second_term = factor_2 * mpmath.hyp1f1(
0.5 * a + 0.75, 1.5, 0.5 * x**2) / mpmath.gamma(0.25 + 0.5 * a)
return first_term + second_term
def recurrence_step_feedback(prms, M, precision=500):
"""Compute feedback model solution via the recurrence method.
Arguments:
parameters -- List of the five rate parameters: ru, rb, th, su, sb
M -- Number of terms evaluated by the recursion relation
precision -- Decimal precision used by the mpmath mpf type"""
mpm.mp.dps = precision
def update(nn, h0m2, h0m1, h1m2, h1m1):
n = mpm.mpf(nn)
u1 = mpm.mpf(1)/(sb*n)*((th + su)*h1m1 + su*h1m2 - \
(sb + mpm.mpf(1))*(n - mpm.mpf(1))*h0m1 + ru*h0m2)
u2 = (rb + su) / n * h1m1 - (sb + mpm.mpf(1)) * u1 + ru / n * h0m1
return [u1, u2]
# Set up parameters
ru = mpm.mpf(prms[0])
rb = mpm.mpf(prms[1])
th = mpm.mpf(prms[2])
su = mpm.mpf(prms[3])
sb = mpm.mpf(prms[4])
Sb = mpm.mpf(1) + sb
Rr = ru - rb * Sb
Cc = (Sb - mpm.mpf(1)) / Sb
al = th + su / Rr * (ru - rb)
bet = mpm.mpf(1) + th + mpm.mpf(1) / Sb * (su + ru * Cc)
w_1 = Rr * (Sb - mpm.mpf(1)) / (Sb**mpm.mpf(2))
Aa = mpm.mpf(1)/(Sb*al/(sb*ru)*mpm.hyp1f1((al + 1), (bet), (w_1)) + \
(mpm.mpf(1) + (th - al)/(ru - rb))*mpm.hyp1f1((al), (bet), (w_1)))
h0Ini = Aa*(Sb*al/(sb*ru)*mpm.hyp1f1((al + 1), (bet), (w_1)) + \
((th - al)/(ru - rb))*mpm.hyp1f1((al), (bet), (w_1)))
h1Ini = Aa * mpm.hyp1f1((al), (bet), (w_1))
h01Ini = mpm.mpf(1) / sb * (th + su) * h1Ini
hh = [[h0Ini, h1Ini]]
u2 = (rb + su) * h1Ini - (sb + mpm.mpf(1)) * h01Ini + ru * h0Ini
hh.append([h01Ini, u2])
for n in range(2, M):
hh.append(
update(n, hh[n - 2][0], hh[n - 1][0], hh[n - 2][1], hh[n - 1][1]))
G = np.sum(hh, 1)
return G
def kummer_log(a,b,x):
## First try using the funcion in the library.
## If it is 0 or inf then we try to use our own implementation with logs
## If it does not converge, then we return None !!
a = float(a); b = float(b); x = float(x)
# f_scipy = scipy_hyp1f1(a,b,x)
f_mpmath = mpmath.hyp1f1(a,b,x)
f_log = float(mpmath.log(f_mpmath))
if (np.isinf(f_log) == True):
# warnings.warn("hyp1f1() is 'inf', trying log version, (a,b,x) = (%f,%f,%f)" %(a,b,x),UserWarning, stacklevel=2)
f_log = kummer_own_log(a,b,x)
# print f_log
elif(f_mpmath == 0):
# warnings.warn("hyp1f1() is '0', trying log version, (a,b,x) = (%f,%f,%f)" %(a,b,x),UserWarning, stacklevel=2)
raise RuntimeError('Kummer function is 0. Kappa = %f', "Kummer_is_0", x)
# f_log = kummer_own_log(a,b,x) # TODO: We cannot do negative x, the functions is in log
else:
# f_log = np.log(f_scipy)
f_log = f_log
# print (a,b,x)
# print f_log
f_log = float(f_log)
return f_log
def kummer_log(a, b, x):
## First try using the funcion in the library.
## If it is 0 or inf then we try to use our own implementation with logs
## If it does not converge, then we return None !!
a = float(a)
b = float(b)
x = float(x)
# f_scipy = scipy_hyp1f1(a,b,x)
f_mpmath = mpmath.hyp1f1(a, b, x)
f_log = float(mpmath.log(f_mpmath))
if (np.isinf(f_log) == True):
# warnings.warn("hyp1f1() is 'inf', trying log version, (a,b,x) = (%f,%f,%f)" %(a,b,x),UserWarning, stacklevel=2)
f_log = kummer_own_log(a, b, x)
# print f_log
elif (f_mpmath == 0):
# warnings.warn("hyp1f1() is '0', trying log version, (a,b,x) = (%f,%f,%f)" %(a,b,x),UserWarning, stacklevel=2)
raise RuntimeError('Kummer function is 0. Kappa = %f', "Kummer_is_0",
x)
# f_log = kummer_own_log(a,b,x) # TODO: We cannot do negative x, the functions is in log
else:
# f_log = np.log(f_scipy)
f_log = f_log
# print (a,b,x)
# print f_log
f_log = float(f_log)
return f_log
def binMRlogL(n, Ic, Is):
'''
Given a light curve, calculate the Log likelihood that
its intensity distribution follows a blurred modified Rician with Ic, Is.
INPUTS:
n: 1d array containing the (binned) intensity as a function of time, i.e. a lightcurve [counts/sec]. Bin size must be fixed.
Ic: Coherent portion of MR [1/second]
Is: Speckle portion of MR [1/second]
OUTPUTS:
[float] the Log likelihood.
'''
lnL = np.zeros(len(n))
tmp = np.zeros(len(n))
for ii in range(len(n)): # hyp1f1 can't do numpy arrays because of its data type, which is mpf
tmp[ii] = float(hyp1f1(n[ii] + 1, 1, Ic / (Is ** 2 + Is)))
# dprint(np.log(1. / (Is + 1)))
# dprint(- n * np.log(1 + 1. / Is))
# dprint(- Ic / Is)
# dprint(np.log(tmp))
lnL = np.log(1. / (Is + 1)) - n * np.log(1 + 1. / Is) - Ic / Is + np.log(tmp)
# dprint(np.sum(lnL))
return np.sum(lnL)
def blurredMR(n, Ic, Is):
"""
Calculates the probability of getting a bin with n counts given Ic & Is.
n, Ic, Is must have the same units.
INPUTS:
n - array of the number of counts you want to know the probability of encountering. numpy array, can have length = 1. Units are the same as Ic & Is
Ic - the constant part of the speckle pattern [counts/time]. User needs to keep track of the bin size.
Is - the random part of the speckle pattern [units] - same as Ic
OUTPUTS:
p - array of probabilities
EXAMPLE:
n = np.arange(8)
Ic,Is = 4.,6.
p = blurredMR(n,Ic,Is)
plt.plot(n,p)
#plot the probability distribution of the blurredMR vs n
n = 5
p = blurredMR(n,Ic,Is)
#returns the probability of getting a bin with n counts
"""
n = n.astype(int)
p = np.zeros(len(n))
for ii in range(len(n)):
p[ii] = 1 / (Is + 1) * (1 + 1 / Is)**(-n[ii]) * np.exp(
-Ic / Is) * hyp1f1(float(n[ii]) + 1, 1, Ic / (Is**2 + Is))
return p
def make_plot(a, b, z, title, maxterms):
approx, terms = optimal_terms.asymptotic_series(a, b, z, maxterms)
ref = np.float64(mpmath.hyp1f1(a, b, z))
cd = correct_digits(approx, ref)
termsize = np.abs(terms/terms[0])
fig, ax1 = plt.subplots()
ax1.plot(cd, '-', linewidth=2, color=GREEN)
ax1.set_ylim(0, 17)
ax1.set_xlabel('term number')
# Make the y-axis label and tick labels match the line color.
ax1.set_ylabel('correct digits', color=GREEN)
for tl in ax1.get_yticklabels():
tl.set_color(GREEN)
ax2 = ax1.twinx()
cmap, norm = colors.from_levels_and_colors([-np.inf, 0, np.inf],
[BLUE, RED])
ax2.scatter(np.arange(termsize.shape[0]), termsize,
c=terms, cmap=cmap, norm=norm, edgecolors='')
# ax2.semilogy(termsize, 'r--', linewidth=2)
ax2.set_yscale('log')
ax2.set_ylabel('relative term size', color=RED)
# Set the limits, with a little margin.
ax2.set_xlim(0, termsize.shape[0])
ax2.set_ylim(np.min(termsize), np.max(termsize))
for tl in ax2.get_yticklabels():
tl.set_color(RED)
ax1.set_title("a = {:.2e}, b = {:.2e}, z = {:.2e}".format(a, b, z))
plt.savefig("{}.png".format(title))
def multiprec_pdf(df, mu, x):
df = mp.mpf(str(df))
mu = mp.mpf(str(mu))
x = mp.mpf(str(x))
pdf = (mp.exp(-mu**2 / 2) * 2**(-df) * df**(df/2) * mp.gamma(df+1) * \
((mp.sqrt(2) * x * mu * (x**2+df)**(-df/2-1) * mp.hyp1f1(df/2+1,1.5,(mu**2 * x**2)/(2 * (x**2+df))))/(mp.gamma((df+1)/2))+((x**2+df)**(-df/2-0.5) * mp.hyp1f1((df+1)/2,0.5,(mu**2 * x**2)/(2 * (x**2+df))))/(mp.gamma(df/2+1))))/(mp.gamma(df/2))
return pdf
def multiprec_pdf(df, mu, x):
df = mp.mpf(str(df))
mu = mp.mpf(str(mu))
x = mp.mpf(str(x))
pdf = (mp.exp(-mu**2 / 2) * 2**(-df) * df**(df/2) * mp.gamma(df+1) * \
((mp.sqrt(2) * x * mu * (x**2+df)**(-df/2-1) * mp.hyp1f1(df/2+1,1.5,(mu**2 * x**2)/(2 * (x**2+df))))/(mp.gamma((df+1)/2))+((x**2+df)**(-df/2-0.5) * mp.hyp1f1((df+1)/2,0.5,(mu**2 * x**2)/(2 * (x**2+df))))/(mp.gamma(df/2+1))))/(mp.gamma(df/2))
return pdf
def o_function(l, k, r):
res = mpmath.hyp1f1(-1j / k + l, 2 * l + 2, -2 * 1j * k * r)
res *= (1. / (2 * l + 1)) * (k * r)**l
res *= mpmath.gamma(1 + 1j / k)
res *= mpmath.rf(-1j / k, l)
res *= (-2j)**l / mpmath.fac(2 * l)
res *= mpmath.exp(mpmath.pi / (2 * k))
return res
def test_hyp1f1(self):
assert_mpmath_equal(
_inf_to_nan(sc.hyp1f1),
_exception_to_nan(
lambda a, b, x: mpmath.hyp1f1(a, b, x, **HYPERKW)),
[Arg(-1e5, 1e5), Arg(-1e5, 1e5),
Arg()],
n=2000)
def test_hyp1f1_complex(self):
assert_mpmath_equal(
_inf_to_nan(lambda a, b, x: sc.hyp1f1(a.real, b.real, x)),
_exception_to_nan(
lambda a, b, x: mpmath.hyp1f1(a, b, x, **HYPERKW)),
[Arg(-1e3, 1e3), Arg(-1e3, 1e3),
ComplexArg()],
n=2000)
def reference_value(a, b, z):
mpmath.mp.dps = 20
try:
lo = mpmath.hyp1f1(a, b, z, maxprec=MAXPREC)
except ZeroDivisionError:
# Pole in hypergeometric series
return np.inf
return np.float64(lo)
def spherical_hypergeometric(
max_radial, max_angular, atomic_gaussian_constants, gto_gaussian_constants, all_rij
):
# Compute everything up to 50 decimal places
math.mp.dps = 50
n_rij = len(all_rij)
n_constants = len(atomic_gaussian_constants)
values = np.zeros(
(n_constants, n_rij, max_radial, max_angular + 1), dtype=np.float64
)
gradients = np.zeros(
(n_constants, n_rij, max_radial, max_angular + 1), dtype=np.float64
)
for i_atomic_constant, c in enumerate(atomic_gaussian_constants):
for i_rij, rij in enumerate(all_rij):
for n in range(max_radial):
for l in range(max_angular + 1): # noqa: E741
a = (n + l + 3) / 2.0
b = l + 1.5
d = gto_gaussian_constants[n]
z = c * c * rij * rij / (c + d)
gamma_ratio = math.gamma(a) / math.gamma(b)
value = (
gamma_ratio * math.exp(-c * rij * rij) * math.hyp1f1(a, b, z)
)
values[i_atomic_constant, i_rij, n, l] = value
grad_factor = 2.0 * a * c * c * rij / (b * (c + d))
grad = (
grad_factor
* gamma_ratio
* math.exp(-c * rij * rij)
* math.hyp1f1(a + 1.0, b + 1.0, z)
)
gradients[i_atomic_constant, i_rij, n, l] = (
grad - 2.0 * c * rij * value
)
return values, gradients
def dump_reference_json():
path = '../'
sys.path.insert(0, os.path.join(path, 'build/'))
sys.path.insert(0, os.path.join(path, 'tests/'))
mp.dps = 200
data = []
for l in range(20):
for n in range(20):
for z in [1e-2, 1e-1, 1, 10, 20, 30, 40, 60, 80, 100, 150, 200]:
a = 0.5 * (n + l + 3)
b = l + 1.5
val = float(hyp1f1(a, b, z))
der = float(a / b * hyp1f1(a + 1, b + 1, z))
data.append(dict(a=a, b=b, z=z, val=val, der=der))
print(len(data))
with open(path + "tests/reference_data/hyp1f1_reference.ubjson",
'wb') as f:
ubjson.dump(data, f)
def G(self,s): # Laplace-Transform
zz = 2*self.v + 2 + s
mu = sqrt(self.v**2+2*zz)
a = mu/2 - self.v/2 - 1
b = mu/2 + self.v/2 + 2
v1 = (2*self.alp)**(-a)*gamma(b)/gamma(mu+1)/(zz*(zz - 2*(1 + self.v)))
prec = floor(max(log10(abs(v1)),mp.dps))+self.prec
# additional precision needed for computation of hyp1f1
with mp.extradps(prec):
value = hyp1f1(a,mu + 1,self.beta)*v1
return value
def e_mean_n(sk, mk, shape, k):
"""
E(|mean^shape|)
"""
temp = []
for cluster in range(k):
p = (1 / math.sqrt(sk[cluster])) ** shape * 2 ** (shape / 2) * gamma((1 + shape) / 2) / math.sqrt(
math.pi) * mpmath.hyp1f1(-shape / 2, 1 / 2, -1 / 2 * mk[cluster] ** 2 * sk[0])
temp.append(p)
return np.asarray(temp).reshape(-1, 1)
def Asian(S, K, T, t, sig, r, N):
# Assigning multi precision
S = mpf(S)
K = mpf(K)
sig = mpf(sig)
T = mpf(T)
t = mpf(t)
r = mpf(r)
# Geman and Yor's variable
tau = mpf(((sig**2) / 4) * (T - t))
v = mpf(2 * r / (sig**2) - 1)
alp = mpf(sig**2 / (4 * S) * K * T)
beta = mpf(-1 / (2 * alp))
tau = mpf(tau)
N = mpf(N)
# Initiate the stepsize
h = 2 * pi / N
mp.dps = 100
c1 = mpf('0.5017')
c2 = mpf('0.6407')
c3 = mpf('0.6122')
c4 = mpc('0', '0.2645')
# The for loop is evaluating the Laplace inversion at each point theta which is based on the trapezoidal
# rule
ans = 0.0
for k in range(N / 2): # N/2 : symmetry
theta = -pi + (k + 0.5) * h
z = 2 * v + 2 + N / tau * (c1 * theta / tan(c2 * theta) - c3 +
c4 * theta)
dz = N / tau * (-c1 * c2 * theta / sin(c2 * theta)**2 +
c1 / tan(c2 * theta) + c4)
zz = N / tau * (c1 * theta / tan(c2 * theta) - c3 + c4 * theta)
mu = sqrt(v**2 + 2 * z)
a = mu / 2 - v / 2 - 1
b = mu / 2 + v / 2 + 2
G = (2 * alp)**(-a) * gamma(b) / gamma(mu + 1) * hyp1f1(
a, mu + 1, beta) / (z * (z - 2 * (1 + v)))
ans += exp(zz * tau) * G * dz
return 2 * exp(tau * (2 * v + 2)) * exp(
-r * (T - t)) * 4 * S / (T * sig**2) * h / (2j * pi) * ans
def equilibrium_biallelic(n, gamma, h, mutation_model, theta):
"""
n: sample size
gamma: scaled selection coefficient (2Ns)
mutation_model: can be ISM or recurrent (or reversible)
theta: scaled mutation rate.
"""
if mutation_model == "ISM":
print("warning: not implemented for ISM")
return np.zeros(n + 1)
elif mutation_model in ["recurrent", "reversible"]:
if h != 0.5:
print(
"warning: with recurrent mutations, steady state only returned "
" for h = 1/2.")
if not isinstance(theta, list):
theta_fd = theta_bd = theta
else:
theta_fd, theta_bd = theta
fs = np.zeros(n + 1)
if gamma is None or gamma == 0.0:
for i in range(n + 1):
fs[i] = (scisp.gammaln(n + 1) - scisp.gammaln(n - i + 1) -
scisp.gammaln(i + 1) + scisp.gammaln(i + theta_fd) +
scisp.gammaln(n - i + theta_bd))
fs += (scisp.gammaln(theta_fd + theta_bd) -
scisp.gammaln(theta_fd) - scisp.gammaln(theta_bd) -
scisp.gammaln(n + theta_fd + theta_bd))
fs = np.exp(fs)
else:
## unstable for large n
for i in range(n + 1):
fs[i] = np.exp(
scisp.gammaln(n + 1) - scisp.gammaln(n - i + 1) -
scisp.gammaln(i + 1) + scisp.gammaln(i + theta_fd) +
scisp.gammaln(n - i + theta_bd) -
scisp.gammaln(n + theta_fd + theta_bd)) * hyp1f1(
i + theta_fd, n + theta_fd + theta_bd, 2 * gamma)
return fs / np.sum(fs)
else:
raise ValueError(
f"{mutation_model} is not a valid mutation model, pick "
"from either ISM or recurrent / reversible")
def coulomb_wave_function(l, eta, rho):
# calculate C_l(eta) coef using alternate def
# norm_factor = 2**l * np.exp(-np.pi * eta / 2) * np.abs(
# gamma(l + 1 + 1.0j * eta)) / factorial(2 * l + 1)
product = np.arange(1.0, l + 1.0)
if l == 0:
product = np.array([1.0])
product = np.add.outer(eta**2, product**2)
product = np.prod(product, axis=1)
norm_factor = 2**l * np.sqrt(2 * np.pi * eta / (
np.exp(np.pi * eta * 2) - 1) * product) / factorial(2 * l + 1)
# return the f_l function
return_array = np.zeros(norm_factor.shape, dtype='complex128')
for idx in np.arange(norm_factor.shape[0]):
input_0 = complex(l + 1.0 - 1.0j * eta[idx])
input_1 = complex(2.0 * l + 2.0)
input_2 = 1.0j * 2.0 * rho[idx]
hyp = hyp1f1(input_0, input_1, input_2)
hyp = float(hyp.real) + 1.j * float(hyp.imag)
return_array[idx] = norm_factor[idx] * rho[idx]**(
l + 1) * np.exp(-1.0j * rho[idx]) * hyp
return return_array
def analytic_twostate(parameters, N):
""" Analytic steady state distribution for a two-state model (leaky telegraph).
Requires computation at high precision via mpm for accurate convergence of
the summation.
Arguments:
parameters -- List of the four rate parameters: v12,v21,K0,K1
N -- Maximal mRNA copy number. The distribution is evaluated for n=0:N-1"""
v12 = mpm.mpf(parameters[0])
v21 = mpm.mpf(parameters[1])
K0 = mpm.mpf(parameters[2])
K1 = mpm.mpf(parameters[3])
P = mpm.matrix(np.zeros(N)) # Preallocate at high precision
for n in range(N):
for r in range(n + 1):
mpmCalc = mpm.power(K1,n-r) * mpm.power(K0-K1,r) * mpm.exp(-K0) * \
mpm.hyp1f1(v12,v12+v21+r,K0-K1) / (mpm.factorial(n-r) * mpm.factorial(r))
P[n] += mpmCalc * fracrise_mpm(v21, v21 + v12, r)
P = np.array([float(p) for p in P])
return P / P.sum()
def R_final_kl(r, k, l, Z_eff):
return 4 * pi * (2*k*r)**l * abs( mp.gamma(l+1 - 1j*Z_eff / k / a0) ) * mp.exp(pi * Z_eff /2/k/a0) / mp.factorial(2*l+1) * (mp.expj(-k*r) * mp.hyp1f1(l+1+1j*Z_eff/k/a0, (2*l+2), 2j*k*r, maxterms=1000000)).real
def blurredMR2(x,Ic,Is):
p = np.zeros(len(x))
for ii in x:
p[ii] = 1/(Is + 1)*(1 + 1/Is)**(-ii)*np.exp(-Ic/Is)*hyp1f1(float(x[ii]) + 1,1,Ic/(Is**2 + Is))
return p
def hyp1f1(a, b, z):
#global mp
""" Computes the confluent hypergeometric function.
The parameters a, b, and z may be complex. Further, one or more of them may be numpy arrays.
"""
uselib = lib is not None and not use_mpmath
#if not uselib and mp is None:
# mp = __import__("mpmath")
p = PrmsAndInfo(c_int(max_iter), c_double(tol), c_int(0), c_double(0),
c_int(0))
if (np.ndim(a) + np.ndim(b) + np.ndim(z) > 1):
l = [len(x) for x in (a, b, z) if hasattr(x, "__len__")]
if l[1:] != l[:-1]:
raise TypeError(
"if more than one parameter is a numpy array, they have to have the same length"
)
a, b, z = [
np.ones(l[0]) * x if not hasattr(x, "__len__") else x
for x in (a, b, z)
]
if uselib:
out = np.zeros(l[0], dtype=np.complex128)
lib.hyp1f1_all_arr(a.astype(np.complex128),
b.astype(np.complex128),
z.astype(np.complex128), out, len(out),
byref(p))
if not nofallback and p.prec_warning or not uselib:
out = np.array(
[mp.hyp1f1(aa, bb, zz) for aa, bb, zz in zip(a, b, z)],
dtype=np.complex128)
return out
if (np.ndim(a) == 1):
if uselib:
out = np.zeros(len(a), dtype=np.complex128)
lib.hyp1f1_a_arr(a.astype(np.complex128), cmpl(b), cmpl(z), out,
len(out), byref(p))
if not nofallback and p.prec_warning or not uselib:
out = np.array([mp.hyp1f1(aa, b, z) for aa in a],
dtype=np.complex128)
return out
elif (np.ndim(b) == 1):
if uselib:
out = np.zeros(len(b), dtype=np.complex128)
lib.hyp1f1_b_arr(cmpl(a), b.astype(np.complex128), cmpl(z), out,
len(out), byref(p))
if not nofallback and p.prec_warning or not uselib:
out = np.array([mp.hyp1f1(a, bb, z) for bb in b],
dtype=np.complex128)
return out
elif (np.ndim(z) == 1):
if uselib:
out = np.zeros(len(z), dtype=np.complex128)
lib.hyp1f1_z_arr(cmpl(a), cmpl(b), z.astype(np.complex128), out,
len(out), byref(p))
if not nofallback and p.prec_warning or not uselib:
out = np.array([mp.hyp1f1(a, b, zz) for zz in z],
dtype=np.complex128)
return out
else:
if uselib:
c = lib.hyp1f1(cmpl(a), cmpl(b), cmpl(z), byref(p))
out = c.re + 1j * c.im
if not nofallback and p.prec_warning or not uselib:
out = np.complex128(mp.hyp1f1(a, b, z))
return out
def hyp_mpm_memo(lamda, mu, k, r):
return mpm.hyp1f1(lamda + r, mu + lamda + r, -k)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 17 22:21:02 2019
@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)
def recur_cosin_high_dim(x, m):
fz = hyp1f1(m / 2., 1. / 2., -x)
if fz.imag > 0:
print("hyp1f1 has imaginary part")
return 2 * (1 - fz.real)
def blurredMR(x, Ic, Is):
p = np.zeros(len(x))
for ii in x:
p[ii] = 1 / (Is + 1) * (1 + 1 / Is)**(-ii) * np.exp(-Ic / Is) * hyp1f1(
float(x[ii]) + 1, 1, Ic / (Is**2 + Is))
return p
def test_hyp1f1(self):
assert_mpmath_equal(_inf_to_nan(sc.hyp1f1),
_exception_to_nan(lambda a, b, x: mpmath.hyp1f1(a, b, x, **HYPERKW)),
[Arg(-1e5, 1e5), Arg(-1e5, 1e5), Arg()],
n=2000)
def float_mp_hyp1f1(a, b, x):
try:
return float(mpmath.hyp1f1(a, b, x))
except TypeError as e:
return numpy.nan
energetic barrier between the inactive and the active state.
logC : Bool.
boolean indicating if the concentration is given in log scale
Returns
-------
p_act : float.
The probability of the repressor being in the active state.
'''
return (1 + R / Nns * p_act(C, ka, ki, epsilon, logC) * np.exp(-eRA))**-1
# TWO-STATE PROMOTER
# define a np.frompyfunc that allows us to evaluate the sympy.mp.math.hyp1f1
np_log_hyp = np.frompyfunc(lambda x, y, z:
mpmath.ln(mpmath.hyp1f1(x, y, z, zeroprec=1000)), 3, 1)
def log_p_m_unreg(mRNA, kp_on, kp_off, gm, rm):
'''
Computes the log probability lnP(m) for an unregulated promoter,
i.e. the probability of having m mRNA.
Parameters
----------
mRNA : float.
mRNA copy number at which evaluate the probability.
kp_on : float.
rate of activation of the promoter in the chemical master equation
kp_off : float.
rate of deactivation of the promoter in the chemical master equation
def test_hyp1f1_complex(self):
assert_mpmath_equal(_inf_to_nan(lambda a, b, x: sc.hyp1f1(a.real, b.real, x)),
_exception_to_nan(lambda a, b, x: mpmath.hyp1f1(a, b, x, **HYPERKW)),
[Arg(-1e3, 1e3), Arg(-1e3, 1e3), ComplexArg()],
n=2000)
def analyze():
# set parameters
ky = 0.5*math.pi
kx0 = -2.0*math.pi
Omega0 = 0.001
qshear = 1.5
kappa2 = 2.0*(2.0-qshear)*Omega0**2.0
cs = 0.001
constC = 0.5*(cs**2.0*ky**2.0+kappa2)/(qshear*Omega0*cs*ky)
c1 = -1.82085106245
c2 = -0.8208057072217868
# read results of SSEET_SHWAVE
fname = 'bin/SSHEET_SHWAVE.hst'
a = athena_read.hst(fname)
time1 = a['time']
dvyc1 = a['dvyc']
dvys1 = a['dvys']
nf1 = len(time1)
norm1c = 0.0
norm1s = 0.0
for n in range(nf1):
tau_ = qshear*Omega0*time1[n]+kx0/ky
T_ = 1.0j * cmath.sqrt(2.0*cs*ky/(qshear*Omega0))*tau_
exp_ = cmath.exp(-0.25j*T_*T_)
fterm_ = exp_*mp.hyp1f1(0.25-0.5j*constC, 0.5, 0.5j*T_*T_)
first_ = fterm_.real
exp_ = cmath.exp(0.25j*(math.pi-T_*T_))
sterm_ = exp_*T_*mp.hyp1f1(0.75-0.5j*constC, 1.5, 0.5j*T_*T_)
second_ = sterm_.real
advy = c1*first_+c2*second_
norm1c += abs(dvyc1[n]-advy)
norm1s += abs(dvys1[n])
norm1c /= nf1
norm1s /= nf1
# read results of SSEET_SHWAVE_ORB
fname = 'bin/SSHEET_SHWAVE_ORB.hst'
b = athena_read.hst(fname)
time2 = b['time']
dvyc2 = b['dvyc']
dvys2 = b['dvys']
nf2 = len(time2)
norm2c = 0.0
norm2s = 0.0
for n in range(nf2):
tau_ = qshear*Omega0*time2[n]+kx0/ky
T_ = 1.0j * cmath.sqrt(2.0*cs*ky/(qshear*Omega0))*tau_
exp_ = cmath.exp(-0.25j*T_*T_)
fterm_ = exp_*mp.hyp1f1(0.25-0.5j*constC, 0.5, 0.5j*T_*T_)
first_ = fterm_.real
exp_ = cmath.exp(0.25j*(math.pi-T_*T_))
sterm_ = exp_*T_*mp.hyp1f1(0.75-0.5j*constC, 1.5, 0.5j*T_*T_)
second_ = sterm_.real
advy = c1*first_+c2*second_
norm2c += abs(dvyc2[n]-advy)
norm2s += abs(dvys2[n])
norm2c /= nf2
norm2s /= nf2
logger.warning('[SSHEET_SHWAVE]: L1-Norm Errors')
msg = '[SSHEET_SHWAVE]: epsilon_c = {}, epsilon_s = {}'
flag = True
logger.warning('[SSHEET_SHWAVE]: w/o Orbital Advection')
logger.warning(msg.format(norm1c, norm1s))
if norm1c > 0.2:
logger.warning('[SSHEET_SHWAVE]: dvyc Error is more than 20%.')
flag = False
if norm1s > 0.01:
logger.warning('[SSHEET_SHWAVE]: dvys Error is more than 1%.')
flag = False
logger.warning('[SSHEET_SHWAVE]: w/ Orbital Advection')
logger.warning(msg.format(norm2c, norm2s))
if norm1c > 0.2:
logger.warning('[SSHEET_SHWAVE]: dvyc Error is more than 20%.')
flag = False
if norm1s > 0.01:
logger.warning('[SSHEET_SHWAVE]: dvys Error is more than 1%.')
flag = False
return flag
def float_mp_hyp1f1(a, b, x):
try:
return float(mpmath.hyp1f1(a, b, x))
except TypeError as e:
return numpy.nan
def reghyp1f1(a, b, z):
"""Regularized Hypergeometric 1F1 function."""
return float(mpmath.hyp1f1(a, b, z) / mpmath.gamma(b))
