flopscope 0.2.0__py3-none-any.whl

flopscope/stats/_logistic.py

@@ -0,0 +1,148 @@
+"""Logistic distribution for :mod:`flopscope.stats`."""
+
+from __future__ import annotations
+
+import numpy as _np
+
+from flopscope.stats._base import ContinuousDistribution
+
+
+class LogisticDistribution(ContinuousDistribution):
+    """Logistic continuous random variable.
+
+    This object mirrors ``scipy.stats.logistic``.
+
+    Methods
+    -------
+    pdf(x, loc=0, scale=1)
+        Evaluate the probability density function.
+    cdf(x, loc=0, scale=1)
+        Evaluate the cumulative distribution function.
+    ppf(q, loc=0, scale=1)
+        Evaluate the percent-point function.
+
+    Notes
+    -----
+    ``loc`` is the center of the distribution and ``scale`` controls the
+    spread. The CDF is the sigmoid function and the PPF is the logit
+    function. Each public method deducts ``1 * numel(input)`` FLOPs from the
+    active budget.
+    """
+
+    def __init__(self):
+        super().__init__("logistic")
+
+    def pdf(self, x, loc=0, scale=1):
+        """Evaluate the probability density function.
+
+        Parameters
+        ----------
+        x : array_like
+            Points at which to evaluate the density.
+        loc : float, optional
+            Location parameter of the distribution. Defaults to ``0``.
+        scale : float, optional
+            Scale parameter of the distribution. Defaults to ``1``.
+
+        Returns
+        -------
+        FlopscopeArray
+            Probability density evaluated elementwise at ``x``.
+
+        Notes
+        -----
+        Equivalent to ``scipy.stats.logistic.pdf(x, loc, scale)``.
+        FLOP cost: ``1 * numel(x)``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import flopscope as flops
+        >>> x = np.array([-1.0, 0.0, 1.0])
+        >>> np.round(flops.stats.logistic.pdf(x), 3)
+        array([0.197, 0.25 , 0.197])
+        """
+        return self._deduct_and_call("pdf", 1, x, loc=loc, scale=scale)
+
+    def cdf(self, x, loc=0, scale=1):
+        """Evaluate the cumulative distribution function.
+
+        Parameters
+        ----------
+        x : array_like
+            Points at which to evaluate the cumulative probability.
+        loc : float, optional
+            Location parameter of the distribution. Defaults to ``0``.
+        scale : float, optional
+            Scale parameter of the distribution. Defaults to ``1``.
+
+        Returns
+        -------
+        FlopscopeArray
+            Cumulative probability evaluated elementwise at ``x``.
+
+        Notes
+        -----
+        Equivalent to ``scipy.stats.logistic.cdf(x, loc, scale)``.
+        FLOP cost: ``1 * numel(x)``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import flopscope as flops
+        >>> x = np.array([-1.0, 0.0, 1.0])
+        >>> np.round(flops.stats.logistic.cdf(x), 3)
+        array([0.269, 0.5  , 0.731])
+        """
+        return self._deduct_and_call("cdf", 1, x, loc=loc, scale=scale)
+
+    def ppf(self, q, loc=0, scale=1):
+        """Evaluate the percent-point function.
+
+        Parameters
+        ----------
+        q : array_like
+            Probabilities in ``[0, 1]``.
+        loc : float, optional
+            Location parameter of the distribution. Defaults to ``0``.
+        scale : float, optional
+            Scale parameter of the distribution. Defaults to ``1``.
+
+        Returns
+        -------
+        FlopscopeArray
+            Quantiles corresponding to ``q``.
+
+        Notes
+        -----
+        Equivalent to ``scipy.stats.logistic.ppf(q, loc, scale)``.
+        FLOP cost: ``1 * numel(q)``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import flopscope as flops
+        >>> q = np.array([0.25, 0.5, 0.75])
+        >>> np.round(flops.stats.logistic.ppf(q), 3)
+        array([-1.099,  0.   ,  1.099])
+        """
+        return self._deduct_and_call("ppf", 1, q, loc=loc, scale=scale)
+
+    def _compute_pdf(self, x, loc=0, scale=1):
+        z = (x - loc) / scale
+        ez = _np.exp(-z)
+        return ez / (scale * (1.0 + ez) ** 2)
+
+    def _compute_cdf(self, x, loc=0, scale=1):
+        z = (x - loc) / scale
+        return 1.0 / (1.0 + _np.exp(-z))
+
+    def _compute_ppf(self, q, loc=0, scale=1):
+        result = loc + scale * _np.log(q / (1.0 - q))
+        result = _np.where((q > 0) & (q < 1), result, _np.nan)
+        result = _np.where(q == 0, -_np.inf, result)
+        result = _np.where(q == 1, _np.inf, result)
+        return result
+
+
+logistic = LogisticDistribution()

