def b_mat(ind_mat): r""" Calculates the B coefficients from [1]_ Eq. 27. Parameters ---------- index_matrix : array, shape (N,3) ordering of the basis in x, y, z Returns ------- B : array, shape (N,) B coefficients for the basis References ---------- .. [1] Ozarslan E. et. al, "Mean apparent propagator (MAP) MRI: A novel diffusion imaging method for mapping tissue microstructure", NeuroImage, 2013. """ B = np.zeros(ind_mat.shape[0]) for i in range(ind_mat.shape[0]): n1, n2, n3 = ind_mat[i] K = int(not(n1 % 2) and not(n2 % 2) and not(n3 % 2)) B[i] = K * np.sqrt(factorial(n1) * factorial(n2) * factorial(n3) ) / (factorial2(n1) * factorial2(n2) * factorial2(n3)) return B
def radon_n_bspline_general( y , theta , m , n ): exponent = 2*m - n + 1 y_plus = positive_power( exponent ) ## Calculate m+1 fold derivative (analytically) deriv_positive_power = scalar_product( ( misc.factorial( exponent ) / \ misc.factorial( exponent - (m +1) ) ) , positive_power( m - n ) ) if theta == 0.0 or theta == np.pi/2.0 or theta == np.pi: y_plus = deriv_positive_power ## Consider special case of theta = 0 , pi if np.abs( theta - np.pi/2.0 ) > eps: for i in range( m + 1 ): y_plus = finite_difference( y_plus, np.cos(theta) ) ## Consider special case of theta = pi/2 if np.abs( theta ) > eps and np.abs( theta - np.pi ) > eps: for i in range( m + 1 ): y_plus = finite_difference( y_plus , np.sin(theta) ) return y_plus(y)/float( misc.factorial( exponent ) )
def normal_reference_constant(self): """ Constant used for silverman normal reference asymtotic bandwidth calculation. C = 2((pi^(1/2)*(nu!)^3 R(k))/(2nu(2nu)!kap_nu(k)^2))^(1/(2nu+1)) nu = kernel order kap_nu = nu'th moment of kernel R = kernel roughness (square of L^2 norm) Note: L2Norm property returns square of norm. """ nu = self._order if not nu == 2: msg = "Only implemented for second order kernels" raise NotImplementedError(msg) if self._normal_reference_constant is None: C = np.pi ** (0.5) * factorial(nu) ** 3 * self.L2Norm C /= 2 * nu * factorial(2 * nu) * self.moments(nu) ** 2 C = 2 * C ** (1.0 / (2 * nu + 1)) self._normal_reference_constant = C return self._normal_reference_constant
def update_rho(self, rho): """ calculate probability distribution for quadrature measurement outcomes given a two-mode density matrix """ X1, X2 = np.meshgrid(self.xvecs[0], self.xvecs[1]) p = np.zeros((len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex) N = rho.dims[0][0] M1 = np.zeros((N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex) M2 = np.zeros((N, N, len(self.xvecs[0]), len(self.xvecs[1])), dtype=complex) for m in range(N): for n in range(N): M1[m,n] = exp(-1j * self.theta1 * (m - n)) / \ sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \ exp(-X1 ** 2) * np.polyval(hermite(m), X1) * np.polyval(hermite(n), X1) M2[m,n] = exp(-1j * self.theta2 * (m - n)) / \ sqrt(pi * 2 ** (m + n) * factorial(n) * factorial(m)) * \ exp(-X2 ** 2) * np.polyval(hermite(m), X2) * np.polyval(hermite(n), X2) for n1 in range(N): for n2 in range(N): i = state_number_index([N, N], [n1, n2]) for p1 in range(N): for p2 in range(N): j = state_number_index([N, N], [p1, p2]) p += M1[n1, p1] * M2[n2, p2] * rho.data[i, j] self.data = p
def K(dim=4, dfn=7, dfd=np.inf): r""" Determine the polynomial K in: Worsley, K.J. (1994). 'Local maxima and the expected Euler characteristic of excursion sets of \chi^2, F and t fields.' Advances in Applied Probability, 26:13-42. If dfd=inf, return the limiting polynomial. """ def lbinom(n, j): return gammaln(n+1) - gammaln(j+1) - gammaln(n-j+1) m = dfd n = dfn D = dim k = np.arange(D) coef = 0 for j in range(int(np.floor((D-1)/2.)+1)): if np.isfinite(m): t = (gammaln((m+n-D)/2.+j) - gammaln(j+1) - gammaln((m+n-D)/2.)) t += lbinom(m-1, k-j) - k * np.log(m) else: _t = np.power(2., -j) / (factorial(k-j) * factorial(j)) t = np.log(_t) t[np.isinf(_t)] = -np.inf t += lbinom(n-1, D-1-j-k) coef += (-1)**(D-1) * factorial(D-1) * np.exp(t) * np.power(-1.*n, k) return np.poly1d(coef[::-1])
def beta(p,a): """Returns the pth coefficient beta. inputs: p -- (int) pth coefficient a -- (float) uncorrected fractional distance of MC output: beta_p -- pth beta coefficient for given vel. or accel. """ beta_p = a ** (p+1) / factorial(p+1) if p > 0: for q in range(p): if a >= 0: beta_p -= beta(q,a) / factorial(p + 1 - q) else: # a < 0 beta_p -= (-1) ** (p+q) * beta(q,a) / factorial(p + 1 - q) return beta_p
def shore_odf_matrix(radial_order, mu, smoment, vertices): """ Eq. 33 (choose ux=uy=uz) """ ind_mat = shore_index_matrix(radial_order) n_vert = vertices.shape[0] n_elem = ind_mat.shape[0] odf_mat = np.zeros((n_vert, n_elem)) rho = mu for i in range(n_vert): vx, vy, vz = vertices[i] for j in range(n_elem): n1, n2, n3 = ind_mat[j] f = np.sqrt(factorial(n1) * factorial(n2) * factorial(n3)) k = mu ** (smoment) / np.sqrt(2 ** (2 - smoment) * np.pi ** 3) odf_mat[i, j] = k * f * _odf_cfunc(n1, n2, n3, vx, vy, vz, smoment) return odf_mat
def arcsin(n,x): #construct a backwards order of your n's integers = np.arange(n,-1,-1, dtype=np.float64) coeff = factorial(integers*2)/((2*integers+1)*(factorial(integers)**2)*(4**integers)) allcoeff = np.zeros(2*n+2) allcoeff[::2]=coeff[:] return np.polyval(allcoeff,x)
def eval_expx(lamb,i,j): '''get the i,j element of exp(lamb(a+a^dag))''' res=0. r=min(i,j)+1 for m in xrange(r): res+=lamb**(i+j-2*m)*sqrt(factorial(j)*factorial(i))/factorial(m)/factorial(i-m)/factorial(j-m) return exp(lamb**2/2)*res #it is a pending issue whether '-' sign make sense here.
def _sch_lpmv(n, x): ''' Outputs array of Schmidt Seminormalized Associated Legendre Functions S_{n}^{m} for m<=n. Parameters ---------- n : int Degree of polynomial. x : float Point at which to evaluate Returns ------- array of values for Legendre functions. ''' from scipy.special import lpmv n = int(n) sch = np.array([1.0]) sch2 = np.array([(-1.0) ** m * np.sqrt( (2.0 * factorial(n - m)) / factorial(n + m)) for m in range(1, n + 1)]) sch = np.append(sch, sch2) if isinstance(x, float) or len(x) == 1: leg = lpmv(np.arange(0, n + 1), n, x) return np.array([sch * leg]).T else: for j in range(0, len(x)): leg = lpmv(range(0, n + 1), n, x[j]) if j == 0: out = np.array([sch * leg]).T else: out = np.append(out, np.array([sch * leg]).T, axis=1) return out
def cumulant_from_moments(momt, n): """Compute n-th cumulant given moments. Parameters ---------- momt: array_like `momt[j]` contains `(j+1)`-th moment. These can be raw moments around zero, or central moments (in which case, `momt[0]` == 0). n: integer which cumulant to calculate (must be >1) Returns ------- kappa: float n-th cumulant. """ if n < 1: raise ValueError("Expected a positive integer. Got %s instead." % n) if len(momt) < n: raise ValueError("%s-th cumulant requires %s moments, " "only got %s." % (n, n, len(momt))) kappa = 0. for p in _faa_di_bruno_partitions(n): r = sum(k for (m, k) in p) term = (-1)**(r - 1) * factorial(r - 1) for (m, k) in p: term *= np.power(momt[m - 1] / factorial(m), k) / factorial(k) kappa += term kappa *= factorial(n) return kappa
def get_n_combos(n,k): """ Returns the number of combinations of n choose k. Uses Stirling's approximation when numbers are very large. """ result = None try: fac_n = factorial(n) fac_k = factorial(k) fac_nk = factorial(n-k) summ = fac_n + fac_k + fac_nk if summ == np.inf or summ != summ: raise ValueError("Values too large. Using Stirling's approximation") result = fac_n/fac_k result /= fac_nk except: # Catch all large number exceptions. pass if not result or result == np.inf or result != result: # No result yet. if n == k or k == 0: result = 1 else: x = stirling(n) - stirling(k) - stirling(n-k) # Use Stirling's approx. result = np.exp(x) return result
def wdm_linearity(self, domain): # Calculate dispersive terms: if self.beta is None: self.factor = (0.0, 0.0) else: if self.centre_omega is None: self.Domega = (domain.omega - domain.centre_omega, domain.omega - domain.centre_omega) else: self.Domega = (domain.omega - self.centre_omega[0], domain.omega - self.centre_omega[1]) terms = [0.0, 0.0] for n, beta in enumerate(self.beta[0]): terms[0] += beta * np.power(self.Domega[0], n) / factorial(n) for n, beta in enumerate(self.beta[1]): terms[1] += beta * np.power(self.Domega[1], n) / factorial(n) self.factor = (1j * fftshift(terms[0]), 1j * fftshift(terms[1])) # Include attenuation terms if available: if self.alpha is None: return self.factor else: self.factor[0] -= 0.5 * self.alpha[0] self.factor[1] -= 0.5 * self.alpha[1] return factor
def update(self, rho): """ Calculate the probability function for the given state of an harmonic oscillator (as density matrix) """ if isket(rho): rho = ket2dm(rho) self.data = np.zeros(len(self.xvecs[0]), dtype=complex) M, N = rho.shape for m in range(M): k_m = pow(self.omega / pi, 0.25) / \ sqrt(2 ** m * factorial(m)) * \ exp(-self.xvecs[0] ** 2 / 2.0) * \ np.polyval(hermite(m), self.xvecs[0]) for n in range(N): k_n = pow(self.omega / pi, 0.25) / \ sqrt(2 ** n * factorial(n)) * \ exp(-self.xvecs[0] ** 2 / 2.0) * \ np.polyval(hermite(n), self.xvecs[0]) self.data += np.conjugate(k_n) * k_m * rho.data[m, n]
def GL_mode(u,p): r = len(u[:,0]) z = len(u[0,:]) L = zeros((r,z)) for i in range(p+1): L += float(factorial(p))*(-u)**i/( float(factorial(p - i))*(float(factorial(i)))**2. ) return L
def time(self, t, s=1.0): """ Complex Paul wavelet, centred at zero. Parameters ---------- t : float Time. If `s` is not specified, i.e. set to 1, this can be used as the non-dimensional time t/s. s : float Scaling factor. Default is 1. Returns ------- out : complex Value of the Paul wavelet at the given time The Paul wavelet is defined (in time) as:: (2 ** m * i ** m * m!) / (pi * (2 * m)!) \ * (1 - i * t / s) ** -(m + 1) """ m = self.m x = t / s const = (2 ** m * 1j ** m * factorial(m)) \ / (np.pi * factorial(2 * m)) ** .5 functional_form = (1 - 1j * x) ** -(m + 1) output = const * functional_form return output
def B(l,ll,r,rr,i,l1,l2,Ra,Rb,Rp,g1,l3,l4,Rc,Rd,Rq,g2): """ Expansion coefficient B. Source: Handbook of Computational Chemistry David Cook Oxford University Press 1998 """ b = 1 b *= (-1)**(l) * theta(l,l1,l2,Rp-Ra,Rp-Rb,r,g1) b *= theta(ll,l3,l4,Rq-Rc,Rq-Rd,rr,g2) b *= (-1)**i * (2*delta)**(2*(r+rr)) b *= misc.factorial(l + ll - 2*r - 2*rr,exact=True) b *= delta**i * (Rp-Rq)**(l+ll-2*(r+rr+i)) tmp = 1 tmp *= (4*delta)**(l+ll) * misc.factorial(i,exact=True) tmp *= misc.factorial(l+ll-2*(r+rr+i),exact=True) b /= tmp return b
def series_problem_a(): c = np.arange(70, -1, -1) # original values for n c = factorial(2*c) / ((2*c+1) * factorial(c)**2 * 4**c) #series coeff's p = np.zeros(2*c.size) # make space for skipped zero-terms p[::2] = c # set nonzero polynomial terms to the series coeff's P = np.poly1d(p) # make a polynomial out of it return 6 * P(.5) #return pi (since pi/6 = arcsin(1/2))
def arcsin_approx(): n = 70 s = 1. * np.arange(70,-1,-1) r = factorial(2*s)/((2*s+1)*(factorial(s)**2)*(4**s)) # computes coefficients q = np.zeros(142) q[0::2] = r P = np.poly1d(q) return P(1/math.sqrt(2))*4
def likelihood(theta, n, x): """ :param theta: probability of infection :param n: n testing :param x: x positive :return likelihood probability """ return (factorial(n) / (factorial(n-x) * factorial(x))) * (1 - theta) ** (n - x) * (theta ** x)
def beta_m(a, B, N): A = np.zeros([N,N]) alpha = np.zeros([N,1]) for i in range(N): alpha[i,0] = a ** (i+1) / factorial(i+1) for j in range(i+1): A[i,j] = B[i-j]/factorial(i-j) return A.dot(alpha)
def integrand(zbar, T=T, data=data): fromb_times = data[1][data[2]=="B"] #total = len(fromb_times) numbefore = np.sum(fromb_times<=zbar) numafter = np.sum(fromb_times>zbar) pbefore = zbar**numbefore*np.exp(-zbar)/float(factorial([numbefore])[0]) pafter = (1.4*(T-zbar))**numafter*np.exp(-1.4*(T-zbar))/float(factorial([numafter])[0]) return pbefore*pafter*.2*np.exp(-.2*zbar)
def basis2d(n0,n1,beta=[1.,1.]): """2d dimensionless Cartesian basis function""" b=hermite2d(n0,n1) b[0]*=((2**n0)*(np.pi**(.5))*factorial(n0))**(-.5) exp0=lambda x: beta[0] * b[0](x) * np.exp(-.5*(x**2)) b[1]*=((2**n1)*(np.pi**(.5))*factorial(n1))**(-.5) exp1=lambda x: beta[1] * b[1](x) * np.exp(-.5*(x**2)) return [exp0,exp1]
def constant_potential_twosphere_identical(phi01, phi02, r1, r2, R, kappa, epsilon): # From Carnie+Chan 1993 N = 20 # Number of terms in expansion qe = 1.60217646e-19 Na = 6.0221415e23 E_0 = 8.854187818e-12 cal2J = 4.184 index = arange(N, dtype=float) + 0.5 k1 = special.kv(index, kappa*r1)*sqrt(pi/(2*kappa*r1)) k2 = special.kv(index, kappa*r2)*sqrt(pi/(2*kappa*r2)) i1 = special.iv(index, kappa*r1)*sqrt(pi/(2*kappa*r1)) i2 = special.iv(index, kappa*r2)*sqrt(pi/(2*kappa*r2)) B = zeros((N,N), dtype=float) for n in range(N): for m in range(N): for nu in range(N): if n>=nu and m>=nu: g1 = gamma(n-nu+0.5) g2 = gamma(m-nu+0.5) g3 = gamma(nu+0.5) g4 = gamma(m+n-nu+1.5) f1 = factorial(n+m-nu) f2 = factorial(n-nu) f3 = factorial(m-nu) f4 = factorial(nu) Anm = g1*g2*g3*f1*(n+m-2*nu+0.5)/(pi*g4*f2*f3*f4) kB = special.kv(n+m-2*nu+0.5,kappa*R)*sqrt(pi/(2*kappa*R)) B[n,m] += Anm*kB M = zeros((N,N), float) for i in range(N): for j in range(N): M[i,j] = (2*i+1)*B[i,j]*i1[i] if i==j: M[i,j] += k1[i] RHS = zeros(N) RHS[0] = phi01 a = solve(M,RHS) a0 = a[0] U = 4*pi * ( -pi/2 * a0/phi01 * 1/sinh(kappa*r1) + kappa*r1 + kappa*r1/tanh(kappa*r1) ) # print 'E: %f'%U C0 = qe**2*Na*1e-3*1e10/(cal2J*E_0) C1 = r1*epsilon*phi01*phi01 E_inter = U*C1*C0 return E_inter
def wigner6j(j1,j2,j3,J1,J2,J3): """Return the value of the 6-j symbol for the given values of j and m using the Racah formula. / j1 j2 j3 \ < > \ J1 J2 J3 / Based upon Wigner3j.m from David Terr, Raytheon Reference: http://mathworld.wolfram.com/Wigner6j-Symbol.html Usage wigner = Wigner6j(j1,j2,j3,J1,J2,J3) Args: j1 (float): j1 j2 (float): j2 j3 (float): j3 J1 (float): J1 J2 (float): J2 J3 (float): J3 Returns: float: value of the 6-j symbol """ # Check that the js and Js are only integer or half integer if ( ( 2*j1 != round(2*j1) ) | ( 2*j2 != round(2*j2) ) | ( 2*j2 != round(2*j2) ) | ( 2*J1 != round(2*J1) ) | ( 2*J2 != round(2*J2) ) | ( 2*J3 != round(2*J3) ) ): print('All arguments must be integers or half-integers.') return -1 # Check if the 4 triads ( (j1 j2 j3), (j1 J2 J3), (J1 j2 J3), (J1 J2 j3) ) satisfy the triangular inequalities if ( ( abs(j1-j2) > j3 ) | ( j1+j2 < j3 ) | ( abs(j1-J2) > J3 ) | ( j1+J2 < J3 ) | ( abs(J1-j2) > J3 ) | ( J1+j2 < J3 ) | ( abs(J1-J2) > j3 ) | ( J1+J2 < j3 ) ): print('6j-Symbol is not triangular!') return 0 # Check if the sum of the elements of each traid is an integer if ( ( 2*(j1+j2+j3) != round(2*(j1+j2+j3)) ) | ( 2*(j1+J2+J3) != round(2*(j1+J2+J3)) ) | ( 2*(J1+j2+J3) != round(2*(J1+j2+J3)) ) | ( 2*(J1+J2+j3) != round(2*(J1+J2+j3)) ) ): print('6j-Symbol is not triangular!') return 0 # Arguments for the factorials t1 = j1+j2+j3 t2 = j1+J2+J3 t3 = J1+j2+J3 t4 = J1+J2+j3 t5 = j1+j2+J1+J2 t6 = j2+j3+J2+J3 t7 = j1+j3+J1+J3 # Finding summation borders tmin = max(0, max(t1, max(t2, max(t3,t4)))) tmax = min(t5, min(t6,t7)) tvec = arange(tmin,tmax+1,1) # Calculation the sum part of the 6j-Symbol WignerReturn = 0 for t in tvec: WignerReturn += (-1)**t*factorial(t+1)/( factorial(t-t1)*factorial(t-t2)*factorial(t-t3)*factorial(t-t4)*factorial(t5-t)*factorial(t6-t)*factorial(t7-t) ) # Calculation of the 6j-Symbol return WignerReturn*sqrt( TriaCoeff(j1,j2,j3)*TriaCoeff(j1,J2,J3)*TriaCoeff(J1,j2,J3)*TriaCoeff(J1,J2,j3) )
def dimBasis2d(n0,n1,beta=[1.,1.],phs=[1.,1.]): """2d dimensional Cartesian basis function of characteristic size beta phs: additional phase factor, used in the Fourier Transform""" b=hermite2d(n0,n1) b[0]*=(beta[0]**(-.5))*(((2**n0)*(np.pi**(.5))*factorial(n0))**(-.5)) exp0=lambda x: b[0](x/beta[0]) * np.exp(-.5*((x/beta[0])**2)) * phs[0] b[1]*=(beta[1]**(-.5))*(((2**n1)*(np.pi**(.5))*factorial(n1))**(-.5)) exp1=lambda x: b[1](x/beta[1]) * np.exp(-.5*((x/beta[1])**2)) * phs[1] return [exp0,exp1]
def radial_poly(rho, n, m): upper = (n - np.abs(m)) / 2 s = np.arange(upper + 1) consts = -1 ** s consts *= factorial(n - s) consts /= factorial(s) consts /= factorial((n + np.abs(m))/2 - s) consts /= factorial((n - np.abs(m))/2 - s) return (consts * rho[..., np.newaxis]**(n - 2 * s)).sum(axis=-1)
def number_of_permutations(self): """ Returns the number of permutations of this coordination geometry. """ if self.permutations_safe_override: return factorial(self.coordination) elif self.permutations is None: return factorial(self.coordination) return len(self.permutations)
def get_K(x,n): K = 0. n_fact = factorial(n) n_fact2 = factorial(2*n) for s in range(n+1): K += 2**s*n_fact*factorial(2*n-s)/(factorial(s)*n_fact2*factorial(n-s)) * x**s return K
def _maternpolykernel(R, p, l): nu = p + 0.5 r = np.sqrt(2.*nu)*R/l poly = np.zeros_like(r) factor = gamma(p+1)/gamma(2*p+1) for i in np.arange(p+1): poly += factorial(p+i)*np.power(2.*r,p-i)/(factorial(i)*factorial(p-i)) return factor*np.exp(-r)*poly
def calculateExponentialSeries(ck, truncationOrder): N = truncationOrder // 2 n = np.linspace(0, 2 * N - 1, 2 * N) expSeries = np.power(-ck**2 / 2, n) / factorial(n) # print(expSeries) return expSeries
def PiecewiseMollify(theta, c_j, a_n, x): """ Piecewise mollify the spectral reconstruction of a discontinuous function to reduce the effect of Gibbs phenomenon. Perform a real-space convolution of a spectral reconstruction with an adaptive unit-mass mollifier. Parameters ---------- theta : float free parameter to vary in the range 0 < theta < 1 c_j : 1D array, Array containing x positions of the discontinuities in the data a_n : 1D array, shape = (N+1,) N - highest order in the Chebyshev expansion vector of Chebyshev expansion coefficients x : 1D array, 1D grid of points in real space, where the function is evaluated Returns ---------- mollified : 1D array, shape = (len(x),) real space mollified representation of a discontinuous function mollified_err : 1D array, shape = (len(x),) error estimate for each point in the convolution, derived from scipy.integrate.quad """ N = a_n.shape[0] - 1 sanity_check = np.empty(len(x)) mollified = np.array([]) mollified_err = np.array([]) I_N = lambda y: T.chebval(y, a_n) chi_top = lambda y, f: f(y) if -1 <= y <= 1 else 0 I_N_top = lambda y: chi_top(y, I_N) c_jplus = np.append(c_j, 1.0) for idx_c, pos in enumerate(c_jplus): if idx_c == 0: lim_left = -1.0 lim_right = pos offset = np.ma.masked_where(x > lim_right, x) offset = np.ma.compressed(offset) else: lim_left = c_jplus[idx_c - 1] lim_right = pos offset = np.ma.masked_where(x > lim_right, x) offset = np.ma.masked_where(x <= lim_left, offset) offset = np.ma.compressed(offset) chi_cut = lambda y, f: f(y) if lim_left <= y <= lim_right else 0 convolution = np.empty(len(offset)) convolution_err = np.empty(len(offset)) for idx_o, off_x in enumerate(offset): c_jx = c_j - off_x dx = lambda y: sqrt(theta * N * min(abs(y - c) for c in c_jx)) var = lambda y: N / (2 * theta * dx(y)) p_N = lambda y: (theta**2) * dx(y) * N j_max = int(np.amax(np.frompyfunc(p_N, 1, 1)(x))) h_j = np.zeros(2 * (j_max + 1)) for j in range(j_max + 1): h_j[2 * j] = ((-1)**j) / ((4**j) * factorial(j)) hermite = lambda y: H.hermeval(sqrt(var(y)) * y, h_j) expon = lambda y: (1. / sqrt(theta * N * dx(y))) * exp(-var(y) * (y**2)) phi0 = lambda y: hermite(y) * expon(y) phi_off = lambda y: phi0(y - off_x) phi = lambda y: chi_cut(y, phi_off) norm = quad(phi, lim_left, lim_right)[0] convfunc = lambda y: (1 / norm) * (phi(y) * I_N_top(y)) convolution[idx_o], convolution_err[idx_o] = quad( convfunc, lim_left, lim_right) mollified = np.append(mollified, convolution) mollified_err = np.append(mollified_err, convolution_err) assert mollified.shape == sanity_check.shape, "Piecewise mollification inconsistent with regular one" assert mollified_err.shape == sanity_check.shape, "Piecewise mollification inconsistent with regular one" return mollified, mollified_err
import scipy.misc as sp import numpy as np limit = int(sp.factorial(9)) curious = [] for ii in range(limit): s = str(ii) temp_sum = 0 for jj in range(len(s)): # print(s[jj]) temp_sum += sp.factorial(int(s[jj])) if temp_sum == ii: curious.append(ii) print(curious) curious = curious[2:] # Remove 1 and 2 print(np.sum(curious))
def Wigner6j(j1, j2, j3, J1, J2, J3): #====================================================================== # Calculating the Wigner6j-Symbols using the Racah-Formula # Author: Ulrich Krohn # Date: 13th November 2009 # # Based upon Wigner3j.m from David Terr, Raytheon # Reference: http://mathworld.wolfram.com/Wigner6j-Symbol.html # # Usage: # from wigner import Wigner6j # WignerReturn = Wigner6j(j1,j2,j3,J1,J2,J3) # # / j1 j2 j3 \ # < > # \ J1 J2 J3 / # #====================================================================== # Check that the js and Js are only integer or half integer if ((2 * j1 != round(2 * j1)) | (2 * j2 != round(2 * j2)) | (2 * j2 != round(2 * j2)) | (2 * J1 != round(2 * J1)) | (2 * J2 != round(2 * J2)) | (2 * J3 != round(2 * J3))): raise ('All arguments must be integers or half-integers.') return -1 # Check if the 4 triads ( (j1 j2 j3), (j1 J2 J3), (J1 j2 J3), (J1 J2 j3) ) satisfy the triangular inequalities if ((abs(j1 - j2) > j3) | (j1 + j2 < j3) | (abs(j1 - J2) > J3) | (j1 + J2 < J3) | (abs(J1 - j2) > J3) | (J1 + j2 < J3) | (abs(J1 - J2) > j3) | (J1 + J2 < j3)): #print '6j-Symbol is not triangular!' return 0 # Check if the sum of the elements of each traid is an integer if ((2 * (j1 + j2 + j3) != round(2 * (j1 + j2 + j3))) | (2 * (j1 + J2 + J3) != round(2 * (j1 + J2 + J3))) | (2 * (J1 + j2 + J3) != round(2 * (J1 + j2 + J3))) | (2 * (J1 + J2 + j3) != round(2 * (J1 + J2 + j3)))): #print '6j-Symbol is not triangular!' return 0 # Arguments for the factorials t1 = j1 + j2 + j3 t2 = j1 + J2 + J3 t3 = J1 + j2 + J3 t4 = J1 + J2 + j3 t5 = j1 + j2 + J1 + J2 t6 = j2 + j3 + J2 + J3 t7 = j1 + j3 + J1 + J3 # Finding summation borders tmin = max(0, max(t1, max(t2, max(t3, t4)))) tmax = min(t5, min(t6, t7)) tvec = arange(tmin, tmax + 1, 1) # Calculation the sum part of the 6j-Symbol WignerReturn = 0 for t in tvec: WignerReturn += (-1)**t * factorial(t + 1) / ( factorial(t - t1) * factorial(t - t2) * factorial(t - t3) * factorial(t - t4) * factorial(t5 - t) * factorial(t6 - t) * factorial(t7 - t)) # Calculation of the 6j-Symbol return WignerReturn * sqrt( TriaCoeff(j1, j2, j3) * TriaCoeff(j1, J2, J3) * TriaCoeff(J1, j2, J3) * TriaCoeff(J1, J2, j3))
import scipy.misc as spm factorials = {} for i in range(10): factorials[str(i)] = spm.factorial(i) ans = 0 for i in range(3, 500000): stri = str(i) num = 0 for j in stri: # if j == '9' or j =='8': # break num += factorials[j] if num == i: print i ans += i print ans
def norm(self, n): return 1.0 / (np.sqrt(np.sqrt(np.pi) * (2.0**n) * factorial(n)))
def _build_levels_c(self, lodft, log_rad, angle, Xrcos, Yrcos, height, img_dims): ''' Modified by Li Jie Add muti scale,for example,scale_factor=2**(1/2) ''' if height <= 1: coeff = [lodft] else: Xrcos = Xrcos - np.log2(self.scale_factor) #################################################################### ####################### Orientation bandpass ####################### #################################################################### himask = pointOp(log_rad, Yrcos, Xrcos) order = self.nbands - 1 const = np.power(2, 2 * order) * np.square( factorial(order)) / (self.nbands * factorial(2 * order)) Ycosn = 2 * np.sqrt(const) * np.power(np.cos( self.Xcosn), order) * (np.abs(self.alpha) < np.pi / 2) # Loop through all orientation bands orientations = [] for b in range(self.nbands): anglemask = pointOp(angle, Ycosn, self.Xcosn + np.pi * b / self.nbands) banddft = np.power(np.complex( 0, -1), self.nbands - 1) * lodft * anglemask * himask orientations.append(banddft) #################################################################### ######################## Subsample lowpass ######################### #################################################################### dims = np.array(lodft.shape) ctr = np.ceil((dims + 0.5) / 2) lodims = np.round(img_dims / (self.scale_factor**(self.height - height))) loctr = np.ceil((lodims + 0.5) / 2) lostart = (ctr - loctr).astype(np.int) loend = (lostart + lodims).astype(np.int) # Selection log_rad = log_rad[lostart[0]:loend[0], lostart[1]:loend[1]] angle = angle[lostart[0]:loend[0], lostart[1]:loend[1]] lodft = lodft[lostart[0]:loend[0], lostart[1]:loend[1]] # Subsampling in frequency domain YIrcos = np.abs(np.sqrt(1 - Yrcos**2)) lomask = pointOp(log_rad, YIrcos, Xrcos) lodft = lomask * lodft #################################################################### ####################### Recursion next level ####################### #################################################################### coeff = self._build_levels_c(lodft, log_rad, angle, Xrcos, Yrcos, height - 1, img_dims) coeff.insert(0, orientations) return coeff
def function(x, lamb, offsX, offsY, scaleX, scaleY): # poisson function, parameter lamb is the fit parameter x = (x - offsX) / scaleX y = (lamb**x / factorial(x)) * np.exp(-lamb) return scaleY * y + offsY
def double_poisson(self,k, *params): (r1,r2,p1,p2) = params poisson_1 = p1 * (r1**k/factorial(k)) * np.exp(-r1) poisson_2 = p2 * (r2**k/factorial(k)) * np.exp(-r2) return poisson_1 + poisson_2
def factor(n, d): return (1./np.sqrt(2**n * factorial(n)))*((omega/np.pi)**0.25)*np.exp(-0.5*omega*(x-d)**2)\ *eval_hermite(n, np.sqrt(omega)*(x-d))
def chi(zeta, n): "Returns the normalization constant of the mSPF basis." return np.sqrt(2 / zeta**1.5 * factorial(n) / gamma(n + 3.5))
def whitney_innerproduct(complex,k): """ For a given SimplicialComplex, compute a matrix representing the innerproduct of Whitney k-forms """ assert(k >= 0 and k <= complex.complex_dimension()) ## MASS MATRIX COO DATA rows,cols = massmatrix_rowcols(complex,k) data = empty(rows.shape) ## PRECOMPUTATION p = complex.complex_dimension() scale_integration = (factorial(k)**2)/((p + 2)*(p + 1)) k_forms = [tuple(x) for x in combinations(range(p+1),k)] k_faces = [tuple(x) for x in combinations(range(p+1),k+1)] num_k_forms = len(k_forms) num_k_faces = len(k_faces) k_form_pairs = [tuple(x) for x in combinations(k_forms,2)] + [(x,x) for x in k_forms] num_k_form_pairs = len(k_form_pairs) k_form_pairs_to_index = dict(zip(k_form_pairs,range(num_k_form_pairs))) k_form_pairs_to_index.update(zip([x[::-1] for x in k_form_pairs],range(num_k_form_pairs))) num_k_face_pairs = num_k_faces**2 if k > 0: k_form_pairs_array = array(k_form_pairs) #maps flat vector of determinants to the flattened matrix entries dets_to_vals = scipy.sparse.lil_matrix((num_k_face_pairs,num_k_form_pairs)) k_face_pairs = [] for face1 in k_faces: for face2 in k_faces: row_index = len(k_face_pairs) k_face_pairs.append((face1,face2)) for n in range(k+1): for m in range(k+1): form1 = face1[:n] + face1[n+1:] form2 = face2[:m] + face2[m+1:] col_index = k_form_pairs_to_index[(form1,form2)] dets_to_vals[row_index,col_index] += (-1)**(n+m)*((face1[n] == face2[m]) + 1) k_face_pairs_to_index = dict(zip(k_face_pairs,range(num_k_faces**2))) dets_to_vals = dets_to_vals.tocsr() ## END PRECOMPUTATION ## COMPUTATION if k == 1: Fdet = lambda x : x #det for 1x1 matrices - extend else: Fdet, = scipy.linalg.flinalg.get_flinalg_funcs(('det',),(complex.vertices,)) dets = ones(num_k_form_pairs) for i,s in enumerate(complex[-1].simplices): # for k=1, dets is already correct i.e. dets[:] = 1 if k > 0: # lambda_i denotes the scalar barycentric basis function of the i-th vertex of this simplex # d(lambda_i) is the 1 form (gradient) of the i-th scalar basis function within this simplex pts = complex.vertices[s,:] d_lambda = barycentric_gradients(pts) mtxs = d_lambda[k_form_pairs_array] # these lines are equivalent to: for n,(A,B) in enumerate(mtxs): # for n,(form1,form2) in enumerate(k_form_pairs): dets[n] = Fdet(inner(A,B))[0] # dets[n] = det(dot(d_lambda[form1,:],d_lambda[form2,:].T)) volume = complex[-1].primal_volume[i] vals = dets_to_vals * dets vals *= volume * scale_integration #scale by the volume, barycentric weights, and account for the p! in each whitney form #put values into appropriate entries of the COO data array data[i*num_k_face_pairs:(i+1)*num_k_face_pairs] = vals #now rows,cols,data form a COOrdinate representation for the mass matrix shape = (complex[k].num_simplices,complex[k].num_simplices) return coo_matrix((data,(rows,cols)), shape).tocsr()
def poisson_prob(n, lam): global poissonBackup key = n * 10 + lam if key not in poissonBackup.keys(): poissonBackup[key] = np.exp(-lam) * lam ** n / factorial(n) return poissonBackup[key]
def multinomial(x, n, p): x = np.atleast_2d(x) return factorial(n) / factorial(x).prod(1) * (p**x).prod(1)
def rc(self, n, m, l): return (-1.)**l*factorial(n - l)/(factorial(l)*factorial((n+m)/2.0 - l)*factorial((n-m)/2.0 - l))
import lib.AmBePlots as abp import lib.BeamPlots as bp import pandas as pd import matplotlib.pyplot as plt import scipy.optimize as scp import numpy as np import scipy.misc as scm SIGNAL_DIRS = ["./Data/V3_5PE100ns/BeamData/"] SIGNAL_LABELS = ['Beam'] BKG_DIR = "./Data/BkgCentralData/" PEPERMEV = 12. expoPFlat= lambda x,C1,tau,mu,B: C1*np.exp(-(x-mu)/tau) + B mypoisson = lambda x,mu: (mu**x)*np.exp(-mu)/scm.factorial(x) def GetDataFrame(mytreename,mybranches,filelist): RProcessor = rp.ROOTProcessor(treename=mytreename) for f1 in filelist: RProcessor.addROOTFile(f1,branches_to_get=mybranches) data = RProcessor.getProcessedData() df = pd.DataFrame(data) return df def BeamPlotDemo(PositionDict,MCdf): Sdf = PositionDict["Beam"][0] Sdf_trig = PositionDict["Beam"][1] Sdf_mrd = PositionDict["Beam"][2] Sdf = Sdf.loc[Sdf["eventTimeTank"]>-9].reset_index(drop=True)
def Wigner3j(j1, j2, j3, m1, m2, m3): #====================================================================== # Wigner3j.m by David Terr, Raytheon, 6-17-04 # # Compute the Wigner 3j symbol using the Racah formula [1]. # # Usage: # from wigner import Wigner3j # wigner = Wigner3j(j1,j2,j3,m1,m2,m3) # # / j1 j2 j3 \ # | | # \ m1 m2 m3 / # # Reference: Wigner 3j-Symbol entry of Eric Weinstein's Mathworld: # http://mathworld.wolfram.com/Wigner3j-Symbol.html #====================================================================== # Error checking if ((2 * j1 != floor(2 * j1)) | (2 * j2 != floor(2 * j2)) | (2 * j3 != floor(2 * j3)) | (2 * m1 != floor(2 * m1)) | (2 * m2 != floor(2 * m2)) | (2 * m3 != floor(2 * m3))): raise ('All arguments must be integers or half-integers.') return -1 # Additional check if the sum of the second row equals zero if (m1 + m2 + m3 != 0): #print '3j-Symbol unphysical' return 0 if (j1 - m1 != floor(j1 - m1)): #print '2*j1 and 2*m1 must have the same parity' return 0 if (j2 - m2 != floor(j2 - m2)): #print '2*j2 and 2*m2 must have the same parity' return 0 if (j3 - m3 != floor(j3 - m3)): #print '2*j3 and 2*m3 must have the same parity' return 0 if (j3 > j1 + j2) | (j3 < abs(j1 - j2)): #print 'j3 is out of bounds.' return 0 if abs(m1) > j1: #print 'm1 is out of bounds.' return 0 if abs(m2) > j2: #print 'm2 is out of bounds.' return 0 if abs(m3) > j3: #print 'm3 is out of bounds.' return 0 t1 = j2 - m1 - j3 t2 = j1 + m2 - j3 t3 = j1 + j2 - j3 t4 = j1 - m1 t5 = j2 + m2 tmin = max(0, max(t1, t2)) tmax = min(t3, min(t4, t5)) tvec = arange(tmin, tmax + 1, 1) wigner = 0 for t in tvec: wigner += (-1)**t / (factorial(t) * factorial(t - t1) * factorial(t - t2) * factorial(t3 - t) * factorial(t4 - t) * factorial(t5 - t)) return wigner * (-1)**(j1 - j2 - m3) * sqrt( factorial(j1 + j2 - j3) * factorial(j1 - j2 + j3) * factorial(-j1 + j2 + j3) / factorial(j1 + j2 + j3 + 1) * factorial(j1 + m1) * factorial(j1 - m1) * factorial(j2 + m2) * factorial(j2 - m2) * factorial(j3 + m3) * factorial(j3 - m3))
def _derivative_stencil_coefficients(axis, p=1, q=3): """Calculates the coefficients needed for the derivative. Parameters ---------- axis : array like Axis onto which the derivative will be calculated. p : integer, optional Order of the derivative to be calculated. Default is to calculate the first derivative (p=1). 2*n-p+1 gives the relative order of the approximation. q : integer, optional Length of the stencil used for centered differentials. The length has to be odd numbered. Default is q=3. Returns ------- Coefficients (a_q) needed for the linear combination of `q` points to get the first derivative according to Arbic et al. (2012) equations (20) and (22). At the boundaries forward and backward differences approximations are calculated. References ---------- Cushman-Roisin, B. & Beckers, J.-M. Introduction to geophysical fluid dynamics: Physical and numerical aspects Academic Press, 2011, 101, 828. Arbic, Brian B. Scott, R. B.; Chelton, D. B.; Richman, J. G. & Shriver, J. F. Effects of stencil width on surface ocean geostrophic velocity and vorticity estimation from gridded satellite altimeter data. Journal of Geophysical Research, 2012, 117, C03029. """ # Calculate left and right stencils. q_left = (q - 1) / 2 q_right = (q - 1) / 2 + 1 # I = axis.size # Constructs matrices according to Cushman-Roisin & Beckers (2011) # equations (1.25) and adapted for variable grids as in Arbic et # al. (2012), equations (20), (22). The linear system of equations # is solved afterwards. coeffs = zeros((I, q)) smart_coeffs = dict() for i in range(I): A = zeros((q, q)) # if i < q_left: start = q_left - i else: start = 0 if i > I - q_right: stop = i - (I - q_right) else: stop = 0 # A[0, start:q + stop] = 1 da = axis[i - q_left + start:i + q_right - stop] - axis[i] da_key = str(da) # if da_key not in smart_coeffs.keys(): for h in range(1, q): A[h, start:q - stop] = da**h B = zeros((q, 1)) # This tells where the p-th derivative is calculated B[p] = factorial(p) C = linalg.solve(A[:q - start - stop, start:q - stop], B[:q - (start + stop), :]) # smart_coeffs[da_key] = C.flatten() # coeffs[i, start:q - stop] = smart_coeffs[da_key] # return coeffs
def TriaCoeff(a, b, c): # Calculating the triangle coefficient return factorial(a + b - c) * factorial(a - b + c) * factorial( -a + b + c) / (factorial(a + b + c + 1))
def residuez(b, a, tol=1e-3, rtype='avg'): """Compute partial-fraction expansion of b(z) / a(z). If M = len(b) and N = len(a) b(z) b[0] + b[1] z**(-1) + ... + b[M-1] z**(-M+1) H(z) = ------ = ---------------------------------------------- a(z) a[0] + a[1] z**(-1) + ... + a[N-1] z**(-N+1) r[0] r[-1] = --------------- + ... + ---------------- + k[0] + k[1]z**(-1) ... (1-p[0]z**(-1)) (1-p[-1]z**(-1)) If there are any repeated roots (closer than tol), then the partial fraction expansion has terms like r[i] r[i+1] r[i+n-1] -------------- + ------------------ + ... + ------------------ (1-p[i]z**(-1)) (1-p[i]z**(-1))**2 (1-p[i]z**(-1))**n See also -------- invresz, poly, polyval, unique_roots """ b, a = map(asarray, (b, a)) gain = a[0] brev, arev = b[::-1], a[::-1] krev, brev = polydiv(brev, arev) if krev == []: k = [] else: k = krev[::-1] b = brev[::-1] p = roots(a) r = p * 0.0 pout, mult = unique_roots(p, tol=tol, rtype=rtype) p = [] for n in range(len(pout)): p.extend([pout[n]] * mult[n]) p = asarray(p) # Compute the residue from the general formula (for discrete-time) # the polynomial is in z**(-1) and the multiplication is by terms # like this (1-p[i] z**(-1))**mult[i]. After differentiation, # we must divide by (-p[i])**(m-k) as well as (m-k)! indx = 0 for n in range(len(pout)): bn = brev.copy() pn = [] for l in range(len(pout)): if l != n: pn.extend([pout[l]] * mult[l]) an = atleast_1d(poly(pn))[::-1] # bn(z) / an(z) is (1-po[n] z**(-1))**Nn * b(z) / a(z) where Nn is # multiplicity of pole at po[n] and b(z) and a(z) are polynomials. sig = mult[n] for m in range(sig, 0, -1): if sig > m: # compute next derivative of bn(s) / an(s) term1 = polymul(polyder(bn, 1), an) term2 = polymul(bn, polyder(an, 1)) bn = polysub(term1, term2) an = polymul(an, an) r[indx + m - 1] = (polyval(bn, 1.0 / pout[n]) / polyval(an, 1.0 / pout[n]) / factorial(sig - m) / (-pout[n]) ** (sig - m)) indx += sig return r / gain, p, k
def cm_volume_helper(cm_det_abs_root, n): return cm_det_abs_root / ((2.**(n / 2.)) * factorial(n))
# PS1EX3 from numpy import sqrt, sin, pi from scipy.misc import factorial print(sqrt(17)) print(factorial(18)) print(sin((18 * 2 * pi) / 360)) # PS1EX4 import sys import numpy as np G = 9.81 def distance(height, time): fallen = 0.5 * G * time**2 return height - fallen if fallen <= height else 0 if __name__ == '__main__': try: # also handels non-int input, by ValueError given = raw_input("Enter the height and time, space seperated: ") height, time = [float(n) for n in given.split(' ')] except ValueError: print('Not a number. Usage: pset1ex4.py HEIGHT TIME') sys.exit() final_height = distance(height, time)
def MollifyQuadBuffer(theta, c_j, a_n, x): """ Mollify the spectral reconstruction of a discontinuous function to reduce the effect of Gibbs phenomenon. Perform a real-space convolution of a spectral reconstruction with an adaptive unit-mass mollifier. Parameters ---------- theta : float free parameter to vary in the range 0 < theta < 1 c_j : 1D array, Array containing x positions of the discontinuities in the data a_n : 1D array, shape = (N+1,) N - highest order in the Chebyshev expansion vector of Chebyshev expansion coefficients x : 1D array, 1D grid of points in real space, where the function is evaluated Returns ---------- convolution : 1D array, shape = (len(x),) real space mollified representation of a discontinuous function """ N = a_n.shape[0] - 1 deltax = 2.0 / (len(x) - 1) I_N = lambda y: T.chebval(y, a_n) I_Nf = lambda y: I_N(y) if -1 <= y <= 1 else 0 buff_right = lambda y: I_N(2.0 - y) if 1.0 < y < 1.4 else 0 buff_left = lambda y: I_N(-(2.0 + y)) if -1.4 < y < -1.0 else 0 I_Nnew = lambda y: buff_right(y) + buff_left(y) + I_Nf(y) add_left = np.arange(-1.4, -1.0, deltax) add_right = np.arange(1.0, 1.4, deltax) offset = np.hstack((add_left, x, add_right)) convolution = np.empty(len(offset)) for idx, off_x in enumerate(offset): c_jx = c_j - off_x dx = lambda y: sqrt(theta * N * min(abs(y - c) for c in c_jx)) var = lambda y: N / (2 * theta * dx(y)) p_N = lambda y: (theta**2) * dx(y) * N j_max = int(np.amax(np.frompyfunc(p_N, 1, 1)(x))) h_j = np.zeros(2 * (j_max + 1)) for j in range(j_max + 1): h_j[2 * j] = ((-1)**j) / ((4**j) * factorial(j)) hermite = lambda y: H.hermeval(sqrt(var(y)) * y, h_j) expon = lambda y: (1. / sqrt(theta * N * dx(y))) * exp(-var(y) * (y**2)) phi = lambda y: hermite(y) * expon(y) phif = lambda y: phi(y - off_x) norm = quad(phi, -1.4, 1.4)[0] convfunc = lambda y: (phif(y) * I_Nnew(y)) convolution[idx] = (1 / norm) * quad(convfunc, -1.4, 1.4)[0] convolution = convolution[len(add_left):-(len(add_right))] return convolution
def residue(b, a, tol=1e-3, rtype='avg'): """ Compute partial-fraction expansion of b(s) / a(s). If ``M = len(b)`` and ``N = len(a)``, then the partial-fraction expansion H(s) is defined as:: b(s) b[0] s**(M-1) + b[1] s**(M-2) + ... + b[M-1] H(s) = ------ = ---------------------------------------------- a(s) a[0] s**(N-1) + a[1] s**(N-2) + ... + a[N-1] r[0] r[1] r[-1] = -------- + -------- + ... + --------- + k(s) (s-p[0]) (s-p[1]) (s-p[-1]) If there are any repeated roots (closer together than `tol`), then H(s) has terms like:: r[i] r[i+1] r[i+n-1] -------- + ----------- + ... + ----------- (s-p[i]) (s-p[i])**2 (s-p[i])**n Returns ------- r : ndarray Residues. p : ndarray Poles. k : ndarray Coefficients of the direct polynomial term. See Also -------- invres, numpy.poly, unique_roots """ b, a = map(asarray, (b, a)) rscale = a[0] k, b = polydiv(b, a) p = roots(a) r = p * 0.0 pout, mult = unique_roots(p, tol=tol, rtype=rtype) p = [] for n in range(len(pout)): p.extend([pout[n]] * mult[n]) p = asarray(p) # Compute the residue from the general formula indx = 0 for n in range(len(pout)): bn = b.copy() pn = [] for l in range(len(pout)): if l != n: pn.extend([pout[l]] * mult[l]) an = atleast_1d(poly(pn)) # bn(s) / an(s) is (s-po[n])**Nn * b(s) / a(s) where Nn is # multiplicity of pole at po[n] sig = mult[n] for m in range(sig, 0, -1): if sig > m: # compute next derivative of bn(s) / an(s) term1 = polymul(polyder(bn, 1), an) term2 = polymul(bn, polyder(an, 1)) bn = polysub(term1, term2) an = polymul(an, an) r[indx + m - 1] = polyval(bn, pout[n]) / polyval(an, pout[n]) \ / factorial(sig - m) indx += sig return r / rscale, p, k
def graficos(self, PA): base_path = self.__base_path + '/Graficos/' # Gráficos da otimização base_dir = '/PSO/' Validacao_Diretorio(base_path, base_dir) self.Otimizacao.Graficos(base_path + base_dir, Nome_param=self.parametros.simbolos, Unid_param=self.parametros.unidades, FO2a2=True) # Gráficos da estimação base_dir = '/Estimacao/' Validacao_Diretorio(base_path, base_dir) # Gráfico comparativo entre valores experimentais e calculados pelo modelo, sem variância for i in xrange(self.NY): y = self.y.experimental.matriz_estimativa[:, i] ym = self.y.modelo.matriz_estimativa[:, i] ymin = min(y) ymax = max(y) diag = linspace(min(y), max(y)) fig = figure() ax = fig.add_subplot(1, 1, 1) plot(y, ym, 'bo', linewidth=2.0) plot(diag, diag, 'k-', linewidth=2.0) ax.yaxis.grid(color='gray', linestyle='dashed') ax.xaxis.grid(color='gray', linestyle='dashed') xlim((ymin, ymax)) ylim((ymin, ymax)) if self.y.simbolos == None and self.y.unidades == None: xlabel(r'$y_{%d}$' % (i + 1) + ' experimental') ylabel(r'$y_{%d}$' % (i + 1) + ' calculado') elif self.y.simbolos != None and self.y.unidades == None: xlabel(self.y.simbolos[i] + ' experimental') ylabel(self.y.simbolos[i] + ' calculado') elif self.y.simbolos != None and self.y.unidades != None: xlabel(self.y.simbolos[i] + '/' + self.y.unidades[i] + ' experimental') ylabel(self.y.simbolos[i] + '/' + self.y.unidades[i] + ' calculado') fig.savefig(base_path + base_dir + 'grafico_' + str(self.y.nomes[i]) + '_ye_ym_sem_var.png') close() # Região de abrangência (verossimilhança) Hist_Posicoes, Hist_Fitness = self.regiaoAbrangencia(PA) if self.NP == 1: aux = [] for it in xrange( size(self.parametros.regiao_abrangencia) / self.NP): aux.append(self.parametros.regiao_abrangencia[it][0]) X = [Hist_Posicoes[it][0] for it in xrange(len(Hist_Posicoes))] Y = Hist_Fitness X_sort = sort(X) Y_sort = [Y[i] for i in argsort(X)] fig = figure() ax = fig.add_subplot(1, 1, 1) plot(X_sort, Y_sort, 'bo', markersize=4) plot(self.parametros.estimativa[0], self.Otimizacao.best_fitness, 'ro', markersize=8) plot([min(aux), min(aux)], [min(Y_sort), max(Y_sort) / 4], 'r-') plot([max(aux), max(aux)], [min(Y_sort), max(Y_sort) / 4], 'r-') ax.text(min(aux), max(Y_sort) / 4, u'%.2e' % (min(aux), ), fontsize=8, horizontalalignment='center') ax.text(max(aux), max(Y_sort) / 4, u'%.2e' % (max(aux), ), fontsize=8, horizontalalignment='center') ax.yaxis.grid(color='gray', linestyle='dashed') ax.xaxis.grid(color='gray', linestyle='dashed') ylabel(r"$\quad \Phi $", fontsize=20) if self.parametros.simbolos == None and self.parametros.unidades == None: xlabel(r'$\theta_{%d}$' % (i + 1), fontsize=20) elif self.parametros.simbolos != None and self.parametros.unidades == None: xlabel(self.parametros.simbolos[0], fontsize=20) elif self.parametros.simbolos != None and self.parametros.unidades != None: xlabel(self.parametros.simbolos[0] + '/' + self.parametros.unidades[0], fontsize=20) fig.savefig(base_path + base_dir + 'Regiao_verossimilhanca_' + str(self.parametros.nomes[0]) + '_' + str(self.parametros.nomes[0]) + '.png') close() else: Combinacoes = int( factorial(self.NP) / (factorial(self.NP - 2) * factorial(2))) p1 = 0 p2 = 1 cont = 0 passo = 1 for pos in xrange(Combinacoes): if pos == (self.NP - 1) + cont: p1 += 1 p2 = p1 + 1 passo += 1 cont += self.NP - passo fig = figure() ax = fig.add_subplot(1, 1, 1) for it in xrange( size(self.parametros.regiao_abrangencia) / self.NP): PSO, = plot(self.parametros.regiao_abrangencia[it][p1], self.parametros.regiao_abrangencia[it][p2], 'bo', linewidth=2.0, zorder=1) plot(self.parametros.estimativa[p1], self.parametros.estimativa[p2], 'r*', markersize=10.0, zorder=2) ax.yaxis.grid(color='gray', linestyle='dashed') ax.xaxis.grid(color='gray', linestyle='dashed') if self.parametros.simbolos == None and self.parametros.unidades == None: xlabel(r'$\theta_{%d}$' % (p1 + 1), fontsize=20) ylabel(r'$\theta_{%d}$' % (p2 + 1), fontsize=20) elif self.parametros.simbolos != None and self.parametros.unidades == None: xlabel(self.parametros.simbolos[p1], fontsize=20) ylabel(self.parametros.simbolos[p2], fontsize=20) elif self.parametros.simbolos != None and self.parametros.unidades != None: xlabel(self.parametros.simbolos[p1] + '/' + self.parametros.unidades[p1], fontsize=20) ylabel(self.parametros.simbolos[p2] + '/' + self.parametros.unidades[p2], fontsize=20) fig.savefig(base_path + base_dir + 'Regiao_verossimilhanca_' + str(self.parametros.nomes[p1]) + '_' + str(self.parametros.nomes[p2]) + '.png') close() p2 += 1
def fact(x): """Inputs x and outputs x!.""" return misc.factorial(x, exact=True)
def clebsch(j1, j2, j3, m1, m2, m3): """Calculates the Clebsch-Gordon coefficient for coupling (j1,m1) and (j2,m2) to give (j3,m3). Parameters ---------- j1 : float Total angular momentum 1. j2 : float Total angular momentum 2. j3 : float Total angular momentum 3. m1 : float z-component of angular momentum 1. m2 : float z-component of angular momentum 2. m3 : float z-component of angular momentum 3. Returns ------- cg_coeff : float Requested Clebsch-Gordan coefficient. """ if m3 != m1 + m2: return 0 vmin = int(np.max([-j1 + j2 + m3, -j1 + m1, 0])) vmax = int(np.min([j2 + j3 + m1, j3 - j1 + j2, j3 + m3])) C = np.sqrt( (2.0 * j3 + 1.0) * factorial(j3 + j1 - j2) * factorial(j3 - j1 + j2) * factorial(j1 + j2 - j3) * factorial(j3 + m3) * factorial(j3 - m3) / (factorial(j1 + j2 + j3 + 1) * factorial(j1 - m1) * factorial(j1 + m1) * factorial(j2 - m2) * factorial(j2 + m2))) S = 0 for v in range(vmin, vmax + 1): S += (-1.0) ** (v + j2 + m2) / factorial(v) * \ factorial(j2 + j3 + m1 - v) * factorial(j1 - m1 + v) / \ factorial(j3 - j1 + j2 - v) / factorial(j3 + m3 - v) / \ factorial(v + j1 - j2 - m3) C = C * S return C
def ref_xfact(m): return factorial2(2 * m - 1) / np.sqrt(factorial(2 * m))
def single_poisson(self,k, lam): poisson = (lam**k/factorial(k)) * np.exp(-lam) return poisson
def gamma(x): if x % 1 == 0: return factorial(x - 1) if x % 1 == 0.5: return np.sqrt(np.pi) * factorial( 2 * (x - 0.5)) / (4**(x - 0.5) * factorial((x - 0.5)))