ri,dZddlmZddlmZddlmZddlmZddl m Z m Z m Z m Z mZmZmZddl mZdd lmZdd lmZmZgd Zd d ddddeezdeezdededededzdefdZddddeezezdeezdedzdefdZddddd eded!edzd"ededzdef d#Z d*ddd%ded&ee eefzee eefzd'ed$d(ededzdef d)Z!y)+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@| t||n|}t|s!t|st|s t |r|j |||||St |r't|||\}}|j |||||Stj ||||||S)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 k/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/sklearn/externals/array_api_extra/_delegation.pyrrsV#%*A "B 2 R R B zz!QT zJJ"1$1zz!QT zJJ >>!QT b QQg fill_valuerxr%c*t|tr d}t|| t|n|}|j |}t |s!t |st|s t|r|j||Stj|||S)as 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 !}}QJ}//   Q:" ==r#)dtypeaxisr num_classesr0r1c| t|}|j|jds d}t|| t j |t |}t|rddlm }|||||St|r-ddl m }|j||j} |||}nt j|||}|j||d }|d k7r|j!|d |}|S#t$r } t| d} ~ wwxYw) au 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 >11kTBB"@ IIa " $;/CnnQ 3 ))CU) +C rzkk#r4( J $! # $s$ C44 D =DD constantconstant_valuesr pad_widthmoderFc| t|n|}|dk7r d}t|t|s!t|st |s t |r|j ||||St|r|j|}|j||jdf}|j|dj}|jjj |t||St!j ||||S) a 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 )vvaD/vJJ"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#