]j,SrSSKJr SSKJr SSKJr SSKJr SSK J r J r J r J r JrJrJr SSK Jr SS KJr SS KJrJr /S QrS S SSS.S\\-S\\-S\S\S\S\S-S\4SjjrSSS.S\\-\-S\\-S\S-S\4SjjrSSSS.S \S\S!\S-S"\S\S-S\4 S#jjrS*SSS%.S\S&\\ \\4-\\ \\4-S'\S$S(\S\S-S\4 S)jjjr!g)+z@Delegation to existing implementations for Public API Functions.)Sequence) ModuleType)Literal)_funcs)array_namespaceis_cupy_namespaceis_dask_namespaceis_jax_namespaceis_numpy_namespaceis_pydata_sparse_namespaceis_torch_namespacedevice)asarrays)ArrayDType)isclose nan_to_numone_hotpadgh㈵>g:0yE>FNrtolatol equal_nanxpabrrrrreturnc JUc [X5OUn[U5(d0[U5(d [U5(d[ U5(aUR XX#US9$[ U5(a[XUS9upUR XX#US9$[R "XX#XES9$)a Return a boolean array where two arrays are element-wise equal within a tolerance. The tolerance values are positive, typically very small numbers. The relative difference ``(rtol * abs(b))`` and the absolute difference `atol` are added together to compare against the absolute difference between `a` and `b`. NaNs are treated as equal if they are in the same place and if ``equal_nan=True``. Infs are treated as equal if they are in the same place and of the same sign in both arrays. Parameters ---------- a, b : Array | int | float | complex | bool Input objects to compare. At least one must be an array. rtol : array_like, optional The relative tolerance parameter (see Notes). atol : array_like, optional The absolute tolerance parameter (see Notes). equal_nan : bool, optional Whether to compare NaN's as equal. If True, NaN's in `a` will be considered equal to NaN's in `b` in the output array. xp : array_namespace, optional The standard-compatible namespace for `a` and `b`. Default: infer. Returns ------- Array A boolean array of shape broadcasted from `a` and `b`, containing ``True`` where `a` is close to `b`, and ``False`` otherwise. Warnings -------- The default `atol` is not appropriate for comparing numbers with magnitudes much smaller than one (see notes). See Also -------- math.isclose : Similar function in stdlib for Python scalars. Notes ----- For finite values, `isclose` uses the following equation to test whether two floating point values are equivalent:: absolute(a - b) <= (atol + rtol * absolute(b)) Unlike the built-in `math.isclose`, the above equation is not symmetric in `a` and `b`, so that ``isclose(a, b)`` might be different from ``isclose(b, a)`` in some rare cases. The default value of `atol` is not appropriate when the reference value `b` has magnitude smaller than one. For example, it is unlikely that ``a = 1e-9`` and ``b = 2e-9`` should be considered "close", yet ``isclose(1e-9, 2e-9)`` is ``True`` with default settings. Be sure to select `atol` for the use case at hand, especially for defining the threshold below which a non-zero value in `a` will be considered "close" to a very small or zero value in `b`. The comparison of `a` and `b` uses standard broadcasting, which means that `a` and `b` need not have the same shape in order for ``isclose(a, b)`` to evaluate to ``True``. `isclose` is not defined for non-numeric data types. ``bool`` is considered a numeric data-type for this purpose. )rrrrr) rr r r r rrrr)rrrrrrs j/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sklearn/externals/array_api_extra/_delegation.pyrrsV#%* "B 2 R R B  zz!T zJJ"$zz!T zJJ >>!T QQg fill_valuerxr%cP[U[5(a Sn[U5eUc [U5OUnUR U5n[ U5(d0[ U5(d [U5(d[U5(aURXAS9$[R"XAUS9$)a Replace NaN with zero and infinity with large finite numbers (default behaviour). If `x` is inexact, NaN is replaced by zero or by the user defined value in the `fill_value` keyword, infinity is replaced by the largest finite floating point value representable by ``x.dtype``, and -infinity is replaced by the most negative finite floating point value representable by ``x.dtype``. For complex dtypes, the above is applied to each of the real and imaginary components of `x` separately. Parameters ---------- x : array | float | complex Input data. fill_value : int | float, optional Value to be used to fill NaN values. If no value is passed then NaN values will be replaced with 0.0. xp : array_namespace, optional The standard-compatible namespace for `x`. Default: infer. Returns ------- array `x`, with the non-finite values replaced. See Also -------- array_api.isnan : Shows which elements are Not a Number (NaN). Examples -------- >>> import array_api_extra as xpx >>> import array_api_strict as xp >>> xpx.nan_to_num(xp.inf) 1.7976931348623157e+308 >>> xpx.nan_to_num(-xp.inf) -1.7976931348623157e+308 >>> xpx.nan_to_num(xp.nan) 0.0 >>> x = xp.asarray([xp.inf, -xp.inf, xp.nan, -128, 128]) >>> xpx.nan_to_num(x) array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary -1.28000000e+002, 1.28000000e+002]) >>> y = xp.asarray([complex(xp.inf, xp.nan), xp.nan, complex(xp.nan, xp.inf)]) array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary -1.28000000e+002, 1.28000000e+002]) >>> xpx.nan_to_num(y) array([ 1.79769313e+308 +0.00000000e+000j, # may vary 0.00000000e+000 +0.00000000e+000j, 0.00000000e+000 +1.79769313e+308j]) z&Complex fill values are not supported.)nanr$) isinstancecomplex TypeErrorrasarrayr r r rrr)r&r%rmsgys r"rrtsv*g&&6n!z rB 1 A " B   b ! ! b ! !}}Q}//   Q" ==r#)dtypeaxisr num_classesr0r1cUc [U5nURURS5(d Sn[U5eUc[R "U[ U5S9n[U5(a SSKJ n U"XX#S9$[U5(a+SSK J n URXR5nU"X5nO[R"XUS9nURXS S 9nUS :waUR!US U5nU$![a n [U eSn A ff=f) a One-hot encode the given indices. Each index in the input `x` is encoded as a vector of zeros of length `num_classes` with the element at the given index set to one. Parameters ---------- x : array An array with integral dtype whose values are between `0` and `num_classes - 1`. num_classes : int Number of classes in the one-hot dimension. dtype : DType, optional The dtype of the return value. Defaults to the default float dtype (usually float64). axis : int, optional Position in the expanded axes where the new axis is placed. Default: -1. xp : array_namespace, optional The standard-compatible namespace for `x`. Default: infer. Returns ------- array An array having the same shape as `x` except for a new axis at the position given by `axis` having size `num_classes`. If `axis` is unspecified, it defaults to -1, which appends a new axis. If ``x < 0`` or ``x >= num_classes``, then the result is undefined, may raise an exception, or may even cause a bad state. `x` is not checked. Examples -------- >>> import array_api_extra as xpx >>> import array_api_strict as xp >>> xpx.one_hot(xp.asarray([1, 2, 0]), 3) Array([[0., 1., 0.], [0., 0., 1.], [1., 0., 0.]], dtype=array_api_strict.float64) Nintegralzx must have an integral dtype.rr)r)r0r1r!F)copyr/)risdtyper0r+r default_dtype get_devicer jax.nnrrtorch.nn.functionalastypeint64 RuntimeError IndexErrormoveaxis) r&r2r0r1rr- jax_one_hot torch_one_hotoutes r"rrsb z Q  ::aggz * *.n }$$R 1 >11BB"@ IIa " $/CnnQ3 ))CU) +C rzkk#r4( J $! # $s-C66 D DD constantconstant_valuesr pad_widthmoderFc&Uc [U5OUnUS:wa Sn[U5e[U5(d0[U5(d [ U5(d[ U5(aUR XX#S9$[U5(azURU5nURXRS45nURUSS9R5nURRR U[U5US9$[ R "XX4S9$) aj Pad the input array. Parameters ---------- x : array Input array. pad_width : int or tuple of ints or sequence of pairs of ints Pad the input array with this many elements from each side. If a sequence of tuples, ``[(before_0, after_0), ... (before_N, after_N)]``, each pair applies to the corresponding axis of ``x``. A single tuple, ``(before, after)``, is equivalent to a list of ``x.ndim`` copies of this tuple. mode : str, optional Only "constant" mode is currently supported, which pads with the value passed to `constant_values`. constant_values : python scalar, optional Use this value to pad the input. Default is zero. xp : array_namespace, optional The standard-compatible namespace for `x`. Default: infer. Returns ------- array The input array, padded with ``pad_width`` elements equal to ``constant_values``. rDz-Only `'constant'` mode is currently supported)rF)r)r1)valuerE)rNotImplementedErrorr r r r rrr, broadcast_tondimflipflattennn functionaltupler)r&rGrHrFrr-s r"rrsF "z rB z=!#&& 2 R B   %b ) )vvaDvJJ"JJy) OOI{; GGIDG199; uu##AuY'7#OO ::aO KKr#)rD)"__doc__collections.abcrtypesrtypingr_libr_lib._utils._compatrr r r r r rrr8_lib._utils._helpersr_lib._utils._typingrr__all__r*floatboolrintrrrSrr#r"rasF$6*- 5 YR wYR wYR  YR  YR  YR TYR YR@" L> u}wL>e L> T L>  L>h JJ J 4< J  J TJ J`!+8L ! 8L 8LU38_$xc3h'@@8L * 8L  8L T 8L 8Lr#