IR-eddlZddlmZmZddlmZddlZddlm Z ddl m Z m Z m Z gdZejejejejiZdZdZd Zejd ejeejdiZGd d eZGd deZGddeZGddeZGddZGddeeZGddeeZdZ GddeeZ!dS)N)ABCMetaabstractmethod)deepcopy)log)QuantityUnitUnitConversionError)MissingDataAssociationException"IncompatibleUncertaintiesException NDUncertaintyStdDevUncertaintyUnknownUncertaintyVarianceUncertaintyInverseVariancecPtjtj|jt }fdt |jD}||gtj|j|zS)Ncg|]}|v| Sr).0i preserve_axess z._move_preserved_axes_first..&s#JJJ11M3I3IQ3I3I3I) npprodarrayshapelistrangendimreshapetolist)arrrzeroth_axis_after_reshape collapse_axess ` r_move_preserved_axes_firstr&s!#(;(;Dr8Es BGBEIIa$6$677rceZdZdZdS)r zThis exception should be used to indicate cases in which uncertainties with two different classes can not be propagated. N__name__ __module__ __qualname____doc__rrrr r Krr ceZdZdZdS)r zThis exception should be used to indicate that an uncertainty instance has not been associated with a parent `~astropy.nddata.NDData` object. Nr:rrrr r Qr?rr ceZdZdZddZeedZedZedZ e j dZ ed Z e j d Z ed Z ed Z e j d Z edZdZdZdZdZddZdZedZedZedZedZdZdS)r a}This is the metaclass for uncertainty classes used with `NDData`. Parameters ---------- array : any type, optional The array or value (the parameter name is due to historical reasons) of the uncertainty. `numpy.ndarray`, `~astropy.units.Quantity` or `NDUncertainty` subclasses are recommended. If the `array` is `list`-like or `numpy.ndarray`-like it will be cast to a plain `numpy.ndarray`. Default is ``None``. unit : unit-like, optional Unit for the uncertainty ``array``. Strings that can be converted to a `~astropy.units.Unit` are allowed. Default is ``None``. copy : `bool`, optional Indicates whether to save the `array` as a copy. ``True`` copies it before saving, while ``False`` tries to save every parameter as reference. Note however that it is not always possible to save the input as reference. Default is ``True``. Raises ------ IncompatibleUncertaintiesException If given another `NDUncertainty`-like class as ``array`` if their ``uncertainty_type`` is different. NTc t|trO|j|jkrt| ||jkrt jdn|j|j}|j}nSt|tr>|'|j ||jkrt jdn|j|j}|j }|d|_nt||_|rt|}t|}||_d|_ dS)Nz;overwriting Uncertainty's current unit with specified unit.z8overwriting Quantity's current unit with specified unit.) isinstancer uncertainty_typer _unitrinfounitrrvaluerr parent_nddata)selfrcopyrGs r__init__zNDUncertainty.__init__ws e] + + %)>>>88DEK$7$7VWWWW(zKEE x ( ( EJ$:tuz?Q?QSTTTT'zKE <DJJdDJ  "UOOED>>D !rcdS)z`str` : Short description of the type of uncertainty. Defined as abstract property so subclasses *have* to override this. NrrJs rrDzNDUncertainty.uncertainty_type trcdS)zp`bool` : Supports uncertainty propagation with correlated uncertainties? .. versionadded:: 1.2 FrrNs rsupports_correlatedz!NDUncertainty.supports_correlateds urc|jS)z*`numpy.ndarray` : the uncertainty's value.)_arrayrNs rrzNDUncertainty.arrays {rct|ttjfrtj|dd}||_dS)NF)subokrK)rCrrndarrayrrSrJrHs rrzNDUncertainty.arrays< edBJ/ 0 0 =HU%e<<MM "'7'?  "{'> ?? LL !- ??@PQQ "&!D!D[!Q!Q"%%di00000*-%vdi=='  s C##3DcdS)z Subclasses must override this property. It should take in a data unit and return the correct unit for the uncertainty given the uncertainty type. NrrWs rr[z,NDUncertainty._data_unit_to_uncertainty_unit$rOrc|jjdz} tj|jd|}n$#t $rt |j}YnwxYwd||dgS)N(z, ) separatorprefix)) __class__r;r array2stringrrestrjoin)rJrsbodys r__repr__zNDUncertainty.__repr__-sw(3. #?4:fMMMDD # # #tz??DDD #wwc*+++s.AAcj |j|j|jfS#t$r|j|jdfcYSwxYwr()rSrErIr rNs r __getstate__zNDUncertainty.__getstate__6sM 1; D,>> >. 1 1 1; D0 0 0 0 1s 22ct|dkrtd|d|_|d|_|d}|t j|}||_dS)Nz!The state should contain 3 items.r)r) TypeErrorrSrErcrdrZ)rJstaterhs r __setstate__zNDUncertainty.__setstate__>sb u::???@@ @Ah 1X q  [((F$rcR||j||jdS)zBNormal slicing on the array, keep the unit and return a reference.F)rGrK)rvrrG)rJitems r __getitem__zNDUncertainty.__getitem__Is#~~dj.TYU~KKKrc||jsLt|tjs|dkr,t d|jj|||j }|jdkr| |||}n|jdkr| |||}nq|jdkr| |||}nN|jdvr| |||}n-t d|j|||}||d S) aCalculate the resulting uncertainty given an operation on the data. .. versionadded:: 1.2 Parameters ---------- operation : callable The operation that is performed on the `NDData`. Supported are `numpy.add`, `numpy.subtract`, `numpy.multiply` and `numpy.true_divide` (or `numpy.divide`). other_nddata : `NDData` instance The second operand in the arithmetic operation. result_data : `~astropy.units.Quantity` or ndarray The result of the arithmetic operations on the data. correlation : `numpy.ndarray` or number The correlation (rho) is defined between the uncertainties in sigma_AB = sigma_A * sigma_B * rho. A value of ``0`` means uncorrelated operands. axis : int or tuple of ints, optional Axis over which to perform a collapsing operation. Returns ------- resulting_uncertainty : `NDUncertainty` instance Another instance of the same `NDUncertainty` subclass containing the uncertainty of the result. Raises ------ ValueError If the ``operation`` is not supported or if correlation is not zero but the subclass does not support correlated uncertainties. Notes ----- First this method checks if a correlation is given and the subclass implements propagation with correlated uncertainties. Then the second uncertainty is converted (or an Exception is raised) to the same class in order to do the propagation. Then the appropriate propagation method is invoked and the result is returned. rz={} does not support uncertainty propagation with correlation.Naddsubtractmultiply) true_dividedividezunsupported operation: F)rK)rQrCrrV ValueErrorr]rvr;_convert_uncertainty uncertainty_propagate_add_propagate_subtract_propagate_multiply_propagate_divide_propagate_collapse)rJ operation other_nddata result_data correlationr4 other_uncertresults r propagatezNDUncertainty.propagateMsg`' +rz22 kQ6F6F vdn566  #44\5MNNL!U**,,\; TT#z1111 +{#z1111 +{#'@@@// k;WW !O9;M!O!OPPP--i>>F~~f5~111rct|tr'|j|jkr|S||St)aChecks if the uncertainties are compatible for propagation. Checks if the other uncertainty is `NDUncertainty`-like and if so verify that the uncertainty_type is equal. If the latter is not the case try returning ``self.__class__(other_uncert)``. Parameters ---------- other_uncert : `NDUncertainty` subclass The other uncertainty. Returns ------- other_uncert : `NDUncertainty` subclass but converted to a compatible `NDUncertainty` subclass if possible and necessary. Raises ------ IncompatibleUncertaintiesException: If the other uncertainty cannot be converted to a compatible `NDUncertainty` subclass. )rCr rDrvr rJrs rrz"NDUncertainty._convert_uncertaintysE0 lM 2 2 5$ (EEE##~~l3334 4rcdSr(rrJrrrs rrzNDUncertainty._propagate_addtrcdSr(rrs rrz!NDUncertainty._propagate_subtractrrcdSr(rrs rrz!NDUncertainty._propagate_multiplyrrcdSr(rrs rrzNDUncertainty._propagate_dividerrct|dd}|tt|dt|dd}|t|jd||S)aUConvert this uncertainty to a different uncertainty type. Parameters ---------- other_uncert : `NDUncertainty` subclass The `NDUncertainty` subclass to convert to. Returns ------- resulting_uncertainty : `NDUncertainty` instance An instance of ``other_uncert`` subclass containing the uncertainty converted to the new uncertainty type. Raises ------ TypeError If either the initial or final subclasses do not support conversion, a `TypeError` is raised. _convert_to_varianceNz9 does not support conversion to another uncertainty type._convert_from_variancez; does not support conversion from another uncertainty type.)rkrtyper;)rJr as_variance from_variances r represent_aszNDUncertainty.represent_ass(d$:DAA  ::XXX  .FMM  (,,, }[[]]+++r)NTNr()r;r<r=r>rLpropertyrrDrQrsetterrGrarIr[r{r}rrrrrrrrrrrrr r Ws;> " " " "D^XXX \\ X [[0SSXS !/!/X!/F###J^,,,111 % % %LLLN2N2N2N2`555@^^^^,,,,,rr ) metaclasscbeZdZdZedZedZdZdZdZ dZ dZ d Z d S) rzThis class implements any unknown uncertainty type. The main purpose of having an unknown uncertainty class is to prevent uncertainty propagation. Parameters ---------- args, kwargs : see `NDUncertainty` cdS)zC`False` : Uncertainty propagation is *not* possible for this class.FrrNs rrQz&UnknownUncertainty.supports_correlated urcdS)zq``"unknown"`` : `UnknownUncertainty` implements any unknown uncertainty type. unknownrrNs rrDz#UnknownUncertainty.uncertainty_types yrcdS)z> No way to convert if uncertainty is unknown. NrrWs rr[z1UnknownUncertainty._data_unit_to_uncertainty_units trc$d}t|)zcRaise an Exception because unknown uncertainty types cannot implement propagation. z3Uncertainties of unknown type cannot be propagated.)r )rJrmsgs rrz'UnknownUncertainty._convert_uncertainty sD0555rcdS)z+Not possible for unknown uncertainty types.Nrrs rrz!UnknownUncertainty._propagate_addrrcdSr(rrs rrz&UnknownUncertainty._propagate_subtracttrcdSr(rrs rrz&UnknownUncertainty._propagate_multiplyrrcdSr(rrs rrz$UnknownUncertainty._propagate_dividerrN) r;r<r=r>rrQrDr[rrrrrrrrrrs  XX  666rrcDeZdZdZd dZdZdddfdZdd d fd ZdS) _VariancePropagationMixinz Propagation of uncertainties for variances, also used to perform error propagation for variance-like uncertainties (standard deviation and inverse variance). Nc4 |jjdz}n#ttf$rd}YnwxYw|j|t jt jfvr|||St|}t|}t j |j|jj }|jM||j|jjdzkr,|||jz|j}n ||}|||SdS)ah Error propagation for collapse operations on variance or variance-like uncertainties. Uncertainties are calculated using the formulae for variance but can be used for uncertainty convertible to a variance. Parameters ---------- numpy_op : function Numpy operation like `np.sum` or `np.max` to use in the collapse subtract : bool, optional If ``True``, propagate for subtraction, otherwise propagate for addition. axis : tuple, optional Axis on which to compute collapsing operations. rNr4)rIrGrerrrminmax_get_err_at_extremumcollapse_to_variance_mappingcollapse_from_variance_mappingr/ masked_arraymaskr\rH)rJnumpy_opr4result_unit_sq to_variancermasked_uncertaintythiss rrz-_VariancePropagationMixin._propagate_collapse)sB& "!/4a7NN * " " "!NNN " : !BFBF+++000EEE;8D >x H %'U%7%7J 2 7&&"I)# DI..$2D2I12LLL $ $6$)$CDDN++D ';'9::D$}T5555A " !s ((c  tdsg|tjurtjj n|tjurtjj tj|jj }S tj |j  }|j |Sfd|D}tj t|j j|t|j j|}t|j|}tj fdt#||D}t%|j j||S)a Return the value of the ``uncertainty`` array at the indices which satisfy the ``extremum`` function applied to the ``measurement`` array, where we expect ``extremum`` to be np.argmax or np.argmin, and we expect a two-dimensional output. Assumes the ``measurement`` and ``uncertainty`` array dimensions are ordered such that the zeroth dimension is the one to preserve. For example, if you start with array with shape (a, b, c), this function applies the ``extremum`` function to the last two dimensions, with shapes b and c. This operation is difficult to cast in a vectorized way. Here we implement it with a list comprehension, which is likely not the most performant solution. N__len__cg|]}|v| Srr)raxr4s rrzB_VariancePropagationMixin._get_err_at_extremum..sAAA"D.....rchg|].\}}|tj||j/Sr)r unravel_indexr)rme arg_extremums rrzB_VariancePropagationMixin._get_err_at_extremum..s9 V V Vtq!Qr Q99 : V V Vr)hasattrrrr/argminrargmaxarangerr asanyarrayrIravelrr&rlrzipr-) rJextremumr4all_axesindrmeaserrrrs ` @rrz._VariancePropagationMixin._get_err_at_extremumcsi"  GD)$<$< 6D rv  5 N N &t'9'> N N  )]CC V V V Vs4QT~~ V V V  '   #     rFc|Sr(rr3s rr8z"_VariancePropagationMixin.arc|Sr(rrs rr8z"_VariancePropagationMixin.rc|rd}nd} |jdz}n#t$rd}YnwxYw|j]|jE|||jkr1||j|jz|j} n||j} nd} |jj|jR||j|jjdzkr1||j|jz|j} n||j} nd} t |tjs|dkr)d|ztj | | zz} | | z|| zz} n| | z} || S)a_ Error propagation for addition or subtraction of variance or variance-like uncertainties. Uncertainties are calculated using the formulae for variance but can be used for uncertainty convertible to a variance. Parameters ---------- other_uncert : `~astropy.nddata.NDUncertainty` instance The uncertainty, if any, of the other operand. result_data : `~astropy.nddata.NDData` instance The results of the operation on the data. correlation : float or array-like Correlation of the uncertainties. subtract : bool, optional If ``True``, propagate for subtraction, otherwise propagate for addition. to_variance : function, optional Function that will transform the input uncertainties to variance. The default assumes the uncertainty is the variance. from_variance : function, optional Function that will convert from variance to the input uncertainty. The default assumes the uncertainty is the variance. rrNr) rGrerr\rHrIrCrrVr1) rJrrrrrrcorrelation_signrotherrcorrrs r_propagate_add_subz,_VariancePropagationMixin._propagate_add_subsL  !!    "(-q0NN " " "!NNN "   ) ,;;!DD22  K 2l6G GHHR'' $ L$677E : ! %K **d.@.Eq.HHH#{4:#:;;>>~NNT"{4:..D k2: . . "+2B2B{?RWTE\%:%::DE\$4t$;;FFE\F}V$$$s  ##c|Sr(rrs rr8z"_VariancePropagationMixin.rrc|Sr(rrs rr8z"_VariancePropagationMixin.rrc8t|tr|j}|rd}nd}|j|jrm|d|jzd|jjzdzjkrA||j|jzd|jjzdzj}n||j}tj|jj dz|z} nd} |j|jrm|d|jzd|jjzdzjkrA||j|jzd|jjzdzj} n||j} tj|jj dz| z} nd} t|tj s|dkr8d|ztj | |zz|jj z|jj z} nd} |r$|| | z|| zz|jj dzz S|| | z|| zzS)ac Error propagation for multiplication or division of variance or variance-like uncertainties. Uncertainties are calculated using the formulae for variance but can be used for uncertainty convertible to a variance. Parameters ---------- other_uncert : `~astropy.nddata.NDUncertainty` instance The uncertainty, if any, of the other operand. result_data : `~astropy.nddata.NDData` instance The results of the operation on the data. correlation : float or array-like Correlation of the uncertainties. divide : bool, optional If ``True``, propagate for division, otherwise propagate for multiplication. to_variance : function, optional Function that will transform the input uncertainties to variance. The default assumes the uncertainty is the variance. from_variance : function, optional Function that will convert from variance to the input uncertainty. The default assumes the uncertainty is the variance. rrNrr) rCrrHrrGrIr\rabsrlrVr1) rJrrrrrrrd_brightd_aleftrs r_propagate_multiply_dividez4_VariancePropagationMixin._propagate_multiply_dividesN k8 , , ,%+K  !!      ) ! 6KL$5 566388Q>DEE K 2l6G GHHR\7<<BCC "k,"455F4-2A5;<rrrrrrrrr"s 86868686t1 1 1 pK!k[%[%[%[%DK!kDIDIDIDIDIDIrrceZdZdZedZedZdZfdZfdZ fdZ fdZ fd Z d Z d Zed ZxZS) r aStandard deviation uncertainty assuming first order gaussian error propagation. This class implements uncertainty propagation for ``addition``, ``subtraction``, ``multiplication`` and ``division`` with other instances of `StdDevUncertainty`. The class can handle if the uncertainty has a unit that differs from (but is convertible to) the parents `NDData` unit. The unit of the resulting uncertainty will have the same unit as the resulting data. Also support for correlation is possible but requires the correlation as input. It cannot handle correlation determination itself. Parameters ---------- args, kwargs : see `NDUncertainty` Examples -------- `StdDevUncertainty` should always be associated with an `NDData`-like instance, either by creating it during initialization:: >>> from astropy.nddata import NDData, StdDevUncertainty >>> ndd = NDData([1,2,3], unit='m', ... uncertainty=StdDevUncertainty([0.1, 0.1, 0.1])) >>> ndd.uncertainty # doctest: +FLOAT_CMP StdDevUncertainty([0.1, 0.1, 0.1]) or by setting it manually on the `NDData` instance:: >>> ndd.uncertainty = StdDevUncertainty([0.2], unit='m', copy=True) >>> ndd.uncertainty # doctest: +FLOAT_CMP StdDevUncertainty([0.2]) the uncertainty ``array`` can also be set directly:: >>> ndd.uncertainty.array = 2 >>> ndd.uncertainty StdDevUncertainty(2) .. note:: The unit will not be displayed. cdS)z`True` : `StdDevUncertainty` allows to propagate correlated uncertainties. ``correlation`` must be given, this class does not implement computing it by itself. TrrNs rrQz%StdDevUncertainty.supports_correlated trcdS)z>``"std"`` : `StdDevUncertainty` implements standard deviation.stdrrNs rrDz"StdDevUncertainty.uncertainty_typerrc>t|tr|Str()rCr r rs rrz&StdDevUncertainty._convert_uncertaintys! l$5 6 6 5 4 4rczt|||dtjtjSNFrrrsuperrrsquarer1rJrrrrvs rrz StdDevUncertainty._propagate_adds:ww))    ' *   rczt|||dtjtjSNTrrrs rrz%StdDevUncertainty._propagate_subtracts:ww))    ' *   rczt|||dtjtjSNFrrrrrrrr1rs rrz%StdDevUncertainty._propagate_multiplys:ww11    ' 2   rczt|||dtjtjSNTrrrs rrz#StdDevUncertainty._propagate_divides:ww11    ' 2   rcJt||S)Nr)rr)rJnumpy_operationr4rvs rrz%StdDevUncertainty._propagate_collapses ww**?*FFFrc|Sr(rrWs rr[z0StdDevUncertainty._data_unit_to_uncertainty_units rcp|jdn |jdz}|jdn |jdz}t||S)NrrGrrGrrJ new_arraynew_units rrz&StdDevUncertainty._convert_to_variancesA J.DDDJM 9,44$)Q,"98<<<rrQrDrrrrrrr[r classmethodr __classcell__rvs@rr r zs*))VXX555                     GGGGG=== --[-----rr ceZdZdZedZedZfdZfdZfdZ fdZ dZ d Z e d ZxZS) ra Variance uncertainty assuming first order Gaussian error propagation. This class implements uncertainty propagation for ``addition``, ``subtraction``, ``multiplication`` and ``division`` with other instances of `VarianceUncertainty`. The class can handle if the uncertainty has a unit that differs from (but is convertible to) the parents `NDData` unit. The unit of the resulting uncertainty will be the square of the unit of the resulting data. Also support for correlation is possible but requires the correlation as input. It cannot handle correlation determination itself. Parameters ---------- args, kwargs : see `NDUncertainty` Examples -------- Compare this example to that in `StdDevUncertainty`; the uncertainties in the examples below are equivalent to the uncertainties in `StdDevUncertainty`. `VarianceUncertainty` should always be associated with an `NDData`-like instance, either by creating it during initialization:: >>> from astropy.nddata import NDData, VarianceUncertainty >>> ndd = NDData([1,2,3], unit='m', ... uncertainty=VarianceUncertainty([0.01, 0.01, 0.01])) >>> ndd.uncertainty # doctest: +FLOAT_CMP VarianceUncertainty([0.01, 0.01, 0.01]) or by setting it manually on the `NDData` instance:: >>> ndd.uncertainty = VarianceUncertainty([0.04], unit='m^2', copy=True) >>> ndd.uncertainty # doctest: +FLOAT_CMP VarianceUncertainty([0.04]) the uncertainty ``array`` can also be set directly:: >>> ndd.uncertainty.array = 4 >>> ndd.uncertainty VarianceUncertainty(4) .. note:: The unit will not be displayed. cdS)z6``"var"`` : `VarianceUncertainty` implements variance.varrrNs rrDz$VarianceUncertainty.uncertainty_type'rrcdS)z`True` : `VarianceUncertainty` allows to propagate correlated uncertainties. ``correlation`` must be given, this class does not implement computing it by itself. TrrNs rrQz'VarianceUncertainty.supports_correlated,rrcNt|||dS)NFrrrrs rrz"VarianceUncertainty._propagate_add6s-ww)) +{U*   rcNt|||dS)NTr!r"rs rrz'VarianceUncertainty._propagate_subtract;s-ww)) +{T*   rcNt|||dS)NFrrrrs rrz'VarianceUncertainty._propagate_multiply@s-ww11 +{52   rcNt|||dS)NTr%r&rs rrz%VarianceUncertainty._propagate_divideEs-ww11 +{42   rc |dzS)NrrrWs rr[z2VarianceUncertainty._data_unit_to_uncertainty_unitJs axrc|Sr(rrNs rrz(VarianceUncertainty._convert_to_varianceMs rc|Sr(r)rrs rrz*VarianceUncertainty._convert_from_variancePsrr;r<r=r>rrDrQrrrrr[rrrrrs@rrrs..`XX                    [rrc d|z S)z5Just a simple inverse for use in the InverseVariance.rrrs r_inverser-Us q5LrceZdZdZedZedZfdZfdZfdZ fdZ dZ d Z e d ZxZS) ra Inverse variance uncertainty assuming first order Gaussian error propagation. This class implements uncertainty propagation for ``addition``, ``subtraction``, ``multiplication`` and ``division`` with other instances of `InverseVariance`. The class can handle if the uncertainty has a unit that differs from (but is convertible to) the parents `NDData` unit. The unit of the resulting uncertainty will the inverse square of the unit of the resulting data. Also support for correlation is possible but requires the correlation as input. It cannot handle correlation determination itself. Parameters ---------- args, kwargs : see `NDUncertainty` Examples -------- Compare this example to that in `StdDevUncertainty`; the uncertainties in the examples below are equivalent to the uncertainties in `StdDevUncertainty`. `InverseVariance` should always be associated with an `NDData`-like instance, either by creating it during initialization:: >>> from astropy.nddata import NDData, InverseVariance >>> ndd = NDData([1,2,3], unit='m', ... uncertainty=InverseVariance([100, 100, 100])) >>> ndd.uncertainty # doctest: +FLOAT_CMP InverseVariance([100, 100, 100]) or by setting it manually on the `NDData` instance:: >>> ndd.uncertainty = InverseVariance([25], unit='1/m^2', copy=True) >>> ndd.uncertainty # doctest: +FLOAT_CMP InverseVariance([25]) the uncertainty ``array`` can also be set directly:: >>> ndd.uncertainty.array = 0.25 >>> ndd.uncertainty InverseVariance(0.25) .. note:: The unit will not be displayed. cdS)z;``"ivar"`` : `InverseVariance` implements inverse variance.ivarrrNs rrDz InverseVariance.uncertainty_types vrcdS)z`True` : `InverseVariance` allows to propagate correlated uncertainties. ``correlation`` must be given, this class does not implement computing it by itself. TrrNs rrQz#InverseVariance.supports_correlatedrrcft|||dttSrrrr-rs rrzInverseVariance._propagate_adds6ww))    " *   rcft|||dttSrr3rs rrz#InverseVariance._propagate_subtracts6ww))    " *   rcft|||dttSrrrr-rs rrz#InverseVariance._propagate_multiplys6ww11    " 2   rcft|||dttSr r6rs rrz!InverseVariance._propagate_divides6ww11    " 2   rcd|dzz S)NrrrrWs rr[z.InverseVariance._data_unit_to_uncertainty_units5!8|rcp|jdn d|jz }|jdn d|jz }t||SNrrrrs rrz$InverseVariance._convert_to_variancesA J.DDA N 9,44!di-"98<<<N:N %?244JO8Ks98,,,,rr+rs@rrrZs//bXX                    === --[-----rr)"rcabcrrrKrnumpyrastropyr astropy.unitsrrr __all__r2rmeanrr&r-r6medianr Exceptionr r r rrr rr-rrrrrDs''''''''==========   FBIGRY       ///F 7 7G #It" i U,U,U,U,U,gU,U,U,U,p 00000000fUIUIUIUIUIUIUIUIp y-y-y-y-y-1=y-y-y-x\\\\\3]\\\~ u-u-u-u-u-/u-u-u-u-u-r