Beispiel #1
0
def getNthOctagonalTriangularNumber( n ):
    sign = power( -1, real( n ) )

    return nint( floor( fdiv( fmul( fsub( 7, fprod( [ 2, sqrt( 6 ), sign ] ) ),
                                    power( fadd( sqrt( 3 ), sqrt( 2 ) ),
                                           fsub( fmul( 4, real_int( n ) ), 2 ) ) ),
                              96 ) ) )
Beispiel #2
0
def zp(x):
    """
    plasma dispersion function                                
    using complementary error function in mpmath library.                       
                                                                                
    """
    return -mp.sqrt(mp.pi) * mp.exp(-x**2) * mp.erfi(x) + mpc(0, 1) * mp.sqrt(mp.pi) * mp.exp(-x**2)
def dfdb (y,x,b,c):

    global FT,XO,XT,XF

    ft=FT

    v=x[0]
    i=y[0]

    iss=IS=b[0]
    n=N=b[1]
    ikf=IKF=b[2]
    isr=ISR=b[3]
    nr=NR=b[4]
    vj=VJ=b[5]
    m=M=b[6]
    rs=RS=b[7]

    #ещё раз: ВСЕ константы должны быть в перспективе либо глобальными переменными, как FT, либо составляющими вектора c, но он кривой, потому лучше уж глобальными.

    return mpm.matrix ([[iss*mpm.sqrt(ikf/(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO)))*(-mpm.exp((-i*rs + v)/(ft*n)) + XO)*(mpm.exp((-i*rs + v)/(ft*n)) - XO)/(XT*(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO))) + mpm.sqrt(ikf/(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO)))*(mpm.exp((-i*rs + v)/(ft*n)) - XO),
                         iss**XT*mpm.sqrt(ikf/(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO)))*(-i*rs + v)*(mpm.exp((-i*rs + v)/(ft*n)) - XO)*mpm.exp((-i*rs + v)/(ft*n))/(XT*ft*n**XT*(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO))) - iss*mpm.sqrt(ikf/(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO)))*(-i*rs + v)*mpm.exp((-i*rs + v)/(ft*n))/(ft*n**XT),
                        iss*mpm.sqrt(ikf/(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO)))*(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO))*(-ikf/(XT*(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO))**XT) + XO/(XT*(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO))))*(mpm.exp((-i*rs + v)/(ft*n)) - XO)/ikf,
                         ((XO - (-i*rs + v)/vj)**XT + XF)**(m/XT)*(mpm.exp((-i*rs + v)/(ft*nr)) - XO),
                         -isr*(-i*rs + v)*((XO - (-i*rs + v)/vj)**XT + XF)**(m/XT)*mpm.exp((-i*rs + v)/(ft*nr))/(ft*nr**XT),
                        isr*m*(XO - (-i*rs + v)/vj)*(-i*rs + v)*((XO - (-i*rs + v)/vj)**XT + XF)**(m/XT)*(mpm.exp((-i*rs + v)/(ft*nr)) - XO)/(vj**XT*((XO - (-i*rs + v)/vj)**XT + XF)),
                         isr*((XO - (-i*rs + v)/vj)**XT + XF)**(m/XT)*(mpm.exp((-i*rs + v)/(ft*nr)) - XO)*mpm.log((XO - (-i*rs + v)/vj)**XT + XF)/XT,
                         i*iss**XT*mpm.sqrt(ikf/(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO)))*(mpm.exp((-i*rs + v)/(ft*n)) - XO)*mpm.exp((-i*rs + v)/(ft*n))/(XT*ft*n*(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO))) - i*iss*mpm.sqrt(ikf/(ikf + iss*(mpm.exp((-i*rs + v)/(ft*n)) - XO)))*mpm.exp((-i*rs + v)/(ft*n))/(ft*n)+ \
                         i*isr*m*(XO - (-i*rs + v)/vj)*((XO - (-i*rs + v)/vj)**XT + XF)**(m/XT)*(mpm.exp((-i*rs + v)/(ft*nr)) - XO)/(vj*((XO - (-i*rs + v)/vj)**XT + XF)) - i*isr*((XO - (-i*rs + v)/vj)**XT + XF)**(m/XT)*mpm.exp((-i*rs + v)/(ft*nr))/(ft*nr)
                        ]])
Beispiel #4
0
def getNthNonagonalOctagonalNumber( n ):
    sqrt6 = sqrt( 6 )
    sqrt7 = sqrt( 7 )

    return nint( floor( fdiv( fmul( fsub( fmul( 11, sqrt7 ), fmul( 9, sqrt6 ) ),
                                    power( fadd( sqrt6, sqrt7 ), fsub( fmul( 8, real_int( n ) ), 5 ) ) ),
                              672 ) ) )
 def __cubic_roots(self,a,c,d):
     from mpmath import mpf, mpc, sqrt, cbrt
     assert(all([isinstance(_,mpf) for _ in [a,c,d]]))
     Delta = -4 * a * c*c*c - 27 * a*a * d*d
     self.__Delta = Delta
     # NOTE: this was the original function used for root finding.
     # proots, err = polyroots([a,0,c,d],error=True,maxsteps=5000000)
     # Computation of the cubic roots.
     u_list = [mpf(1),mpc(-1,sqrt(3))/2,mpc(-1,-sqrt(3))/2]
     Delta0 = -3 * a * c
     Delta1 = 27 * a * a * d
     # Here we have two choices for the value from sqrt, positive or negative. Since C
     # is used as a denominator below, we pick the choice with the greatest absolute value.
     # http://en.wikipedia.org/wiki/Cubic_function
     # This should handle the case g2 = 0 gracefully.
     C1 = cbrt((Delta1 + sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) / 2)
     C2 = cbrt((Delta1 - sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) / 2)
     if abs(C1) > abs(C2):
         C = C1
     else:
         C = C2
     proots = [(-1 / (3 * a)) * (u * C + Delta0 / (u * C)) for u in u_list]
     # NOTE: we ignore any residual imaginary part that we know must come from numerical artefacts.
     if Delta < 0:
         # Sort the roots following the convention: complex with negative imaginary, real, complex with positive imaginary.
         # Then assign the roots following the P convention (e2 real root, e1 complex with positive imaginary).
         e3,e2,e1 = sorted(proots,key = lambda c: c.imag)
     else:
         # The convention in this case is to sort in descending order.
         e1,e2,e3 = sorted([_.real for _ in proots],reverse = True)
     return e1,e2,e3
