process-improve 1.97.1__tar.gz → 1.97.2__tar.gz

{process_improve-1.97.1 → process_improve-1.97.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-improve
-Version: 1.97.1
+Version: 1.97.2
 Summary: Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis.
 Keywords: Designed Experiments,Latent Variables,PCA,PLS,Multivariate Data Analysis,Batch data analysis
 Author: Kevin Dunn
@@ -42,7 +42,7 @@ Requires-Dist: osqp>=1.0 ; extra == 'control'
 Requires-Dist: coverage>=7.13.1 ; extra == 'dev'
 Requires-Dist: hypothesis>=6.100 ; extra == 'dev'
 Requires-Dist: matplotlib-stubs>=0.3.11 ; extra == 'dev'
-Requires-Dist: mypy>=1.19.1,<2.4 ; extra == 'dev'
+Requires-Dist: mypy>=1.19.1,<2.5 ; extra == 'dev'
 Requires-Dist: pandas-stubs>=2.3.3.260113 ; extra == 'dev'
 Requires-Dist: plotly-stubs>=0.0.6 ; extra == 'dev'
 Requires-Dist: pre-commit>=4.5.1 ; extra == 'dev'

{process_improve-1.97.1 → process_improve-1.97.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "process-improve"
-version = "1.97.1"
+version = "1.97.2"
 description = "Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis."
 readme = "README.md"
 license = "MIT"
@@ -74,7 +74,7 @@ dev = [
     "coverage>=7.13.1",
     "hypothesis>=6.100",
     "matplotlib-stubs>=0.3.11",
-    "mypy>=1.19.1,<2.4",
+    "mypy>=1.19.1,<2.5",
     "pandas-stubs>=2.3.3.260113",
     "plotly-stubs>=0.0.6",
     "pre-commit>=4.5.1",
@@ -108,7 +108,7 @@ dev = [
     "coverage>=7.13.1",
     "hypothesis>=6.100",
     "matplotlib-stubs>=0.3.11",
-    "mypy>=1.19.1,<2.4",
+    "mypy>=1.19.1,<2.5",
     "pandas-stubs>=2.3.3.260113",
     "plotly-stubs>=0.0.6",
     "pre-commit>=4.5.1",

{process_improve-1.97.1 → process_improve-1.97.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "process-improve"
-version = "1.97.1"
+version = "1.97.2"
 description = 'Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis.'
 readme = "README.md"
 license = "MIT"
@@ -122,7 +122,7 @@ dev = [
     "coverage>=7.13.1",
     "hypothesis>=6.100",
     "matplotlib-stubs>=0.3.11",
-    "mypy>=1.19.1,<2.4",
+    "mypy>=1.19.1,<2.5",
     "pandas-stubs>=2.3.3.260113",
     "plotly-stubs>=0.0.6",
     "pre-commit>=4.5.1",
@@ -157,7 +157,7 @@ dev = [
     "coverage>=7.13.1",
     "hypothesis>=6.100",
     "matplotlib-stubs>=0.3.11",
-    "mypy>=1.19.1,<2.4",
+    "mypy>=1.19.1,<2.5",
     "pandas-stubs>=2.3.3.260113",
     "plotly-stubs>=0.0.6",
     "pre-commit>=4.5.1",

{process_improve-1.97.1 → process_improve-1.97.2}/src/process_improve/_extras.py

@@ -58,11 +58,16 @@ def require_extra(missing: str, extra: str) -> ImportError:
 class _MissingExtra:
     """Stand-in for an optional module that was not installed.
 
-    Attribute access raises :class:`AttributeError` (Python's special-method
-    convention -- ``hasattr(stub, 'Figure')`` returns ``False``) with the
-    canonical "install the extra" remediation message in the body. Direct
-    *calls* on the stub raise :class:`ImportError` because that is the
-    natural error class for "you need to install this dependency".
+    Using the stub in any way that needs the real package raises
+    :class:`ImportError` with the canonical "install the extra" message, so a
+    missing ``plotting`` extra fails the same way as a missing ``expt`` extra.
+    Attribute access returns a child stub that remembers the dotted path, so
+    ``go.Figure(...)`` and ``go.layout.Template(...)`` raise ``ImportError`` at
+    the call, and indexing (``pio.templates[name]``) raises it too.
+
+    Dunder lookups (``__array__``, ``__deepcopy__``, ...) raise
+    :class:`AttributeError` instead, so protocol probes such as ``copy``,
+    ``pickle`` and numpy see a missing attribute, per the Python data model.
 
     Lets a module top-level write::
 
@@ -75,21 +80,32 @@ class _MissingExtra:
     who never touch the optional surface.
     """
 
-    __slots__ = ("_extra", "_missing")
+    __slots__ = ("_extra", "_missing", "_path")
 
-    def __init__(self, missing: str, extra: str) -> None:
+    def __init__(self, missing: str, extra: str, path: str = "") -> None:
         self._missing = missing
         self._extra = extra
-
-    def __getattr__(self, name: str) -> object:
-        # __getattr__ must raise AttributeError so ``hasattr`` and friends
-        # behave per the Python data model (CodeQL py/non-standard-exception
-        # -raised-in-special-method). The install-hint message is preserved
-        # in the exception text.
-        raise AttributeError(f"{_extra_message(self._missing, self._extra)}\n(Attempted attribute access: {name!r}.)")
+        self._path = path
+
+    def _error(self) -> ImportError:
+        hint = f"\n(Attempted to use {self._path!r}.)" if self._path else ""
+        return ImportError(f"{_extra_message(self._missing, self._extra)}{hint}")
+
+    def __getattr__(self, name: str) -> _MissingExtra:
+        if name.startswith("__") and name.endswith("__"):
+            # __getattr__ must raise AttributeError for protocol lookups so
+            # ``hasattr`` and friends behave per the data model (CodeQL
+            # py/non-standard-exception-raised-in-special-method).
+            raise AttributeError(
+                f"{_extra_message(self._missing, self._extra)}\n(Attempted attribute access: {name!r}.)"
+            )
+        return _MissingExtra(self._missing, self._extra, f"{self._path}.{name}" if self._path else name)
 
     def __call__(self, *_args: object, **_kwargs: object) -> object:
-        # __call__ has no equivalent convention; raise ImportError here
-        # because callers that try to use the stub directly are asking
-        # for the missing package.
-        raise require_extra(self._missing, self._extra)
+        raise self._error()
+
+    def __getitem__(self, _key: object) -> object:
+        raise self._error()
+
+    def __setitem__(self, _key: object, _value: object) -> None:
+        raise self._error()

{process_improve-1.97.1 → process_improve-1.97.2}/src/process_improve/experiments/designs.py

@@ -678,7 +678,8 @@ def generate_design(  # noqa: PLR0913
         ``Constraint(expression="3*T + 5*D <= 600")``; a dict of ``Constraint`` fields or
         a bare expression string is accepted too. Honoured by the optimal
         families (``"d_optimal"``, chosen automatically when constraints are given,
-        ``"i_optimal"``, ``"a_optimal"`` and ``"e_optimal"``), whose runs are selected
+        ``"i_optimal"``, ``"a_optimal"``, ``"e_optimal"``, ``"g_optimal"`` and
+        ``"k_optimal"``), whose runs are selected
         from a candidate set of feasible points; by ``"mixture"`` (linear constraints
         in the proportions); and by the ``"sobol"``, ``"halton"``, ``"maximin"`` and
         ``"maxpro"`` space-filling designs. Other design types do not enforce them and set
@@ -695,7 +696,8 @@ def generate_design(  # noqa: PLR0913
         Ignored by the classical (non-optimal) design families.
     fixed_runs : pandas.DataFrame or None
         Runs to hold fixed while the optimizer fills the rest (design augmentation), for the
-        optimal families only (``"d_optimal"``, ``"i_optimal"``, ``"a_optimal"``, ``"e_optimal"``). One row per
+        optimal families only (``"d_optimal"``, ``"i_optimal"``, ``"a_optimal"``, ``"e_optimal"``,
+        ``"g_optimal"``, ``"k_optimal"``). One row per
         fixed run, one column per factor, in the same coding as the returned design: continuous
         factors in coded ``[-1, 1]`` units, categorical factors as level labels.
         The fixed runs occupy the first rows of the result and ``budget`` counts them, so

{process_improve-1.97.1 → process_improve-1.97.2}/src/process_improve/experiments/designs_response_surface.py

@@ -456,8 +456,12 @@ def dispatch_dsd(factors: list[Factor], budget: int | None = None) -> tuple[np.n
     two zeros (one in each half of the foldover) become ``+z`` and ``-z``, and the
     single centre run becomes two, with the categorical factors at ``+b`` and ``-b``.
     The signs are chosen to maximise the determinant of the main-effects information
-    matrix. Every main effect stays orthogonal to every second-order effect; the
-    categorical main effects are slightly correlated with each other.
+    matrix. Every main effect stays orthogonal to every second-order effect, and the
+    continuous main effects stay orthogonal to each other. Resolving the zeros costs
+    some orthogonality between a categorical main effect and the other main effects:
+    it is slightly correlated with each continuous main effect (``|r|`` about 0.17 for
+    four continuous factors and one categorical factor in 14 runs) and with the other
+    categorical main effects.
 
     A ``budget`` larger than the minimal design adds fake factors: the conference
     matrix of the largest buildable order whose design fits the budget is used, and its

{process_improve-1.97.1 → process_improve-1.97.2}/src/process_improve/monitoring/control_charts.py

@@ -1,7 +1,8 @@
 """Class for ControlChart: robust control charts with a balance between CUSUM and Shewhart properties."""
 
 import logging
-from typing import ClassVar
+from collections.abc import Mapping
+from typing import Any, ClassVar
 
 import numpy as np
 import pandas as pd
@@ -18,6 +19,15 @@ logger = logging.getLogger(__name__)
 #: (scipy.integrate.quad of rho_norm(z) * phi(z); E = 0.3061160, so
 #: c_k = 3.266736). This makes E[rho(Z)] = 1, the condition for the scale
 #: estimates built from rho to be consistent for sigma on Gaussian data.
+#:
+#: Departure from the paper, kept deliberately: equation (13) of Gelper, Fried and
+#: Croux (2010, p 289) pairs the cutoff k = 2 with c_k = 2.52 ("for the common choice
+#: of k = 2 we have c_k = 2.52"; numerically 1 / E[rho_norm(Z)] = 2.5153 for k = 2).
+#: This module uses 2.52 as the cutoff instead, with the matching c_k above. Both pairs
+#: give consistent scale estimates on Gaussian data, but this biweight saturates later
+#: (at ``|x| > 2.52`` rather than ``|x| > 2``), so it down-weights large forecast errors
+#: less than the paper's. The constants are left unchanged because existing results
+#: and callers depend on them.
 BIWEIGHT_RHO_CONSISTENCY = 3.266736
 
 
@@ -38,8 +48,9 @@ def rho(x: float, k: float = 2.52) -> float:
     x : float
         Value at which to evaluate the bi-weight rho function.
     k : float, optional
-        Bi-weight cutoff. The default of 2.52 is from p 289 of the referenced
-        paper.
+        Bi-weight cutoff. The default of 2.52 is kept for compatibility. In the
+        paper (equation 13, p 289) 2.52 is instead the consistency constant c_k
+        for the cutoff k = 2; see the note on ``BIWEIGHT_RHO_CONSISTENCY``.
 
     Returns
     -------
@@ -55,12 +66,40 @@ def rho(x: float, k: float = 2.52) -> float:
     return c_k if np.abs(x) > k else c_k * (1 - np.power(1 - np.power(x / k, 2), 3))
 
 
+def _rho_array(x: np.ndarray | pd.Series, k: float = 2.52) -> np.ndarray:
+    """
+    Evaluate the bi-weight :func:`rho` element-wise over an array.
+
+    Replaces ``np.vectorize(rho)``, which calls the scalar function once per element. The
+    polynomial branch is evaluated on ``x`` clipped to ``[-k, k]``: ``np.where`` evaluates both
+    branches, and an unclipped huge ``|x|`` would overflow in ``np.power`` and raise a
+    ``RuntimeWarning`` from values that are then discarded. Saturated entries take ``c_k``
+    directly and NaN propagates, exactly as in :func:`rho`.
+
+    Parameters
+    ----------
+    x : np.ndarray or pd.Series
+        Values at which to evaluate the bi-weight rho function.
+    k : float, optional
+        Bi-weight cutoff, as in :func:`rho`.
+
+    Returns
+    -------
+    np.ndarray
+        ``rho(x)`` for every element of ``x``, as float64.
+    """
+    x = np.asarray(x, dtype=float)
+    c_k = BIWEIGHT_RHO_CONSISTENCY
+    inside = c_k * (1 - np.power(1 - np.power(np.clip(x, -k, k) / k, 2), 3))
+    return np.where(np.abs(x) > k, c_k, inside)
+
+
 def _finite(values: pd.Series | np.ndarray) -> bool:
     """Return ``True`` if at least one entry of ``values`` is finite."""
     return bool(np.isfinite(np.asarray(values, dtype=float)).any())
 
 
-def _training_error_radicand(future_errors: pd.Series, rho_func: np.vectorize) -> float:
+def _training_error_radicand(future_errors: pd.Series) -> float:
     """
     Return tau squared for the training-sample errors, or NaN when it is undefined.
 
@@ -74,8 +113,6 @@ def _training_error_radicand(future_errors: pd.Series, rho_func: np.vectorize) -
     ----------
     future_errors : pd.Series
         One-step-ahead errors over the training samples (those after the warm-up).
-    rho_func : np.vectorize
-        Element-wise bounded loss applied to the standardised errors.
 
     Returns
     -------
@@ -86,14 +123,17 @@ def _training_error_radicand(future_errors: pd.Series, rho_func: np.vectorize) -
     if not _finite(future_errors):
         return float("nan")
 
+    # s_T = 1.48 Med|r_t|, as printed below equation (16) of the paper: 1.48 is the Gaussian
+    # consistency factor of the median absolute error, 1 / Phi^-1(3/4) = 1.4826, rounded. The
+    # robust Shewhart chart below uses the unrounded value.
     s_t_median_error = 1.48 * future_errors.abs().median()
     if not np.isfinite(s_t_median_error) or s_t_median_error <= 0:
         return float("nan")
 
-    return float(np.power(s_t_median_error, 2) * np.nanmean(rho_func(future_errors / s_t_median_error)))
+    return float(np.power(s_t_median_error, 2) * np.nanmean(_rho_array(future_errors / s_t_median_error)))
 
 
-def _tau_from_training_errors(future_errors: pd.Series, rho_func: np.vectorize) -> float:
+def _tau_from_training_errors(future_errors: pd.Series) -> float:
     """
     Return the robust scale estimate (tau) for the training-sample errors.
 
@@ -108,8 +148,6 @@ def _tau_from_training_errors(future_errors: pd.Series, rho_func: np.vectorize)
     ----------
     future_errors : pd.Series
         One-step-ahead errors over the training samples (those after the warm-up).
-    rho_func : np.vectorize
-        Element-wise bounded loss applied to the standardised errors.
 
     Returns
     -------
@@ -123,16 +161,15 @@ def _tau_from_training_errors(future_errors: pd.Series, rho_func: np.vectorize)
         or not positive (the errors carry no usable spread).
     """
     if not _finite(future_errors):
-        # Missing values at or near the start of the series propagate through the
-        # Holt-Winters recursion and leave every training error NaN.
+        # Every training error is NaN when the training period holds no finite observation
+        # to forecast against, or when the warm-up statistics themselves are not finite.
         raise ValueError(
             f"The control-chart scale estimate is undefined: none of the {future_errors.size} "
-            "training-sample errors is finite. Missing values at or near the start of the "
-            "series propagate through the Holt-Winters recursion and leave every error NaN. "
-            "Supply a series without leading gaps, or pass an explicit positive 's'."
+            "training-sample errors is finite, so the series has no finite observation in its "
+            "training period to forecast against. Supply a series with more finite values."
         )
 
-    resids = _training_error_radicand(future_errors, rho_func)
+    resids = _training_error_radicand(future_errors)
     if not np.isfinite(resids) or resids <= 0:
         raise ValueError(
             f"The control-chart scale estimate is undefined (tau^2 = {resids}), so the control "
@@ -170,6 +207,105 @@ def psi(x: float, k: float = 2.0) -> float:
     return x if abs(x) < k else k * np.sign(x)
 
 
+def _holt_winters_recursion(
+    y: np.ndarray, warm_up: Mapping[str, Any], ld_1: float, ld_2: float, ld_s: float
+) -> dict[str, np.ndarray]:
+    """
+    Run the robust Holt-Winters recursion over ``y``, one time step per row.
+
+    Row ``i`` needs row ``i - 1``, so the recursion stays a loop, but over plain numpy arrays
+    that are read and filled in place, instead of several ``DataFrame`` lookups per row and a
+    ``df.loc`` write of every row. The arithmetic is kept expression for expression, in the
+    same order, on the same ``np.float64`` scalars and through the same scalar :func:`rho` and
+    :func:`psi`, so the results are bit-for-bit those of the per-row pandas implementation it
+    replaces (pinned by ``tests/test_control_chart_hw_golden.py``).
+
+    Parameters
+    ----------
+    y : np.ndarray
+        The observations, as stored in ``ControlChart.df["y"]``.
+    warm_up : Mapping[str, Any]
+        ``ControlChart.warm_up``. Row 0 is set from ``y_zero_robust`` (median of the warm-up
+        window) and the initial level ``alpha_0``, trend ``beta_0`` and strictly positive
+        scale ``sigma_0`` (p 290 of the paper).
+    ld_1 : float
+        Smoothing parameter for the level, lambda_1.
+    ld_2 : float
+        Smoothing parameter for the trend, lambda_2.
+    ld_s : float
+        Smoothing parameter for the scale, lambda_s.
+
+    Returns
+    -------
+    dict[str, np.ndarray]
+        Float64 arrays of length ``len(y)``, keyed by their ``ControlChart.df`` column:
+        ``psi_input``, ``rho_input``, ``y_star``, ``alpha_hat``, ``beta_hat``, ``sigma_hat``
+        and ``error``. ``error[0]`` is NaN: row 0 has no one-step-ahead prediction.
+    """
+    y_zero, alpha_0, beta_0, sigma_0 = (warm_up[key] for key in ("y_zero_robust", "alpha_0", "beta_0", "sigma_0"))
+    n = len(y)
+    psi_input, rho_input, y_star, alpha_hat, beta_hat, sigma_hat, error = (np.full(n, np.nan) for _ in range(7))
+
+    rho_input[0] = (y_zero - alpha_0 - beta_0) / sigma_0
+    psi_input[0] = rho_input[0]
+    y_star[0] = y_zero
+    alpha_hat[0] = alpha_0
+    beta_hat[0] = beta_0
+    sigma_hat[0] = sigma_0
+
+    for i in range(1, n):
+        # Cover the warm-up period, and the rest of the data set. We need that for the residual
+        # calculation later anyway. The previous state is read back from the float64 arrays,
+        # which yields the same np.float64 scalars the per-row DataFrame lookups returned.
+        alpha_prev, beta_prev, sigma_prev = alpha_hat[i - 1], beta_hat[i - 1], sigma_hat[i - 1]
+
+        # Error = observed - predicted. Predicted = one-step-ahead prediction
+        error_i = y[i] - (alpha_prev + beta_prev)
+        if np.isnan(error_i):
+            # If there is an error, replace it with the median of the last 10 error estimates
+            # or as many points as available, filtered to the finite ones so an all-NaN slice
+            # never reaches a median (which returns NaN but emits "Mean of empty slice"). (#557)
+            #
+            # Known limitation, kept for now: the imputed error is a median of ABSOLUTE errors,
+            # so it is never negative. Each missing row is treated as an observation above its
+            # prediction, which nudges the level up, and over a long gap the trend term
+            # compounds that into a drift (with lambdas 0.4 / 0.7, a 40-row gap in N(50, 2) noise
+            # took the level from about 49 to 550). Carrying the forecast forward for every
+            # missing row, as below, would remove the bias; later gaps keep the imputation so
+            # that their results do not change.
+            recent_errors = np.abs(error[max(i - 10, 0) : i])
+            recent_errors = recent_errors[np.isfinite(recent_errors)]
+            if not recent_errors.size:
+                # No finite error to impute from: a gap that starts at index 1, the first row
+                # with a one-step-ahead error. Imputing NaN used to spread through every later
+                # row and make the whole fit fail. Carry the forecast forward instead (the level
+                # follows the trend; trend and scale are held) and leave this row's error and
+                # cleaned value NaN, so nothing invented reaches the target or the scale.
+                alpha_hat[i], beta_hat[i], sigma_hat[i] = alpha_prev + beta_prev, beta_prev, sigma_prev
+                continue
+            error_i = float(np.median(recent_errors))
+        rho_i = error_i / sigma_prev
+        prior_variance = np.power(sigma_prev, 2)
+        sigma_i = np.sqrt(rho(rho_i) * ld_s * prior_variance + (1.0 - ld_s) * prior_variance)
+        psi_i = error_i / sigma_i
+        y_star_i = psi(psi_i) * sigma_i + alpha_prev + beta_prev
+        alpha_i = ld_1 * y_star_i + (1 - ld_1) * (alpha_prev + beta_prev)
+        beta_i = ld_2 * (alpha_i - alpha_prev) + (1 - ld_2) * beta_prev
+
+        psi_input[i], rho_input[i], y_star[i] = psi_i, rho_i, y_star_i
+        alpha_hat[i], beta_hat[i], sigma_hat[i], error[i] = alpha_i, beta_i, sigma_i, error_i
+
+    return {
+        "psi_input": psi_input,
+        "rho_input": rho_input,
+        "y_star": y_star,
+        "alpha_hat": alpha_hat,
+        "beta_hat": beta_hat,
+        "sigma_hat": sigma_hat,
+        "error": error,
+    }
+
+
 class ControlChart:
     """Create control chart instance objects."""
 
@@ -218,6 +354,21 @@ class ControlChart:
                 "CUSUM-style history with Shewhart behaviour.)"
             )
 
+        self._reset_fit_state()
+
+    def _reset_fit_state(self) -> None:
+        """
+        Forget everything an earlier fit set; only the constructor arguments survive.
+
+        ``calculate_limits`` starts here, so a chart reused for a new series gives exactly
+        what a fresh chart would. It used to keep the previous series' ``target`` and ``s``
+        and treat them as given, keep its fitted lambdas instead of searching again, and
+        fail outright on a series of a different length.
+        """
+        constructor_arguments = {"style": self.style, "variant": self.variant}
+        self.__dict__.clear()
+        self.__dict__.update(constructor_arguments)
+
         # Will be calculated by the self.calculate_limits() function
         self.target: float | None = None
         self._given_target: float | None = None
@@ -261,7 +412,19 @@ class ControlChart:
         `target` / `s` are ignored for that small-sample case.
         Otherwise, if `target` and `s` are numeric, those values are used;
         if not, they are estimated.
+
+        Missing values (NaN) in `y` are bridged by imputing a one-step-ahead error equal
+        to the median absolute error of the previous 10 rows. That error is never negative,
+        so a gap pulls the Holt-Winters level upward, increasingly so for long gaps; fill or
+        drop long runs of missing values before fitting. A gap that starts at index 1, the
+        first row with a one-step-ahead error, has no earlier error to impute from: those
+        rows carry the forecast forward instead (the level follows the trend, the trend and
+        scale are held), and their error and cleaned value stay NaN.
+
+        Every call starts afresh: nothing fitted by an earlier call on the same chart
+        (target, ``s``, lambdas, warm-up statistics) is carried into this one.
         """
+        self._reset_fit_state()
         self._given_target = target
         self._given_s = s
         logger.debug(
@@ -285,7 +448,9 @@ class ControlChart:
         self.df["y"] = y.ravel() if isinstance(y, np.ndarray) else pd.Series(y).values.ravel()
         self.N = self.df.shape[0]
 
-        # Between M = 10 and 20 samples required to warm-up (calculate summary statistics)
+        # Between M = 10 and 20 samples required to warm-up (calculate summary statistics).
+        # The paper fixes its startup period at m = 10 (p 291); here it grows with N, to 10%
+        # of the series, capped at 20. Kept as is: existing results depend on it.
         self.warm_up["M"] = self.warm_up_M = int(min(20, max(10, np.ceil(0.10 * self.N))))
 
         if (self.warm_up_M > self.N) and self.variant.strip().lower() == "hw":
@@ -295,7 +460,7 @@ class ControlChart:
             self.s = self._tau = self.df["y"].std()
             self.df["y_star"] = self.df["y"].values
             self.df["alpha_hat"] = self.target
-            self.df["beta_hat"] = 0
+            self.df["beta_hat"] = 0.0
             self.df["sigma_hat"] = np.nan
             self.df["error"] = np.nan
             return
@@ -377,7 +542,6 @@ class ControlChart:
         lambda_1 and lambda_2 values. This is done in a 5x5 grid in the code below.
         """
         self.ld_s = ld_s = 0.2
-        rho_func = np.vectorize(rho)
 
         # ``is not None``: an explicit ld_1=0.0 (or ld_2=0.0) is a legitimate
         # user choice, but 0.0 is falsy and a plain truthiness test silently
@@ -398,9 +562,11 @@ class ControlChart:
             ld_2_index = np.linspace(0.1, 0.9, num=5, endpoint=True)
             residuals, _ = np.meshgrid(ld_1_index, ld_2_index)
 
+            # The warm-up statistics do not depend on the lambdas: estimate them once, not per cell.
+            self._holt_winters_warm_up_statistics()
             for i, ld_1 in enumerate(ld_1_index):
                 for j, ld_2 in enumerate(ld_2_index):
-                    self._holt_winters_warmup_fit(ld_1=ld_1, ld_2=ld_2, ld_s=ld_s)
+                    self._holt_winters_smooth(ld_1=ld_1, ld_2=ld_2, ld_s=ld_s)
 
                     # Apply equation 16 from the paper to the residuals in the 'training' period,
                     # that is the samples after the warm-up period. NaN-aware
@@ -414,7 +580,7 @@ class ControlChart:
                     # An unusable cell records NaN and cannot win the search; the
                     # `np.all(np.isnan(residuals))` check below still catches the case
                     # where every cell is unusable. (#557)
-                    residuals[i, j] = _training_error_radicand(future_errors, rho_func)
+                    residuals[i, j] = _training_error_radicand(future_errors)
 
             if np.all(np.isnan(residuals)):
                 raise ValueError(
@@ -428,11 +594,11 @@ class ControlChart:
             self.ld_1 = best_ld_1
             self.ld_2 = best_ld_2
             self._residuals_HW = residuals
-            self._holt_winters_warmup_fit(ld_1=best_ld_1, ld_2=best_ld_2, ld_s=ld_s)
+            self._holt_winters_smooth(ld_1=best_ld_1, ld_2=best_ld_2, ld_s=ld_s)
 
         # Common code for both branches of if-else above
         future_errors = self.df["error"].iloc[np.asarray(self.train_samples, dtype=int)]
-        self._tau = _tau_from_training_errors(future_errors, rho_func)
+        self._tau = _tau_from_training_errors(future_errors)
         if self.target is None:
             # Estimate the target as the median of the y-star (cleaned) y-values
             self.target = self.df["y_star"].median()
@@ -451,20 +617,34 @@ class ControlChart:
         See paper: https://onlinelibrary.wiley.com/doi/abs/10.1002/for.1125.
 
         Calculates the Holt-Winters fitting and control chart parameters, for given values of the
-        smoothing parameters lambda_1 (how must local history for the level is used, with values
+        smoothing parameters lambda_1 (how much local history for the level is used, with values
         approaching 1.0 implying that less history is used), and lambda_2 (history for the trend
         that is used, with lambda_2 approaching 1.0 implying that historical data is less
         interesting), and lambda_s, a similar parameter for the moving variance of the sequence.
 
         lambda_1 = ld_1 = 0.5 (default): value must be between 0 <= ld_1 <= 1.0
         lambda_2 = ld_2 = 0.8 (default): value must be between 0 <= ld_2 <= 1.0
-        lambda_s = ld_s = 0.2 (default): value must be between 0 <= ld_2 <= 1.0, based on values
+        lambda_s = ld_s = 0.2 (default): value must be between 0 <= ld_s <= 1.0, based on values
                                          used in the paper, recommended on page 291.
 
         The ideal lambda values (ld_1, ld_2, ld_s) can be found from a grid search.
         """
-        df = self.df
-        y_warm_up = df["y"].iloc[0 : self.warm_up_M]
+        self._holt_winters_warm_up_statistics()
+        self._holt_winters_smooth(ld_1=ld_1, ld_2=ld_2, ld_s=ld_s)
+
+    def _holt_winters_warm_up_statistics(self) -> None:
+        """
+        Estimate the warm-up level, trend and scale (p 290 of the paper) into ``self.warm_up``.
+
+        They depend only on the warm-up window and on a given ``target`` / ``s``, not on the
+        smoothing lambdas, so the lambda grid search estimates them once instead of per cell.
+
+        Raises
+        ------
+        ValueError
+            If the warm-up window has zero (or non-finite) variance.
+        """
+        y_warm_up = self.df["y"].iloc[0 : self.warm_up_M]
         self.warm_up["y_zero_robust"] = y_warm_up.median()
 
         if isinstance(self.target, float):
@@ -513,53 +693,10 @@ class ControlChart:
                 "Supply more representative warm-up data, or pass a positive 's'."
             )
 
-        df.loc[0, "rho_input"] = (
-            self.warm_up["y_zero_robust"] - self.warm_up["alpha_0"] - self.warm_up["beta_0"]
-        ) / self.warm_up["sigma_0"]
-        df.loc[0, "psi_input"] = df["rho_input"][0]
-        df.loc[0, "y_star"] = self.warm_up["y_zero_robust"]
-        df.loc[0, "alpha_hat"] = self.warm_up["alpha_0"]
-        df.loc[0, "beta_hat"] = self.warm_up["beta_0"]
-        df.loc[0, "sigma_hat"] = self.warm_up["sigma_0"]
-
-        for i in range(1, self.N):
-            # Cover the warm-up period, and the rest of the data set. We need that for the residual
-            # calculation later anyway.
-
-            # Error = observed - predicted. Predicted = one-step-ahead prediction
-            error_i = df["y"][i] - (df["alpha_hat"][i - 1] + df["beta_hat"][i - 1])
-            if np.isnan(error_i):
-                # If there is an error, replace it with the median of the last 10 error estimates
-                # or as many points as available. When the gap is at the very start of the series
-                # there is no finite history to take that median over, so `error_i` stays NaN and
-                # propagates through alpha_hat / beta_hat / sigma_hat for the rest of the
-                # recursion; `calculate_limits` raises on that downstream. Filter to the finite
-                # history explicitly rather than letting an all-NaN slice reach pandas' median,
-                # which returns NaN but emits "Mean of empty slice". (#557)
-                recent_errors = df["error"].iloc[max(i - 10, 0) : i].abs().to_numpy(dtype=float)
-                recent_errors = recent_errors[np.isfinite(recent_errors)]
-                error_i = float(np.median(recent_errors)) if recent_errors.size else np.nan
-            rho_i = error_i / df["sigma_hat"][i - 1]
-            prior_variance = np.power(df["sigma_hat"][i - 1], 2)
-            sigma_i = np.sqrt(rho(rho_i) * ld_s * prior_variance + (1.0 - ld_s) * prior_variance)
-            psi_i = error_i / sigma_i
-            y_star_i = psi(psi_i) * sigma_i + df["alpha_hat"][i - 1] + df["beta_hat"][i - 1]
-            alpha_i = ld_1 * y_star_i + (1 - ld_1) * (df["alpha_hat"][i - 1] + df["beta_hat"][i - 1])
-            beta_i = ld_2 * (alpha_i - df["alpha_hat"][i - 1]) + (1 - ld_2) * df["beta_hat"][i - 1]
-            df.loc[i] = [
-                df["y"][i],
-                psi_i,
-                rho_i,
-                y_star_i,
-                alpha_i,
-                beta_i,
-                sigma_i,
-                error_i,
-            ]
-
-            # Checks: for algorithm debugging:
-            # future_errors = df["error"]
-            # S_T_median_error = 1.48 * future_errors.abs().median()  # must handle NaNs!
-            # resids = np.power(S_T_median_error, 2) * \
-            #                      np.nanmean((future_errors / S_T_median_error).apply(rho))
-            # print(np.sqrt(max(0.0, resids)))
+    def _holt_winters_smooth(self, ld_1: float, ld_2: float, ld_s: float) -> None:
+        """Run the Holt-Winters recursion from ``self.warm_up`` and write its columns into ``self.df``."""
+        df = self.df
+        columns = _holt_winters_recursion(df["y"].to_numpy(), self.warm_up, ld_1=ld_1, ld_2=ld_2, ld_s=ld_s)
+        # One write per column per fit; the "y" column, the column order and the index are untouched.
+        for name, values in columns.items():
+            df[name] = values