def _evaluate(self,R,z,phi=0.,t=0.,_forceFloatEval=False):
"""
NAME:
_evaluate
PURPOSE:
evaluate the potential at R,z
INPUT:
R - Galactocentric cylindrical radius
z - vertical height
phi - azimuth
t - time
OUTPUT:
Phi(R,z)
HISTORY:
2010-07-09 - Started - Bovy (NYU)
"""
if not _forceFloatEval and not self.integerSelf == None:
return self.integerSelf._evaluate(R,z,phi=phi,t=t)
elif self.beta == 3.:
r= numpy.sqrt(R**2.+z**2.)
return (1./self.a)\
*(r-self.a*(r/self.a)**(3.-self.alpha)/(3.-self.alpha)\
*special.hyp2f1(3.-self.alpha,
2.-self.alpha,
4.-self.alpha,
-r/self.a))/(self.alpha-2.)/r
else:
r= numpy.sqrt(R**2.+z**2.)
return special.gamma(self.beta-3.)\
*((r/self.a)**(3.-self.beta)/special.gamma(self.beta-1.)\
*special.hyp2f1(self.beta-3.,
self.beta-self.alpha,
self.beta-1.,
-self.a/r)
-special.gamma(3.-self.alpha)/special.gamma(self.beta-self.alpha))/r
def demon(n, d, g, kgiven=0):
ks = np.arange(n + 1)
c1, c2 = [], []
for k in ks:
a = hyp2f1(1, n - k + 1, n + 2, 1 - d)
b = 0 if g == 0 else hyp2f1(1, n - k + 1, n + 2, 1 - d * g)
c1.append(a * d - b * d * g)
c2.append(a)
plt.plot(ks / n, c1, label='c1')
plt.plot(ks / n, c2, label='c2')
plt.xlabel('k / n')
plt.ylabel('Effective n / n')
plt.legend()
plt.figure()
S = [100 * generalised_entropy_gain(n, k, d, g) for k in ks]
plt.plot(ks / n, S, label='S')
plt.xlabel('k / n')
plt.ylabel('information gain')
plt.figure()
dif = np.logspace(-1, 1, 100)
S = [100 * generalised_entropy_gain(n, kgiven, d, g) for d in dif]
plt.semilogx(dif, S, label='S')
plt.xlabel('difficulty')
plt.ylabel('information gain')
def Power_Spectrum_Real_Space_e1(f,x,modes_number):
n = modes_number + 1
if (n<2):
print "ERROR: It can not calculate the power spectrum of real space because the number of input points are not enough."
return 0
else:
mode = zeros(n)
amp = zeros(n)
amp[0] = float('inf')
# for j in range(1,len(t)):
# pk[0] += 0.5*(t[j]-t[j-1])*(x[j]+x[j-1])/2.0
for i in range(1,n):
A = 0.0
B = 0.0
for j in range(1,len(x)-1):
A += ( f[j]*sqrt(16.0*float(i+1)*float(i+2)/pi)*cos(x[j])**3*hyp2f1(-i,3+i,1.5,sin(x[j])**2)*tan(x[j])**2 \
+ f[j-1]*sqrt(16.0*float(i+1)*float(i+2)/pi)*cos(x[j-1])**3*hyp2f1(-i,3+i,1.5,sin(x[j-1])**2)*tan(x[j-1])**2 ) \
* (x[j]-x[j-1])/2.0
# B += -4.0*sqrt(2.0+3.0*float(i)+float(i)**2)/(3.0*(3.0+2.0*float(i))*sqrt(pi)) \
# *( f[j]*sin(x[j])*(4.0*float(i)*(3.0+float(i))*cos(x[j])**4*hyp2f1(1-i,4+i,2.5,sin(x[j])**2) \
# + 9.0*cos(x[j])**2*hyp2f1(-i,3+i,1.5,sin(x[j])**2) )*tan(x[j])**2\
# +f[j-1]*sin(x[j-1])*(4.0*float(i)*(3.0+float(i))*cos(x[j-1])**4*hyp2f1(1-i,4+i,2.5,sin(x[j-1])**2) \
# + 9.0*cos(x[j-1])**2*hyp2f1(-i,3+i,1.5,sin(x[j-1])**2) )*tan(x[j-1])**2 )\
# * (x[j]-x[j-1])/2.0
mode[i]= float(i)
amp[i] = (A**2 + B**2)/2.0
print "mode = ", mode[i], " & Amplitude = ", amp[i]
return (mode,amp)
def _A_0(params, freq, rec, T):
x = freq
r, alpha, s, beta = params
max_alpha_beta = max(alpha, beta)
min_alpha_beta = min(alpha, beta)
t = s + 1. if alpha > beta else r + x
r_s_x = r + s + x
return special.hyp2f1(r_s_x, t, r_s_x + 1., (max_alpha_beta - min_alpha_beta) / (max_alpha_beta + rec)) / (max_alpha_beta + rec) ** r_s_x\
- special.hyp2f1(r_s_x, t, r_s_x + 1., (max_alpha_beta - min_alpha_beta) / (max_alpha_beta + T)) / (max_alpha_beta + T) ** r_s_x
def _log_A_0(params, freq, rec, age):
r, alpha, s, beta = params
min_ab, max_ab, t = (alpha, beta, r + freq) if alpha < beta else (beta, alpha, s + 1)
abs_ab = max_ab - min_ab
rsx = r + s + freq
p_1, q_1 = special.hyp2f1(rsx, t, rsx + 1., abs_ab / (max_ab + rec)), (max_ab + rec)
p_2, q_2 = special.hyp2f1(rsx, t, rsx + 1., abs_ab / (max_ab + age)), (max_ab + age)
sign = np.ones(len(freq))
return misc.logsumexp([log(p_1) + rsx * log(q_2), log(p_2) + rsx * log(q_1)],
axis=0, b=[sign, -sign]) - rsx * log(q_1 * q_2)
def generalised_entropy_gain(n, k, d, g):
if abs(d - 1) < 1e-6: d = 1 + 1e-6
a = hyp2f1(1, n - k + 1, n + 2, 1 - d)
b = 0 if g == 0 else hyp2f1(1, n - k + 1, n + 2, 1 - d * g)
x = (a * d - b * d * g) * ((1 - g) * d * a - (1 - g * d)) / (d - 1) # * (k+1)/(n+2)#
y = a * (1 - g) * d * (1 - a) / (d - 1) # (n-k+1)/(n+2)#
H1 = H(k) - np.log(k + 1)
H2 = H(n - k) - np.log(n - k + 1)
Hn = H(n + 1) - np.log(n + 2) - 1. / (n + 2)
dS = (x * H1 + y * H2 - (x + y) * Hn)
return dS # , a*d - b*d*g, a
def ComovingDistance(z):
"""
line-of-sight comoving distance to a source at redshift z
units will be the same as D_H, defined above.
if O_K==0, this will compute the result analytically, using
hypergeometric functions.
if O_K!=0, this will compute the result using numerical integration
of the function 1/H(z). this case is omitted here.
"""
check(O_K_is_zero, 'the universe should be flat!')
return D_H*2/sqrt(O_M)*(hyp2f1(1./6, 1./2, 7./6, -O_L/O_M) - hyp2f1(1./6, 1./2, 7./6, -O_L/O_M/(1+z)**3) / sqrt(1+z))
def next_item(self, subtopic):
ids, difficulty, types, costs = self.items[subtopic]
n, k = subtopic.n, subtopic.k
dS = [generalised_entropy_gain(n, k, d, g) for d, g in zip(difficulty, types)]
dS /= costs
maxind = np.argmax(dS)
mask = list(xrange(maxind)) + list(xrange(maxind + 1, len(difficulty)))
# print maxind, mask
self.items[subtopic] = np.vstack((ids[mask], difficulty[mask], types[mask], costs[mask])) # remove after test
d, g = difficulty[maxind], types[maxind]
a = hyp2f1(1, n - k + 1, n + 2, 1 - d)
b = 0 if g == 0 else hyp2f1(1, n - k + 1, n + 2, 1 - d * g)
return (ids[maxind], d, g, costs[maxind]), a * d - b * d * g, a
def getExpectations(r, alpha, a, b, numdays):
expectations = dict()
for tt in range(1, numdays + 1):
t = tt / 7.0
x = special.hyp2f1(r, b, a + b - 1, t / (alpha + t))
expectations[tt] = ((a + b - 1) / (a - 1)) * ( 1 - ( (alpha / (alpha + t)) ** r ) * x)
return expectations
def SHOREmatrix_odf(radial_order, zeta, sphere_vertices):
"""Compute the SHORE matrix"
Parameters
----------
radial_order : unsigned int,
Radial Order
zeta : unsigned int,
scale factor
sphere_vertices : array, shape (N,3)
vertices of the odf sphere
"""
r, theta, phi = cart2sphere(sphere_vertices[:, 0], sphere_vertices[:, 1], sphere_vertices[:, 2])
theta[np.isnan(theta)] = 0
counter = 0
upsilon = np.zeros(
(len(sphere_vertices), (radial_order + 1) * ((radial_order + 1) / 2) * (2 * radial_order + 1)))
for n in range(radial_order + 1):
for l in range(0, n + 1, 2):
for m in range(-l, l + 1):
upsilon[:, counter] = (-1) ** (n - l / 2.0) * __kappa_odf(zeta, n, l) * \
hyp2f1(l - n, l / 2.0 + 1.5, l + 1.5, 2.0) * \
real_sph_harm(m, l, theta, phi)
counter += 1
return upsilon[:, 0:counter]
def expected_number_of_purchases_up_to_time(
self,
t
):
"""
Calculate the expected number of repeat purchases up to time t.
Calculate repeat purchases for a randomly chosen individual from the
population.
Equivalent to equation (9) of [2]_.
Parameters
----------
t: array_like
times to calculate the expection for
Returns
-------
array_like
References
----------
.. [2] Fader, Peter S., Bruce G.S. Hardie, and Ka Lok Lee (2005a),
"Counting Your Customers the Easy Way: An Alternative to the
Pareto/NBD Model," Marketing Science, 24 (2), 275-84.
"""
r, alpha, a, b = self._unload_params("r", "alpha", "a", "b")
hyp = hyp2f1(r, b, a + b - 1, t / (alpha + t))
return (a + b - 1) / (a - 1) * (1 - hyp * (alpha / (alpha + t)) ** r)
def conditional_expected_number_of_purchases_up_to_time(
self, t, frequency, recency, T):
"""
Conditinal expected number of repeat purchases up to time t.
Calculate the expected number of repeat purchases up to time t for a
randomly choose individual from the population, given they have
purchase history (frequency, recency, T)
See Wagner, U. and Hoppe D. (2008).
Parameters:
t: a scalar or array of times.
frequency: a scalar: historical frequency of customer.
recency: a scalar: historical recency of customer.
T: a scalar: age of the customer.
Returns: a scalar or array
"""
x = frequency
r, alpha, a, b = self._unload_params('r', 'alpha', 'a', 'b')
hyp_term = hyp2f1(r + x, b + x + 1, a + b + x, t / (alpha + T + t))
first_term = (a + b + x) / (a - 1)
second_term = (1 - hyp_term * ((alpha + T) / (alpha + t + T))**(r + x))
numerator = first_term * second_term
denominator = (1 + (a / (b + x)) * ((alpha + T) /
(alpha + recency))**(r + x))
return numerator / denominator
def msd(self):
r""" Calculates the analytical mean squared displacement (MSD) [1]_
..math::
:nowrap:
\begin{equation}
MSD:{DSI}=\int_{-\infty}^{\infty}\int_{-\infty}^{\infty}
\int_{-\infty}^{\infty} P(\hat{\mathbf{r}}) \cdot
\hat{\mathbf{r}}^{2} \ dr_x \ dr_y \ dr_z
\end{equation}
where $\hat{\mathbf{r}}$ is a point in the 3D propagator space (see Wu
et al. [1]_).
References
----------
.. [1] Wu Y. et al., "Hybrid diffusion imaging", NeuroImage, vol 36,
p. 617-629, 2007.
"""
msd = 0
c = self._shore_coef
for n in range(int(self.radial_order / 2) + 1):
msd += c[n] * (-1) ** n *\
(9 * (gamma(n + 1.5)) / (8 * np.pi ** 6 * self.zeta ** 3.5 *
factorial(n))) ** 0.5 *\
hyp2f1(-n, 2.5, 1.5, 2)
return np.clip(msd, 0, msd.max())
def odf_sh(self):
r""" Calculates the real analytical ODF in terms of Spherical
Harmonics.
"""
# Number of Spherical Harmonics involved in the estimation
J = (self.radial_order + 1) * (self.radial_order + 2) // 2
# Compute the Spherical Harmonics Coefficients
c_sh = np.zeros(J)
counter = 0
for n in range(self.radial_order + 1):
for l in range(0, n + 1, 2):
for m in range(-l, l + 1):
j = int(l + m + (2 * np.array(range(0, l, 2)) + 1).sum())
Cnl = (((-1)**
(n - l / 2)) / (2.0 * (4.0 * np.pi**2 * self.zeta)**(3.0 / 2.0)) * (
(2.0 * (4.0 * np.pi**2 * self.zeta)**
(3.0 / 2.0) * factorial(n - l)) / (gamma(n + 3.0 / 2.0)))**
(1.0 / 2.0))
Gnl = (gamma(l / 2 + 3.0 / 2.0) * gamma(3.0 / 2.0 + n)) / \
(gamma(l + 3.0 / 2.0) * factorial(n - l)) * \
(1.0 / 2.0) ** (-l / 2 - 3.0 / 2.0)
Fnl = hyp2f1(-n + l, l / 2 + 3.0 / 2.0, l + 3.0 / 2.0, 2.0)
c_sh[j] += self._shore_coef[counter] * Cnl * Gnl * Fnl
counter += 1
return c_sh
def _zforce(self, R, z, phi=0., t=0.):
"""
NAME:
_zforce
PURPOSE:
evaluate the vertical force for this potential
INPUT:
R - Galactocentric cylindrical radius
z - vertical height
phi - azimuth
t - time
OUTPUT:
the vertical force
HISTORY:
2010-07-09 - Written - Bovy (NYU)
"""
if self._specialSelf is not None:
return self._specialSelf._zforce(R, z, phi=phi, t=t)
else:
r = numpy.sqrt(R**2. + z**2.)
return -z/r**self.alpha*self.a**(self.alpha-3.)/(3.-self.alpha)\
*special.hyp2f1(3.-self.alpha,
self.beta-self.alpha,
4.-self.alpha,
-r/self.a)
def conditional_expected_number_of_purchases_up_to_time(self, t, frequency, recency, T):
"""
Calculate the expected number of repeat purchases up to time t for a randomly choose individual from
the population, given they have purchase history (frequency, recency, T)
See Wagner, U. and Hoppe D. (2008).
Parameters:
t: a scalar or array of times.
frequency: a scalar: historical frequency of customer.
recency: a scalar: historical recency of customer.
T: a scalar: age of the customer.
Returns: a scalar or array
"""
x = frequency
r, alpha, a, b = self._unload_params('r', 'alpha', 'a', 'b')
hyp_term = special.hyp2f1(r + x, b + x + 1, a + b + x, t / (alpha + T + t))
first_term = (a + b + x) / (a - 1)
second_term = (1 - hyp_term * ((alpha + T) / (alpha + t + T)) ** (r + x))
numerator = first_term * second_term
denominator = 1 + (a / (b + x)) * ((alpha + T) / (alpha + recency)) ** (r + x)
return numerator / denominator
def _Rforce(self, R, z, phi=0., t=0., _forceFloatEval=False):
"""
NAME:
_Rforce
PURPOSE:
evaluate the radial force for this potential
INPUT:
R - Galactocentric cylindrical radius
z - vertical height
phi - azimuth
t - time
OUTPUT:
the radial force
HISTORY:
2010-07-09 - Written - Bovy (NYU)
"""
if not _forceFloatEval and not self.integerSelf == None:
return self.integerSelf._Rforce(R, z, phi=phi, t=t)
else:
r = numpy.sqrt(R**2. + z**2.)
return -R/r**self.alpha*self.a**(self.alpha-3.)/(3.-self.alpha)\
*special.hyp2f1(3.-self.alpha,
self.beta-self.alpha,
4.-self.alpha,
-r/self.a)
def msd(self):
r""" Calculates the analytical mean squared displacement (MSD) [1]_
..math::
:nowrap:
\begin{equation}
MSD:{DSI}=\int_{-\infty}^{\infty}\int_{-\infty}^{\infty}
\int_{-\infty}^{\infty} P(\hat{\mathbf{r}}) \cdot
\hat{\mathbf{r}}^{2} \ dr_x \ dr_y \ dr_z
\end{equation}
where $\hat{\mathbf{r}}$ is a point in the 3D propagator space (see Wu
et. al [1]_).
References
----------
.. [1] Wu Y. et. al, "Hybrid diffusion imaging", NeuroImage, vol 36,
p. 617-629, 2007.
"""
msd = 0
c = self._shore_coef
for n in range(int(self.radial_order / 2) + 1):
msd += c[n] * (-1) ** n *\
(9 * (gamma(n + 1.5)) / (8 * np.pi ** 6 * self.zeta ** 3.5 *
factorial(n))) ** 0.5 *\
hyp2f1(-n, 2.5, 1.5, 2)
return np.clip(msd, 0, msd.max())
def resid_anscombe(self, Y, mu):
"""
The Anscombe residuals for the negative binomial family
Parameters
----------
Y : array-like
Endogenous response variable
mu : array-like
Fitted mean response variable
Returns
-------
resid_anscombe : array
The Anscombe residuals as defined below.
Notes
-----
`resid_anscombe` = (hyp2f1(-alpha*Y)-hyp2f1(-alpha*mu)+\
1.5*(Y**(2/3.)-mu**(2/3.)))/(mu+alpha*mu**2)**(1/6.)
where hyp2f1 is the hypergeometric 2f1 function parameterized as
hyp2f1(x) = hyp2f1(2/3.,1/3.,5/3.,x)
"""
hyp2f1 = lambda x: special.hyp2f1(2 / 3., 1 / 3., 5 / 3., x)
return (hyp2f1(-self.alpha*Y)-hyp2f1(-self.alpha*mu)+1.5*(Y**(2/3.)-\
mu**(2/3.)))/(mu+self.alpha*mu**2)**(1/6.)
def test_hyp2f1_battin_scalar():
x = np.linspace(0, 1, num=11)
expected_res = special.hyp2f1(3, 1, 5/2, x)
for ii, x_i in enumerate(x):
res = hyper.hyp2f1(3, 1, 5/2, x_i)
assert_almost_equal(res, expected_res[ii])
def odf_sh(self):
r""" Calculates the real analytical ODF in terms of Spherical
Harmonics.
"""
# Number of Spherical Harmonics involved in the estimation
J = (self.radial_order + 1) * (self.radial_order + 2) // 2
# Compute the Spherical Harmonics Coefficients
c_sh = np.zeros(J)
counter = 0
for l in range(0, self.radial_order + 1, 2):
for n in range(l, int((self.radial_order + l) / 2) + 1):
for m in range(-l, l + 1):
j = int(l + m + (2 * np.array(range(0, l, 2)) + 1).sum())
Cnl = (
((-1) ** (n - l / 2)) /
(2.0 * (4.0 * np.pi ** 2 * self.zeta) ** (3.0 / 2.0)) *
((2.0 * (4.0 * np.pi ** 2 * self.zeta) ** (3.0 / 2.0) *
factorial(n - l)) /
(gamma(n + 3.0 / 2.0))) ** (1.0 / 2.0)
)
Gnl = (gamma(l / 2 + 3.0 / 2.0) * gamma(3.0 / 2.0 + n)) / \
(gamma(l + 3.0 / 2.0) * factorial(n - l)) * \
(1.0 / 2.0) ** (-l / 2 - 3.0 / 2.0)
Fnl = hyp2f1(-n + l, l / 2 + 3.0 / 2.0, l + 3.0 / 2.0, 2.0)
c_sh[j] += self._shore_coef[counter] * Cnl * Gnl * Fnl
counter += 1
return c_sh
def shore_matrix_odf(radial_order, zeta, sphere_vertices):
r"""Compute the SHORE ODF matrix [1]_"
Parameters
----------
radial_order : unsigned int,
an even integer that represent the order of the basis
zeta : unsigned int,
scale factor
sphere_vertices : array, shape (N,3)
vertices of the odf sphere
References
----------
.. [1] Merlet S. et. al, "Continuous diffusion signal, EAP and
ODF estimation via Compressive Sensing in diffusion MRI", Medical
Image Analysis, 2013.
"""
r, theta, phi = cart2sphere(sphere_vertices[:, 0], sphere_vertices[:, 1],
sphere_vertices[:, 2])
theta[np.isnan(theta)] = 0
F = radial_order / 2
n_c = np.round(1 / 6.0 * (F + 1) * (F + 2) * (4 * F + 3))
upsilon = np.zeros((len(sphere_vertices), n_c))
counter = 0
for l in range(0, radial_order + 1, 2):
for n in range(l, int((radial_order + l) / 2) + 1):
for m in range(-l, l + 1):
upsilon[:, counter] = (-1) ** (n - l / 2.0) * _kappa_odf(zeta, n, l) * \
hyp2f1(l - n, l / 2.0 + 1.5, l + 1.5, 2.0) * \
real_sph_harm(m, l, theta, phi)
counter += 1
return upsilon
def self_gravity_omega(R,disk):
R2 = R * R
omega = math.pi * np.sqrt(math.pi) * disk.gravityG * 2.0**(disk.p/4.0) * disk.rho0 * R2 / disk.R_0 * spec.gamma(disk.p/2.0 + 0.5)/ spec.gamma(disk.p/2.0) \
* spec.hyp2f1(disk.p/2.0 + 0.5, 1.5, 2.0, - R2 / disk.R_0 / disk.R_0)
return omega
def _zforce(self,R,z,phi=0.,t=0.,_forceFloatEval=False):
"""
NAME:
_zforce
PURPOSE:
evaluate the vertical force for this potential
INPUT:
R - Galactocentric cylindrical radius
z - vertical height
phi - azimuth
t - time
OUTPUT:
the vertical force
HISTORY:
2010-07-09 - Written - Bovy (NYU)
"""
if not _forceFloatEval and not self.integerSelf == None:
return self.integerSelf._zforce(R,z,phi=phi,t=t)
else:
r= numpy.sqrt(R**2.+z**2.)
return -z/r**self.alpha*self.a**(self.alpha-3.)/(3.-self.alpha)\
*special.hyp2f1(3.-self.alpha,
self.beta-self.alpha,
4.-self.alpha,
-r/self.a)
def resid_anscombe(self, endog, mu):
"""
The Anscombe residuals for the negative binomial family
Parameters
----------
endog : array-like
Endogenous response variable
mu : array-like
Fitted mean response variable
Returns
-------
resid_anscombe : array
The Anscombe residuals as defined below.
Notes
-----
`resid_anscombe` = (hyp2f1(-alpha*endog)-hyp2f1(-alpha*mu)+\
1.5*(endog**(2/3.)-mu**(2/3.)))/(mu+alpha*mu**2)**(1/6.)
where hyp2f1 is the hypergeometric 2f1 function parameterized as
hyp2f1(x) = hyp2f1(2/3.,1/3.,5/3.,x)
"""
hyp2f1 = lambda x : special.hyp2f1(2/3., 1/3., 5/3., x)
return ((hyp2f1(-self.alpha * endog) - hyp2f1(-self.alpha * mu) +
1.5 * (endog**(2/3.)-mu**(2/3.))) /
(mu + self.alpha*mu**2)**(1/6.))
def get_kbar_lam_approx(lam, n, R, a, alpha1, alpha2, beta1, beta2,
verbose = 0):
"""Function to compute the expected degree as a function of
the latent parameter lam approximately. See Appendix of
the WHSCM paper for details of approximation.
Args:
lam (float): The latent parameter lambda of a node.
n (int): The number of nodes in a graph.
R (float): The R parameter of the WHSCM.
a (float): The a parameter of the WHSCM.
alpha1 (float): The alpha1 parameter of the WHSCM.
alpha2 (float): The alpha2 parameter of the WHSCM.
beta1 (float): The beta1 parameter of the WHSCM.
beta2 (float): The beta2 parameter of the WHSCM.
Returns:
kbar_lam_approx (float): The expected degree of a node
with the latent parameter lambda
in the WHSCM.
"""
lam_c = get_lam_c(a, R, beta1)
A1 = get_A1_const(alpha1, alpha2, lam_c)
A2 = get_A2_const(alpha1, alpha2, lam_c, A1)
if lam >= 1 and lam <= lam_c:
term1 = (n*A1*(lam**(1.+beta1)))/(a * (alpha1-2.) * np.exp(2*R))
term2 = special.hyp2f1(1., (alpha1-2.)/beta1, 1. + (alpha1-2.)/beta1, - (lam**beta1))
term3 = (lam_c**(2.-alpha1)) * special.hyp2f1(1., (alpha1-2.)/beta1, 1. + (alpha1-2.)/beta1, - ((lam/lam_c)**beta1))
term4 = (n * A2 * (lam_c)**(1.-alpha2)) / (alpha2 - 1.)
term5 = special.hyp2f1(1., alpha2 - 1., alpha2, -(a * np.exp(2*R))/(lam_c * lam**(1.+beta1)))
kbar_lam_approx = term1 * (term2 - term3) + term4*term5
elif lam > lam_c:
term1 = n * A1 / (alpha1-1.)
term2 = special.hyp2f1(1., (alpha1-1.)/(1.+beta1), (alpha1+beta1)/(1.+beta1), -(a*np.exp(2.*R))/lam)
term3 = ((lam_c)**(1.-alpha1)) * special.hyp2f1(1., (alpha1-1.)/(1+beta1), (alpha1+beta1)/(1.+beta1), -(a*np.exp(2.*R))/(lam*(lam_c)**(1.+beta1)))
term4 = (n * A2 * (lam_c)**(1.-alpha2)) / (alpha2 - 1.)
kbar_lam_approx = term1 * (term2 - term3) + term4
else:
if verbose == 1:
print "ERROR (get_kbar_lam_approx): Lambda parameter "+\
"has to be between 1 and infinity."
kbar_lam_approx = None
return kbar_lam_approx
def posterior(x, n, p1, p2):
"""
Calculates the posterior probability that the probability of developing
severe side effects falls within a specific range given the data:
x is the number of patients that develop severe side effects
n is the total number of patients observed
p1 is the lower bound on the range
p2 is the upper bound on the range
You can assume the prior beliefs of p follow a uniform distribution
If n is not a positive integer, raise a ValueError with the message n must
be a positive integer
If x is not an integer that is greater than or equal to 0, raise a
ValueError with the message x must be an integer that is greater than or
equal to 0
If x is greater than n, raise a ValueError with the message x cannot be
greater than n
If p1 or p2 are not floats within the range [0, 1], raise a ValueError with
the message {p} must be a float in the range [0, 1] where {p} is the
corresponding variable
if p2 <= p1, raise a ValueError with the message p2 must be greater than p1
The only import you are allowed to use is from scipy import special
Returns: the posterior probability that p is within the range [p1, p2]
given x and n
"""
if not isinstance(n, int) or n <= 0:
raise ValueError("n must be a positive integer")
if not isinstance(x, (int, float)) or (x < 0):
mg = "x must be an integer that is greater than or equal to 0"
raise ValueError(mg)
if x > n:
raise ValueError("x cannot be greater than n")
if not isinstance(p1, float) or p1 < 0 or p1 > 1:
raise ValueError("p1 must be a float in the range [0, 1]")
if not isinstance(p2, float) or p2 < 0 or p2 > 1:
raise ValueError("p2 must be a float in the range [0, 1]")
if p2 <= p1:
raise ValueError("p2 must be greater than p1")
num = (math.factorial(n+1))
den = (math.factorial(x) * math.factorial(n - x))
fct = num / den
hp1 = special.hyp2f1(x+1, x-n, x+2, p1)
hp2 = special.hyp2f1(x+1, x-n, x+2, p2)
return fct * (((p2**(x+1))*hp2)-((p1**(x+1))*hp1))/(x+1)
def olvers(a, b, c, x):
# Olver's hypergeometric function
# See https://dlmf.nist.gov/15.1
# Note that hyp2f1 does not exist for c=0,-1,-2,...
if np.abs(c % (-1)) < 0.1:
print('Oops, too close to a pole!')
# maybe build alternate definition here
return hyp2f1(a, b, c, x) / gamma(c)
def posterior(x, n, p1, p2):
"""
calculates the posterior probability that the probability of
developing severe side effects falls within a specific range
given the data
- x is the number of patients that develop severe side effects
- n is the total number of patients observed
- p1 is the lower bound on the range
- p2 is the upper bound on the range
the prior beliefs of p follow a uniform distribution
If n is not a positive integer, raise a ValueError
with the message: n must be a positive integer
If x is not an integer that is greater than or equal to 0,
raise a ValueError with the message:
x must be an integer that is greater than or equal to 0
If x is greater than n, raise a ValueError with the message:
x cannot be greater than n
If p1 or p2 are not floats within the range [0, 1], raise a
ValueError with the message:
"{p} must be a float in the range [0, 1]"
where {p} is the corresponding variable
if p2 <= p1, raise a ValueError with the message:
"p2 must be greater than p1"
"""
if not isinstance(n, int) or n < 1:
raise ValueError("n must be a positive integer")
if type(x) != int or x < 0:
mg = "x must be an integer that is greater than or equal to 0"
raise ValueError(mg)
if x > n:
raise ValueError("x cannot be greater than n")
if not isinstance(p1, float) or p1 < 0 or p1 > 1:
raise ValueError("p1 must be a float in the range [0, 1]")
if not isinstance(p2, float) or p2 < 0 or p2 > 1:
raise ValueError("p2 must be a float in the range [0, 1]")
if p2 <= p1:
raise ValueError("p2 must be greater than p1")
y = n - x
f = math.factorial(n + 1) / (math.factorial(x) * math.factorial(y))
h_1 = special.hyp2f1(x + 1, x - n, x + 2, p1)
h_2 = special.hyp2f1(x + 1, x - n, x + 2, p2)
posterior = f * (((p2**(x + 1)) * h2) - ((p1**(x + 1)) * h1)) / (x + 1)
return posterior
def log_a0(r, alpha, s, beta, freq, rec, age):
# check if alpha >= beta for format of A0 is slightly from when beta >= alpha
max_ab, min_ab, b = (alpha, beta, s+1.) if alpha > beta else (beta, alpha, r + freq)
ai = r + s + freq
ci = ai + 1.
zt = (max_ab - min_ab) / (max_ab + rec)
zT = (max_ab - min_ab) / (max_ab + age)
# F(a,b,c,z) is Gaussian hypergeometric function
ft, fT = hyp2f1(ai, b, ci, zt), hyp2f1(ai, b, ci, zT)
sign = ones(len(freq))
# result = log(ft * (max_ab + age) ** ai -fT * (max_ab + rec) ** ai) - ai * log((max_ab + rec)*(max_ab + age))
# logsumexp function is used for calculating the log ratio of A0.
# why use logsumexp: when computing with very small numbers, it is very common to keep the numbers in logspace.
# Most of the time, you only want to add up numbers in an array which could be done using log(sum(exp(a)))
result = logsumexp([log(ft) + ai * log(max_ab + age), log(fT) + ai * log(max_ab + rec)], axis=0, b=[sign, -sign]) - ai * log((max_ab + rec) * (max_ab + age))
return result
def g2(x, a, T):
"""
Kernel applicable to fSABR process
"""
H = a + 0.5
cH = np.sqrt(2 * H * math.gamma(3 / 2 - H) /
(math.gamma(2 - 2 * H) * math.gamma(H + 1 / 2)))
return cH * (x**a) * hyp2f1(H - 0.5, 0.5 - H, H + 0.5, -x / (T - x))
def _mass_integral(self, x, slope=8):
"""
Returns the analitic result of the integral appearing in mass expression
:param slope: exponent entering the profile
:return: integral result
"""
hypF = np.real(hyp2f1(3. / 2, slope, 5. / 2, -x**2))
return 1. / 3 * x**3 * hypF
def test_unital_argument(self, hyp2f1_test_case):
"""Tests for case z = 1, c - a - b > 0.
Expected answers computed using mpmath.
"""
a, b, c, z, expected, rtol = hyp2f1_test_case
assert z == 1 and c - a - b > 0 # Tests the test
assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
def qli(l, i, alpha, beta):
"""Return the scalar (q_\phi^{l})_{i}."""
if i % 2 == 0:
return B(alpha, l + beta - i / 2) * hyp2f1(
-i / 2, alpha, l + alpha + beta - i / 2, -1
)
else:
return 0.0
def _psi(self,m):
"""\psi(m) = -\int_m^\infty d m^2 \rho(m^2)"""
if self.twominusalpha == 0.:
return -2.*self.a**2*(self.a/m)**self.betaminusalpha\
/self.betaminusalpha\
*special.hyp2f1(self.betaminusalpha,
self.betaminusalpha,
self.betaminusalpha+1,
-self.a/m)
else:
return -2.*self.a**2\
*(self.psi_inf-(m/self.a)**self.twominusalpha\
/self.twominusalpha\
*special.hyp2f1(self.twominusalpha,
self.betaminusalpha,
self.threeminusalpha,
-m/self.a))
def deflect(self):
xi =np.sqrt((self.image_x-self.centroid[0])**2+(self.image_y-self.centroid[1])**2)/self.a
alpha = 2*self.kappa_0*self.a/xi * (sp.beta((self.n_outer-3)/2.0,(3-self.gamma)/2.0) \
- sp.beta((self.n_outer-3)/2.0, 3.0/2.0) * (1+xi**2)**((3-self.n_outer)/2.0)\
* sp.hyp2f1((self.n_outer-3)/2.0,self.gamma/2.0,self.n_outer/2.0,1/(1+xi**2)))
self.alpha_x = alpha*(self.image_x-self.centroid[0])/np.sqrt((self.image_x-self.centroid[0])**2+(self.image_y-self.centroid[1])**2)
self.alpha_y = alpha*(self.image_y-self.centroid[1])/np.sqrt((self.image_x-self.centroid[0])**2+(self.image_y-self.centroid[1])**2)
def _psi(self, m):
"""\psi(m) = -\int_m^\infty d m^2 \rho(m^2)"""
if self.twominusalpha == 0.:
return -2.*self.a**2*(self.a/m)**self.betaminusalpha\
/self.betaminusalpha\
*special.hyp2f1(self.betaminusalpha,
self.betaminusalpha,
self.betaminusalpha+1,
-self.a/m)
else:
return -2.*self.a**2\
*(self.psi_inf-(m/self.a)**self.twominusalpha\
/self.twominusalpha\
*special.hyp2f1(self.twominusalpha,
self.betaminusalpha,
self.threeminusalpha,
-m/self.a))
def corr_error_pdf(r, trueR, n):
num_const = (n - 2) * fn.gamma(n - 1)
num_rho = (1 - trueR ** 2) ** ((n - 1) / 2)
num_r = (1 - r ** 2) ** ((n - 4) / 2)
den_const = np.sqrt(2 * np.pi) * fn.gamma(n - 0.5)
den_rhor = (1 - trueR * r) ** (n - 1.5) # TODO prevent overflow here
num_hyp = fn.hyp2f1(0.5, 0.5, (2 * n - 1) / 2, (trueR * r + 1) / 2)
return (num_const * num_rho * num_r * num_hyp) / (den_const * den_rhor)
def cdf(n, z):
d = math.pow(abs(z), 1 - n) * sp.gamma(n / 2) * sp.hyp2f1(
(n - 1) / 2, n / 2,
(n + 1) / 2, -1 / z**2) / (2 * math.sqrt(math.pi) * sp.gamma(
(n + 1) / 2))
if z > 0:
return 1 - d
return d
def test_special_case_z_near_minus_1(self, hyp2f1_test_case):
"""Tests for case z ~ -1, c ~ 1 + a - b
Expected answers computed using mpmath.
"""
a, b, c, z, expected, rtol = hyp2f1_test_case
assert abs(1 + a - b - c) < 1e-15 and abs(z + 1) < 1e-15
assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
def In(y,n,x0 = None): #defini par l'integrale entre 0 et +infini, donc pas de (-1)^n if x0 is None: x = y return 2.**(n/2.-2.)*gamma((1.+n)/2.)/(5.*sqrt(5.*num.pi))*( 10.*(n+1.)*(5.+x**2.)**(-(3.+n)/2.) - 32.*(5.+x**2.)**(-(1.+n)/2.) + 155.*2.**(3.+n)*(1.+n)*(5.+4.*x**2.)**(-(3.+n)/2.) + 2.**(6.+n)*(5.+4.*x**2.)**(-(1.+n)/2.) - 150.*(1.+n)*x**(-(n+3.))*hyp2f1(1./2.,(3.+n)/2.,3./2.,-5./x**2.) - 75.*(1.+n)*x**(-(n+3.))*hyp2f1(1./2.,(3.+n)/2.,3./2.,-5./(4.*x**2.)) + 50.*(1.+n)*(3.+n)*x**(-(n+5.))*hyp2f1(1./2.,(5.+n)/2.,3./2.,-5./x**2.) + 25.*(1.+n)*(3.+n)*x**(-(n+5.))*hyp2f1(1./2.,(5.+n)/2.,3./2.,-5./(4.*x**2.))) else: x_tab = num.linspace(x0,3.*sqrt(n + 3.)/y,1000) F = x_tab**n*f(x_tab)*exp(-(x_tab*y)**2./2.) return integrate(x_tab,F)
def cdf(r, params, Rm):
a = params[2]
b = params[3]
g = params[4]
# Normalisation constant
x = -Rm**(1.0 / a)
y = -r**(1.0 / a)
z = (r / Rm)**(2.0 - g)
u = a * (b - g)
v = -a * (g - 2.0)
w = 1.0 + v
c = hyp2f1(u, v, w, x)
d = hyp2f1(u, v, w, y)
return z * np.abs(d) / np.abs(c)
def singular_part(PP, run):
"""Computation of the Singular Part of the Self-Force
PP : class instance
contains all parameters
run : int, default 0
id to distinguish several runs"""
# Schwarzschild Metric Function f at tbe Particle Location:
f_p = 1 - 2 / PP.r_p
# Computing rdot:
q1 = PP.p_orbit / PP.r_p
q3 = PP.p_orbit - 2 * q1
q4 = np.sqrt((PP.p_orbit - 2)**2 - 4 * PP.e_orbit**2)
q5 = q3 * (q1**2) / (q4 * PP.p_orbit)
chi_dot = q5 * (np.sqrt(PP.p_orbit - 4 - 2 * q1)) / (PP.p_orbit)
dr_p_dtau = (PP.Ep * PP.r_p**2 * PP.e_orbit * np.sin(PP.chi_p) * chi_dot /
(f_p * PP.p_orbit))
# Computing other relevant quantities:
qaux1 = 1 + PP.Lp**2 / PP.r_p**2
qaux2 = qaux1**(1.5)
alpha = PP.Lp**2 / (PP.r_p**2 + PP.Lp**2)
# Computing the Value of some Hypergeometric Functions:
ff_1d2 = special.hyp2f1(0.5, 0.5, 1, alpha)
ff_m1d2 = special.hyp2f1(-0.5, 0.5, 1, alpha)
# Computing Regularization Parameters, not dependent on ell:
A_r_H = PP.Ep / (f_p * qaux1)
A_r_I = -PP.Ep / (f_p * qaux1)
B_r = ((dr_p_dtau**2 - 2 * PP.Ep**2) * ff_1d2 +
(dr_p_dtau**2 + PP.Ep**2) * ff_m1d2) / (2 * f_p * qaux2)
# Computing Singular Part of the Self-Force (only the radial component at the moment):
for ll in range(PP.ell_max + 1):
PP.SF_S_r_l_H[ll] = PP.charge * (
(ll + 0.5) * A_r_H + B_r) / (PP.r_p**2)
PP.SF_S_r_l_I[ll] = PP.charge * (
(ll + 0.5) * A_r_I + B_r) / (PP.r_p**2)
logging.info("FRED RUN %d: Singular Part of the Self-Force Computed", run)
def sbpl(engs, params, flux): IdxLow = float(params[0]) # low-energy index, aka lambda_1 or alpha IdxHig = float(params[1]) # high-energy index, aka lambda_2 or beta ebk = float(params[2]) # Ebreak, break energy delta = 0.3 # breakscale energy in keV. Uncomment the next line to use as a fit parameter. #delta = float(params[3]) for i in range(len(engs)-1): delta = delta a = (IdxHig - IdxLow)/2. b = (IdxLow + IdxHig)/2. # LOG AND LOG10 CONSTANTS TO SIMPLIFY THE FUNCTION c1 = 4.60517 # log(100) c2 = 0.868589 # 2*(1./log(10)) see also logarithmic properties of log((1+n)/(1-n)) c3 = 2.30259 # log(10) c4 = 0.434294 # 1./log(10) c5 = 1.59603 # log(2)*log(10) = log(2)+log(10) c6 = 1.15129 # log(10)/2. # changed the following to simplify, see orig function commented out below: # delta*(-c6*a-c6*b-c6) to -c6*delta*(a+b+1.) # (a+b+1.) to (IdxHig + 1.) multiplier = ( (1./(IdxHig+1.)) * -exp(-c1*b) * (cosh(c5*a*delta)-sinh(c5*a*delta))) lowIntegral = ( engs[i]**(b+1) * ( ((engs[i]/ebk)**(-c2/delta) +1.)**(-c3*a*delta)) * ((((engs[i]/ebk)**(-c4/delta)) + ((engs[i]/ebk)**(c4/delta)))**(c3*a*delta)) * float(hyp2f1(-c3*a*delta, -c6*delta*(IdxHig+1.), -c6*delta*(IdxHig+1.)+1., -(engs[i]/ebk)**(-c2/delta))) * (cosh((c4 * log(engs[i]/ebk))/delta)**(-c3*a*delta)) * (((1./cosh((c4*(log(1/ebk)+c1))/delta)) * cosh((c4*log(engs[i]/ebk))/delta))**(c3*a*delta)) ) highIntegral = ( engs[i+1]**(b+1) * ( ((engs[i+1]/ebk)**(-c2/delta) +1.)**(-c3*a*delta)) * ((((engs[i+1]/ebk)**(-c4/delta)) + ((engs[i+1]/ebk)**(c4/delta)))**(c3*a*delta)) * float(hyp2f1(-c3*a*delta, -c6*delta*(IdxHig+1.), -c6*delta*(IdxHig+1.)+1., -(engs[i+1]/ebk)**(-c2/delta))) * (cosh((c4 * log(engs[i+1]/ebk))/delta)**(-c3*a*delta)) * (((1./cosh((c4*(log(1/ebk)+c1))/delta)) * cosh((c4*log(engs[i+1]/ebk))/delta))**(c3*a*delta)) ) val = multiplier * (lowIntegral - highIntegral) flux[i] = val
def freq_future_k_days(self, freq, rec, age, k):
# predict transactions will happen in next k days
r, alpha, a, b = self.pars
freq, rec, age = self.check_inputs(freq, rec, age)
a1 = (a+b+freq-1.)/(a-1.)
a2 = 1. - power((alpha+age)/(alpha+age+k), r+freq) * hyp2f1(r+freq, b+freq, a+b+freq-1, k/(alpha+age+k))
a3 = 1. + a/(b+freq-1) * power((alpha+age)/(alpha+rec), r+freq)
future_freq = a1 * a2 / a3
return future_freq
def laplace_b1_logistic(s):
location = b1
scale = 0.06240118068052774
laplace_b1 = np.exp(location / scale) * (
1 / (1 + np.exp(location / scale)) -
s * scale * gamma(1 + s * scale) *
hyp2f1(1, 1 + s * scale, 2 + s * scale,
-np.exp(location / scale)) / gamma(2 + s * scale))
return laplace_b1
def conditionalExpectation(t, x, tx, T, r, alpha, a, b):
E = (a + b + x - 1) / (a - 1)
E *= 1 - (( (alpha + T) / (alpha + T + t) ) ** (r + x)) * special.hyp2f1(r + x, b + x, a + b + x - 1, t / (alpha + T + t))
if x > 0:
E /= 1 + (a / (b + x - 1)) * (((alpha + T) / (alpha + tx))**(r + x))
return E
def laplace_bp_pdf_logistic_performance_union(s):
scale = 0.47738487306528626
location = bp
laplace_bp = np.exp(location / scale) * (
1 / (1 + np.exp(location / scale)) -
s * scale * gamma(1 + s * scale) *
hyp2f1(1, 1 + s * scale, 2 + s * scale,
-np.exp(location / scale)) / gamma(2 + s * scale))
return laplace_bp
def laplace_bp_pdf_logistic(s):
location = bp
scale = 0.2980952087304305
laplace_bp = np.exp(location / scale) * (
1 / (1 + np.exp(location / scale)) -
s * scale * gamma(1 + s * scale) *
hyp2f1(1, 1 + s * scale, 2 + s * scale,
-np.exp(location / scale)) / gamma(2 + s * scale))
return laplace_bp
def genphi(x, alpha = 1, beta = 3, gamma = 1, Vmax = 21.0, rmax = 1.5):
rs = rmax/2.16
Ps = (Vmax/0.465)**2.0
x0 = 10**-12
p1a = ss.hyp2f1((3-gamma)/alpha, (beta-gamma)/alpha, (3+alpha-gamma)/alpha, -x0**alpha)
p1b = ss.hyp2f1((3-gamma)/alpha, (beta-gamma)/alpha, (3+alpha-gamma)/alpha, -x**alpha)
I1 = ( x0**(3-gamma) * p1a - x**(3-gamma) * p1b ) / (x * (gamma - 3))
p2 = ss.hyp2f1( (-2+beta)/alpha, (beta-gamma)/alpha, (-2+alpha+beta)/alpha, -x**(-alpha))
I2 = x**(2-beta) * p2 / (beta -2)
ans1 = Ps * ( 1 - (I1+I2) )
#to calculate the factor that gives the same mass within 300pc
#factor = rhos_correct(.3, alpha, beta, gamma, Vmax, rmax)
#ans2 = Ps * ( 1 - (np.log(1+x))/x )
return ans1 #* factor
def GrowthFunction(self,a): """ a is the scale factor """ a=np.array(a)+1e-15 D=np.ones(np.size(a)) H=self.H_0*(self.Omega_matter*(a**(-3))+self.Omega_lambda)**(1/2.) D=(H/self.H_0)*a**(5/2.)/np.sqrt(self.Omega_matter)*special.hyp2f1(5/6.,3/2.,11/6.,-a**3*self.Omega_lambda/self.Omega_matter) return D
def cdf(r,params,Rm):
rc = params[2]
a = params[3]
b = params[4]
g = params[5]
# Normalisation constant
x = - ((rc/Rm)**(-1.0/a))
y = - ((r/rc)**(1.0/a))
z = (r/Rm)**(2.0-g)
u = a*(b-g)
v = -a*(g-2.0)
w = 1.0 + v
c = hyp2f1(u,v,w,x)
d = hyp2f1(u,v,w,y)
return z*d.real/c.real
def trans_0015(a,b,c,z):
""" http://functions.wolfram.com/HypergeometricFunctions/Hypergeometric2F1/17/02/09/0015/"""
# print c-a,b,b-a+1,1/(1-z)
# print mph2f1(c-a,b,b-a+1,1/(1-z)), hyp2f1(c-a,b,b-a+1,1/(1-z))
# print mph2f1(b-c+1,a-c+1,2-c,z), hyp2f1(b-c+1,a-c+1,2-c,z)
# print mph2f1(b-c+1,a-c+1,2-c,z), hyp2f1(b-c+1,a-c+1,2-c,z)
_ = gammaln(1-a)+gammaln(b-c+1)
return (np.exp(_-gammaln(b-a+1)-gammaln(1-c)-b*np.log(1-z))*hyp2f1(c-a,b,b-a+1,1/(1-z))+
np.exp(_+gammaln(c)-gammaln(b)-gammaln(2-c)-gammaln(c-a)+(1-c)*np.log(-z))*hyp2f1(b-c+1,a-c+1,2-c,z))
def test_region4(self, hyp2f1_test_case):
"""0.9 <= |z| <= 1 and |1 - z| >= 1.
This region is unhandled by of the standard transformations and
needs special care.
"""
a, b, c, z, expected, rtol = hyp2f1_test_case
assert 0.9 <= abs(z) <= 1 and abs(1 - z) >= 1 # Tests the test
assert_allclose(hyp2f1(a, b, c, z), expected, rtol=rtol)
def trans_15_3_9(a,b,c,z):
# print mph2f1(a,a-c+1,a+b-c+1,1-1/z), hyp2f1(a,a-c+1,a+b-c+1,1-1/z)
# print mph2f1(c-a,1-a,c-a-b+1,1-1/z), hyp2f1(c-a,1-a,c-a-b+1,1-1/z)
# print gammaln(c-b-a)
# return (np.exp(-a * np.log(z)+gammaln(c)+gammaln(c-b-a)-gammaln(c-b)-gammaln(c-a))*hyp2f1(a,a-c+1,a+b-c+1,1-1/z)+
# np.float_power(z,a-c)*np.exp((c-a-b) * np.log(1-z)+gammaln(c)+gammaln(a+b-c)-gammaln(a)-gammaln(b))*hyp2f1(c-a,1-a,c-a-b+1,1-1/z))
# print pochln2(c-b,-a)
# print a-c+1, a+b-c+1
return z**(-a)*np.exp(gammaln(c)+pochln2(c-b,-a)-gammaln(c-a))*hyp2f1(a,a-c+1,a+b-c+1,1-1/z)
def doublePL_Lintegral(x,a,b):
'''
Indefinite integral of a double power law function
:math:`f(x,a,b) = (x^a + x^b)^{-1}`.
'''
return (b*x**(1-a) / ((a-1)*(a-b)) -
x**(1-a)*((a-b)*
hyp2f1(1.,(a-1)/(a-b),(a-1)/(a-b)+1,-x**(b-a)) + b) /
((a-1)*(a-b)))
def _log_A_0(params, freq, recency, age):
r, alpha, s, beta = params
min_of_alpha_beta, max_of_alpha_beta, t = (alpha, beta, r + freq) if alpha < beta else (beta, alpha, s + 1)
abs_alpha_beta = max_of_alpha_beta - min_of_alpha_beta
rsf = r + s + freq
p_1, q_1 = special.hyp2f1(rsf, t, rsf + 1., abs_alpha_beta / (max_of_alpha_beta + recency)), (max_of_alpha_beta + recency)
p_2, q_2 = special.hyp2f1(rsf, t, rsf + 1., abs_alpha_beta / (max_of_alpha_beta + age)), (max_of_alpha_beta + age)
try:
size = len(freq)
sign = np.ones(size)
except TypeError:
sign = 1
return misc.logsumexp([log(p_1) + rsf * log(q_2), log(p_2) + rsf * log(q_1)], axis=0, b=[sign, -sign]) \
- rsf * log(q_1 * q_2)
def comoving_distance(z):
"""
line-of-sight comoving distance to a source at redshift z
units will be the same as D_H, defined above.
if O_K==0, this will compute the result analytically, using
hypergeometric functions.
if O_K!=0, this will compute the result using numerical integration
of the function 1/H(z)
"""
if O_K_is_zero:
return D_H * 2. / numpy.sqrt(O_M) * \
( hyp2f1(1./6,1./2,7./6,-O_L/O_M) -\
hyp2f1(1./6,1./2,7./6,
-O_L/O_M/(1.+z)**3 )/numpy.sqrt(1.+z) )
else:
I,err = integrate.quad(H_inv,0,z)
return D_H * I
def uLinkage(sigma, mu, V):
if V < EPS:
return u0(sigma, mu)
ret = mu
if sigma > EPS:
val = hyp2f1(1.0, V / sigma, 1.0 + V / sigma, 1.0 - u0(sigma, mu) / mu)
ret = u0(sigma, mu) * val;
elif sigma < -EPS:
ret = mu / (math.fabs(sigma) + V) * (u0(sigma, mu) / mu * math.fabs(sigma) + V);
return ret;
def rhos_correct(auxr = .3, alpha = 1, beta = 3, gamma = 1, Vmax = 21.0, rmax=1.5):
rs = rmax/2.16
Ps = (Vmax/0.465)**2.0
x0 = 10**-12
p1a = ss.hyp2f1((3-gamma)/alpha, (beta-gamma)/alpha, (3+alpha-gamma)/alpha, -x0**alpha)
#to calculate the factor that gives the same mass within 300pc
auxx = auxr/rs
alpha0, beta0, gamma0 = [1,3,1]
p1_a = ss.hyp2f1((3-gamma0)/alpha0, (beta0-gamma0)/alpha0, (3+alpha0-gamma0)/alpha0, -x0**alpha0)
p1_b = ss.hyp2f1((3-gamma0)/alpha0,(beta0-gamma0)/alpha0,(3+alpha0-gamma0)/alpha0, -auxx**alpha0)
auxmass0 = ( x0**(3-gamma0) * p1_a - auxx**(3-gamma0) * p1_b ) / ((gamma0 - 3))
p1_b2 = ss.hyp2f1((3-gamma)/alpha,(beta-gamma)/alpha,(3+alpha-gamma)/alpha, -auxx**alpha)
auxmass = ( x0**(3-gamma) * p1a - auxx**(3-gamma) * p1_b2 ) / ((gamma - 3))
factor = auxmass0/auxmass
return factor