Beispiel #6
0
    def gamma_shot(self, wrel, l, n, t, k, tc):
        """
        Calculate 
        1, transfer gain
        2, electron shot noise
        
        """
        if wrel > 1.0 and wrel < 1.1:
            mp.mp.dps = 40
        else:
            mp.mp.dps = 20
        wc = wrel * mp.sqrt(1+n)
        za_val = self.za(wrel, l, n, t, k, tc)
        mp.mp.dps = 15
        zr_val = self.zr(wc, l, tc)

        # below calculating shot noise:
        ldc = self.ant_len/l
        nc  =permittivity * boltzmann * tc/ ldc**2 / echarge**2
        vtc = np.sqrt(2 * boltzmann * tc/ emass)
        ne = nc * vtc * (1 + n * mp.sqrt(t)) * 2 * np.pi * self.ant_rad * self.ant_len / np.sqrt(4 * np.pi)
        ###################################
        ## a: coefficient in shot noise. ##
        ###################################
        scpot= 4
        a = 1 + echarge * scpot / boltzmann/tc
        shot_noise = 2 * a * echarge**2 * mp.fabs(za_val)**2 * ne        
        return [mp.fabs((zr_val+za_val)/zr_val)**2, shot_noise]
Beispiel #7
0
def resolver_equacao(a, b, c):
    u'''
    Resolve uma equação do segundo grau.
    '''
    a, b, c = mpf(a), mpf(b), mpf(c)
    d = b ** 2 - 4 * a * c
    return ( (-b+sqrt(d))/(2*a), (-b-sqrt(d))/(2*a) )
Beispiel #8
0
def fermihalf(x, sgn):
    """ Series approximation to the F_{1/2}(x) or F_{-1/2}(x) 
        Fermi-Dirac integral """

    f = lambda k: mp.sqrt(x ** 2 + np.pi ** 2 * (2 * k - 1) ** 2)

    # if x < -100:
    #    return 0.0
    if x < -9 or True:
        if sgn > 0:
            return mp.exp(x)
        else:
            return mp.exp(x)

    if sgn > 0:  # F_{1/2}(x)
        a = np.array((1.0 / 770751818298, -1.0 / 3574503105, -13.0 / 184757992,
                      85.0 / 3603084, 3923.0 / 220484, 74141.0 / 8289, -5990294.0 / 7995))
        g = lambda k: mp.sqrt(f(k) - x)

    else:  # F_{-1/2}(x)
        a = np.array((-1.0 / 128458636383, -1.0 / 714900621, -1.0 / 3553038,
                      27.0 / 381503, 3923.0 / 110242, 8220.0 / 919))
        g = lambda k: -0.5 * mp.sqrt(f(k) - x) / f(k)

    F = np.polyval(a, x) + 2 * np.sqrt(2 * np.pi) * sum(map(g, range(1, 21)))
    return F
Beispiel #9
0
def getRobbinsConstant( ):
    robbins = fsub( fsub( fadd( 4, fmul( 17, sqrt( 2 ) ) ), fmul( 6, sqrt( 3 ) ) ), fmul( 7, pi ) )
    robbins = fdiv( robbins, 105 )
    robbins = fadd( robbins, fdiv( log( fadd( 1, sqrt( 2 ) ) ), 5 ) )
    robbins = fadd( robbins, fdiv( fmul( 2, log( fadd( 2, sqrt( 3 ) ) ) ), 5 ) )

    return robbins
	def __compute_roots(self,a,c,d):
		from mpmath import mpf, mpc, sqrt, cbrt
		assert(all([isinstance(_,mpf) for _ in [a,c,d]]))
		Delta = self.__Delta
		# NOTE: this was the original function used for root finding.
		# proots, err = polyroots([a,0,c,d],error=True,maxsteps=5000000)
		# Computation of the cubic roots.
		# TODO special casing.
		u_list = [mpf(1),mpc(-1,sqrt(3))/2,mpc(-1,-sqrt(3))/2]
		Delta0 = -3 * a * c
		Delta1 = 27 * a * a * d
		C1 = cbrt((Delta1 + sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) / 2)
		C2 = cbrt((Delta1 - sqrt(Delta1 * Delta1 - 4 * Delta0 * Delta0 * Delta0)) / 2)
		if abs(C1) > abs(C2):
			C = C1
		else:
			C = C2
		proots = [(-1 / (3 * a)) * (u * C + Delta0 / (u * C)) for u in u_list]
		# NOTE: we ignore any residual imaginary part that we know must come from numerical artefacts.
		if Delta < 0:
			# Sort the roots following the convention: complex with negative imaginary, real, complex with positive imaginary.
			# Then assign the roots following the P convention (e2 real root, e1 complex with positive imaginary).
			e3,e2,e1 = sorted(proots,key = lambda c: c.imag)
		else:
			# The convention in this case is to sort in descending order.
			e1,e2,e3 = sorted([_.real for _ in proots],reverse = True)
		return e1,e2,e3
	def __compute_t_r(self,n_lobes,lobe_idx,H_in,Hr,d_eval,p4roots,lead_cf):
		from pyranha import math
		from mpmath import asin, sqrt, ellipf, mpf
		assert(n_lobes == 1 or n_lobes == 2)
		C = -lead_cf
		assert(C > 0)
		# First determine if we are integrating in the upper or lower plane.
		# NOTE: we don't care about eps, we are only interested in the sign.
		if (self.__F1 * math.sin(pt('h_\\ast'))).trim().evaluate(d_eval) > 0:
			sign = 1
		else:
			sign = -1
		if n_lobes == 2:
			assert(lobe_idx == 0 or lobe_idx == 1)
			r0,r1,r2,r3 = p4roots
			# k is the same in both cases.
			k = sqrt(((r3-r2)*(r1-r0))/((r3-r1)*(r2-r0)))
			if lobe_idx == 0:
				assert(Hr == r0)
				phi = asin(sqrt(((r3-r1)*(H_in-r0))/((r1-r0)*(r3-H_in))))
			else:
				assert(Hr == r2)
				phi = asin(sqrt(((r3-r1)*(H_in-r2))/((H_in-r1)*(r3-r2))))
			return -sign * mpf(2) / sqrt(C * (r3 - r1) * (r2 - r0)) * ellipf(phi,k**2)
		else:
			# TODO: single lobe case.
			assert(False)
			pass
