.jN-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!dS)+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|st |r||||||St |r/t|||\}}||||||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. N)rrrrr) rr r r r rrrr)rrrrrrs [C:\Projects\DSCons\.venv\Lib\site-packages\sklearn\externals\array_api_extra\_delegation.pyrrsV#%*A   "B 2K R K R K B   K zz!QT zJJJ"K1$$$1zz!QT zJJJ >!QT b Q Q QQg fill_valuerxr%crt|trd}t||t|n|}||}t |s-t |st|st|r| ||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.N)nanr$) isinstancecomplex TypeErrorrasarrayr r r rrr)r&r%rmsgys r"rrtsv*g&&6nn!z   rB 1 A "0 B  0 b ! !0 b ! ! 0 }}QJ}///  Q:" = = ==r#)dtypeaxisr num_classesr0r1cZ|t|}||jdsd}t||#t j|t |}t|rddlm }|||||St|rIddl m }| ||j } |||}n1#t$r } t| d} ~ wwxYwt j |||}| ||d }|d kr||d |}|S) 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"rrsdb z Q   ::agz * *.nn }$R 1 >>>C111111{1kTBBBB" 4@@@@@@ IIa " " $-;//CC $ $ $! # $nQ 333 ))CU) + +C rzzkk#r4(( Js8 C CCCconstantconstant_valuesr pad_widthmoderFcb|t|n|}|dkrd}t|t|s-t|st |st |r|||||St|r||}| ||j df}| |d }|j j|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``. NrDz-Only `'constant'` mode is currently supported)rF)r)r1)valuerE)rNotImplementedErrorr r r r rrr, broadcast_tondimflipflattennn functionaltupler)r&rGrHrFrr-s r"rrs>F "z   rB z=!#&&& 2K R K B  K &b ) ) K vvaD/vJJJ"PJJy)) OOI{;; GGIDG1199;; u##AuY'7'7#OOO :aO K K KKr#)rD)"__doc__collections.abcrtypesrtypingr_libr_lib._utils._compatrr r r r r rrr8_lib._utils._helpersr_lib._utils._typingrr__all__r*floatboolrintrrrSrr#r"rasFF$$$$$$655555******-------- 5 5 5 YRYRYR wYR wYR  YR  YR  YR TYR YRYRYRYR@" L>L>L> u}wL>e L> T L>  L>L>L>L>h JJJJ J 4< J  J TJ JJJJ`!+8L ! 8L8L8L 8LU38_$xc3h'@@8L * 8L  8L T 8L 8L8L8L8L8L8Lr#