Example #1
0
def e_ratio(a, b, e, x):
    # Get S
    bt2 = mp.beta(a, b - 1.0)  # Beta function
    bix = mp.betainc(a, b + 1.0, 0.0, e)  # Incomplete Beta function
    hf = mp.hyp2f1(1.0, a, a + b - 1.0,
                   -1.0)  # 2F1, Gauss' hypergeometric function
    hfre = mp.re(hf)
    Sval = bix - x * bt2 * hfre
    # Get U
    c1 = mp.mpc(1.0 + a)
    c2 = mp.mpc(-b)
    c3 = mp.mpc(1.0)
    c4 = mp.mpc(2.0 + a)
    Uval = mp.appellf1(c1, c2, c3, c4, e, -e)
    Ure = mp.re(Uval)
    # Get P & Q
    Pval = mp.hyp2f1(a + 1.0, 1.0 - b, a + 2.0,
                     e)  # 2F1, Gauss' hypergeometric function
    Pre = mp.re(Pval)
    Qval = mp.hyp2f1(a + 1.0, 2.0 - b, a + 2.0,
                     e)  # 2F1, Gauss' hypergeometric function
    Qre = mp.re(Qval)
    # Get T
    Tval = ((e**(1.0 + a)) / (1.0 + a)) * (3.0 * Pre + 2.0 * Qre - Ure)
    Tval = Tval + 4.0 * Sval
    # Get Rval (ratio)
    Rval = 0.25 * (1.0 - e * e) * (
        (1.0 - e)**(1.0 - b)) * (e**(1.0 - a)) * Tval
    return Rval
Example #2
0
def e_ratio(a,b,e,x):
  # Get S
  bt2 = mp.beta(a,b-1.0)             # Beta function
  bix = mp.betainc(a,b+1.0,0.0,e)    # Incomplete Beta function
  hf = mp.hyp2f1(1.0,a,a+b-1.0,-1.0) # 2F1, Gauss' hypergeometric function
  hfre = mp.re(hf)
  Sval = bix - x*bt2*hfre
  # Get U
  c1 = mp.mpc(1.0 + a)
  c2 = mp.mpc(-b)
  c3 = mp.mpc(1.0)
  c4 = mp.mpc(2.0 + a)
  Uval = mp.appellf1(c1,c2,c3,c4,e,-e)
  Ure = mp.re(Uval)
  # Get P & Q
  Pval = mp.hyp2f1(a+1.0,1.0-b,a+2.0,e) # 2F1, Gauss' hypergeometric function
  Pre = mp.re(Pval)
  Qval = mp.hyp2f1(a+1.0,2.0-b,a+2.0,e) # 2F1, Gauss' hypergeometric function
  Qre = mp.re(Qval)
  # Get T
  Tval = ( (e**(1.0+a)) / (1.0+a) )*( 3.0*Pre + 2.0*Qre - Ure )
  Tval = Tval + 4.0*Sval
  # Get Rval (ratio)
  Rval = 0.25*(1.0-e*e)*( (1.0-e)**(1.0-b) )*( e**(1.0-a) )*Tval
  return Rval
Example #3
0
def next_upper_bracket(t, z_function):

	current_sign = np.sign( mp.re( z_function(t) ) )
	next_sign = current_sign

	while current_sign == next_sign:
		t += 1
		next_sign = np.sign( mp.re( z_function(t) ) )

	return t
Example #4
0
def one_side(x,y):
    m = ((-1 + x)*(1 + y))/((1 + x)*(-1 + y))
    k = sqrt(m)
    u = asin(1/k)
    EE = ellipe(m)
    EF = re(ellipf(u,m))
    n = (-1 + x)/(-1 + y)
    EPI = ellippi(n/m,1/m)/k
    #EPI = ellippi(n,u,m)
    return re(-(EE*(1 + x)*(-1 + y) + (x - y)*(EF + EPI*(x-y) + EF*y))/sqrt(((1 + x)*(1 - y))))
def v(x,t,s,b):
    """
    inverse map of w(v) = x+i\tau --> x-t.
    """
    # c is atrificial parameter for findroot.
    c = 10**(-9)
    if x>b:
        return j*mp.findroot(lambda y: re(w(j*y,s,b)-(x-t)), [-s/2+c,0-c],"bisect")
    elif x<-b:
        return j*mp.findroot(lambda y: re(w(j*y,s,b)-(x-t)), [0+c,s/2-c],"bisect")
    else:
        return 1/2+j*mp.findroot(lambda y: re(w(1/2+j*y,s,b)-(x-t)), 0)
Example #6
0
def alpha(z, x, beta):
    """
    Eq. (A4) from Ref[1]
    Note that 'x' here corresponds to 'chi = x/rho', 
    and 'z' here corresponds to 'xi = z/2/rho' in the paper. 
    """
    arg1 = sqrt(2 * fabs(m(z, x, beta)))
    arg2 = -2 * (m(z, x, beta) + nu(x, beta))
    arg3 = 2 * eta(z, x, beta) / arg1

    if z < 0:
        return re(1 / 2 * (-arg1 + sqrt(fabs(arg2 + arg3))))
    else:
        return re(1 / 2 * (arg1 + sqrt(fabs(arg2 - arg3))))
