rustima 0.1.0__tar.gz → 0.2.0__tar.gz

{rustima-0.1.0 → rustima-0.2.0}/Cargo.lock

@@ -880,7 +880,7 @@ checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "rustima"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "approx",

{rustima-0.1.0 → rustima-0.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustima"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 rust-version = "1.83"
 description = "High-performance SARIMAX engine with PyO3 bindings"
@@ -27,7 +27,9 @@ statrs = "0.18"
 rayon = "1.10"
 
 # Python bindings
-pyo3 = { version = "0.28", features = ["auto-initialize"] }
+# auto-initialize 제거(2026-07-11): 크레이트 내 Python::with_gil 사용처 0 — 임베딩 불필요.
+# 켜두면 manylinux(정적 python) 휠 빌드가 실패해 PyPI 릴리스를 막는다.
+pyo3 = { version = "0.28" }
 numpy = "0.28"
 
 # Error handling

{rustima-0.1.0 → rustima-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustima
-Version: 0.1.0
+Version: 0.2.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Mathematics

{rustima-0.1.0 → rustima-0.2.0}/benches/bench_fit.rs

@@ -1,6 +1,6 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use sarimax_rs::optimizer;
-use sarimax_rs::types::{SarimaxConfig, SarimaxOrder, Trend};
+use rustima::optimizer;
+use rustima::types::{SarimaxConfig, SarimaxOrder, Trend};
 
 /// Deterministic LCG data generator (fixed seed → reproducible data).
 fn generate_ar1_data(n: usize, phi: f64, seed: u64) -> Vec<f64> {

{rustima-0.1.0 → rustima-0.2.0}/benches/bench_kalman.rs

@@ -1,9 +1,9 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use sarimax_rs::initialization::KalmanInit;
-use sarimax_rs::kalman::kalman_loglike;
-use sarimax_rs::params::SarimaxParams;
-use sarimax_rs::state_space::StateSpace;
-use sarimax_rs::types::{SarimaxConfig, SarimaxOrder, Trend};
+use rustima::initialization::KalmanInit;
+use rustima::kalman::kalman_loglike;
+use rustima::params::SarimaxParams;
+use rustima::state_space::StateSpace;
+use rustima::types::{SarimaxConfig, SarimaxOrder, Trend};
 
 /// Deterministic LCG data generator (fixed seed → reproducible data).
 fn generate_ar1_data(n: usize, phi: f64, seed: u64) -> Vec<f64> {

rustima-0.2.0/lbfgsb_c/License.txt

@@ -0,0 +1,60 @@
+L-BFGS-B License
+================
+
+This directory contains a C translation of L-BFGS-B (version 3.0):
+
+  - Original FORTRAN L-BFGS-B: Ciyou Zhu, Richard Byrd, Jorge Nocedal,
+    Jose Luis Morales (Northwestern University).
+  - C translation (L-BFGS-B-C): Stephen Becker, 2015
+    (stephen.becker@colorado.edu), https://github.com/stephenbeckr/L-BFGS-B-C
+
+L-BFGS-B is released under the "New BSD License" (aka "Modified BSD License"
+or "3-clause license").
+
+New BSD License
+---------------
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+Citation request (from the original authors)
+--------------------------------------------
+
+The authors of L-BFGS-B expect that all publications describing work using
+this software, or all commercial products using it, quote at least one of
+the references below:
+
+  R. H. Byrd, P. Lu and J. Nocedal. A Limited Memory Algorithm for Bound
+  Constrained Optimization (1995), SIAM Journal on Scientific and
+  Statistical Computing, 16, 5, pp. 1190-1208.
+
+  C. Zhu, R. H. Byrd and J. Nocedal. Algorithm 778: L-BFGS-B, FORTRAN
+  routines for large scale bound constrained optimization (1997), ACM
+  Transactions on Mathematical Software, 23, 4, pp. 550-560.
+
+  J.L. Morales and J. Nocedal. Remark on "Algorithm 778: L-BFGS-B, FORTRAN
+  routines for large scale bound constrained optimization" (2011), ACM
+  Transactions on Mathematical Software, 38, 1.

{rustima-0.1.0 → rustima-0.2.0}/lbfgsb_c/lbfgsb.h

@@ -5,6 +5,12 @@
 #ifndef lbfgsb_h
 #define lbfgsb_h
 
+/* MSVC's C mode has no C11 _Thread_local keyword — map to its equivalent
+ * so Windows wheel builds compile. gcc/clang paths are unaffected. */
+#if defined(_MSC_VER) && !defined(__clang__)
+#define _Thread_local __declspec(thread)
+#endif
+
 
 
  /* Force 64-bit integers on all platforms (including Windows LLP64

{rustima-0.1.0 → rustima-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rustima"
-version = "0.1.0"
+version = "0.2.0"
 requires-python = ">=3.10"
 description = "High-performance SARIMAX (Seasonal ARIMA with eXogenous regressors) engine in Rust with statsmodels-compatible Python API"
 readme = "README.md"
@@ -38,6 +38,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Rust",
     "Topic :: Scientific/Engineering",
     "Topic :: Scientific/Engineering :: Mathematics",
@@ -72,7 +73,14 @@ notebook = [
 features = ["pyo3/extension-module"]
 module-name = "rustima"
 python-source = "python"
-include = ["LICENSE", "README.md"]
+include = ["LICENSE", "README.md", "lbfgsb_c/License.txt"]
+# sdist 위생: 벤치마크·논문 자산은 배포에서 제외 (개발용은 저장소에 유지)
+exclude = [
+    "benchmarks/**",
+    "docs/ver5.2/**",
+    "*.ipynb",
+    "*.csv",
+]
 
 [tool.pytest.ini_options]
 testpaths = ["python_tests"]

{rustima-0.1.0 → rustima-0.2.0}/python/rustima/__init__.py

@@ -30,16 +30,21 @@ if "RAYON_NUM_THREADS" not in _os.environ:
 from .rustima import *  # noqa: F401,F403
 
 # High-level Python API
-from .model import SARIMAXModel, SARIMAXResult, ForecastResult, PredictionResult
+from .model import (
+    SARIMAXModel, SARIMAXResult, ForecastResult, PredictionResult,
+    RollingForecastResult,
+)
 from .auto import auto_arima, AutoARIMAResult
 
 __all__ = [
     # Rust low-level functions
     "version",
-    "sarimax_fit", "sarimax_forecast", "sarimax_loglike", "sarimax_residuals",
+    "sarimax_fit", "sarimax_forecast", "sarimax_rolling_forecast",
+    "sarimax_loglike", "sarimax_residuals",
     "sarimax_batch_fit", "sarimax_batch_forecast", "sarimax_batch_loglike",
     "sarimax_grid_search", "sarimax_inference", "sarimax_diagnostics",
     # High-level Python API
     "SARIMAXModel", "SARIMAXResult", "ForecastResult", "PredictionResult",
+    "RollingForecastResult",
     "auto_arima", "AutoARIMAResult",
 ]

{rustima-0.1.0 → rustima-0.2.0}/python/rustima/model.py

@@ -636,6 +636,67 @@ class SARIMAXModel:
         self._fit_result = SARIMAXResult(self, result_dict)
         return self._fit_result
 
+    def filter(self, params):
+        """Construct a result at the given parameters WITHOUT fitting.
+
+        Runs a single Kalman-filter pass to evaluate the log-likelihood at
+        ``params`` and returns a :class:`SARIMAXResult` bound to this model.
+        No optimization is performed (statsmodels ``.filter(params)``
+        semantics). This is the building block for walk-forward rolling
+        (:meth:`SARIMAXResult.extend`) and for reconstructing a result from
+        serialized parameters without re-estimation.
+
+        Parameters
+        ----------
+        params : array_like
+            Full parameter vector in statsmodels layout
+            ``[trend | exog | ar | ma | sar | sma | sigma2]``.
+
+        Returns
+        -------
+        SARIMAXResult
+            ``result.method == "filter"``, ``converged == True``.
+        """
+        params = np.ascontiguousarray(np.asarray(params, dtype=np.float64).ravel())
+        expected_names = _generate_param_names(
+            self.order, self.seasonal_order, self.n_exog, trend=self.trend
+        )
+        if len(params) != len(expected_names):
+            raise ValueError(
+                f"params length {len(params)} != expected {len(expected_names)} "
+                f"for this specification: {expected_names}"
+            )
+
+        llf = float(
+            rustima.sarimax_loglike(
+                self.endog,
+                self.order,
+                self.seasonal_order,
+                params,
+                **self._model_kwargs(),
+            )
+        )
+
+        k = len(params)
+        _p, d, _q = self.order
+        _P, D, _Q, s = self.seasonal_order
+        n_eff = self.nobs - ((d + s * D) if self.simple_differencing else 0)
+        sigma2_idx = expected_names.index("sigma2")
+
+        result_dict = {
+            "params": params,
+            "loglike": llf,
+            "scale": float(params[sigma2_idx]),
+            "aic": -2.0 * llf + 2.0 * k,
+            "bic": -2.0 * llf + k * np.log(n_eff),
+            "n_obs": n_eff,
+            "converged": True,
+            "method": "filter",
+            "n_iter": 0,
+            "n_params": k,
+        }
+        return SARIMAXResult(self, result_dict)
+
 
 class SARIMAXResult:
     """Fit result wrapper (statsmodels ResultsWrapper compatible).
@@ -948,6 +1009,134 @@ class SARIMAXResult:
         """Alias for forecast() (statsmodels compatibility)."""
         return self.forecast(steps=steps, alpha=alpha, exog=exog)
 
+    def rolling_forecast(self, start, step=1, horizon=1, alpha=0.05):
+        """Single-pass rolling-origin h-step forecasts (fixed parameters).
+
+        One Kalman-filter pass over the full sample captures the predicted
+        state at every origin ``start, start+step, ...``; each origin's
+        h-step forecast is propagated from its snapshot. Total cost
+        O(T + N·horizon) — versus O(N·T) for an :meth:`extend` chain — while
+        producing numerically identical forecasts (Markov property).
+
+        Origins run while ``origin <= nobs - 1``; models with exog are
+        capped at ``nobs - horizon`` (in-sample exog must cover each
+        forecast window). ``simple_differencing=True`` is not supported yet.
+
+        Parameters
+        ----------
+        start : int
+            First forecast origin (number of observations consumed).
+        step : int
+            Origin spacing (e.g. 24 for daily rolling on hourly data).
+        horizon : int
+            Forecast steps per origin.
+        alpha : float
+            CI significance level.
+
+        Returns
+        -------
+        RollingForecastResult
+            ``origins`` (N,), ``predicted_mean``/``variance``/``ci_lower``/
+            ``ci_upper`` (N, horizon).
+        """
+        result = rustima.sarimax_rolling_forecast(
+            self.model.endog,
+            self.model.order,
+            self.model.seasonal_order,
+            self.params,
+            start=start,
+            step=step,
+            horizon=horizon,
+            alpha=alpha,
+            **self._rs_kwargs(),
+        )
+        return RollingForecastResult(result, alpha=alpha)
+
+    def extend(self, endog, exog=None):
+        """Extend the sample with new observations, keeping parameters fixed.
+
+        Returns a new :class:`SARIMAXResult` whose sample is the original
+        history plus ``endog``, filtered at the SAME parameters — no
+        re-estimation. Subsequent :meth:`forecast` calls start after the new
+        observations, enabling walk-forward rolling::
+
+            res = SARIMAXModel(train, order, seasonal_order).fit()
+            for block in blocks:
+                fc = res.get_forecast(steps=len(block)).predicted_mean
+                res = res.extend(block)
+
+        Implementation note
+        -------------------
+        rustima refilters the FULL extended history with the fixed parameters
+        (statsmodels ``append(refit=False)`` semantics). Because the Kalman
+        filter is Markovian, post-extension forecasts are numerically
+        equivalent to statsmodels' state-carry-over ``extend``. Unlike
+        statsmodels ``extend``, ``llf``/``aic``/``bic`` here cover the full
+        extended sample rather than only the new observations.
+
+        Parameters
+        ----------
+        endog : array_like
+            New observations that come AFTER the current sample.
+        exog : array_like, optional
+            Exogenous values for the new observations, shape
+            ``(len(endog), n_exog)``. Required iff the model has exog.
+
+        Returns
+        -------
+        SARIMAXResult
+        """
+        new = np.asarray(endog, dtype=np.float64).ravel()
+        if new.size == 0:
+            raise ValueError("endog is empty: extend() requires at least one new observation")
+        if not np.isfinite(new).all():
+            raise ValueError("endog contains NaN or Inf values")
+
+        m = self.model
+        if m.exog is not None:
+            if exog is None:
+                raise ValueError(
+                    "model was built with exog; extend() requires exog for the new observations"
+                )
+            ex = np.asarray(exog, dtype=np.float64)
+            if ex.ndim == 1:
+                ex = ex.reshape(-1, 1)
+            if ex.shape != (new.size, m.n_exog):
+                raise ValueError(
+                    f"exog shape {ex.shape} != expected ({new.size}, {m.n_exog})"
+                )
+            full_exog = np.vstack([m.exog, ex])
+        else:
+            if exog is not None:
+                raise ValueError(
+                    "model was built without exog; unexpected exog passed to extend()"
+                )
+            full_exog = None
+
+        new_model = SARIMAXModel(
+            np.concatenate([m.endog, new]),
+            order=m.order,
+            seasonal_order=m.seasonal_order,
+            exog=full_exog,
+            trend=m.trend,
+            enforce_stationarity=m.enforce_stationarity,
+            enforce_invertibility=m.enforce_invertibility,
+            simple_differencing=m.simple_differencing,
+        )
+        return new_model.filter(self.params)
+
+    def append(self, endog, exog=None, refit=False, **fit_kwargs):
+        """Append new observations (statsmodels-compatible convenience).
+
+        ``refit=False`` (default) is an alias for :meth:`extend` — parameters
+        stay fixed. ``refit=True`` re-estimates parameters on the extended
+        sample via :meth:`SARIMAXModel.fit`.
+        """
+        extended = self.extend(endog, exog=exog)
+        if refit:
+            return extended.model.fit(**fit_kwargs)
+        return extended
+
     @property
     def resid(self):
         """Standardized residuals."""
@@ -1249,6 +1438,42 @@ class ForecastResult:
         })
 
 
+class RollingForecastResult:
+    """Rolling-origin forecast result (one row per origin).
+
+    Attributes
+    ----------
+    origins : np.ndarray, shape (N,)
+        Forecast origins (observations consumed before each forecast).
+    predicted_mean : np.ndarray, shape (N, horizon)
+    variance : np.ndarray, shape (N, horizon)
+    ci_lower : np.ndarray, shape (N, horizon)
+    ci_upper : np.ndarray, shape (N, horizon)
+    """
+
+    def __init__(self, result_dict, alpha=0.05):
+        self.origins = np.asarray(result_dict["origins"], dtype=np.int64)
+        self.predicted_mean = np.asarray(result_dict["mean"], dtype=np.float64)
+        self.variance = np.asarray(result_dict["variance"], dtype=np.float64)
+        self.ci_lower = np.asarray(result_dict["ci_lower"], dtype=np.float64)
+        self.ci_upper = np.asarray(result_dict["ci_upper"], dtype=np.float64)
+        self._alpha = alpha
+
+    def to_dataframe(self):
+        """Long-format Polars DataFrame: origin, step, mean, variance, ci."""
+        import polars as pl
+
+        n_origins, horizon = self.predicted_mean.shape
+        return pl.DataFrame({
+            "origin": np.repeat(self.origins, horizon),
+            "step": np.tile(np.arange(1, horizon + 1), n_origins),
+            "mean": self.predicted_mean.ravel(),
+            "variance": self.variance.ravel(),
+            "ci_lower": self.ci_lower.ravel(),
+            "ci_upper": self.ci_upper.ravel(),
+        })
+
+
 class PredictionResult:
     """In-sample (and optionally out-of-sample) prediction result.
 

{rustima-0.1.0 → rustima-0.2.0}/python_tests/conftest.py

@@ -58,10 +58,14 @@ def converged_models(models):
 
 
 def expected_k_params(order, seasonal, n_exog=0):
-    """Expected number of estimated params (concentrated scale)."""
+    """Expected number of estimated params.
+
+    Non-concentrated layout (current default): [exog|ar|ma|sar|sma|sigma2],
+    so sigma2 adds +1.
+    """
     p, _d, q = order
     P, _D, Q, _s = seasonal
-    return p + q + P + Q + n_exog
+    return p + q + P + Q + n_exog + 1
 
 
 # ---------------------------------------------------------------------------

{rustima-0.1.0 → rustima-0.2.0}/python_tests/generate_fixtures.py

@@ -83,8 +83,14 @@ def fit_and_extract(y, order, seasonal_order=(0, 0, 0, 0)):
     # Also compute loglike using model.loglike() to double-check
     loglike_check = model.loglike(res.params)
 
+    # The fit above concentrates the scale out (concentrate_scale=True), so
+    # res.params omits sigma2.  The current rustima engine / SARIMAXModel use
+    # the full non-concentrated layout [trend|exog|ar|ma|sar|sma|sigma2], so we
+    # append sigma2 (= res.scale, always the LAST parameter for trend='n').
+    params = res.params.tolist() + [float(res.scale)]
+
     return {
-        "params": res.params.tolist(),
+        "params": params,
         "loglike": float(loglike),
         "loglike_check": float(loglike_check),
         "scale": float(res.scale),
@@ -200,17 +206,37 @@ def main():
             concentrate_scale=True,
         )
         res = model.fit(disp=False)
-        fcast = res.get_forecast(steps=10)
+
+        # The fit concentrates the scale out for speed, so res.params omits
+        # sigma2.  rustima (and statsmodels' default) use the full
+        # NON-concentrated layout [ar|ma|sar|sma|sigma2].  To make the fixture
+        # convention unambiguous, refilter a non-concentrated model at the
+        # full parameter vector and harvest the user-facing outputs from it —
+        # no post-hoc scale adjustments.
+        sigma2 = float(res.scale)
+        full_params = np.asarray(res.params.tolist() + [sigma2])
+        model_nc = sm.tsa.SARIMAX(
+            data,
+            order=order,
+            seasonal_order=seasonal_order,
+            trend="n",
+            enforce_stationarity=False,
+            enforce_invertibility=False,
+            concentrate_scale=False,
+        )
+        res_nc = model_nc.filter(full_params)
+        fcast = res_nc.get_forecast(steps=10)
         ci = fcast.conf_int(alpha=0.05)
+        resid = res_nc.filter_results.standardized_forecasts_error[0]
 
-        # Standardized residuals
-        resid = res.filter_results.standardized_forecasts_error[0]
+        ci_lo = ci[:, 0] if isinstance(ci, np.ndarray) else ci.iloc[:, 0].to_numpy()
+        ci_hi = ci[:, 1] if isinstance(ci, np.ndarray) else ci.iloc[:, 1].to_numpy()
 
         forecast_fixtures[name] = {
-            "params": res.params.tolist(),
+            "params": full_params.tolist(),
             "forecast_mean": fcast.predicted_mean.tolist(),
-            "forecast_ci_lower": ci[:, 0].tolist() if isinstance(ci, np.ndarray) else ci.iloc[:, 0].tolist(),
-            "forecast_ci_upper": ci[:, 1].tolist() if isinstance(ci, np.ndarray) else ci.iloc[:, 1].tolist(),
+            "forecast_ci_lower": ci_lo.tolist(),
+            "forecast_ci_upper": ci_hi.tolist(),
             "standardized_residuals": resid.tolist(),
         }
 

{rustima-0.1.0 → rustima-0.2.0}/python_tests/generate_matrix_fixtures.py

@@ -244,8 +244,12 @@ def fit_oracle(y, order, seasonal, exog=None, future_exog=None):
             else:
                 forecast_var = list(forecast_var)
 
+            # Fit concentrates the scale out (concentrate_scale=True), so
+            # res.params omits sigma2.  The current rustima engine uses the full
+            # non-concentrated layout [exog|ar|ma|sar|sma|sigma2], so append
+            # sigma2 (= res.scale) as the trailing parameter.
             return {
-                "params": res.params.tolist(),
+                "params": res.params.tolist() + [float(res.scale)],
                 "loglike": float(res.llf),
                 "aic": float(res.aic),
                 "bic": float(res.bic),

{rustima-0.1.0 → rustima-0.2.0}/python_tests/test_exog.py

@@ -51,8 +51,8 @@ class TestExogLoglike:
     def test_loglike_with_single_exog(self):
         """loglike with 1 exog variable returns finite value."""
         y, exog = _generate_arx_data()
-        # params: [exog_beta(1), ar(1)]
-        params = np.array([2.0, 0.5], dtype=np.float64)
+        # params: [exog_beta(1), ar(1), sigma2]
+        params = np.array([2.0, 0.5, 0.25], dtype=np.float64)
         ll = rustima.sarimax_loglike(
             y, (1, 0, 0), (0, 0, 0, 0), params, exog=exog
         )
@@ -61,8 +61,8 @@ class TestExogLoglike:
     def test_loglike_with_multi_exog(self):
         """loglike with multiple exog variables returns finite value."""
         y, X, _ = _generate_multi_exog_data(n_exog=3)
-        # params: [exog(3), ar(1)]
-        params = np.array([1.5, -0.8, 0.3, 0.5], dtype=np.float64)
+        # params: [exog(3), ar(1), sigma2]
+        params = np.array([1.5, -0.8, 0.3, 0.5, 0.25], dtype=np.float64)
         ll = rustima.sarimax_loglike(
             y, (1, 0, 0), (0, 0, 0, 0), params, exog=X
         )
@@ -71,7 +71,7 @@ class TestExogLoglike:
     def test_loglike_without_exog_unchanged(self):
         """loglike without exog is unchanged (backward compatible)."""
         y, _ = _generate_arx_data()
-        params = np.array([0.5], dtype=np.float64)
+        params = np.array([0.5, 1.0], dtype=np.float64)
         ll = rustima.sarimax_loglike(
             y, (1, 0, 0), (0, 0, 0, 0), params
         )
@@ -80,13 +80,15 @@ class TestExogLoglike:
     def test_loglike_exog_improves_fit(self):
         """With true exog, loglike should be better than without."""
         y, exog = _generate_arx_data(beta=2.0)
-        # With exog (true model)
-        params_with = np.array([2.0, 0.5], dtype=np.float64)
+        # With exog; sigma2 ~ innovation variance of the SARIMAX
+        # regression-with-AR(1)-errors form (~1.25 for this ARX process)
+        params_with = np.array([2.0, 0.5, 1.25], dtype=np.float64)
         ll_with = rustima.sarimax_loglike(
             y, (1, 0, 0), (0, 0, 0, 0), params_with, exog=exog
         )
-        # Without exog (misspecified)
-        params_without = np.array([0.5], dtype=np.float64)
+        # Without exog (misspecified); sigma2 ~ residual variance of the
+        # misspecified model (var(beta*x + eps) = 4 + 0.25)
+        params_without = np.array([0.5, 4.25], dtype=np.float64)
         ll_without = rustima.sarimax_loglike(
             y, (1, 0, 0), (0, 0, 0, 0), params_without
         )
@@ -107,8 +109,8 @@ class TestExogFit:
             y, (1, 0, 0), (0, 0, 0, 0), exog=exog
         )
         assert result["converged"], "fit with exog should converge"
-        # params: [exog(1), ar(1)]
-        assert len(result["params"]) == 2
+        # params: [exog(1), ar(1), sigma2]
+        assert len(result["params"]) == 3
         assert np.isfinite(result["loglike"])
 
     def test_fit_recovers_exog_coeff(self):
@@ -132,8 +134,8 @@ class TestExogFit:
             enforce_stationarity=False, enforce_invertibility=False,
         )
         assert result["converged"]
-        # params: [exog(3), ar(1)] = 4
-        assert len(result["params"]) == 4
+        # params: [exog(3), ar(1), sigma2] = 5
+        assert len(result["params"]) == 5
         assert np.isfinite(result["loglike"])
 
     def test_fit_arma_with_exog(self):
@@ -144,8 +146,8 @@ class TestExogFit:
             enforce_stationarity=False, enforce_invertibility=False,
         )
         assert result["converged"]
-        # params: [exog(1), ar(1), ma(1)] = 3
-        assert len(result["params"]) == 3
+        # params: [exog(1), ar(1), ma(1), sigma2] = 4
+        assert len(result["params"]) == 4
 
 
 # ---------------------------------------------------------------------------
@@ -246,7 +248,7 @@ class TestExogBatch:
         for i, r in enumerate(results):
             assert "error" not in r, f"series {i} failed: {r.get('error')}"
             assert r["converged"], f"series {i} did not converge"
-            assert len(r["params"]) == 2  # [exog(1), ar(1)]
+            assert len(r["params"]) == 3  # [exog(1), ar(1), sigma2]
 
 
 # ---------------------------------------------------------------------------
@@ -281,6 +283,7 @@ class TestExogStatsmodelsComparison:
             y, (1, 0, 0), (0, 0, 0, 0),
             np.array(sm_params, dtype=np.float64),
             exog=exog,
+            concentrate_scale=True,
         )
 
         # Should be close (not exact due to initialization differences;