def zernike_variance_von_karman(n, m, R, k0, Cn_squared, wavelength): '''Calculate the variance of the Zernike mode (`n`,`m`), using a von Karman turbulence spectrum. Parameters ---------- n : int The radial Zernike order. m : int The azimuthal Zernike order. R : scalar The radius of the aperture. k0 : scalar The spatial frequency of the outer scale (1/L0). Cn_squared : scalar The integrated Cn^2 profile. wavelength : scalar The wavelength at which to calculate the variance. Returns ------- scalar The variance of the specific Zernike mode. ''' A = 0.00969 * (2*np.pi / wavelength)**2 * Cn_squared coeffs_all = (-1)**(n - m) * 2 * (2 * np.pi)**(11./3) * (n + 1) * A * R**(5./3) / (sqrt(np.pi) * np.sin(np.pi * (n + 1./6))) term11 = mpmath.hyper([n + (3./2), n + 2, n + 1],[n + (1./6), n + 2, n + 2, 2 * n + 3], (2*np.pi * R * k0)**2) term12 = sqrt(np.pi) * (2*np.pi * R * k0)**(2 * n - 5./3) * scipy.special.gamma(n + 1) / (2**(2 * n + 3) * scipy.special.gamma(11./6) * scipy.special.gamma(n + 1./6) * scipy.special.gamma(n + 2)**2) term21 = -1 * scipy.special.gamma(7./3) * scipy.special.gamma(17./6) / (2 * scipy.special.gamma(-n + 11./6) * scipy.special.gamma(17./6)**2 * scipy.special.gamma(n + 23./6)) term22 = mpmath.hyper([11./6, 7./3, 17./6], [-n + 11./6, 17./6, 17./6, n + 23./6], (2*np.pi * R * k0)**2) return coeffs_all * (term11 * term12 + term21 * term22)
def prob_L_from_mut(L,ta,ts,phi,N, theta0=theta):
if L<200000 and L>0:
if phi>0.01:
b=0.5+0.25*L*rho*N+0.5*L*theta*N
c=(0.25+0.5*exp(ta/N)-0.5*exp(2*ta/N))*L*rho*N
prob1=phi*0.5*exp(0.5*L*((-1.5+exp(-ta/N))*N*rho-2*ta*theta)+c)*hyper(1,b+1,-c)/b
b+=0.5*theta0*N
c=(0.25+exp(ta/N)*(0.5-0.5*exp(ta/N)))*L*rho*N
prob2=-phi*0.5*exp(-0.75*L*rho*N+0.5*exp(-ta/N)*L*rho*N-ta*theta0-L*ta*theta+c)*hyper(1,b+1,-c)/b
else:
prob1, prob2 = 0,0
if phi<0.99:
b=0.5+0.25*L*rho*N+0.5*L*theta*N
c=(0.25+0.5*exp(ts/N)-0.5*exp(2*ts/N))*L*rho*N
prob3=(1-phi)*0.5*exp(0.5*L*((-1.5+exp(-ts/N))*N*rho-2*ts*theta)+c)*hyper(1,b+1,-c)/b
b+=0.5*theta0*N
c=(0.25+exp(ts/N)*(0.5-0.5*exp(ts/N)))*L*rho*N
prob4=-(1-phi)*0.5*exp(-0.75*L*rho*N+0.5*exp(-ts/N)*L*rho*N-ts*theta0-L*ts*theta+c)*hyper(1,b+1,-c)/b
else:
prob3, prob4=0,0
return abs(math.fsum((prob1,prob2,prob3,prob4)))
else:
prob=phi*(math.exp(-ta*L*(rho+theta))/(1+L*N*(rho+theta))-math.exp(-ta*(L*(rho+theta)+theta))/(1+L*(rho+theta)*N+theta*N))*(1+L*((-exp(-rho*ta)+1)/(1-rho*N)-rho*N*(1-exp(-ta))/(1-rho*N)))
prob+=(1-phi)*(math.exp(-ts*L*(rho+theta))/(1+L*(rho+theta)*N)-math.exp(-ts*(L*(rho+theta)+theta))/(1+L*(rho+theta)*N+theta*N))*(1+L*((-exp(-rho*ts)+1)/(1-rho*N)-rho*N*(1-exp(-ts))/(1-rho*N)))
return prob
def mhyper(self,q,m,n,k):
u = min(self.tag_length ,n)-1
A = binomial(m,q)*binomial(n,k-q)
B = hyper([1,q-k,q-m],[1+q,1-k+n+q], 1)
C = -binomial(m,1+u)*binomial(n,k-1-u)
D = hyper([1,1-k+u,1-m+u],[2+u,2-k+n+u], 1)
return mathlog(float((A*B + C*D) / binomial(m+n, k)))
def _eval_evalf(self, prec):
z = self.argument._to_mpmath(prec)
ap = [a._to_mpmath(prec) for a in self.ap]
bp = [b._to_mpmath(prec) for b in self.bq]
with mpmath.workprec(prec):
res = mpmath.hyper(ap, bp, z, eliminate=False)
return Expr._from_mpmath(res, prec)
def _eval_evalf(self, prec):
z = self.argument._to_mpmath(prec)
ap = [a._to_mpmath(prec) for a in self.ap]
bp = [b._to_mpmath(prec) for b in self.bq]
with mpmath.workprec(prec):
res = mpmath.hyper(ap, bp, z, eliminate=False)
return Expr._from_mpmath(res, prec)
def _f(q,γ,ϵ):
''' The distribution function. Checked with Mathematica on 2018-06-20
'''
a1 = [1/2]
b1 = [3/2,3/2-γ**2/2]
a2 = [γ**2/2]
b2 = [γ**2/2 + 1/2,γ**2/2+1]
zm = π*ϵ - q
zp = π*ϵ + q
p1 = Γ((γ**2-1)/2)/(2*np.sqrt(π)*Γ(γ**2/2))
p2 = Γ(-γ**2)*np.sin(π*γ**2 / 2) / π
t1 = p1*(zm*hyper(a1,b1,zm**2/4) + zp*hyper(a1,b1,zp**2/4))
t2 = p2*(np.sign(zm)*(np.abs(zm)**(γ**2))*hyper(a2,b2,zm**2/4) + zp**(γ**2) * hyper(a2,b2,zp**2/4))
cf = np.float(t1-t2)
if cf > 1.0E-16:
return np.float(t1-t2)
else:
return 0.0
def t2z_convert(t, nu):
t = mpf(t)
nu = mpf(nu)
z = sqrt(mpf("2")) * erfinv( # inverse normal cdf
mpf("2") * t *
gamma((mpf("1") / mpf("2")) * nu + mpf("1") / mpf("2")) * hyper(
(mpf("1") / mpf("2"),
(mpf("1") / mpf("2")) * nu + mpf("1") / mpf("2")),
(mpf("3") / mpf("2"), ),
-power(t, mpf("2")) / nu,
) / (sqrt(pi) * sqrt(nu) * gamma((mpf("1") / mpf("2")) * nu)))
return z
def fingerprint(p):
ret = np.log(p[0]**2) ## A constant factor
ret += s_values * np.log(
p[1]**
2) ## C^s for some C, together with previous cover most prefactors
ret += loggamma(p[2] + p[3] * s_values) ## A flexible gamma
ret += loggamma(p[4] + p[5] * s_values) ## A flexible gamma
hyp = [
complex(
hyper([p[6] * s + p[7], p[8] + p[9] * s], [p[10] + p[11] * s],
p[12])) for s in s_values
] ## slow generalised_hypergeom
ret += np.log(hyp)
# s_values**2 * np.log(p[6]**2) #+ s**3 * np.log(p[3]**2) + s**4 * np.log(p[4]**2) ## Strange series temrs
#ret += np.log(1 + p[5]*s_values + p[6]*s_values**2 + p[7]*s_values**3 + p[8]*s_values**4) ## Log of polynomial
return ret
def f02(a, b, z):
return mp.hyper([], [a, b], z)
class Turbines(object):
def __init__(self, x, y, HH, yaw, a, RD, W, ground):
self.loc = loc # Location in Space
self.RD = RD # Rotor Diameter
self.W = W # Width of influence
from scipy.special import gamma
from mpmath import hyper
T_norm = 2.0*gamma(7.0/6.0)
D_norm = 2.0*gamma(7.0/6.0)
S_norm = (2.0+pi)/(2.0*pi)
h1 = float(hyper([],[1/3, 2/3, 5/6, 7/6],-(np.pi**6/46656)))
h2 = float(hyper([],[2/3, 7/6, 4/3, 3/2],-(np.pi**6/46656)))
h3 = float(hyper([],[4/3, 3/2, 5/3, 11/6],-(np.pi**6/46656)))
SD_norm = (1/3*np.pi**(3/2)*h1 - 1/15*np.pi**3*gamma(11/6)*h2 + gamma(7/6)*(1 + 1/360*np.pi**5*h3))/(.81831)
volNormalization = T_norm*SD_norm*W*R**(self.problem.dom.dim)
#!/usr/bin/env python
'''
program: hypergeometric_functions_with_mpmath.py
author: tc
created: 2015-10-17 -- 11 CEST
description: computes some hypergeometric functions with mpmath, and checks
with Mathematica values.
notes: hyp0f1(a, z) fails at a=0, while the Mathematica version does not.
'''
import mpmath
a = [1, 1]
b = [3, 3, 3]
z = 2.0
res1 = float(mpmath.hyper(a, b, z))
res2 = float(mpmath.hyp0f1(1, 2))
print 'HypergeometricPFQ[{1, 1}, {3, 3, 3}, 2.0]: 1.07893'
print 'mpmath.hyper([1, 1], [3, 3, 3], 2.0): %f' % res1
print 'Hypergeometric0F1Regularized[1, 2]: 4.25235'
print 'mpmath.hyp0f1(1, 2): %f' % res2