def FDoubleDisc(x1,x2,t,s,b):
    """
    inside of log() for disconnected HEE.
    We take single interval subsystem A=[x1,x2].
    This has very complicated minimizasion because the configuration of boundary surface Q
    varys by Hawking-Page transition.
    """
    v1 = v(x1,t,s,b)
    v2 = v(x2,t,s,b)
    vb1 = vb(x1,t,s,b)
    vb2 = vb(x2,t,s,b)
    h1 = v1-vb1
    hp1 = h1+j*s/2
    hm1 = h1-j*s/2
    h2 = v2-vb2
    hp2 = h2+j*s/2
    hm2 = h2-j*s/2
    F = (pi**(-4))*Dw(v1,s,b)*(-Dw(-vb1,s,b))*Dw(v2,s,b)*(-Dw(-vb2,s,b))
    if s<1:
        g1 = min([re(sinh(pi*hp1/s)**2),re(sinh(pi*hm1/s)**2)])
        g2 = min([re(sinh(pi*hp2/s)**2),re(sinh(pi*hm2/s)**2)])
        return F * (s**4)*g1*g2
    else:
        m1 = (sin(pi*hp1)*sin(pi*hp2))**2
        m2 = ((sin(pi*hp1)*sin(pi*hm2))**2)*exp(2*pi*s)
        m3 = ((sin(pi*hm1)*sin(pi*hp2))**2)*exp(2*pi*s)
        m4 = (sin(pi*hm1)*sin(pi*hm2))**2
        return F * min([re(m1),re(m2),re(m3),re(m4)])
Example #8
0
def S_single_hol(x1, x2, t, a):
    t1, t2, tb1, tb2 = theta(x1, t, a), theta(x2, t,
                                              a), thetaB(x1, t,
                                                         a), thetaB(x2, t, a)
    z1, z2, zb1, zb2 = j * exp(j * t1), j * exp(j * t2), j * exp(
        -j * tb1), j * exp(-j * tb2)

    deriv = a**2 / (exp(j * (t1 - tb1 + t2 - tb2) / 2) * cos(t1) * cos(t2) *
                    cos(tb1) * cos(tb2))
    conn = (z1 - z2) * (zb1 - zb2)
    disconn = (z1 - zb1) * (z2 - zb2)

    return min([re(log(deriv * conn)),
                re(log(deriv * disconn))]) / 6 - log((x2 - x1)**2) / 6
Example #9
0
def v(x, t, s, b):
    # c is atrificial parameter for findroot.
    c = 10**(-10)
    if x > b:
        return j * mp.findroot(lambda y: re(w(j * y, s, b) - (x - t)),
                               [-s / 2 + c, 0 - c], "bisect")
    elif x < -b:
        return j * mp.findroot(lambda y: re(w(j * y, s, b) - (x - t)),
                               [0 + c, s / 2 - c], "bisect")
    else:
        tolerant = 10**(-20)
        normparam = 10**11
        return 1 / 2 + j * mp.findroot(
            lambda y: tanh(re(w(1 / 2 + j * y, s, b) - (x - t)) / normparam),
            0,
            tol=tolerant)
Example #10
0
    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
Example #11
0
def mp_get_Psca_from_expansion(k, R, dist, zeta):
    csqrs = []
    rhos = []
    lbda = mp_get_lagrange_mul_from_expansion(k, R, dist, zeta, csqrs, rhos)

    limit = len(csqrs)
    print(limit)
    print(lbda)
    i = 0
    lhs = mpmath.mpf(0.0)
    rhs = lhs
    oldlhs = lhs
    oldrhs = rhs
    tol = 1e-6
    while (i < limit):
        if (i == len(csqrs)):  #here the l quantum number is i+1
            cNl = mp_get_normalized_RgNl0_coeff_for_zdipole_field(
                k, R, dist, i + 1)
            csqrs.append(mpmath.re(mpmath.conj(cNl) * cNl))
            rhos.append(mp_rho_N(i + 1, k * R))

        denom = 1.0 + lbda * zeta * rhos[i]
        lhs += zeta * csqrs[i] * (1.0 + lbda) * (
            1.0 + 2 * zeta * rhos[i] * lbda) / 4 / denom**2
        rhs += zeta * csqrs[i] * (1.0 + lbda) * lbda / 4 / denom**2

        i += 1
        if (i == limit) and ((lhs - oldlhs) > tol * lhs or
                             (rhs - oldrhs) > tol * rhs):
            limit = int(np.ceil(limit * 1.2))
            oldlhs = lhs
            oldrhs = rhs

    return 0.5 * k * (lhs - rhs)
Example #12
0
def loop():
    global a, listindex, pointer, loopdict
    realpart = mpmath.re(a[listindex])
    impart = mpmath.im(a[listindex])
    if mpmath.workdps(mpmath.mp.dps * 3 / 4)(
            mpmath.chop)(realpart - impart) > 0:
        pointer = loopdict[pointer]
Example #13
0
def getNthKFibonacciNumber( n, k ):
    if real( n ) < 0:
        raise ValueError( 'non-negative argument expected' )

    if real( k ) < 2:
        raise ValueError( 'argument <= 2 expected' )

    if n < k - 1:
        return 0

    nth = int( n ) + 4

    precision = int( fdiv( fmul( n, k ), 8 ) )

    if ( mp.dps < precision ):
        mp.dps = precision

    poly = [ 1 ]
    poly.extend( [ -1 ] * int( k ) )

    roots = polyroots( poly )
    nthPoly = getNthFibonacciPolynomial( k )

    result = 0
    exponent = fsum( [ nth, fneg( k ), -2 ] )

    for i in range( 0, int( k ) ):
        result += fdiv( power( roots[ i ], exponent ), polyval( nthPoly, roots[ i ] ) )

    return floor( fadd( re( result ), fdiv( 1, 2 ) ) )
