IR-erddlZddlmZddlZddlmZddlmZddl m Z m Z ddl m Z ddlmZdgZd ZGd dZdS) N)deepcopy) NDUncertainty)dimensionless_unscaled) format_doc sharedmethod)AstropyUserWarning)MaskedNDArithmeticMixina Performs {name} by evaluating ``self`` {op} ``operand``. Parameters ---------- operand, operand2 : `NDData`-like instance If ``operand2`` is ``None`` or not given it will perform the operation ``self`` {op} ``operand``. If ``operand2`` is given it will perform ``operand`` {op} ``operand2``. If the method was called on a class rather than on the instance ``operand2`` must be given. propagate_uncertainties : `bool` or ``None``, optional If ``None`` the result will have no uncertainty. If ``False`` the result will have a copied version of the first operand that has an uncertainty. If ``True`` the result will have a correctly propagated uncertainty from the uncertainties of the operands but this assumes that the uncertainties are `NDUncertainty`-like. Default is ``True``. .. versionchanged:: 1.2 This parameter must be given as keyword-parameter. Using it as positional parameter is deprecated. ``None`` was added as valid parameter value. handle_mask : callable, ``'first_found'`` or ``None``, optional If ``None`` the result will have no mask. If ``'first_found'`` the result will have a copied version of the first operand that has a mask). If it is a callable then the specified callable must create the results ``mask`` and if necessary provide a copy. Default is `numpy.logical_or`. .. versionadded:: 1.2 handle_meta : callable, ``'first_found'`` or ``None``, optional If ``None`` the result will have no meta. If ``'first_found'`` the result will have a copied version of the first operand that has a (not empty) meta. If it is a callable then the specified callable must create the results ``meta`` and if necessary provide a copy. Default is ``None``. .. versionadded:: 1.2 compare_wcs : callable, ``'first_found'`` or ``None``, optional If ``None`` the result will have no wcs and no comparison between the wcs of the operands is made. If ``'first_found'`` the result will have a copied version of the first operand that has a wcs. If it is a callable then the specified callable must compare the ``wcs``. The resulting ``wcs`` will be like if ``False`` was given otherwise it raises a ``ValueError`` if the comparison was not successful. Default is ``'first_found'``. .. versionadded:: 1.2 uncertainty_correlation : number or `~numpy.ndarray`, optional The correlation between the two operands is used for correct error propagation for correlated data as given in: https://en.wikipedia.org/wiki/Propagation_of_uncertainty#Example_formulas Default is 0. .. versionadded:: 1.2 kwargs : Any other parameter that should be passed to the callables used. Returns ------- result : `~astropy.nddata.NDData`-like The resulting dataset Notes ----- If a ``callable`` is used for ``mask``, ``wcs`` or ``meta`` the callable must accept the corresponding attributes as first two parameters. If the callable also needs additional parameters these can be defined as ``kwargs`` and must start with ``"wcs_"`` (for wcs callable) or ``"meta_"`` (for meta callable). This startstring is removed before the callable is called. ``"first_found"`` can also be abbreviated with ``"ff"``. ceZdZdZdejdddddfdZdZd Zdd Z d Z d Z e e ed dddZe e eddddZe e eddddZe e eddddZe dZe dZe dZe dZe d dZdS)!r a Mixin class to add arithmetic to an NDData object. When subclassing, be sure to list the superclasses in the correct order so that the subclass sees NDData as the main superclass. See `~astropy.nddata.NDDataArray` for an example. Notes ----- This class only aims at covering the most common cases so there are certain restrictions on the saved attributes:: - ``uncertainty`` : has to be something that has a `NDUncertainty`-like interface for uncertainty propagation - ``mask`` : has to be something that can be used by a bitwise ``or`` operation. - ``wcs`` : has to implement a way of comparing with ``=`` to allow the operation. But there is a workaround that allows to disable handling a specific attribute and to simply set the results attribute to ``None`` or to copy the existing attribute (and neglecting the other). For example for uncertainties not representing an `NDUncertainty`-like interface you can alter the ``propagate_uncertainties`` parameter in :meth:`NDArithmeticMixin.add`. ``None`` means that the result will have no uncertainty, ``False`` means it takes the uncertainty of the first operand (if this does not exist from the second operand) as the result's uncertainty. This behavior is also explained in the docstring for the different arithmetic operations. Decomposing the units is not attempted, mainly due to the internal mechanics of `~astropy.units.Quantity`, so the resulting data might have units like ``km/m`` if you divided for example 100km by 5m. So this Mixin has adopted this behavior. Examples -------- Using this Mixin with `~astropy.nddata.NDData`: >>> from astropy.nddata import NDData, NDArithmeticMixin >>> class NDDataWithMath(NDArithmeticMixin, NDData): ... pass Using it with one operand on an instance:: >>> ndd = NDDataWithMath(100) >>> ndd.add(20) NDDataWithMath(120) Using it with two operand on an instance:: >>> ndd = NDDataWithMath(-4) >>> ndd.divide(1, ndd) NDDataWithMath(-0.25) Using it as classmethod requires two operands:: >>> NDDataWithMath.subtract(5, 4) NDDataWithMath(1) TNr first_foundFc  iiiiid} | D]_} | dd} | | | | d| d<7#t$rtd| dd| wxYwi}|d|d<nd|d vrG|j(t|drt |j|d<n1t |j|d<n|j|||fi| d|d<|duo|jdu}|r|s\|j9t|jd s$t|j|jz|j }nFt|j|j }n*tj |j|j}||| }t|d s:tj |tj |t }n|j||fd| i| d}t|d st|d r |j|d <|d|d<nU|s7|jt |j|d<n4t |j|d<n|j||||fd| i| d|d<|j |*|j#t'jd|jdt,|nlt|d rd|d <nV|d vr7|jt |j|d <n3t |j|d <n|j|||fd| i| d |d <|d|d<nT|d vr7|jst |j|d<n1t |j|d<n|j|||fi| d|d<||fS)a Base method which calculates the result of the arithmetic operation. This method determines the result of the arithmetic operation on the ``data`` including their units and then forwards to other methods to calculate the other properties for the result (like uncertainty). Parameters ---------- operation : callable The operation that is performed on the `NDData`. Supported are `numpy.add`, `numpy.subtract`, `numpy.multiply` and `numpy.true_divide`. operand : same type (class) as self see :meth:`NDArithmeticMixin.add` propagate_uncertainties : `bool` or ``None``, optional see :meth:`NDArithmeticMixin.add` handle_mask : callable, ``'first_found'`` or ``None``, optional see :meth:`NDArithmeticMixin.add` handle_meta : callable, ``'first_found'`` or ``None``, optional see :meth:`NDArithmeticMixin.add` compare_wcs : callable, ``'first_found'`` or ``None``, optional see :meth:`NDArithmeticMixin.add` uncertainty_correlation : ``Number`` or `~numpy.ndarray`, optional see :meth:`NDArithmeticMixin.add` operation_ignores_mask : bool, optional When True, masked values will be excluded from operations; otherwise the operation will be performed on all values, including masked ones. axis : int or tuple of ints, optional axis or axes over which to perform collapse operations like min, max, sum or mean. kwargs : Any other parameter that should be passed to the different :meth:`NDArithmeticMixin._arithmetic_mask` (or wcs, ...) methods. Returns ------- result : ndarray or `~astropy.units.Quantity` The resulting data as array (in case both operands were without unit) or as quantity if at least one had a unit. kwargs : `dict` The kwargs should contain all the other attributes (besides data and unit) needed to create a new instance for the result. Creating the new instance is up to the calling method, for example :meth:`NDArithmeticMixin.add`. )maskmetawcsdata uncertainty_rzUnknown prefix z for parameter Nr)ffr unit)raxisr)dtyperrrz!Not setting psf attribute during .r)splitKeyErrorrhasattrr_arithmetic_wcsrrrr npma masked_array zeros_likebool_arithmetic_datar_arithmetic_uncertaintypsfwarningswarn__name__r_arithmetic_maskr_arithmetic_meta)self operationoperandpropagate_uncertainties handle_mask handle_metauncertainty_correlation compare_wcsoperation_ignores_maskrkwdskwds2isplittedkwargsuse_masked_arith masked_inputresults Blib/python3.11/site-packages/astropy/nddata/mixins/ndarithmetic.py _arithmeticzNDArithmeticMixin._arithmeticsRRBrRR R RAwwsAH R26q'hqk"8A;// R R RP!PPQPPQQQ R   F5MM 1 1 1xGGU$;$; ( 5 5u ( 2 2u 0D07K38<F5M#d?Dty/D  * H9(F1K1K(#)$)ty*@ty#Q#Q#QLL#)$)$)#D#D#DLL "u11$)TYGG Y|$777F66** ++vT!B!B!B, +T*7)-16vF vv&& '74+@+@ '!YF6N # *$(F= ! !( '(01D(E(E}%%(01A(B(B}%%$@D$@' %%  %  & %%F= ! 8 G$7GKCFmF6N  !F6NN 1 1 19 5!)',!7!7v!)$)!4!4v2T27K38=F6N v~s A&A(c *|jet|drUt|dr|j||j|j}n||jtz|j|jz}nt|drU|j'||j|jz|j|jz}nh||j|jz|jtz}nA|'||j|jz|j|jz}n||j|d}|S)a} Calculate the resulting data. Parameters ---------- operation : callable see `NDArithmeticMixin._arithmetic` parameter description. operand : `NDData`-like instance The second operand wrapped in an instance of the same class as self. kwds : Additional parameters. Returns ------- result_data : ndarray or `~astropy.units.Quantity` If both operands had no unit the resulting data is a simple numpy array, but if any of the operands had a unit the return is a Quantity. Nrrrr)rrrr)r,r-r.r5r<s r=r$z"NDArithmeticMixin._arithmetic_databs*0 9 &!9!9 w'' GL,@"49gl;;"I!779UWf % % =|'"49 #97<7<;WXX"I*GL   '  m1 1 '/   #/w2MBB0/    #// $3:3F3N4   % '2< > FDI&& &;ty',??$?? ?r@c p||j|jfi|stdt|jS)aA Calculate the resulting wcs. There is actually no calculation involved but it is a good place to compare wcs information of both operands. This is currently not working properly with `~astropy.wcs.WCS` (which is the suggested class for storing as wcs property) but it will not break it neither. Parameters ---------- operation : callable see :meth:`NDArithmeticMixin._arithmetic` parameter description. By default, the ``operation`` will be ignored. operand : `NDData` instance or subclass The second operand wrapped in an instance of the same class as self. compare_wcs : callable see :meth:`NDArithmeticMixin.add` parameter description. kwds : Additional parameters given to ``compare_wcs``. Raises ------ ValueError If ``compare_wcs`` returns ``False``. Returns ------- result_wcs : any type The ``wcs`` of the first operand is returned. zWCS are not equal.)r ValueErrorr)r,r-r.r3r5s r=rz!NDArithmeticMixin._arithmetic_wcssDR{48W[99D99 3122 2!!!r@c *||j|jfi|S)a Calculate the resulting meta. Parameters ---------- operation : callable see :meth:`NDArithmeticMixin._arithmetic` parameter description. By default, the ``operation`` will be ignored. operand : `NDData`-like instance The second operand wrapped in an instance of the same class as self. handle_meta : callable see :meth:`NDArithmeticMixin.add` kwds : Additional parameters given to ``handle_meta``. Returns ------- result_meta : any type The result of ``handle_meta``. )r)r,r-r.r1r5s r=r+z"NDArithmeticMixin._arithmetic_metaBs"4{49gl;;d;;;r@addition+)nameopc 6|jtj||fi|SN)_prepare_then_do_arithmeticraddr,r.operand2r9s r=rVzNDArithmeticMixin.add^s%0t/TTVTTTr@ subtraction-c 6|jtj||fi|SrT)rUrsubtractrWs r=r\zNDArithmeticMixin.subtractc10t/ K(  .4   r@multiplication*c 6|jtj||fi|SrT)rUrmultiplyrWs r=razNDArithmeticMixin.multiplyjr]r@division/c 6|jtj||fi|SrT)rUr true_dividerWs r=dividezNDArithmeticMixin.divideqs10t/ NGX  17   r@c 2|jtjfi|SrT)rUrsumr,r9s r=rhzNDArithmeticMixin.sumxs/t/AA&AAAr@c 2|jtjfi|SrT)rUrmeanris r=rkzNDArithmeticMixin.mean|s/t/BB6BBBr@c b|dd}|jtjfd|i|SNr/)poprUrminr,r9r/s r=rozNDArithmeticMixin.minJ#)**-F"M"M/t/ F  ,C GM   r@c b|dd}|jtjfd|i|Srm)rnrUrmaxrps r=rszNDArithmeticMixin.maxrqr@c t|tr|j}||}|}n*||}n|}|td||}|8t |jts||}|j||fi|\}}n@t |jtr|j|||fi|\}}n|j||fi|\}}||fi|S)aIntermediate method called by public arithmetic (i.e. ``add``) before the processing method (``_arithmetic``) is invoked. .. warning:: Do not override this method in subclasses. This method checks if it was called as instance or as class method and then wraps the operands and the result from ``_arithmetic`` in the appropriate subclass. Parameters ---------- self_or_cls : instance or class ``sharedmethod`` behaves like a normal method if called on the instance (then this parameter is ``self``) but like a classmethod when called on the class (then this parameter is ``cls``). operations : callable The operation (normally a numpy-ufunc) that represents the appropriate action. operand, operand2, kwargs : See for example ``add``. Result ------ result : `~astropy.nddata.NDData`-like Depending how this method was called either ``self_or_cls`` (called on class) or ``self_or_cls.__class__`` (called on instance) is the NDData-subclass that is used as wrapper for the result. NzCoperand2 must be given when the method isn't called on an instance.)rBr rDrC issubclassr>) self_or_clsr-r.rXr9clsr< init_kwdss r=rUz-NDArithmeticMixin._prepare_then_do_arithmeticsbJ k#4 5 5 #'C#% #g,,C- c'llG     1) ) s8}}H!4 3Ix R R6 R R FII *,= > >  /!! !! FII!8 7!!!! FIs6''Y'''r@rT)NN)r) __module__ __qualname____doc__r logical_orr>r$r%r*rr+rr _arit_docrVr\rarfrhrkrorsrUr@r=r r gs<<<D!%M !!$ zzzzx+++ZTTTl-@-@-@-@^,",","\<<<8Z s333UUU43\UZ #666   76\ Z 0S999   :9\ Z s333   43\ BB\BCC\C  \   \ 7;`(`(`(\`(`(`(r@)r'copyrnumpyrastropy.nddata.nduncertaintyr astropy.unitsr astropy.utilsrrastropy.utils.exceptionsrastropy.utils.maskedr __all__r}r r~r@r=rs66666600000022222222777777''''''   P  fJ (J (J (J (J (J (J (J (J (J (r@