def __init__(self, alpha, beta, K): """ Note alpha/beta = mean, alpha/beta^2 = variance @param alpha: shape parameter @param beta: inverse scale parameter @param K: number of bins """ if alpha <= 0: raise Exception("alpha = %f <= 0" % alpha) if beta <= 0: raise Exception("beta = %f <= 0" % beta) if K < 1: raise Exception("Num bins = %d < 1" % K) # find upper boundaries of each bin max_prob = gammainc(alpha, self.MAX_RATE) bin_prob = max_prob / K targets = np.arange(bin_prob, max_prob+bin_prob/2, bin_prob) #XXX: not sure why we don't divide targets / beta bin_ubounds = gammaincinv(alpha, targets) / beta bin_lbounds = np.zeros(K) bin_lbounds[1:] = bin_ubounds[:-1] tmp = gammainc(alpha+1, bin_ubounds * beta) - gammainc(alpha+1, bin_lbounds * beta) bin_rates = tmp * alpha / beta * K # Rate of middle of each bin self.bin_rates = bin_rates # Probability mass of each bin self.bin_probs = np.zeros(K) + bin_prob
def truncated_gamma(shape=None, alpha=1., beta=1., x_min=None, x_max=None): """ Generate random variates from a lower-and upper-bounded gamma distribution. @param shape: shape of the random sample @param alpha: shape parameter (alpha > 0.) @param beta: scale parameter (beta >= 0.) @param x_min: lower bound of variate @param x_max: upper bound of variate @return: random variates of lower-bounded gamma distribution """ from scipy.special import gammainc, gammaincinv from numpy.random import gamma from numpy import inf if x_min is None and x_max is None: return gamma(alpha, 1 / beta, shape) elif x_min is None: x_min = 0. elif x_max is None: x_max = inf x_min = max(0., x_min) x_max = min(1e300, x_max) a = gammainc(alpha, beta * x_min) b = gammainc(alpha, beta * x_max) return probability_transform(shape, lambda x, alpha=alpha: gammaincinv(alpha, x), a, b) / beta
def integrate(self,lower,upper,method=None,**kwargs): """ Analytically Compute Schechter integral using incomplete gamma functions. If `method` is not None, numerical integration will be used. The gamma functions break down for alpha<=-1, so numerical is used if that is the case. """ if self.alpha<=-1: method = True #use default numerical method, because gamma functions fail for alpha<=-1 if method is not None: return FunctionModel1D.integrate(self,lower,upper,method,**kwargs) from scipy.special import gamma,gammainc,gammaincc s = self.alpha+1 u = upper/self.Lstar l = lower/self.Lstar if upper==np.inf and lower<=0: I = gamma(s) elif upper==np.inf: I = gammaincc(s,l)*gamma(s) elif lower==0: I = gammainc(s,u)*gamma(s) else: I = (gammainc(s,u) - gammainc(s,l))*gamma(s) return self.phistar*I
def dldtheta(self,dat): """ Evaluates the gradient of the Gamma function with respect to the primary parameters. :param dat: Data on which the gradient should be evaluated. :type dat: DataModule.Data :returns: The gradient :rtype: numpy.array """ m = dat.numex() grad = zeros((len(self.primary),m)) s = self.param['s'] p = self.param['p'] u = array([self.param['a'],self.param['b']]) cab = .5 + 0.5*sign(u)*gammainc(1/p,abs(u)**p /s) for ind,key in enumerate(self.primary): if key == 's': U = -.5*sign(u)*(abs(u) *exp(-abs(u)**p/s))/(s**(1/p+1)*gammafunc(1/p)) grad[ind,:] = -1.0/p/s + abs(squeeze(dat.X))**p/s**2 - (U[1]-U[0])/(cab[1]-cab[0]) if key == 'p': f = lambda x: 1/x df = lambda x: -1/x**2 g = lambda x,k: abs(u[k])**x/s dg = lambda x,k: abs(u[k])**x*log(abs(u[k]))/s dIncGamma = array([totalDerivativeOfIncGamma(p,f,lambda v: g(v,0),df,lambda v: dg(v,0)),\ totalDerivativeOfIncGamma(p,f,lambda v: g(v,1),df,lambda v: dg(v,1))]) U = .5*sign(u) * (dIncGamma/float(gammafunc(1/p)) + gammainc(1/p,abs(u)**p/s)*digamma(1/p)/p**2) grad[ind,:] = 1/p + 1/p**2*log(s) + digamma(1/p)*1/p**2 - abs(squeeze(dat.X))**p*log(abs(squeeze(dat.X)))/s - (U[1]-U[0])/(cab[1]-cab[0]) return grad
def new_BD_ratio(P, zp): MB, ReB, nB, M1, M2, h1, h2, R_brk = P.values I01, I02, IeB = convert_I(M1, zp), convert_I(M2, zp), convert_I(MB, zp) disc1 = I01 * h1 * h1 * gammainc(2., R_brk / h1) disc2 = I02 * h2 * h2 * (1 - gammainc(2., R_brk / h2)) bn = get_b_n(nB) bulge = np.exp(bn) * IeB * ReB * ReB * gamma((2 * nB) + 1) / (bn**(2.*nB)) return bulge / (2* (disc2 + disc1))
def dndx_rvir(Lrng=(0.001, 10), nL=1000, beta=0.2, rvir_Lstar=250.*u.kpc, phi_str_pref = 1.49, alpha = -1.05, Mstar = -20.44, cosmo=None): # ; M* - 5 log h """ Estimate dN/dX for a set of CGM assuming unit covering fraction Following Prochaska+11 Use beta=0 and rvir_Lstar=300kpc for a constant CGM to 300kpc Parameters ---------- Lrng : tuple, optional Range to integrate luminosity in terms of L* nL : int, optional Number of evaluations of L in that interval beta : float, optional Parameterization of rvir with L r_vir = 250 kpc * (L/L*)^beta phi_str, alpha, Mstar : float, float, float Blanton lum function Phi(M) = 0.4 log(10) Phi* 10^(-0.4 [M-M*][alpha+1]) exp(- ; 10^(-0.4[M-M*] ) ) Phi(L) = Phi* (L/L*)^alpha exp(-L/L*) Phi* has the funny units of 1e-2 h^3 Mpc^-3 cosmo : Cosmology, optional Defaults to Planck15 Returns ------- Lval : ndarray Luminosities of evaluation dNdX : float Cumulative dNdX """ # Cosmology if cosmo is None: cosmo = Planck15 hubb = cosmo.H0.value / 100. # Constants phi_str_cgs = (phi_str_pref * 1e-2 * hubb**3) / u.Mpc**3 dndx_const = (const.c / cosmo.H0).cgs # Cumulative Lval = np.linspace(Lrng[0], Lrng[1], nL) x = alpha + 1 + beta # Integrate if gflg: igmma = np.zeros_like(Lval) i0 = float(gammainc(x,Lrng[1])) for kk,iLval in enumerate(Lval): igmma[kk] = i0 - float(gammainc(x,iLval)) else: igmma = gammainc(x,Lrng[1]) - gammainc(x,Lval) dNdx_rvir = (dndx_const * phi_str_cgs * (np.pi * rvir_Lstar**2) * ( gamma(x) * igmma)).decompose().value # Return return Lval, dNdx_rvir
def getMass(self,sigCrit=1.): import numpy from math import pi from scipy.special import gammainc,gamma b,n,re = self.b,self.n,self.re k = 2.*n-1./3+4./(405.*n)+46/(25515.*n**2) amp = b*b*k**(2*n)/(2*n*re**2*(gamma(2*n)*gammainc(2*n,k*(b/re)**(1/n)))) return 2*pi*sigCrit*re**2*amp*gamma(2*n)*n/k**(2*n) ### amp = b*b*k**(2*n)/(numpy.exp(k)*2*n*re**2*(gamma(2*n)*gammainc(2*n,k*(b/re)**(1/n)))) return 2*pi*sigCrit*re**2*amp*gamma(2*n)*n/(numpy.exp(k)*k**(2*n))
def cdf(self,dat): ''' Evaluates the cumulative distribution function on the data points in dat. :param dat: Data points for which the c.d.f. will be computed. :type dat: natter.DataModule.Data :returns: A numpy array containing the probabilities. :rtype: numpy.array ''' u = array([self.param['a'],self.param['b']]) u = .5 + 0.5*sign(u)*gammainc(1/self.param['p'],abs(u)**self.param['p'] / self.param['s']) return squeeze(.5 + 0.5*sign(dat.X)*gammainc(1/self.param['p'],abs(dat.X)**self.param['p'] / self.param['s']) - u[0])/(u[1]-u[0])
def sfr_avg(self, tage=None, dt=0.1): """ The average SFR between time ``tage``-``dt`` and ``tage``, given the SFH parameters, for ``sfh=1`` or ``sfh=4``. Like SFHSTAT in FSPS. Requires scipy, as it uses gamma functions. :param tage: (default, None) The ages (in Gyr) at which the average SFR over the last ``dt`` is desired. if ``None``, uses the current value of the ``tage`` in the parameter set. Scalar or iterable. :param dt: (default: 0.1) The time interval over which the recent SFR is averaged, in Gyr. defaults to 100 Myr (i.e. sfr8). :returns sfr_avg: The SFR at ``tage`` averaged over the last ``dt`` Gyr, in units of solar masses per year. """ from scipy.special import gammainc assert self.params['sf_trunc'] <= 0, \ "sfr_avg not supported for sf_trunc > 0" if self.params['sfh'] == 1: power = 1 elif self.params['sfh'] == 4: power = 2 else: raise ValueError("sfr_avg not supported for this SFH type.") tau, sf_start = self.params['tau'], self.params['sf_start'] if tage is None: tage = np.atleast_1d(self.params['tage']) else: tage = np.atleast_1d(tage) if tage[0] <= 0: tage = 10**(self.log_age - 9) tb = (self.params['tburst'] - sf_start) / tau tmax = (tage[-1] - sf_start) / tau normalized_times = (np.array([tage, tage - dt]).T - sf_start) / tau tau_mass_frac = gammainc(power, normalized_times) / gammainc(power, tmax) burst_in_past = tb <= normalized_times mass = (tau_mass_frac * (1 - self.params['const'] - self.params['fburst']) + self.params['const'] * normalized_times / tmax + burst_in_past * self.params['fburst']) avsfr = (mass[..., 0] - mass[..., 1]) / dt / 1e9 # Msun/yr return np.clip(avsfr, 0, np.inf)
def _getInterpProbs(self, n, log_s): #These values come from: #http://ned.ipac.caltech.edu/level5/March05/Graham/Graham2.html b_n = 1.9992*n-0.3271 x = b_n*numpy.power(10,log_s)**(1./n) probs = gammainc(2*n, x) return interp1d(probs, log_s), numpy.min(probs), numpy.max(probs)
def det_tau_r(E_f, V_f, m_list, mu_xi, dp_tau, dp_r, tau_range, r_range, sV0): w_arr = np.linspace(0, 20, 300) tau_arr = np.linspace(tau_range[0], tau_range[1], dp_tau) r_arr = np.linspace(r_range[0], r_range[1], dp_tau) e_arr = orthogonalize([tau_arr, r_arr]) x_axis = e_arr[0] y_axis = e_arr[1] for mi in m_list: res_array = np.zeros((dp_tau, dp_r)) for i_tau, taui in enumerate(tau_arr): for i_r, ri in enumerate(r_arr): s = get_scale(mu_xi, mi, taui, ri) print s #sV0 = float(s * (pi * mu_r ** 2) ** (1. / mi)) T = 2. * taui / ri s0 = ((T * (mi + 1) * sV0 ** mi) / (2. * E_f * pi * ri ** 2)) ** (1. / (mi + 1)) print s0 k = np.sqrt(T / E_f) ef0 = k * np.sqrt(w_arr) G = 1 - np.exp(-(ef0 / s0) ** (mi + 1)) mu_int = ef0 * E_f * V_f * (1 - G) I = s0 * gamma(1 + 1. / (mi + 1)) * gammainc(1 + 1. / (mi + 1), (ef0 / s0) ** (mi + 1)) mu_broken = E_f * V_f * I / (mi + 1) result = mu_int + mu_broken sigma_c = np.max(result) if sigma_c == result[-1]: print "w_arr too short" pass res_array[i_tau, i_r] = sigma_c mlab.surf(x_axis, y_axis, res_array / 100.) mlab.xlabel("det tau") mlab.ylabel("det r") mlab.zlabel("sigma") mlab.show()
def _rhov2int(self, phi, r, ra): """Compute dimensionless pressure integral for phi, r """ # Isotropic case first (equation 9, GZ15) rhov2r = exp(phi)*gammainc(self.g + 2.5, phi) rhov2 = 3*rhov2r rhov2t = 2*rhov2r # Add anisotropy, add parts depending explicitly on r # (see equations 12, 13, and 14 of GZ15) if (ra < self.ramax) and (r>0) and (phi>0): p, g = r/ra, self.g p2 = p**2 p12 = 1+p2 g3, g5, g7, fp2 = g+1.5, g+2.5, g+3.5, phi*p2 P1 = p2*phi**g5/gamma(g7) H1 = hyp1f1(1, g7, -fp2) if fp2 <self.max_arg_exp else g5/fp2 H2 = hyp1f1(2, g7, -fp2) if fp2 <self.max_arg_exp else g5*g3/fp2**2 rhov2r += P1*H1 rhov2r /= p12 rhov2t /= p12 rhov2t += 2*P1*(H1/p12 + H2) rhov2t /= p12 rhov2 = rhov2r + rhov2t return rhov2, rhov2r, rhov2t
def deterministic_r(): E_f, V_f, tau, m, sV0 = 200e3, 0.01, .1, 7.0, 3.e-3 for ri in [0.005, 0.01, 0.015]: T = 2. * tau / ri w_arr = np.linspace(0,1.2,1000) # analytical solution s0 = ((T * (m+1) * sV0**m)/(2. * E_f * pi * ri ** 2))**(1./(m+1)) k = np.sqrt(T/E_f) ef0 = k*np.sqrt(w_arr) G = 1 - np.exp(-(ef0/s0)**(m+1)) mu_int = ef0 * E_f * V_f * (1-G) I = s0 * gamma(1 + 1./(m+1)) * gammainc(1 + 1./(m+1), (ef0/s0)**(m+1)) mu_broken = E_f * V_f * I / (m+1) plt.plot(w_arr, mu_int + mu_broken, lw = 2, color = 'black') plt.ylim(0, 16) plt.xlim(0, 1.25) plt.show() fig = plt.figure() ax1 = fig.add_subplot(111) ax2 = ax1.twinx() for mi in [4.0, 5.0, 7.0]: r_arr = np.linspace(0.001, 0.01, 100) T = 2. * tau / r_arr s0 = ((T * (mi+1) * sV0**mi)/(2. * E_f * pi * r_arr ** 2))**(1./(mi+1)) wstar = E_f / T * s0**2 * mi**(-2./(mi+1)) zeta = mi**(-1./(mi+1.)) * np.exp(-1./mi) + 1. / (mi + 1.) * gamma(1 + 1./(mi+1)) * gammainc(1 + 1./(mi+1), 1./mi) strength = E_f * V_f * s0 * zeta ax1.loglog(r_arr, strength, lw=2, color='black') ax1.set_ylim(10,100) ax2.loglog(r_arr, wstar, lw=2, color='black', ls='dashed') ax2.set_ylim(0.1,1) plt.xlim(0,0.01) plt.show()
def int_sfh_2(t1, t2, tage, tau, sf_start, tburst=0, fburst=0): """Use Gamma functions """ normalized_times = (np.array([t1, t2, tage]) - sf_start) / tau mass = gammainc(2, normalized_times) intsfr = (mass[1] - mass[0]) / mass[2] return intsfr
def deflections(self, xin, yin): import numpy from math import cos, sin, pi from scipy.special import gammainc x, y = self.align_coords(xin, yin) q = self.q if q == 1.: q = 1. - 1e-7 # Avoid divide-by-zero errors b, n, re = self.b, self.n, self.re k = 2. * n - 1. / 3 + 4. / (405. * n) + 46 / (25515. * n**2) amp = (b / re)**2 / gammainc(2 * n, k * (b / re)**(1 / n)) r0 = re / q**0.5 o = numpy.ones(x.size).astype(x.dtype) eval = numpy.array( [abs(x).ravel() / r0, abs(y).ravel() / r0, n * o, q * o]).T xout = numpy.sign(x) * (amp * self.xmod.eval(eval) * r0).reshape( x.shape) yout = numpy.sign(y) * (amp * self.ymod.eval(eval) * r0).reshape( y.shape) theta = -(self.theta - pi / 2.) ctheta = cos(theta) stheta = sin(theta) x = xout * ctheta + yout * stheta y = yout * ctheta - xout * stheta return x, y
def deterministic_tau(): E_f, V_f, r, m, sV0 = 200e3, 0.01, 0.01, 7., 3.e-3 w_arr = np.linspace(0, 1.2, 300) for taui in [0.05, .1, .2]: T = 2. * taui / r s0 = ((T * (m+1) * sV0**m)/(2. * E_f * pi * r ** 2))**(1./(m+1)) k = np.sqrt(T/E_f) ef0 = k*np.sqrt(w_arr) G = 1 - np.exp(-(ef0/s0)**(m+1)) mu_int = ef0 * E_f * V_f * (1-G) I = s0 * gamma(1 + 1./(m+1)) * gammainc(1 + 1./(m+1), (ef0/s0)**(m+1)) mu_broken = E_f * V_f * I / (m+1) plt.plot(w_arr, mu_int + mu_broken, lw = 2, color = 'black') plt.ylim(0, 16) plt.xlim(0, 1.25) plt.show() fig = plt.figure() ax1 = fig.add_subplot(111) ax2 = ax1.twinx() for mi in [4.0, 5.0, 7.0]: tau_arr = np.linspace(0.05, .2, 5) T = 2. * tau_arr / r s0 = ((T * (mi+1) * sV0**mi)/(2. * E_f * pi * r ** 2))**(1./(mi+1)) wstar = E_f / T * s0**2 * mi**(-2./(mi+1)) zeta = mi**(-1./(mi+1.)) * np.exp(-1./mi) + 1. / (mi + 1.) * gamma(1 + 1./(mi+1)) * gammainc(1 + 1./(mi+1), 1./mi) strength = E_f * V_f * s0 * zeta ax1.loglog(tau_arr, strength, lw=2, color='black') ax1.set_ylim(0,15) ax2.loglog(tau_arr, wstar, lw=2, color='black', ls='dashed') ax2.set_ylim(0.1,1.) plt.xlim(0.05,.2) plt.ylim(0) plt.show()
def _draw_gamma_rates(self): ''' Function to draw and assign rates from a discretized gamma distribution, if specified. By default, 4 categories are drawn. ''' if self.rate_probs is not None: print("\nThe provided value for the `rate_probs` argument will be ignored since gamma-distributed heterogeneity has been specified with the alpha parameter.") if type(self.k_gamma) is not int: raise TypeError("\nProvided argument `num_categories` must be an integer.") #### Note that this code is adapted from gamma.c in PAML #### rv = gamma(self.alpha, scale = 1./self.alpha) freqK = np.zeros(self.k_gamma) ### probs rK = np.zeros(self.k_gamma) ### rates for i in range(self.k_gamma-1): raw=rv.ppf( (i+1.)/self.k_gamma ) freqK[i] = gammainc(self.alpha + 1, raw*self.alpha) rK[0] = freqK[0] * self.k_gamma rK[self.k_gamma-1] = (1-freqK[self.k_gamma-2]) * self.k_gamma for i in range(1,self.k_gamma-1): rK[i] = self.k_gamma * (freqK[i] -freqK[i-1]) ############################################################# self.rate_probs = np.repeat(1./self.k_gamma, self.k_gamma) self.rate_factors = deepcopy(rK) if self.pinv > ZERO: self.rate_probs = list(self.rate_probs - self.pinv/self.k_gamma) + [self.pinv] self.rate_factors = list(self.rate_factors) + [0.0] self.rate_probs = np.array( self.rate_probs ) self.rate_factors = np.array( self.rate_factors )
def cdf(self,x,nu=None,var_2=None,var_3=None,var_4=None): """cumulative distribution function """ lamb = 0.5 k = nu*.5 P = spec.gammainc(k,lamb*x) return P
def integrate_sfh_ben(t1, t2, tage, tau, sf_start, tburst=0, fburst=0): normalized_times = (np.array([t1, t2, tage]) - sf_start) / tau mass = gammainc(2, normalized_times) intsfr = (mass[1] - mass[0]) / mass[2] return intsfr
def _testCompareToExplicitDerivative(self, dtype): """Compare to the explicit reparameterization derivative. Verifies that the computed derivative satisfies dsample / dalpha = d igammainv(alpha, u) / dalpha, where u = igamma(alpha, sample). Args: dtype: TensorFlow dtype to perform the computations in. """ delta = 1e-3 np_dtype = dtype.as_numpy_dtype try: from scipy import misc # pylint: disable=g-import-not-at-top from scipy import special # pylint: disable=g-import-not-at-top alpha_val = np.logspace(-2, 3, dtype=np_dtype) alpha = constant_op.constant(alpha_val) sample = random_ops.random_gamma([], alpha, np_dtype(1.0), dtype=dtype) actual = gradients_impl.gradients(sample, alpha)[0] (sample_val, actual_val) = self.evaluate((sample, actual)) u = special.gammainc(alpha_val, sample_val) expected_val = misc.derivative( lambda alpha_prime: special.gammaincinv(alpha_prime, u), alpha_val, dx=delta * alpha_val) self.assertAllClose(actual_val, expected_val, rtol=1e-3, atol=1e-3) except ImportError as e: tf_logging.warn("Cannot use special functions in a test: %s" % str(e))
def cdf(self, y): a = self.a b = self.b p = self.p z = (y/b)**a cdf = gammainc(p, z) return cdf
def F(nu,x): """ Boys function. INPUT: NU: Boys function index X: Boys function variable OUTPUT: FF: Value of the Boys function for index NU evaluated at X Source: Evaluation of the Boys Function using Analytical Relations I. I. Guseinov and B. A. Mamedov Journal of Mathematical Chemistry 2006 """ if x < 1e-8: # Taylor expansion for argument close or equal to zero (avoid division by zero) ff = 1 / (2 * nu + 1) - x / (2 * nu + 3) else: # Evaluate Boys function with incomplete and complete Gamma functions ff = 0.5 / x**(nu+0.5) * spec.gamma(nu+0.5)*spec.gammainc(nu+0.5,x) return ff
def df(self, *arg): """ Returns the normalised DF, can only be called after Poisson solver Arguments can be: - r, v (isotropic single-mass models) - r, v, j (isotropic multi-mass models) - r, v, theta, j (anisotropic models) - x, y, z, vx, vy, vz, j (all models) Here j specifies the mass bin, j=0 for single mass Works with scalar and array input """ if (len(arg)<2)|(len(arg)==5)|(len(arg)==6)|(len(arg)>7): raise ValueError("Error: df needs 2, 3, 4 or 7 arguments") if len(arg) == 2: r, v = (self._tonp(q) for q in arg) j = 0 if len(arg) == 3: r, v = (self._tonp(q) for q in arg[:-1]) j = arg[-1] if len(arg) == 4: r, v, theta = (self._tonp(q) for q in arg[:-1]) j = arg[-1] if len(arg) < 7: r2, v2 = r**2, v**2 if len(arg) == 7: x, y, z, vx, vy, vz = (self._tonp(q) for q in arg[:-1]) j = arg[-1] r2 = x**2 + y**2 + z**2 v2 = vx**2 + vy**2 + vz**2 r, v = sqrt(r2), sqrt(v2) phi = self.interp_phi(r) vesc2 = 2.0*phi # Note: phi > 0 DF = numpy.zeros([max(r.size, v.size)]) c = (r<self.rt)&(v2<vesc2) E = (phi-0.5*v2)/self.sig2[j] # Dimensionless positive energy DF[c] = exp(E[c]) # Float truncation parameter # Following Gomez-Leyton & Velazquez 2014, J. Stat. Mech. 4, 6 if (self.g>0): DF[c] *= gammainc(self.g, E[c]) if (self.raj[j] < self.ramax): if (len(arg)==7): J2 = v2*r2 - (x*vx + y*vy + z*vz)**2 if (len(arg)==4): J2 = sin(theta)**2*v2*r2 DF[c] *= exp(-J2[c]/(2*self.raj[j]**2*self.sig2[j])) DF[c] *= self.A[j] return DF
def qtimedelay(set_par,deltim=1.): ''' gamma-function based weight function to control the runoff delay ''' alpha=3.0 print set_par['mut'] alamb = alpha/set_par['mut'] psave=0.0 set_par['frac_future']=np.zeros(500.) #Parameter added ntdh = set_par['frac_future'].size deltim=1. print 'qtimedelay is calculated with a unit of',deltim,'hours' for jtim in range(ntdh): # print jtim tfuture=jtim*deltim # print alamb*tfuture cumprob= special.gammainc(alpha, alamb*tfuture)# hoeft niet want verschil wordt genomen: /special.gamma(alpha) # print cumprob set_par['frac_future'][jtim]=max(0.,cumprob-psave) if set_par['frac_future'][jtim] > 0.0001: print set_par['frac_future'][jtim] psave = cumprob if cumprob < 0.99: print 'not enough bins in the frac_future' #make sure sum to one set_par['frac_future'][:]=set_par['frac_future'][:]/set_par['frac_future'][:].sum() return set_par
def deflections(self, xin, yin): from numpy import ones, arctan as atan, arctanh as atanh from math import cos, sin, pi, exp from numpy import arcsin as asin, arcsinh as asinh from scipy.special import gammainc, gamma x, y = self.align_coords(xin, yin) q = self.q if q == 1.: q = 1. - 1e-7 # Avoid divide-by-zero errors from sersic import sersicdeflections as sd b, n, re = self.b, self.n, self.re k = 2. * n - 1. / 3 + 4. / (405. * n) + 46 / (25515. * n**2) b = b / q**0.5 re = re / q**0.5 amp = b * b * k**(2 * n) / ( 2 * n * re**2 * (gamma(2 * n) * gammainc(2 * n, k * (b / re)**(1 / n)))) if x.ndim > 1: yout, xout = sd(-1 * y.ravel(), x.ravel(), amp, re, n, q) xout, yout = xout.reshape(x.shape), -1 * yout.reshape(y.shape) else: yout, xout = sd(-1 * y, x, amp, re, n, q) yout = -1 * yout theta = -(self.theta - pi / 2.) ctheta = cos(theta) stheta = sin(theta) x = xout * ctheta + yout * stheta y = yout * ctheta - xout * stheta return x, y
def IRF3(self, parameters): A1 = parameters['A1'].value a1 = parameters['a1'].value n1 = parameters['n1'].value t = np.arange(1.0, 10000) Fs = A1 * t**n1 * (t/a1)**-n1 * gammainc(n1, t/a1) # Step response function based on pearsonIII return np.append(0, Fs[1:] - Fs[0:-1]) # block reponse function
def loglik(self,dat): ''' Computes the loglikelihood of the data points in dat. :param dat: Data points for which the loglikelihood will be computed. :type dat: natter.DataModule.Data :returns: An array containing the loglikelihoods. :rtype: numpy.array ''' sigma,kappa,delta,gamma,n,p,s = \ self.param['sigma'],self.param['kappa'],self.param['delta'],\ self.param['gamma'],self.param['n'],self.param['p'],self.param['s'] r = squeeze(dat.X) if delta == 0.0: addTerm = - log(gammainc(n/p,kappa**p/2.0/s)) else: addTerm = 0 ll = log(p) + n*log(kappa) + (n*gamma+2.0*n*delta-2.0)/2.0 * log(r)\ + log(2.0*delta*(r**gamma + sigma**2.0) + gamma*sigma**2.0)\ -gammaln(n/p) - n/p*log(s) - (n+p)/p * log(2.0) - (n+2.0)/2.0 *log(sigma**2 + r**gamma) \ - r**(p*gamma/2.0 + p*delta)*kappa**p/2.0/s/(sigma**2+r**gamma)**(p/2.0) + addTerm return ll
def delta_chi2(ptarg, ndeg): """ Find delta chi2 corresponding to the given probability for n degrees of freedom (number of data points - number of free parameters). ptarg is the target probability (ptarg=0.9 correponds to 90%). ptarg is the probability that a model fitted to data with the given number of degrees of freedom will have a chisq val delta_chi2 larger than the minimum chisq value for the best-fitting parameters. """ assert 0 <= ptarg <= 1 d0, d1 = 0, 1e5 a = 0.5 * ndeg while True: d = 0.5*(d0 + d1) p = gammainc(a, 0.5*d) #print ptarg, p, d, d0, d1 if p > ptarg: d1 = d else: d0 = d if abs(p - ptarg) < 1e-4: break return d
def _rhov2int(self, phi, r, ra): """Compute product of density and mean square velocity """ # Isotropic case first rhov2r = exp(phi)*gammainc(self.g + 2.5, phi) rhov2 = 3*rhov2r rhov2t = 2*rhov2r # Add anisotropy if (ra < self.ramax)&(r>0)&(phi>0): p, g = r/ra, self.g p2 = p**2 p12 = 1+p2 g3, g5, g7, fp2 = g+1.5, g+2.5, g+3.5, phi*p2 P1 = p2*phi**g5/gamma(g7) H1, H2 = hyp1f1(1, g7, -fp2), hyp1f1(2, g7, -fp2) rhov2r += P1*H1 rhov2r /= p12 rhov2t /= p12 rhov2t += 2*P1*(H1/p12 + H2) rhov2t /= p12 rhov2 = rhov2r + rhov2t return rhov2, rhov2r, rhov2t
def sersic_L_Rcut(Ieff,Reff,ndex,Rcut=100): bn = 2.0*ndex-1/3.0+0.009876/ndex xtmp = bn*(Rcut)**(1.0/ndex) res = 2.0*np.pi*Ieff*Reff**2.0*ndex*(np.e**bn/(bn**(2.0*ndex)))*spf.gammainc(2.0*ndex,xtmp)*spf.gamma(2.0*ndex) #res = np.pi*Ieff*Reff**2.0*(2.0*ndex)*(np.e**bn/(bn**(2.0*ndex)))*spf.gamma(2.0*ndex) return res
def likelihood(p, f, nswitch): if nswitch == 1: ecc, pa, r_e, g_x, g_y = p #Galaxy position, eccentricity, position x, y, N, area, max_rad, E_bg, n = f #angle, half-light radius, background density else: ecc, pa, r_e, n, g_x, g_y = p x, y, N, area, max_rad, E_bg = f # rand = np.random.choice(len(x),size=(int(round(area*E_bg))),replace=False) # # mask = np.zeros(len(x)) # mask[rand] = 1 # x = np.ma.masked_array(x,mask) # y = np.ma.masked_array(y,mask) # N = len(x) - int(round(area*E_bg)) # Eqn from Martin, De Jong, Rix 2008 ellip_r = np.sqrt(((1 - ecc)**-1 * ((x - g_x) * np.cos(pa) - (y - g_y) * np.sin(pa)))**2 + ((x - g_x) * np.sin(pa) + (y - g_y) * np.cos(pa))**2) b_n = 1.9992 * n - .3271 ##Normalization term comes from Graham and Driver, 2005 norm_term = ((N - E_bg * area) * b_n**(2 * n) / (r_e**2 * 2 * np.pi * n * (1 - ecc)) / (gammainc(2 * n, b_n * (max_rad / r_e)**(1. / n)) * gamma(2 * n))) fcn = (np.sum( np.log(norm_term * np.exp(-b_n * ((ellip_r / r_e)**(1. / n))) + E_bg))) ########David Sand's LL fcn # N_ = N - area * E_bg # S0 = N_ / (2 * np.pi * (r_e / b_n)**2 * (1 - ecc)) # fcn = np.sum(np.log(S0 * np.exp(-b_n* (ellip_r / r_e)) + E_bg)) # b_n = 1.9992*n - .3271 # # N = N - E_bg*area # fcn = (-2 * N * np.log(r_e) # + N * np.log(b_n**(2*n) / n # / (gammainc(2*n,b_n * (max_rad/r_e)**(1./n)) * gamma(2*n)) # ) # - N * np.log(2 * np.pi) # - N * np.log(1-ecc) # - b_n * np.sum(ellip_r ** (1/n)) / r_e ** (1/n) # # + np.log(E_bg) # ) if (np.min(x) < g_x < np.max(x) and np.min(y) < g_y < np.max(y) and 0 <= ecc < 1 and 0 <= pa < np.pi and # 0 < r_e < 10 .3 < n < 10 and 0 < r_e < 10 #and 0 <= E_bg < N/area ): return (fcn) else: return (-np.inf)
def Iq(q, rg=60.0, porod_exp=3.0): """ :param q: Input q-value (float or [float, float]) :param rg: Radius of gyration :param porod_exp: Porod exponent :return: Calculated intensity """ usub = (q * rg)**2 * (2.0 / porod_exp + 1.0) * (2.0 / porod_exp + 2.0) / 6.0 with errstate(divide='ignore', invalid='ignore'): upow = power(usub, -0.5 * porod_exp) # Note: scipy gammainc is "regularized", being gamma(s,x)/Gamma(s), # so need to scale by Gamma(s) to recover gamma(s, x). result = (porod_exp * upow * (gamma(0.5 * porod_exp) * gammainc(0.5 * porod_exp, usub) - upow * gamma(porod_exp) * gammainc(porod_exp, usub))) result[q <= 0] = 1.0 return result
def singinhomobremss( freq, S_norm, alpha, p, peak_frequency ): # Single inhomogeneous free-free emission model return ( S_norm * (p + 1) * ((freq / peak_frequency) ** (2.1 * (p + 1) - alpha)) * special.gammainc((p + 1), ((freq / peak_frequency) ** (-2.1))) * special.gamma(p + 1) )
def mass(self, r): x = r / self._rs gamma = spfn.gamma(3. / self._alpha) return 4*np.pi*self._rhos*np.power(self._rs,3)/self._alpha* \ np.exp(2./self._alpha)* \ np.power(2./self._alpha,-3./self._alpha)* \ gamma*spfn.gammainc(3./self._alpha, (2./self._alpha)*np.power(x,self._alpha))
def _rhoint_rot(self, phi, r, theta): # Compute eq 3 for scalar phi, r and theta g, om = self.g, self.omega Q = 3 * sqrt(2) * r * sin(theta) # Eq 3 integ = quad( lambda x: exp(phi - x) * gammainc(g, phi - x) * numpy.sinh( om * Q * x**0.5), 0, phi)[0] return integ / (om * Q * gamma(1.5))
def _polymerexclvol(self, x): sc = self.params['scale'] rg = self.params['rg'] mm = self.params['m'] bg = self.params['background'] nu = 1.0 / mm Xx = x * x * rg * rg *(2.0 * nu + 1.0) * (2.0 * nu + 2.0) / 6.0 onu = 1.0 / nu o2nu = 1.0 /(2.0 * nu) Ps =(1.0 / (nu * pow(Xx,o2nu))) * (gamma(o2nu)*gammainc(o2nu,Xx) - \ 1.0 / pow(Xx,o2nu) * gamma(onu)*gammainc(onu,Xx)) if x == 0: Ps = 1.0 return (sc * Ps + bg);
def get_mass(self,r): """galpy power-law mass be careful of the scipy gamma incomplete gamma function definition! inputs --------------- r : radius to compute enclosed mass for """ return 2.*np.pi*self.rho0*self.rcut**(3.-self.alpha)*gammainc(1.5-self.alpha/2.,(r/self.rcut)**2.)*gamma(1.5-self.alpha/2.)
def test_incomplete_gamma_p(self, N, percentile): inverse = covid19.inv_incomplete_gamma_p(percentile, N) forward = gammainc(N, inverse) np.testing.assert_almost_equal( percentile, forward, decimal=6, err_msg= "Forward and inverse calculations of incomplete gamma don't agree")
def calculate_r(z, t2, length, alpha, beta, N): x1 = np.power(z, 2) x1_ = np.cumsum(x1, axis=1) x1 = np.outer(x1_, t2) x2 = x1.transpose() x3 = np.zeros(length) x3 = np.c_[x3, x2[:, :-1]] x3 = np.tril(x3) x4 = (x1 - x3) / 2 # x5 = (1 - 1 / eta**2) * x4 - N * np.log(eta) x5_1 = np.tril(np.log(gammainc(beta + x4, alpha + N / 2))) x5_2 = np.tril(gammaln(alpha + N / 2)) x5_3 = alpha * np.log(beta) - gammaln(alpha) - np.log(gammainc( beta, alpha)) x5_4 = -(alpha + N / 2) * np.tril(np.log(beta + x4)) x5 = x4 + x5_1 + x5_2 + x5_3 + x5_4 lmbda = np.tril(np.exp(x5)) r = np.sum(lmbda.T, axis=0) return r
def posterior(D): """Remember gammainc is normalized to gamma""" min_D = sigma2 / dt if D <= min_D: ln_res = -np.inf else: ln_res = (p * log(n * V * G3 / (4 * dt * D)) - n * V * G3 / (4 * D * dt) - log(D) - log(gammainc(p, rel_loc_error * G3)) - gammaln(p)) return np.exp(ln_res)
def getGamma(k, maxsbins): # Space out bins according to shape k+1 so that each bin represents an equal # (incomplete) expectation of X in the shape k distribution. Other bin choices are # possible, but this is a good one from the point of view of achieving more accuracy # using a smaller number of bins. l = gammadist.ppf([i / maxsbins for i in range(maxsbins)], k + 1) # Calculate: # m0[i] = P[X < l_i] # m1[i] = E[X; X < l_i] # susc[i] = E[X | l_i <= X < l_{i+1}], the representative susceptibility for bin i # q[i] = P(l_i <= X < l_{i+1}) m0 = np.append(gammainc(k, l), 1) m1 = np.append(gammainc(k + 1, l), 1) susc = np.array([(m1[i + 1] - m1[i]) / (m0[i + 1] - m0[i]) for i in range(maxsbins)]) q = np.array([m0[i + 1] - m0[i] for i in range(maxsbins)]) return susc, q
def getMass(self, sigCrit=1.): from math import pi from scipy.special import gammainc, gamma b, n, re = self.b, self.n, self.re k = 2. * n - 1. / 3 + 4. / (405. * n) + 46 / (25515. * n**2) amp = b * b * k**(2 * n) / ( 2 * n * re**2 * (gamma(2 * n) * gammainc(2 * n, k * (b / re)**(1 / n)))) return 2 * pi * sigCrit * re**2 * amp * gamma(2 * n) * n / k**(2 * n)
def eta_esin(nu, r, tempi, tempe, v): theta = boltzmann * tempe / (electronMass * cLight2) ne = eDens(r, tempi, tempe, v) h = height(r, tempi, tempe) tau_es = 2.0 * ne * thomson * h s_exp = tau_es * (tau_es + 1.0) A = 1.0 + 4.0 * theta * (1.0 + 4.0 * theta) etaMax = 3.0 * boltzmann * tempe / (planck * nu) jm = np.log(etaMax) / np.log(A) gamma1 = sp.gammainc(jm + 1.0, A * s_exp) gamma2 = sp.gammainc(jm + 1.0, s_exp) aux2 = s_exp * (A - 1.0) result = np.where(aux2 < 200.0, np.exp(aux2) * (1.0 - gamma1) + etaMax * gamma2, etaMax * gamma2) return result
def testIgammaMediumValues(self, dtype, rtol, atol): # Test values near zero. x = np.random.uniform(low=1., high=100., size=[NUM_SAMPLES]).astype(dtype) a = np.random.uniform(low=1., high=100., size=[NUM_SAMPLES]).astype(dtype) expected_values = sps.gammainc(a, x) with self.session() as sess: with self.test_scope(): actual = sess.run(math_ops.igamma(a, x)) self.assertAllClose(expected_values, actual, atol=atol, rtol=rtol)
def expected_grad(sample, concentration, rate): u = sp_special.gammainc( concentration, sample * rate) delta = 1e-3 return sp_misc.derivative( lambda concentration_prime: sp_special. gammaincinv( # pylint:disable=g-long-lambda concentration_prime, u), concentration, dx=delta * concentration) / rate
def sersic_mag_tot_to_Ieff(mag_tot, Reff, ndex, z, Rcut=100): # g band bn = 2.0 * ndex - 1 / 3.0 + 0.009876 / ndex xtmp = bn * (Rcut)**(1.0 / ndex) ktmp = 2.0 * np.pi * ndex * (np.e**bn / (bn**(2.0 * ndex))) * spf.gammainc( 2.0 * ndex, xtmp) * spf.gamma(2.0 * ndex) Dl_s = p13.luminosity_distance(z).value * 1e6 Ieff = 10.0**((5.12 - 2.5 * np.log10(ktmp) - 5.0 * np.log10(Reff) + 5.0 * np.log10(Dl_s / 10) - mag_tot) * 0.4) # L_sun/pc^2 return Ieff
def rho0(self, mass): """Central density for the Einasto profile in M_sun/Mpc^3 h^2""" alpha = 0.18 R200 = self.R200(mass) conc = self.concentration(mass) gamma = special.gammainc( 3 / alpha, 2 / alpha * conc**alpha) * special.gamma(3 / alpha) prefac = 4 * math.pi * np.exp( 2 / alpha) / alpha * (alpha / 2)**(3 / alpha) return mass / gamma / prefac / (R200 / conc)**3
def cdf(self, dat): ''' Evaluates the cumulative distribution function on the data points in dat. :param dat: Data points for which the c.d.f. will be computed. :type dat: natter.DataModule.Data :returns: A numpy array containing the probabilities. :rtype: numpy.array ''' u = array([self.param['a'], self.param['b']]) u = .5 + 0.5 * sign(u) * gammainc( 1 / self.param['p'], abs(u)**self.param['p'] / self.param['s']) return squeeze(.5 + 0.5 * sign(dat.X) * gammainc(1 / self.param['p'], abs(dat.X)**self.param['p'] / self.param['s']) - u[0]) / (u[1] - u[0])
def get_rho0(self): """solve the mass enclosed at 100rcut to recover the central density returned in units of density, mass/(length^3) """ r = 100.*self.rscl tmp_mass = 2.*np.pi*self.rcut**(3.-self.alpha)*gammainc(1.5-self.alpha/2.,(r/self.rcut)**2.)*gamma(1.5-self.alpha/2.) return self.M/tmp_mass
def randsphere(n_points,ndim,radius,center = []): if center == []: center = np.array([0]*ndim) r = radius x = np.random.normal(size=(n_points, ndim)) ssq = np.sum(x**2,axis=1) fr = r*gammainc(ndim/2,ssq/2)**(1/ndim)/np.sqrt(ssq) frtiled = np.tile(fr.reshape(n_points,1),(1,ndim)) p = center + np.multiply(x,frtiled) return p, center
def approximateEntropy(m, sequence): n = len(sequence) fi1 = get_fi(m, sequence) fi2 = get_fi(m + 1, sequence) print(fi1 - fi2) print(math.log(2) - (fi1 - fi2)) obs = 2 * n * (math.log(2) - (fi1 - fi2)) print(obs) p = 1 - special.gammainc(math.pow(2, m - 1), obs / 2) return p, p >= 0.01
def v_esc_theory_flat_lambda(theta,z_c,alpha,rho_2_1e14,r_2,beta,little_h,omega_DE): """cosmology""" H_z = H_z_function(z_c, [omega_DE,little_h],'flat_lambda') q_z= q_z_function(z_c,omega_DE,'flat_lambda') """Einasto""" ### map betweenEinasto params and Miller et al params### rho_2 = rho_2_1e14*1e14 n = 1/alpha rho_0 = rho_2 * np.exp(2.*n) h = r_2 / (2.*n)**n d_n = (3*n) - (1./3.) + (8./1215.*n) + (184./229635.*n**2.) + (1048./31000725.*n**3.) - (17557576./1242974068875. * n**4.) gamma_3n = 2 * ((ss.gammainc(3*n , d_n) ) * ss.gamma(3*n)) Mtot = 4. * np.pi * rho_0 * Msun * (h**3.) * n * gamma_3n #kg G_newton = astroc.G.to( u.Mpc * u.km**2 / u.s**2 / u.kg).value #Mpc km2/s^2 kg r_eq_cubed = -((G_newton*Mtot) / (q_z * H_z**2.)) #Mpc ^3 r_eq = (r_eq_cubed)**(1.0/3.0)# Mpc """if r_eq -> infinity then return vanilla Einasto""" if q_z < 0.: ### phi orig ### s_orig = r/h part1_orig = 1. - ( ( ss.gammaincc(3.*n,s_orig**(1./n)) * ss.gamma(3.*n) ) / gamma_3n ) part2_orig = (s_orig * ss.gammaincc(2.*n,s_orig**(1./n)) * ss.gamma(2.*n) ) / gamma_3n phi_ein_orig = -(G_newton* Mtot/(s_orig*h)) * (part1_orig+part2_orig) ### phi r_eq ### s_req = r_eq/h part1_req = 1. - ( ( ss.gammaincc(3.*n,s_req**(1./n)) * ss.gamma(3.*n) ) / gamma_3n ) part2_req = (s_req * ss.gammaincc(2.*n,s_req**(1./n)) * ss.gamma(2.*n) ) / gamma_3n phi_ein_req = -(G_newton* Mtot/(s_req*h)) * (part1_req+part2_req) v_esc = np.sqrt(-2.*( phi_ein_orig - phi_ein_req ) - q_z * (H_z**2.) * (r**2 - r_eq**2) ) elif q_z >= 0.: ### phi orig ### s_orig = r/h part1_orig = 1. - ( ( ss.gammaincc(3.*n,s_orig**(1./n)) * ss.gamma(3.*n) ) / gamma_3n ) part2_orig = (s_orig * ss.gammaincc(2.*n,s_orig**(1./n)) * ss.gamma(2.*n) ) / gamma_3n phi_ein_orig = -(G_newton* Mtot/(s_orig*h)) * (part1_orig+part2_orig) v_esc = np.sqrt(-2.*( phi_ein_orig )) v_esc_projected = v_esc / np.sqrt(g_beta(beta)) return v_esc_projected
def v_esc_theory_non_flat_lil(theta,z_c,alpha,rho_2_1e14,r_2,beta,lil_omega_M,lil_omega_lambda): """cosmology""" qHsquared = ( (0.5 * lil_omega_M * (1+z_c)**3.)- lil_omega_lambda) * 100.**2. """Einasto""" ### map betweenEinasto params and Miller et al params### rho_2 = rho_2_1e14*1e14 n = 1/alpha rho_0 = rho_2 * np.exp(2.*n) h = r_2 / (2.*n)**n d_n = (3*n) - (1./3.) + (8./1215.*n) + (184./229635.*n**2.) + (1048./31000725.*n**3.) - (17557576./1242974068875. * n**4.) gamma_3n = 2 * ((ss.gammainc(3*n , d_n) ) * ss.gamma(3*n)) Mtot = 4. * np.pi * rho_0 * Msun * (h**3.) * n * gamma_3n #kg G_newton = astroc.G.to( u.Mpc * u.km**2 / u.s**2 / u.kg).value #Mpc km2/s^2 kg r_eq_cubed = -(G_newton*Mtot) / qHsquared #Mpc ^3 r_eq = (r_eq_cubed)**(1.0/3.0)# Mpc """if r_eq -> infinity then return vanilla Einasto""" if math.isnan(r_eq) == False: ### phi orig ### s_orig = r/h part1_orig = 1. - ( ( ss.gammaincc(3.*n,s_orig**(1./n)) * ss.gamma(3.*n) ) / gamma_3n ) part2_orig = (s_orig * ss.gammaincc(2.*n,s_orig**(1./n)) * ss.gamma(2.*n) ) / gamma_3n phi_ein_orig = -(G_newton* Mtot/(s_orig*h)) * (part1_orig+part2_orig) ### phi r_eq ### s_req = r_eq/h part1_req = 1. - ( ( ss.gammaincc(3.*n,s_req**(1./n)) * ss.gamma(3.*n) ) / gamma_3n ) part2_req = (s_req * ss.gammaincc(2.*n,s_req**(1./n)) * ss.gamma(2.*n) ) / gamma_3n phi_ein_req = -(G_newton* Mtot/(s_req*h)) * (part1_req+part2_req) v_esc = np.sqrt(-2.*( phi_ein_orig - phi_ein_req ) - qHsquared * (r**2 - r_eq**2) ) elif math.isnan(r_eq) == True: ### phi orig ### s_orig = r/h part1_orig = 1. - ( ( ss.gammaincc(3.*n,s_orig**(1./n)) * ss.gamma(3.*n) ) / gamma_3n ) part2_orig = (s_orig * ss.gammaincc(2.*n,s_orig**(1./n)) * ss.gamma(2.*n) ) / gamma_3n phi_ein_orig = -(G_newton* Mtot/(s_orig*h)) * (part1_orig+part2_orig) v_esc = np.sqrt(-2.* phi_ein_orig ) v_esc_projected = v_esc / np.sqrt(g_beta(beta)) return v_esc_projected
def mole_gammainc(m, z): """ Compute incomplete gamma function defined below . F_m(z) = Int_0^1 t^{2m} Exp[-zt^2]dt Impled with scipy.special.gammainc(a,x) defined below . 1/Gamma[a] Int_0^x t^{a-1} Exp[-t] dt Variable transformation . t->(t^2)/x . dt -> (2t/x) dt . gammainc(a,x) = x^{1-a} /Gamma[a] Int_0^1 t^{2a-2} (2t/x) Exp[-(t^2)/x] dt . = 2 (x^(-a))/gamma[a] Int_0^1 t^{2a-1} Exp[-(t^2)/x] dt . F_m(z) = (1/2) gamma[a] x^a Special case . z = 0 . F_m(0) = Int_0^1 t^{2m} dt . = (2m+1)^{-1} [t^{2m+1}]_0^1 . = (2m+1)^{-1} """ eps = 10.0**(-14.0) if (abs(z) < eps): return 1 / (2 * m + 1.0) if (m == 0): a = m + 0.5 res = gamma(a) / (2 * z**a) * gammainc(a, z) # res = sqrt(pi/z)/2 * erf(sqrt(z)) else: a = m + 0.5 res = gamma(a) / (2 * z**a) * gammainc(a, z) if ((not res < 1) and (not res > -1)): raise RuntimeError("""gammain failed res: {2} m: {0} z: {1} """.format(m, z, res)) return res
def qminus_esin_fast(r, tempi, tempe, v): nuMin = 1.0e6 nuMax = 1.0e21 iter = 30 paso = np.power(nuMax / nuMin, 1.0 / float(iter - 1)) sum = 0.0 nu = nuMin theta = boltzmann * tempe / (electronMass * cLight2) ne = eDens(r, tempi, tempe, v) h = height(r, tempi, tempe) k_es = ne * thomson tau_es = 2.0 * k_es * h A = 1.0 + 4.0 * theta * (1.0 + 4.0 * theta) for i in range(iter): x = planck * nu / (electronMass * cLight2) / (3.0 * theta) bnu = blackbody_nu(nu, tempe).value bnu2 = 4.0 * np.pi * bnu xi = xiBremss(nu, r, tempi, tempe, v) + xiSync(nu, r, tempi, tempe, v) #k_nu = np.where(bnu2 > 1.0e-2*xi*h,xi/bnu2,50.0) k_nu = xi / bnu2 #l_eff = 1.0/np.sqrt(k_nu*(k_nu+k_es)) #tau_es = 2.0*k_es*np.where(l_eff<h,l_eff,h) s_exp = tau_es * (tau_es + 1.0) etaMax = 3.0 * boltzmann * tempe / (planck * nu) jm = np.log(etaMax) / np.log(A) gamma1 = sp.gammainc(jm + 1.0, A * s_exp) gamma2 = sp.gammainc(jm + 1.0, s_exp) aux2 = s_exp * (A - 1.0) #etaa = np.where(aux2<200.0,np.exp(aux2)*(1.0-gamma1)+etaMax*gamma2,etaMax*gamma2) etaa = np.exp(aux2) * (1.0 - gamma1) + etaMax * gamma2 tau_nu = np.sqrt(np.pi) / 2.0 * k_nu * h fluxx = 2.0*np.pi/np.sqrt(3.0) * bnu * \ (1.0-np.exp(-2.0*np.sqrt(3.0)*tau_nu)) dnu = nu * (np.sqrt(paso) - 1.0 / np.sqrt(paso)) sum += fluxx * etaa * dnu nu = nu * paso return sum * 2.0 / (np.sqrt(np.pi) * h)
def compute_deff_prime(alpha_ice, g_ice, sigma_a, delta_a1, delta_a2, sigma_v, delta_v1, delta_v2, Dr, x): alpha_a1_g_ice = (alpha_ice + delta_a1 + 1) / g_ice alpha_a2_g_ice = (alpha_ice + delta_a2 + 1) / g_ice t_k = (1 / x) * (Dr**g_ice) #coordinate transform for limit of integration gamma_fun_a1 = gm.gamma(alpha_a1_g_ice) inc_gamma_fun_a1 = gm.gammainc(t_k, alpha_a1_g_ice) gamma_fun_a2 = gm.gamma(alpha_a2_g_ice) inc_gamma_fun_a2 = gm.gammainc(t_k, alpha_a2_g_ice) alpha_v1_g_ice = (alpha_ice + 2 * delta_v1 + 1) / g_ice alpha_v2_g_ice = (alpha_ice + 2 * delta_v2 + 1) / g_ice gamma_fun_v1 = gm.gamma(alpha_v1_g_ice) inc_gamma_fun_v1 = gm.gammainc(t_k, alpha_v1_g_ice) gamma_fun_v2 = gm.gamma(alpha_v2_g_ice) inc_gamma_fun_v2 = gm.gammainc(t_k, alpha_v2_g_ice) A = Dr**(-2 * delta_v1) * inc_gamma_fun_v1 * gamma_fun_v1 B = Dr**(-2 * delta_v2) * (1 - inc_gamma_fun_v2) * gamma_fun_v2 C = Dr**(-delta_a1) * inc_gamma_fun_a1 * gamma_fun_a1 G = Dr**(-delta_a2) * (1 - inc_gamma_fun_a2) * gamma_fun_a2 area_factor = (C * x**(delta_a1 / g_ice) + G * x**(delta_a2 / g_ice)) deff_prime = (A * x**(2 * delta_v1 / g_ice) + B * x**(2 * delta_v2 / g_ice)) / area_factor deff_prime = Dr * deff_prime**0.25 * (sigma_v**2 / sigma_a)**0.25 #compute average area of particle in square microns. ave_area = sigma_a * (np.pi / 4) * Dr**2 * area_factor / gm.gamma( (alpha_ice + 1) / g_ice) ave_area *= 1e-12 LOG.debug('ave_area') LOG.debug(ave_area) return deff_prime, ave_area
def boys(n, x): import scipy.special as sp # x -> 0: the denominator goes to 0, zero deviation error will occur. # thus, have to return 0-limit value(x->0.) if x < 0.: raise radius = 0.0001 if x < radius: return 1. / (2.0 * n + 1.0) else: numerator = sp.gammainc(n+0.5, x) * sp.gamma(n + 0.5) denominator = 2.0 * math.pow(x, n + 0.5) return numerator /denominator
def Q(self, nu, chisq): """ Calculate the probability that a normally distributed random numbers produce a chi squared value greater than measured. The distribution is described by an incomplete gamma function and should only be used for models that are linear or close to linear in their parameters. [1] pg. 778-780. :param nu: Number of degrees of freedom. :param chisq: Measured chi squared value. :return: The probability that random noise will produce a chi squared greater than the measured value. """ return 1 - spsp.gammainc(nu / 2, chisq / 2)
def _cdf(self, x): k = self.k mu = self.mu p = self.p sumand = (k * (-p + 1) * gamma(k) * gammainc(k, mu * x)) / ( (factorial(k - 1) * gamma(k + 1))) if mu == 0: return sumand + mu * p * x else: return sumand + mu * p * (-(1 / mu) * np.exp(-mu * x))
def gamma_dist(k, theta, n=400): assert k > 0 and theta > 0 assert type(n) == int and n > 2 dist = np.zeros((n, 2)) dist[:, 0] = np.linspace(0, k * theta + 5 * np.sqrt(k) * theta, n, endpoint=False) cumdist = np.concatenate((sp.gammainc(k, dist[:, 0] / theta), [1])) dist[:, 1] = np.diff(cumdist) return dist