Example #14
0
def write_g_im(filename, e, sigma):
    nlines = len(e)
    with open(filename, 'w') as f:
        for iw in range(0, nlines):
            s = '{0:18.8f}{1:18.12f}{2:18.12f}\n'. \
                format(float(im(e[iw])), float(re(sigma[iw])), float(im(sigma[iw])))
            f.write(s)
Example #15
0
def F1_cubic(hstar,kappa):
    '''
    F1 function corresponding to a cubic viscosity profile (Nieuwstadt 1983)

    Parameters
    ----------
    hstar: float
        Non-dimensional boundary-layer height
        hstar = h*fc/utau
    kappa: float
        Von Karman constant

    Returns
    -------
    F1: float
        Value of F1 function
    '''
    C = hstar/kappa
    alpha = 0.5+0.5*np.sqrt(1+4j*C)
    F1 = np.zeros((1),dtype=np.float64)
    F1[0] = 1./kappa*(-np.log(hstar)+
                      mpmath.re( mpmath.digamma(alpha+1)+
                                 mpmath.digamma(alpha-1)-
                                 2*mpmath.digamma(1.0) ) )
    return np.asscalar(F1)
Example #16
0
def end():
    global a, listindex, pointer, loopdict
    realpart = mpmath.re(a[listindex])
    impart = mpmath.im(a[listindex])
    if mpmath.workdps(mpmath.mp.dps * 3 / 4)(
            mpmath.chop)(realpart - impart) <= 0:
        pointer = next(key for key, value in loopdict.items()
                       if value == pointer)
Example #17
0
 def generate(c, num_iterations=200):
     orbit_re = []
     orbit_im = []
     z = mpmath.mpc(real='0.0', imag='0.0')
     for _ in range(num_iterations):
         z = mpmath.fadd(mpmath.fmul(z, z), c)
         orbit_re.append(mpmath.nstr(mpmath.re(z)))
         orbit_im.append(mpmath.nstr(mpmath.im(z)))
     return [orbit_re, orbit_im]
Example #18
0
def get_moments(coef):
    # returns moments of function calculated from coefficients of Pade decomposition
    n = len(coef) / 2
    # for i in range(0, n):
    #     p[i] = coef[i]
    #     q[i] = coef[i + n]
    # m[0] = re(p[n - 1])
    # m[1] = re(p[n - 2] - m[0] * q[n - 1])
    # m[2] = re(p[n - 3] - p[n - 1] * q[n - 2] - (p[n - 2] - p[n - 1] * q[n - 1]) * q[n - 1])

    m = [1025.615, 2025.615, 3025.615]
    m[0] = float(re(coef[n - 1]))
    m[1] = float(re(coef[n - 2] - coef[n - 1] * coef[2 * n - 1]))
    m[2] = float(
        re(coef[n - 3] - coef[n - 1] * coef[2 * n - 2] -
           (coef[n - 2] - coef[n - 1] * coef[2 * n - 1]) * coef[2 * n - 1]))
    # m[1] = float(re(coef[n-2] - m[0] * coef[2*n-1]))

    return m
Example #19
0
def formatOutput( output ):
    # filter out text strings
    for c in output:
        if c in '+-.':
            continue

        # anything with embedded whitespace is a string
        if c in string.whitespace or c in string.punctuation:
            return output

    #print( )
    #print( 'formatOutput 1:', output )

    # override settings with temporary settings if needed
    # if g.tempCommaMode:
    #     comma = True
    # else:
    #     comma = g.comma

    # output settings, which may be overrided by temp settings
    outputRadix = g.outputRadix
    integerGrouping = g.integerGrouping
    leadingZero = g.leadingZero

    if g.tempHexMode:
        integerGrouping = 4
        leadingZero = True
        outputRadix = 16

    if g.tempLeadingZeroMode:
        leadingZero = True

    if g.tempOctalMode:
        integerGrouping = 3
        leadingZero = True
        outputRadix = 8

    mpOutput = mpmathify( output )

    imaginary = im( mpOutput )
    real = re( mpOutput )

    result, negative = formatNumber( real, outputRadix, leadingZero, integerGrouping )

    if negative:
        result = '-' + result

    if imaginary != 0:
        strImaginary, negativeImaginary = formatNumber( imaginary, outputRadix, leadingZero )
        result = '( ' + result + ( ' - ' if negativeImaginary else ' + ' ) + strImaginary + 'j )'

    #print( 'formatOutput 2:', output )
    #print( )

    return result
Example #20
0
def formatOutput( output ):
    # filter out text strings
    for c in output:
        if c in '+-.':
            continue

        # anything with embedded whitespace is a string
        if c in string.whitespace or c in string.punctuation:
            return output

    # output settings, which may be overrided by temp settings
    outputRadix = g.outputRadix
    integerGrouping = g.integerGrouping
    leadingZero = g.leadingZero
    integerDelimiter = g.integerDelimiter

    # override settings with temporary settings if needed
    if g.tempCommaMode:
        integerGrouping = 3     # override whatever was set on the command-line
        leadingZero = False     # this one, too
        integerDelimiter = ','

    if g.tempHexMode:
        integerGrouping = 4
        leadingZero = True
        outputRadix = 16

    if g.tempLeadingZeroMode:
        leadingZero = True

    if g.tempOctalMode:
        integerGrouping = 3
        leadingZero = True
        outputRadix = 8

    mpOutput = mpmathify( output )

    imaginary = im( mpOutput )
    real = re( mpOutput )

    result, negative = formatNumber( real, outputRadix, leadingZero, integerGrouping,
                                     integerDelimiter, g.decimalDelimiter )

    if negative:
        result = '-' + result

    if imaginary != 0:
        strImaginary, negativeImaginary = \
            formatNumber( imaginary, outputRadix, leadingZero, integerGrouping, integerDelimiter, g.DecimalDelimiter )
        result = '( ' + result + ( ' - ' if negativeImaginary else ' + ' ) + strImaginary + 'j )'

    #print( 'formatOutput 2:', output )
    #print( )

    return result
