math.asin

All Samples(400) | Call(316) | Derive(0) | Import(84)

asin(x)

Return the arc sine (measured in radians) of x.

src/o/b/obspy-HEAD/obspy.signal/trunk/obspy/signal/rotate.py obspy(Download)

 
import warnings
import numpy as np
from math import sqrt, pi, sin, cos, asin, tan, atan, atan2
 
 
def rotate_NE_RT(n, e, ba):

        Cos_sigma = sin(U1) * sin(U2) + cos(U1) * cos(U2) * cos(dlon)
        sigma = atan2(Sin_sigma, Cos_sigma)
        Sin_alpha = cos(U1) * cos(U2) * sin(dlon) / sin(sigma)
        alpha = asin(Sin_alpha)
        Cos2sigma_m = cos(sigma) - (2 * sin(U1) * sin(U2) / pow(cos(alpha), 2))
        C = (f / 16) * pow(cos(alpha), 2) * \
            (4 + f * (4 - 3 * pow(cos(alpha), 2)))

src/a/s/Astropysics-0.1.dev-r699/astropysics/coords/coordsys.py Astropysics(Download)

            else:
                if cycle > 0:
                    #this means use "triangle wave" pattern with the given quarter-period 
                    from math import sin,asin
                    offset = low/(low-up)-0.5
                    return (up-low)*(asin(sin(pi*(2*rads/cycle+offset)))/pi+0.5)+low
                else:

    def __sub__(self,other):        
        if isinstance(other,self.__class__):
            from math import cos,degrees,acos,asin,sin,sqrt
 
            b1 = self._lat.radians
            b2 = other._lat.radians
            db = abs(b2 - b1)

 
            havsep = hdb + cos(b1)*cos(b2)*hdl
            #archaversin
            sep = acos(1 - 2*havsep) if 0.25 < havsep <= 0.75 else 2*asin(havsep**0.5)
 
            #straightforward definition without the tweaks using haversin - this
            #is in principal faster, but in practice it ends up only about

src/w/e/weewx-HEAD/trunk/experimental/astral.py weewx(Download)

 
import datetime
import time
from math import cos, sin, tan, acos, asin, atan2, floor, radians, degrees
 
__version__ = "0.3+"
__author__ = "Simon Kennedy <python@sffjunkie.co.uk>"

def _sun_declination(juliancentury):
    e = _obliquity_correction(juliancentury)
    lambd = _sun_apparent_long(juliancentury)
 
    sint = sin(radians(e)) * sin(radians(lambd))
    return degrees(asin(sint))

src/t/i/timba-HEAD/Frameworks/Cattery/Meow/Direction.py timba(Download)

from Parameterization import *
import Jones
import Context
from math import cos,sin,acos,asin,sqrt,pi
 
def radec_to_lmn (ra,dec,ra0,dec0):
  """Returns l,m,n corresponding to direction ra,dec w.r.t. direction ra0,dec0""";

def lm_to_radec (l,m,ra0,dec0):
  """Returns ra,dec corresponding to l,m w.r.t. direction ra0,dec0""";
  cosdec0 = cos(dec0);
  # subpolar formula
  if cosdec0:
    ra = ra0 + asin(l)/cosdec0;
    dec = dec0 + asin(m);

      ra -= 2*pi;
  # polar formula, not sure if it's correct
  else:
    m = asin(m);
    l = asin(l);
    ra = atan2(m,l);
    if dec0 > 0:

src/o/b/obspy.signal-0.4.0/obspy/signal/rotate.py obspy.signal(Download)

 
import warnings
import numpy as np
from math import sqrt, pi, sin, cos, asin, tan, atan, atan2
 
 
def rotate_NE_RT(n, e, ba):

        Cos_sigma = sin(U1) * sin(U2) + cos(U1) * cos(U2) * cos(dlon)
        sigma = atan2(Sin_sigma, Cos_sigma)
        Sin_alpha = cos(U1) * cos(U2) * sin(dlon) / sin(sigma)
        alpha = asin(Sin_alpha)
        Cos2sigma_m = cos(sigma) - (2 * sin(U1) * sin(U2) / pow(cos(alpha), 2))
        C = (f / 16) * pow(cos(alpha), 2) * \
            (4 + f * (4 - 3 * pow(cos(alpha), 2)))

src/a/g/agtl-0.7.1.0-freerunner0/advancedcaching/astral.py agtl(Download)

# Shortened for AGTL by Daniel Fett 
 
import datetime
from math import cos, sin, tan, acos, asin, atan2, floor, radians, degrees
 
SUN_POSITION_CACHE_DURATION = 3600 # seconds

    def _sun_declination(self, juliancentury):
        e = self._obliquity_correction(juliancentury)
        lambd = self._sun_apparent_long(juliancentury)
 
        sint = sin(radians(e)) * sin(radians(lambd))
        return degrees(asin(sint))