Beispiel #12
0
    def gamma_shot(self, wrel, l, n, t, tc):
        """
        Calculate 
        1, transfer gain
        2, electron shot noise
        
        """
        if wrel > 1.0 and wrel < 1.2:
            mp.mp.dps = 80
        else:
            mp.mp.dps = 40
        wc = wrel * mp.sqrt(1+n)
        za = self.za_l(wc, l, n, t, tc)
        mp.mp.dps = 15
        zr = self.zr_mp(wc, l, tc)

        # below calculating shot noise:
        ldc = self.ant_len/l
        nc  =permittivity * boltzmann * tc/ ldc**2 / echarge**2
        vtc = np.sqrt(2 * boltzmann * tc/ emass)
        ne = nc * vtc * (1 + n * mp.sqrt(t)) * 2 * np.pi * self.ant_rad * self.ant_len / np.sqrt(4 * np.pi)
        ###################
        ## a: coefficient in shot noise. see Issautier et al. 1999
        ###################
        a = 1 + echarge * 3.6 / boltzmann/tc
        shot_noise = 2 * a * echarge**2 * mp.fabs(za)**2 * ne        
        return [mp.fabs((zr+za)/zr)**2, shot_noise]
	def P(self,z):
		# A+S 18.9.
		from mpmath import sqrt, mpc, sin, ellipfun, mpf
		Delta = self.Delta
		e1, e2, e3 = self.__roots
		if self.__ng3:
			z = mpc(0,1) * z
		if Delta > 0:
			zs = sqrt(e1 - e3) * z
			m = (e2 - e3) / (e1 - e3)
			retval = e3 + (e1 - e3) / ellipfun('sn',u=zs,m=m)**2
		elif Delta < 0:
			H2 = (sqrt((e2 - e3) * (e2 - e1))).real
			assert(H2 > 0)
			m = mpf(1) / mpf(2) - 3 * e2 / (4 * H2)
			zp = 2 * z * sqrt(H2)
			retval = e2 + H2 * (1 + ellipfun('cn',u=zp,m=m)) / (1 - ellipfun('cn',u=zp,m=m))
		else:
			g2, g3 = self.__invariants
			if g2 == 0 and g3 == 0:
				retval = 1 / (z**2)
			else:
				c = e1 / 2
				retval = -c + 3 * c / (sin(sqrt(3 * c) * z))**2
		if self.__ng3:
			return -retval
		else:
			return retval
	def __compute_periods(self):
		# A+S 18.9.
		from mpmath import sqrt, ellipk, mpc, pi, mpf
		Delta = self.Delta
		e1, e2, e3 = self.__roots
		if Delta > 0:
			m = (e2 - e3) / (e1 - e3)
			Km = ellipk(m)
			Kpm = ellipk(1 - m)
			om = Km / sqrt(e1 - e3)
			omp = mpc(0,1) * om * Kpm / Km
		elif Delta < 0:
			# NOTE: the expression in the sqrt has to be real and positive, as e1 and e3 are
			# complex conjugate and e2 is real.
			H2 = (sqrt((e2 - e3) * (e2 - e1))).real
			assert(H2 > 0)
			m = mpf(1) / mpf(2) - 3 * e2 / (4 * H2)
			Km = ellipk(m)
			Kpm = ellipk(1 - m)
			om2 = Km / sqrt(H2)
			om2p = mpc(0,1) * Kpm * om2 / Km
			om = (om2 - om2p) / 2
			omp = (om2 + om2p) / 2
		else:
			g2, g3 = self.__invariants
			if g2 == 0 and g3 == 0:
				om = mpf('+inf')
				omp = mpc(0,'+inf')
			else:
				# NOTE: here there is no need for the dichotomy on the sign of g3 because
				# we are already working in a regime in which g3 >= 0 by definition.
				c = e1 / 2
				om = 1 / sqrt(12 * c) * pi()
				omp = mpc(0,'+inf')
		return 2 * om, 2 * omp
Beispiel #15
0
def BSLaplace(S,K,T,t,r,sig,N,phi): 
        """Solving the Black Scholes PDE in the Laplace domain"""
        x   = ln(S/K)     
        r = mpf(r);sig = mpf(sig);T = mpf(T);t=mpf(t)
        S = mpf(S);K = mpf(K);x=mpf(x)
        mu  = r - 0.5*(sig**2)
       
        tau = T - t   
        c1 = mpf('0.5017')
        c2 = mpf('0.6407')
        c3 = mpf('0.6122')
        c4 = mpc('0','0.2645')        
        
        ans = 0.0
        h = 2*pi/N
        h = mpf(h)
        for k in range(N/2): # Use symmetry
            theta = -pi + (k+0.5)*h
            z     =  N/tau*(c1*theta/tan(c2*theta) - c3 + c4*theta)
            dz    =  N/tau*(-c1*c2*theta/(sin(c2*theta)**2) + c1/tan(c2*theta)+c4)
            eps1  =  (-mu + sqrt(mu**2 + 2*(sig**2)*(z+r)))/(sig**2)
            eps2  =  (-mu - sqrt(mu**2 + 2*(sig**2)*(z+r)))/(sig**2)
            b1    =  1/(eps1-eps2)*(eps2/(z+r) + (1 - eps2)/z)
            b2    =  1/(eps1-eps2)*(eps1/(z+r) + (1 - eps1)/z)
            ans  +=  exp(z*tau)*bs(x,b1,b2,eps1,eps2,z,r,phi)*dz
            val = (K*(h/(2j*pi)*ans)).real
           
            
        return 2*val
Beispiel #16
0
def find_Y_and_M(G,R,ndigs=12,Yset=None,Mset=None):
    r"""
    Compute a good value of M and Y for Maass forms on G

    INPUT:

    - ''G'' -- group
    - ''R'' -- real
    - ''ndigs'' -- integer (number of desired digits of precision)
    - ''Yset'' -- real (default None) if set we return M corr. to this Y
    - ''Mset'' -- integer (default None) if set we return Y corr. to this M

    OUTPUT:

    - [Y,M] -- good values of Y (real) and M (integer)

    EXAMPLES::

    

    TODO:
    Better and more effective bound
    """
    l=G._level
    if(Mset <> None):
        # then we get Y corr. to this M
        Y0=mpmath.sqrt(3.0)/mpmath.mpf(2*l)
        
    if(Yset==None):
        Y0=mpmath.sqrt(3.0)/mpmath.mpf(2*l)
        Y=mpmath.mpf(0.95*Y0)
    else:
        Y=Yset
    #print "Y=",Y,"Yset=",Yset
    IR=mpmath.mpc(0,R)
    eps=mpmath.mpf(10 **-ndigs)
    twopiY=mpmath.pi()*Y*mpmath.mpf(2)

    M0=get_M_for_maass(R,Y,eps) 
    if(M0<10):
        M0=10
    ## Do this in low precision
    dold=mpmath.mp.dps
    #print "Start M=",M0
    #print "dold=",dold
    #mpmath.mp.dps=100
    try:
        for n in range(M0,10000 ):
            X=mpmath.pi()*Y*mpmath.mpf(2 *n)
            #print "X,IR=",X,IR
            test=mpmath.fp.besselk(IR,X)
            if(abs(test)<eps):
                raise StopIteration()
    except StopIteration:
        M=n
    else:
        M=n
        raise Exception,"Error: Did not get small enough error:=M=%s gave err=%s" % (M,test)
    mpmath.mp.dps=dold
    return [Y,M]