Example #21
0
def hilbert(d):
    '''
    Compute Hilbert Class Polynomial.
    Follows pseudo code from Algorithm 7.5.8
    Args:
        d: fundamental discriminant

    Returns:
        Hilbert class number, Hilbert class polynomial, and all reduced forms
    '''
    # initialize
    t = [1]
    b = d % 2
    r = floor(sqrt((-d)/3))
    h = 0
    red = set()

    reduced_forms = reduced_form(d)    # print h1
    a_inverse_sum = sum(1/mpf(form[0]) for form in reduced_forms)
    precision = round(pi*sqrt(-d)*a_inverse_sum / log(10)) + 10
    mpmath.mp.dps = precision

    # outer loop
    while b <= r:
        m = (b*b - d) / 4
        m_sqrt = int(floor(sqrt(m)))
        for a in range(1, m_sqrt+1):
            if m % a != 0:
                continue
            c = m/a
            if b > a:
                continue
            # optional polynomial setup
            tau = (-b + 1j * sqrt(-d)) / (2*a)
            f = power(dedekind_eta(2 * tau, precision) / dedekind_eta(tau, precision), 24)
            j = power((256 * f + 1), 3) / f

            if b==a or c==a or b==0:
                # T = T * (X-j)
                t = polynomial_mul(t, [-j, 1])
                h += 1
                red.add((a, b, c))
            else:
                poly = [j.real * j.real + j.imag * j.imag, -2 * j.real, 1]
                t = polynomial_mul(t, poly)
                h += 2
                red.add((a, b, c))
                red.add((a, -b, c))
        b += 2

    if red != reduced_forms:
        raise ValueError('Reduced form inconsistent.')

    return h, [int(floor(mpmath.re(p) + 0.5)) for p in t], red
def root_find_mp(func, x_loc, y_loc, step_size, points,
                 solver='halley', wordy=True, tol=1e-15):

    jump_limit = 0.1
    maxsteps = 200

    try:
        grad = ((points[-1, 1] - points[-2, 1]) +
                (points[-1, 1] - 2*points[-2, 1] + points[-3, 1])) * \
                np.abs(step_size/(points[-1, 0] - points[-2, 0]))
        root_mp = mp.findroot(func, points[-1, 1] + grad, solver, tol)
        root = float(mp.re(root_mp)) + 1j * float(mp.im(root_mp))
        if np.abs(root-points[-1, 1]) < 0.1:
            points = np.vstack([points, [x_loc, root]])
        else:
            raise ValueError('Jump of {:.5f} at x = {:.5f}, y = {:.5f}'.format(
                np.abs(root-points[-1, 1]), points[-1, 0], points[-1, 1]+grad))
        x_error = None

    except IndexError:
        if points.all() == 0:
            root_mp = mp.findroot(func, y_loc, solver, tol, maxsteps)
            root = float(mp.re(root_mp)) + 1j*float(mp.im(root_mp))
            points[0,] = x_loc, root
        elif points.shape == (1, 2):
            root_mp = mp.findroot(func, points[-1, 1], solver, tol, maxsteps)
            root = float(mp.re(root_mp)) + 1j*float(mp.im(root_mp))
            points = np.vstack([points, [x_loc, root]])
        elif points.shape == (2, 2):
            grad = (points[-1, 1] - points[-2, 1]) *\
                    np.abs(step_size/(points[-1, 0] - points[-2, 0]))
            root_mp = mp.findroot(func, points[-1, 1] + grad, solver, tol, maxsteps)
            root = float(mp.re(root_mp)) + 1j*float(mp.im(root_mp))
            if np.abs(root - points[-1, 1]) < jump_limit:
                points = np.vstack([points, [x_loc, root]])
            else:
                raise ValueError('Jump of {:.5f} at x = {:.5f}, y = {:.5f}'.format(
                    np.abs(root-points[-1, 1]), points[-1, 0], points[-1, 1]+grad))
        x_error = None

    return points, np.abs(step_size), x_error, x_loc
Example #23
0
def S_double_hol_conn(x1, x2, t, s, b):
    v1, v2, vb1, vb2 = v(x1, t, s, b), v(x2, t, s, b), vb(x1, t, s,
                                                          b), vb(x2, t, s, b)

    deriv = (pi**(-4)) * Dw(v1, s, b) * (-Dw(-vb1, s, b)) * Dw(
        v2, s, b) * (-Dw(-vb2, s, b))
    if s < 1:
        conn = (s**2) * sinh(pi * (v1 - v2) / s) * sinh(pi * (vb1 - vb2) / s)
    else:
        conn = sin(pi * (v1 - v2)) * sin(pi * (vb1 - vb2))

    return re(log(deriv * conn**2)) / 12 - log((x2 - x1)**2) / 6
