コード例 #1
0
def ExactIntegrationOfSinus(t, a=None, b=None):
    with precision(300):
        if a == None and b == None:
            return 0.5 * math.pi * math.sqrt(t) * (mpmath.angerj(0.5, t) -
                                                   mpmath.angerj(-0.5, t))
        elif a == None and b != None:
            a = 0
        elif b == None:
            b = t
        mpmath.mp.dps = 50
        mpmath.mp.pretty = True
        pi = mpmath.mp.pi
        pi = +pi
        fcos = mpmath.fresnelc
        fsin = mpmath.fresnels
        arg_b = mpmath.sqrt(2 * (t - b) / pi)

        if a == "MinusInfinity":
            return mpmath.sqrt(
                0.5 * mpmath.mp.pi) * (-2 * mpmath.sin(t) * fcos(arg_b) +
                                       2 * mpmath.cos(t) * fsin(arg_b) +
                                       mpmath.sin(t) - mpmath.cos(t))
        else:
            arg_a = mpmath.sqrt(2 * (t - a) / pi)
            return mpmath.sqrt(2 * mpmath.mp.pi) * (
                (fsin(arg_b) - fsin(arg_a)) * mpmath.cos(t) +
                (fcos(arg_a) - fcos(arg_b)) * mpmath.sin(t))
コード例 #2
0
def cos_gamma(_a: float, incl: float, tol=10e-5) -> float:
    """Calculate the cos of the angle gamma"""
    if abs(incl) < tol:
        return 0
    else:
        return mpmath.cos(_a) / mpmath.sqrt(
            mpmath.cos(_a)**2 + mpmath.cot(incl)**2)  # real
コード例 #3
0
def _view_cone_calc(lat_geoc, lon_geoc, sat_pos, sat_vel, q_max, m):
    """Semi-private: Performs the viewing cone visibility calculation for the day defined by m.
    Note: This function is based on a paper titled "rapid satellite-to-site visibility determination
    based on self-adaptive interpolation technique"  with some variation to account for interaction
    of viewing cone with the satellite orbit.

    Args:
        lat_geoc (float): site location in degrees at the start of POI
        lon_geoc (float): site location in degrees at the start of POI
        sat_pos (Vector3D): position of satellite (at the same time as sat_vel)
        sat_vel (Vector3D): velocity of satellite (at the same time as sat_pos)
        q_max (float): maximum orbital radius
        m (int): interval offsets (number of days after initial condition)

    Returns:
        Returns 4 numbers representing times at which the orbit is tangent to the viewing cone,

    Raises:
        ValueError: if any of the 4 formulas has a complex answer. This happens when the orbit and
        viewing cone do not intersect or only intersect twice.

    Note: With more analysis it should be possible to find a correct interval even in the case
        where there are only two intersections but this is beyond the current scope of the project.
    """
    lat_geoc = (lat_geoc * mp.pi) / 180
    lon_geoc = (lon_geoc * mp.pi) / 180

    # P vector (also referred  to as orbital angular momentum in the paper) calculations
    p_unit_x, p_unit_y, p_unit_z = cross(sat_pos, sat_vel) / (mp.norm(sat_pos) * mp.norm(sat_vel))

    # Following are equations from Viewing cone section of referenced paper
    r_site_magnitude = earth_radius_at_geocetric_lat(lat_geoc)
    gamma1 = THETA_NAUGHT + mp.asin((r_site_magnitude * mp.sin((mp.pi / 2) + THETA_NAUGHT)) / q_max)
    gamma2 = mp.pi - gamma1

    # Note: atan2 instead of atan to get the correct quadrant.
    arctan_term = mp.atan2(p_unit_x, p_unit_y)
    arcsin_term_gamma, arcsin_term_gamma2 = [(mp.asin((mp.cos(gamma) - p_unit_z * mp.sin(lat_geoc))
                                             / (mp.sqrt((p_unit_x ** 2) + (p_unit_y ** 2)) *
                                              mp.cos(lat_geoc)))) for gamma in [gamma1, gamma2]]

    angle_1 = (arcsin_term_gamma - lon_geoc - arctan_term + 2 * mp.pi * m)
    angle_2 = (mp.pi - arcsin_term_gamma - lon_geoc - arctan_term + 2 * mp.pi * m)
    angle_3 = (arcsin_term_gamma2 - lon_geoc - arctan_term + 2 * mp.pi * m)
    angle_4 = (mp.pi - arcsin_term_gamma2 - lon_geoc - arctan_term + 2 * mp.pi * m)
    angles = [angle_1, angle_2, angle_3, angle_4]

    # Check for complex answers
    if any([not isinstance(angle, mp.mpf) for angle in angles]):
        raise ValueError()

    # Map all angles to 0 to 2*pi
    for idx in range(len(angles)):
        while angles[idx] < 0:
            angles[idx] += 2 * mp.pi
        while angles[idx] > 2 * mp.pi:
            angles[idx] -= 2 * mp.pi

    # Calculate the corresponding time for each angle and return
    return [mp.nint((1 / ANGULAR_VELOCITY_EARTH) * angle) for angle in angles]
コード例 #4
0
ファイル: poly_fit.py プロジェクト: nick-lifx/hsbk_rgb
def any_f_to_poly(f, a, b, order):
  # remap [a, b] to [-1, 1] for better conditioning
  p = mpmath.lu_solve(
    vandermonde(mpmath.matrix([a, b]), 2),
    mpmath.matrix([-1., 1.])
  )

  # fit polynomial to [-1, 1], then compose with mapping function
  p_x = mpmath.matrix(
    [mpmath.cos((i + .5) * mpmath.pi / order) for i in range(order)]
  )
  x = mpmath.matrix(
    [a + (b - a) * (.5 + .5 * p_x[i]) for i in range(order)]
  )
  q = utils.poly.compose(
    mpmath.lu_solve(vandermonde(p_x, order), f(x)),
    p
  )

  # checking
  p_x = mpmath.matrix(
    [mpmath.cos(i * mpmath.pi / order) for i in range(order + 1)]
  )
  x = mpmath.matrix(
    [a + (b - a) * (.5 + .5 * p_x[i]) for i in range(order + 1)]
  )
  y = utils.poly.eval_multi(q, x) - f(x)
  est_err = max([abs(y[i]) for i in range(y.rows)])
  print('est_err', est_err)

  return q
コード例 #5
0
ファイル: asymint.py プロジェクト: omereis/sasmodels
 def integrand(theta, phi):
     evals[0] += 1
     qab = q * mp.sin(theta)
     qa = qab * mp.cos(phi)
     qb = qab * mp.sin(phi)
     qc = q * mp.cos(theta)
     Zq = KERNEL_MP(qa, qb, qc)**2
     return Zq * mp.sin(theta)
コード例 #6
0
def easom(data):
    """
    Easom’s function
    Whose global minimum is f∗ = −1 at x∗ = (π, π) within −100 ≤ x, y ≤ 100. It has many
local minima.
    """
    return float(-mp.cos(data[0]) * mp.cos(data[1]) *
                 mp.exp(-(data[0] - mp.pi)**2 - (data[1] - mp.pi)**2))