Beispiel #17
0
 def mobility(self, z=1000, E=0, T=300, pn=None):
     if pn is None:
         Eg = self.band_gap(T, symbolic=False, electron_volts=False)
         # print Eg, self.__to_numeric(-Eg/(k*T)), mp.exp(self.__to_numeric(-Eg/(k*T)))
         pn = self.Nc(T, symbolic=False) * self.Nv(T, symbolic=False) * mp.exp(
             self.__to_numeric(-Eg / (k * T))) * 1e-12
         # print pn
     N = 0
     for dopant in self.dopants:
         N += dopant.concentration(z)
     N *= 1e-6
     # print N
     mobility = {'mobility_e': {'mu_L': 0, 'mu_I': 0, 'mu_ccs': 0, 'mu_tot': 0},
                 'mobility_h': {'mu_L': 0, 'mu_I': 0, 'mu_ccs': 0, 'mu_tot': 0}}
     for key in mobility.keys():
         mu_L = self.reference[key]['mu_L0'] * (T / 300.0) ** (-self.reference[key]['alpha'])
         mu_I = (self.reference[key]['A'] * (T ** (3 / 2)) / N) / (
         mp.log(1 + self.reference[key]['B'] * (T ** 2) / N) - self.reference[key]['B'] * (T ** 2) / (
         self.reference[key]['B'] * (T ** 2) + N))
         try:
             mu_ccs = (2e17 * (T ** (3 / 2)) / mp.sqrt(pn)) / (mp.log(1 + 8.28e8 * (T ** 2) * (pn ** (-1 / 3))))
             X = mp.sqrt(6 * mu_L * (mu_I + mu_ccs) / (mu_I * mu_ccs))
         except:
             mu_ccs = np.nan
             X = 0
         # print X
         mu_tot = mu_L * (1.025 / (1 + ((X / 1.68) ** (1.43))) - 0.025)
         Field_coeff = (1 + (mu_tot * E * 1e-2 / self.reference[key]['v_s']) ** self.reference[key]['beta']) ** (
         -1 / self.reference[key]['beta'])
         mobility[key]['mu_L'] = mu_L * 1e-4
         mobility[key]['mu_I'] = mu_I * 1e-4
         mobility[key]['mu_ccs'] = mu_ccs * 1e-4
         mobility[key]['mu_tot'] = mu_tot * 1e-4 * Field_coeff
     return mobility
Beispiel #18
0
 def bimax_integrand(self, z, wc, l, n, t):
     """
     Integrand of electron-noise integral.
     
     """
     return f1(wc*l/z/mp.sqrt(2)) * z * \
         (mp.exp(-z**2) + n/mp.sqrt(t)*mp.exp(-z**2 / t)) / \
         (mp.fabs(BiMax.d_l(z, wc, n, t))**2 * wc**2)
Beispiel #19
0
def eta(lam):
    """Function from DLMF 8.12.1 shifted to be centered at 0."""
    if lam > 0:
        return mp.sqrt(2*(lam - mp.log(lam + 1)))
    elif lam < 0:
        return -mp.sqrt(2*(lam - mp.log(lam + 1)))
    else:
        return 0
Beispiel #20
0
def fp(ne):
    """ 
    Return the plasma frequency. 
    ~ 8.98 * sqrt(ne)

    """
    
    return mp.sqrt(echarge**2/emass/permittivity)/2/mp.pi * mp.sqrt(ne)
Beispiel #21
0
def findCenteredPolygonalNumber( n, k ):
    if real_int( k ) < 3:
        raise ValueError( 'the number of sides of the polygon cannot be less than 3,' )

    s = fdiv( k, 2 )

    return nint( fdiv( fadd( sqrt( s ),
                       sqrt( fsum( [ fmul( 4, real( n ) ), s, -4 ] ) ) ), fmul( 2, sqrt( s ) ) ) )
Beispiel #22
0
def zk(z, k):
    """
    modified dispersion function for Kappa distribution.
    (Mace and Hellberg, 1995)
    
    """
    i = mp.mpc(0, 1)
    coeff = i * (k + 0.5) * (k-0.5) / (mp.sqrt(k**3) * (k+1))
    return coeff * hyp2f1(1, 2*k+2, k+2, (1-z/(i * mp.sqrt(k)))/2)
Beispiel #23
0
def getNthDecagonalNonagonalNumber( n ):
    dps = 8 * int( real_int( n ) )

    if mp.dps < dps:
        mp.dps = dps

    return nint( floor( fdiv( fmul( fadd( 15, fmul( 2, sqrt( 14 ) ) ),
                                    power( fadd( fmul( 2, sqrt( 2 ) ), sqrt( 7 ) ),
                                           fsub( fmul( 8, n ), 6 ) ) ), 448 ) ) )
Beispiel #24
0
def getNthNonagonalPentagonalNumber( n ):
    sqrt21 = sqrt( 21 )
    sign = power( -1, real_int( n ) )

    return nint( floor( fdiv( fprod( [ fadd( 25, fmul( 4, sqrt21 ) ),
                                       fsub( 5, fmul( sqrt21, sign ) ),
                                       power( fadd( fmul( 2, sqrt( 7 ) ), fmul( 3, sqrt( 3 ) ) ),
                                              fsub( fmul( 4, n ), 4 ) ) ] ),
                              336 ) ) )
Beispiel #25
0
def temp(t, x=mpf(1), Q=mpf(1), A=mpf(1), Ti=mpf(10)):
    u'''
    Definição da função temperatura temp = T(t, x)
    '''
    t = mpf(t)
    colchete1 = mpf(2) * sqrt(t*A/pi) * exp(-x**2/(t*4*A))
    colchete2 = x * erfc(x/( mpf(2) * sqrt(t*A)))
    
    return Ti + Q * (colchete1 - colchete2)
