a ߙfbg@sdZddlZddlmZddlZddlmZddl m Z ddl m Z gdZed d Zed d Zed dZGddde jZddZGdddeZGddde jZGdddeZdS)z\ This module contains the fundamental classes used for representing coordinates in astropy. N) namedtuple) angle_formats)units) isiterable)AngleLatitude Longitude hms_tuple)hms dms_tuple)dr r signed_dms_tuple)signrr r cseZdZdZejZdZd%fdd Ze ddZ e dd Z fd d Z e d d Ze ddZe ddZe ddZd&ddZddZd'ddZd(ddZd)dd Zd!d"Zd#d$ZZS)*ru 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. The examples below illustrate common ways of initializing an `Angle` object. First some imports:: >>> from astropy.coordinates import Angle >>> from astropy import units as u The angle values can now be provided:: >>> 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('1°2′3″N') >>> Angle('1d2m3.4s') >>> Angle('1d2m3.4sS') >>> Angle('-1h2m3s') >>> Angle('-1h2m3sE') >>> Angle('-1h2.5m') >>> Angle('-1h2.5mW') >>> 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 : unit-like, 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. TNc st|tjsĈdur$|tt|tr<||}nt|trt |\}}|durb}t|trx|||}|urtj||dd}n2t |rt|t j r|j jdvsćfdd|D}tj||f||d|S)NFcopyZSUVOcsg|]}t|ddqS)Fr)r).0xunit9lib/python3.9/site-packages/astropy/coordinates/angles.py z!Angle.__new__..)dtyper) isinstanceuZQuantity_convert_unit_to_angle_unitUnittuple_tuple_to_floatstrformZ parse_anglernpndarrayrkindsuper__new__)clsanglerrrkwargsZ angle_unit __class__rrr)ps,       z Angle.__new__cCsD|tjkrtj|S|tjkr(tj|Std|d|ddS)z Converts an angle represented as a 3-tuple or 2-tuple into a floating point number in the given unit. zCan not parse 'z ' as unit ''N)r hourangler$Z hms_to_hoursdegreeZdms_to_degrees UnitsError)r+rrrrr"s     zAngle._tuple_to_floatcCs|tjurtjS|SN)rhourr0rrrrrsz!Angle._convert_unit_to_angle_unitcst||dSr3)r( _set_unitr)selfrr-rrr5szAngle._set_unitcCs|jS)zB The angle's value in hours (read-only property). )r0r6rrrr4sz Angle.hourcCstt|jS)z The angle's value in hours, as a named tuple with ``(h, m, s)`` members. (This is a read-only property.) )r r$Z hours_to_hmsr0r7rrrhmssz Angle.hmscCstt|jS)z The angle's value in degrees, as a named tuple with ``(d, m, s)`` members. (This is a read-only property.) )rr$degrees_to_dmsr1r7rrrdmssz Angle.dmscCs&tt|jgtt|jRS)a 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. )rr%rr1r$r9absr7rrr signed_dmss zAngle.signed_dmsFfromunitc s^|dur|j}n|t|}tjdtjditjgdtjgditjdtjdid} d kr| vrxtd d | } || vr| ||tjur|r|j} durd td jqdjn$d krd|j} fddn.|tjurV|r.|j } dur&d td jndjn&d kr.sz!Angle.to_string..cstj|dSrA)r$Zhours_to_stringrFrGrrrH=sz{0:1.formatr?rcsdtd|S)Nr@zf}{1})r#rJval)rB unit_stringrrplain_unit_formatOsz*Angle.to_string..plain_unit_formatcs|dS)NgrrL)rNrrrOTsz0' can not be represented in sexagesimal notationz/The unit value provided is not an angular unit.csNt|sDt|}r,|ds,d|}dkr@d|d}|S|}|S)N-+r?$)r%Zisnanfloat startswith)rMr ) alwayssignrJfuncrr do_format_s   z"Angle.to_string..do_formatU)Zotypesrr)rrrr r1r0 ValueErrorr#rJr4Z is_equivalentradianto_value to_stringnamer2r%Z vectorizendim)r6rdecimalrCrBrVrDrErJZ separatorsZsepsvaluesrOrXZ format_ufuncresultr)rVrErJrWrDrBrCrNrr]sC                   zAngle.to_stringcCstj|jd}||j}||}|tj}tjddl|||}tj |ddt |dkr|||8}|||k|8<|||k|7<Wdn1s0YdS)zr Implementation that assumes ``angle`` is already validated and that wrapping is inplace. gv@ignoreZinvalidFrrN) rr1torr\viewr%r&errstateZ nan_to_numany)r6 wrap_angleZa360Zwrap_angle_floorZ self_anglewrapsrrr_wrap_atss    zAngle._wrap_atcCs.t|dd}|s|}|||r*dS|S)an Wrap the `~astropy.coordinates.Angle` object at the given ``wrap_angle``. This method forces all the angle values to be within a contiguous 360 degree range so that ``wrap_angle - 360d <= angle < wrap_angle``. By default a new Angle object is returned, but if the ``inplace`` argument is `True` then the `~astropy.coordinates.Angle` object is wrapped in place and nothing is returned. For instance:: >>> 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 : angle-like Specifies a single value for the wrap angle. This can be any object that can initialize an `~astropy.coordinates.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 `~astropy.coordinates.Angle` Returns ------- out : Angle or None If ``inplace is False`` (default), return new `~astropy.coordinates.Angle` object with angles wrapped accordingly. Otherwise wrap in place and return `None`. FrN)rrrk)r6riZinplacerrrwrap_ats )  z Angle.wrap_atcCsLd}|dur"|tt||kM}|rD|durD|t|t|kM}t|S)a 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 : angle-like or None Specifies lower bound for checking. This can be any object that can initialize an `~astropy.coordinates.Angle` object, e.g. ``'180d'``, ``180 * u.deg``, or ``Angle(180, unit=u.deg)``. upper : angle-like or None Specifies upper bound for checking. This can be any object that can initialize an `~astropy.coordinates.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`` TN)r%allrbool)r6lowerupperokrrris_within_boundss ! zAngle.is_within_boundscs0|jr|jdSfdd}tj|d|idS)NrIcs |jdS)NrI)r]rFrIrr formattersz$Angle._str_helper..formatterrm)rs)Zisscalarr]r%Z array2string)r6rJrsrrIr _str_helpers  zAngle._str_helpercCs|Sr3rtr7rrr__str__sz Angle.__str__cCs |jddS)Nr?rIrur7rrr _repr_latex_szAngle._repr_latex_)NNT)NFr=NFFr>N)F)NN)N)__name__ __module__ __qualname____doc__rr[Z_equivalent_unitZ _include_easy_conversion_membersr) staticmethodr"rr5propertyr4r8r:r<r]rkrlrrrtrvrw __classcell__rrr-rrs8Q        . / ( rcCs8t|trtdd|DSt|ttfr4|tS|S)zReturn 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.) css|]}t|VqdSr3)_no_angle_subclass)rZ_objrrr rz%_no_angle_subclass..)rr!rr rfr)objrrrrs rcsDeZdZdZd fdd Zd ddZfddZfd d ZZS) ra 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`, `~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 : unit-like, 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`. Nc s8t|trtdtj||fd|i|}||S)Nz9A Latitude angle cannot be created from a Longitude angler)rr TypeErrorr(r)_validate_angles)r*r+rr,r6r-rrr).s  zLatitude.__new__cCs|dur |}tj|jd}tj|jd}tjdd0t|j|kpXt|j|k}Wdn1sn0Y|rtd |tjdS)znCheck that angles are between -90 and 90 degrees. If not given, the check is done on the object itselfNgVgV@rcrdzCLatitude angle(s) must be within -90 deg <= angle <= 90 deg, got {}) rr1rerr%rgrhvaluerZrJ)r6ZanglesrorpZinvalid_anglesrrrr6s  zLatitude._validate_anglescs:t|trtd|tjjur(||t||dS)Nz8A Longitude angle cannot be assigned to a Latitude angle) rr rr%ZmaZmaskedrr( __setitem__r6itemrr-rrrKs    zLatitude.__setitem__cstj|i|}t|Sr3r(__array_ufunc__rr6argsr,Zresultsr-rrrUszLatitude.__array_ufunc__)N)N) rxryrzr{r)rrrr~rrr-rrs -  rc@seZdZejjdZdS) LongitudeInfo)riN)rxryrzr QuantityInfoZ_represent_as_dict_attrsrrrrrZsrcsxeZdZdZdZedejZe Z dfdd Z fddZ e dd Zejd d Zfd d Zfd dZZS)r a 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 : tuple or angle-like 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 : unit-like ['angle'], 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 : angle-like or None, optional 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`. Nihc sLt|trtdtj||fd|i|}|durBt|d|j}||_|S)Nz:A Longitude angle cannot be created from a Latitude angle.rri)rrrr(r)getattr_default_wrap_angleri)r*r+rrir,r6r-rrr)s zLongitude.__new__cs0t|trtdt||||jdS)Nz8A Latitude angle cannot be assigned to a Longitude angle)rrrr(rrkrirr-rrrs zLongitude.__setitem__cCs|jSr3) _wrap_angler7rrrriszLongitude.wrap_anglecCst|dd|_||jdS)NFr)rrrkri)r6rrrrriscs t|t|d|j|_dS)Nr)r(__array_finalize__rrr)r6rr-rrrs zLongitude.__array_finalize__cstj|i|}t|Sr3rrr-rrrszLongitude.__array_ufunc__)NN)rxryrzr{rrrZdegrrinfor)rr}risetterrrr~rrr-rr ^s5    r )r{warnings collectionsrZnumpyr%rr$ZastropyrrZ astropy.utilsr__all__r rrZSpecificTypeQuantityrrrrrr rrrrs$       \ Z