o
    \i                     @   s  d Z ddlmZ ddlmZ ddlmZ ddlmZm	Z	 ddl
mZ ddlmZ dd	lmZ d
dgZdededefddZddddddeeB deeB dededededB defdd
Z	d#ddddedeeeef B eeeef  B d ed d!ededB defd"dZdS )$z@Delegation to existing implementations for Public API Functions.    )Sequence)
ModuleType)Literal   )Backend_funcs)array_namespace)asarrays)Arrayisclosepadxpbackendsreturnc                    s   t  fdd|D S )av  
    Check whether `xp` is one of the `backends` to delegate to.

    Parameters
    ----------
    xp : array_namespace
        Array namespace to check.
    *backends : IsNamespace
        Arbitrarily many backends (from the ``IsNamespace`` enum) to check.

    Returns
    -------
    bool
        ``True`` if `xp` matches one of the `backends`, ``False`` otherwise.
    c                 3   s    | ]}|  V  qd S )N)is_namespace).0backendr    /var/www/www-root/data/www/176.119.141.140/sports-predictor/venv/lib/python3.10/site-packages/sklearn/externals/array_api_extra/_delegation.py	<genexpr>   s    z_delegate.<locals>.<genexpr>)any)r   r   r   r   r   	_delegate   s   r   gh㈵>g:0yE>FNrtolatol	equal_nanr   abr   r   r   c                C   s   |du r	t | |n|}t|tjtjtjtjr!|j| ||||dS t|tjr:t	| ||d\} }|j| ||||dS t
j| |||||d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)r   r   r   r   r   )r   r   r   NUMPYCUPYDASKJAXr   TORCHr	   r   )r   r   r   r   r   r   r   r   r   r   "   s   Kconstantconstant_valuesr   x	pad_widthmoder&   c                C   s   |du rt | n|}|dkrd}t|t|tjr=||}||| jdf}|j|dd	 }|j
jj| t||dS t|tjtjtjtjrR|j| |||dS tj| |||d	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``.
    Nr$   z-Only `'constant'` mode is currently supported   )r   )axis)value)r&   r%   )r   NotImplementedErrorr   r   r#   asarraybroadcast_tondimflipflattennn
functionalr   tupler   r"   r    SPARSEr   )r'   r(   r)   r&   r   msgr   r   r   r   y   s   #
)r$   )__doc__collections.abcr   typesr   typingr   _libr   r   _lib._utils._compatr   _lib._utils._helpersr	   _lib._utils._typingr
   __all__boolr   complexfloatr   intr5   r   r   r   r   r   <module>   s\    
Z