§
    `ƒiò  ã                   óT  — d dl mZ dZ ej        ddded¬¦  «        ZdZ ej        d	dd
ed¬¦  «        ZdZ ej        ddded¬¦  «        ZdZ	 ej        ddde	d¬¦  «        Z
dZ ej        ddded¬¦  «        ZdZ ej        ddded¬¦  «        ZdZ ej        ddded ¬¦  «        Zd!S )"é    )Ú_corez^
template <typename T>
static __device__ T logit(T x) {
    x /= 1 - x;
    return log(x);
}

Ú
cupy_logit)ze->fzf->fzd->dzout0 = logit(in0)zªLogit function.

    Args:
        x (cupy.ndarray): input data

    Returns:
        cupy.ndarray: values of logit(x)

    .. seealso:: :data:`scipy.special.logit`

    )ÚpreambleÚdoczY
template <typename T>
static __device__ T expit(T x) {
    return 1 / (1 + exp(-x));
}

Ú
cupy_expitzout0 = expit(in0)a  Logistic sigmoid function (expit).

    Args:
        x (cupy.ndarray): input data (must be real)

    Returns:
        cupy.ndarray: values of expit(x)

    .. seealso:: :data:`scipy.special.expit`

    .. note::
        expit is the inverse of logit.

    z§
template <typename T>
static __device__ T log_expit(T x)
{
    if (x < 0.0) {
        return x - log1p(exp(x));
    } else {
        return -log1p(exp(-x));
    }
}

Úcupy_log_expitzout0 = log_expit(in0)a©  Logarithm of the logistic sigmoid function.

    Args:
        x (cupy.ndarray): input data (must be real)

    Returns:
        cupy.ndarray: values of log(expit(x))

    .. seealso:: :data:`scipy.special.log_expit`

    .. note::
        The function is mathematically equivalent to ``log(expit(x))``, but
        is formulated to avoid loss of precision for inputs with large
        (positive or negative) magnitude.
    a1  
static __device__ double boxcox(double x, double lmbda) {
    // if lmbda << 1 and log(x) < 1.0, the lmbda*log(x) product can lose
    // precision, furthermore, expm1(x) == x for x < eps.
    // For doubles, the range of log is -744.44 to +709.78, with eps being
    // the smallest value produced.  This range means that we will have
    // abs(lmbda)*log(x) < eps whenever abs(lmbda) <= eps/-log(min double)
    // which is ~2.98e-19.
    if (fabs(lmbda) < 1e-19) {
        return log(x);
    } else {
        return expm1(lmbda * log(x)) / lmbda;
    }
}

Úcupy_boxcox)zee->fzff->fzdd->dz"out0 = out0_type(boxcox(in0, in1))zÏCompute the Box-Cox transformation.

    Args:
        x (cupy.ndarray): input data (must be real)

    Returns:
        cupy.ndarray: values of boxcox(x)

    .. seealso:: :data:`scipy.special.boxcox`

    a  
static __device__ double boxcox1p(double x, double lmbda) {
    // The argument given above in boxcox applies here with the modification
    // that the smallest value produced by log1p is the minimum representable
    // value, rather than eps.  The second condition here prevents underflow
    // when log1p(x) is < eps.
    double lgx = log1p(x);
    if ((fabs(lmbda) < 1e-19)
        || ((fabs(lgx) < 1e-289) && (fabs(lmbda) < 1e273))) {
        return lgx;
    } else {
        return expm1(lmbda * lgx) / lmbda;
    }
}

Úcupy_boxcox1pz$out0 = out0_type(boxcox1p(in0, in1))zÞCompute the Box-Cox transformation op 1 + `x`.

    Args:
        x (cupy.ndarray): input data (must be real)

    Returns:
        cupy.ndarray: values of boxcox1p(x)

    .. seealso:: :data:`scipy.special.boxcox1p`

    z²
static __device__ double inv_boxcox(double x, double lmbda) {
    if (lmbda == 0.0) {
        return exp(x);
    } else {
        return exp(log1p(lmbda * x) / lmbda);
    }
}

Úcupy_inv_boxcoxz&out0 = out0_type(inv_boxcox(in0, in1))z×Compute the Box-Cox transformation.

    Args:
        x (cupy.ndarray): input data (must be real)

    Returns:
        cupy.ndarray: values of inv_boxcox(x)

    .. seealso:: :data:`scipy.special.inv_boxcox`

    zõ
static __device__ double inv_boxcox1p(double x, double lmbda) {
    if (lmbda == 0.0) {
        return expm1(x);
    } else if (fabs(lmbda * x) < 1e-154) {
        return x;
    } else {
        return expm1(log1p(lmbda * x) / lmbda);
    }
}

Úcupy_inv_boxcox1pz(out0 = out0_type(inv_boxcox1p(in0, in1))záCompute the Box-Cox transformation op 1 + `x`.

    Args:
        x (cupy.ndarray): input data (must be real)

    Returns:
        cupy.ndarray: values of inv_boxcox1p(x)

    .. seealso:: :data:`scipy.special.inv_boxcox1p`
N)Úcupyr   Úlogit_definitionÚcreate_ufuncÚlogitÚexpit_definitionÚexpitÚlog_expit_definitionÚ	log_expitÚboxcox_definitionÚboxcoxÚboxcox1p_definitionÚboxcox1pÚinv_boxcox_definitionÚ
inv_boxcoxÚinv_boxcox1p_definitionÚinv_boxcox1p© ó    ús/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/special/_statistics.pyú<module>r       s‡  ðØ Ð Ð Ð Ð Ð ðÐ ð 	ˆÔØØØØð
	ð		ñ 		ô 		€ð$Ð ð 	ˆÔØØØØð	ð		ñ 		ô 		€ð.Ð ð ˆEÔØØØØ!ð	ð	ñ 	ô 	€	ð,Ð ð$ 
ˆÔ	ØØØ(Øð
	ð
	ñ 
	ô 
	€ð$Ð ð$ ˆ5ÔØØØ*Ø ð
	ð	ñ 	ô 	€ð$	Ð ð  ˆUÔØØØ,Ø"ð
	ð	ñ 	ô 	€
ð$Ð ð "ˆuÔ!ØØØ.Ø$ð		ðñ ô €€€r   