flopscope/stats/_lognorm.py

@@ -0,0 +1,160 @@
+"""Log-normal distribution for :mod:`flopscope.stats`."""
+
+from __future__ import annotations
+
+import numpy as _np
+
+from flopscope.stats._base import ContinuousDistribution
+from flopscope.stats._erf import _erf
+from flopscope.stats._ndtri import _ndtri
+
+_SQRT2 = _np.sqrt(2.0)
+_INV_SQRT_2PI = 1.0 / _np.sqrt(2.0 * _np.pi)
+
+
+class LognormDistribution(ContinuousDistribution):
+    """Log-normal continuous random variable.
+
+    This object mirrors ``scipy.stats.lognorm``.
+
+    Methods
+    -------
+    pdf(x, s, loc=0, scale=1)
+        Evaluate the probability density function.
+    cdf(x, s, loc=0, scale=1)
+        Evaluate the cumulative distribution function.
+    ppf(q, s, loc=0, scale=1)
+        Evaluate the percent-point function.
+
+    Notes
+    -----
+    ``s`` is the shape parameter: the standard deviation of the underlying
+    normal distribution. It is the first positional argument, ahead of
+    ``loc`` and ``scale``, matching SciPy's ``lognorm`` signature. Each
+    public method deducts ``1 * numel(input)`` FLOPs from the active budget.
+    """
+
+    def __init__(self):
+        super().__init__("lognorm")
+
+    def pdf(self, x, s, loc=0, scale=1):
+        """Evaluate the probability density function.
+
+        Parameters
+        ----------
+        x : array_like
+            Points at which to evaluate the density.
+        s : float
+            Shape parameter of the distribution.
+        loc : float, optional
+            Location parameter. Defaults to ``0``.
+        scale : float, optional
+            Scale parameter. Defaults to ``1``.
+
+        Returns
+        -------
+        FlopscopeArray
+            Probability density evaluated elementwise at ``x``.
+
+        Notes
+        -----
+        Equivalent to ``scipy.stats.lognorm.pdf(x, s, loc, scale)``.
+        FLOP cost: ``1 * numel(x)``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import flopscope as flops
+        >>> x = np.array([0.5, 1.0, 2.0])
+        >>> np.round(flops.stats.lognorm.pdf(x, s=0.5), 3)
+        array([0.61 , 0.798, 0.153])
+        """
+        return self._deduct_and_call("pdf", 1, x, s, loc=loc, scale=scale)
+
+    def cdf(self, x, s, loc=0, scale=1):
+        """Evaluate the cumulative distribution function.
+
+        Parameters
+        ----------
+        x : array_like
+            Points at which to evaluate the cumulative probability.
+        s : float
+            Shape parameter of the distribution.
+        loc : float, optional
+            Location parameter. Defaults to ``0``.
+        scale : float, optional
+            Scale parameter. Defaults to ``1``.
+
+        Returns
+        -------
+        FlopscopeArray
+            Cumulative probability evaluated elementwise at ``x``.
+
+        Notes
+        -----
+        Equivalent to ``scipy.stats.lognorm.cdf(x, s, loc, scale)``.
+        FLOP cost: ``1 * numel(x)``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import flopscope as flops
+        >>> x = np.array([0.5, 1.0, 2.0])
+        >>> np.round(flops.stats.lognorm.cdf(x, s=0.5), 3)
+        array([0.083, 0.5  , 0.917])
+        """
+        return self._deduct_and_call("cdf", 1, x, s, loc=loc, scale=scale)
+
+    def ppf(self, q, s, loc=0, scale=1):
+        """Evaluate the percent-point function.
+
+        Parameters
+        ----------
+        q : array_like
+            Probabilities in ``[0, 1]``.
+        s : float
+            Shape parameter of the distribution.
+        loc : float, optional
+            Location parameter. Defaults to ``0``.
+        scale : float, optional
+            Scale parameter. Defaults to ``1``.
+
+        Returns
+        -------
+        FlopscopeArray
+            Quantiles corresponding to ``q``.
+
+        Notes
+        -----
+        Equivalent to ``scipy.stats.lognorm.ppf(q, s, loc, scale)``.
+        FLOP cost: ``1 * numel(q)``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import flopscope as flops
+        >>> q = np.array([0.25, 0.5, 0.75])
+        >>> np.round(flops.stats.lognorm.ppf(q, s=0.5), 3)
+        array([0.714, 1.   , 1.401])
+        """
+        return self._deduct_and_call("ppf", 1, q, s, loc=loc, scale=scale)
+
+    def _compute_pdf(self, x, s, loc=0, scale=1):
+        y = (x - loc) / scale
+        safe_y = _np.where(y > 0, y, 1.0)  # avoid log(0)
+        lny = _np.log(safe_y)
+        result = _INV_SQRT_2PI / (s * safe_y * scale) * _np.exp(-0.5 * (lny / s) ** 2)
+        return _np.where(y > 0, result, 0.0)
+
+    def _compute_cdf(self, x, s, loc=0, scale=1):
+        y = (x - loc) / scale
+        safe_y = _np.where(y > 0, y, 1.0)
+        z = _np.log(safe_y) / (s * _SQRT2)
+        result = 0.5 * (1.0 + _erf(z))
+        return _np.where(y > 0, result, 0.0)
+
+    def _compute_ppf(self, q, s, loc=0, scale=1):
+        return loc + scale * _np.exp(s * _ndtri(q))
+
+
+lognorm = LognormDistribution()

