
    rh                        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Zddddddeez  deez  dededededz  defdZ	 d"ddddedeeeef   z  eeeef      z  ded   d ededz  defd!Zy)#z@Delegation to existing implementations for Public API Functions.    )Sequence)
ModuleType)Literal   )Backend_funcs)array_namespace)asarrays)Arrayisclosepadxpbackendsreturnc                 ,     t         f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   @   K   | ]  }|j                          y w)N)is_namespace).0backendr   s     /var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/sklearn/externals/array_api_extra/_delegation.py	<genexpr>z_delegate.<locals>.<genexpr>   s     @Gw##B'@s   )any)r   r   s   ` r   	_delegater      s      @x@@@    gh㈵>g:0yE>FNrtolatol	equal_nanr   abr   r   r   c                   |t        | |      n|}t        |t        j                  t        j                  t        j
                  t        j                        r|j                  | ||||      S t        |t        j                        r't        | ||      \  } }|j                  | ||||      S t        j                  | |||||      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.
    )r   r   r   )r   r   )r	   r   r   NUMPYCUPYDASKJAXr   TORCHr
   r   )r   r    r   r   r   r   s         r   r   r   "   s    V #%*A	"BW]]GLL',,Lzz!QT	zJJW]]#1$1zz!QT	zJJ>>!QT	bQQr   constantconstant_valuesr   x	pad_widthmoder)   c                d   |t        |       n|}|dk7  rd}t        |      t        |t        j                        r|j                  |      }|j                  || j                  df      }|j                  |d      j                         }|j                  j                  j                  | t        |      |      S t        |t        j                  t        j                  t        j                   t        j"                        r|j                  | |||      S t%        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``.
    r'   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   msgs         r   r   r   y   s    F  "z	rBz=!#&& W]]#JJy)	OOI{;	GGIDG199;	uu##AuY'7#OOW]]GKKw~~NvvaD/vJJ::aOKKr   )r'   )__doc__collections.abcr   typesr   typingr   _libr   r   _lib._utils._compatr	   _lib._utils._helpersr
   _lib._utils._typingr   __all__boolr   complexfloatr   intr9   r    r   r   <module>rJ      s8   F $   ! 0 * &e
A* A AT A.  TRwTRwTR 	TR
 TR TR 	TTR TRt !+3L
  ! 3L3LU38_$xc3h'@@3L *
3L
 3L 	T3L 3Lr   