def epsilon_experiment(N, series_type, Omega, eps_values=[1.0, 0.1, 0.01, 0.001]): # x is global, symbol or array psi = series(x, series_type, N) f = 1 for eps in eps_values: A = sym.zeros(N - 1, N - 1) b = sym.zeros(N - 1) for i in range(0, N - 1): integrand = f * psi[i] integrand = sym.lambdify([x], integrand, 'mpmath') b[i, 0] = mpmath.quad(integrand, [Omega[0], Omega[1]]) for j in range(0, N - 1): integrand = eps*sym.diff(psi[i], x)*\ sym.diff(psi[j], x) - sym.diff(psi[i], x)*psi[j] integrand = sym.lambdify([x], integrand, 'mpmath') A[i, j] = mpmath.quad(integrand, [Omega[0], Omega[1]]) c = A.LUsolve(b) u = sum(c[r, 0] * psi[r] for r in range(N - 1)) + x U = sym.lambdify([x], u, modules='numpy') x_ = numpy.arange(Omega[0], Omega[1], 1 / ((N + 1) * 100.0)) U_ = U(x_) plt.plot(x_, U_) plt.legend(["eps=%.1e" % eps for eps in eps_values], loc="upper left") plt.title(series_type) plt.show()
def least_squares_orth(f, psi, Omega, symbolic=True, print_latex=False): """ Given a function f(x,y) on a rectangular domain Omega=[[xmin,xmax],[ymin,ymax]], return the best approximation to f(x,y) in the space V spanned by the functions in the list psi. This function assumes that psi are orthogonal on Omega. """ # Modification of least_squares function: drop the j loop, # set j=i, compute c on the fly in the i loop. N = len(psi) - 1 # Note that A, b, c becmes (N+1)x(N+1), use 1st column A = sym.zeros(N + 1) b = sym.zeros(N + 1) c = sym.zeros(N + 1) x, y = sym.symbols('x y') print('...evaluating matrix...', A.shape, b.shape, c.shape) for i in range(N + 1): j = i print('(%d,%d)' % (i, j)) integrand = psi[i] * psi[j] if symbolic: I = sym.integrate(integrand, (x, Omega[0][0], Omega[0][1]), (y, Omega[1][0], Omega[1][1])) if not symbolic or isinstance(I, sym.Integral): # Could not integrate symbolically, use numerical int. print('numerical integration of', integrand) integrand = sym.lambdify([x, y], integrand, 'mpmath') I = mpmath.quad(integrand, [Omega[0][0], Omega[0][1]], [Omega[1][0], Omega[1][1]]) A[i, 0] = I integrand = psi[i] * f if symbolic: I = sym.integrate(integrand, (x, Omega[0][0], Omega[0][1]), (y, Omega[1][0], Omega[1][1])) if not symbolic or isinstance(I, sym.Integral): # Could not integrate symbolically, use numerical int. print('numerical integration of', integrand) integrand = sym.lambdify([x, y], integrand, 'mpmath') I = mpmath.quad(integrand, [Omega[0][0], Omega[0][1]], [Omega[1][0], Omega[1][1]]) b[i, 0] = I c[i, 0] = b[i, 0] / A[i, 0] print() print('A:\n', A, '\nb:\n', b) c = [c[i, 0] for i in range(c.shape[0])] # make list print('coeff:', c) # c is a sympy Matrix object, numbers are in c[i,0] u = sum(c[i] * psi[i] for i in range(len(psi))) print('approximation:', u) print('f:', sym.expand(f)) if print_latex: print(sym.latex(A, mode='plain')) print(sym.latex(b, mode='plain')) print(sym.latex(c, mode='plain')) return u, c
def test(self): pot = lambda x,y,z: self.m/2.*(self.wx**2*x**2+self.wy**2*y**2+self.wz**2*z**2) u0 = 4*pi*hbar**2*self.a0/self.m TF = lambda x,y,z: scipy.maximum(self.mu-pot(x,y,z)/u0,0) import mpmath print 'hi' print mpmath.quad(TF,[-self.Rx,self.Rx],[-self.Ry,self.Ry],[-self.Rz,self.Rz])
def cdf(x, p, b, loc=0, scale=1): """ Cumulative distribution function of the generalized inverse Gaussian distribution. The CDF is computed by using mpmath.quad to numerically integrate the PDF. """ x = mpmath.mpf(x) p = mpmath.mpf(p) b = mpmath.mpf(b) loc = mpmath.mpf(loc) scale = mpmath.mpf(scale) if x <= loc: return mpmath.mp.zero m = mode(p, b, loc, scale) # If the mode is in the integration interval, use it to do the integral # in two parts. Otherwise do just one integral. if x <= m: c = mpmath.quad(lambda t: pdf(t, p, b, loc, scale), [loc, x]) else: c = (mpmath.quad(lambda t: pdf(t, p, b, loc, scale), [loc, m]) + mpmath.quad(lambda t: pdf(t, p, b, loc, scale), [m, x])) c = min(c, mpmath.mp.one) return c
def least_squares_non_verbose(f, psi, Omega, symbolic=True): """ Given a function f(x) on an interval Omega (2-list) return the best approximation to f(x) in the space V spanned by the functions in the list psi. """ N = len(psi) - 1 A = sym.zeros(N + 1, N + 1) b = sym.zeros(N + 1, 1) x = sym.Symbol('x') for i in range(N + 1): for j in range(i, N + 1): integrand = psi[i] * psi[j] integrand = sym.lambdify([x], integrand, 'mpmath') I = mpmath.quad(integrand, [Omega[0], Omega[1]]) A[i, j] = A[j, i] = I integrand = psi[i] * f integrand = sym.lambdify([x], integrand, 'mpmath') I = mpmath.quad(integrand, [Omega[0], Omega[1]]) b[i, 0] = I c = mpmath.lu_solve(A, b) # numerical solve c = [c[i, 0] for i in range(c.rows)] u = sum(c[i] * psi[i] for i in range(len(psi))) return u, c
def ila_er_lp1(self, rloc): alpha, beta = self.alpha, self.beta interval = [0, self.k * self.na] integrand = lambda eta: self.ila_integrand_lp1_a(eta, rloc) res = (alpha + 1j * beta) / 2 * mpmath.quad(integrand, interval) integrand = lambda eta: self.ila_integrand_lp1_b(eta, rloc) res += (alpha + 1j * beta) / 2 * mpmath.quad(integrand, interval) return res
def least_squares_numerical(f, psi, N, x, integration_method='scipy', orthogonal_basis=False): """ Given a function f(x) (Python function), a basis specified by the Python function psi(x, i), and a mesh x (array), return the best approximation to f(x) in in the space V spanned by the functions in the list psi. The best approximation is represented as an array of values corresponding to x. All calculations are performed numerically. integration_method can be `scipy` or `trapezoidal` (the latter uses x as mesh for evaluating f). """ import scipy.integrate A = np.zeros((N + 1, N + 1)) b = np.zeros(N + 1) if not callable(f) or not callable(psi): raise TypeError('f and psi must be callable Python functions') Omega = [x[0], x[-1]] dx = x[1] - x[0] # assume uniform partition print('...evaluating matrix...', end=' ') for i in range(N + 1): j_limit = i + 1 if orthogonal_basis else N + 1 for j in range(i, j_limit): print('(%d,%d)' % (i, j)) if integration_method == 'scipy': A_ij = scipy.integrate.quad(lambda x: psi(x, i) * psi(x, j), Omega[0], Omega[1], epsabs=1E-9, epsrel=1E-9)[0] elif integration_method == 'sympy': A_ij = mpmath.quad(lambda x: psi(x, i) * psi(x, j), [Omega[0], Omega[1]]) else: values = psi(x, i) * psi(x, j) A_ij = trapezoidal(values, dx) A[i, j] = A[j, i] = A_ij if integration_method == 'scipy': b_i = scipy.integrate.quad(lambda x: f(x) * psi(x, i), Omega[0], Omega[1], epsabs=1E-9, epsrel=1E-9)[0] elif integration_method == 'sympy': b_i = mpmath.quad(lambda x: f(x) * psi(x, i), [Omega[0], Omega[1]]) else: values = f(x) * psi(x, i) b_i = trapezoidal(values, dx) b[i] = b_i c = b / np.diag(A) if orthogonal_basis else np.linalg.solve(A, b) u = sum(c[i] * psi(x, i) for i in range(N + 1)) return u, c
def discrete_util(self, timeslice): lower = slice2min(timeslice) - conf.TICK / 2.0 upper = lower + conf.TICK if timeslice == 0: ans = quad(self.marginal_util, [0.0, conf.TICK/2.0]) + \ quad(self.marginal_util, [conf.DAY-conf.TICK/2.0, conf.DAY]) else: ans = quad(self.marginal_util, [lower, upper]) return ans
def discrete_util(self, timeslice): lower = slice2min(timeslice) - conf.TICK/2.0 upper = lower + conf.TICK if timeslice == 0: ans = quad(self.marginal_util, [0.0, conf.TICK/2.0]) + \ quad(self.marginal_util, [conf.DAY-conf.TICK/2.0, conf.DAY]) else: ans = quad(self.marginal_util, [lower, upper]) return ans
def rate_cov_strate_sleeping_v3_uniform(k_matrix,alpha,rate_th1,lamda_u1,bw): # define the distribution of the activity first_int = (1/3) # correspond to the integral in first term second_int = (1/2) - (1/3) # correspond to the integral in second term #---------------------------- calibrated ----------------------------------------- expected_activity = (1/2) # expected value of a # this changes for optimization hance should be calibratable expected_strategic_function = (1/2) # expected value of s #---------------------------- calibrated ----------------------------------------- noise_var = 1 # preprocessing - define empty elements and get information about the inputs k_mat = k_matrix.copy() num_tiers = k_mat.shape[0] density_org = k_mat[:,2].copy() power = gb.db2pow(k_mat[:,1]) density_update = np.array(density_org*([1]*(num_tiers-1)+[expected_strategic_function])) # define necessary values area_org = np.zeros(num_tiers,float) # original association probability area_sc_update = np.zeros(num_tiers,float) # association probability of disconnected cell N_k_u1 = np.zeros(num_tiers,float) #number of users in tier K BS N_k_sc = np.zeros(num_tiers,float) #number of users in tier K BS N_k_total = np.zeros(num_tiers,float) threshold_u1 = np.zeros(num_tiers,float) #threshold for users in tier K BS t_func_main = np.zeros(num_tiers,float) t_func_sc = np.zeros(num_tiers,float) for i in range(num_tiers): area_org[i] = A_k(density_org,power,alpha,i) area_sc_update[i] = A_k(density_update,power,alpha,i) N_k_u1 = 1 + 1.28*lamda_u1*(area_org/density_org) N_k_sc = expected_activity*(1-expected_strategic_function)*density_org[-1]*N_k_u1[-1]*(area_sc_update/density_update) #for binary optimization N_k_total = N_k_u1 + N_k_sc threshold_u1 = 2**((rate_th1/bw)*N_k_total) -1 for i in range(num_tiers): first_exp_term = -(threshold_u1[i]*noise_var/power[i]) z_term = 0 if (threshold_u1[i]==0) else (threshold_u1[i])**(2/alpha) *mp.quad(lambda u: 1/ (1+u**(alpha/2)),[(1/threshold_u1[i])**(2/alpha),mp.inf]) second_exp_term = -mp.pi*z_term* sum(density_update*(power/power[i])**(2/alpha)) third_exp_term_main = -mp.pi * sum(density_org*(power/power[i])**(2/alpha)) third_exp_term_sc = -mp.pi * sum(density_update*(power/power[i])**(2/alpha)) t_func_main[i] = mp.quad(lambda y: y * mp.exp(first_exp_term*y**alpha) * mp.exp(second_exp_term*y**2) * mp.exp(third_exp_term_main*y**2),[0,mp.inf]) t_func_sc[i] = mp.quad(lambda y: y* mp.exp(first_exp_term*y**alpha) * mp.exp(second_exp_term*y**2) * mp.exp(third_exp_term_sc*y**2), [0,mp.inf]) temp_second_sum = sum(2*mp.pi*density_update*t_func_sc) temp_third_sum = sum(2*mp.pi*density_org[0:-1]*t_func_main[0:-1]) #rate_coverage = (2*mp.pi*density_org[-1]/expected_activity)*(t_func_main[-1]*first_int + temp_second_sum*second_int) + temp_third_sum rate_coverage = (area_org[-1]/expected_activity)*((2*mp.pi*density_org[-1]/area_org[-1])*t_func_main[-1]*first_int + temp_second_sum*second_int) + temp_third_sum #print((sum(2*mp.pi*density_update*t_func_sc)*second_int+t_func_main[-1]*first_int)*(2*mp.pi*density_org[-1])) #print(t_func_main[-1]*first_int) #print(temp_second_sum*second_int) #print((2*mp.pi*density_org[-1]/expected_activity)*(t_func_main[-1]*first_int) + temp_third_sum) #print(temp_second_sum) return (rate_coverage)
def arc_length(self, start, stop, q_type = None): """ Parameters: --------- q_type: string 'exact', 'integral', 'numeric' start, stop: numeric/str These are the limits of integration """ start = sym.sympify(start) stop = sym.sympify(stop) if q_type is None: q_type = self.q_type u = self.u I = sym.Integral(self.ds, (u, start, stop)) if q_type == 'integral': return I elif q_type == 'exact': return I.doit() else: f = make_func(str(self.ds), func_params=(self.ind_var), func_type='numpy') value = mp.quad(f, [float(start.evalf()), float(stop.evalf())]) return value
def element_vector(f, phi, Omega_e, symbolic=True, numint=None): n = len(phi) b_e = sym.zeros(n, 1) # Make f a function of X (via f.subs to avoid real numbers from lambdify) X = sym.Symbol('X') if symbolic: h = sym.Symbol('h') else: h = Omega_e[1] - Omega_e[0] x = (Omega_e[0] + Omega_e[1]) / 2 + h / 2 * X # mapping f = f.subs('x', x) detJ = h / 2 if numint is None: for r in range(n): if symbolic: I = sym.integrate(f * phi[r] * detJ, (X, -1, 1)) if not symbolic or isinstance(I, sym.Integral): # Ensure h is numerical h = Omega_e[1] - Omega_e[0] detJ = h / 2 f_func = sym.lambdify([X], f, 'mpmath') phi_func = sym.lambdify([X], phi[r], 'mpmath') integrand = lambda X: f_func(X) * phi_func(X) * detJ I = mpmath.quad(integrand, [-1, 1]) b_e[r] = I else: #phi = [sym.lambdify([X], phi[r]) for r in range(n)] # f contains h from the mapping, substitute X with Xj # instead of f = sym.lambdify([X], f) for r in range(n): for j in range(len(numint[0])): Xj, wj = numint[0][j], numint[1][j] fj = f.subs(X, Xj) b_e[r] += fj * phi[r](Xj) * detJ * wj return b_e
def calculate(self): """ Example: >>> calc = CrossSectionCalcBed(1.4e8, atom = AtomFactory.get_h2()) >>> calc.calculate()*2. """ integrated_cross_sec_subshells = np.zeros(len(self.w_max)) for n_shell in range(len(self.w_max)): u = self.u[n_shell] S = self.S[n_shell] factor = S / (self.t[n_shell] + u + 1.0) sub_factor1_1 = 2.0 - (self.atom.Ni[n_shell] / self.atom.N[n_shell]) sub_factor1_2 = (self.t[n_shell] - 1.0) / self.t[n_shell] - np.log( self.t[n_shell]) / (self.t[n_shell] + 1.) summand1 = sub_factor1_1 * sub_factor1_2 integrated_cross_sec_subshells[n_shell] = mp.quad( lambda w: self.calculate_modified_oscillator_strength( w, n_shell), [0., self.w_max[n_shell]]) factor2 = np.log(self.t[n_shell]) / self.atom.N[n_shell] integrated_cross_sec_subshells[n_shell] *= factor2 integrated_cross_sec_subshells[n_shell] += summand1 integrated_cross_sec_subshells[n_shell] *= factor total_cross_section_bed = np.sum(integrated_cross_sec_subshells) return (total_cross_section_bed) * 1.e4
def logistic_gaussian_deriv2(m, v): if m.is_infinite or v.is_infinite: return Float('0.0') mpmath.mp.dps = 500 mmpf = m._to_mpmath(500) vmpf = v._to_mpmath(500) # The integration routine below is obtained by substituting x = atanh(t) # into the definition of logistic_gaussian'' # # def f(x): # expx = mpmath.exp(x) # one_plus_expx = 1 + expx # return mpmath.exp(-(x - mmpf) * (x - mmpf) / (2 * vmpf)) * (1 - expx) / ((1 + mpmath.exp(-x)) * one_plus_expx * one_plus_expx) # coef = 1 / mpmath.sqrt(2 * mpmath.pi * vmpf) # int = mpmath.quad(f, [-mpmath.inf, mpmath.inf]) # result = coef * int # # Such substitution makes mpmath.quad call much faster. def f(t): one_minus_t = 1 - t one_minus_t_squared = 1 - t * t sqrt_one_minus_t_squared = mpmath.sqrt(one_minus_t_squared) return mpmath.exp(-(mpmath.atanh(t) - mmpf) ** 2 / (2 * vmpf)) * (one_minus_t - sqrt_one_minus_t_squared) / ((one_minus_t_squared + sqrt_one_minus_t_squared) * (one_minus_t + sqrt_one_minus_t_squared)) coef = mpmath.mpf('0.5') / mpmath.sqrt(2 * mpmath.pi * vmpf) int, err = mpmath.quad(f, [-1, 1], error=True) result = coef * int if mpmath.mpf('1e50') * abs(err) > abs(int): print(f"Suspiciously big error when evaluating an integral for logistic_gaussian''({m}, {v}).") print(f"Integral: {int}") print(f"integral error estimate: {err}") print(f"Coefficient: {coef}") print(f"Result (Coefficient * Integral): {result}") return Float(result)
def logistic_gaussian(m, v): if m == oo: if v == oo: return oo return Float('1.0') if v == oo: return Float('0.5') mpmath.mp.dps = 500 mmpf = m._to_mpmath(500) vmpf = v._to_mpmath(500) # The integration routine below is obtained by substituting x = atanh(t) # into the definition of logistic_gaussian # # f = lambda x: mpmath.exp(-(x - mmpf) * (x - mmpf) / (2 * vmpf)) / (1 + mpmath.exp(-x)) # result = 1 / mpmath.sqrt(2 * mpmath.pi * vmpf) * mpmath.quad(f, [-mpmath.inf, mpmath.inf]) # # Such substitution makes mpmath.quad call much faster. tanhm = mpmath.tanh(mmpf) # Not really a precise threshold, but fine for our data if tanhm == mpmath.mpf('1.0'): return Float('1.0') f = lambda t: mpmath.exp(-(mpmath.atanh(t) - mmpf) ** 2 / (2 * vmpf)) / ((1 - t) * (1 + t + mpmath.sqrt(1 - t * t))) coef = 1 / mpmath.sqrt(2 * mpmath.pi * vmpf) int, err = mpmath.quad(f, [-1, 1], error=True) result = coef * int if mpmath.mpf('1e50') * abs(err) > abs(int): print(f"Suspiciously big error when evaluating an integral for logistic_gaussian({m}, {v}).") print(f"Integral: {int}") print(f"integral error estimate: {err}") print(f"Coefficient: {coef}") print(f"Result (Coefficient * Integral): {result}") return Float(result)
def __compute_surprise_weighted_by_quadrature(self, mi, pi, m, p): f = lambda i: mpmath.binomial( self.pi, i) * mpmath.binomial(self.p - self.pi, self.m - i) / \ mpmath.binomial(self.p, self.m) # +- 0.5 is because of the continuity correction return float( -mpmath.log10(mpmath.quad(f, [self.mi - 0.5, self.m + 0.5])))
def nPDF(self, x): p = np.zeros(x.size) for i, xx in enumerate(x): gil_pelaez = lambda t: mp.re( self.char_fn(t) * mp.exp(-1j * t * xx)) cutoff = self.find_cutoff(1e-30) # Instead of finding roots, break up quadrature into degrees proportional to the # expected number of oscillations of e^(i xx t) within t = [0, cutoff] nosc = cutoff / (1 / max(10, np.abs(xx - self.mean()))) # roots = self.find_roots(gil_pelaez, cutoff) # if np.abs(xx - self.mean()) < 3 * np.sqrt(self.variance()): I = mp.quad(gil_pelaez, np.linspace(0, cutoff, nosc), maxdegree=10) # I = mp.quadosc(gil_pelaez, (0, cutoff), zeros=roots) # else: # For now, do not trust any results out greater than 3sigma # I = 0 # if np.abs(xx - self.mean()) >= 2 * np.sqrt(self.variance()): # I = self.asymptotic_expansion(xx) p[i] = 1 / np.pi * float(I) print(i) return p
def Z_abc(a, b, c): if (a != 0): return (mp.quad(lambda u: (1 / (1 + u**(b / 2))), [((c / a)**(2 / b)), mp.inf]) * (a**(2 / b))) else: return (0)
def log_likelihood_marginalised_mean_flux( self, params, include_emu=True, integration_bounds='default', integration_options='gauss-legendre', verbose=True, integration_method='Quadrature'): #marginalised_axes=(0, 1) """Evaluate (Gaussian) likelihood marginalised over mean flux parameter axes: (dtau0, tau0)""" #assert len(marginalised_axes) == 2 assert self.mf_slope if integration_bounds == 'default': integration_bounds = [ list(self.param_limits[0]), list(self.param_limits[1]) ] likelihood_function = lambda dtau0, tau0: mmh.exp( self.likelihood(np.concatenate(([dtau0, tau0], params)), include_emu=include_emu)) if integration_method == 'Quadrature': integration_output = mmh.quad(likelihood_function, integration_bounds[0], integration_bounds[1], method=integration_options, error=True, verbose=verbose) elif integration_method == 'Monte-Carlo': integration_output = (self._do_Monte_Carlo_marginalisation( likelihood_function, n_samples=integration_options), ) print(integration_output) return float(mmh.log(integration_output[0]))
def mini(r): nonlocal txi, tv xi = [r] y = f(r) v = r*f(r) + mpmath.quad(f, [r, mpmath.inf]) if verbose: print('Trying r={0} (v={1})'.format(r, v), file=sys.stderr) for i in itertools.count(): xm1 = xi[i] h = v / xm1 y += h if y >= maximum or mpmath.almosteq(y, maximum, abs_eps=mpmath.mp.eps * 2**10): break # We solve for x via secant method instead of using f's inverse. x = mpmath.findroot(lambda x: f(x) - y, xm1) xi.append(x) xi.append(mpmath.mpf()) if len(xi) == nseg: if mpmath.almosteq(y, maximum, abs_eps=mpmath.mp.eps * 2**10): txi, tv = xi[::-1], v return 0 # If y > maximum, then v is too large, which means r is too far # left, so we want to return a negative value. The opposite holds # true when y < maximum. return maximum - y return len(xi) - nseg + h*mpmath.sign(len(xi) - nseg)
def _noncentral_chi_cdf(x, df, nc, dps=None): if dps is None: dps = mpmath.mp.dps x, df, nc = mpmath.mpf(x), mpmath.mpf(df), mpmath.mpf(nc) with mpmath.workdps(dps): res = mpmath.quad(lambda t: _noncentral_chi_pdf(t, df, nc), [0, x]) return res
def obj1(fn_param, m, b, x0, x1): lin_y0 = mp.mp.mpf(m) * x0 + b lin_y1 = mp.mp.mpf(m) * x1 + b lin_area = (lin_y0 + lin_y1) / 2 * (x1 - x0) fn_area = mp.quad(fn_param, [x0, x1]) return abs(lin_area - fn_area)
def test(f_test, a, b): result = mpmath.quad(f_test, (a, b)) print('Test Integrate = %.16f' % result) print('Composite Trapezoid method:') print_info(CTrapezoid, f_test, a, b, M, result) print('Composite Gauss method:') print_info(CGauss, f_test, a, b, M, result)
def least_squares(f, psi, Omega, symbolic=True): """ Given a function f(x) on an interval Omega (2-list) return the best approximation to f(x) in the space V spanned by the functions in the list psi. """ N = len(psi) - 1 A = sym.zeros(N + 1, N + 1) b = sym.zeros(N + 1, 1) x = sym.Symbol('x') print('...evaluating matrix...', end=' ') for i in range(N + 1): for j in range(i, N + 1): print('(%d,%d)' % (i, j)) integrand = psi[i] * psi[j] if symbolic: I = sym.integrate(integrand, (x, Omega[0], Omega[1])) if not symbolic or isinstance(I, sym.Integral): # Could not integrate symbolically, use numerical int. print('numerical integration of', integrand) integrand = sym.lambdify([x], integrand, 'mpmath') I = mpmath.quad(integrand, [Omega[0], Omega[1]]) A[i, j] = A[j, i] = I integrand = psi[i] * f if symbolic: I = sym.integrate(integrand, (x, Omega[0], Omega[1])) if not symbolic or isinstance(I, sym.Integral): # Could not integrate symbolically, use numerical int. print('numerical integration of', integrand) integrand = sym.lambdify([x], integrand, 'mpmath') I = mpmath.quad(integrand, [Omega[0], Omega[1]]) b[i, 0] = I print() print('A:\n', A, '\nb:\n', b) if symbolic: c = A.LUsolve(b) # symbolic solve # c is a sympy Matrix object, numbers are in c[i,0] c = [sym.simplify(c[i, 0]) for i in range(c.shape[0])] else: c = mpmath.lu_solve(A, b) # numerical solve c = [c[i, 0] for i in range(c.rows)] print('coeff:', c) u = sum(c[i] * psi[i] for i in range(len(psi))) print('approximation:', u) return u, c
def solve(f, x0=None, nseg=128, verbose=False): """Find r, v, and the x coordinates for f.""" r = x0 if r is None: if verbose: print('Calculating initial guess... ', end='', file=sys.stderr) # The area we seek is nseg equal-area rectangles surrounding f(x), not # f(x) itself, but we can get a good approximation from it. v = mpmath.quad(f, [0, mpmath.inf]) / nseg r = mpmath.findroot(lambda x: x*f(x) + mpmath.quad(f, [x, mpmath.inf]) - v, x0=1, x1=100, maxsteps=100) if verbose: print(r, file=sys.stderr) # We know that f(0) is the maximum because f must decrease monotonically. maximum = f(0) txi = [] tv = mpmath.mpf() def mini(r): nonlocal txi, tv xi = [r] y = f(r) v = r*f(r) + mpmath.quad(f, [r, mpmath.inf]) if verbose: print('Trying r={0} (v={1})'.format(r, v), file=sys.stderr) for i in itertools.count(): xm1 = xi[i] h = v / xm1 y += h if y >= maximum or mpmath.almosteq(y, maximum, abs_eps=mpmath.mp.eps * 2**10): break # We solve for x via secant method instead of using f's inverse. x = mpmath.findroot(lambda x: f(x) - y, xm1) xi.append(x) xi.append(mpmath.mpf()) if len(xi) == nseg: if mpmath.almosteq(y, maximum, abs_eps=mpmath.mp.eps * 2**10): txi, tv = xi[::-1], v return 0 # If y > maximum, then v is too large, which means r is too far # left, so we want to return a negative value. The opposite holds # true when y < maximum. return maximum - y return len(xi) - nseg + h*mpmath.sign(len(xi) - nseg) r = mpmath.findroot(mini, r) assert len(txi) == nseg if verbose: print('Done calculating r, v, x[i].', file=sys.stderr) return r, tv, txi
def rate_cov_random_switching_v2(k_matrix, alpha, rate_th, lamda_user, q_on, bw): k_mat = k_matrix.copy() num_tiers = k_mat.shape[0] #density = k_mat[:,2] #density[-1] = q_on density = np.array( k_mat[:, 2] * ([1] * (num_tiers - 1) + [q_on])) #hence last row always corresponds to small cells #print(density) power = gb.db2pow(k_mat[:, 1]) small_cell_idx = num_tiers - 1 #indicates the index of the small cell #density[small_cell_idx] = q_on # initialize the integration result matrix tier_integ_result = np.zeros(num_tiers, float) #integration results of each tier area_tiers = np.zeros(num_tiers, float) #area of the tiers threshold_tier = np.zeros(num_tiers, float) #threshold of the tiers N_k = np.zeros(num_tiers, float) #number of users in each tier first_exp_term = np.zeros(num_tiers, float) #first exponential term in integral second_exp_term = np.zeros(num_tiers, float) #second exponential term in integral third_exp_term = np.zeros(num_tiers, float) #third exponential term in integral for i in range(num_tiers): area_tiers[i] = A_k(density, power, alpha, i) #N_k[i] = 0 if density[i]==0 else 1.28*lamda_user*area_tiers[i]/density[i] N_k[i] = 0 if density[ i] == 0 else 1 + 1.28 * lamda_user * area_tiers[i] / density[i] threshold_tier[i] = mp.inf if ( bw == 0) else 2**(rate_th * N_k[i] / bw) - 1 first_exp_term[i] = threshold_tier[i] * 1 / power[i] third_exp_term[i] = mp.pi * sum(density * (power / power[i])**(2 / alpha)) Z_term = 0 if (threshold_tier[i] == 0) else threshold_tier[i]**( 2 / alpha) * mp.quad(lambda u: 1 / (1 + u**(alpha / 2)), [(threshold_tier[i])**(-2 / alpha), mp.inf]) second_exp_term[i] = third_exp_term[i] * Z_term for k in range(num_tiers): tier_integ_result[k] = mp.quad( lambda y: y * mp.exp(-first_exp_term[k] * y**alpha) * mp.exp( -second_exp_term[k] * y**2) * mp.exp(-third_exp_term[k] * y**2 ), [0, mp.inf]) rate_cov_prob = 2 * mp.pi * sum(density * tier_integ_result) return (rate_cov_prob)
def getIntegratedFisher(self, K, FisherPerMode, kmin, kmax, V, apply_filter = False, scipy_mode = True, interp_mode = 'cubic'): """Integrate per-mode Fisher matrix element in k, to get full Fisher matrix element. Given arrays of k values and corresponding Fisher matrix elements F(k), compute \frac{V}{(2\pi)^2} \int_{kmin}^{kmax} dk k^2 F(k) , where V is the survey volume. The function actually first interpolates over the discrete supplied values of FisherPerMode, and then integrates the interpolating function between kmin and kmax using scipy.integrate.quad. Parameters ---------- K : ndarray Array of k values. FisherPerMode : array Array of Fisher element values corresponding to K. kmin : float Lower limit of k integral. kmax : float Upper limit of k integral. V : float Survey volume. Returns ------- result : float Result of integral. """ if (kmin<np.min(K)) or (kmax>np.max(K)): print('Kmin(Kmax) should be higher(lower) than the minimum(maximum) of the K avaliable!') print('\tMin, max K available: %f %f' % (np.min(K),np.max(K))) print('\tInput Kmin, Kmax: %f %f' % (kmin,kmax)) return 0 else: if apply_filter: lenK = len(K) window_length = 7 #2*int(lenK/10)+1 #make sure it is an odd number FisherPerMode = savgol_filter(FisherPerMode, window_length, 3) #, mode = 'nearest') mus = np.linspace(-1, 1, len(K)) function = scipy.interpolate.interp2d(K, mus, FisherPerMode, interp_mode, fill_value = 0., bounds_error = 0.) f = lambda x1,x2 : x1**2.*(si.dfitpack.bispeu(function.tck[0], function.tck[1], function.tck[2], function.tck[3], function.tck[4], x1, x2)[0])[0] if scipy_mode: result = scipy.integrate.dblquad(lambda y, x: function(x, y)*x**2., kmin, kmax, lambda x: -1., lambda x: 1., epsrel = 1e-15) else: ## A bit slow but it is worth it for numerical precision #def f(x, y): # x, y = float(x), float(y) # z = function(x, y)*x**2. # z = z[0] # return mpmath.mpf(1)*z resultmp = mpmath.quad(f, [kmin, kmax], [-1, 1]) result = [resultmp] result = result[0]*(V)/(2.*np.pi)**2. return result
def compute_log_moment(sample_ration, variance, iterataions, order): mu0 = lambda y: pdf_gauss_mp(y, sigma=variance, mean=mp.mpf(0)) mu1 = lambda y: pdf_gauss_mp(y, sigma=variance, mean=mp.mpf(1)) mu = lambda y: (1 - sample_ration) * mu0(y) + sample_ration * mu1(y) a_lambda_fn = lambda z: mu(z) * (mu(z) / mu0(z)) ** order integral, _ = mp.quad(a_lambda_fn, [-mp.inf, mp.inf], error=True) moment = _to_np_float64(integral) return np.log(moment)*iterataions
def norm_vawe_function(self, ind_layer_energy): C_norm = (mp.sqrt( mp.quad( lambda t: (self.vawe_function(t, self.roots[ind_layer_energy]))**2, [min(self.structure_width_vector), self.x_max])).real) #print(C_norm) return self.vawe_layer(ind_layer_energy) / C_norm
def Imn_func(mv,nv,kv,Rv,alphav): ''' eqn. 12.106 The 'gauss-legendre' quadrature method is used here as it provides more accurate output, even with increasing m&n indices. ''' return mpmath.quad(lambda thetav: Imn_term_func(mv,nv,kv,Rv,alphav, thetav), (0,alphav), method='gauss-legendre')
def electronOccupationState(eigenvalues, fermiEnergy): """ return electron occupation state for each subband meaning just number of suband value sets """ nk = [] for eigenvalue in eigenvalues: result = temp1*mpmath.quad(lambda x: 1/(1 + mpmath.exp((x-fermiEnergy)/temp2)), [eigenvalue, 2*eigenvalue + fermiEnergy]) nk.append(result) nk = np.array(nk) return nk
def getIntegratedFisher(self, K, FisherPerMode, kmin, kmax, V, apply_filter = False, scipy_mode = False, interp_mode = 'cubic'): """Integrate per-mode Fisher matrix element in k, to get full Fisher matrix element. Given arrays of k values and corresponding Fisher matrix elements F(k), compute \frac{V}{(2\pi)^2} \int_{kmin}^{kmax} dk k^2 F(k) , where V is the survey volume. The function actually first interpolates over the discrete supplied values of FisherPerMode, and then integrates the interpolating function between kmin and kmax using scipy.integrate.quad. Parameters ---------- K : ndarray Array of k values. FisherPerMode : array Array of Fisher element values corresponding to K. kmin : float Lower limit of k integral. kmax : float Upper limit of k integral. V : float Survey volume. Returns ------- result : float Result of integral. """ if (kmin<np.min(K)) or (kmax>np.max(K)): print('Kmin(Kmax) should be higher(lower) than the minimum(maximum) of the K avaliable!') print('\tMin, max K available: %f %f' % (np.min(K),np.max(K))) print('\tInput Kmin, Kmax: %f %f' % (kmin,kmax)) return 0 else: if apply_filter: lenK = len(K) window_length = 7 #2*int(lenK/10)+1 #make sure it is an odd number FisherPerMode = savgol_filter(FisherPerMode, window_length, 3) #, mode = 'nearest') function = scipy.interpolate.interp1d(K, FisherPerMode, interp_mode) if scipy_mode: result = scipy.integrate.quad(lambda x: function(x)*x**2., kmin, kmax, epsrel = 1e-15) else: ## A bit slow but it is worth it for numerical precision def f(x): x = float(x) y = function(x)*x**2. return mpmath.mpf(1)*y resultmp = mpmath.quad(f, [kmin, kmax]) result = [resultmp] result = result[0]*V/(4.*np.pi**2.) return result
def E_C_pareto_k_c_approx(l, a, d, k, c, w_cancel=True): q = 0 if d <= l else 1 - (l/d)**a def tail(x): if x <= l: return 1 else: return (l/x)**a def tail_delayed(x): return (d/(x+d) )**a def proxy(x): return tail(x)*tail(x+d)/tail(d) def proxy_u(x): return tail(x)**2 def proxy_l(x): return tail(x+d)**2/tail(d)**2 if c == 1: if d <= l: E_X__X_leq_d = 0 # E_Y = (a*l + d)/2/(a-1) # E_Y = l-d + l**a*(l**(1-a) - (l+d)**(1-a) )/(a-1) \ # + l**(2*a) * (l*(l+d))**(a-1/2) / (2*a-1) # E_Y = l-d + l**a*mpmath.quad(lambda x: (x+d)**(-a), [l-d, l] ) \ # + l**(2*a)*mpmath.quad(lambda x: x**(-a) * (x+d)**(-a), [l, mpmath.inf] ) # E_Y = l-d + l**a*mpmath.quad(lambda x: (x+d)**(-a), [l-d, l] ) \ # + (l**(2*a)*mpmath.quad(lambda x: x**(-a) * x**(-a), [l, mpmath.inf] ) \ # + l**(2*a)*mpmath.quad(lambda x: (x+d)**(-a) * (x+d)**(-a), [l, mpmath.inf] ) )/2 # E_Y = (mpmath.quad(proxy_u, [0, mpmath.inf] ) + mpmath.quad(proxy_l, [0, mpmath.inf] ) )/2 E_Y = mpmath.quad(tail_delayed, [0, mpmath.inf] ) return k*(q*E_X__X_leq_d + (1-q)*(2*E_Y + d) ) else: E_X__X_leq_d = l*a/(a-1)*(1 - (l/d)**(a-1) )/(1 - (l/d)**a) # E_Y = (a*l + d)/2/(a-1) # E_Y = mpmath.quad(proxy, [0, mpmath.inf] ) # E_Y = d**a*mpmath.quad(lambda x: (x+d)**(-a), [0, l] ) \ # + (l*d)**a*mpmath.quad(lambda x: x**(-a) * (x+d)**(-a), [l, mpmath.inf] ) # E_Y = d**a*mpmath.quad(lambda x: (x+d)**(-a), [0, l] ) \ # + ((l*d)**a*mpmath.quad(lambda x: x**(-a) * x**(-a), [l, mpmath.inf] ) # + (l*d)**a*mpmath.quad(lambda x: (x+d)**(-a) * (x+d)**(-a), [l, mpmath.inf] ) )/2 # E_Y = (mpmath.quad(proxy_u, [0, mpmath.inf] ) + mpmath.quad(proxy_l, [0, mpmath.inf] ) )/2 E_Y = mpmath.quad(tail, [0, mpmath.inf] ) return k*(q*E_X__X_leq_d + (1-q)*(2*E_Y + d) )
def za_l(self, wc, l, n, t, tc): """ Longitudinal impedance in unit of Ohms. wc: w/w_pc, where w_pc is core electron plasma frequency. tc: core electron temperature. """ limits = self.long_interval(wc, n, t) #print(limits) result = mp.quad(lambda z: self.za_l_integrand(z, wc, l, n, t), limits) return result * self.z_unit * mp.mpc(0, 1)/ mp.sqrt(tc)
def electronOccupationState(eigenvalues, fermiEnergy): print 'Finding n_k...' nk = [] for i in range(0,len(eigenvalues)): ek = float(eigenvalues[i]) #result = nk_factor *( limit(x-ln(1+exp(x-fermiEnergy)/pc.k/300),x,oo) - (ek - ln(1+exp(ek-fermiEnergy)/pc.k/300))) result = mpmath.quad(lambda x: nk_factor/(1+mpmath.exp((x-fermiEnergy)/T/K)), [ek, 2*ek + fermiEnergy]) print float(result) nk.append(float(result)) return nk
def za(self, wrel, lc, n, t, k, Tc): """ antenna impedance """ wc = wrel * mp.sqrt(1+n) coeff = 4*mp.mpc(0,1) / mp.pi**2 / permittivity coeff *= mp.sqrt(emass/2/boltzmann/Tc) int_range = MaxKappa.int_interval(wrel, n, t, k) integral = mp.quad(lambda zc: self.za_integrand(zc, wc, lc, n, t, k), int_range, method='tanh-sinh') return coeff * integral
def E_T_exp_k_n(mu, d, k, n): if d == 0: return 1/mu*(H(n) - H(n-k) ) q = 1 - math.exp(-mu*d) E_H_n_r = 0 for r in range(k+1): E_H_n_r += H(n-r) * binom(k,r) * q**r * (1-q)**(k-r) return d - mpmath.quad(lambda x: (1-math.exp(-mu*x) )**k, [0, d] ) + \ 1/mu*(E_H_n_r - H(n-k) )
def unsigned_area(self) -> mp.mpf: """Calculate the geometric area bounded by x_range. Returns ------- unsigned_area : mp.mpf The unsigned area of the analyzed function relative to the x-axis. """ return mp.quad(lambda x_val: abs(self.func_real(x_val)), self.x_range)
def bimax(self, wrel, l, n, t, tc): """ electron noise. w: f/f_p, where f_p is the total plasma frequency. """ wc = wrel * mp.sqrt(1+n) limits = self.long_interval(wc, n, t) #print(limits) result = mp.quad(lambda z: self.bimax_integrand(z, wc, l, n, t), limits) return result * self.v_unit * mp.sqrt(tc)
def maxkappa(wrel, lc, n, t, k, Tc): """ integral in electron noise calculation. wrel:= w/w_ptot, where w_ptot is the total electron plasma frequency Tc:= core electron temperature """ wc = wrel * mp.sqrt(1+n) int_range = MaxKappa.int_interval(wrel, n, t, k) coeff = 16 * emass/mp.pi**(3/2) /permittivity /wc**2 * mp.sqrt(2*boltzmann*Tc/emass) integral = mp.quad(lambda z: MaxKappa.maxkappa_integrand(z, wc, lc, n, t, k), int_range) return coeff * integral
def E_C_pareto_k_c(loc, a, d, k, c, w_cancel=True): if w_cancel and d == 0: # log(WARNING, "loc= {}, a= {}, d= {}, k= {}, c= {}".format(loc, a, d, k, c) ) return k*(c+1) * a*(c+1)*loc/(a*(c+1)-1) q = 0 if d <= loc else 1 - (loc/d)**a if not w_cancel: return (c*(1-q)+1)*(a*loc/(a-1) ) else: def tail(x): if x <= loc: return 1 else: return (loc/x)**a def proxy(x): return tail(x)*tail(x+d)/tail(d) if c == 1: if d <= loc: E_X__X_leq_d = 0 E_Y = mpmath.quad(proxy, [0, mpmath.inf] ) return k*(q*E_X__X_leq_d + (1-q)*(2*E_Y + d) ) else: E_X__X_leq_d = loc*a/(a-1)*(1 - (loc/d)**(a-1) )/(1 - (loc/d)**a) E_Y = mpmath.quad(proxy, [0, mpmath.inf] ) return k*(q*E_X__X_leq_d + (1-q)*(2*E_Y + d) )
def d_E_T_shiftedexp_k_n_dk(D, mu, d, k, n): q_ = 1 - math.exp(-mu*(d+D/k) ) # return D/k**2 * (-2 + q_**k - k*(1-q_)/(n-k*q_) ) # Beta_q_k_0 = mpmath.quad(lambda x: x**(k-1) * 1/(1-x), [0, q_] ) # rhs = mu*D/k**2 * q_**k - k*Beta_q_k_0 + (mu*D/k*(1-q_) - q_)/(n-k*q_) + 1/(n-k) # return -2*D/k**2 + 1/mu*rhs Beta_q_ = mpmath.quad(lambda x: x**k * 1/(1-x), [0, q_] ) rhs = (mu*D*(k+1)/k**2 * (1-q_)/q_ - math.log(q_) )*Beta_q_ + (mu*D/k*(1-q_) - q_)/(n-k*q_) + 1/(n-k) r = -2*D/k**2 + 1/mu*rhs print("k= {}, r= {}".format(k, r) ) return r
def rescale_profile_by_mass(profile, param, mass, radius): """ Rescale a density profile by a total mass within some radius. Parameters ---------- profile : Formula1D Formula that is a radial density profile. param : string The density-valued parameter that needs to be rescaled. mass : YTQuantity The mass of the object. radius : YTQuantity The radius that the *mass* corresponds to. Examples -------- >>> import yt.units as u >>> import numpy as np >>> gas_density = AM06_density_profile() >>> a = 600.0*u.kpc >>> a_c = 60.0*u.kpc >>> c = 0.17 >>> alpha = -2.0 >>> beta = -3.0 >>> M0 = 1.0e14*u.Msun >>> # Don't set the density parameter rho_0! >>> gas_density.set_param_values(a=a, a_c=a_c, c=c, ... alpha=alpha, beta=beta) >>> rescale_profile_by_mass(gas_density, "rho_0", M0, np.inf*u.kpc) """ R = float(in_cgs(radius).value) M = float(in_cgs(mass).value) rho = profile.copy() values = {} for n, p in profile.param_values.items(): if n == param: # Set the density parameter to change to unity values[n] = 1.0 elif isinstance(p, float): values[n] = p else: values[n] = float(in_cgs(p).value) rho.set_param_values(**values) mass_int = lambda r: rho(r)*r*r scale = float(M/(4.*np.pi*quad(mass_int, [0, R]))) u = get_units(mass/radius**3) quan = check_type(mass)(scale, "g/cm**3") profile.param_values[param] = in_units(quan, u)
def calc_term_noonan(p, nudist, n, dps=None): if dps: mp.dps = dps coeffs = nudist[::-1].tolist() def calc_term(z, nudist, p, n): ans = mp.polyval(coeffs, z) ans = z - p * ans ans = (1.0 - p) / ans return mp.power(ans, n) ans2 = mp.quad(lambda z: calc_term(z, nudist, p, n), [1, mp.j, -1, -mp.j, 1]) ans2 /= 2 * mp.pi * n return ans2.imag
def E_C_G_1red(task_t_rv, d, k, w_cancel=True): mu = task_t_rv.mean() if w_cancel: def Pr_T_g_t(t): t_ = max(d, t) return (t <= d)*(task_t_rv.cdf(d)**k - task_t_rv.cdf(t)**k) \ + 1 - task_t_rv.cdf(t_)**(k-1) * (k*task_t_rv.cdf(t-d)*(1 - task_t_rv.cdf(t_) ) + task_t_rv.cdf(t_) ) def E_X_k__k_minus_1(k_): return k_*mu - mpmath.quad(lambda x: x * k_*task_t_rv.cdf(x)**(k_-1)*task_t_rv.pdf(x), [0, mpmath.inf] ) # E_X_k_k = mpmath.quad(lambda x: x * k*task_t_rv.cdf(x)**(k-1)*task_t_rv.pdf(x), [0, mpmath.inf] ) E_T = E_T_G_1red(task_t_rv, d, k) # return k*mu + 2*E_T_G_1red(task_t_rv, d, k) - E_X_k_k - mpmath.quad(Pr_T_g_t, [0, d] ) Pr_X_k_k__l__d_plus_X = mpmath.quad(lambda x: task_t_rv.cdf(d+x)**k*task_t_rv.pdf(x), [0, mpmath.inf] ) Pr_X_k_k_m_1__l__d_plus_X = mpmath.quad(lambda x: (k*task_t_rv.cdf(d+x)**(k-1)*(1-task_t_rv.cdf(d+x)) + task_t_rv.cdf(d+x)**k)*task_t_rv.pdf(x), [0, mpmath.inf] ) Pr_T_g_d = 1 - task_t_rv.cdf(d)**k sum_ = E_X_k__k_minus_1(k) + E_T \ + mpmath.quad(Pr_T_g_t, [d, mpmath.inf] ) # - max(E_T-d-mu, 0)*(1-Pr_X_k_k__l__d_plus_X) return min(sum_, E_X_k__k_minus_1(k+1) + E_T_G_1red(task_t_rv, 0, k) ) else: return k*mu + mu*(1 - task_t_rv.cdf(d)**k)
def main(): func = lambda x: mpmath.exp(mpmath.power(x, 2)) precision = sys.argv[1].split('**') precision = math.pow(int(precision[0]), int(precision[1])) x = mpmath.mpf(float(sys.argv[2])) print "expected value = %f" % mpmath.quad(func, [0, x]) print "precision = %f" % precision print "x = %f" % x print "max Taylor degree to try = %s" % sys.argv[3] print "" upperbound = int(sys.argv[3]) lowerbound = 0 lowestn = 0 # find the degree logarithmically, this is usually faster than trying 0..n while lowerbound < upperbound: n = (lowerbound + upperbound) / 2 # estimate the remainder diff = mpmath.diff(func, x, n) rn = diff / mpmath.factorial(n + 1) rn = rn * mpmath.power(x, n + 1) # is it good enough? if rn < precision: upperbound = n lowestn = n else: lowerbound = n + 1 if lowestn: print "lowest Taylor degree needed = %d" % lowestn coefficients = [] # find the coefficients of our Taylor polynomial for k in reversed(range(lowestn + 1)): if k > 0: coefficients.append(mpmath.diff(func, 0, k - 1) / mpmath.factorial(k)) # compute the value of the polynomial (add 0 for the free variable, the value of the indefinite integral at 0) p = mpmath.polyval(coefficients + [0], x) print "computed value = %f" % p else: print "max n is too low"
def test_cf(dist, support_lower_limit, support_upper_limit): pdf = density(dist) t = Symbol('t') x = Symbol('x') # first function is the hardcoded CF of the distribution cf1 = lambdify([t], characteristic_function(dist)(t), 'mpmath') # second function is the Fourier transform of the density function f = lambdify([x, t], pdf(x)*exp(I*x*t), 'mpmath') cf2 = lambda t: mpmath.quad(lambda x: f(x, t), [support_lower_limit, support_upper_limit], maxdegree=10) # compare the two functions at various points for test_point in [2, 5, 8, 11]: n1 = cf1(test_point) n2 = cf2(test_point) assert abs(re(n1) - re(n2)) < 1e-12 assert abs(im(n1) - im(n2)) < 1e-12
def cdf_of_gamma_difference(z, alpha_1, beta_1, alpha_2, beta_2): ''' The cumulative distribution function of Gamma_1 - Gamma_2 using mpmath.quad integrating pdf directly. Args: z: A float. x1 - x2. alpha_1: An int. Alpha of Gamma1. beta_1: An int. Beta of Gamma1. alpha_2: An int. Alpha of Gamma2. beta_2: An int. Beta of Gamma2. Returns: The cumulative probability of Gamma1- Gamma2 at z. ''' center = float(alpha_1 ) / float(beta_1) - float(alpha_2) / float(beta_2) standard_err = (float(alpha_1 ) / beta_1 ** 2 + float(alpha_2 ) / beta_2 ** 2 ) ** 0.5 if z > center + 30 * standard_err: z = center + 30 * standard_err return mpmath.quad(lambda x: pdf_of_gamma_difference(x, alpha_1, beta_1, alpha_2, beta_2), [center - 200 * standard_err, z])
def arc_length(self, start, stop, q_type = None): """ Parameters: --------- q_type: string 'exact', 'integral', 'numeric' start, stop: numeric/str These are the limits of integration """ u = self.u if q_type is None: q_type = self.q_type if q_type == 'integral': return sym.Integral(self.ds, (u, start, stop)) elif q_type == 'exact': return self.Ids.subs(u, stop) - self.Ids.subs(u, start) else: f = make_func(str(self.ds), func_params=(self.ind_var), func_type='numpy') value = mp.quad(f, [start, stop]) return value
from __future__ import print_function import mpmath as mp from math import * def func( t, r ): return exp( -r**2 * t **2) r = 10.0 f = lambda t : func(t, r) res1 = mp.quad( f, (0,mp.inf) ) * 2.0 / sqrt(pi) print('res1 = %f' % res1)
def calc_F_v1( t, ibf1, ibf2 ): f = lambda x: exp(-t**2*( x - xgrid[ibf1] )**2) * eval_bfs(x, ibf2, xgrid) #print('mpmath v1 = %18.10f' % mp.quad( eval_F, [-mp.inf,mp.inf] ) ) print('mpmath v2 = %18.10f' % mp.quad( f, [-mp.inf,mp.inf] ) )
def calc_F_v2( t, ibf1, ibf2 ): # integrand beta = pi/(h*t) xbar = xgrid[ibf1] - xgrid[ibf2] f = lambda x : exp(-x**2) * sin(beta*(x + t*xbar))/(x + t*xbar) * sqrt(h)/pi print('mpmath v3 = %18.10f' % mp.quad( f, [-mp.inf,mp.inf] ) )
def _integral_inf_mp(self, fn): integral, _ = mp.quad( fn, [-mp.inf, mp.inf], error=True, maxdegree=7) # maxdegree = 6 is not enough return integral
def E(self): def mom_1(x): return x * self.pdf(x) return float(mpmath.quad(mom_1, [self.a, self.b]))
def cdf(self, x, n): def pdf_n(x): return self.pdf(x, n) cdf = mpmath.quad(pdf_n, [1, x]) return float(cdf)
def _integral_bounded_mp(self, fn, lb, ub): integral, _ = mp.quad(fn, [lb, ub], error=True) return integral