a ߙfb+@s@dZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z ddlmZmZmZddlmZddlmZddlmZmZdd lmZdd lmZgd ZiZiZe Z!da"d d Z#ddZ$ddZ%dCddZ&GdddeZ'GdddeZ(ddZ)Gddde'Z*Gddde(Z+Gdd d e+Z,Gd!d"d"e+Z-Gd#d$d$e+Z.d%d&Z/Gd'd(d(e+Z0Gd)d*d*e+Z1Gd+d,d,e+Z2Gd-d.d.e(Z3Gd/d0d0e3Z4Gd1d2d2e3Z5Gd3d4d4e5Z6Gd5d6d6e5Z7Gd7d8d8e3Z8Gd9d:d:e8Z9Gd;d<dd>e3Z;Gd?d@d@e3Z\zFBaseRepresentationOrDifferentialInfo.default_format..shaper%cSsg|]\}}||jfqSr%dtype)r=r>r;r%r%r& ^rBzGBaseRepresentationOrDifferentialInfo.default_format..) componentsr*r4emptyr:zipstr)r@rGr5ar>r;r%r?r&default_formatXs z3BaseRepresentationOrDifferentialInfo.default_formatcCs|jjSr/)_parentrGselfr%r%r&_represent_as_dict_attrsdsz=BaseRepresentationOrDifferentialInfo._represent_as_dict_attrscCs0|jdurdS|jj}|dr,|ddS|S)N(r)rM_unitstr startswith)rOr9r%r%r&r9hs z)BaseRepresentationOrDifferentialInfo.unitwarnNc Cs||||d}tj|tjd}|d|}|ddD]D}z|d|d<Wq8tyz} ztd| WYd} ~ q8d} ~ 00q8dD]} | |vrt|j| || q|S)a Return a new instance like ``reps`` with ``length`` rows. This is intended for creating an empty column object whose elements can be set in-place for table operations like join or vstack. Parameters ---------- reps : list List of input representations or differentials. length : int Length of the output column object metadata_conflicts : str ('warn'|'error'|'silent') How to handle metadata conflicts name : str Output column name Returns ------- col : `BaseRepresentation` or `BaseDifferential` subclass instance Empty instance of this class consistent with ``cols`` )meta descriptionrDrrNz'input representations are inconsistent.)namerVrW)Zmerge_cols_attributesr4ZzerosZint64 Exception ValueErrorsetattrinfo) rOZrepslengthZmetadata_conflictsrXattrsZindexesoutreperrattrr%r%r&new_likeps  "z-BaseRepresentationOrDifferentialInfo.new_like)rUN) __name__r!r"__doc__Zattrs_from_parentZ_supports_indexing staticmethodrLpropertyrPr9rcr%r%r%r&r8Os   r8cs>eZdZdZdZeZddZeddZ ee j ddZ e j d d Z ed d Zd dZddZfddZddZeddZejddZe j ddZddZddZddZd d!Zd"d#Zd$d%Ze j d;d'd(Zd)d*Zd+d,Zd-d.Z d/d0Z!ed1d2Z"ed3d4Z#ed5d6Z$d7d8Z%d9d:Z&Z'S).rcopyTcsg|]}t|qSr%r:r<) rep_or_diffr%r&rFsz=BaseRepresentationOrDifferential.__init__..r\zIunexpected keyword arguments for case where class instance is passed in: z3__init__() missing 1 required positional argument: z- (or first argument should be an instance of z).zunexpected arguments: z,__init__() got multiple values for argument zunexpected keyword arguments: cs$g|]\}}j||ddqS)Trisubok) attr_classes)r=r>rb)rirOr%r&rFsrmz and r2z, and zInput parameters z cannot be broadcastcs0g|](\}}|j|jkr(r$|q*|n|qSr%)rCri)r=rbZbc_attrrir%r&rFs_)listrG isinstance __class__allpop__dict__r\ TypeErrorKeyErrorrdappendrIr4Zbroadcast_arraysrZlenjoinr[) rOargsr6rGr^r>rbZbc_attrsraZc_strr%)rirkrOr&__init__st           ( z)BaseRepresentationOrDifferential.__init__cCs<|j}|dr"|dd}n|dr8|dd}|S)aName of the representation or differential. In lower case, with any trailing 'representation' or 'differential' removed. (E.g., 'spherical' for `~astropy.coordinates.SphericalRepresentation` or `~astropy.coordinates.SphericalDifferential`.) representationNi differentiali)rdlowerendswith)r$rXr%r%r&get_names    z)BaseRepresentationOrDifferential.get_namecCs tdS)amCreate a representation of this class from a supplied Cartesian one. Parameters ---------- other : `CartesianRepresentation` The representation to turn into this class Returns ------- representation : `BaseRepresentation` subclass instance A new representation of this class's type. NNotImplementedErrorr$otherr%r%r&from_cartesiansz/BaseRepresentationOrDifferential.from_cartesiancCs tdS)aConvert the representation to its Cartesian form. Note that any differentials get dropped. Also note that orientation information at the origin is *not* preserved by conversions through Cartesian coordinates. For example, transforming an angular position defined at distance=0 through cartesian coordinates and back will lose the original angular coordinates:: >>> import astropy.units as u >>> import astropy.coordinates as coord >>> rep = coord.SphericalRepresentation( ... lon=15*u.deg, ... lat=-11*u.deg, ... distance=0*u.pc) >>> rep.to_cartesian().represent_as(coord.SphericalRepresentation) Returns ------- cartrepr : `CartesianRepresentation` The representation in Cartesian form. NrrNr%r%r& to_cartesian*sz-BaseRepresentationOrDifferential.to_cartesiancCs t|jS)z=A tuple with the in-order names of the coordinate components.)r*rnrNr%r%r&rGFsz+BaseRepresentationOrDifferential.componentsc Cs|j|jur(td|jjd|jjzt||Wn4tyl}ztd||WYd}~n d}~00d}|jD]$}|t|d|t|d|kM}qx|S)zEquality operator This implements strict equality and requires that the representation classes are identical and that the representation data are exactly equal. z.cannot compare: objects must have same class:  vs. zcannot compare: NTrq)rtrxrdr4Z broadcastrZrGr:)rOr;excr_compr%r%r&__eq__Ks & "z'BaseRepresentationOrDifferential.__eq__cCst||kSr/r4Z logical_notrOr;r%r%r&__ne__asz'BaseRepresentationOrDifferential.__ne__cs|trfdd}ntjgRi}t|j}|jD]}t|d||t||qFd|j vrx|j |_ |S)aJCreate a new representation or differential with ``method`` applied to the component data. In typical usage, the method is any of the shape-changing methods for `~numpy.ndarray` (``reshape``, ``swapaxes``, etc.), as well as those picking particular elements (``__getitem__``, ``take``, etc.), which are all defined in `~astropy.utils.shapes.ShapedLikeNDArray`. It will be applied to the underlying arrays (e.g., ``x``, ``y``, and ``z`` for `~astropy.coordinates.CartesianRepresentation`), with the results used to create a new instance. Internally, it is also used to apply functions to the components (in particular, `~numpy.broadcast_to`). Parameters ---------- method : str or callable If str, it is the name of a method that is applied to the internal ``components``. If callable, the function is applied. *args : tuple Any positional arguments for ``method``. **kwargs : dict Any keyword arguments for ``method``. cs|gRiSr/r%)Zarrayr}r6methodr%r&~rBz9BaseRepresentationOrDifferential._apply..rqr\) callableoperator methodcallersuper__new__rtrGr[r:rwr\)rOrr}r6Z apply_methodnewr>rtrr&_applyds    z'BaseRepresentationOrDifferential._applycCsT|j|jur(td|jjd|jj|jD] }t|d|t|d||<q.dS)Nz(can only set from object of same class: rrq)rtrxrdrGr:)rOitemr;r>r%r%r& __setitem__s  z,BaseRepresentationOrDifferential.__setitem__cCst||jdjS)aThe shape of the instance and underlying arrays. Like `~numpy.ndarray.shape`, can be set to a new shape by assigning a tuple. Note that if different instances share some but not all underlying data, setting the shape of one instance can make the other instance unusable. Hence, it is strongly recommended to get new, reshaped instances with the ``reshape`` method. Raises ------ ValueError If the new shape has the wrong total number of elements. AttributeError If the shape of any of the components cannot be changed without the arrays being copied. For these cases, use the ``reshape`` method (which copies any arrays that cannot be reshaped in-place). r)r:rGrCrNr%r%r&rCsz&BaseRepresentationOrDifferential.shapec Cshg}|j}|jD]R}t||}|jdkrz ||_Wn$tyV|D] }||_qDYq0||qdS)Nr)rCrGr:sizerYrz)rOrCZreshapedZoldshaper>r@Zval2r%r%r&rCs     cGs tdSr/rrOopr}r%r%r&_scale_operationsz1BaseRepresentationOrDifferential._scale_operationcCs|tj|Sr/)rrmulrOrr%r%r&__mul__sz(BaseRepresentationOrDifferential.__mul__cCs ||Sr/)rrr%r%r&__rmul__sz)BaseRepresentationOrDifferential.__rmul__cCs|tj|Sr/rrtruedivrr%r%r& __truediv__sz,BaseRepresentationOrDifferential.__truediv__cCs|tj|Sr/rrr%r%r&__div__sz(BaseRepresentationOrDifferential.__div__cCs |tjSr/)rrnegrNr%r%r&__neg__sz(BaseRepresentationOrDifferential.__neg__cCs|Sr/rprNr%r%r&__pos__sz(BaseRepresentationOrDifferential.__pos__FcCs tdSr/rrOrrreverser%r%r&_combine_operationsz3BaseRepresentationOrDifferential._combine_operationcCs|tj|Sr/rraddrr%r%r&__add__sz(BaseRepresentationOrDifferential.__add__cCs|jtj|ddSNT)rrrr%r%r&__radd__sz)BaseRepresentationOrDifferential.__radd__cCs|tj|Sr/rrsubrr%r%r&__sub__sz(BaseRepresentationOrDifferential.__sub__cCs|jtj|ddSrrrr%r%r&__rsub__sz)BaseRepresentationOrDifferential.__rsub__csHfddjD}tjdd|D}|D]\}}|j||<q0|S)zTurn the coordinates into a record array with the coordinate values. The record array fields will have the component names. csg|]}|t|fqSr%rjr=crNr%r&rFrBz.cSsg|]\}}||jfqSr%rD)r=rcoor%r%r&rFrB)rGr4rHrCr;)rOZ coo_itemsresultrrr%rNr&_valuess   z(BaseRepresentationOrDifferential._valuescstfddjDS)z@Return a dictionary with the units of the coordinate components.csg|]}|t|jfqSr%)r:r9r<rNr%r&rFsz;BaseRepresentationOrDifferential._units..)dictrGrNr%rNr&_unitss z'BaseRepresentationOrDifferential._unitscsLtj}t|dkr(|}n ddfddjD}|S)Nrz({})r2csg|]}j|qSr%)r to_stringr<rNr%r&rFsz=BaseRepresentationOrDifferential._unitstr..) setrr5r{rvrformatr|rG)rOZ units_setunitstrr%rNr&rSs z)BaseRepresentationOrDifferential._unitstrcCst|jd|jdS)N s)r7rrSrNr%r%r&__str__ sz(BaseRepresentationOrDifferential.__str__cCsvd}t|j|d}d}t|ddrBdddd|jD}|jrRd |jnd }d |jj d|j ||||S) Nz )r3r1 differentialsz (has differentials w.r.t.: {})r2cSsg|] }t|qSr%)repr)r=keyr%r%r&rFrBz=BaseRepresentationOrDifferential.__repr__..zin z[dimensionless]z<{} ({}) {:s} {}{}{}>) r7rr:rr|rkeysrSrtrdrG)rOZ prefixstrZarrstrZdiffstrrr%r%r&__repr__ s z)BaseRepresentationOrDifferential.__repr__)F)(rdr!r"reZ__array_priority__r8r\r~ classmethodrabcabstractmethodrrrgrGrrrrrCsetterrrrrrrrrrrrrrrrSrr __classcell__r%r%rr&r sVO     +        r csdfdd}|S)aMake an attribute getter for use in a property. Parameters ---------- component : str The name of the component that should be accessed. This assumes the actual value is stored in an attribute of that name prefixed by '_'. rqcs t|Sr/rjrNr>r%r& get_component(sz#_make_getter..get_componentr%)r>rr%rr& _make_getters  rcs:eZdZefddZdfdd ZfddZZS) RepresentationInfocstj}|jjr|d7}|S)Nr)rrPrM_differentials)rOr^rr%r&rP/sz+RepresentationInfo._represent_as_dict_attrsNcs8t|}|diD]\}}||d|<q|S)Nrdifferentials.)r_represent_as_dictrvr,)rOr^r_rr;rr%r&r6s z%RepresentationInfo._represent_as_dictcsJi}t|D]$}|dr||||dd<q||d<t|S)Nrr)rrrrTrvr_construct_from_dict)rOmaprrrr%r&r<s  z'RepresentationInfo._construct_from_dict)N)rdr!r"rgrPrrrr%r%rr&r-srcseZdZdZeZfddZddfdd Zdd Zd d Z e d d Z e ddZ ddZddZddZd9ddZddZddZddZeddZfd d!Zd"d#Zfd$d%Zfd&d'Zd(d)Zd:d+d,Zejjd-d.Zd/d0Z d1d2Z!d3d4Z"d5d6Z#d7d8Z$Z%S);raBase for representing a point in a 3D coordinate system. Parameters ---------- comp1, comp2, comp3 : `~astropy.units.Quantity` or subclass The components of the 3D points. The names are the keys and the subclasses the values of the ``attr_classes`` attribute. differentials : dict, `~astropy.coordinates.BaseDifferential`, optional Any differential classes that should be associated with this representation. The input must either be a single `~astropy.coordinates.BaseDifferential` subclass instance, or a dictionary with keys set to a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be ``'s'`` for seconds, indicating that the derivative is a time derivative. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. Notes ----- All representation classes should subclass this base representation class, and define an ``attr_classes`` attribute, a `dict` which maps component names to the class that creates them. They must also define a ``to_cartesian`` method and a ``from_cartesian`` class method. By default, transformations are done via the cartesian system, but classes that want to define a smarter transformation path can overload the ``represent_as`` method. If one wants to use an associated differential class, one should also define ``unit_vectors`` and ``scale_factors`` methods (see those methods for details). c s@|jdkrdSt|ds td|}|tvrt|t|}t|}t|}||krjtd|dd|d|d|d}t |t t|=|t|<|}nD|tvrt|}t d|d |d |}|tvrtd|d|t|<t |j D].}t||st||tt|d |d d qtjfi|dS)Nrrnzrr%r&rhsT          z$BaseRepresentation.__init_subclass__NrcsHtj|i||dur8|r8t|d|jr8|dj}|||_dS)Nr)rr~rsrtr_validate_differentials)rOrr}r6rr%r&r~s zBaseRepresentation.__init__c Cs|durt}n8t|trHt|tr6t|tr6td||}||i}|D]}z ||}Wn.ty}ztd|WYd}~n d}~00||t|trt|trn(||}||krtd t ||||j |j krLtd |j |j qL|S)a Validate that the provided differentials are appropriate for this representation and recast/reshape as necessary and then return. Note that this does *not* set the differentials on ``self._differentials``, but rather leaves that for the caller. NzvTo attach a RadialDifferential to a UnitSphericalRepresentation, you must supply a dictionary with an appropriate key.z9'differentials' argument must be a dictionary-like objectzNFor differential object '{}', expected unit key = '{}' but received key = '{}'zUShape of differentials must be the same as the shape of the representation ({} vs {})) rrsrrrrZ_get_deriv_keyrx _check_baserrrC)rOrrdiffraZ expected_keyr%r%r&rs>          z*BaseRepresentation._validate_differentialscCs|jrtd||jjdS)z Used to raise a consistent exception for any operation that is not supported when a representation has differentials attached. zHOperation '{}' is not supported when differentials are attached to a {}.N)rrxrrtrd)rOZop_namer%r%r&_raise_if_has_differentialssz.BaseRepresentation._raise_if_has_differentialscCst|gSr/)r-rr#r%r%r&_compatible_differentialssz,BaseRepresentation._compatible_differentialscCs|jS)aA dictionary of differential class instances. The keys of this dictionary must be a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be ``'s'`` for seconds, indicating that the derivative is a time derivative. )rrNr%r%r&rs z BaseRepresentation.differentialscCstt|ddS)aCartesian unit vectors in the direction of each component. Given unit vectors :math:`\hat{e}_c` and scale factors :math:`f_c`, a change in one component of :math:`\delta c` corresponds to a change in representation of :math:`\delta c \times f_c \times \hat{e}_c`. Returns ------- unit_vectors : dict of `CartesianRepresentation` The keys are the component names. z! has not implemented unit vectorsNrtyperNr%r%r& unit_vectorss zBaseRepresentation.unit_vectorscCstt|ddS)aScale factors for each component's direction. Given unit vectors :math:`\hat{e}_c` and scale factors :math:`f_c`, a change in one component of :math:`\delta c` corresponds to a change in representation of :math:`\delta c \times f_c \times \hat{e}_c`. Returns ------- scale_factors : dict of `~astropy.units.Quantity` The keys are the component names. z# has not implemented scale factors.NrrNr%r%r& scale_factorss z BaseRepresentation.scale_factorsc Cs |durtS|js"|r"tdn\t|jdkr\t|r\t|tr\t|j d|i}n"| |j kr~td |jt}|jD]z}|j|}z|j |||d||<Wqt y}z6|||j vrtd |||j|nWYd}~qd}~00q|S)zRe-represent the differentials to the specified classes. This returns a new dictionary with the same keys but with the attached differentials converted to the new differential classes. Nz5No differentials associated with this representation!rrzDesired differential classes must be passed in as a dictionary with keys equal to a string representation of the unit of the derivative for each differential stored with this representation object ({0})basezXDesired differential class {} is not compatible with the desired representation class {})rrrZr{inspectisclass issubclassrrrrr represent_asrYrrxrt)rOnew_repdifferential_class new_diffskrrar%r%r&_re_represent_differentialssD     z.BaseRepresentation._re_represent_differentialscCs\||jur|s|St|tr(td||jurB||}n|}||||_|SdS)aConvert coordinates to another representation. If the instance is of the requested class, it is returned unmodified. By default, conversion is done via Cartesian coordinates. Also note that orientation information at the origin is *not* preserved by conversions through Cartesian coordinates. See the docstring for :meth:`~astropy.coordinates.BaseRepresentationOrDifferential.to_cartesian` for an example. Parameters ---------- other_class : `~astropy.coordinates.BaseRepresentation` subclass The type of representation to turn the coordinates into. differential_class : dict of `~astropy.coordinates.BaseDifferential`, optional Classes in which the differentials should be represented. Can be a single class if only a single differential is attached, otherwise it should be a `dict` keyed by the same keys as the differentials. zfInput to a representation's represent_as must be a class, not a string. For strings, use frame objectsN) rtwithout_differentialsrsrJrZrrrr)rO other_classrrr%r%r&rMs  zBaseRepresentation.represent_ascCsNdd|jD}|jt|d|}dd|jD}||j|}|S)aTransform coordinates using a 3x3 matrix in a Cartesian basis. This returns a new representation and does not modify the original one. Any differentials attached to this representation will also be transformed. Parameters ---------- matrix : (3,3) array-like A 3x3 (or stack thereof) matrix, such as a rotation matrix. cSsi|] }|tqSr%)r)r=rr%r%r& rBz0BaseRepresentation.transform..)rcSsi|]\}}||jqSr%rr=rrr%r%r&rrB)rrrr transformr,rt)rOmatrixZdifs_clsZcrepr`r%r%r&ruszBaseRepresentation.transformcsJ|sSfddjD}j|jdd}|j|||S)a Create a new representation with the same positions as this representation, but with these new differentials. Differential keys that already exist in this object's differential dict are overwritten. Parameters ---------- differentials : sequence of `~astropy.coordinates.BaseDifferential` subclass instance The differentials for the new representation to have. Returns ------- `~astropy.coordinates.BaseRepresentation` subclass instance A copy of this representation, but with the ``differentials`` as its differentials. csg|]}t|qSr%rjr<rNr%r&rFrBz9BaseRepresentation.with_differentials..Frri)rGrtrrirupdater)rOrr}rr%rNr&with_differentialssz%BaseRepresentation.with_differentialscs.js SfddjD}j|ddiS)a>Return a copy of the representation without attached differentials. Returns ------- `~astropy.coordinates.BaseRepresentation` subclass instance A shallow copy of this representation, without any differentials. If no differentials were present, no copy is made. csg|]}t|qSr%rjr<rNr%r&rFrBz.riF)rrGrt)rOr}r%rNr&rs z(BaseRepresentation.without_differentialscCs ||S)zCreate a new instance of this representation from another one. Parameters ---------- representation : `~astropy.coordinates.BaseRepresentation` instance The presentation that should be converted to this class. )r)r$rr%r%r&from_representations z&BaseRepresentation.from_representationcsXt|}|j|jkr(tdt|j|jD]\}}|||kM}q>|S)zEquality operator for BaseRepresentation This implements strict equality and requires that the representation classes are identical, the differentials are identical, and that the representation data are exactly equal. z4cannot compare: objects must have same differentials)rrrrrZrIr5)rOr;r_ self_diffZ value_diffrr%r&rs   zBaseRepresentation.__eq__cCst||kSr/rrr%r%r&rszBaseRepresentation.__ne__cs@tjgRi}tfdd|jD|_|S)aCreate a new representation with ``method`` applied to the component data. This is not a simple inherit from ``BaseRepresentationOrDifferential`` because we need to call ``._apply()`` on any associated differential classes. See docstring for `BaseRepresentationOrDifferential._apply`. Parameters ---------- method : str or callable If str, it is the name of a method that is applied to the internal ``components``. If callable, the function is applied. *args : tuple Any positional arguments for ``method``. **kwargs : dict Any keyword arguments for ``method``. cs,g|]$\}}||jgRifqSr%)rrrr%r&rFsz-BaseRepresentation._apply..)rrrrr,)rOrr}r6r`rrr&rszBaseRepresentation._applyc s"t|tstdt|dt||jsRt|jt|jksRtd|jjdi}|j r|j |j krxtd|j D]Z\}}|j||<}|j |j}t||st|jt|jkstd|d|jjdq| |j|}t |||j D]\}}|j |||<qdS)Nz-value must be a representation instance, not r zvalue must be representable as z without loss of information.z'value must have the same differentials.zvalue differential z must be representable as )rsrrxrrtr{rnrZrdrrr,rrr) rOrr;Z diff_classesrrZ self_diff_clsZvalue_diff_clsrrr%r&rs>     zBaseRepresentation.__setitem__c Gsg}|jD]>\}}t||}t|tr6||q|||g|Rqz|j|}WntyrtYS0|j D]*\}} | j |g|Rddi} | |j |<q~|S)aeScale all non-angular components, leaving angular ones unchanged. Parameters ---------- op : `~operator` callable Operator to apply (e.g., `~operator.mul`, `~operator.neg`, etc. *args Any arguments required for the operator (typically, what is to be multiplied with, divided by). scaled_baseT) rnr,r:rrrzrtrYNotImplementedrr) rOrr}Zresultsr>r$r;rrrZ diff_resultr%r%r&rs       z#BaseRepresentation._scale_operationFcCs8||j||||}|tur*tS||SdS)a#Combine two representation. By default, operate on the cartesian representations of both. Parameters ---------- op : `~operator` callable Operator to apply (e.g., `~operator.add`, `~operator.sub`, etc. other : `~astropy.coordinates.BaseRepresentation` subclass instance The other representation. reverse : bool Whether the operands should be reversed (e.g., as we got here via ``self.__rsub__`` because ``self`` is a subclass of ``other``). N)rrdrrrrrOrrrrr%r%r&r=s  z%BaseRepresentation._combine_operationcCsp|j}tj||z|jD]}||j|_qWn:tyjtj|||jD]}||j|_qRYn0dSr/)rCr fsetrrY)rOrCZ orig_shaperr%r%r&rCUs   zBaseRepresentation.shapecs(tttjfddjDS)Vector norm. The norm is the standard Frobenius norm, i.e., the square root of the sum of the squares of all components with non-angular units. Note that any associated differentials will be dropped during this operation. Returns ------- norm : `astropy.units.Quantity` Vector norm, with the same shape as the representation. c3s*|]"\}}t|tst|dVqdS)roN)rrr:)r=r>r$rNr%r&rAvs z*BaseRepresentation.norm..)r4Zsqrt functoolsreducerrrnr,rNr%rNr&normgs zBaseRepresentation.normcOs$|d||j|i|S)aoVector mean. Averaging is done by converting the representation to cartesian, and taking the mean of the x, y, and z components. The result is converted back to the same representation as the input. Refer to `~numpy.mean` for full documentation of the arguments, noting that ``axis`` is the entry in the ``shape`` of the representation, and that the ``out`` argument cannot be used. Returns ------- mean : `~astropy.coordinates.BaseRepresentation` subclass instance Vector mean, in the same representation as that of the input. mean)rrrr rOr}r6r%r%r&r zs zBaseRepresentation.meancOs$|d||j|i|S)a]Vector sum. Adding is done by converting the representation to cartesian, and summing the x, y, and z components. The result is converted back to the same representation as the input. Refer to `~numpy.sum` for full documentation of the arguments, noting that ``axis`` is the entry in the ``shape`` of the representation, and that the ``out`` argument cannot be used. Returns ------- sum : `~astropy.coordinates.BaseRepresentation` subclass instance Vector sum, in the same representation as that of the input. sum)rrrrrr%r%r&rs zBaseRepresentation.sumcCs||S)aDot product of two representations. The calculation is done by converting both ``self`` and ``other`` to `~astropy.coordinates.CartesianRepresentation`. Note that any associated differentials will be dropped during this operation. Parameters ---------- other : `~astropy.coordinates.BaseRepresentation` The representation to take the dot product with. Returns ------- dot_product : `~astropy.units.Quantity` The sum of the product of the x, y, and z components of the cartesian representations of ``self`` and ``other``. )rdotrr%r%r&rszBaseRepresentation.dotcCs|d|||S)aVector cross product of two representations. The calculation is done by converting both ``self`` and ``other`` to `~astropy.coordinates.CartesianRepresentation`, and converting the result back to the type of representation of ``self``. Parameters ---------- other : `~astropy.coordinates.BaseRepresentation` subclass instance The representation to take the cross product with. Returns ------- cross_product : `~astropy.coordinates.BaseRepresentation` subclass instance With vectors perpendicular to both ``self`` and ``other``, in the same type of representation as ``self``. cross)rrrrrr%r%r&rs zBaseRepresentation.cross)N)F)&rdr!r"rerr\rr~rrr rrgrrrrrrrrrrrrrrrrr rCrr r rrrrr%r%rr&rEs@  7=   0 (!   !  rcseZdZdZejejejdZdZd!fdd ZddZ d d Z d"d d Z e e Z eddZddZddZd#ddZddZddZddZddZdd ZZS)$ra Representation of points in 3D cartesian coordinates. Parameters ---------- x, y, z : `~astropy.units.Quantity` or array The x, y, and z coordinates of the point(s). If ``x``, ``y``, and ``z`` have different shapes, they should be broadcastable. If not quantity, ``unit`` should be set. If only ``x`` is given, it is assumed that it contains an array with the 3 coordinates stored along ``xyz_axis``. unit : unit-like If given, the coordinates will be converted to this unit (or taken to be in this unit if not given. xyz_axis : int, optional The axis along which the coordinates are stored when a single array is provided rather than distinct ``x``, ``y``, and ``z`` (default: 0). differentials : dict, `CartesianDifferential`, optional Any differential classes that should be associated with this representation. The input must either be a single `CartesianDifferential` instance, or a dictionary of `CartesianDifferential` s with keys set to a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be ``'s'`` for seconds, indicating that the derivative is a time derivative. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. xyzNTcs|dur|durt|tjr|jjdvrtj|||dd}||_|rZt||d}||_ nd|_ |\|_ |_ |_ | ||_dSt|tr|dur|dur|dur|j}tj|||dS|\}}}|durtd|dus|durtd|jj|dur:tj|||dd}tj|||dd}tj|||dd}d}tj|||||d |j j|j jrx|j j|j jstd dS) NOVTrlrrz|xyz_axis should only be set if x, y, and z are in a single array passed in through x, i.e., y and z should not be not given.z*x, y, and z are required to instantiate {}Frirz/x, y, and z should have matching physical types)rsr4ndarrayrEkinduQuantity_xyzmoveaxis _xyz_axis_x_y_zrrrrr~rZrrtrdr9 is_equivalent UnitsError)rOrrrr9xyz_axisrrirr%r&r~sL     z CartesianRepresentation.__init__cCs`tjdtj|jdd}tjdtj|jdd}t|||ddt|||ddt|||dddS)N?TrmFrpr)r4 broadcast_toronerCr)rOlor%r%r&r&s z$CartesianRepresentation.unit_vectorscCs$tjdtj|jdd}|||dS)Nr%Tr&rr4r(rr)rCrOr*r%r%r&r.sz%CartesianRepresentation.scale_factorsrcCsF|jdur,|j|kr|jSt|j|j|Stj|j|j|jg|dS)aReturn a vector array of the x, y, and z coordinates. Parameters ---------- xyz_axis : int, optional The axis in the final array along which the x, y, z components should be stored (default: 0). Returns ------- xyz : `~astropy.units.Quantity` With dimension 3 along ``xyz_axis``. Note that, if possible, this will be a view. NZaxis)rrr4rstackrr r!rOr$r%r%r&get_xyz2s   zCartesianRepresentation.get_xyzcCs|Sr/r%rr%r%r&rNsz&CartesianRepresentation.from_cartesiancCs|Sr/r%rNr%r%r&rRsz$CartesianRepresentation.to_cartesiancsNtjdd}j|dddtfddjD}|S)a Transform the cartesian coordinates using a 3x3 matrix. This returns a new representation and does not modify the original one. Any differentials attached to this representation will also be transformed. Parameters ---------- matrix : ndarray A 3x3 transformation matrix, such as a rotation matrix. Examples -------- We can start off by creating a cartesian representation object: >>> from astropy import units as u >>> from astropy.coordinates import CartesianRepresentation >>> rep = CartesianRepresentation([1, 2] * u.pc, ... [2, 3] * u.pc, ... [3, 4] * u.pc) We now create a rotation matrix around the z axis: >>> from astropy.coordinates.matrix_utilities import rotation_matrix >>> rotation = rotation_matrix(30 * u.deg, axis='z') Finally, we can apply this transformation: >>> rep_new = rep.transform(rotation) >>> rep_new.xyz # doctest: +FLOAT_CMP rRr$Fr$ric3s$|]\}}||fVqdSr/rr=rdrr`rOr%r&rA~sz4CartesianRepresentation.transform..) erfa_ufuncrxpr1rtrrr,r)rOrprr%r7r&rUs %z!CartesianRepresentation.transformFcsf|jz |}Wnty.tYS0|s<||fn||f\|jfddjDS)Nc3s$|]}t|t|VqdSr/rjr<firstrsecondr%r&rAs z=CartesianRepresentation._combine_operation..)rrdrrYrrtrG)rOrrrother_cr%r;r&rs     z*CartesianRepresentation._combine_operationcCst|jddS)r rRr2)r8Zpmr1rNr%r%r&r szCartesianRepresentation.normcOs"|d|jdg|Ri|S)aTVector mean. Returns a new CartesianRepresentation instance with the means of the x, y, and z components. Refer to `~numpy.mean` for full documentation of the arguments, noting that ``axis`` is the entry in the ``shape`` of the representation, and that the ``out`` argument cannot be used. r rrrr%r%r&r s zCartesianRepresentation.meancOs"|d|jdg|Ri|S)aQVector sum. Returns a new CartesianRepresentation instance with the sums of the x, y, and z components. Refer to `~numpy.sum` for full documentation of the arguments, noting that ``axis`` is the entry in the ``shape`` of the representation, and that the ``out`` argument cannot be used. rr?rr%r%r&rs zCartesianRepresentation.sumc Csbz |}Wn8tyD}z tdt||WYd}~n d}~00t|jdd|jddS)aDot product of two representations. Note that any associated differentials will be dropped during this operation. Parameters ---------- other : `~astropy.coordinates.BaseRepresentation` subclass instance If not already cartesian, it is converted. Returns ------- dot_product : `~astropy.units.Quantity` The sum of the product of the x, y, and z components of ``self`` and ``other``. zLcannot only take dot product with another representation, not a {} instance.NrRr2)rrYrxrrr8Zpdpr1)rOrr>rar%r%r&rs  zCartesianRepresentation.dotc Csz|dz |}Wn8tyN}z tdt||WYd}~n d}~00t|jdd|jdd}|j |ddS)aCross product of two representations. Parameters ---------- other : `~astropy.coordinates.BaseRepresentation` subclass instance If not already cartesian, it is converted. Returns ------- cross_product : `~astropy.coordinates.CartesianRepresentation` With vectors perpendicular to both ``self`` and ``other``. rzNcannot only take cross product with another representation, not a {} instance.NrRr2) rrrYrxrrr8Zpxpr1rt)rOrr>raZsxor%r%r&rs   zCartesianRepresentation.cross)NNNNNT)r)F)rdr!r"rerrrnrr~rrr1rgxyzrrrrrr r rrrrr%r%rr&rs. 3  -   rcseZdZdZeedZeddZd*fdd Z ed d Z e d d Z e d dZ ddZd+ddZddZeddZd,fdd ZddZddZfddZd d!Zd-d"d#Zd$d%Zd&d'Zd(d)ZZS).raB Representation of points on a unit sphere. Parameters ---------- lon, lat : `~astropy.units.Quantity` ['angle'] or str The longitude and latitude of the point(s), in angular units. The latitude should be between -90 and 90 degrees, and the longitude will be wrapped to an angle between 0 and 360 degrees. These can also be instances of `~astropy.coordinates.Angle`, `~astropy.coordinates.Longitude`, or `~astropy.coordinates.Latitude`. differentials : dict, `~astropy.coordinates.BaseDifferential`, optional Any differential classes that should be associated with this representation. The input must either be a single `~astropy.coordinates.BaseDifferential` instance (see `._compatible_differentials` for valid types), or a dictionary of of differential instances with keys set to a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be ``'s'`` for seconds, indicating that the derivative is a time derivative. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. lonlatcCstSr/)rr#r%r%r&_dimensional_representationsz7UnitSphericalRepresentation._dimensional_representationNTcstj||||ddSNrrr~)rOrBrCrrirr%r&r~sz$UnitSphericalRepresentation.__init__cCstttttgSr/rrrrrr#r%r%r&rsz5UnitSphericalRepresentation._compatible_differentialscCs|jSz0 The longitude of the point(s). Z_lonrNr%r%r&rBszUnitSphericalRepresentation.loncCs|jSz/ The latitude of the point(s). Z_latrNr%r%r&rC%szUnitSphericalRepresentation.latcCsdt|jt|j}}t|jt|j}}t| |dddt| || ||dddS)Nr'FrprAr4sinrBcosrCrrOZsinlonZcoslonZsinlatZcoslatr%r%r&r,sz(UnitSphericalRepresentation.unit_vectorsFcCs<tjdtj|jdd}|r |nt|jtj}||dS)Nr%Tr&rA)r4r(rradianrCrNrC)rO omit_coslatsf_latsf_lonr%r%r&r4s z)UnitSphericalRepresentation.scale_factorscCst|j|j}t|dddSg Converts spherical polar coordinates to 3D rectangular cartesian coordinates. rRFr3)r8s2crBrCr)rOr:r%r%r&r:sz(UnitSphericalRepresentation.to_cartesiancCs |jdd}|t|ddiSg Converts 3D rectangular cartesian coordinates to spherical polar coordinates. rRr2riF)r1r8c2sr$cartr:r%r%r&rCs z*UnitSphericalRepresentation.from_cartesiancsbt|rT|sTt|tr6||jdtj|jdddSt|trT||j|jdddSt ||S)NZr%Fphithetarri)rBrCdistanceri) rrrrrBrdegrCrrr)rOrrrr%r&rMs   z(UnitSphericalRepresentation.represent_ascsttrrtjj}t|}t|\}}j ||dt fddj D} |njjjdj dS)aTransform the unit-spherical coordinates using a 3x3 matrix. This returns a new representation and does not modify the original one. Any differentials attached to this representation will also be transformed. Parameters ---------- matrix : (3,3) array-like A 3x3 matrix, such as a rotation matrix (or a stack of matrices). Returns ------- `UnitSphericalRepresentation` or `SphericalRepresentation` If ``matrix`` is O(3) -- :math:`M \dot M^T = I` -- like a rotation, then the result is a `UnitSphericalRepresentation`. All other matrices will change the distance, so the dimensional representation is used instead. rAc3s$|]\}}||fVqdSr/r4r5r7r%r&rA|sz8UnitSphericalRepresentation.transform..rrBrCrar)r4rurr8rVrBrCr9rYrtrrr,rrDr)rOrr@r:rBrCrr%r7r&r^s    z%UnitSphericalRepresentation.transformcGs&|j|j|jd|jdj|g|RS)Nr%rc)rDrBrCrrrr%r%r&rs z,UnitSphericalRepresentation._scale_operationcstfddjDr&tSjjdtjj dd}j D]@\}fddt t j t jfjD}j|ddi|j|<qP|S)Nc3s|]}|jjuVqdSr/base_representationrtr=rrNr%r&rAsz6UnitSphericalRepresentation.__neg__..f@Frpc3s |]\}}|t|VqdSr/rjr=rrrr%r&rAsri)anyrr5rrrtrBrrbrCr,rIrposrrG)rOrr new_compsrrrOr&rs     z#UnitSphericalRepresentation.__neg__cCstjt|jtjddS)aVector norm. The norm is the standard Frobenius norm, i.e., the square root of the sum of the squares of all components with non-angular units, which is always unity for vectors on the unit sphere. Returns ------- norm : `~astropy.units.Quantity` ['dimensionless'] Dimensionless ones, with the same shape as the representation. Frp)rrr4ZonesrCZdimensionless_unscaledrNr%r%r&r s z UnitSphericalRepresentation.normcCs:||j||||}|tur*tS|j|SdSr/)rrdrrrrDrrr%r%r&rs  z.UnitSphericalRepresentation._combine_operationcOs&|d|j|j|i|S)aVector mean. The representation is converted to cartesian, the means of the x, y, and z components are calculated, and the result is converted to a `~astropy.coordinates.SphericalRepresentation`. Refer to `~numpy.mean` for full documentation of the arguments, noting that ``axis`` is the entry in the ``shape`` of the representation, and that the ``out`` argument cannot be used. r )rrDrrr rr%r%r&r s z UnitSphericalRepresentation.meancOs&|d|j|j|i|S)aVector sum. The representation is converted to cartesian, the sums of the x, y, and z components are calculated, and the result is converted to a `~astropy.coordinates.SphericalRepresentation`. Refer to `~numpy.sum` for full documentation of the arguments, noting that ``axis`` is the entry in the ``shape`` of the representation, and that the ``out`` argument cannot be used. r)rrDrrrrr%r%r&rs zUnitSphericalRepresentation.sumcCs |d|j||S)aoCross product of two representations. The calculation is done by converting both ``self`` and ``other`` to `~astropy.coordinates.CartesianRepresentation`, and converting the result back to `~astropy.coordinates.SphericalRepresentation`. Parameters ---------- other : `~astropy.coordinates.BaseRepresentation` subclass instance The representation to take the cross product with. Returns ------- cross_product : `~astropy.coordinates.SphericalRepresentation` With vectors perpendicular to both ``self`` and ``other``. r)rrDrrrrr%r%r&rs  z!UnitSphericalRepresentation.cross)NNT)F)N)F)rdr!r"rerrrnr rDr~rrgrBrCrrrrrrrrrr rr rrrr%r%rr&rs6       *  rcseZdZdZdejiZdfdd ZeddZ d d Z d d Z d dZ e ddZfddZddZdddZddZZS)ra Representation of the distance of points from the origin. Note that this is mostly intended as an internal helper representation. It can do little else but being used as a scale in multiplication. Parameters ---------- distance : `~astropy.units.Quantity` ['length'] The distance of the point(s) from the origin. differentials : dict, `~astropy.coordinates.BaseDifferential`, optional Any differential classes that should be associated with this representation. The input must either be a single `~astropy.coordinates.BaseDifferential` instance (see `._compatible_differentials` for valid types), or a dictionary of of differential instances with keys set to a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be ``'s'`` for seconds, indicating that the derivative is a time derivative. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. raNTcstj|||ddSrErF)rOrarrirr%r&r~szRadialRepresentation.__init__cCs|jSz? The distance from the origin to the point(s).  _distancerNr%r%r&raszRadialRepresentation.distancecCstd|jdS)z?Cartesian unit vectors are undefined for radial representation.z5Cartesian unit vectors are undefined for {} instancesNrrrtrNr%r%r&r sz!RadialRepresentation.unit_vectorscCs tjdtj|jdd}d|iS)Nr%Tr&rar,r-r%r%r&rsz"RadialRepresentation.scale_factorscCstd|jdS)z2Cannot convert radial representation to cartesian.z(cannot convert {} instance to cartesian.NrqrNr%r%r&rsz!RadialRepresentation.to_cartesiancCs||ddS)zU Converts 3D rectangular cartesian coordinates to radial coordinate. F)rari)r )r$r[r%r%r&rsz#RadialRepresentation.from_cartesiancs$t|tr|j|St|SdSr/)rsrrarrrrr%r&r"s  zRadialRepresentation.__mul__cCs|jS)zVector norm. Just the distance itself. Returns ------- norm : `~astropy.units.Quantity` ['dimensionless'] Dimensionless ones, with the same shape as the representation. )rarNr%r%r&r (s zRadialRepresentation.normFcCstSr/)rrr%r%r&r4sz'RadialRepresentation._combine_operationcCs>|d}t||dtjtjftdkr6td||S)aXRadial representations cannot be transformed by a Cartesian matrix. Parameters ---------- matrix : array-like The transformation matrix in a Cartesian basis. Must be a multiplication: a diagonal matrix with identical elements. Must have shape (..., 3, 3), where the last 2 indices are for the matrix on each other axis. Make sure that the matrix shape is compatible with the shape of this representation. Raises ------ ValueError If the matrix is not a multiplication. ).rr.zJRadial representations can only be transformed by a scaled identity matrix)r4rjZnewaxisZidentityrZ)rOrZsclr%r%r&r7s&zRadialRepresentation.transform)NT)F)rdr!r"rerrrnr~rgrarrrrrrr rrrr%r%rr&rs     rcstjurddtjtjfSztdWn*tyXtjtjfddfYS0tdfddfddfddfS)zDFor given operator, return functions that adjust lon, lat, distance.cSs|dtjSN)rrbrr%r%r&rUrBz%_spherical_op_funcs..rcs|gRSr/r%rur}rr%r&r[rBcs|dtjtSrs)rrbr4Zsignbitru scale_signr%r&r^rBcs|Sr/r%rurwr%r&r_rBcs |Sr/r%ru)rscaler%r&r`rB)rrrkr4ZsignrYabs)rr}r%)r}rryrxr&_spherical_op_funcsRs      r{cseZdZdZeeejdZe Z d fdd Z e ddZ ed d Zed d Zed dZddZd!ddZd"fdd ZddZeddZddZddZfddZZS)#raV Representation of points in 3D spherical coordinates. Parameters ---------- lon, lat : `~astropy.units.Quantity` ['angle'] The longitude and latitude of the point(s), in angular units. The latitude should be between -90 and 90 degrees, and the longitude will be wrapped to an angle between 0 and 360 degrees. These can also be instances of `~astropy.coordinates.Angle`, `~astropy.coordinates.Longitude`, or `~astropy.coordinates.Latitude`. distance : `~astropy.units.Quantity` ['length'] The distance to the point(s). If the distance is a length, it is passed to the :class:`~astropy.coordinates.Distance` class, otherwise it is passed to the :class:`~astropy.units.Quantity` class. differentials : dict, `~astropy.coordinates.BaseDifferential`, optional Any differential classes that should be associated with this representation. The input must either be a single `~astropy.coordinates.BaseDifferential` instance (see `._compatible_differentials` for valid types), or a dictionary of of differential instances with keys set to a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be ``'s'`` for seconds, indicating that the derivative is a time derivative. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. rBrCraNTc stj|||||dt|jts|jjjdkrzt|jdd|_WnBty}z*|jd drptd|nWYd}~n d}~00dS)Nrr]FrprzDistance must be >= 0zDistance must be >= 0. To allow negative distance values, you must explicitly pass in a `Distance` object with the the argument 'allow_negative=True'.) rr~rsrprr9 physical_typerZr}rT)rOrBrCrarrierr%r&r~s  z SphericalRepresentation.__init__cCstttttgSr/rGr#r%r%r&rsz1SphericalRepresentation._compatible_differentialscCs|jSrHrIrNr%r%r&rBszSphericalRepresentation.loncCs|jSrJrKrNr%r%r&rCszSphericalRepresentation.latcCs|jSrnrorNr%r%r&rasz SphericalRepresentation.distancecCszt|jt|j}}t|jt|j}}t| |dddt| || ||ddt|||||dddS)Nr'Frpr|rLrOr%r%r&rsz$SphericalRepresentation.unit_vectorsFcCsH|jtj}|r|n|t|j}tjdtj|jdd}|||dS)Nr%Tr&r|) rarrPr4rNrCr(r)rC)rOrQrRrSZ sf_distancer%r%r&rs z%SphericalRepresentation.scale_factorscszt|rlt|trB|||}||jdtj|j|j |ddSt|t rl|||}||j|j|ddSt ||S)Nr\F)r^r_r`rrirBrCrri) rrrrrrBrrbrCrarrrrOrrZdiffsrr%r&rs"    z$SphericalRepresentation.represent_ascCsBt|jtr|jtj}n|j}t|j|j |}t |dddSrT) rsrarviewrrr8Zs2prBrCr)rOr6r:r%r%r&rs  z$SphericalRepresentation.to_cartesiancCs |jdd}|t|ddiSrW)r1r8p2srZr%r%r&rs z&SphericalRepresentation.from_cartesiancsltjj}t|}t|\}}}j||j|dtfddj D} |S)Transform the spherical coordinates using a 3x3 matrix. This returns a new representation and does not modify the original one. Any differentials attached to this representation will also be transformed. Parameters ---------- matrix : (3,3) array-like A 3x3 matrix, such as a rotation matrix (or a stack of matrices). r|c3s$|]\}}||fVqdSr/r4r5r7r%r&rAsz4SphericalRepresentation.transform..) r8rVrBrCr9rrtrarrr,rrOrr@r:rBrCZurrr%r7r&rs  z!SphericalRepresentation.transformcCs t|jS)aVector norm. The norm is the standard Frobenius norm, i.e., the square root of the sum of the squares of all components with non-angular units. For spherical coordinates, this is just the absolute value of the distance. Returns ------- norm : `astropy.units.Quantity` Vector norm, with the same shape as the representation. )r4rzrarNr%r%r&r  s zSphericalRepresentation.normc stfddjDr0tj|g|RSt|g|R\}}}j|j|j|j dd}j D]@\}fddt t j ||fjD}j|ddi|j|<qt|S)Nc3s|]}|jjuVqdSr/rdrfrNr%r&rAsz;SphericalRepresentation._scale_operation..Frpc3s |]\}}|t|VqdSr/rjrhrir%r&rA%rBri)rjrr5rrr{rtrBrCrar,rIrrkrG) rOrr}Zlon_opZlat_opZ distance_oprrrlrrmr&rs    z(SphericalRepresentation._scale_operation)NNNT)F)N)rdr!r"rerrrrrnrZ_unit_representationr~r rrgrBrCrarrrrrrrr rrr%r%rr&rcs4       rcseZdZdZeeejdZdfdd Ze ddZ e d d Z e d d Z d dZ ddZdfdd ZddZeddZddZddZfddZZS)ra Representation of points in 3D spherical coordinates (using the physics convention of using ``phi`` and ``theta`` for azimuth and inclination from the pole). Parameters ---------- phi, theta : `~astropy.units.Quantity` or str The azimuth and inclination of the point(s), in angular units. The inclination should be between 0 and 180 degrees, and the azimuth will be wrapped to an angle between 0 and 360 degrees. These can also be instances of `~astropy.coordinates.Angle`. If ``copy`` is False, `phi` will be changed inplace if it is not between 0 and 360 degrees. r : `~astropy.units.Quantity` The distance to the point(s). If the distance is a length, it is passed to the :class:`~astropy.coordinates.Distance` class, otherwise it is passed to the :class:`~astropy.units.Quantity` class. differentials : dict, `PhysicsSphericalDifferential`, optional Any differential classes that should be associated with this representation. The input must either be a single `PhysicsSphericalDifferential` instance, or a dictionary of of differential instances with keys set to a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be ``'s'`` for seconds, indicating that the derivative is a time derivative. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. r^r_r`NTcstj|||||d|jjdtjddtjddRt|j dtjksft|j dtjkr|t d | tj Wdn1s0Y|jjjd kr|jt|_dS) NrihT)Zinplaceignore)Zinvalidr'rgzEInclination angle(s) must be within 0 deg <= angle <= 180 deg, got {}r])rr~_phiZwrap_atrrbr4Zerrstaterj_thetarZrtoZdegree_rr9r}rr)rOr^r_r`rrirr%r&r~Ss, $z'PhysicsSphericalRepresentation.__init__cCs|jSz. The azimuth of the point(s). rrNr%r%r&r^esz"PhysicsSphericalRepresentation.phicCs|jS)z0 The elevation of the point(s). )rrNr%r%r&r_lsz$PhysicsSphericalRepresentation.thetacCs|jSrn)rrNr%r%r&r`ssz PhysicsSphericalRepresentation.rcCsxt|jt|j}}t|jt|j}}t| |dddt||||| ddt|||||dddS)Nr'Frpr)r4rMr^rNr_r)rOsinphicosphisinthetaZcosthetar%r%r&rzsz+PhysicsSphericalRepresentation.unit_vectorscCs@|jtj}t|j}tjdtj|jdd}||||dS)Nr%Tr&r) r`rrPr4rMr_r(r)rC)rOr`rr*r%r%r&rs  z,PhysicsSphericalRepresentation.scale_factorscst|rvt|trB|||}||jdtj|j|j |ddSt|t rv|||}||jdtj|j|ddSt ||S)Nr\F)rBrCrarrir) rrrrrr^rrbr_r`rrrrrr%r&rs"   z+PhysicsSphericalRepresentation.represent_ascCszt|jtr|jtj}n|j}|t|jt |j }|t|jt|j }|t |j}t |||ddS)rUFrrrri) rsr`rrrrr4rMr_rNr^r)rOr6rrrr%r%r&rs z+PhysicsSphericalRepresentation.to_cartesiancCsLt|j|j}t||j}t|j|j}t||j}||||ddS)rXFr])r4hypotrrrarctan2)r$r[rr`r^r_r%r%r&rs z-PhysicsSphericalRepresentation.from_cartesiancstjdtjj}t|}t|\}}}j|dtj|j |dt fddj D} |S)rr\rc3s$|]\}}||fVqdSr/r4r5r7r%r&rAsz;PhysicsSphericalRepresentation.transform..)r8rVr^rrbr_r9rrtr`rrr,rrr%r7r&rs  z(PhysicsSphericalRepresentation.transformcCs t|jS)aVector norm. The norm is the standard Frobenius norm, i.e., the square root of the sum of the squares of all components with non-angular units. For spherical coordinates, this is just the absolute value of the radius. Returns ------- norm : `astropy.units.Quantity` Vector norm, with the same shape as the representation. )r4rzr`rNr%r%r&r s z#PhysicsSphericalRepresentation.normc stfddjDr0tj|g|RSt|g|R\}}}j|j||j|j dd}j D]@\}fddt t j ||fjD}j|ddi|j|<qx|S)Nc3s|]}|jjuVqdSr/rdrfrNr%r&rAszBPhysicsSphericalRepresentation._scale_operation..Frpc3s |]\}}|t|VqdSr/rjrhrir%r&rArBri)rjrr5rrr{rtr^r_r`r,rIrrkrG) rOrr}phi_opZadjust_theta_signZr_oprrrlrrmr&rs       z/PhysicsSphericalRepresentation._scale_operation)NNNT)N)rdr!r"rerrrrnr~rgr^r_r`rrrrrrrr rrr%r%rr&r,s*"     rcseZdZdZejeejdZdfdd Ze ddZ e d d Z e d d Z d dZ ddZeddZddZfddZZS)ra Representation of points in 3D cylindrical coordinates. Parameters ---------- rho : `~astropy.units.Quantity` The distance from the z axis to the point(s). phi : `~astropy.units.Quantity` or str The azimuth of the point(s), in angular units, which will be wrapped to an angle between 0 and 360 degrees. This can also be instances of `~astropy.coordinates.Angle`, z : `~astropy.units.Quantity` The z coordinate(s) of the point(s) differentials : dict, `CylindricalDifferential`, optional Any differential classes that should be associated with this representation. The input must either be a single `CylindricalDifferential` instance, or a dictionary of of differential instances with keys set to a string representation of the SI unit with which the differential (derivative) is taken. For example, for a velocity differential on a positional representation, the key would be ``'s'`` for seconds, indicating that the derivative is a time derivative. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. rhor^rNTcs6tj|||||d|jj|jjs2tddS)Nrz-rho and z should have matching physical types)rr~_rhor9r"r!rr#)rOrr^rrrirr%r&r~ sz"CylindricalRepresentation.__init__cCs|jS)z? The distance of the point(s) from the z-axis. )rrNr%r%r&r$ szCylindricalRepresentation.rhocCs|jSrrrNr%r%r&r^+ szCylindricalRepresentation.phicCs|jS)z- The height of the point(s). )r!rNr%r%r&r2 szCylindricalRepresentation.zc Cs^t|jt|j}}td|j}t||dddt| |dddtdd|tjdddS)Nr%rFrp)r9rir) r4rMr^rNr(rCrrr))rOrrr*r%r%r&r9 s z&CylindricalRepresentation.unit_vectorscCs0|jtj}tjdtj|jdd}|||dS)Nr%Tr&r)rrrPr4r(r)rC)rOrr*r%r%r&rA s  z'CylindricalRepresentation.scale_factorscCs6t|j|j}t|j|j}|j}||||ddS)zi Converts 3D rectangular cartesian coordinates to cylindrical polar coordinates. F)rr^rri)r4rrrrr)r$r[rr^rr%r%r&rH sz(CylindricalRepresentation.from_cartesiancCs:|jt|j}|jt|j}|j}t|||ddS)zi Converts cylindrical polar coordinates to 3D rectangular cartesian coordinates. Fr)rr4rNr^rMrr)rOrrrr%r%r&rU sz&CylindricalRepresentation.to_cartesianc stfddjDr0tjgRStgR\}}}fdd}j|j|j|j dd}j D]@\}fddt |t j |fjD} j| ddi|j|<q|S) Nc3s|]}|jjuVqdSr/rdrfrNr%r&rAa sz=CylindricalRepresentation._scale_operation..cs|gRSr/r%rurvr%r&rf rBz.Frpc3s |]\}}|t|VqdSr/rjrhrir%r&rAk rBri)rjrr5rrr{rtrr^rr,rIrrkrG) rOrr}rrqZrho_opZz_oprrrlr)r}rrrOr&r` s   z*CylindricalRepresentation._scale_operation)NNNT)rdr!r"rerrrrnr~rgrr^rrrrrrrrr%r%rr&rs$     rcseZdZdZfddZeddZddZedd Zd d Z ed d Z ddZ eddZ ddZ ddddZdddZfddZd ddZZS)!raA base class representing differentials of representations. These represent differences or derivatives along each component. E.g., for physics spherical coordinates, these would be :math:`\delta r, \delta \theta, \delta \phi`. Parameters ---------- d_comp1, d_comp2, d_comp3 : `~astropy.units.Quantity` or subclass The components of the 3D differentials. The names are the keys and the subclasses the values of the ``attr_classes`` attribute. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. Notes ----- All differential representation classes should subclass this base class, and define an ``base_representation`` attribute with the class of the regular `~astropy.coordinates.BaseRepresentation` for which differential coordinates are provided. This will set up a default ``attr_classes`` instance with names equal to the base component names prefixed by ``d_``, and all classes set to `~astropy.units.Quantity`, plus properties to access those, and a default ``__init__`` for initialization. c s|jdvrdSt|ds tdt|dsB|jj}dd|D|_|}|tvrbtd|d |t|<t|jD].}t||svt ||t t |d |d d qvt j fi|dS) aSet default ``attr_classes`` and component getters on a Differential. class BaseDifferential(BaseRepresentationOrDifferential): For these, the components are those of the base representation prefixed by 'd_', and the class is `~astropy.units.Quantity`. )rrrNrezNDifferential representations must have a"base_representation" class attribute.rncSsi|]}d|tjqS)d_)rrrr%r%r&r sz6BaseDifferential.__init_subclass__..Differential class z already definedz Component 'z' of the Differential.r)rdrrrernrr-rZr0r[rgrrr)r$r6Zbase_attr_classesrr>rr%r&r s,      z"BaseDifferential.__init_subclass__cCs$||jvr td|d|jdS)Nrz8 is not compatible with the base (representation) class )rrxrtr$rr%r%r&r s  zBaseDifferential._check_basecCsr|||jD]T}t||}t|d|d}|dur|j|j}|tjj}d|_t |Sqt ddS)zGiven a base (representation instance), determine the unit of the derivative by removing the representation unit from the component units of this differential. rNra!Invalid representation-differential units! This likely happened because either the representation or the associated differential have non-standard units. Check that the input positional data have positional units, and the input velocity data have velocity units, or are both dimensionless.) rrGr:r9Z decomposerZsibasesZ_scalerJ RuntimeError)rOrrXrZd_compZd_unitZ d_unit_sir%r%r&r s    zBaseDifferential._get_deriv_keycCs||||fS)aXGet unit vectors and scale factors from base. Parameters ---------- base : instance of ``self.base_representation`` The points for which the unit vectors and scale factors should be retrieved. Returns ------- unit_vectors : dict of `CartesianRepresentation` In the directions of the coordinates of base. scale_factors : dict of `~astropy.units.Quantity` Scale factors for each of the coordinates Raises ------ TypeError : if the base is not of the correct type rrrrr%r%r&_get_base_vectors s z"BaseDifferential._get_base_vectorscs8|\ttjfddtj|jDS)aConvert the differential to 3D rectangular cartesian coordinates. Parameters ---------- base : instance of ``self.base_representation`` The points for which the differentials are to be converted: each of the components is multiplied by its unit vectors and scale factors. Returns ------- `CartesianDifferential` This object, converted. c3s,|]$\}}t|||VqdSr/rj)r=Zd_crbase_ebase_sfrOr%r&rA sz0BaseDifferential.to_cartesian..)rr r rrrIrGrOrr%rr&r s  zBaseDifferential.to_cartesiancs<||j}||\}|fdd|DddiS)arConvert the differential from 3D rectangular cartesian coordinates to the desired class. Parameters ---------- other The object to convert into this differential. base : `BaseRepresentation` The points for which the differentials are to be converted: each of the components is multiplied by its unit vectors and scale factors. Will be converted to ``cls.base_representation`` if needed. Returns ------- `BaseDifferential` subclass instance A new differential object that is this class' type. c3s$|]\}}||VqdSr/)r)r=r>r~rrr%r&rA sz2BaseDifferential.from_cartesian..riF)rrerr,)r$rrrr%rr&r s zBaseDifferential.from_cartesiancCs<||jur|S||}t|tr.|||S||SdS)aConvert coordinates to another representation. If the instance is of the requested class, it is returned unmodified. By default, conversion is done via cartesian coordinates. Parameters ---------- other_class : `~astropy.coordinates.BaseRepresentation` subclass The type of representation to turn the coordinates into. base : instance of ``self.base_representation`` Base relative to which the differentials are defined. If the other class is a differential representation, the base will be converted to its ``base_representation``. N)rtrrrr)rOrrself_cartesianr%r%r&r s     zBaseDifferential.represent_ascCs2t|tr|||j}n|}|||S)aCreate a new instance of this representation from another one. Parameters ---------- representation : `~astropy.coordinates.BaseRepresentation` instance The presentation that should be converted to this class. base : instance of ``cls.base_representation`` The base relative to which the differentials will be defined. If the representation is a differential itself, the base will be converted to its ``base_representation`` to help convert it. )rsrrrrer)r$rrZ cartesianr%r%r&r6 s  z$BaseDifferential.from_representationcCs&|jt|d|}||j|}|S)CTransform differential using a 3x3 matrix in a Cartesian basis. This returns a new differential and does not modify the original one. Parameters ---------- matrix : (3,3) array-like A 3x3 (or stack thereof) matrix, such as a rotation matrix. base : instance of ``cls.base_representation`` Base relative to which the differentials are defined. If the other class is a differential representation, the base will be converted to its ``base_representation``. transformed_base : instance of ``cls.base_representation`` Base relative to which the transformed differentials are defined. If the other class is a differential representation, the base will be converted to its ``base_representation``. r)rrrrt)rOrrtransformed_baseZcdiffrr%r%r&rK s zBaseDifferential.transformFrcs(fddjD}j|ddiS)aaScale all components. Parameters ---------- op : `~operator` callable Operator to apply (e.g., `~operator.mul`, `~operator.neg`, etc. *args Any arguments required for the operator (typically, what is to be multiplied with, divided by). scaled_base : bool, optional Whether the base was scaled the same way. This affects whether differential components should be scaled. For instance, a differential in longitude should not be scaled if its spherical base is scaled in radius. cs"g|]}t|gRqSr%rjrr}rrOr%r&rFt rBz5BaseDifferential._scale_operation..riF)rGrt)rOrrr}Z scaled_attrsr%rr&rd sz!BaseDifferential._scale_operationcs~t|t|rD|s||fn||f\|jfdd|jDSz||}WntyhtYS0||| SdS)a%Combine two differentials, or a differential with a representation. If ``other`` is of the same differential type as ``self``, the components will simply be combined. If ``other`` is a representation, it will be used as a base for which to evaluate the differential, and the result is a new representation. Parameters ---------- op : `~operator` callable Operator to apply (e.g., `~operator.add`, `~operator.sub`, etc. other : `~astropy.coordinates.BaseRepresentation` subclass instance The other differential or representation. reverse : bool Whether the operands should be reversed (e.g., as we got here via ``self.__rsub__`` because ``self`` is a subclass of ``other``). cs"g|]}t|t|qSr%rjrr;r%r&rF sz7BaseDifferential._combine_operation..N)rsrrtrGrrxrr)rOrrrrr%r;r&rw s  z#BaseDifferential._combine_operationcst|trtSt|Sr/)rsrrrrrrr%r&r s zBaseDifferential.__sub__NcCs4t|ts&|dur&tdt|j||S)apVector norm. The norm is the standard Frobenius norm, i.e., the square root of the sum of the squares of all components with non-angular units. Parameters ---------- base : instance of ``self.base_representation`` Base relative to which the differentials are defined. This is required to calculate the physical size of the differential for all but Cartesian differentials or radial differentials. Returns ------- norm : `astropy.units.Quantity` Vector norm, with the same shape as the representation. Nz3`base` must be provided to calculate the norm of a )rsrrZrrdrr rr%r%r&r  s zBaseDifferential.norm)F)N)rdr!r"rerrrrrrrrrrrrrr rr%r%rr&rq s$ '       rcs^eZdZdZeZdZdfdd ZdddZe ddd Z dd d Z dd dZ e e ZZS)raDifferentials in of points in 3D cartesian coordinates. Parameters ---------- d_x, d_y, d_z : `~astropy.units.Quantity` or array The x, y, and z coordinates of the differentials. If ``d_x``, ``d_y``, and ``d_z`` have different shapes, they should be broadcastable. If not quantities, ``unit`` should be set. If only ``d_x`` is given, it is assumed that it contains an array with the 3 coordinates stored along ``xyz_axis``. unit : `~astropy.units.Unit` or str If given, the differentials will be converted to this unit (or taken to be in this unit if not given. xyz_axis : int, optional The axis along which the coordinates are stored when a single array is provided instead of distinct ``d_x``, ``d_y``, and ``d_z`` (default: 0). copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. NTcs<|dur~|dur~t|tjrt|jjdvrttj|||dd}||_|rZt||d}||_ nd|_ |\|_ |_ |_ dS|\}}}|durt d|dus|durt d|jj|durtj|||dd}tj|||dd}tj|||dd}d}tj||||d|j j|j jr.|j j|j js8td dS) NrTrlrzxyz_axis should only be set if d_x, d_y, and d_z are in a single array passed in through d_x, i.e., d_y and d_z should not be not given.z0d_x, d_y, and d_z are required to instantiate {}Frpz.d_x, d_y and d_z should have equivalent units.)rsr4rrErrr_d_xyzrr_d_x_d_y_d_zrZrrtrdrr~r9r"r#)rOZd_xZd_yd_zr9r$rirr%r&r~ s6 zCartesianDifferential.__init__cstfddjDS)Ncsg|]}t|qSr%rjrrNr%r&rF rBz6CartesianDifferential.to_cartesian..)rrGrr%rNr&r s z"CartesianDifferential.to_cartesiancs|fddjDS)Ncsg|]}t|qSr%rjrrr%r&rF rBz8CartesianDifferential.from_cartesian..)rGr$rrr%rr&r sz$CartesianDifferential.from_cartesiancCs$t||jdd}|j|dddS)aTransform differentials using a 3x3 matrix in a Cartesian basis. This returns a new differential and does not modify the original one. Parameters ---------- matrix : (3,3) array-like A 3x3 (or stack thereof) matrix, such as a rotation matrix. base, transformed_base : `~astropy.coordinates.CartesianRepresentation` or None, optional Not used in the Cartesian transformation. rRr2Fr3)r8r9 get_d_xyzrt)rOrrrr:r%r%r&r s zCartesianDifferential.transformrcCsF|jdur,|j|kr|jSt|j|j|Stj|j|j|jg|dS)aReturn a vector array of the x, y, and z coordinates. Parameters ---------- xyz_axis : int, optional The axis in the final array along which the x, y, z components should be stored (default: 0). Returns ------- d_xyz : `~astropy.units.Quantity` With dimension 3 along ``xyz_axis``. Note that, if possible, this will be a view. Nr.)rrr4rr/rrrr0r%r%r&r s   zCartesianDifferential.get_d_xyz)NNNNT)N)N)NN)r)rdr!r"rerrerr~rrrrrrgZd_xyzrr%r%rr&r s*    rcs2eZdZddZeddZdfdd ZZS) rcCs|||jt|jS)zConvert longitude differential d_lon to d_lon_coslat. Parameters ---------- base : instance of ``cls.base_representation`` The base from which the latitude will be taken. )rd_lonr4rNrCrr%r%r& _d_lon_coslat- s z'BaseSphericalDifferential._d_lon_coslatcCs|||t|jS)aHConvert longitude differential d_lon_coslat to d_lon. Parameters ---------- d_lon_coslat : `~astropy.units.Quantity` Longitude differential that includes ``cos(lat)``. base : instance of ``cls.base_representation`` The base from which the latitude will be taken. rr4rNrC)r$ d_lon_coslatrr%r%r& _get_d_lon8 s z$BaseSphericalDifferential._get_d_lonFcst|trt|t|r"t|trrt|jt|jB}|sB||fn||f\fdd|D}tfi|St||S)"Combine two differentials, or a differential with a representation. If ``other`` is of the same differential type as ``self``, the components will simply be combined. If both are different parts of a `~astropy.coordinates.SphericalDifferential` (e.g., a `~astropy.coordinates.UnitSphericalDifferential` and a `~astropy.coordinates.RadialDifferential`), they will combined appropriately. If ``other`` is a representation, it will be used as a base for which to evaluate the differential, and the result is a new representation. Parameters ---------- op : `~operator` callable Operator to apply (e.g., `~operator.add`, `~operator.sub`, etc. other : `~astropy.coordinates.BaseRepresentation` subclass instance The other differential or representation. reverse : bool Whether the operands should be reversed (e.g., as we got here via ``self.__rsub__`` because ``self`` is a subclass of ``other``). c s(i|] }|t|dt|dqSr'rjrr;r%r&rb sz@BaseSphericalDifferential._combine_operation..) rsrrrrrGrrrrOrrrZall_componentsZ result_argsrr;r&rF s  z,BaseSphericalDifferential._combine_operation)F)rdr!r"rrrrrr%r%rr&r, s  rcseZdZdZeZeddZdfdd Ze dd Z fd d Z dfd d Z e dfdd Z fddZddfdd ZZS)ragDifferential(s) of points on a unit sphere. Parameters ---------- d_lon, d_lat : `~astropy.units.Quantity` The longitude and latitude of the differentials. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. cCstSr/)rr#r%r%r&_dimensional_differentialv sz3UnitSphericalDifferential._dimensional_differentialNTcs2tj|||d|jj|jjs.tddSNrpz-d_lon and d_lat should have equivalent units.rr~_d_lonr9r"_d_latrr#)rOrd_latrirr%r&r~z sz"UnitSphericalDifferential.__init__cCs|j||}||Sr/rrrr$rrZ dimensionalr%r%r&r sz(UnitSphericalDifferential.from_cartesiancsJt|tr|j}nt|tr$|j}n t|S|t}|t|Sr/ rsrrarr`rrrrrOrryrr%r&r s    z&UnitSphericalDifferential.to_cartesiancs*t|tr||||jSt||Sr/)rrrrrrrOrrrr%r&r s z&UnitSphericalDifferential.represent_ascsht|tr||j|jSt|ttfr@||j|}|||jSt|trZ||j |j St ||Sr/) rsrrrrrrrrd_phid_thetarrr$rrrrr%r&r s   z-UnitSphericalDifferential.from_representationcsVtt|r t|||}n2|jj|jj}|j|j|j d|d|||}|S)rr)rr d_distance) r4rurrrrr9rBrrrOrrrrZdurr%r&r sz#UnitSphericalDifferential.transformFrcs$|r |Stj|g|RSdSr/rirrrOrrr}rr%r&r sz*UnitSphericalDifferential._scale_operation)NT)N)N)rdr!r"rerrer rr~rrrrrrrrr%r%rr&ri s     "rcs\eZdZdZeZeZdfdd Zdfdd Z e dfdd Z d d fd d Z Z S)raDifferential(s) of points in 3D spherical coordinates. Parameters ---------- d_lon, d_lat : `~astropy.units.Quantity` The differential longitude and latitude. d_distance : `~astropy.units.Quantity` The differential distance. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. NTcs4tj||||d|jj|jjs0tddSrr)rOrrrrirr%r&r~ szSphericalDifferential.__init__cst|tr||j|jSt|tr,||jSt|trL||||j|jSt|trh||||jSt|t r||j|j |jSt ||SdSr/) rrrrrrrrrrrrrrr%r&r s      z"SphericalDifferential.represent_ascsTt|tr(||j|}|||j|jSt|trF||j|j |j St ||Sr/) rsrrrrrrrrd_rrrrrr%r&r s   z)SphericalDifferential.from_representationFrcs<|r$||j|j||jg|RStj|g|RSdSr/)rtrrrrrrrr%r&r s z&SphericalDifferential._scale_operation)NNT)N)N)rdr!r"rerrer_unit_differentialr~rrrrrr%r%rr&r s  rcsBeZdZdZeddZddZeddZd fd d ZZ S) rzDifferentials from points on a spherical base representation. With cos(lat) assumed to be included in the longitude differential. cCs||||jddfS)aGet unit vectors and scale factors from (unit)spherical base. Parameters ---------- base : instance of ``self.base_representation`` The points for which the unit vectors and scale factors should be retrieved. Returns ------- unit_vectors : dict of `CartesianRepresentation` In the directions of the coordinates of base. scale_factors : dict of `~astropy.units.Quantity` Scale factors for each of the coordinates. The scale factor for longitude does not include the cos(lat) factor. Raises ------ TypeError : if the base is not of the correct type T)rQrrr%r%r&r s z1BaseSphericalCosLatDifferential._get_base_vectorscCs|||jt|jS)zConvert longitude differential with cos(lat) to one without. Parameters ---------- base : instance of ``cls.base_representation`` The base from which the latitude will be taken. )rrr4rNrCrr%r%r&r( s z&BaseSphericalCosLatDifferential._d_loncCs|||t|jS)aHConvert longitude differential d_lon to d_lon_coslat. Parameters ---------- d_lon : `~astropy.units.Quantity` Value of the longitude differential without ``cos(lat)``. base : instance of ``cls.base_representation`` The base from which the latitude will be taken. r)r$rrr%r%r&_get_d_lon_coslat3 s z1BaseSphericalCosLatDifferential._get_d_lon_coslatFcst|trt|t|r"t|trrt|jt|jB}|sB||fn||f\fdd|D}tfi|St||S)rc s(i|] }|t|dt|dqSrrjrr;r%r&r] szFBaseSphericalCosLatDifferential._combine_operation..) rsrrrrrGrrrrrr;r&rA s  z2BaseSphericalCosLatDifferential._combine_operation)F) rdr!r"rerrrrrrr%r%rr&r s   rcseZdZdZeZejejdZe ddZ dfdd Z e d d Z fd d Zdfd d Ze dfdd ZfddZddfdd ZZS)ranDifferential(s) of points on a unit sphere. Parameters ---------- d_lon_coslat, d_lat : `~astropy.units.Quantity` The longitude and latitude of the differentials. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. )rrcCstSr/)rr#r%r%r&rs sz9UnitSphericalCosLatDifferential._dimensional_differentialNTcs2tj|||d|jj|jjs.tddSNrpz4d_lon_coslat and d_lat should have equivalent units.rr~rr9r"rrr#)rOrrrirr%r&r~w sz(UnitSphericalCosLatDifferential.__init__cCs|j||}||Sr/rrr%r%r&r} sz.UnitSphericalCosLatDifferential.from_cartesiancsJt|tr|j}nt|tr$|j}n t|S|t}|t|Sr/rrrr%r&r s    z,UnitSphericalCosLatDifferential.to_cartesiancs*t|tr||||jSt||Sr/)rrrrrrrrr%r&r s z,UnitSphericalCosLatDifferential.represent_ascstt|tr||j|jSt|ttfr@||j|}|||jSt|trf||j |}|||j St ||Sr/) rsrrrrrrrrrrrrr$rrrrr%r&r s   z3UnitSphericalCosLatDifferential.from_representationcsVtt|r t|||}n2|jj|jj}|j|j |jd|d|||}|S)rrrrr) r4rurrrrr9rCrrrrr%r&r sz)UnitSphericalCosLatDifferential.transformFrcs$|r |Stj|g|RSdSr/rrrr%r&r sz0UnitSphericalCosLatDifferential._scale_operation)NT)N)N)rdr!r"rerrerrrnr rr~rrrrrrrrr%r%rr&rd s      "rcsneZdZdZeZeZej ej ej dZ dfdd Z dfdd Z e dfd d Zd d fd d ZZS)raDifferential(s) of points in 3D spherical coordinates. Parameters ---------- d_lon_coslat, d_lat : `~astropy.units.Quantity` The differential longitude (with cos(lat) included) and latitude. d_distance : `~astropy.units.Quantity` The differential distance. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. rNTcs4tj||||d|jj|jjs0tddSrr)rOrrrrirr%r&r~ sz$SphericalCosLatDifferential.__init__cst|tr||j|jSt|tr,||jSt|trL||||j|jSt|trh||||jSt|t r||||j |jSt ||Sr/) rrrrrrrrrrrrrrr%r&r s      z(SphericalCosLatDifferential.represent_ascs`t|tr(||j|}|||j|jSt|trR||j|}|||j |j St ||Sr/) rsrrrrrrrrrrrrrr%r&r s   z/SphericalCosLatDifferential.from_representationFrcs<|r$||j|j||jg|RStj|g|RSdSr/)rtrrrrrrrr%r&r s z,SphericalCosLatDifferential._scale_operation)NNT)N)N)rdr!r"rerrerrrrrnr~rrrrrr%r%rr&r s rcsVeZdZdZeZddZdddZeddZ edfd d Z dfd d Z Z S)raHDifferential(s) of radial distances. Parameters ---------- d_distance : `~astropy.units.Quantity` The differential distance. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. cCs|j|tSr/)rrrrrr%r%r&r szRadialDifferential.to_cartesianNcCs|jSr/)rrr%r%r&r  szRadialDifferential.normcCs|||tddS)NFrp)rrrrr%r%r&r" sz!RadialDifferential.from_cartesiancs>t|ttfr||jSt|tr,||jSt||SdSr/)rsrrrrrrr)r$rrrr%r&r' s   z&RadialDifferential.from_representationFcst||jrB|r |j|jn|j|j|jddSt|ttfrt|jt|jB}|sp||fn||f\fdd|D}t fi|St ||SdS)NFrpc s(i|] }|t|dt|dqSrrjrr;r%r&r< sz9RadialDifferential._combine_operation..) rsrerarrtrrrrGrrrrrr;r&r1 s z%RadialDifferential._combine_operation)N)N)F) rdr!r"rerrerr rrrrrr%r%rr&r s    rcsXeZdZdZeZdfdd Zdfdd Zedfdd Z d d fd d Z Z S)raDifferential(s) of 3D spherical coordinates using physics convention. Parameters ---------- d_phi, d_theta : `~astropy.units.Quantity` The differential azimuth and inclination. d_r : `~astropy.units.Quantity` The differential radial distance. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. NTcs4tj||||d|jj|jjs0tddS)Nrpz/d_phi and d_theta should have equivalent units.)rr~Z_d_phir9r"Z_d_thetarr#)rOrrrrirr%r&r~S sz%PhysicsSphericalDifferential.__init__cst|tr||j|j |jSt|tr8||j|j St|trp|||jt |j }|||j |jSt|t r|||jt |j }|||j St|t r||jSt ||Sr/)rrrrrrrrr4rMr_rrrr)rOrrrrr%r&rY s        z)PhysicsSphericalDifferential.represent_ascsdt|tr||j|j |jSt|trV|||jt |j }|||j |jSt ||Sr/) rsrrrrrrrr4rMr_rr)r$rrrrr%r&rn s    z0PhysicsSphericalDifferential.from_representationFrcs<|r$||j|j||jg|RStj|g|RSdSr/)rtrrrrrrrr%r&r} s z-PhysicsSphericalDifferential._scale_operation)NNT)N)N) rdr!r"rerrer~rrrrrr%r%rr&rD s rcs&eZdZdZeZdfdd ZZS)raDifferential(s) of points in cylindrical coordinates. Parameters ---------- d_rho : `~astropy.units.Quantity` ['speed'] The differential cylindrical radius. d_phi : `~astropy.units.Quantity` ['angular speed'] The differential azimuth. d_z : `~astropy.units.Quantity` ['speed'] The differential height. copy : bool, optional If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes. NFcs4tj||||d|jj|jjs0tddS)Nrpz+d_rho and d_z should have equivalent units.)rr~Z_d_rhor9r"rrr#)rOZd_rhorrrirr%r&r~ sz CylindricalDifferential.__init__)NNF)rdr!r"rerrer~rr%r%rr&r sr)r1)>rerr rrrZnumpyr4Z astropy.unitsZunitsrZerfarr8ZanglesrrrZ distancesrZmatrix_utilitiesrZ astropy.utilsr r Zastropy.utils.data_infor Zastropy.utils.exceptionsr __all__r+r-rrr(r'r.r0r7r8r rrrrrrr{rrrrrrrrrrrrrrr%r%r%r&sx        Tz &wlJOwEx=g:Zk?6@