flopscope/stats/_ndtri.py

@@ -0,0 +1,133 @@
+"""Inverse standard normal CDF (ndtri) via Acklam's algorithm + Newton refinement.
+
+Accuracy: ~1e-12 against scipy.special.ndtri.
+
+References
+----------
+.. [1] Peter J. Acklam, "An algorithm for computing the inverse normal
+   cumulative distribution function," 2004.
+   https://web.archive.org/web/20151030215612/http://home.online.no/~pjacklam/notes/invnorm/
+   (Rational approximation coefficients; algorithm made freely available by the author.)
+
+.. [2] StackedBoxes, "Acklam's Normal Quantile Function," 2017.
+   https://stackedboxes.org/2017/05/01/acklams-normal-quantile-function/
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from flopscope.stats._erf import _erf
+
+# ---------------------------------------------------------------------------
+# Acklam coefficients
+# ---------------------------------------------------------------------------
+
+_A = (
+    -3.969683028665376e01,
+    2.209460984245205e02,
+    -2.759285104469687e02,
+    1.383577518672690e02,
+    -3.066479806614716e01,
+    2.506628277459239e00,
+)
+_B = (
+    -5.447609879822406e01,
+    1.615858368580409e02,
+    -1.556989798598866e02,
+    6.680131188771972e01,
+    -1.328068155288572e01,
+)
+_C = (
+    -7.784894002430293e-03,
+    -3.223964580411365e-01,
+    -2.400758277161838e00,
+    -2.549732539343734e00,
+    4.374664141464968e00,
+    2.938163982698783e00,
+)
+_D = (
+    7.784695709041462e-03,
+    3.224671290700398e-01,
+    2.445134137142996e00,
+    3.754408661907416e00,
+)
+
+_P_LOW = 0.02425
+_P_HIGH = 1.0 - _P_LOW
+
+_SQRT2 = np.sqrt(2.0)
+_INV_SQRT_2PI = 1.0 / np.sqrt(2.0 * np.pi)
+
+
+def _norm_pdf_internal(x):
+    """Standard normal PDF (internal helper, no budget deduction)."""
+    return _INV_SQRT_2PI * np.exp(-0.5 * x * x)
+
+
+def _norm_cdf_internal(x):
+    """Standard normal CDF (internal helper, no budget deduction)."""
+    return 0.5 * (1.0 + _erf(x / _SQRT2))
+
+
+def _ndtri(p):
+    """Inverse standard normal CDF.
+
+    Maps probability *p* in (0, 1) to the quantile *x* such that
+    Phi(x) = p, where Phi is the standard normal CDF.
+
+    Uses Acklam's rational approximation [1]_ with one Newton-Raphson
+    refinement step for ~1e-12 accuracy.
+
+    Edge cases: p=0 -> -inf, p=1 -> +inf, p<0 or p>1 -> nan.
+    """
+    p = np.asarray(p, dtype=np.float64)
+    scalar = p.ndim == 0
+    p = np.atleast_1d(p)
+
+    out = np.empty_like(p)
+
+    # Edge cases
+    out[p == 0.0] = -np.inf
+    out[p == 1.0] = np.inf
+    out[(p < 0.0) | (p > 1.0)] = np.nan
+
+    # Lower region: 0 < p < P_LOW
+    m_low = (p > 0.0) & (p < _P_LOW)
+    if np.any(m_low):
+        q = np.sqrt(-2.0 * np.log(p[m_low]))
+        num = ((((_C[0] * q + _C[1]) * q + _C[2]) * q + _C[3]) * q + _C[4]) * q + _C[5]
+        den = (((_D[0] * q + _D[1]) * q + _D[2]) * q + _D[3]) * q + 1.0
+        out[m_low] = num / den
+
+    # Central region: P_LOW <= p <= P_HIGH
+    m_mid = (p >= _P_LOW) & (p <= _P_HIGH)
+    if np.any(m_mid):
+        q = p[m_mid] - 0.5
+        r = q * q
+        num = ((((_A[0] * r + _A[1]) * r + _A[2]) * r + _A[3]) * r + _A[4]) * r + _A[5]
+        den = ((((_B[0] * r + _B[1]) * r + _B[2]) * r + _B[3]) * r + _B[4]) * r + 1.0
+        out[m_mid] = q * num / den
+
+    # Upper region: P_HIGH < p < 1
+    m_high = (p > _P_HIGH) & (p < 1.0)
+    if np.any(m_high):
+        q = np.sqrt(-2.0 * np.log(1.0 - p[m_high]))
+        num = ((((_C[0] * q + _C[1]) * q + _C[2]) * q + _C[3]) * q + _C[4]) * q + _C[5]
+        den = (((_D[0] * q + _D[1]) * q + _D[2]) * q + _D[3]) * q + 1.0
+        out[m_high] = -(num / den)
+
+    # Newton refinement (one step) for the interior
+    m_interior = (p > 0.0) & (p < 1.0)
+    if np.any(m_interior):
+        x0 = out[m_interior]
+        phi = _norm_cdf_internal(x0)
+        pdf = _norm_pdf_internal(x0)
+        # Avoid division by zero in pdf
+        safe = pdf > 1e-300
+        correction = np.where(safe, (phi - p[m_interior]) / pdf, 0.0)
+        out[m_interior] = x0 - correction
+
+    if scalar:
+        return float(out[0])
+    return out

flopscope/stats/_norm.py

@@ -0,0 +1,149 @@
+"""Normal distribution for :mod:`flopscope.stats`."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from flopscope.stats._base import ContinuousDistribution
+from flopscope.stats._erf import _erf
+from flopscope.stats._ndtri import _ndtri
+
+_SQRT2 = np.sqrt(2.0)
+_INV_SQRT_2PI = 1.0 / np.sqrt(2.0 * np.pi)
+
+
+class NormDistribution(ContinuousDistribution):
+    """Normal (Gaussian) continuous random variable.
+
+    This object mirrors ``scipy.stats.norm`` and uses the standard
+    ``loc``/``scale`` parameterization.
+
+    Methods
+    -------
+    pdf(x, loc=0, scale=1)
+        Evaluate the probability density function.
+    cdf(x, loc=0, scale=1)
+        Evaluate the cumulative distribution function.
+    ppf(q, loc=0, scale=1)
+        Evaluate the percent-point function.
+
+    Notes
+    -----
+    ``loc`` is the mean and ``scale`` is the standard deviation. Each public
+    method deducts ``1 * numel(input)`` FLOPs from the active budget.
+    """
+
+    def __init__(self):
+        super().__init__("norm")
+
+    def pdf(self, x, loc=0, scale=1):
+        """Evaluate the probability density function.
+
+        Parameters
+        ----------
+        x : array_like
+            Points at which to evaluate the density.
+        loc : float, optional
+            Mean of the distribution. Defaults to ``0``.
+        scale : float, optional
+            Standard deviation of the distribution. Defaults to ``1``.
+
+        Returns
+        -------
+        FlopscopeArray
+            Probability density evaluated elementwise at ``x``.
+
+        Notes
+        -----
+        Equivalent to ``scipy.stats.norm.pdf(x, loc, scale)``.
+        FLOP cost: ``1 * numel(x)``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import flopscope as flops
+        >>> x = np.array([-1.0, 0.0, 1.0])
+        >>> np.round(flops.stats.norm.pdf(x), 3)
+        array([0.242, 0.399, 0.242])
+        """
+        return self._deduct_and_call("pdf", 1, x, loc=loc, scale=scale)
+
+    def cdf(self, x, loc=0, scale=1):
+        """Evaluate the cumulative distribution function.
+
+        Parameters
+        ----------
+        x : array_like
+            Points at which to evaluate the cumulative probability.
+        loc : float, optional
+            Mean of the distribution. Defaults to ``0``.
+        scale : float, optional
+            Standard deviation of the distribution. Defaults to ``1``.
+
+        Returns
+        -------
+        FlopscopeArray
+            Cumulative probability evaluated elementwise at ``x``.
+
+        Notes
+        -----
+        Equivalent to ``scipy.stats.norm.cdf(x, loc, scale)``.
+        FLOP cost: ``1 * numel(x)``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import flopscope as flops
+        >>> x = np.array([-1.0, 0.0, 1.0])
+        >>> np.round(flops.stats.norm.cdf(x), 3)
+        array([0.159, 0.5  , 0.841])
+        """
+        return self._deduct_and_call("cdf", 1, x, loc=loc, scale=scale)
+
+    def ppf(self, q, loc=0, scale=1):
+        """Evaluate the percent-point function.
+
+        Parameters
+        ----------
+        q : array_like
+            Probabilities in ``[0, 1]``.
+        loc : float, optional
+            Mean of the distribution. Defaults to ``0``.
+        scale : float, optional
+            Standard deviation of the distribution. Defaults to ``1``.
+
+        Returns
+        -------
+        FlopscopeArray
+            Quantiles corresponding to ``q``.
+
+        Notes
+        -----
+        Equivalent to ``scipy.stats.norm.ppf(q, loc, scale)``.
+        FLOP cost: ``1 * numel(q)``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import flopscope as flops
+        >>> q = np.array([0.25, 0.5, 0.75])
+        >>> np.round(flops.stats.norm.ppf(q), 3)
+        array([-0.674,  0.   ,  0.674])
+        """
+        return self._deduct_and_call("ppf", 1, q, loc=loc, scale=scale)
+
+    # --- Pure-NumPy implementations (no budget deduction) ---
+
+    def _compute_pdf(self, x, loc=0, scale=1):
+        z = (x - loc) / scale
+        return _INV_SQRT_2PI / scale * np.exp(-0.5 * z * z)
+
+    def _compute_cdf(self, x, loc=0, scale=1):
+        z = (x - loc) / (scale * _SQRT2)
+        return 0.5 * (1.0 + _erf(z))
+
+    def _compute_ppf(self, q, loc=0, scale=1):
+        return loc + scale * _ndtri(q)
+
+
+norm = NormDistribution()