U Cv fI$@sVUdZddlmZddlZddlZddlZddlZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZddlZddlmZmZmZddlmZmZddlmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)m*Z*dd l+m,Z,ddl-m.Z.ddl/m0Z0m1Z1ddl2m3Z3e rTddl4m5Z5ddl6m7Z7ddl8m9Z9ddl-m:Z:m;Z;ee?ddhZ@ddZAddZBGdddZCdd d!d"d#ZDdd$d%d&d'ZEe?d(fddd)d*d+d,d-d.ZFde?d(d/dd0d1d2d3d4ZGd5d6d7d8d9ZHd5d6d7d:d;ZIdeJd?ZLd@eMdA<ddBdCd6dDdEdFZNddBd6dGdHdIdJdKZOdLdMZPdNdOdPdQdRdSZQdddTddUdVdWZRdXdYdZd[d\d]d^ZSdde=e?d(d_dd`dadbdcZTdddeZUdfdgZVe?fdhd)didjdkdlZWeXdZYdmdndnd dodpdqZZdrdsZ[e?dtddud(ddvddwdadxdyZ\dtdzd{d|Z]dd}e?dudde=dddtddddd~dd ddd)dd0dCdGdddCddd dd dddZ^dddZ_dddZ`dddddddZadddddddZbdddd dddZcdddZdeddddddddZeeddd[dd[dddZeedd[ddd[dddZeedd[d[dd[dddZeeddddddddZeddddddddZedddddZfddejgdddddd ddddZhededdZiededdZjededdZkedddddZleddddddZledddddddZleddd!ddZlddd!ddZldS)zO Functions for applying functions that act on arrays to xarray's labeled data. ) annotationsN)Counter) TYPE_CHECKING AbstractSetAnyCallableHashableIterableMappingSequenceTypeVarUnionoverload)dtypesduck_array_opsutils)align deep_align) zeros_like)datetime_to_numeric)Indexfilter_indexes_from_coords) merge_attrsmerge_coordinates_without_align)OPTIONS_get_keep_attrsis_duck_dask_array) T_DataArray) is_dict_like is_scalarVariable) Coordinates DataArrayDataset)CombineAttrsOptions JoinOptionszzinnerexactcCs(|D]}t||r|SqtddS)z@Return either first object of type 'kind' or raise if not found.zThis should be unreachable.N) isinstance ValueError)argskindargr1;/tmp/pip-unpacked-wheel-h316xyqg/xarray/core/computation.py_first_of_type2s  r3csfdd|DS)z!Return all objects of type 'kind'csg|]}t|r|qSr1r,.0r0r/r1r2 <s z _all_of_type..r1)r.r/r1r7r2 _all_of_type:sr9c@seZdZdZdZdddZeddZedd Zed d Z ed d Z eddZ eddZ ddZ ddZddZddZefddZdS)_UFuncSignatureaJCore dimensions signature for a given function. Based on the signature provided by generalized ufuncs in NumPy. Attributes ---------- input_core_dims : tuple[tuple] Core dimension names on each input variable. output_core_dims : tuple[tuple] Core dimension names on each output variable. )input_core_dimsoutput_core_dims_all_input_core_dims_all_output_core_dims_all_core_dimsr1cCs>tdd|D|_tdd|D|_d|_d|_d|_dS)Ncss|]}t|VqdSNtupler6ar1r1r2 Usz+_UFuncSignature.__init__..css|]}t|VqdSrArBrDr1r1r2rFVs)rCr;r<r=r>r?)selfr;r<r1r1r2__init__Ts z_UFuncSignature.__init__cCs&|jdkr tdd|jD|_|jS)Ncss|]}|D] }|Vq qdSrAr1r6dimsdimr1r1r2rF^sz6_UFuncSignature.all_input_core_dims..)r= frozensetr;rGr1r1r2all_input_core_dims[s   z#_UFuncSignature.all_input_core_dimscCs&|jdkr tdd|jD|_|jS)Ncss|]}|D] }|Vq qdSrAr1rIr1r1r2rFfsz7_UFuncSignature.all_output_core_dims..)r>rLr<rMr1r1r2all_output_core_dimscs   z$_UFuncSignature.all_output_core_dimscCs|jdkr|j|jB|_|jSrA)r?rNrOrMr1r1r2 all_core_dimsks z_UFuncSignature.all_core_dimscCsddtt|jDS)NcSsi|]\}}|d|qSrKr1)r6nZcore_dimr1r1r2 ssz,_UFuncSignature.dims_map..) enumeratesortedrPrMr1r1r2dims_mapqs z_UFuncSignature.dims_mapcCs t|jSrA)lenr;rMr1r1r2 num_inputswsz_UFuncSignature.num_inputscCs t|jSrA)rWr<rMr1r1r2 num_outputs{sz_UFuncSignature.num_outputscCs6z|j|jko|j|jkWStk r0YdSXdS)NF)r;r<AttributeErrorrGotherr1r1r2__eq__s   z_UFuncSignature.__eq__cCs ||k SrAr1r[r1r1r2__ne__sz_UFuncSignature.__ne__cCs dt|jt|jt|jS)Nz{}({!r}, {!r}))formattype__name__listr;r<rMr1r1r2__repr__s z_UFuncSignature.__repr__cCs:ddd|jD}ddd|jD}|d|S)N,css|]}dd|VqdSz({})rdNr_joinr6rJr1r1r2rFsz*_UFuncSignature.__str__..css|]}dd|VqdSrerfrhr1r1r2rFsz->)rgr;r<)rGlhsrhsr1r1r2__str__sz_UFuncSignature.__str__cszfddjD}fddjD}rdfddDtfddfdd|D}t||}t|S)zCreate an equivalent signature string for a NumPy gufunc. Unlike __str__, handles dimensions that don't map to Python identifiers. Also creates unique names for input_core_dims contained in exclude_dims. csg|]}fdd|DqS)csg|]}j|qSr1rVr6rKrMr1r2r8s?_UFuncSignature.to_gufunc_string...r1r6 core_dimsrMr1r2r8sz4_UFuncSignature.to_gufunc_string..csg|]}fdd|DqS)csg|]}j|qSr1rlrmrMr1r2r8srnr1rorMr1r2r8scsg|]}j|qSr1rlrmrMr1r2r8scs.|kr*|}|g|d|}|S)N_)update)rKrR)counter exclude_dimsr1r2 _enumerates  z4_UFuncSignature.to_gufunc_string.._enumeratecsg|]}fdd|DqS)csg|] }|qSr1r1rmrur1r2r8srnr1r5rvr1r2r8s)r;r<rr`str)rGrtr;r<Z alt_signaturer1)rursrtrGr2to_gufunc_strings   z _UFuncSignature.to_gufunc_stringN)r@)ra __module__ __qualname____doc__ __slots__rHpropertyrNrOrPrVrXrYr]r^rcrkrLrxr1r1r1r2r:?s(         r:z Iterable[Any]r)objectsreturncCs4dd|D}|tt|dkr,|\}nd}|S)NcSsh|]}t|dtqS)name)getattr _DEFAULT_NAMEr6objr1r1r2 szresult_name..)discardrrW)r~namesrr1r1r2 result_names   rzlist[Coordinates])r.rc Cs<g}|D].}z |j}Wntk r*YqX||q|SrA)coordsrZappend)r. coords_listr0rr1r1r2_get_coords_lists  roverriderr(z8tuple[list[dict[Any, Variable]], list[dict[Any, Index]]])r. signaturert combine_attrsrc st|}t|dkr4|s4|\}t|j}t|j}nt|||d\}}g}g} |jD]X} |jt| rfdd| D} t |t| } n|} |} | | | | qT|| fS)aBuild output coordinates and indexes for an operation. Parameters ---------- args : Iterable List of raw operation arguments. Any valid types for xarray operations are OK, e.g., scalars, Variable, DataArray, Dataset. signature : _UfuncSignature Core dimensions signature for the operation. exclude_dims : set, optional Dimensions excluded from the operation. Coordinates along these dimensions are dropped. combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", "override"} or callable, default: "drop" A callable or a string indicating how to combine attrs of the objects being merged: - "drop": empty attrs on returned Dataset. - "identical": all attrs must be the same on every object. - "no_conflicts": attrs from all objects are combined, any that have the same name must also have the same value. - "drop_conflicts": attrs from all objects are combined, any that have the same name but different values are dropped. - "override": skip comparing and copy attrs from the first dataset to the result. If a callable, it must expect a sequence of ``attrs`` dicts and a context object as its only parameters. Returns ------- Dictionaries of Variable and Index objects with merged coordinates. r)rtrcs"i|]\}}|jr||qSr1) isdisjointrJ)r6kvZ dropped_dimsr1r2rSs z3build_output_coords_and_indexes..) rrWdict variablesZxindexesrr<rNsetitemsrr) r.rrtrrZunpacked_coordsZ merged_varsZmerged_indexesZ output_coordsZoutput_indexes output_dimsZfiltered_coordsZfiltered_indexesr1rr2build_output_coords_and_indexess6'       r)rgrt keep_attrsr)z!tuple[DataArray, ...] | DataArray)rrgrcsddlmt|dkr*t||d|dd}t|}|dkrFt|nt|}|jt||||d\}} dd |D} || } |j dkrt fd d t | || D} n|\} | \}| | |d d } t dd |D|d}t | t r| D] }||_qn|| _| S)zYApply a variable level function over DataArray, Variable and/or ndarray objects. rr$rFrgcopyexcludeZraise_on_invaliddroprcSsg|]}t|d|qS)variablerrDr1r1r2r8:sz)apply_dataarray_vfunc..c3s&|]\}}}|||ddVqdS)TrindexesrfastpathNr1)r6rrrr%rr1r2rF?sz(apply_dataarray_vfunc..TrcSsg|] }|jqSr1attrsr6xr1r1r2r8Ns)xarray.core.dataarrayr%rWrr9rr3rrrYrCziprr,r)funcrrgrtrr.objsZ first_objZ result_coordsZresult_indexes data_varsZ result_varoutrrrdar1rr2apply_dataarray_vfuncsZ          rzlist[Iterable]r )all_keysrcCsdd|DS)NcSsi|]}|D] }|dq qSrAr1)r6keyskeyr1r1r2rSYs z%ordered_set_union..r)rr1r1r2ordered_set_unionXsrcs>t|d|ddD]}|qfdd|dDS)Nrrcsg|]}|kr|qSr1r1)r6r intersectionr1r2r8`sz,ordered_set_intersection..)rintersection_update)rrr1rr2ordered_set_intersection\s  rcCs:|d}|ddD] }||krtd|d|q|S)Nrrz6exact match required for all data variable names, but  != )r-)rZ first_keysrr1r1r2assert_and_return_exact_matchcsr)r*outerleftrightr+zdict[str, Callable]_JOINERSzIterable[Mapping | Any]rw)r~howrcCst|}dd|D}||S)NcSsg|]}t|dr|qSr)hasattrrrr1r1r2r8ys z"join_dict_keys..)r)r~rjoinerrr1r1r2join_dict_keyswsrobjectz list[list])r~r fill_valuercsfdd|DS)Ncs g|]fddDqS)cs$g|]}t|r|n|qSr1)rgetr)rrr1r2r8sz2collect_dict_values...r1)r6rr~)rr2r8sz'collect_dict_values..r1)r~rrr1rr2collect_dict_values}s rc CsLz|jWStk rFz |jWYStk r@|YYSXYnXdSrA)rrZr)r0r1r1r2_as_variables_or_variables rz"Mapping[Any, tuple[Variable, ...]]intz$tuple[dict[Hashable, Variable], ...]) result_varsrYrcCsHtddt|D}|D]$\}}t||D]\}}|||<q0q|S)Ncss|] }iVqdSrAr1)r6rqr1r1r2rFsz&_unpack_dict_tuples..)rCrangerr)rrYrrvaluesvalueZ results_dictr1r1r2_unpack_dict_tupless  r)rgrrc Gsltdd|D}t||d}t|||}i}t||D]\}} || ||<q8|jdkrdt||jS|SdS)zjApply a variable level function over dicts of DataArray, DataArray, Variable and ndarray objects. css|]}t|VqdSrA)rr5r1r1r2rFsz0apply_dict_of_variables_vfunc..)rrN)rCrrrrYr) rrrgrr.rZgrouped_by_namerrZ variable_argsr1r1r2apply_dict_of_variables_vfuncs    rzdict[Hashable, Variable]zMapping[Hashable, Variable]zdict[Hashable, Index]r')rcoord_variablesrrcCs.ddlm}||t|}|j|||dS)zdCreate a dataset as quickly as possible. Beware: the `variables` dict is modified INPLACE. rr&r)xarray.core.datasetr'rrrZ_construct_direct)rrrr'Z coord_namesr1r1r2 _fast_datasets  r)rg dataset_joinrrtrzDataset | tuple[Dataset, ...])rrcGsddlm}|tkr$|tkr$tdt||} t|dkrLt||d|dd}t||||d\} } t dd |D}t |f||||d } |j dkrt d d t | | | D} n| \}| \}t | ||d } td d| D|d}t| t r| D] }||_qn|| _| S)zuApply a variable level function over Dataset, dict of DataArray, DataArray, Variable and/or ndarray objects. rr&zto apply an operation to datasets with different data variables with apply_ufunc, you must supply the dataset_fill_value argument.rFrrcss|]}t|d|VqdS)rNrr5r1r1r2rFsz&apply_dataset_vfunc..)rrgrcss|]}t|VqdSrA)r)r6r.r1r1r2rFsrcSsg|] }|jqSr1rrr1r1r2r8sz'apply_dataset_vfunc..)rr'_JOINS_WITHOUT_FILL_VALUES_NO_FILL_VALUE TypeErrorr9rWrrrCrrYrrrr,r)rrrgrrrtrr.r'rZlist_of_coordsZlist_of_indexesrrZ coord_varsrrdsr1r1r2apply_dataset_vfuncsV        rc csfddlm}d}|D]L}z|jf||i}Wn,ttfk rX|dkrP||}|}YnX|VqdS)zBIterate over selections of an xarray object in the provided order.r) _dummy_copyN)xarray.core.groupbyrselKeyError IndexError)rrKrrdummyrZobj_selr1r1r2_iter_over_selectionss  rc sDddlmm}ddlm}fdd|D}|s:td|dtfdd|d d Drhtd jj }j j }g}|D]f}t |rd d|D} n>t |d r||jkrt ||rtdt|||} n t|} || qfddt|D} || \} } jt | tr8tfddt| D} n| } | S)zvApply a dataset or datarray level function over GroupBy, Dataset, DataArray, Variable and/or ndarray objects. r)GroupBypeek_atr!csg|]}t|r|qSr1r4r5rr1r2r8s z&apply_groupby_func..z.must have at least one groupby to iterate overc3s|]}j|j VqdSrA)_groupequals)r6gb) first_groupbyr1r2rFsz%apply_groupby_func..rNzrapply_ufunc can only perform operations over multiple GroupBy objects at once if they are all grouped the same waycss|]\}}|VqdSrAr1)r6rqrr1r1r2rFsrJzugroupby operations cannot be performed with xarray.Variable objects that share a dimension with the grouped dimensionc3s|]}|VqdSrAr1)r6Z zipped_args)rr1r2rF,sc3s|]}|VqdSrAr1)r6output)combiner1r2rF0s)rrrxarray.core.variabler"AssertionErroranyr-rrZ _unique_coordrr,rrJr itertoolsrepeatrrZ_combinerC) rr.rr"ZgroupbysZ grouped_dimZ unique_values iteratorsr0iteratorZappliedZapplied_exampleZcombinedr1)rrrrr2apply_groupby_funcs<        rzIterable[Variable]zdict[Hashable, int])rrtrc Csi}|D]}tt|jt|jkr8tdt|jt|j|jD]L\}}||krF||krh|||<qF|||krFtd|d||d|qFq|S)Nz?broadcasting cannot handle duplicate dimensions on a variable: zLoperands cannot be broadcast together with mismatched lengths for dimension z: z vs )rWrrJr-rbrshape)rrt dim_sizesvarrKsizer1r1r2unified_dim_sizes6s  rr"ztuple[Hashable, ...])rbroadcast_dimsrprc s|j}|j||}|kr |Stfdd|D}|rRtdt||t|fddD}|rtd|dtfdd|D}||}|krtfd d|D} t|| }||krg} |D](} | kr| t q| r| t j q|t| }|S) Ncsg|]}|kr|qSr1r1r6d set_old_dimsr1r2r8asz)broadcast_compat_data..zxoperand to apply_ufunc has required core dimensions {}, but some of these dimensions are absent on an input variable: {}csg|]}|kr|qSr1r1r) set_new_dimsr1r2r8ksz9operand to apply_ufunc encountered unexpected dimensions zS on an input variable: these are core dimensions on other input or output variablesc3s|]}|kr|VqdSrAr1rrr1r2rFtsz(broadcast_compat_data..c3s|]}|VqdSrA)indexr)old_dimsr1r2rFws) datarJrr-r_rbrCr transposer SLICE_NONEnpZnewaxis) rrrprZnew_dimsZmissing_core_dimsZunexpected_dimsZold_broadcast_dimsZreordered_dimsorder key_partsrKr1)rrrr2broadcast_compat_dataRsD     r cCs0|jrtj||||d}ntj||d}|S)N)otypesr)r )rPr vectorizerx)rr output_dtypesrtr1r1r2 _vectorizesr forbiddenF)rtdaskr r rdask_gufunc_kwargszVariable | tuple[Variable, ...]c sbddlmm} tdd|Dd} tfdd| DfddjD} fd dt|jD} td d| Dr|d krt d q$|d kr|dkrin  dd} | dkrJt t| jD]b\}\}}t |rt |t| dD]:\}}t|j|dkrt d|d|d|dqqdd<di}|ri}|D]4\}}|jkrt d|d||j|<qh|d<jD],}|jkr||krt d|dqfdd}n|dkrnt d|nr$t|d}|| }jdkr@|f}n.t|tr\t|jkrnt d j|t|}td!d|D|d"}g}t| |D]\}}| |}|jt|krt d#|jd$t|d%|||dd&}|jD]8\}}|| kr|| |krt d'|| ||q||_||qjdkrV|dSt|SdS)(zDApply a ndarray level function over Variable and/or ndarray objects.r)r"as_compatible_datacss|]}t|dr|VqdS)rJN)rrDr1r1r2rFs z'apply_variable_ufunc..)rtc3s|]}|jkr|VqdSrA)rPrmrr1r2rFs csg|] }|qSr1r1)r6rrr1r2r8sz(apply_variable_ufunc..cs*g|]"\}}t|r"t||n|qSr1)r,r )r6r0rp)r"rr1r2r8scss|]}t|VqdSrAr)r6arrayr1r1r2rFsrapply_ufunc encountered a dask array on an argument, but handling for dask arrays has not been enabled. Either set the ``dask`` argument or load your data into memory first with ``.load()`` or ``.compute()`` parallelizedN allow_rechunk)startrz dimension  on zth function argument to apply_ufunc with dask='parallelized' consists of multiple chunks, but is also a core dimension. To fix, either rechunk into a single dask array chunk along this dimension, i.e., ``.chunk(dict(z=-1))``, or pass ``allow_rechunk=True`` in ``dask_gufunc_kwargs`` but beware that this may significantly increase memory usage.T output_sizesz dimension 'z7' in 'output_sizes' must correspond to output_core_dimszI' in 'output_core_dims' needs corresponding (dim, size) in 'output_sizes'cs4ddlm}|jf|d}|S)Nr)r r ) dask.arrayrZ apply_gufuncrx)arraysrres)rrt numpy_funcr rr r1r2rs  z"apply_variable_ufunc..funcallowedz:unknown setting for dask array handling in apply_ufunc: {})r rtzapplied function does not have the number of outputs specified in the ufunc signature. Result is not a tuple of {} elements: {!r}cSsg|] }|jqSr1rrr1r1r2r8srzNapplied function returned data with unexpected number of dimensions. Received z dimension(s) but expected z dimensions with names: )rzsize of dimension {!r} on inputs was unexpectedly changed by applied function from {} to {}. Only dimensions specified in ``exclude_dims`` with xarray.apply_ufunc are allowed to change size.)rr"rrrCr<rr;rr-rrrTrrWchunkspoprrOrVrNr_rrYr,r9rndimsizesrr)rrrtrr r rrr.rrrZ input_datarrRrrpaxisrKrZoutput_sizes_renamedrrZ result_datarrrrJrZnew_sizer1)r"rrrtrr rr r2apply_variable_ufuncs                      r%)rcGsVtdd|DrN|dkr$tdn*|dkr6tdn|dkr@ntd|||S) z4Apply a ndarray level function over ndarray objects.css|]}t|VqdSrArr5r1r1r2rF9sz$apply_array_ufunc..rrrz\cannot use dask='parallelized' for apply_ufunc unless at least one input is an xarray objectrz)unknown setting for dask array handling: )rr-)rrr.r1r1r2apply_array_ufunc7sr&r@)r;r<rtr rgrdataset_fill_valuerkwargsrr rmetarrzSequence[Sequence] | Noneboolzbool | str | NonezMapping | NonezSequence | NonezMapping[Any, int] | Nonezdict[str, Any] | None)rr.r;r<rtr rgrr'rr(rr rr)rrcsxddlmddlmddlm|dkr:dt|}n4t|t|krntdt|d|d t|d | dkrzi} t||}|rt |t st d t |j d ||jkstd ||jd| dkr4|dkri}n|}| dk rtjdtdd|d| | dk r4tjdtdd|d| | rHtj|f| }|dkr\tdd}t |trv|rrdnd}tjt||||| || |d }tfdd|Drtjt||||||||| || |d }t|f|Stdd|Drt|f|||||||dStfd d|Dr@t|f|||||d!Stfd"d|Dr`||St|f|d#| iSdS)$aD+Apply a vectorized function for unlabeled arrays on xarray objects. The function will be mapped over the data variable(s) of the input arguments using xarray's standard rules for labeled computation, including alignment, broadcasting, looping over GroupBy/Dataset variables, and merging of coordinates. Parameters ---------- func : callable Function to call like ``func(*args, **kwargs)`` on unlabeled arrays (``.data``) that returns an array or tuple of arrays. If multiple arguments with non-matching dimensions are supplied, this function is expected to vectorize (broadcast) over axes of positional arguments in the style of NumPy universal functions [1]_ (if this is not the case, set ``vectorize=True``). If this function returns multiple outputs, you must set ``output_core_dims`` as well. *args : Dataset, DataArray, DataArrayGroupBy, DatasetGroupBy, Variable, numpy.ndarray, dask.array.Array or scalar Mix of labeled and/or unlabeled arrays to which to apply the function. input_core_dims : sequence of sequence, optional List of the same length as ``args`` giving the list of core dimensions on each input argument that should not be broadcast. By default, we assume there are no core dimensions on any input arguments. For example, ``input_core_dims=[[], ['time']]`` indicates that all dimensions on the first argument and all dimensions other than 'time' on the second argument should be broadcast. Core dimensions are automatically moved to the last axes of input variables before applying ``func``, which facilitates using NumPy style generalized ufuncs [2]_. output_core_dims : list of tuple, optional List of the same length as the number of output arguments from ``func``, giving the list of core dimensions on each output that were not broadcast on the inputs. By default, we assume that ``func`` outputs exactly one array, with axes corresponding to each broadcast dimension. Core dimensions are assumed to appear as the last dimensions of each output in the provided order. exclude_dims : set, optional Core dimensions on the inputs to exclude from alignment and broadcasting entirely. Any input coordinates along these dimensions will be dropped. Each excluded dimension must also appear in ``input_core_dims`` for at least one argument. Only dimensions listed here are allowed to change size between input and output objects. vectorize : bool, optional If True, then assume ``func`` only takes arrays defined over core dimensions as input and vectorize it automatically with :py:func:`numpy.vectorize`. This option exists for convenience, but is almost always slower than supplying a pre-vectorized function. Using this option requires NumPy version 1.12 or newer. join : {"outer", "inner", "left", "right", "exact"}, default: "exact" Method for joining the indexes of the passed objects along each dimension, and the variables of Dataset objects with mismatched data variables: - 'outer': use the union of object indexes - 'inner': use the intersection of object indexes - 'left': use indexes from the first object with each dimension - 'right': use indexes from the last object with each dimension - 'exact': raise `ValueError` instead of aligning when indexes to be aligned are not equal dataset_join : {"outer", "inner", "left", "right", "exact"}, default: "exact" Method for joining variables of Dataset objects with mismatched data variables. - 'outer': take variables from both Dataset objects - 'inner': take only overlapped variables - 'left': take only variables from the first object - 'right': take only variables from the last object - 'exact': data variables on all Dataset objects must match exactly dataset_fill_value : optional Value used in place of missing variables on Dataset inputs when the datasets do not share the exact same ``data_vars``. Required if ``dataset_join not in {'inner', 'exact'}``, otherwise ignored. keep_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", "override"} or bool, optional - 'drop' or False: empty attrs on returned xarray object. - 'identical': all attrs must be the same on every object. - 'no_conflicts': attrs from all objects are combined, any that have the same name must also have the same value. - 'drop_conflicts': attrs from all objects are combined, any that have the same name but different values are dropped. - 'override' or True: skip comparing and copy attrs from the first object to the result. kwargs : dict, optional Optional keyword arguments passed directly on to call ``func``. dask : {"forbidden", "allowed", "parallelized"}, default: "forbidden" How to handle applying to objects containing lazy data in the form of dask arrays: - 'forbidden' (default): raise an error if a dask array is encountered. - 'allowed': pass dask arrays directly on to ``func``. Prefer this option if ``func`` natively supports dask arrays. - 'parallelized': automatically parallelize ``func`` if any of the inputs are a dask array by using :py:func:`dask.array.apply_gufunc`. Multiple output arguments are supported. Only use this option if ``func`` does not natively support dask arrays (e.g. converts them to numpy arrays). dask_gufunc_kwargs : dict, optional Optional keyword arguments passed to :py:func:`dask.array.apply_gufunc` if dask='parallelized'. Possible keywords are ``output_sizes``, ``allow_rechunk`` and ``meta``. output_dtypes : list of dtype, optional Optional list of output dtypes. Only used if ``dask='parallelized'`` or ``vectorize=True``. output_sizes : dict, optional Optional mapping from dimension names to sizes for outputs. Only used if dask='parallelized' and new dimensions (not found on inputs) appear on outputs. ``output_sizes`` should be given in the ``dask_gufunc_kwargs`` parameter. It will be removed as direct parameter in a future version. meta : optional Size-0 object representing the type of array wrapped by dask array. Passed on to :py:func:`dask.array.apply_gufunc`. ``meta`` should be given in the ``dask_gufunc_kwargs`` parameter . It will be removed as direct parameter a future version. Returns ------- Single value or tuple of Dataset, DataArray, Variable, dask.array.Array or numpy.ndarray, the first type on that list to appear on an input. Notes ----- This function is designed for the more common case where ``func`` can work on numpy arrays. If ``func`` needs to manipulate a whole xarray object subset to each block it is possible to use :py:func:`xarray.map_blocks`. Note that due to the overhead :py:func:`xarray.map_blocks` is considerably slower than ``apply_ufunc``. Examples -------- Calculate the vector magnitude of two arguments: >>> def magnitude(a, b): ... func = lambda x, y: np.sqrt(x**2 + y**2) ... return xr.apply_ufunc(func, a, b) ... You can now apply ``magnitude()`` to :py:class:`DataArray` and :py:class:`Dataset` objects, with automatically preserved dimensions and coordinates, e.g., >>> array = xr.DataArray([1, 2, 3], coords=[("x", [0.1, 0.2, 0.3])]) >>> magnitude(array, -array) array([1.41421356, 2.82842712, 4.24264069]) Coordinates: * x (x) float64 0.1 0.2 0.3 Plain scalars, numpy arrays and a mix of these with xarray objects is also supported: >>> magnitude(3, 4) 5.0 >>> magnitude(3, np.array([0, 4])) array([3., 5.]) >>> magnitude(array, 0) array([1., 2., 3.]) Coordinates: * x (x) float64 0.1 0.2 0.3 Other examples of how you could use ``apply_ufunc`` to write functions to (very nearly) replicate existing xarray functionality: Compute the mean (``.mean``) over one dimension: >>> def mean(obj, dim): ... # note: apply always moves core dimensions to the end ... return apply_ufunc( ... np.mean, obj, input_core_dims=[[dim]], kwargs={"axis": -1} ... ) ... Inner product over a specific dimension (like :py:func:`dot`): >>> def _inner(x, y): ... result = np.matmul(x[..., np.newaxis, :], y[..., :, np.newaxis]) ... return result[..., 0, 0] ... >>> def inner_product(a, b, dim): ... return apply_ufunc(_inner, a, b, input_core_dims=[[dim], [dim]]) ... Stack objects along a new dimension (like :py:func:`concat`): >>> def stack(objects, dim, new_coord): ... # note: this version does not stack coordinates ... func = lambda *x: np.stack(x, axis=-1) ... result = apply_ufunc( ... func, ... *objects, ... output_core_dims=[[dim]], ... join="outer", ... dataset_fill_value=np.nan ... ) ... result[dim] = new_coord ... return result ... If your function is not vectorized but can be applied only to core dimensions, you can use ``vectorize=True`` to turn into a vectorized function. This wraps :py:func:`numpy.vectorize`, so the operation isn't terribly fast. Here we'll use it to calculate the distance between empirical samples from two probability distributions, using a scipy function that needs to be applied to vectors: >>> import scipy.stats >>> def earth_mover_distance(first_samples, second_samples, dim="ensemble"): ... return apply_ufunc( ... scipy.stats.wasserstein_distance, ... first_samples, ... second_samples, ... input_core_dims=[[dim], [dim]], ... vectorize=True, ... ) ... Most of NumPy's builtin functions already broadcast their inputs appropriately for use in ``apply_ufunc``. You may find helper functions such as :py:func:`numpy.broadcast_arrays` helpful in writing your function. ``apply_ufunc`` also works well with :py:func:`numba.vectorize` and :py:func:`numba.guvectorize`. See Also -------- numpy.broadcast_arrays numba.vectorize numba.guvectorize dask.array.apply_gufunc xarray.map_blocks :ref:`dask.automatic-parallelization` User guide describing :py:func:`apply_ufunc` and :py:func:`map_blocks`. References ---------- .. [1] https://numpy.org/doc/stable/reference/ufuncs.html .. [2] https://numpy.org/doc/stable/reference/c-api/generalized-ufuncs.html rr$rr!Nr@z_input_core_dims must be None or a tuple with the length same to the number of arguments. Given z input_core_dims: z, but number of args is .z/Expected exclude_dims to be a 'set'. Received 'z ' instead.zfeach dimension in `exclude_dims` must also be a core dimension in the function signature. Please make z a core dimensionrz}``meta`` should be given in the ``dask_gufunc_kwargs`` parameter. It will be removed as direct parameter in a future version.) stacklevelr)z``output_sizes`` should be given in the ``dask_gufunc_kwargs`` parameter. It will be removed as direct parameter in a future version.rFdefaultrr)rrtrrr r rc3s|]}t|VqdSrAr4rDrr1r2rFszapply_ufunc..) r;r<rtrgrr'rrr r rcss|]}t|VqdSrA)rrDr1r1r2rFs)rrgrtrrrc3s|]}t|VqdSrAr4rDr$r1r2rFs)rrgrtrc3s|]}t|VqdSrAr4rDr!r1r2rFsr)rr%rrrr"rWr-r:r,rrr`rarPrwarningswarn FutureWarning setdefault functoolspartialrr*r%r apply_ufuncrrrr&)rr;r<rtr rgrr'rr(rr rr)rr.rZvariables_vfuncZ this_applyr1)r%rr"r2r6Ns~                 r6rcsTddlmtfdd||fDrBtddd||fDt||||dd S) aK Compute covariance between two DataArray objects along a shared dimension. Parameters ---------- da_a : DataArray Array to compute. da_b : DataArray Array to compute. dim : str, optional The dimension along which the covariance will be computed ddof : int, optional If ddof=1, covariance is normalized by N-1, giving an unbiased estimate, else normalization is by N. Returns ------- covariance : DataArray See Also -------- pandas.Series.cov : corresponding pandas function xarray.corr : respective function to calculate correlation Examples -------- >>> from xarray import DataArray >>> da_a = DataArray( ... np.array([[1, 2, 3], [0.1, 0.2, 0.3], [3.2, 0.6, 1.8]]), ... dims=("space", "time"), ... coords=[ ... ("space", ["IA", "IL", "IN"]), ... ("time", pd.date_range("2000-01-01", freq="1D", periods=3)), ... ], ... ) >>> da_a array([[1. , 2. , 3. ], [0.1, 0.2, 0.3], [3.2, 0.6, 1.8]]) Coordinates: * space (space) >> da_b = DataArray( ... np.array([[0.2, 0.4, 0.6], [15, 10, 5], [3.2, 0.6, 1.8]]), ... dims=("space", "time"), ... coords=[ ... ("space", ["IA", "IL", "IN"]), ... ("time", pd.date_range("2000-01-01", freq="1D", periods=3)), ... ], ... ) >>> da_b array([[ 0.2, 0.4, 0.6], [15. , 10. , 5. ], [ 3.2, 0.6, 1.8]]) Coordinates: * space (space) >> xr.cov(da_a, da_b) array(-3.53055556) >>> xr.cov(da_a, da_b, dim="time") array([ 0.2 , -0.5 , 1.69333333]) Coordinates: * space (space) .(Only xr.DataArray is supported.Given {}.cSsg|] }t|qSr1r`r7r1r1r2r8szcov..cov)rKddofmethodrr%rrr_ _cov_corr)da_ada_brKr<r1r$r2r;sE r;csRddlmtfdd||fDrBtddd||fDt|||dd S) a Compute the Pearson correlation coefficient between two DataArray objects along a shared dimension. Parameters ---------- da_a : DataArray Array to compute. da_b : DataArray Array to compute. dim : str, optional The dimension along which the correlation will be computed Returns ------- correlation: DataArray See Also -------- pandas.Series.corr : corresponding pandas function xarray.cov : underlying covariance function Examples -------- >>> from xarray import DataArray >>> da_a = DataArray( ... np.array([[1, 2, 3], [0.1, 0.2, 0.3], [3.2, 0.6, 1.8]]), ... dims=("space", "time"), ... coords=[ ... ("space", ["IA", "IL", "IN"]), ... ("time", pd.date_range("2000-01-01", freq="1D", periods=3)), ... ], ... ) >>> da_a array([[1. , 2. , 3. ], [0.1, 0.2, 0.3], [3.2, 0.6, 1.8]]) Coordinates: * space (space) >> da_b = DataArray( ... np.array([[0.2, 0.4, 0.6], [15, 10, 5], [3.2, 0.6, 1.8]]), ... dims=("space", "time"), ... coords=[ ... ("space", ["IA", "IL", "IN"]), ... ("time", pd.date_range("2000-01-01", freq="1D", periods=3)), ... ], ... ) >>> da_b array([[ 0.2, 0.4, 0.6], [15. , 10. , 5. ], [ 3.2, 0.6, 1.8]]) Coordinates: * space (space) >> xr.corr(da_a, da_b) array(-0.57087777) >>> xr.corr(da_a, da_b, dim="time") array([ 1., -1., 1.]) Coordinates: * space (space) .r9cSsg|] }t|qSr1r:r7r1r1r2r8`szcorr..corr)rKr=r>)r@rArKr1r$r2rBsC rBr)r@rArc Cst||ddd\}}||@}||}||}|||}||j|d}||j|d}||j|ddd|} |dkr| S|j|d} |j|d} | | | } | Sd S) z Internal method for xr.cov() and xr.corr() so only have to sanitize the input arrays once and we don't repeat code. r*F)rgrrQTr)rKskipnaZ min_countr;N)rZnotnullwheresumZmeanZstd) r@rArKr<r=Z valid_valuesZ valid_countZ demeaned_da_aZ demeaned_da_br;Zda_a_stdZda_b_stdrBr1r1r2r?fs      r?zDataArray | Variabler)rEbrKrc CsB||jkrtd|dn||jkr6td|dd|j|krPdksnntd|d|j|n6d|j|krdksntd|d|j|tt|j|j}|j||j|krt|ts.|t|d ikr.t|ts.|t|d ikr.t ||d d t ||hd \}}nt |j||j|d kr|j||j|kr|j |did d}t |jr||din|}n0|j |did d}t |jr||din|}n(t|d|j|dkrdnddttj|||g|gg|j|dkr|gnggdt||gd}|j|ddi}|S)a Compute the cross product of two (arrays of) vectors. The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular to both `a` and `b`. The vectors in `a` and `b` are defined by the values along the dimension `dim` and can have sizes 1, 2 or 3. Where the size of either `a` or `b` is 1 or 2, the remaining components of the input vector is assumed to be zero and the cross product calculated accordingly. In cases where both input vectors have dimension 2, the z-component of the cross product is returned. Parameters ---------- a, b : DataArray or Variable Components of the first and second vector(s). dim : hashable The dimension along which the cross product will be computed. Must be available in both vectors. Examples -------- Vector cross-product with 3 dimensions: >>> a = xr.DataArray([1, 2, 3]) >>> b = xr.DataArray([4, 5, 6]) >>> xr.cross(a, b, dim="dim_0") array([-3, 6, -3]) Dimensions without coordinates: dim_0 Vector cross-product with 2 dimensions, returns in the perpendicular direction: >>> a = xr.DataArray([1, 2]) >>> b = xr.DataArray([4, 5]) >>> xr.cross(a, b, dim="dim_0") array(-3) Vector cross-product with 3 dimensions but zeros at the last axis yields the same results as with 2 dimensions: >>> a = xr.DataArray([1, 2, 0]) >>> b = xr.DataArray([4, 5, 0]) >>> xr.cross(a, b, dim="dim_0") array([ 0, 0, -3]) Dimensions without coordinates: dim_0 One vector with dimension 2: >>> a = xr.DataArray( ... [1, 2], ... dims=["cartesian"], ... coords=dict(cartesian=(["cartesian"], ["x", "y"])), ... ) >>> b = xr.DataArray( ... [4, 5, 6], ... dims=["cartesian"], ... coords=dict(cartesian=(["cartesian"], ["x", "y", "z"])), ... ) >>> xr.cross(a, b, dim="cartesian") array([12, -6, -3]) Coordinates: * cartesian (cartesian) >> a = xr.DataArray( ... [1, 2], ... dims=["cartesian"], ... coords=dict(cartesian=(["cartesian"], ["x", "z"])), ... ) >>> b = xr.DataArray( ... [4, 5, 6], ... dims=["cartesian"], ... coords=dict(cartesian=(["cartesian"], ["x", "y", "z"])), ... ) >>> xr.cross(a, b, dim="cartesian") array([-10, 2, 5]) Coordinates: * cartesian (cartesian) >> a = xr.DataArray( ... [[1, 2, 3], [4, 5, 6]], ... dims=("time", "cartesian"), ... coords=dict( ... time=(["time"], [0, 1]), ... cartesian=(["cartesian"], ["x", "y", "z"]), ... ), ... ) >>> b = xr.DataArray( ... [[4, 5, 6], [1, 2, 3]], ... dims=("time", "cartesian"), ... coords=dict( ... time=(["time"], [0, 1]), ... cartesian=(["cartesian"], ["x", "y", "z"]), ... ), ... ) >>> xr.cross(a, b, dim="cartesian") array([[-3, 6, -3], [ 3, -6, 3]]) Coordinates: * time (time) int64 0 1 * cartesian (cartesian) >> ds_a = xr.Dataset(dict(x=("dim_0", [1]), y=("dim_0", [2]), z=("dim_0", [3]))) >>> ds_b = xr.Dataset(dict(x=("dim_0", [4]), y=("dim_0", [5]), z=("dim_0", [6]))) >>> c = xr.cross( ... ds_a.to_array("cartesian"), ds_b.to_array("cartesian"), dim="cartesian" ... ) >>> c.to_dataset(dim="cartesian") Dimensions: (dim_0: 1) Dimensions without coordinates: dim_0 Data variables: x (dim_0) int64 -3 y (dim_0) int64 6 z (dim_0) int64 -3 See Also -------- numpy.cross : Corresponding numpy function Dimension z not on az not on brz The size of zF on a must be 1, 2, or 3 to be compatible with a cross product but is zF on b must be 1, 2, or 3 to be compatible with a cross product but is rrr)rrgrr,)rr)Zconstant_valuesrrrErFzR is incompatible: dimensions without coordinates must have have a length of 2 or 3r)r;r<rr  missing_dimsignore)rJr-r#rbrfromkeysr,r"rrrminpadrrchunkr6rcrossZ result_typer)rErFrKall_dimscr1r1r2rOsd     "   rOrJz*str | Iterable[Hashable] | ellipsis | None)rJr(c sddlmddlmtfdd|DrHtddd|Dt|dkr\td tj d d|D}g|D]}fd d|j D7qxd fd dt D|dkr}nNt |t r|f}n<|dkr t}|D]}||j qtdd|D}t||fdd|D}fddDg}fdd|D}d|} | ddfdd|dD7} td} | dkrd} tjtj| f|} t| f|||| dd} | jddiS) a3Generalized dot product for xarray objects. Like np.einsum, but provides a simpler interface based on array dimensions. Parameters ---------- *arrays : DataArray or Variable Arrays to compute. dims : ..., str or tuple of str, optional Which dimensions to sum over. Ellipsis ('...') sums over all dimensions. If not specified, then all the common dimensions are summed over. **kwargs : dict Additional keyword arguments passed to numpy.einsum or dask.array.einsum Returns ------- DataArray Examples -------- >>> da_a = xr.DataArray(np.arange(3 * 2).reshape(3, 2), dims=["a", "b"]) >>> da_b = xr.DataArray(np.arange(3 * 2 * 2).reshape(3, 2, 2), dims=["a", "b", "c"]) >>> da_c = xr.DataArray(np.arange(2 * 3).reshape(2, 3), dims=["c", "d"]) >>> da_a array([[0, 1], [2, 3], [4, 5]]) Dimensions without coordinates: a, b >>> da_b array([[[ 0, 1], [ 2, 3]], [[ 4, 5], [ 6, 7]], [[ 8, 9], [10, 11]]]) Dimensions without coordinates: a, b, c >>> da_c array([[0, 1, 2], [3, 4, 5]]) Dimensions without coordinates: c, d >>> xr.dot(da_a, da_b, dims=["a", "b"]) array([110, 125]) Dimensions without coordinates: c >>> xr.dot(da_a, da_b, dims=["a"]) array([[40, 46], [70, 79]]) Dimensions without coordinates: b, c >>> xr.dot(da_a, da_b, da_c, dims=["b", "c"]) array([[ 9, 14, 19], [ 93, 150, 207], [273, 446, 619]]) Dimensions without coordinates: a, d >>> xr.dot(da_a, da_b) array([110, 125]) Dimensions without coordinates: c >>> xr.dot(da_a, da_b, dims=...) array(235) rr$r!c3s|]}t|f VqdSrAr4r7)r%r"r1r2rFszdot..z9Only xr.DataArray and xr.Variable are supported.Given {}.cSsg|] }t|qSr1r:r7r1r1r2r8szdot..z#At least one array should be given.css|]}t|jVqdSrA)rrJr7r1r1r2rFscsg|]}|kr|qSr1r1r)rPr1r2r8sabcdefghijklmnopqrstuvwxyzcsi|]\}}||qSr1r1)r6ir) einsum_axesr1r2rSszdot...Ncss|]\}}|dkr|VqdS)rNr1)r6rrQr1r1r2rFscs g|]}fdd|jDqS)csg|]}|kr|qSr1r1rrr1r2r8sz"dot...rRr7rr1r2r8scs g|]}|kr|kr|qSr1r1r)rdot_dimsr1r2r8scs(g|] }ddfdd|DqS)z...c3s|]}|VqdSrAr1rdim_mapr1r2rFsz!dot...)rg)r6rrXr1r2r8srdz->...rWc3s|]}|VqdSrAr1rrXr1r2rFsZarithmetic_joinr+r*r)r;r<rgrrIrJ)rr%rr"rrr_rWrrrJrTr,rwrrrrCrrgrr4r5rZeinsumr6r) rJrr(Z common_dimsr8Z dim_countsr;r<Zsubscripts_listZ subscriptsrgrresultr1)r%r"rPrrYrVrUr2dot]shQ         $ r[c Csddlm}|dkrtdd}ttj|||ddd|d}|d krt|d rt||rt||si|_t |d d|j krt |d i||j _n:t |d i|_t |d gD]}t t ||dd i||_qt |d gD]}t t ||dd i||_q|S)a Return elements from `x` or `y` depending on `cond`. Performs xarray-like broadcasting across input arguments. All dimension coordinates on `x` and `y` must be aligned with each other and with `cond`. Parameters ---------- cond : scalar, array, Variable, DataArray or Dataset When True, return values from `x`, otherwise returns values from `y`. x : scalar, array, Variable, DataArray or Dataset values to choose from where `cond` is True y : scalar, array, Variable, DataArray or Dataset values to choose from where `cond` is False keep_attrs : bool or str or callable, optional How to treat attrs. If True, keep the attrs of `x`. Returns ------- Dataset, DataArray, Variable or array In priority order: Dataset, DataArray, Variable or array, whichever type appears as an input argument. Examples -------- >>> x = xr.DataArray( ... 0.1 * np.arange(10), ... dims=["lat"], ... coords={"lat": np.arange(10)}, ... name="sst", ... ) >>> x array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) Coordinates: * lat (lat) int64 0 1 2 3 4 5 6 7 8 9 >>> xr.where(x < 0.5, x, x * 100) array([ 0. , 0.1, 0.2, 0.3, 0.4, 50. , 60. , 70. , 80. , 90. ]) Coordinates: * lat (lat) int64 0 1 2 3 4 5 6 7 8 9 >>> y = xr.DataArray( ... 0.1 * np.arange(9).reshape(3, 3), ... dims=["lat", "lon"], ... coords={"lat": np.arange(3), "lon": 10 + np.arange(3)}, ... name="sst", ... ) >>> y array([[0. , 0.1, 0.2], [0.3, 0.4, 0.5], [0.6, 0.7, 0.8]]) Coordinates: * lat (lat) int64 0 1 2 * lon (lon) int64 10 11 12 >>> xr.where(y.lat < 1, y, -1) array([[ 0. , 0.1, 0.2], [-1. , -1. , -1. ], [-1. , -1. , -1. ]]) Coordinates: * lat (lat) int64 0 1 2 * lon (lon) int64 10 11 12 >>> cond = xr.DataArray([True, False], dims=["x"]) >>> x = xr.DataArray([1, 2], dims=["y"]) >>> xr.where(cond, x, 0) array([[1, 2], [0, 0]]) Dimensions without coordinates: x, y See Also -------- numpy.where : corresponding numpy function Dataset.where, DataArray.where : equivalent methods rr&NFr.r+r)rgrrrTrrrr) rr'rr6rrDrr,rrrr)Zcondryrr'rZrrQr1r1r2rDs0S  rDdegreer%)coordcoeffs degree_dimrcCsdSrAr1r^r_r`r1r1r2polyvalmsrbcCsdSrAr1rar1r1r2rbtscCsdSrAr1rar1r1r2rb{scCsdSrAr1rar1r1r2rbszDataset | DataArraycCsdSrAr1rar1r1r2rbscCs||jkrtd|dt||jtsHtd|d||jd||}|j|t |diddd}t |}t ||j ||id d }t |dd d D]"}||9}||j ||id d 7}q|S) aEvaluate a polynomial at specific values Parameters ---------- coord : DataArray or Dataset Values at which to evaluate the polynomial. coeffs : DataArray or Dataset Coefficients of the polynomial. degree_dim : Hashable, default: "degree" Name of the polynomial degree dimension in `coeffs`. Returns ------- DataArray or Dataset Evaluated polynomial. See Also -------- xarray.DataArray.polyfit numpy.polynomial.polynomial.polyval z Dimension `z.` should be a coordinate variable with labels.z'` should be of integer dtype. Received z instead.rrF)rrT)rr)Z_indexesr-rZ issubdtypedtypermaxitemZreindexZarange_ensure_numericrZiselr)r^r_r`Zmax_degrdegr1r1r2rbs(  )rrcsPddlm}ddddddddfdd }t||rD||S||Sd S) aConverts all datetime64 variables to float64 Parameters ---------- data : DataArray or Dataset Variables with possible datetime dtypes. Returns ------- DataArray or Dataset Variables with datetime64 dtypes converted to float64. rr&r%r)rrcSs.|jd}t|s|}t|dddS)Nrir)Zcomputerr rer`)rZscalarr1r1r2 _cfoffsetsz"_ensure_numeric.._cfoffsetcs\|jjdkrB|jjdkr"tdn|}|jt|j|dddS|jjdkrX|tS|S)NZMOMz 1970-01-01ns)offsetZ datetime_unitrm) rcr/rZ datetime64rrrZastypefloat)rrkrhr1r2 to_floatables   z%_ensure_numeric..to_floatableN)rr'r,map)rr'rpr1ror2rfs   rf)rKrCrrzHashable | Nonez bool | None)rrKrCrrc Csh|jstd|dk rn|jdkr.|jd}ntd||jkrPtd|d||jkrjtd|dd }|s|dkr|jj|kr||}| |d}|||d||d }t |j rddl } t t|j|j} | jj||j | |d } |j| |j |jd } || _n|||f} | j|=|sN|dkr\|jj|kr\| ||} |j| _| S) z.Apply common operations for idxmin and idxmax.z(This function does not apply for scalarsNrrz6Must supply 'dim' argument for multidimensional arraysz Dimension "z" not in dimensionz" does not have coordinatesZcfO)rKr$rrC)r rl)r"r-rJrrrcr/ZisnullallrDrrrrrr rZ from_arrayrZravelZreshaperrr) rrrKrCrrZ na_dtypesZallnaZindxrr Z dask_coordrr1r1r2_calc_idxminmaxs8      rs_T)r'r%)bound_U_Vz tuple[_T])__objrcCsdSrAr1)rxr1r1r2 unify_chunks3sryz tuple[_T, _U])__obj1__obj2rcCsdSrAr1)rzr{r1r1r2ry8sztuple[_T, _U, _V])rzr{__obj3rcCsdSrAr1)rzr{r|r1r1r2ry=sztuple[Dataset | DataArray, ...]cGsdSrAr1)r~r1r1r2ryBsc sZddlmfdd|D}g}i}|D]}|jD]~}|jdk r8|jD]T\}}z.|||krtd|d||d|WqPtk r|||<YqPXqP||j |j g7}q8q*|s|Sdd l m }||\} } t | } g} t||D]`\} }|jD],\}}|jdk r|jt| d |j|<q| t| rJ| |n|qt| S) uv Given any number of Dataset and/or DataArray objects, returns new objects with unified chunk size along all chunked dimensions. Returns ------- unified (DataArray or Dataset) – Tuple of objects with the same type as *objects with consistent chunk sizes for all dask-array variables See Also -------- dask.array.core.unify_chunks rr$cs&g|]}t|r|n|qSr1)r,Z_to_temp_datasetrrr$r1r2r8Xsz unify_chunks..NrGz size mismatch: r)ryrl)rr%Z _variablesrr r#rr-r_dataZ_dimsZdask.array.coreryiterrrnextrr,Z_from_temp_datasetrC)r~ZdatasetsZunify_chunks_argsr#rrrKrryrqZ dask_dataZdask_data_iterrrrr1r$r2ryGs<       ")r*)N)Nr)N)NrN)N)r])r])r])r])r])r])mr{ __future__rr4roperatorr0 collectionsrtypingrrrrrr r r r r rZnumpyrZ xarray.corerrrZxarray.core.alignmentrrZxarray.core.commonrZxarray.core.duck_array_opsrZxarray.core.indexesrrZxarray.core.mergerrZxarray.core.optionsrrZxarray.core.pycompatrZxarray.core.typesrZxarray.core.utilsrr rr"Zxarray.core.coordinatesr#rr%rr'r(r)Z ReprObjectrrrLrr3r9r:rrrrrrr itemgetterr__annotations__rrrrrrrrrrslicerr rr%r&r6r;rBr?rOr[rDrbrfZNArsrtrvrwryr1r1r1r2s  4            K;     ;/6#2| P O'S z 3.?