コード例 #7
0
    def get_dtheta_at(self, phi, covered_r):
        from math import asin, cos, sqrt, pi

        if covered_r >= sqrt(2) * cos(phi):
            # In this case, the confidence radius is so large such that it covers the whole orbit and the north pole.
            dtheta = pi
        else:
            dtheta = 2 * asin((.5 * covered_r) / cos(phi))
        return dtheta
コード例 #8
0
def sec_der(x_val: Real) -> mp.mpf:
    """Define the actual second derivative."""
    x_squared = mp.power(x_val, 2)
    return (
        mp.cos(x_val)
        + (-4 * x_squared) * mp.cos(x_squared)
        + -2 * mp.sin(x_squared)
        + mp.sin(x_val)
    )
コード例 #9
0
ファイル: util.py プロジェクト: YuguangTong/qtn-proj
def f2(x):
    """
    Another angular integral in electron noise calculation.
    
    """
    term1 = 2*x**3 * (2*mp.si(2*x)-mp.si(x))
    term2 = 2*x**2 * (mp.cos(2*x) - mp.cos(x))
    term3 = x * (mp.sin(2*x) - 2*mp.sin(x)) - (mp.cos(2*x) - 4* mp.cos(x)  + 3)
    return (term1 + term2 + term3)/(12 * x**2)
コード例 #10
0
def get_rotation_matrix_north_pole_to(theta, phi):
    from numpy import array, matmul
    from math import sin, cos

    Rx = array([[1, 0, 0], [0, sin(phi), cos(phi)], [0, -cos(phi), sin(phi)]])
    Rz = array([[sin(theta), cos(theta), 0], [-cos(theta),
                                              sin(theta), 0], [0, 0, 1]])
    rotation_matrix = matmul(Rz, Rx)

    return rotation_matrix
コード例 #11
0
def FSingleDisc(x1,x2,t,a):
    """
    inside of log() for connected HEE. We take single interval subsystem A=[x1,x2].
    """
    t1 = T(x1,t,a)
    t2 = T(x2,t,a)
    tb1 = TB(x1,t,a)
    tb2 = TB(x2,t,a)
    num = (a**4)*( (exp(j*t1)-exp(-j*tb1))*(exp(j*t2)-exp(-j*tb2)) )**2
    den = exp(j*(t1-tb1+t2-tb2))*((cos(t1)*cos(tb1)*cos(t2)*cos(tb2))**2)
    return num/den
コード例 #12
0
def S_single_hol_disconn(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))
    disconn = (z1 - zb1) * (z2 - zb2)

    return re(log(deriv * disconn)) / 6 - log((x2 - x1)**2) / 6
コード例 #13
0
ファイル: rpnGeometry.py プロジェクト: GaelicGrime/rpn
def getAntiprismVolumeOperator(n, k):
    result = getProduct([
        fdiv(
            fprod([
                n,
                sqrt(fsub(fmul(4, cos(cos(fdiv(pi, fmul(n, 2))))), 1)),
                sin(fdiv(fmul(3, pi), fmul(2, n)))
            ]), fmul(12, sin(sin(fdiv(pi, n))))),
        sin(fdiv(fmul(3, pi), fmul(2, n))),
        getPower(k, 3)
    ])

    return result.convert('meter^3')
コード例 #14
0
def Diagonalizzazione(I):
    α = AngoloDiRotazione(I)
    Iη = I[0]
    Iξ = I[1]
    Iηξ = I[2]
    if α != 0:
        Iy = Iη * mpmath.cos(α)**2 + Iξ * mpmath.sin(
            α)**2 - 2 * Iηξ * mpmath.cos(α) * mpmath.sin(α)
        Iz = Iξ * mpmath.sin(α)**2 + Iξ * mpmath.cos(
            α)**2 + 2 * Iηξ * mpmath.cos(α) * mpmath.sin(α)
        J = [Iy, Iz]
        return J
    else:
        return I
コード例 #15
0
ファイル: elliptic.py プロジェクト: ulmononian/diskload
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))
コード例 #16
0
def calculate_coordinates(input_angles):
    # Constants
    scalling_const = np.sqrt(.3)
    f = 195 * scalling_const * math.power(10, -3)
    t = 375 * scalling_const * math.power(10, -3)
    coord_list = []
    for angle in input_angles:
        T_1 = angle[0] - np.pi
        T_2 = angle[1] - np.pi
        x = float((f * math.cos(T_1) + t * math.cos(
            (T_1 - T_2))) * math.power(10, 3))
        y = float((f * math.sin(T_1) + t * math.sin(
            (T_1 - T_2))) * math.power(10, 3))
        coord_list.append([x, y])
    return coord_list
コード例 #17
0
def family_graphical_combination(t, c, angle_alpha_prime):
    """
    Aberdeen family of graphical operators
    """
    if not (isinstance(t, Opinion) and isinstance(c, Opinion) \
            and t.check() and c.check()):
        raise Exception("Two valid Opinions are required!")

    if mpmath.almosteq(angle_alpha_prime, -mpmath.pi / 3, epsilon):
        new_magnitude = c.get_magnitude_ratio() * (
            mpmath.mpf("2") * t.getUncertainty() /
            mpmath.sqrt(mpmath.mpf("3")))
        #new_magnitude = 0
    elif mpmath.almosteq(angle_alpha_prime,
                         mpmath.mpf("2/3") * mpmath.pi, epsilon):
        new_magnitude = c.get_magnitude_ratio() * (
            mpmath.mpf("2") * (mpmath.mpf("1") - t.getUncertainty()) /
            mpmath.sqrt(mpmath.mpf("3")))
        #new_magnitude = 0
    elif mpmath.almosteq(angle_alpha_prime,
                         mpmath.mpf("1/2") * mpmath.pi, epsilon):
        #new_magnitude = 1 - t.getUncertainty()
        new_magnitude = 2 * t.getBelief()
    else:
        new_magnitude = c.get_magnitude_ratio() * (mpmath.mpf("2") * \
                                                (mpmath.sqrt(mpmath.power(mpmath.tan(angle_alpha_prime), mpmath.mpf("2")) +1 ) /
                                                 ( mpmath.absmax(mpmath.tan(angle_alpha_prime) + mpmath.sqrt(mpmath.mpf("3"))) ) ) * \
                                                t.getBelief())

    new_uncertainty = t.getUncertainty(
    ) + mpmath.sin(angle_alpha_prime) * new_magnitude
    new_disbelief = t.getDisbelief() + (
        t.getUncertainty() - new_uncertainty) * mpmath.cos(
            mpmath.pi / 3) + mpmath.cos(angle_alpha_prime) * mpmath.sin(
                mpmath.pi / 3) * new_magnitude

    if mpmath.almosteq(new_uncertainty, 1, epsilon):
        new_uncertainty = mpmath.mpf("1")
    if mpmath.almosteq(new_uncertainty, 0, epsilon):
        new_uncertainty = mpmath.mpf("0")

    if mpmath.almosteq(new_disbelief, 1, epsilon):
        new_disbelief = mpmath.mpf("1")
    if mpmath.almosteq(new_disbelief, 0, epsilon):
        new_disbelief = mpmath.mpf("0")

    return Opinion(1 - new_disbelief - new_uncertainty, new_disbelief,
                   new_uncertainty, "1/2")