Example #24
0
def find_root(t, method="riemann_siegel"):
	# Finds root at the point nearest >= t.
	n_max = 100000

	eps = 1e-11

	if t < 14:
		lower = 14
	else:
		lower = t

	if method == "euler":
		z_function = lambda t: euler.calculate_z(t)
	elif method == "dirichlet":
		z_function = lambda t: dirichlet.calculate_z(t)
	else:
		z_function = lambda t: riemann_siegel.calculate_z(t)

	# Need to find the lowest upper bracketing value.
	upper = next_upper_bracket(t=t, z_function=z_function)

	n = 0
	while n <= n_max:
		mid = (upper + lower) / 2
		value = z_function(mid)

		# print "Trying between {} and {}".format(lower, upper)
		# print "Got Z({}) = {}".format(mid, value)

		if abs(value) < eps: # Found a root.
			print "The root closest to t={} in the upward direction is {}.".format(t, mid)
			return mid
		else:
			n += 1
			if np.sign( mp.re(z_function(lower)) ) == np.sign( mp.re(z_function(mid)) ):
				lower = mid
			else:
				upper = mid

	return None
Example #25
0
def select():
    global lastop, a, listindex, argindex, theFile
    if lastop == 0:
        print(
            'Parse Error: SELECT. came before corresponding EXP. or LOG. at instruction '
            + str(pointer))
        print(greporig(pointer))
        left = val
        middle = a[listindex]
        right = val
        if listindex > 0:
            left = a[listindex - 1]
        if listindex < len(a) - 1:
            right = a[listindex + 1]
        print('Nearby Tape Values: ' + mpmath.nstr(left) + ',' +
              mpmath.nstr(middle) + ',' + mpmath.nstr(right))
        sys.exit()
    elif lastop == 1:
        if a[argindex] != 0 or mpmath.im(
                a[listindex]) != 0 or a[listindex] >= 0:
            try:
                a[argindex] = mpmath.power(a[argindex], a[listindex])
            except OverflowError:
                print(
                    'Number too large to represent. Try increasing precision or moving default tape value closer to 1.'
                )
                print(greporig(pointer))
            a[argindex] = mpmath.chop(a[argindex], tol)
        else:
            a[argindex] = mpmath.mpc('inf')
    else:
        if a[listindex] == 1:
            print('Tried to take a log base one at instruction ' +
                  str(pointer))
            print(greporig(pointer))
            left = val
            middle = a[listindex]
            right = val
            if listindex > 0:
                left = a[listindex - 1]
            if listindex < len(a) - 1:
                right = a[listindex + 1]
            print('Nearby Tape Values: ' + mpmath.nstr(left) + ',' +
                  mpmath.nstr(middle) + ',' + mpmath.nstr(right))
            sys.exit()
        a[argindex] = mpmath.log(a[argindex], a[listindex])
        #patch up nans when arg is infinite, since we usually want zero for the real part then
        if mpmath.isinf(mpmath.im(a[argindex])) and mpmath.isnan(
                mpmath.re(a[argindex])):
            a[argindex] = mpmath.mpc(0, mpmath.im(a[argindex]))
        a[argindex] = mpmath.chop(a[argindex], tol)
    oparg = 0
Example #26
0
  def __call__(self, r, z=1e-10):
    """
    Returns the intensity distribution near the focal spot.
    """
    u = self.normalized_distance(z)
    v = self.normalized_radius(r)

    α = self.alpha()
    β = self.beta(u, v)

    I = 2 * α**2 * mp.exp(-α) / (mp.cosh(α) - 1) / (u**2 + 4 * α**2)

    if mp.sqrt(u**2 + 4 * α**2) < v:
      U1 = lommelU(u, v, 1)
      U2 = lommelU(u, v, 2)

      U1s = mp.re(U1)
      U1c = mp.im(U1)
      U2s = mp.re(U2)
      U2c = mp.im(U2)

      return I * ((U1c + U2s)**2 + (U1s - U2c)**2)

    if mp.sqrt(u**2 + 4 * α**2) > v:
      V0 = lommelV(u, v, 0)
      V1 = lommelV(u, v, 1)

      V0s = mp.re(V0)
      V0c = mp.im(V0)
      V1s = mp.re(V1)
      V1c = mp.im(V1)

      exp = mp.exp(α * (1 - β))
      cos = mp.cos(u * (1 + β) / 2)
      sin = mp.sin(u * (1 + β) / 2)

      return I * ((V0c - V1s - exp * cos)**2 + (V0s + V1c + exp * sin)**2)

    raise ValueError('invalid coordinates')
Example #27
0
def linear_equilibrium(mu1, mu2, complex_guess_1, complex_guess_2):
    """The linear equilibrium function finds a two dimensional vector solution. The solutions we are looking for are real.
    Many solutions that can be found are complex and because of the numerical methods in which python finds these solutions
    we have decided to use the mpmath modules. This method of finding the solution for our non linear heat flux uses
    the muller method of numerical calculation. For more information on mpmath root finding:
    http://mpmath.org/doc/1.1.0/calculus/optimization.html"""
    import numpy as np
    import sympy
    import mpmath
    #List of Constants
    I0 = 1367.0  #Solar constant W/m^2
    a = 2.8  #Unitless parameter needed for linear albedo feedback relationships more info in Budyko 1969
    b = .009  #Another parameter needed for linear feedback relationship more info in Budyko 1969
    sig = 5.67 * 10**-8  #Stephan boltzmann constant m^2 kg s^-2 K^-1
    e = .64  #Emmisivity of earth
    A = 2.7  #Heat flux parameter for linear heat forcing
    solution_array = []
    for x in mu1:
        for y in mu2:
            #Below we find the two-dimensional vector solutions in form of [polar_solution, tropical_solution]
            f = [
                lambda T1, T2:
                (.156 * x * I0 * (1 - a) + .156 * x * I0 * b * T1 - e * sig *
                 (T1**4) + (A * (T2 - T1))), lambda T1, T2:
                (.288 * y * I0 * (1 - a) + .288 * y * I0 * b * T2 - e * sig *
                 (T2**4) + (A * (T1 - T2)))
            ]
            solution = np.array(
                mpmath.findroot(f, ([complex_guess_1, complex_guess_2]),
                                solver='muller',
                                verify=False))
            if abs(mpmath.im(solution[0])) > 1e-10:
                solution[0] = np.nan
            if abs(mpmath.im(solution[1])) > 1e-10:
                solution[1] = np.nan
            solution_array.append(
                [mpmath.re(solution[0]),
                 mpmath.re(solution[1]), x, y])
    return (solution_array)