src/a/n/analyticgeom-HEAD/trunk/modulos/Cuadricas.py analyticgeom(Download)

from pivy.coin import *
from PyQt4 import QtGui, QtCore, uic
from modulos.util import main, lee,  conecta
from math import sqrt, cos, sin, asin, pi, pow
from MallaBase2 import MallaBase,  ParametricPlot3D,  creaVars,  Eq,  creaVarParam, creaOpParam
from Visor import Visor
#import psyco

    def rango(self,w=0):
        tmax = pi/2
        if w > 2.0/3.0:
            tmax = asin((-6 + 7*w)/(sqrt((-2 + w)**2/(-1 + w)**2)*(-1 + w)))
        return (-pi/2,tmax, 40)
 
class F3a4(MallaBase):

    def rango(self,w=0):
        rmin = -pi/2
        rmax = 3.0/2.0 * pi
        if w > 17.0/21.0:
            r56 = asin((12 - 13*w)/((-1 + w)*sqrt((8 + (-8 + w)*w)/(-1 + w)**2)))
            rmin = r56
            rmax = pi - r56

    def rangot(self, w=0):
        t0 = -asin((2 * (-6+7 * w))/(7 * (-1+w) * sqrt((16-16 * w+w**2)/(-1+w)**2)))
        tmin = t0
#        tmin = -pi/2
        if w<.89:
            tmin = -pi/2
        dif = tmin + pi/2

src/a/s/astromate-HEAD/trunk/astromate/units.py astromate(Download)

"AstroMate units"
# vim: set fileencoding=UTF-8 :
# -*- coding: UTF-8 -*-
 
import gettext
 
from math import pi, sin, cos, asin, sqrt, radians, degrees, atan2

			dDec = coord1.dec - coord2.dec
			# Sinnott's formula for angular separation 
			C = sin(radians(dDec)/2)**2 + cos(radians(coord1.dec))*cos(radians(coord2.dec)) * sin(radians(dRA)/2)**2
			self.__sep = degrees( 2 * asin( sqrt (abs(C)) ) )
			# initial bearing
			y = sin(radians(dRA)) * cos(radians(coord2.dec))
			x = cos(radians(coord1.dec))*sin(radians(coord2.dec)) - sin(radians(coord1.dec))*cos(radians(coord2.dec))*cos(radians(dRA))

	def __add__(self, other):
		if not isinstance(other, Coordinate):
			raise TypeError("Invalid parameter type %s"%repr(type(other)))
		destDec = asin( sin(radians(other.dec))*cos(radians(self.__sep)) + cos(radians(other.dec))*sin(radians(self.__sep))*cos(radians(self.__bear)) );
 
		destRA = radians(other.RA) + atan2( sin(radians(self.__bear))*sin(radians(self.__sep))*cos(radians(other.dec)), cos(radians(self.__sep))-sin(radians(other.dec))*sin(destDec));

src/a/n/analyticgeom-HEAD/modulos/Cuadricas.py analyticgeom(Download)

from pivy.coin import *
from PyQt4 import QtGui, QtCore, uic
from modulos.util import main, lee,  conecta
from math import sqrt, cos, sin, asin, pi, pow
from MallaBase2 import MallaBase,  ParametricPlot3D,  creaVars,  Eq,  creaVarParam, creaOpParam
from Visor import Visor
#import psyco

    def rango(self,w=0):
        tmax = pi/2
        if w > 2.0/3.0:
            tmax = asin((-6 + 7*w)/(sqrt((-2 + w)**2/(-1 + w)**2)*(-1 + w)))
        return (-pi/2,tmax, 40)
 
class F3a4(MallaBase):

    def rango(self,w=0):
        rmin = -pi/2
        rmax = 3.0/2.0 * pi
        if w > 17.0/21.0:
            r56 = asin((12 - 13*w)/((-1 + w)*sqrt((8 + (-8 + w)*w)/(-1 + w)**2)))
            rmin = r56
            rmax = pi - r56

    def rangot(self, w=0):
        t0 = -asin((2 * (-6+7 * w))/(7 * (-1+w) * sqrt((16-16 * w+w**2)/(-1+w)**2)))
        tmin = t0
#        tmin = -pi/2
        if w<.89:
            tmin = -pi/2
        dif = tmin + pi/2

src/a/s/astral-0.3/src/astral.py astral(Download)

"""
 
import datetime
from math import cos, sin, tan, acos, asin, atan2, floor, radians, degrees
 
try:
    import pytz

    def _sun_declination(self, juliancentury):
        e = self._obliquity_correction(juliancentury)
        lambd = self._sun_apparent_long(juliancentury)
 
        sint = sin(radians(e)) * sin(radians(lambd))
        return degrees(asin(sint))

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 Next