Beispiel #26
0
def getNthNonagonalTriangularNumber( n ):
    a = fmul( 3, sqrt( 7 ) )
    b = fadd( 8, a )
    c = fsub( 8, a )

    return nint( fsum( [ fdiv( 5, 14 ),
                         fmul( fdiv( 9, 28 ), fadd( power( b, real_int( n ) ), power( c, n ) ) ),
                         fprod( [ fdiv( 3, 28 ),
                                  sqrt( 7 ),
                                  fsub( power( b, n ), power( c, n ) ) ] ) ] ) )
Beispiel #27
0
def temp_t(t, x=mpf(1), Q=mpf(1), A=mpf(1), Ti=mpf(10)):
    u'''
    Definição da derivada da temperatura em relação ao tempo, temp_t = T_t(t, x)
    '''
    t = mpf(t)
    termo1 = sqrt(A/(t*pi)) * exp(-x**2/(t*4*A))
    termo2 = sqrt(A/(t*pi)) * (x**2/(t**2 * 2 * A)) * exp(-x**2/(t*4*A))
    termo3 = (x**2/(sqrt(t**3 * A) * 4)) * erfc_z(x / (mpf(2) * sqrt(t * A)))
    
    return Q * (termo1 + termo2 + termo3)
Beispiel #28
0
def ldeb(ne, te):
    """ 
    Return the Debye length.
    ne: electron density
    te: electron temperature
    SI units
    ~ 69.01 * sqrt(te/ne)

    """
    
    return mp.sqrt(permittivity * boltzmann/ echarge**2) * mp.sqrt(te/ne)
Beispiel #29
0
 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 obliquity(t):
			from mpmath import acos, cos, sqrt
			H = self.__H_time(t)
			hs = self.__hs_time(t)
			G = d_eval['G']
			Gt = d_eval['\\tilde{G}']
			Hts = d_eval['\\tilde{H}_\\ast']
			Gxy = sqrt(G**2-H**2)
			Gtxys = sqrt(Gt**2-(Hts-H)**2)
			retval = (Gxy*Gtxys*cos(hs)+H*(Hts-H))/(G*Gt)
			return acos(retval)
def mino_freqs_kerr(r1, r2, r3, r4, En, Lz, Q, aa, slr, ecc, x, M=1):
    """
    Mino frequencies for the Kerr case (aa != 0)

    Parameters:
        r1 (float): radial root
        r2 (float): radial root
        r3 (float): radial root
        r4 (float): radial root
        En (float): energy
        Lz (float): angular momentum
        Q (float): Carter constant
        aa (float): spin
        slr (float): semi-latus rectum
        ecc (float): eccentricity
        x (float): inclincation

    Keyword Args:
        M (float): mass

    Returns:
        ups_r (float): radial Mino frequency
        ups_theta (float): polar Mino frequency
        ups_phi (float): azimuthal Mino frequency
        gamma (float): time Mino frequency
    """
    # En, Lz, Q = calc_eq_constants(aa, slr, ecc)
    # r1, r2, r3, r4 = radial_roots(En, Q, aa, slr, ecc, M)
    pi = mp.pi
    L2 = Lz * Lz
    aa2 = aa * aa
    En2 = En * En
    M2 = M * M

    # polar pieces
    zm = 1 - x * x
    # a2zp = (L2 + aa2*(-1 + En2)*(-1 + zm))/((-1 + En2)*(-1 + zm))
    eps0zp = -((L2 + aa2 * (-1 + En2) * (-1 + zm)) / (L2 * (-1 + zm)))
    zmOverzp = (aa2 * (-1 + En2) * (-1 + zm) * zm) / (L2 + aa2 * (-1 + En2) *
                                                      (-1 + zm))

    kr = sqrt(((r1 - r2) * (r3 - r4)) / ((r1 - r3) * (r2 - r4)))
    ktheta = sqrt(zmOverzp)

    kr2 = kr * kr
    ktheta2 = ktheta * ktheta

    ellipticK_r = ellipk(kr2)
    ellipticK_theta = ellipk(ktheta2)

    rp = M + sqrt(M2 - aa2)
    rm = M - sqrt(M2 - aa2)
    hr = (r1 - r2) / (r1 - r3)
    hp = ((r1 - r2) * (r3 - rp)) / ((r1 - r3) * (r2 - rp))
    hm = ((r1 - r2) * (r3 - rm)) / ((r1 - r3) * (r2 - rm))

    ellipticPi_hmkr = ellippi(hm, kr2)
    ellipticPi_hpkr = ellippi(hp, kr2)
    ellipticPi_hrkr = ellippi(hr, kr2)
    ellipticPi_zmktheta = ellippi(zm, ktheta2)
    ellipticE_kr = ellipe(kr2)
    ellipticE_ktheta = ellipe(ktheta2)

    ups_r = (pi * sqrt((1 - En2) * (r1 - r3) * (r2 - r4))) / (2 * ellipticK_r)
    ups_theta = (sqrt(eps0zp) * Lz * pi) / (2.0 * ellipticK_theta)
    ups_phi = (2 * aa * ups_r * (-(
        ((-(aa * Lz) + 2 * En * M * rm) *
         (ellipticK_r - ((r2 - r3) * ellipticPi_hmkr) / (r2 - rm))) /
        (r3 - rm)) + (
            (-(aa * Lz) + 2 * En * M * rp) *
            (ellipticK_r - ((r2 - r3) * ellipticPi_hpkr) /
             (r2 - rp))) / (r3 - rp))) / (pi * sqrt(
                 (1 - En2) * (r1 - r3) * (r2 - r4)) * (-rm + rp)) + (
                     2 * ups_theta * ellipticPi_zmktheta) / (sqrt(eps0zp) * pi)
    gamma = (4 * En * M2 + (2 * En * ups_theta * (L2 + aa2 * (-1 + En2) *
                                                  (-1 + zm)) *
                            (-ellipticE_ktheta + ellipticK_theta)) /
             ((-1 + En2) * sqrt(eps0zp) * Lz * pi * (-1 + zm)) +
             (2 * ups_r *
              ((2 * M *
                (-(((-2 * aa2 * En * M + (-(aa * Lz) + 4 * En * M2) * rm) *
                    (ellipticK_r - ((r2 - r3) * ellipticPi_hmkr) /
                     (r2 - rm))) / (r3 - rm)) +
                 ((-2 * aa2 * En * M + (-(aa * Lz) + 4 * En * M2) * rp) *
                  (ellipticK_r - ((r2 - r3) * ellipticPi_hpkr) /
                   (r2 - rp))) / (r3 - rp))) / (-rm + rp) + 2 * En * M *
               (r3 * ellipticK_r + (r2 - r3) * ellipticPi_hrkr) +
               (En *
                ((r1 - r3) * (r2 - r4) * ellipticE_kr +
                 (-(r1 * r2) + r3 * (r1 + r2 + r3)) * ellipticK_r + (r2 - r3) *
                 (r1 + r2 + r3 + r4) * ellipticPi_hrkr)) / 2.0)) / (pi * sqrt(
                     (1 - En2) * (r1 - r3) * (r2 - r4))))

    return ups_r, ups_theta, ups_phi, gamma