コード例 #18
0
ファイル: math.py プロジェクト: fredrik-johansson/piranha
def cos(arg):
	"""Cosine.
	
	This function is a wrapper around a lower level function. If the argument is a standard *float* or *int*,
	the function from the builtin :mod:`math` module will be used. If the argument is an :mod:`mpmath`
	float, the corresponding multiprecision function, if available, will be used. Otherwise, the argument is assumed
	to be a series type and a function from the piranha C++ library is used.
	
	:param arg: cosine argument
	:returns: cosine of *arg*
	:raises: :exc:`TypeError` if the type of *arg* is not supported, or any other exception raised by the invoked
		low-level function
	
	>>> from .types import poisson_series, polynomial, rational, short
	>>> t = poisson_series(polynomial(rational,short))()
	>>> cos(2 * t('x'))
	cos(2*x)
	>>> cos('y') # doctest: +IGNORE_EXCEPTION_DETAIL
	Traceback (most recent call last):
	   ...
	TypeError: invalid argument type(s)
	
	"""
	if isinstance(arg,float) or isinstance(arg,int):
		import math
		return math.cos(arg)
	try:
		from mpmath import mpf, cos
		if isinstance(arg,mpf):
			return cos(arg)
	except ImportError:
		pass
	from ._core import _cos
	return _cpp_type_catcher(_cos,arg)
コード例 #19
0
def calc_J(chi, En, Lz, Q, aa, slr, ecc):
    """
    Schmidt's J function.

    Parameters:
        chi (float): radial angle
        En (float): energy
        Lz (float): angular momentum
        Q (float): Carter constant
        aa (float): spin
        slr (float): semi-latus rectum
        ecc (float): eccentricity

    Returns:
        J (float)
    """
    En2 = En * En
    ecc2 = ecc * ecc
    aa2 = aa * aa
    Lz2 = Lz * Lz
    slr2 = slr * slr

    eta = 1 + ecc * cos(chi)
    eta2 = eta * eta

    J = ((1 - ecc2) * (1 - En2) + 2 * (1 - En2 - (1 - ecc2) / slr) * eta +
         (((3 + ecc2) * (1 - En2)) / (1 - ecc2) +
          ((1 - ecc2) * (aa2 * (1 - En2) + Lz2 + Q)) / slr2 - 4 / slr) * eta2)

    return J
