ó šßÈ[c@`sedZddlmZmZmZmZddlZddlmZddl Z ddl m Z ddl mZdd l mZdd lmZdd lmZd d dgZeddddfƒZeddddfƒZedddddfƒZdejfd„ƒYZd„Zdefd„ƒYZdejfd„ƒYZdefd„ƒYZ dS( u\ This module contains the fundamental classes used for representing coordinates in astropy. i(tabsolute_importtdivisiontprint_functiontunicode_literalsN(t namedtuplei(tsixi(tangle_utilities(tunits(t isiterable(tNUMPY_LT_1_14_1uAngleuLatitudeu Longitudeu hms_tupleuhumusu dms_tupleudusigned_dms_tupleusigntAnglec B`sìeZdZejZeZdded„Z e d„ƒZ e d„ƒZ d„Z ed„ƒZed„ƒZed„ƒZed„ƒZded deed dd „Zed „Zddd „Zdd„Zd„Zd„ZRS(u: One or more angular value(s) with units equivalent to radians or degrees. An angle can be specified either as an array, scalar, tuple (see below), string, `~astropy.units.Quantity` or another :class:`~astropy.coordinates.Angle`. The input parser is flexible and supports a variety of formats:: Angle('10.2345d') Angle(['10.2345d', '-20d']) Angle('1:2:30.43 degrees') Angle('1 2 0 hours') Angle(np.arange(1, 8), unit=u.deg) Angle('1°2′3″') Angle('1d2m3.4s') Angle('-1h2m3s') Angle('-1h2.5m') Angle('-1:2.5', unit=u.deg) Angle((10, 11, 12), unit='hourangle') # (h, m, s) Angle((-1, 2, 3), unit=u.deg) # (d, m, s) Angle(10.2345 * u.deg) Angle(Angle(10.2345 * u.deg)) Parameters ---------- angle : `~numpy.array`, scalar, `~astropy.units.Quantity`, :class:`~astropy.coordinates.Angle` The angle value. If a tuple, will be interpreted as ``(h, m, s)`` or ``(d, m, s)`` depending on ``unit``. If a string, it will be interpreted following the rules described above. If ``angle`` is a sequence or array of strings, the resulting values will be in the given ``unit``, or if `None` is provided, the unit will be taken from the first given value. unit : `~astropy.units.UnitBase`, str, optional The unit of the value specified for the angle. This may be any string that `~astropy.units.Unit` understands, but it is better to give an actual unit object. Must be an angular unit. dtype : `~numpy.dtype`, optional See `~astropy.units.Quantity`. copy : bool, optional See `~astropy.units.Quantity`. Raises ------ `~astropy.units.UnitsError` If a unit is not provided or it is not an angular unit. cC`sqt|tjƒsI|dk r9|jtj|ƒƒ}nt|tƒr]|j||ƒ}qIt|tj ƒrêt j ||ƒ\}}|dkrœ|}nt|tƒrÀ|j||ƒ}n||k rFtj||dt ƒ}qFqIt |ƒrIt|tjƒo|jjdk rIg|D]}t||dt ƒ^q"}qIntt|ƒj|||d|d|ƒS(NtcopyuSUVOtdtype(t isinstancetutQuantitytNonet_convert_unit_to_angle_unittUnitttuplet_tuple_to_floatRt string_typestutilt parse_angletFalseRtnptndarrayR tkindR tsupert__new__(tclstangletunitR R t angle_unittx((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRWs&     .!cC`sW|tjkrtj|ŒS|tjkr8tj|ŒStjdj||ƒƒ‚dS(u Converts an angle represented as a 3-tuple or 2-tuple into a floating point number in the given unit. u!Can not parse '{0}' as unit '{1}'N(Rt hourangleRt hms_to_hourstdegreetdms_to_degreest UnitsErrortformat(RR ((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRts    cC`s|tjkrtjS|S(N(RthourR#(R ((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRƒscC`s#tt|ƒj|j|ƒƒdS(N(RR t _set_unitR(tselfR ((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR*‡scC`s|jS(uB The angle's value in hours (read-only property). (R#(R+((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR)ŠscC`sttj|jƒŒS(uƒ The angle's value in hours, as a named tuple with ``(h, m, s)`` members. (This is a read-only property.) (t hms_tupleRt hours_to_hmsR#(R+((s9lib/python2.7/site-packages/astropy/coordinates/angles.pythms‘scC`sttj|jƒŒS(u… The angle's value in degrees, as a named tuple with ``(d, m, s)`` members. (This is a read-only property.) (t dms_tupleRtdegrees_to_dmsR%(R+((s9lib/python2.7/site-packages/astropy/coordinates/angles.pytdms™scC`s.ttj|jƒtjtj|jƒƒŒS(uŒ The angle's value in degrees, as a named tuple with ``(sign, d, m, s)`` members. The ``d``, ``m``, ``s`` are thus always positive, and the sign of the angle is given by ``sign``. (This is a read-only property.) This is primarily intended for use with `dms` to generate string representations of coordinates that are correct for negative angles. (tsigned_dms_tupleRtsignR%RR0tabs(R+((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyt signed_dms¡s ufromunitic `se|d kr|j}n|jtj|ƒƒ}iidtj6dtj6d 6idddgtj6dddgtj6d 6id tj6d tj6d 6} ˆd krïˆ| krÉtdjˆƒƒ‚n| ˆ} || krï| |‰qïn|tjkrx|r?|j} ˆd k r3dt ˆƒdj‰qudj‰q ˆd krTd‰n|j} ‡‡‡‡fd†‰n”|tjkr|rÈ|j } ˆd k r¼dt ˆƒdj‰qþdj‰q ˆd krÝd‰n|j } ‡‡‡‡fd†‰n |j tj ƒrý|rZ|j |ƒ} ˆd k rNdt ˆƒdj‰qúdj‰q ˆd krâ|j |ƒ} |jdˆƒ‰ˆd kr£ˆdd!‰nˆd k rʇ‡fd†} | ‰qú‡fd†} | ‰q tdj|jƒƒ‚ntjdƒ‚‡‡‡fd†} tj| ddgƒ}|| ƒ}|jdkra|d!}n|S("u A string representation of the angle. Parameters ---------- unit : `~astropy.units.UnitBase`, optional Specifies the unit. Must be an angular unit. If not provided, the unit used to initialize the angle will be used. decimal : bool, optional If `True`, a decimal representation will be used, otherwise the returned string will be in sexagesimal form. sep : str, optional The separator between numbers in a sexagesimal representation. E.g., if it is ':', the result is ``'12:41:11.1241'``. Also accepts 2 or 3 separators. E.g., ``sep='hms'`` would give the result ``'12h41m11.1241s'``, or sep='-:' would yield ``'11-21:17.124'``. Alternatively, the special string 'fromunit' means 'dms' if the unit is degrees, or 'hms' if the unit is hours. precision : int, optional The level of decimal precision. If ``decimal`` is `True`, this is the raw precision, otherwise it gives the precision of the last place of the sexagesimal representation (seconds). If `None`, or not provided, the number of decimal places is determined by the value, and will be between 0-8 decimal places as required. alwayssign : bool, optional If `True`, include the sign no matter what. If `False`, only include the sign if it is negative. pad : bool, optional If `True`, include leading zeros when needed to ensure a fixed number of characters for sexagesimal representation. fields : int, optional Specifies the number of fields to display when outputting sexagesimal notation. For example: - fields == 1: ``'5d'`` - fields == 2: ``'5d45m'`` - fields == 3: ``'5d45m32.5s'`` By default, all fields are displayed. format : str, optional The format of the result. If not provided, an unadorned string is returned. Supported values are: - 'latex': Return a LaTeX-formatted string - 'unicode': Return a string containing non-ASCII unicode characters, such as the degree symbol Returns ------- strrepr : str or array A string representation of the angle. If the angle is an array, this will be an array with a unicode dtype. udmsuhmsu^\circu {}^\primeu{}^{\prime\prime}u ^\mathrm{h}u ^\mathrm{m}u ^\mathrm{s}ulatexu°′″uÊ°áµË¢uunicodeufromunituUnknown format '{0}'u{0:0.uf}u{0:g}c `s%tj|dˆdˆdˆdˆƒS(Nt precisiontseptpadtfields(Rtdegrees_to_string(R"(R9R8R6R7(s9lib/python2.7/site-packages/astropy/coordinates/angles.pytsc `s%tj|dˆdˆdˆdˆƒS(NR6R7R8R9(Rthours_to_string(R"(R9R8R6R7(s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR;&su{0:1.R(iiÿÿÿÿc`sdtˆƒdj|ˆƒS(Nu{0:0.uf}{1}(tstrR((tval(R6t unit_string(s9lib/python2.7/site-packages/astropy/coordinates/angles.pytplain_unit_format8sc`sdj|ˆƒS(Nu{0:g}{1}(R((R>(R?(s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR@=su4'{0}' can not be represented in sexagesimal notationu/The unit value provided is not an angular unit.c`sWˆt|ƒƒ}ˆr5|jdƒ r5d|}nˆdkrSdj|ƒ}n|S(Nu-u+ulatexu${0}$(tfloatt startswithR((R>ts(t alwayssignR(tfunc(s9lib/python2.7/site-packages/astropy/coordinates/angles.pyt do_formatJs   totypesuUiN((RR RRRR%R#t ValueErrorR(R=R)t is_equivalenttradiantto_valuet to_stringtnameR'Rt vectorizetndim(R+R tdecimalR7R6RDR8R9R(t separatorstsepstvaluesR@RFt format_ufunctresult((RDR9R(RER8R6R7R?s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRL®s„D                              cC`sSt|ƒ}tj||dtjƒdtj|}|rK||d>> from astropy.coordinates import Angle >>> import astropy.units as u >>> a = Angle([-20.0, 150.0, 350.0] * u.deg) >>> a.wrap_at(360 * u.deg).degree # Wrap into range 0 to 360 degrees # doctest: +FLOAT_CMP array([340., 150., 350.]) >>> a.wrap_at('180d', inplace=True) # Wrap into range -180 to 180 degrees # doctest: +FLOAT_CMP >>> a.degree # doctest: +FLOAT_CMP array([-20., 150., -10.]) Parameters ---------- wrap_angle : str, `Angle`, angular `~astropy.units.Quantity` Specifies a single value for the wrap angle. This can be any object that can initialize an `Angle` object, e.g. ``'180d'``, ``180 * u.deg``, or ``Angle(180, unit=u.deg)``. inplace : bool If `True` then wrap the object in place instead of returning a new `Angle` Returns ------- out : Angle or `None` If ``inplace is False`` (default), return new `Angle` object with angles wrapped accordingly. Otherwise wrap in place and return `None`. g€v@N((R RtmodRtdeg(R+t wrap_angletinplacetwrapped((s9lib/python2.7/site-packages/astropy/coordinates/angles.pytwrap_atYs ) , cC`srt}|dk r4|tjt|ƒ|kƒM}n|rh|dk rh|tj|t|ƒkƒM}nt|ƒS(u Check if all angle(s) satisfy ``lower <= angle < upper`` If ``lower`` is not specified (or `None`) then no lower bounds check is performed. Likewise ``upper`` can be left unspecified. For example:: >>> from astropy.coordinates import Angle >>> import astropy.units as u >>> a = Angle([-20, 150, 350] * u.deg) >>> a.is_within_bounds('0d', '360d') False >>> a.is_within_bounds(None, '360d') True >>> a.is_within_bounds(-30 * u.deg, None) True Parameters ---------- lower : str, `Angle`, angular `~astropy.units.Quantity`, `None` Specifies lower bound for checking. This can be any object that can initialize an `Angle` object, e.g. ``'180d'``, ``180 * u.deg``, or ``Angle(180, unit=u.deg)``. upper : str, `Angle`, angular `~astropy.units.Quantity`, `None` Specifies upper bound for checking. This can be any object that can initialize an `Angle` object, e.g. ``'180d'``, ``180 * u.deg``, or ``Angle(180, unit=u.deg)``. Returns ------- is_within_bounds : bool `True` if all angles satisfy ``lower <= angle < upper`` N(tTrueRRtallR tbool(R+tlowertuppertok((s9lib/python2.7/site-packages/astropy/coordinates/angles.pytis_within_boundsŠs ! ""c`s]ˆjrˆjdˆƒStr1‡fd†}n‡‡fd†}tjˆdi|d6ƒS(NR(c`s|jdˆƒS(NR((RL(R"(R((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyt formatter·sc`sˆj|ƒjdˆƒS(NR((t _new_viewRL(R"(R(R+(s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRc¼sRcuall(tisscalarRLR Rt array2string(R+R(Rc((R(R+s9lib/python2.7/site-packages/astropy/coordinates/angles.pyt _str_helper²s  cC`s |jƒS(N(Rg(R+((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyt__str__ÁscC`s|jddƒS(NR(ulatex(Rg(R+((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyt _repr_latex_ÄsN(t__name__t __module__t__doc__RRJt_equivalent_unitR\t _include_easy_conversion_membersRRt staticmethodRRR*tpropertyR)R.R1R5RRLR[RbRgRhRi(((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR s&4    © 1(  cC`sCt|tƒr#td„|DƒƒSt|tƒr?|jtƒS|S(uÃReturn any Angle subclass objects as an Angle objects. This is used to ensure that Latitude and Longitude change to Angle objects when they are used in calculations (such as lon/2.) cs`s|]}t|ƒVqdS(N(t_no_angle_subclass(t.0t_obj((s9lib/python2.7/site-packages/astropy/coordinates/angles.pys Ïs(R RR tview(tobj((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRqÈstLatitudecB`sDeZdZdd„Zdd„Zd„Zdd„Zd„ZRS(u¹ Latitude-like angle(s) which must be in the range -90 to +90 deg. A Latitude object is distinguished from a pure :class:`~astropy.coordinates.Angle` by virtue of being constrained so that:: -90.0 * u.deg <= angle(s) <= +90.0 * u.deg Any attempt to set a value outside that range will result in a `ValueError`. The input angle(s) can be specified either as an array, list, scalar, tuple (see below), string, :class:`~astropy.units.Quantity` or another :class:`~astropy.coordinates.Angle`. The input parser is flexible and supports all of the input formats supported by :class:`~astropy.coordinates.Angle`. Parameters ---------- angle : array, list, scalar, `~astropy.units.Quantity`, `Angle`. The angle value(s). If a tuple, will be interpreted as ``(h, m, s)`` or ``(d, m, s)`` depending on ``unit``. If a string, it will be interpreted following the rules described for :class:`~astropy.coordinates.Angle`. If ``angle`` is a sequence or array of strings, the resulting values will be in the given ``unit``, or if `None` is provided, the unit will be taken from the first given value. unit : :class:`~astropy.units.UnitBase`, str, optional The unit of the value specified for the angle. This may be any string that `~astropy.units.Unit` understands, but it is better to give an actual unit object. Must be an angular unit. Raises ------ `~astropy.units.UnitsError` If a unit is not provided or it is not an angular unit. `TypeError` If the angle parameter is an instance of :class:`~astropy.coordinates.Longitude`. cK`sPt|tƒrtdƒ‚ntt|ƒj||d||}|jƒ|S(Nu9A Latitude angle cannot be created from a Longitude angleR (R t Longitudet TypeErrorRRvRt_validate_angles(RRR tkwargsR+((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRs $ cC`s|dkr|}ntjj|jdƒ}tjj|jdƒ}tj|j|kƒsutj|j|kƒr™tdj |jtjƒƒƒ‚ndS(unCheck that angles are between -90 and 90 degrees. If not given, the check is done on the object itselfg€VÀg€V@uDLatitude angle(s) must be within -90 deg <= angle <= 90 deg, got {0}N( RRR%ttoR RtanytvalueRHR((R+tanglesR_R`((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRy s  0 cC`sHt|tƒrtdƒ‚n|j|ƒtt|ƒj||ƒdS(Nu8A Longitude angle cannot be assigned to a Latitude angle(R RwRxRyRRvt __setitem__(R+titemR}((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRs cC`s(tt|ƒj|d|ƒ}t|ƒS(Ntcontext(RR t__array_wrap__Rq(R+RuR((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR‚#scO`s%tt|ƒj||Ž}t|ƒS(N(RRvt__array_ufunc__Rq(R+targsRztresults((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRƒ'sN( RjRkRlRRRyRR‚Rƒ(((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRvÔs -   t LongitudeInfocB`seZejjdZRS(u wrap_angle(u wrap_angle(RjRkRt QuantityInfot_represent_as_dict_attrs(((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR†,sRwcB`seZdZd ZedejƒZe ƒZ d d d„Z d„Z d„Z ed„ƒZejd„ƒZd„Zd d„Zd „ZRS( u^ Longitude-like angle(s) which are wrapped within a contiguous 360 degree range. A ``Longitude`` object is distinguished from a pure :class:`~astropy.coordinates.Angle` by virtue of a ``wrap_angle`` property. The ``wrap_angle`` specifies that all angle values represented by the object will be in the range:: wrap_angle - 360 * u.deg <= angle(s) < wrap_angle The default ``wrap_angle`` is 360 deg. Setting ``wrap_angle=180 * u.deg`` would instead result in values between -180 and +180 deg. Setting the ``wrap_angle`` attribute of an existing ``Longitude`` object will result in re-wrapping the angle values in-place. The input angle(s) can be specified either as an array, list, scalar, tuple, string, :class:`~astropy.units.Quantity` or another :class:`~astropy.coordinates.Angle`. The input parser is flexible and supports all of the input formats supported by :class:`~astropy.coordinates.Angle`. Parameters ---------- angle : array, list, scalar, `~astropy.units.Quantity`, :class:`~astropy.coordinates.Angle` The angle value(s). If a tuple, will be interpreted as ``(h, m s)`` or ``(d, m, s)`` depending on ``unit``. If a string, it will be interpreted following the rules described for :class:`~astropy.coordinates.Angle`. If ``angle`` is a sequence or array of strings, the resulting values will be in the given ``unit``, or if `None` is provided, the unit will be taken from the first given value. unit : :class:`~astropy.units.UnitBase`, str, optional The unit of the value specified for the angle. This may be any string that `~astropy.units.Unit` understands, but it is better to give an actual unit object. Must be an angular unit. wrap_angle : :class:`~astropy.coordinates.Angle` or equivalent, or None Angle at which to wrap back to ``wrap_angle - 360 deg``. If ``None`` (default), it will be taken to be 360 deg unless ``angle`` has a ``wrap_angle`` attribute already (i.e., is a ``Longitude``), in which case it will be taken from there. Raises ------ `~astropy.units.UnitsError` If a unit is not provided or it is not an angular unit. `TypeError` If the angle parameter is an instance of :class:`~astropy.coordinates.Latitude`. ihcK`sst|tƒrtdƒ‚ntt|ƒj||d||}|dkrft|d|jƒ}n||_ |S(Nu:A Longitude angle cannot be created from a Latitude angle.R u wrap_angle( R RvRxRRwRRtgetattrt_default_wrap_angleRX(RRR RXRzR+((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRks$  cC`sEt|tƒrtdƒ‚ntt|ƒj||ƒ|jƒdS(Nu8A Latitude angle cannot be assigned to a Longitude angle(R RvRxRRwRt_wrap_internal(R+R€R}((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRvscC`s¹tjj|jdƒ}|jj|jƒ}||}|j}tj||kƒsjtj||kƒrµtj |||ƒ|}tj ||jƒ}t t |ƒj d|ƒndS(u¡ Wrap the internal values in the Longitude object. Using the :meth:`~astropy.coordinates.Angle.wrap_at` method causes recursion. g€v@N((RR%R{R RXRKR}RR|RVRRRwR(R+ta360RXtwrap_angle_floort self_angleRZR}((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR‹}s   *cC`s|jS(N(t _wrap_angle(R+((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRXscC`st|ƒ|_|jƒdS(N(R RR‹(R+R}((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRX”scC`s2tt|ƒj|ƒt|d|jƒ|_dS(Nu _wrap_angle(RRwt__array_finalize__R‰RŠR(R+Ru((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR™s cC`s(tt|ƒj|d|ƒ}t|ƒS(NR(RR R‚Rq(R+RuR((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyR‚ŸscO`s%tt|ƒj||Ž}t|ƒS(N(RRwRƒRq(R+R„RzR…((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRƒ£sN(RjRkRlRRR RRWRŠR†tinfoRRR‹RpRXtsetterRR‚Rƒ(((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyRw0s5     (!Rlt __future__RRRRtmatht collectionsRtnumpyRtexternRtRRRRtutilsRt utils.compatR t__all__R,R/R2tSpecificTypeQuantityR RqRvR‡R†Rw(((s9lib/python2.7/site-packages/astropy/coordinates/angles.pyts&"  ÿª X