Example #28
0
    def propagate(self, T):
        """
    Returns new Gaussian beam with updated parameters from transfer matrix.
    """
        z = self.origin
        k = self.wavenumber
        q = self.parameter
        q = (T[0, 0] * q + T[0, 1]) / (T[1, 0] * q + T[1, 1])

        z = mp.re(q) + z
        w = mp.sqrt(2 * mp.im(q) / k)

        return Gaussian(waist=w, origin=z, wavelength=self.wavelength)
Example #29
0
def S_double_dirac(x1, x2, t, s, b):
    v1, v2, vb1, vb2 = v(x1, t, s, b), v(x2, t, s, b), vb(x1, t, s,
                                                          b), vb(x2, t, s, b)

    deriv = ((2 * pi)**(-4)) * Dw(v1, s, b) * (-Dw(-vb1, s, b)) * Dw(
        v2, s, b) * (-Dw(-vb2, s, b))
    conn = jt1(v1 - v2, j * s) * jt1(vb2 - vb1, j * s) / eta(j * s)**6
    disconn = jt1(v1 - vb1 + j * s / 2, j * s) * jt1(v2 - vb2 + j * s / 2,
                                                     j * s)
    cross = jt1(v1 - vb2 + j * s / 2, j * s) * jt1(v2 - vb1 + j * s / 2, j * s)

    return re(log(deriv * (conn * disconn / cross)**2)) / 12 - log(
        (x2 - x1)**2) / 6
Example #30
0
def S_single_dirac(x1, x2, t, a):
    t1, t2, tb1, tb2 = theta(x1, t, a), theta(x2, t,
                                              a), thetaB(x1, t,
                                                         a), thetaB(x2, t, a)
    z1, z2, zb1, zb2 = j * exp(j * t1), j * exp(j * t2), j * exp(
        -j * tb1), j * exp(-j * tb2)

    deriv = a**2 / (exp(j * (t1 - tb1 + t2 - tb2) / 2) * cos(t1) * cos(t2) *
                    cos(tb1) * cos(tb2))
    conn = (z1 - z2) * (zb1 - zb2)
    disconn = (z1 - zb1) * (z2 - zb2)
    cross = (z1 - zb2) * (z2 - zb1)

    return re(log(deriv * conn * disconn / cross)) / 6 - log((x2 - x1)**2) / 6
Example #31
0
def non_linear_albedo_solver(mu1, mu2, guess_1, guess_2):
    """This solution is a modeling of a situation where solar intensity is decreased sufficiently until the earth
    produces enough ice that the earth will reflect sufficient radiation to keep the earth in an ice age.
    Ice ages are still subject to a heat flux, the below function finds the equilibria for the ice ages for
    made with a non-linear heat flux."""
    import numpy as np
    import sympy
    import mpmath
    #List of Constants
    I0 = 1367.0  #Solar constant W/m^2
    a = 2.8  #Unitless parameter needed for linear albedo feedback relationships more info in Budyko 1969
    b = .009  #Another parameter needed for linear feedback relationship more info in Budyko 1969
    sig = 5.67 * 10**-8  #Stephan boltzmann constant m^2 kg s^-2 K^-1
    e = .64  #Emmisivity of earth
    A = 600  #Heat flux parameter for non-linear heat forcing
    solution_array = []
    for x in mu1:
        for y in mu2:
            #Below we find the two-dimensional vector solutions in form of [polar_solution, tropical_solution]
            f = [
                lambda T1, T2: (.156 * x * I0 * (1 - .75) - e * sig * (T1**4) +
                                (A / (T2 - T1))), lambda T1, T2:
                (.288 * y * I0 * (1 - .75) - e * sig * (T2**4) + (A /
                                                                  (T1 - T2)))
            ]
            solution = np.array(
                mpmath.findroot(f, ([guess_1, guess_2]),
                                solver='muller',
                                verify=False))
            if abs(mpmath.im(solution[0])) > 1e-10:
                solution[0] = np.nan
            if abs(mpmath.im(solution[1])) > 1e-10:
                solution[1] = np.nan
            solution_array.append(
                [mpmath.re(solution[0]),
                 mpmath.re(solution[1]), x, y])
    return (solution_array)