コード例 #20
0
ファイル: exactising.py プロジェクト: iCodeIN/deft
def CalculateCoefSum(n, m, k):
    # define a[k_] as per Paul D. Beale
    a_coef = (1 + x*x)**2 - b*mp.cos(np.pi*k/n)
    c2_coef_sum = 0
    for j in range(0, m+2, 2): # should include endpoint so m --> m+2
        c2_coef_sum += sy.expand((mh.factorial(m)/mh.factorial(j)/mh.factorial(m-j))*(a_coef**2 - b*b)**(j//2) * a_coef**(m - j))
    return c2_coef_sum
コード例 #21
0
def cos(arg):
    """Cosine.
	
	This function is a wrapper around a lower level function. If the argument is a standard *float* or *int*,
	the function from the builtin :mod:`math` module will be used. If the argument is an :mod:`mpmath`
	float, the corresponding multiprecision function, if available, will be used. Otherwise, the argument is assumed
	to be a series type and a function from the piranha C++ library is used.
	
	:param arg: cosine argument
	:rtype: cosine of *arg*
	:raises: :exc:`TypeError` if the type of *arg* is not supported, or any other exception raised by the invoked
		low-level function
	
	>>> from . import get_series
	>>> t = get_series('poisson_series<polynomial<rational,short>>')
	>>> cos(2 * t('x'))
	cos(2x)
	>>> cos('y') # doctest: +IGNORE_EXCEPTION_DETAIL
	Traceback (most recent call last):
	   ...
	TypeError: invalid argument type(s)
	
	"""
    if isinstance(arg, float) or isinstance(arg, int):
        import math
        return math.cos(arg)
    try:
        from mpmath import mpf, cos
        if isinstance(arg, mpf):
            return cos(arg)
    except ImportError:
        pass
    from ._core import _cos
    return _cpp_type_catcher(_cos, arg)
コード例 #22
0
 def Pprime(self, z):
     # A+S 18.9.
     from mpmath import ellipfun, sqrt, cos, sin, mpc, 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 = -2 * sqrt(
             (e1 - e3)**3) * ellipfun('cn', u=zs, m=m) * ellipfun(
                 'dn', u=zs, m=m) / (ellipfun('sn', u=zs, m=m)**3)
     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 = -4 * sqrt(H2**3) * ellipfun('sn', u=zp, m=m) * ellipfun(
             'dn', u=zp, m=m) / ((1 - ellipfun('cn', u=zp, m=m))**2)
     else:
         g2, g3 = self.__invariants
         if g2 == 0 and g3 == 0:
             retval = -2 / (z**3)
         else:
             c = e1 / 2
             A = sqrt(3 * c)
             retval = -6 * c * A * cos(A * z) / (sin(A * z))**3
     if self.__ng3:
         return mpc(0, -1) * retval
     else:
         return retval
コード例 #23
0
 def get_angle_beta(self):
     if mpmath.almosteq(self.getDisbelief(), 1, epsilon):
         return mpmath.pi / 3
     return mpmath.atan(
         (self.getUncertainty() * mpmath.sin(mpmath.pi / mpmath.mpf("3"))) /
         (mpmath.mpf("1") - (self.getDisbelief() + self.getUncertainty() *
                             mpmath.cos(mpmath.pi / mpmath.mpf("3")))))
コード例 #24
0
def d_theta(angle,k_v,R_v,alpha_v,An):
    '''Off-axis level, :math:`D_{\\theta}`, for piston in a sphere
    
    Parameters
    ----------
    angle : mpmath.mpf
        Azimuth/elevation angle in radians
    k_v : mpmath.mpf
        Wavenumber
    alpha: mpmath.mpf   
        Piston equivalent aperture in radians. 
    An : mpmath.matrix
        An is a required pre-calculated matrix which results from the 
        satisfying the conditions of the model - specific to each parameter
        set.
    
    Returns
    -------
    abs(rel_level()) : mpmath.mpf   
        The off-axis value at angle :math:`\theta`
    '''
    num = 4 
    N_v = An.rows
    denom  = (k_v**2)*(R_v**2)*mpmath.sin(alpha_v)**2
    part1 = num/denom
    jn_matrix = mpmath.matrix([I**f for f in range(N_v)])
    legendre_matrix = mpmath.matrix([legendre(n_v, mpmath.cos(angle)) for n_v in range(N_v)])
    Anjn = HP(An,jn_matrix).doit()
    part2_matrix = HP(Anjn,legendre_matrix).doit() 
    part2 = sum(part2_matrix)
    rel_level = lambdify([], -part1*part2, 'mpmath')
    return abs(rel_level())
コード例 #25
0
def rotate_point(x, y, degrees):
    radians = math.radians(degrees)

    cos_theta = math.cos(radians)
    sin_theta = math.sin(radians)
    return x * cos_theta - y * sin_theta, \
           x * sin_theta + y * cos_theta
コード例 #26
0
ファイル: test_guess.py プロジェクト: msgoff/sympy
def test_rationalize():
    from mpmath import cos, pi, mpf

    assert rationalize(cos(pi / 3)) == S.Half
    assert rationalize(mpf("0.333333333333333")) == Rational(1, 3)
    assert rationalize(mpf("-0.333333333333333")) == Rational(-1, 3)
    assert rationalize(pi, maxcoeff=250) == Rational(355, 113)
コード例 #27
0
 def get_angle_alpha(self):
     if (mpmath.almosteq(self.getBelief(), 1, epsilon)):
         return mpmath.mpf("0")
     return mpmath.atan(
         (self.getUncertainty() * mpmath.sin(mpmath.pi / mpmath.mpf("3"))) /
         (self.getDisbelief() +
          self.getUncertainty() * mpmath.cos(math.pi / mpmath.mpf("3"))))
コード例 #28
0
	def Pprime(self,z):
		# A+S 18.9.
		from mpmath import ellipfun, sqrt, cos, sin, mpc, 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 = -2 * sqrt((e1 - e3)**3) * ellipfun('cn',u=zs,m=m) * ellipfun('dn',u=zs,m=m) / (ellipfun('sn',u=zs,m=m)**3)
		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 = -4 * sqrt(H2**3) * ellipfun('sn',u=zp,m=m) * ellipfun('dn',u=zp,m=m) / ((1 - ellipfun('cn',u=zp,m=m))**2)
		else:
			g2, g3 = self.__invariants
			if g2 == 0 and g3 == 0:
				retval = -2 / (z**3)
			else:
				c = e1 / 2
				A = sqrt(3 * c)
				retval = -6 * c * A * cos(A * z) / (sin(A * z))**3
		if self.__ng3:
			return mpc(0,-1) * retval
		else:
			return retval
コード例 #29
0
ファイル: cosine.py プロジェクト: WarrenWeckesser/mpsci
def invcdf(p):
    """
    Inverse of the CDF of the raised cosine distribution.
    """
    with mpmath.extradps(5):
        p = mpmath.mpf(p)

        if p < 0 or p > 1:
            return mpmath.nan
        if p == 0:
            return -mpmath.pi
        if p == 1:
            return mpmath.pi

        if p < 0.094:
            x = _poly_approx(mpmath.cbrt(12 * mpmath.pi * p)) - mpmath.pi
        elif p > 0.906:
            x = mpmath.pi - _poly_approx(mpmath.cbrt(12 * mpmath.pi * (1 - p)))
        else:
            y = mpmath.pi * (2 * p - 1)
            y2 = y**2
            x = y * _p2(y2) / _q2(y2)

        solver = 'mnewton'
        x = mpmath.findroot(f=lambda t: cdf(t) - p,
                            x0=x,
                            df=lambda t: (1 + mpmath.cos(t)) / (2 * mpmath.pi),
                            df2=lambda t: -mpmath.sin(t) / (2 * mpmath.pi),
                            solver=solver)

        return x
コード例 #30
0
ファイル: test_ode.py プロジェクト: 1zinnur9/pymaclab
def test_odefun_harmonic():
    mp.dps = 15
    # Harmonic oscillator
    f = odefun(lambda x, y: [-y[1], y[0]], 0, [1, 0])
    for x in [0, 1, 2.5, 8, 3.7]:    #  we go back to 3.7 to check caching
        c, s = f(x)
        assert c.ae(cos(x))
        assert s.ae(sin(x))
コード例 #31
0
ファイル: rpnGeometry.py プロジェクト: flawr/rpn
def getAntiprismVolume( n, k ):
    if real( n ) < 3:
        raise ValueError( 'the number of sides of the prism cannot be less than 3,' )

    if not isinstance( k, RPNMeasurement ):
        return getAntiprismVolume( n, RPNMeasurement( real( k ), 'meter' ) )

    if k.getDimensions( ) != { 'length' : 1 }:
        raise ValueError( '\'antiprism_volume\' argument 2 must be a length' )

    result = getProduct( [ fdiv( fprod( [ n, sqrt( fsub( fmul( 4, cos( cos( fdiv( pi, fmul( n, 2 ) ) ) ) ), 1 ) ),
                                   sin( fdiv( fmul( 3, pi ), fmul( 2, n ) ) ) ] ),
                           fmul( 12, sin( sin( fdiv( pi, n ) ) ) ) ),
                           sin( fdiv( fmul( 3, pi ), fmul( 2, n ) ) ),
                           getPower( k, 3 ) ] )

    return result.convert( 'meter^3' )
コード例 #32
0
def test_odefun_harmonic():
    mp.dps = 15
    # Harmonic oscillator
    f = odefun(lambda x, y: [-y[1], y[0]], 0, [1, 0])
    for x in [0, 1, 2.5, 8, 3.7]:  #  we go back to 3.7 to check caching
        c, s = f(x)
        assert c.ae(cos(x))
        assert s.ae(sin(x))
コード例 #33
0
ファイル: _legendre.py プロジェクト: WarrenWeckesser/mpsci
def _root_approx(n, k):
    # Tricomi approximation
    with mpmath.extradps(5):
        n = mpmath.mpf(n)
        k = mpmath.mpf(k)
        c = 1 + (1 / (8 * n**2)) * (-1 + 1 / n)
        a = mpmath.pi * (4 * k - 1) / (4 * n + 2)
        return c * mpmath.cos(a)
コード例 #34
0
ファイル: GW.py プロジェクト: suri2501/femilaro
def invFourier(x,F):
  k1 = r2*mpm.pi
  f = []
  for xi in x:
    kx = k1*(xi/Lx)
    f.append( mpm.fsum( F[ki]*mpm.cos(kx*mpm.mpf(ki))   \
                          for ki in xrange(len(F))    ) )
  return f
コード例 #35
0
ファイル: approx_cos.py プロジェクト: ruuda/convector
def error(coefs, progress=True):
    (a, b) = coefs
    xs = (x * mp.pi / mp.mpf(4096) for x in range(-4096, 4097))
    err = max(fabs(cos(x) - f(x, a, b)) for x in xs)
    if progress:
        print('(a, b, c): ({}, {}, {})'.format(a, b, c(a, b)))
        print('evaluated error: ', err)
        print()
    return float(err)
コード例 #36
0
		def spin_vector(t):
			import numpy
			ht = self.__ht_time(t)
			H = self.__H_time(t)
			G = d_eval['G']
			Gt = d_eval['\\tilde{G}']
			Hts = d_eval['\\tilde{H}_\\ast']
			Gtxys = sqrt(Gt**2-(Hts-H)**2)
			return numpy.array([x.real for x in [Gtxys*sin(ht),-Gtxys*cos(ht),Hts-H]])
コード例 #37
0
    def rotate_point_around_anchor(self, x, y, anchor_x, anchor_y, angle):
        anglefrac = angle.as_integer_ratio()
        radian_qty = radians(anglefrac[0] / anglefrac[1])

        old_x = x - anchor_x
        old_y = y - anchor_y

        coord = matrix([float(old_x), float(old_y)])
        transform = matrix([[cos(radian_qty), -sin(radian_qty)], [sin(radian_qty), cos(radian_qty)]])
        result = transform * coord

        new_x = Decimal(str(result[0]))
        new_y = Decimal(str(result[1]))

        new_x += anchor_x
        new_y += anchor_y

        return new_x, new_y
コード例 #38
0
def test_odefun_sinc_large():
    mp.dps = 15
    # Sinc function; test for large x
    f = sinc
    g = odefun(lambda x, y: [(cos(x) - y[0]) / x],
               1, [f(1)],
               tol=0.01,
               degree=5)
    assert abs(f(100) - g(100)[0]) / f(100) < 0.01
コード例 #39
0
		def orbit_vector(t):
			import numpy
			ht = self.__ht_time(t)
			hs = self.__hs_time(t)
			h = hs + ht
			H = self.__H_time(t)
			G = d_eval['G']
			Gxy = sqrt(G**2-H**2)
			return numpy.array([x.real for x in [Gxy*sin(h),-Gxy*cos(h),H]])
コード例 #40
0
def polar_cubic(a, q, r):
    '''
    The polar coordinate solution of the cubic function; for use when
    Q^3+R^2 < 0

    This version formulated to work with mpmath for arbitrary floating point
    precision and numpy arrays.
    '''
    theta = mpmath.acos(r / numpy.power(mpf('-1') * numpy.power(q, mpf('3')), mpf('0.5')))
    return mpmath.cos(theta / mpf('3')) * numpy.power(mpf('-1') * q, mpf('0.5')) * mpf('2') - a / mpf('3')
コード例 #41
0
ファイル: sbf_mp.py プロジェクト: tpudlik/sbf
def sph_yn_exact(n, z):
    """Return the value of y_n computed using the exact formula.

    The expression used is http://dlmf.nist.gov/10.49.E4 .

    """
    zm = mpmathify(z)
    s1 = sum((-1)**k*_a(2*k, n)/zm**(2*k+1) for k in xrange(0, int(n/2) + 1))
    s2 = sum((-1)**k*_a(2*k+1, n)/zm**(2*k+2) for k in xrange(0, int((n-1)/2) + 1))
    return -cos(zm - n*pi/2)*s1 + sin(zm - n*pi/2)*s2
コード例 #42
0
ファイル: GW.py プロジェクト: suri2501/femilaro
def Fourier(N,f):
  k1 = r2*mpm.pi
  x  = [-r1/r2+mpm.mpf(i)/mpm.mpf(2*N) for i in xrange(2*N)]
  fx = [f(Lx*xi) for xi in x]
  F = []
  for ki in xrange(N):
    kx = k1*mpm.mpf(ki)
    F.append( mpm.fsum( fi*mpm.cos(kx*xi) for xi,fi in zip(x,fx) ) )
    F[-1] /= mpm.mpf(N)
  F[0] /= r2 # scale the first coefficient (mean value)
  return F
コード例 #43
0
		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)
コード例 #44
0
	def __init__(self,params):
		import sympy
		from mpmath import mpf, sqrt, cos
		from copy import deepcopy
		self.__set_original_H()
		# Set up constants.
		self.__eps_val = (1./mpf(299792458.))**2
		self.__GG_val = mpf(6.673E-11)
		# Setup names.
		names = ['m2','r2','rot2','r1','rot1','i_a','ht','a','e','i','h']
		if not all([s in params for s in names]):
			raise ValueError('invalid set of parameters')
		# Convert all the values to mpf and introduce convenience shortcuts.
		m2, r2, rot2, r1, rot1, i_a, ht_in, a, e, i, h_in = [mpf(params[s]) for s in names]
		L_in = sqrt(self.__GG_val * m2 * a)
		G_in = L_in * sqrt(1. - e**2)
		H_in = G_in * cos(i)
		Gt_in = (2 * r1**2 * rot1) / 5
		Ht_in = Gt_in * cos(i_a)
		Hts_in = H_in + Ht_in
		hs_in = h_in - ht_in
		Gxy_in = sqrt(G_in**2 - H_in**2)
		Gtxys_in = sqrt(Gt_in**2 - Ht_in**2)
		J2 = (2 * m2 * r2**2 * rot2) / 5
		II_1 = mpf(5) / (2 * r1**2)
		# Evaluation dictionary.
		eval_names = [sympy.Symbol(s) for s in ['L','G','H','\\tilde{G}','\\tilde{H}_\\ast','h_\\ast','m_2','\\mathcal{G}','J_2',\
			'\\varepsilon','\\mathcal{I}_1','\\tilde{h}','g']]
		eval_values = [sympy.Float(x) for x in [L_in,G_in,H_in,Gt_in,Hts_in,hs_in,m2,self.__GG_val,J2,self.__eps_val,II_1,ht_in,0]]
		d_eval = dict(zip(eval_names,eval_values))
		self.__init_d_eval = deepcopy(d_eval)
		def diff_f(x,_):
			from sympy import Symbol
			H = x[0]
			hs = x[2]
			d_eval[Symbol('H')] = H
			d_eval[Symbol('h_\\ast')] = hs
			return [d.evalf(subs = d_eval) for d in self.__diffs]
		self.__diff_f = diff_f
コード例 #45
0
ファイル: bombardelli_test.py プロジェクト: KratosCSIC/trunk
def ExactIntegrationOfSinusKernel(t, a = None, b = None):
    with precision(300):
        if a == None and b == None:
            return 0.5 * math.pi * math.sqrt(t) * (mpmath.angerj(0.5, t) - mpmath.angerj(-0.5, t))
        if a == None and b != None:
            a = t
        elif b == None:
            b = 0.
        mpmath.mp.pretty = True
        pi = mpmath.mp.pi
        pi = +pi
        fcos = mpmath.fresnelc
        fsin = mpmath.fresnels
        
        arg_a = mpmath.sqrt(2 * (t - a) / mpmath.mp.pi)
        arg_b = mpmath.sqrt(2 * (t - b) / mpmath.mp.pi) 
        return mpmath.sqrt(2 * mpmath.mp.pi) * ((fsin(arg_b) - fsin(arg_a)) * mpmath.cos(t) + (fcos(arg_a) - fcos(arg_b)) * mpmath.sin(t))
コード例 #46
0
ファイル: MAWS.py プロジェクト: kentgorday/Heidelberg_15
 def rotate(self, identifier, angles, step=1):
     ang_num = 2*math.pi/360
     rotateZ = [math.cos(angles[0]*ang_num),-math.sin(angles[0]*ang_num),0,math.sin(angles[0]*ang_num),math.cos(angles[0]*ang_num),0,0,0,1]
     rotateY = [math.cos(angles[1]*ang_num),0,-math.sin(angles[1]*ang_num),0,1,0,math.sin(angles[1]*ang_num),0,math.cos(angles[1]*ang_num)]
     rotateX = [1,0,0,0,math.cos(angles[2]*ang_num),-math.sin(angles[2]*ang_num),0,math.sin(angles[2]*ang_num),math.cos(angles[2]*ang_num)]
     antirotateZ = [math.cos(-angles[0]*ang_num),-math.sin(-angles[0]*ang_num),0,math.sin(-angles[0]*ang_num),math.cos(-angles[0]*ang_num),0,0,0,1]
     antirotateY = [math.cos(-angles[1]*ang_num),0,-math.sin(-angles[1]*ang_num),0,1,0,math.sin(-angles[1]*ang_num),0,math.cos(-angles[1]*ang_num)]
     antirotateX = [1,0,0,0,math.cos(-angles[2]*ang_num),-math.sin(-angles[2]*ang_num),0,math.sin(-angles[2]*ang_num),math.cos(-angles[2]*ang_num)]
     #self.command("transform "+identifier+""+"{ {%s %s %s} {%s %s %s} {%s %s %s} }"%tuple(rotateZ))
     self.command("transform "+identifier+"."+str(step+1)+"{ {%s %s %s} {%s %s %s} {%s %s %s} }"%tuple(antirotateZ))
     #self.command("transform "+identifier+""+"{ {%s %s %s} {%s %s %s} {%s %s %s} }"%tuple(rotateY))
     self.command("transform "+identifier+"."+str(step+1)+"{ {%s %s %s} {%s %s %s} {%s %s %s} }"%tuple(antirotateY))
     #self.command("transform "+identifier+""+"{ {%s %s %s} {%s %s %s} {%s %s %s} }"%tuple(rotateX))
     self.command("transform "+identifier+"."+str(step+1)+"{ {%s %s %s} {%s %s %s} {%s %s %s} }"%tuple(antirotateX))
     for i in range(0,3):
         self.orientation[i] += angles[i]
コード例 #47
0
ファイル: GW.py プロジェクト: suri2501/femilaro
T0 = time.clock()
THk = []
N2 , a2 = N**2 , a**2
k1 = r2*mpm.pi/Lx
for ki in range(Nk):
  k = k1*mpm.mpf(ki)
  k2 = k**2
  PHI = a2*(k2+l**2) + N2
  tmp = mpm.sqrt(PHI**2 - r4*a2*k2*N2)
  PSIs2 = PHI + tmp
  PSIg2 = PHI - tmp
  den = r2*tmp
  Os = mpm.sqrt(PSIs2/r2)
  Og = mpm.sqrt(PSIg2/r2)
  theta = THk0[ki]                                 \
   * ( (mpm.mpf(2)*N2-PSIg2)/den * mpm.cos(Os*t)   \
      +(PSIs2-mpm.mpf(2)*N2)/den * mpm.cos(Og*t) )
  THk.append(theta)

TH = invFourier((xi-U*t+(Lx/r2-xc) for xi in x),THk)

T1 = time.clock()
print('Computation time: %f'%(T1-T0))

py.figure(3)
py.plot(                            \
  [float(xi+xc) for xi in x] ,  \
  [float(ti) for ti in TH0],        \
  'k-', label='initial condition')
py.plot(                     \
  [float(xi+Lx/r2) for xi in x] ,  \
コード例 #48
0
ファイル: test_guess.py プロジェクト: A-turing-machine/sympy
def test_rationalize():
    from mpmath import cos, pi, mpf
    assert rationalize(cos(pi/3)) == Rational(1, 2)
    assert rationalize(mpf("0.333333333333333")) == Rational(1, 3)
    assert rationalize(mpf("-0.333333333333333")) == Rational(-1, 3)
    assert rationalize(pi, maxcoeff = 250) == Rational(355, 113)
コード例 #49
0
 def ftot(t):
     return mp.cos(mp.cos(t)) * mp.sin(t) * mp.exp(1j * omega * mp.sin(t))
コード例 #50
0
ファイル: test_guess.py プロジェクト: NervenCid/sympy
def test_rationalize():
    from mpmath import cos, pi, mpf
    assert rationalize(cos(pi/3)) == sympify("1/2")
    assert rationalize(mpf("0.333333333333333")) == sympify("1/3")
    assert rationalize(mpf("-0.333333333333333")) == sympify("-1/3")
    assert rationalize(pi, maxcoeff = 250) == sympify("355/113")
コード例 #51
0
        # generate the cordic luts
        import mpmath, operator

        mpmath.mp.prec = 100

        tangents = [mpmath.mpf(0.5) ** i for i in range(0, 61)]
        angles = [mpmath.atan(tan) for tan in tangents]
        circle_fracs = [angle / (mpmath.pi / 2) for angle in angles]

        # To speed up the cordic function, we can ignore fractions that are too
        # small
        circle_fracs = [cf for cf in circle_fracs if cf >= mpmath.mpf(0.5) ** (frac_bits + 2)]

        cordic_lut = [decimal.Decimal(str(c)) for c in circle_fracs]

        ps = [mpmath.cos(angle) for angle in angles]
        p = decimal.Decimal(str(reduce(operator.mul, ps)))
        cordic_p = decimal_to_fix_extrabits(p, internal_frac_bits)
        with args["lutfile"] as f:
            lutc = "#ifndef LUT_H\n"
            lutc += "#define LUT_H\n"
            lutc += "\n"
            lutc += '#include "base.h"\n'
            lutc += '#include "internal.h"\n'
            lutc += "\n"
            lutc += make_c_internal_define_lut(internal_inv_integer_lut, "INT_INV_LUT", "LUT_int_inv_integer")
            lutc += "\n"
            lutc += make_c_internal_defines(ln_coef_lut, "FIX_LN_COEF")
            lutc += "\n"
            lutc += make_c_internal_defines(log2_coef_lut, "FIX_LOG2_COEF")
            lutc += "\n"
コード例 #52
0
ファイル: common_util.py プロジェクト: huba/DepthConfusion
TEST_YELLOW = pygame.Color(255, 0, 255, 255)#-16711681
TEST_BLUE = pygame.Color(0, 0, 255, 255)#-65536

#Visibility flags
SHOW_ALL = 0
ONLY_SHOW_EXPOSED = 1

#135 degrees
THETA = 3 * mp.pi / 4

#Isometric Unprojection
UNPROJECT = mp.matrix([[1,  0, 0],
                       [0, -1, 0], #NOTE: the y coordinate has to be inverted because my
                       [0,  0, 1]]) #grid coordinates are a bit weird

UNPROJECT *= mp.matrix([[ mp.cos(THETA),  mp.sin(THETA), 0],
                       [-mp.sin(THETA),  mp.cos(THETA), 0],
                       [             0,              0, 1]])

UNPROJECT *= mp.matrix([[1, 0, 0],
                        [0, 2, 0],
                        [0, 0, 1]])


class OutOfIt(Exception):
	def __init__(self, msg, value):
		self.msg = msg
		self.value = value
	
	
	def __repr__(self):
コード例 #53
0
ファイル: wrap_noise.py プロジェクト: DiNAi/hueperlin
# coding: utf-8

# In[1]:

import mpmath
import random


# In[4]:

scurve_1=lambda x:x
scurve_inf=lambda x:0.5*(1-mpmath.cos(x*mpmath.pi))
class WrapNoise:
    def __init__(self, kappa=0.001, frequency=1.0,
                 scurve=scurve_inf, seed=0):
        self._kappa = mpmath.mpf(kappa)
        self._period = 1.0/self._kappa
        self.frequency = frequency
        self._tau = 2*mpmath.pi
        self._seed = seed
        self._rng = random.Random(self._seed)
        self.scurve = scurve
        self.initialise_cache()
    def scale_t(self,t):
        return t*self.frequency
    def tau(self):
        return self._tau
    def initialise_cache(self):
        self._angle_cache = {}
        self._wrap_cache = {}
コード例 #54
0
ファイル: stark.py プロジェクト: bluescarni/stark_weierstrass
	def cart_state(self,tau):
		from mpmath import cos, sin
		xi,eta,phi = self.state(tau)
		return xi*eta*cos(phi),xi*eta*sin(phi),(xi**2 - eta**2)/2
コード例 #55
0
def cos(op):
    op = convertToRadians(op)
    return mpmath.cos(op)
コード例 #56
0
	def __set_params(self,d):
		from copy import deepcopy
		from mpmath import mpf, sqrt, polyroots, cos, acos, pi, mp
		from weierstrass_elliptic import weierstrass_elliptic as we
		names = ['m2','r2','rot2','r1','rot1','i_a','ht','a','e','i','h']
		if not all([s in d for s in names]):
			raise ValueError('invalid set of parameters')
		# Convert all the values to mpf and introduce convenience shortcuts.
		m2, r2, rot2, r1, rot1, i_a, ht_in, a, e, i, h_in = [mpf(d[s]) for s in names]
		L_in = sqrt(self.__GG_val * m2 * a)
		G_in = L_in * sqrt(1. - e**2)
		H_in = G_in * cos(i)
		Gt_in = (2 * r1**2 * rot1) / 5
		Ht_in = Gt_in * cos(i_a)
		Hts_in = H_in + Ht_in
		hs_in = h_in - ht_in
		Gxy_in = sqrt(G_in**2 - H_in**2)
		Gtxys_in = sqrt(Gt_in**2 - Ht_in**2)
		J2 = (2 * m2 * r2**2 * rot2) / 5
		II_1 = mpf(5) / (2 * r1**2)
		# Evaluation dictionary.
		eval_names = ['L','G','H','\\tilde{G}','\\tilde{H}_\\ast','h_\\ast','\\tilde{G}_{xy\\ast}','m_2','\\mathcal{G}','J_2','G_{xy}',\
			'\\varepsilon','\\mathcal{I}_1']
		eval_values = [L_in,G_in,H_in,Gt_in,Hts_in,hs_in,Gtxys_in,m2,self.__GG_val,J2,Gxy_in,self.__eps_val,II_1]
		d_eval = dict(zip(eval_names,eval_values))
		# Evaluate Hamiltonian with initial conditions.
		HHp_val = self.__HHp.trim().evaluate(d_eval)
		# Add the value of the Hamiltonian to the eval dictionary.
		d_eval['\\mathcal{H}^\\prime'] = HHp_val
		# Evaluate g2 and g3.
		g2_val, g3_val = self.__g2.trim().evaluate(d_eval), self.__g3.trim().evaluate(d_eval)
		# Create the Weierstrass object.
		wp = we(g2_val,g3_val)
		# Store the period.
		self.__wp_period = wp.periods[0]
		# Now let's find the roots of the quartic polynomial.
		# NOTE: in theory here we could use the exact solution for the quartic.
		p4coeffs = [t[0] * t[1].trim().evaluate(d_eval) for t in zip([1,4,6,4,1],self.__f4_cf)]
		p4roots, err = polyroots(p4coeffs,error = True, maxsteps = 1000)
		# Find a reachable root.
		Hr, H_max, n_lobes, lobe_idx = self.__reachable_root(p4roots,H_in)
		# Determine t_r
		t_r = self.__compute_t_r(n_lobes,lobe_idx,H_in,Hr,d_eval,p4roots,p4coeffs[0])
		# Now evaluate the derivatives of the polynomial. We will need to replace H_in with Hr in the eval dict.
		d_eval['H'] = Hr
		_, f4Hp, f4Hpp, _, _ = self.__f4
		f4p_eval = f4Hp.trim().evaluate(d_eval)
		f4pp_eval = f4Hpp.trim().evaluate(d_eval)
		# Build and store the expression for H(t).
		self.__H_time = lambda t: Hr + f4p_eval / (4 * (wp.P(t - t_r) - f4pp_eval / 24))
		# H will not be needed any more, replace with H_r
		del d_eval['H']
		d_eval['H_r'] = Hr
		# Inject the invariants and the other two constants into the evaluation dictionary.
		d_eval['g_2'] = g2_val
		d_eval['g_3'] = g3_val
		d_eval['A'] = f4p_eval / 4
		d_eval['B'] = f4pp_eval / 24
		# Verify the formulae in solutions.py
		self.__verify_solutions(d_eval)
		# Assuming g = 0 as initial angle.
		self.__g_time = spin_gr_theory.__get_g_time(d_eval,t_r,0.)
		self.__hs_time = spin_gr_theory.__get_hs_time(d_eval,t_r,hs_in)
		self.__ht_time = spin_gr_theory.__get_ht_time(d_eval,t_r,ht_in)
		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)
		self.__obliquity_time = obliquity
		def spin_vector(t):
			import numpy
			ht = self.__ht_time(t)
			H = self.__H_time(t)
			G = d_eval['G']
			Gt = d_eval['\\tilde{G}']
			Hts = d_eval['\\tilde{H}_\\ast']
			Gtxys = sqrt(Gt**2-(Hts-H)**2)
			return numpy.array([x.real for x in [Gtxys*sin(ht),-Gtxys*cos(ht),Hts-H]])
		self.__spin_vector_time = spin_vector
		def orbit_vector(t):
			import numpy
			ht = self.__ht_time(t)
			hs = self.__hs_time(t)
			h = hs + ht
			H = self.__H_time(t)
			G = d_eval['G']
			Gxy = sqrt(G**2-H**2)
			return numpy.array([x.real for x in [Gxy*sin(h),-Gxy*cos(h),H]])
		self.__orbit_vector_time = orbit_vector
		# Store the params of the system.
		self.__params = dict(zip(names,[mpf(d[s]) for s in names]))
		# Final report.
		rad_conv = 360 / (2 * pi())
		print("\x1b[31mAccuracy in the identification of the poly roots:\x1b[0m")
		print(err)
		print("\n\x1b[31mPeriod (years):\x1b[0m")
		print(wp.periods[0] / (3600*24*365))
		print("\n\x1b[31mMin and max orbital inclination (deg):\x1b[0m")
		print(acos(Hr/G_in) * rad_conv,acos(H_max/G_in) * rad_conv)
		print("\n\x1b[31mMin and max axial inclination (deg):\x1b[0m")
		print(acos((Hts_in - Hr)/Gt_in) * rad_conv,acos((Hts_in-H_max)/Gt_in)  * rad_conv)
		print("\n\x1b[31mNumber of lobes:\x1b[0m " + str(n_lobes))
		print("\n\x1b[31mLobe idx:\x1b[0m " + str(lobe_idx))
		# Report the known results for simplified system for comparison.
		H = H_in
		HHp,G,L,GG,eps,m2,Hts,Gt,J2 = [d_eval[s] for s in ['\\mathcal{H}^\\prime','G','L','\\mathcal{G}',\
			'\\varepsilon','m_2','\\tilde{H}_\\ast','\\tilde{G}','J_2']]
		print("\n\x1b[31mEinstein (g):\x1b[0m " + str((3 * eps * GG**4 * m2**4/(G**2*L**3))))
		print("\n\x1b[31mLense-Thirring (g):\x1b[0m " + str(((eps * ((-6*H*J2*GG**4*m2**3)/(G**4*L**3)+3*GG**4*m2**4/(G**2*L**3))))))
		print("\n\x1b[31mLense-Thirring (h):\x1b[0m " + str((2*eps*J2*GG**4*m2**3/(G**3*L**3))))
		# These are the Delta_ constants of quasi-periodicity.
		f_period = self.wp_period
		print("\n\x1b[31mDelta_g:\x1b[0m " + str(self.g_time(f_period) - self.g_time(0)))
		print("\n\x1b[31mg_rate:\x1b[0m " + str((self.g_time(f_period) - self.g_time(0))/f_period))
		Delta_hs = self.hs_time(f_period) - self.hs_time(0)
		print("\n\x1b[31mDelta_hs:\x1b[0m " + str(Delta_hs))
		print("\n\x1b[31mhs_rate:\x1b[0m " + str(Delta_hs/f_period))
		Delta_ht = self.ht_time(f_period) - self.ht_time(0)
		print("\n\x1b[31mDelta_ht:\x1b[0m " + str(Delta_ht))
		print("\n\x1b[31mht_rate:\x1b[0m " + str(Delta_ht/f_period))
		print("\n\x1b[31mDelta_h:\x1b[0m " + str(Delta_ht+Delta_hs))
		print("\n\x1b[31mh_rate:\x1b[0m " + str((Delta_ht+Delta_hs)/f_period))
		print("\n\n")
コード例 #57
0
ファイル: test_ode.py プロジェクト: 1zinnur9/pymaclab
def test_odefun_sinc_large():
    mp.dps = 15
    # Sinc function; test for large x
    f = sinc
    g = odefun(lambda x, y: [(cos(x)-y[0])/x], 1, [f(1)], tol=0.01, degree=5)
    assert abs(f(100) - g(100)[0])/f(100) < 0.01
コード例 #58
0
 def ftot(t):
     cos2t = mp.cos(t) ** 2
     return mp.exp(-z1 / cos2t) / cos2t * mp.exp(1j * omega * mp.cos(t - beta) / cos2t)
コード例 #59
0
ファイル: rpnPolynomials.py プロジェクト: flawr/rpn
def solveCubicPolynomial( a, b, c, d ):
    if mp.dps < 50:
        mp.dps = 50

    if a == 0:
        return solveQuadraticPolynomial( b, c, d )

    f = fdiv( fsub( fdiv( fmul( 3, c ), a ), fdiv( power( b, 2 ), power( a, 2 ) ) ), 3 )

    g = fdiv( fadd( fsub( fdiv( fmul( 2, power( b, 3 ) ), power( a, 3 ) ),
                          fdiv( fprod( [ 9, b, c ] ), power( a, 2 ) ) ),
                    fdiv( fmul( 27, d ), a ) ), 27 )
    h = fadd( fdiv( power( g, 2 ), 4 ), fdiv( power( f, 3 ), 27 ) )

    # all three roots are the same
    if h == 0:
        x1 = fneg( root( fdiv( d, a ), 3 ) )
        x2 = x1
        x3 = x2
    # two imaginary and one real root
    elif h > 0:
        r = fadd( fneg( fdiv( g, 2 ) ), sqrt( h ) )

        if r < 0:
            s = fneg( root( fneg( r ), 3 ) )
        else:
            s = root( r, 3 )

        t = fsub( fneg( fdiv( g, 2 ) ), sqrt( h ) )

        if t < 0:
            u = fneg( root( fneg( t ), 3 ) )
        else:
            u = root( t, 3 )

        x1 = fsub( fadd( s, u ), fdiv( b, fmul( 3, a ) ) )

        real = fsub( fdiv( fneg( fadd( s, u ) ), 2 ), fdiv( b, fmul( 3, a ) ) )
        imaginary = fdiv( fmul( fsub( s, u ), sqrt( 3 ) ), 2 )

        x2 = mpc( real, imaginary )
        x3 = mpc( real, fneg( imaginary ) )
    # all real roots
    else:
        j = sqrt( fsub( fdiv( power( g, 2 ), 4 ), h ) )
        k = acos( fneg( fdiv( g, fmul( 2, j ) ) ) )

        if j < 0:
            l = fneg( root( fneg( j ), 3 ) )
        else:
            l = root( j, 3 )

        m = cos( fdiv( k, 3 ) )
        n = fmul( sqrt( 3 ), sin( fdiv( k, 3 ) ) )
        p = fneg( fdiv( b, fmul( 3, a ) ) )

        x1 = fsub( fmul( fmul( 2, l ), cos( fdiv( k, 3 ) ) ), fdiv( b, fmul( 3, a ) ) )
        x2 = fadd( fmul( fneg( l ), fadd( m, n ) ), p )
        x3 = fadd( fmul( fneg( l ), fsub( m, n ) ), p )

    return [ chop( x1 ), chop( x2 ), chop( x3 ) ]
コード例 #60
0
ファイル: exptrig.py プロジェクト: vpereira/Mathics
 def eval(self, z):
     return mpmath.cos(z)