Beispiel #32
0
def compute_g(n):
    """g_k from DLMF 5.11.3/5.11.5"""
    a = compute_a(2 * n)
    g = [mp.sqrt(2) * mp.rf(0.5, k) * a[2 * k] for k in range(n)]
    return g
Beispiel #33
0
def calc(r, t):
    return floor(1 + (.25 * (-3 - (2 * r) + sqrt(1 - (4 * r) + (4 * (r**2)) +
                                                 (8 * t)))))
Beispiel #34
0
def sph_kn_bessel(n, z):
    out = besselk(n + mpf(1) / 2, z) * sqrt(pi / (2 * z))
    return out
Beispiel #35
0
    def move(self, alpha, v, t):
        if alpha == 0:
            self.x1 += v * t
            self.x2 += v * t
            return
        reverse_alpha = False
        reverse_v = False
        alpha = mpmath.radians(alpha)
        if alpha < 0:
            alpha = -alpha
            reverse_alpha = True

        if v < 0:
            v = -v
            reverse_v = True

        R = self.l * mpmath.cot(alpha) + 0.5 * self.d  # outer radius
        r = self.l * mpmath.cot(alpha) - 0.5 * self.d  # inner radius
        w = v / R  # angular velocity
        beta = w * t  # angle that has been turned after the move viewed from the center of the circle
        assert (beta < mpmath.pi)  # make sure it still forms a triangle
        theta = 0.5 * beta  # the angle of deviation from the original orientation
        m = 2 * R * mpmath.sin(theta)  # displacement of outer rear wheel
        n = 2 * r * mpmath.sin(theta)  # displacement of inner rear wheel
        if not reverse_alpha and not reverse_v:
            delta_x1, delta_y1 = mpmath.cos(theta) * m, mpmath.sin(theta) * m
            delta_x2, delta_y2 = mpmath.cos(theta) * n, mpmath.sin(theta) * n
        elif reverse_alpha and not reverse_v:
            delta_x2, delta_y2 = mpmath.cos(theta) * m, -mpmath.sin(theta) * m
            delta_x1, delta_y1 = mpmath.cos(theta) * n, -mpmath.sin(theta) * n
        elif not reverse_alpha and reverse_v:
            delta_x1, delta_y1 = -mpmath.cos(theta) * m, mpmath.sin(theta) * m
            delta_x2, delta_y2 = -mpmath.cos(theta) * n, mpmath.sin(theta) * n
        else:
            delta_x2, delta_y2 = -mpmath.cos(theta) * m, -mpmath.sin(theta) * m
            delta_x1, delta_y1 = -mpmath.cos(theta) * n, -mpmath.sin(theta) * n

        delta_x1 = float(delta_x1)
        delta_y1 = float(delta_y1)
        delta_x2 = float(delta_x2)
        delta_y2 = float(delta_y2)

        # the current calculation is based on this relative reference system
        # we need to map this coordinate in the relative reference system back to the absolute system

        # use the dot product of the rear wheel line to find the rotation from the relative reference system to the absolute system
        if self.y1 != 0 or self.y2 != 10:  # no rotation is needed
            bottom = np.sqrt(((self.x2 - self.x1) * (self.x2 - self.x1) +
                              (self.y2 - self.y1) * (self.y2 - self.y1))) * 10
            top = (self.y2 - self.y1) * 10
            cosine_value = float(top / bottom)
            rotation = mpmath.acos(cosine_value)
            # print(rotation)
            if self.x1 < self.x2:  # since arccos does not give direction, we need to do a check here
                rotation = -rotation
            # let A be the linear transformation that maps a relative referenced coordinate to an absolute referenced coordinate
            A = np.asarray(
                [[float(mpmath.cos(rotation)),
                  float(-mpmath.sin(rotation))],
                 [float(mpmath.sin(rotation)),
                  float(mpmath.cos(rotation))]])
            # then we map delta_1 and delta_2 to the absolute reference system
            relative_delta_1 = np.asarray([delta_x1, delta_y1])
            relative_delta_2 = np.asarray([delta_x2, delta_y2])
            absolute_delta_1 = np.matmul(A, relative_delta_1)
            absolute_delta_2 = np.matmul(A, relative_delta_2)
            delta_x1 = absolute_delta_1[0]
            delta_y1 = absolute_delta_1[1]
            delta_x2 = absolute_delta_2[0]
            delta_y2 = absolute_delta_2[1]
        # make vector addition in the absolute reference system
        self.x1 += delta_x1
        self.x2 += delta_x2
        self.y1 += delta_y1
        self.y2 += delta_y2
        dist = mpmath.sqrt((self.x1 - self.x2) * (self.x1 - self.x2) +
                           (self.y2 - self.y1) * (self.y2 - self.y1))
        assert abs(dist - self.d) <= self.d * 1e-4
def radius(x, y, z):
    return mp.sqrt(mp.power(x, 2) + mp.power(y, 2) + mp.power(z, 2))
def f(x, y, z):
    x = mp.mpmathify(x)
    y = mp.mpmathify(y)
    z = mp.mpmathify(z)
	
    R = radius(x, y, z)

    # solving 0 division problem here

    if x == 0 and z == 0 or y == 0:
        part1 = mp.mpmathify(0)
    else:
        part1 = mp.mpf('0.5') * y * (mp.power(z, 2) - mp.power(x, 2)) * mp.asinh(y / (mp.sqrt(mp.power(x, 2) + mp.power(z, 2))))

    if x == 0 and y == 0 or z == 0:
        part2 = 0
    else:
        part2 = mp.mpf('0.5') * z * (mp.power(y, 2) - mp.power(x, 2)) * mp.asinh(z / (mp.sqrt(mp.power(x, 2) + mp.power(y, 2))))

    if x == 0 or y == 0 or z == 0:
        part3 = 0
    else:
        part3 = x * y * z * mp.atan((y * z) / (x * R))

    # solving 0 division problem here

    part4 = mp.mpf('1 / 6') * R * (2 * mp.power(x, 2) - mp.power(y, 2) - mp.power(z, 2))

    return mp.mpmathify(part1 + part2 - part3 + part4)