Example #32
0
def put_price_calc(given, op):
    #Option data
    K = given[0]  #Strike
    R = given[1]  #Risk free rate of return (in %)
    T = given[2]  #Time to expiry
    y = given[3]  #Annual dividend yield
    S0 = given[4]  #Stock price
    #Parameters over which data is being optimized
    sigma = op[0]  #Log return diffusion
    lemu = op[1]  #Arrival rate of up jumps
    lemd = op[2]  #Arrival rate of down jumps
    etau = op[3]  #Strength of up jump
    etad = op[4]  #Strength of down jump
    k = math.log(K)  #Log of strike rate
    r = R / 100  #Risk free rate of return
    mu = r - y - lemu / (etau - 1) + lemd / (
        etad + 1)  #Mu for the given data and parameters
    #Risk neutral probability of finishing in the money
    pi2 = 0.5 + mp.fdiv(1, mp.pi) * mp.quad(
        lambda u: mp.re(
            mp.fdiv(
                mp.exp(-mp.mpc(0, 1) * u * k) * char_fun(
                    u, mu, sigma, lemu, lemd, etau, etad, T, S0),
                mp.mpc(0, 1) * u)), [0, mp.inf])
    #Delta of the option
    pi1 = 0.5 + mp.fdiv(1, mp.pi) * mp.quad(
        lambda u: mp.re(
            mp.fdiv(
                mp.exp(-mp.mpc(0, 1) * u * k) * char_fun(
                    u - mp.mpc(0, 1), mu, sigma, lemu, lemd, etau, etad, T, S0),
                mp.mpc(0, 1) * u * char_fun(-mp.mpc(0, 1), mu, sigma, lemu,
                                            lemd, etau, etad, T, S0))),
        [0, mp.inf])
    #Price of the put option
    P_alternate = K * mp.exp(-r * T) * (1 - pi2) - S0 * mp.exp(
        -y * T) * (1 - pi1)
    return P_alternate
Example #33
0
def S_double_hol_disconn(x1, x2, t, s, b):
    v1, v2, vb1, vb2 = v(x1, t, s, b), v(x2, t, s, b), vb(x1, t, s,
                                                          b), vb(x2, t, s, b)
    #difference from mirror twist op
    p1, n1, p2, n2 = v1 - vb1 + j * s / 2, v1 - vb1 - j * s / 2, v2 - vb2 + j * s / 2, v2 - vb2 - j * s / 2

    deriv = (pi**(-4)) * Dw(v1, s, b) * (-Dw(-vb1, s, b)) * Dw(
        v2, s, b) * (-Dw(-vb2, s, b))
    if s < 1:
        g1 = min([re(sinh(pi * p1 / s)**2), re(sinh(pi * n1 / s)**2)])
        g2 = min([re(sinh(pi * p2 / s)**2), re(sinh(pi * n2 / s)**2)])
        disconnSquare = (s**4) * g1 * g2
    else:
        m1 = sin(pi * p1) * sin(pi * p2)
        m2 = sin(pi * p1) * sin(pi * n2) * exp(pi * s)
        m3 = sin(pi * n1) * sin(pi * p2) * exp(pi * s)
        m4 = sin(pi * n1) * sin(pi * n2)
        disconnSquare = min([re(m1**2), re(m2**2), re(m3**2), re(m4**2)])

    return re(log(deriv * disconnSquare)) / 12 - log((x2 - x1)**2) / 6
Example #34
0
def elliptic_core_g(x,y):
  x = x/2
  y = y/2
  
  factor = (cos(x)/sin(y) + sin(y)/cos(x) - (cos(y)/tan(y)/cos(x) + sin(x)*tan(x)/sin(y)))/pi
  k = tan(x)/tan(y)
  m = k*k
  n = (sin(x)/sin(y))*(sin(x)/sin(y))
  u = asin(tan(y)/tan(x))

  complete = ellipk(m) - ellippi(n, m)
  incomplete = ellipf(u,m) - ellippi(n/k/k,1/m)/k
  #incomplete = ellipf(u,m) - ellippi(n,u,m)

  return re(1.0 - factor*(incomplete + complete))
Example #35
0
def getNthPadovanNumber( arg ):
    n = fadd( real( arg ), 4 )

    a = root( fsub( fdiv( 27, 2 ), fdiv( fmul( 3, sqrt( 69 ) ), 2 ) ), 3 )
    b = root( fdiv( fadd( 9, sqrt( 69 ) ), 2 ), 3 )
    c = fadd( 1, fmul( mpc( 0, 1 ), sqrt( 3 ) ) )
    d = fsub( 1, fmul( mpc( 0, 1 ), sqrt( 3 ) ) )
    e = power( 3, fdiv( 2, 3 ) )

    r = fadd( fdiv( a, 3 ), fdiv( b, e ) )
    s = fsub( fmul( fdiv( d, -6 ), a ), fdiv( fmul( c, b ), fmul( 2, e ) ) )
    t = fsub( fmul( fdiv( c, -6 ), a ), fdiv( fmul( d, b ), fmul( 2, e ) ) )

    return nint( re( fsum( [ fdiv( power( r, n ), fadd( fmul( 2, r ), 3 ) ),
                             fdiv( power( s, n ), fadd( fmul( 2, s ), 3 ) ),
                             fdiv( power( t, n ), fadd( fmul( 2, t ), 3 ) ) ] ) ) )
Example #36
0
def isKthPower( n, k ):
    if not isint( k, gaussian=True ) and isint( k ):
        raise ValueError( 'integer arguments expected' )

    if k == 1:
        return 1
    elif k < 1:
        raise ValueError( 'a positive power k is expected' )

    if im( n ):
        # I'm not sure why this is necessary...
        if re( n ) == 0:
            return isKthPower( im( n ), k )

        # We're looking for a Gaussian integer among any of the roots.
        for i in [ autoprec( root )( n, k, i ) for i in arange( k ) ]:
            if isint( i, gaussian=True ):
                return 1

        return 0
    else:
        rootN = autoprec( root )( n, k )
        return 1 if isint( rootN, gaussian=True ) else 0