Beispiel #38
0
	return 0.5*mp.erfc(x/mp.sqrt(2))

 
snrlen = 13
snrdb = np.linspace(0,13,13)
simlen = int(1e5)
#Simulated BER declaration
err = []
#Analytical BER declaration
ber = []

#for SNR 0 to 10 dB
for i in range(0,snrlen):
	awgn = np.random.normal(0,1,simlen)
	snr = 10**(0.1*snrdb[i])
	rx = mp.sqrt(snr) + awgn
	err_ind = np.nonzero(rx < 0)#condition for a misinterpreted bit
	#calculating the total number of errors
	err_n = np.size(err_ind)
	#calcuating the simulated BER
	err.append(err_n/simlen)
	#calculating the analytical BER
	ber.append(qfunc(mp.sqrt(snr)))
	
plt.semilogy(snrdb.T,ber,label='AWGN theory')
plt.semilogy(snrdb.T,err,'o',label='Simulated')
plt.xlabel('SNR in dB')
plt.ylabel('$P_B$')
plt.legend()
plt.grid()
plt.show()
Beispiel #39
0
def qfunc(x):
	return 0.5*mp.erfc(x/mp.sqrt(2))
Beispiel #40
0
def pdf_gauss_mp(x, sigma, mean):
    return mp.mpf(1.) / mp.sqrt(mp.mpf("2.") * sigma**2 * mp.pi) * mp.exp(
        -(x - mean)**2 / (mp.mpf("2.") * sigma**2))
            shap = shap[18:68]

            for i in shap:
                xlist.append(i[0])
                ylist.append(i[1])
            forx = []
            fory = []
            for x in xlist:
                forx.append((x - centre_x)**2)
            for y in ylist:
                fory.append((y - centre_y)**2)
            listsum = [sum(x) for x in zip(forx, fory)]
            features = []
            for i in listsum:
                k = mpmath.sqrt(float(i))
                features.append(float(k))
            maxx = (max(features))
            final = []
            for i in features:
                if (i == 0.0):
                    continue
                F = i / maxx
                final.append(F)
            # print(final)
            numpy_array = np.array(final)
            # features_vector.append(numpy_array)
            for (x, y) in shap:
                cv2.circle(tasveer, (x, y), 1, (0, 0, 255), 2)
            cv2.circle(tasveer, (centre_x, centre_y), 1, (0, 0, 0), 5)
            # print(features_vector)
Beispiel #42
0
def pval(x):
    return float(1 - 0.5 * (1 + mpmath.erf(x / mpmath.sqrt(2))))
Beispiel #43
0
def _noncentral_chi_pdf(t, df, nc):
    res = mpmath.besseli(df / 2 - 1, mpmath.sqrt(nc * t))
    res *= mpmath.exp(-(t + nc) / 2) * (t / nc)**(df / 4 - 1 / 2) / 2
    return res
'''
Generate code from cartesian coordinates.
'''
import numpy
import mpmath
# set precision
mpmath.mp.dps = 15

# reference tet:
t0 = [-1, -1 / mpmath.sqrt(3), -1 / mpmath.sqrt(6)]
t1 = [+0, +2 / mpmath.sqrt(3), -1 / mpmath.sqrt(6)]
t2 = [+1, -1 / mpmath.sqrt(3), -1 / mpmath.sqrt(6)]
t3 = [+0, +0, 3 / mpmath.sqrt(6)]


def is_float(value):
    try:
        float(value)
        return True
    except ValueError:
        return False


# read data from file,
# e.g.,
# <https://people.sc.fsu.edu/~jburkardt/f_src/tetrahedron_arbq_rule/tetrahedron_arbq_rule.f90>
def read_data(filename, blocks='xyzw'):
    data = []
    current_block = None
    next_block = 0
    with open(filename) as f:
Beispiel #45
0
    def ub_psi_(self, a, b, x):

        return 1/mp.gamma(a) * \
               mp.sqrt(mp.power(2, a) * mp.power(x, -a) * mp.gamma(a) * mp.exp(x/2) * mp.expint(1 + a - b, x/2))
def safeHasSquareRoot(num):
    return mpmath.isint(mpmath.sqrt(num))
snrdb = np.linspace(0, 9, 10)
#Number of samples
simlen = int(1e5)
#Simulated BER declaration
err = []
#Analytical BER declaration
ber = []

#for SNR 0 to 10 dB
for i in range(0, snrlen):
    #Generating AWGN, 0 mean unit variance
    noise = np.random.normal(0, 1, simlen)
    #from dB to actual SNR
    snr = 10**(0.1 * snrdb[i])
    #Received symbol in baseband
    rx = mp.sqrt(snr) + noise
    #storing the index for the received symbol
    #in error
    err_ind = np.nonzero(rx < 0)
    #calculating the total number of errors
    err_n = np.size(err_ind)
    #calcuating the simulated BER
    err.append(err_n / simlen)
    #calculating the analytical BER
    ber.append(qfunc(mp.sqrt(snr)))

#plt.semilogy(snrdb.T,ber,label='Analysis')
plt.plot(snrdb.T, err)
plt.xlabel('SNR$\\left(\\frac{E_b}{N_0}\\right)$')
plt.ylabel('$P_e$')
plt.legend()
Beispiel #48
0
 def analytic_solution_helper(x, tau, x_0):
     result = float((1 - tau) * 1 / (x * mpmath.sqrt(tau)) *
                    mpmath.besseli(1, 2 * x / x_0 * mpmath.sqrt(tau)) *
                    mpmath.exp(-(1 + tau) * x / x_0))
     return result
Beispiel #49
0
def gauss_pdf(x):
	return 1/mp.sqrt(2*np.pi)*np.exp(-x**2/2.0)
    def get_frame(self):

        pickle_in = open("New_testing_dlib_normalized.pickle", "rb")

        model = pickle.load(pickle_in)
        while (self.video.isOpened()):
            self.frame += 1
            ret, frame = self.video.read()
            if ret is True:
                if self.frame % 5 == 0:
                    # print(str(self.frame)+" frame")
                    #ret, frame = self.video.read()
                    # if ret == True:
                    self.frame += 1
                    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                    file = open("Expressions.csv", "w")
                    face = detector(gray, 0)
                    # print("Number of Faces {}".format(len(face)))
                    my_list = []
                    count_interested = 0
                    count_bore = 0
                    count_neutral = 0
                    for (J, rect) in enumerate(face):
                        shap = predictor(frame, rect)
                        xlist = []
                        ylist = []
                        shap = face_utils.shape_to_np(shap)
                        Centre = (shap[30])
                        centre_x = Centre[0]
                        centre_y = Centre[1]
                        shap = shap[18:68]
                        for i in shap:
                            xlist.append(i[0])
                            ylist.append(i[1])
                        forx = []
                        fory = []
                        for x in xlist:
                            forx.append((x - centre_x)**2)
                        for y in ylist:
                            fory.append((y - centre_y)**2)
                        listsum = [sum(x) for x in zip(forx, fory)]
                        features = []
                        for i in listsum:
                            k = mpmath.sqrt(float(i))
                            features.append(float(k))
                        maxx = (max(features))
                        final = []
                        for i in features:
                            if (i == 0.0):
                                continue
                            F = i / maxx
                            final.append(F)
                        # print(final)
                        numpy_array = np.array(final)
                        prediction = model.predict([numpy_array])[0]
                        # print(prediction)
                        # print("done")
                        (x, y, w, h) = face_utils.rect_to_bb(rect)
                        cv2.rectangle(frame, (x, y), (x + w, y + h),
                                      (0, 0, 255), 2)
                        # display the image and the prediction
                        cv2.putText(frame, prediction, (x - 7, y - 6),
                                    cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0),
                                    2)
                        cv2.circle(frame, (centre_x, centre_y), 1, (0, 0, 0),
                                   10)
                        for (x, y) in shap:
                            cv2.circle(frame, (x, y), 1, (0, 0, 255), 2)
                            cv2.line(frame, (centre_x, centre_y), (x, y),
                                     (0, 255, 1))
                        cv2.waitKey(100)
                        if prediction == "INTERESTED":
                            count_interested += 1
                            # self.Expression.append(1)

                        elif prediction == "BORE":
                            count_bore += 1
                        else:
                            count_neutral += 1

                        ret, jpeg = cv2.imencode('.jpg', frame)
                        my_list.append(jpeg.tobytes)

                    if (count_interested > count_bore) and (count_interested >
                                                            count_neutral):
                        self.Expression.append(1)

                    elif (count_bore > count_interested) and (count_bore >
                                                              count_neutral):
                        self.Expression.append(-1)
                    else:
                        self.Expression.append(0)

                    with file:
                        writter = csv.writer(file)
                        writter.writerow(self.Expression)
                    return (my_list)
            else:
                break
Beispiel #51
0
def cse_simplify_and_evaluate_sympy_expressions(self):

    # If an empty variable dict is passed, return an empty dictionary
    if self.variable_dict == {}:
        return {}

    # Call expand_variable_dict
    expanded_variable_dict = expand_variable_dict(self.variable_dict)

    # Setting precision
    mp.dps = precision

    # Creating free_symbols_set, which stores all free symbols from all expressions.
    logging.debug(' Getting all free symbols...')
    free_symbols_set = set()
    for val in expanded_variable_dict.values():
        try:
            free_symbols_set = free_symbols_set | val.free_symbols
        except AttributeError:
            pass

    # Initializing free_symbols_dict
    free_symbols_dict = dict()

    logging.debug(' ...Setting each free symbol to a random value...')

    # Setting each variable in free_symbols_set to a random number in [0, 1) according to the hashed string
    # representation of each variable.
    for var in free_symbols_set:
        # Make sure M_PI is set to its correct value, pi
        if str(var) == "M_PI":
            free_symbols_dict[var] = mpf(pi)
        # Then make sure M_SQRT1_2 is set to its correct value, 1/sqrt(2)
        elif str(var) == "M_SQRT1_2":
            free_symbols_dict[var] = mpf(1/sqrt(2))
        # All other free variables are set to random numbers
        else:
            # Take the variable [var], turn it into a string, encode the string, hash the string using the md5
            # algorithm, turn the hash into a hex number, turn the hex number into an int, set the random seed to
            # that int. This ensures each variable gets a unique but consistent value.
            random.seed(int(hashlib.md5(str(var).encode()).hexdigest(), 16))
            # Store the random value in free_symbols_dict as a mpf
            free_symbols_dict[var] = mpf(random.random())
            # Warning: might slow Travis CI too much: logging.debug(' ...Setting '+str(var)+' to the random value: '+str(free_symbols_dict[var]))

    # Initialize calculated_dict and simplified_expression_dict
    calculated_dict = dict()
    simplified_expression_dict = dict()

    logging.debug(' ...Calculating values for each variable based on free symbols...')

    # Evaluating each expression using the values in var_dict
    for var, expression in expanded_variable_dict.items():
        # Using SymPy's cse algorithm to optimize our value substitution
        replaced, reduced = cse(expression, order='none')

        # Warning: might slow Travis CI too much: logging.debug(' var = '+str(var)+' |||| replaced = '+str(replaced))

        # Calculate our result_value
        result_value = calculate_value(free_symbols_dict, replaced, reduced)

        # Check if result_value is near-zero, and double checking if it should be zero
        if fabs(result_value) != mpf('0.0') and fabs(result_value) < 10 ** ((-2.0/3)*precision):
            logging.info("Found |result| (" + str(fabs(result_value)) + ") close to zero. "
                         "Checking if indeed it should be zero.")
            new_result_value = calculate_value(free_symbols_dict, replaced, reduced, precision_factor=2)
            if fabs(new_result_value) < 10 ** (-(4.0/3) * precision):
                logging.info("After re-evaluating with twice the digits of precision, |result| dropped to " +
                             str(new_result_value) + ". Setting value to zero")
                result_value = mpf('0.0')

        # Store result_value in calculated_dict
        calculated_dict[var] = result_value

    return calculated_dict
Beispiel #52
0
def sph_h2n_bessel(n, z):
    return hankel2(n + mpf(1) / 2, z) * sqrt(pi / (2 * z))
Beispiel #53
0
def sph_i2n_bessel(n, z):
    out = besseli(-n - mpf(1) / 2, z) * sqrt(pi / (2 * z))
    return out
Beispiel #54
0
def sph_jn_bessel(n, z):
    out = besselj(n + mpf(1) / 2, z) * sqrt(pi / (2 * z))
    if mpmathify(z).imag == 0:
        return out.real  # Small imaginary parts are spurious
    else:
        return out
Beispiel #55
0
def sph_i1n_bessel(n, z):
    out = besseli(n + mpf(1) / 2, z) * sqrt(pi / (2 * z))
    if mpmathify(z).imag == 0:
        return out.real
    else:
        return out