Example #37
0
 def g(theta,phi):
     R = abs(re(spherharm(l,m,theta,phi)))
     x = R*cos(phi)*sin(theta)
     y = R*sin(phi)*sin(theta)
     z = R*cos(theta)
     return [x,y,z]
Example #38
0
def handleOutput( valueList, indent=0, file=sys.stdout ):
    '''
    Once the evaluation of terms is complete, the results need to be
    translated into output.

    If the result is a list or a generator, special formatting turns those
    into text output.  Date-time values and measurements also require special
    formatting.

    Setting file to an io.StringIO objects allows for 'printing' to a string,
    which is used by makeHelp.py to generate actual rpn output for the examples.
    '''
    if valueList is None:
        return file

    indentString = ' ' * indent

    if len( valueList ) != 1:
        if g.checkForSingleResults:
            print( 'valueList', valueList )
            raise ValueError( 'unexpected multiple results!' )

        valueList = [ valueList ]

    if isinstance( valueList[ 0 ], RPNFunction ):
        print( indentString + 'rpn:  unexpected end of input in function definition', file=file )
    else:
        mp.pretty = True
        result = valueList.pop( )

        if result is nan:
            return file

        if g.comma:
            g.integerGrouping = 3     # override whatever was set on the command-line
            g.leadingZero = False     # this one, too
            g.integerDelimiter = ','
        else:
            g.integerDelimiter = ' '

        if isinstance( result, RPNGenerator ):
            formatListOutput( result.getGenerator( ), indent=indent, file=file )
        elif isinstance( result, list ):
            formatListOutput( result, indent=indent, file=file )
        else:
            # single result
            if isinstance( result, RPNDateTime ):
                outputString = formatDateTime( result )
            elif isinstance( result, str ):
                result = checkForVariable( result )
                outputString = result
            else:
                # output the answer with all the extras according to command-line arguments
                # handle the units if we are displaying a measurement
                if isinstance( result, RPNMeasurement ):
                    outputString = formatOutput( nstr( result.value, g.outputAccuracy, min_fixed=-g.maximumFixed - 1 ) )
                    outputString += ' ' + formatUnits( result )
                # handle a complex output (mpmath type: mpc)
                elif isinstance( result, mpc ):
                    #print( 'result', result, type( result ) )
                    #print( 'im', im( result ), type( im( result ) ) )
                    #print( 're', re( result ), type( re( result ) ) )
                    imaginary = im( result )

                    if im( result ) > 0:
                        outputString = '(' + formatOutput( nstr( mpmathify( re( result ) ), g.outputAccuracy, min_fixed=-g.maximumFixed - 1 ) ) + \
                                       ' + ' + formatOutput( nstr( mpmathify( im( result ) ), g.outputAccuracy, min_fixed=-g.maximumFixed - 1 ) ) + 'j)'
                    elif im( result ) < 0:
                        outputString = '(' + formatOutput( nstr( mpmathify( re( result ) ), g.outputAccuracy, min_fixed=-g.maximumFixed - 1 ) ) + \
                                       ' - ' + formatOutput( nstr( fneg( mpmathify( im( result ) ) ), g.outputAccuracy, min_fixed=-g.maximumFixed - 1 ) ) + 'i)'
                    else:
                        outputString = formatOutput( nstr( re( result ), g.outputAccuracy, min_fixed=-g.maximumFixed - 1 ) )
                # otherwise, it's a plain old mpf
                else:
                    outputString = formatOutput( nstr( result, g.outputAccuracy, min_fixed=-g.maximumFixed - 1 ) )

            print( indentString + outputString, file=file )

            # handle --identify
            if g.identify:
                handleIdentify( result, file )

        saveResult( result )

    if g.timer or g.tempTimerMode:
        print( '\n' + indentString + '{:.3f} seconds'.format( time.process_time( ) - g.startTime ), file=file )
Example #39
0
 def g(theta,phi):
     R = abs(re(a*spherharm(l,m1,theta,phi)+b*spherharm(l,m2,theta,phi)))**2
     x = R*cos(phi)*sin(theta)
     y = R*sin(phi)*sin(theta)
     z = R*cos(theta)
     return [x,y,z]
Example #40
0
def z_function(t, N=100000):
	zeta = zeta_function(1/2 + (1.j)*t, N)

	return mp.re( np.exp( 1.j * riemann_siegel_theta(t) ) * zeta )
Example #41
0
def isPower( n, k ):
    #print( 'log( n )', log( n ) )
    #print( 'log( k )', log( k ) )
    #print( 'divide', autoprec( lambda n, k: fdiv( re( log( n ) ), re( log( k ) ) ) )( n, k ) )
    return isInteger( autoprec( lambda n, k: fdiv( re( log( n ) ), re( log( k ) ) ) )( n, k ) )
Example #42
0
 def arFpDensity(Da, r0a, La, ta):
     D, r0, L, t = (m.mpmathify(str(x)) for x in (Da, r0a, La, ta))
     pref = m.exp(-r0 ** 2 / (4 * D * t)) * D / (4 * m.sqrt(m.pi) * (D * t) ** 1.5)
     z = (1j * L * r0) / (2 * D * t)
     q = m.exp(-L ** 2 / (D * t))
     return float(m.re(2 * pref * (r0 * m.jtheta(4, z, q) - 0 * 1j * L * m.djtheta(4, z, q))))
Example #43
0
def getReal( n ):
    return re( n )