ssfortran 0.1.0__tar.gz

ssfortran-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+build/
+.venv/
+__pycache__/
+ref/
+PLAN.md
+private/
+data/seatbelts.csv
+data/wwwusage.csv
+data/mcycle.csv
+docs/reference/python/generated/

ssfortran-0.1.0/CMakeLists.txt

@@ -0,0 +1,56 @@
+# Shared library for the Python package (ssfortran) and other C callers.
+# The Fortran-only build and the test suite use fpm (fpm.toml); this build
+# compiles the same sources with -fPIC into libstatespace, with the bundled
+# L-BFGS-B that fpm also uses.
+#
+#   cmake -S . -B build/cmake -G Ninja && cmake --build build/cmake
+#
+# Python wheels are built through scikit-build-core (pyproject.toml).
+cmake_minimum_required(VERSION 3.24)
+project(statespace VERSION 0.1.0 LANGUAGES Fortran)
+
+option(STATESPACE_OPENMP "Build fit_many with OpenMP" ON)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+# L-BFGS-B, bundled in third_party/lbfgsb (see its README), so the build needs
+# no network access.
+set(LBFGSB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/third_party/lbfgsb/src)
+file(GLOB STATESPACE_SOURCES CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src/*.f90)
+set(LBFGSB_SOURCES
+  ${LBFGSB_DIR}/lbfgsb_kinds_module.F90
+  ${LBFGSB_DIR}/lbfgsb_blas_module.F90
+  ${LBFGSB_DIR}/lbfgsb_linpack_module.f90
+  ${LBFGSB_DIR}/lbfgsb.f90
+)
+
+add_library(statespace SHARED ${STATESPACE_SOURCES} ${LBFGSB_SOURCES})
+set_target_properties(statespace PROPERTIES
+  POSITION_INDEPENDENT_CODE ON
+  Fortran_MODULE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/modules
+)
+if(CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+  target_compile_options(statespace PRIVATE
+    $<$<CONFIG:Release>:-O3 -funroll-loops>
+    -ffree-line-length-none
+  )
+endif()
+
+find_package(LAPACK REQUIRED)
+target_link_libraries(statespace PRIVATE ${LAPACK_LIBRARIES})
+
+if(STATESPACE_OPENMP)
+  find_package(OpenMP COMPONENTS Fortran)
+  if(OpenMP_Fortran_FOUND)
+    target_link_libraries(statespace PRIVATE OpenMP::OpenMP_Fortran)
+  endif()
+endif()
+
+# The wheel puts the library inside the Python package.
+if(SKBUILD)
+  install(TARGETS statespace LIBRARY DESTINATION ssfortran RUNTIME DESTINATION ssfortran)
+else()
+  install(TARGETS statespace)
+endif()

ssfortran-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zelpuz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ssfortran-0.1.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: ssfortran
+Version: 0.1.0
+Summary: Linear Gaussian state space models (Durbin and Koopman, Part I) with a Fortran core
+Keywords: state space,kalman filter,kalman smoother,time series,structural time series,unobserved components,durbin koopman
+Author: zelpuz
+License-Expression: MIT
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES.md
+License-File: third_party/lbfgsb/License.txt
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Fortran
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Project-URL: Source, https://github.com/Zelpuz/statespace
+Project-URL: Issues, https://github.com/Zelpuz/statespace/issues
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Description-Content-Type: text/markdown
+
+# statespace
+
+Linear Gaussian state space models, following Part I of Durbin and Koopman,
+*Time Series Analysis by State Space Methods* (2nd ed., 2012). The core is a Fortran
+library; `ssfortran` is its Python package.
+
+- **Filtering and smoothing:**
+  - the Kalman filter with a steady-state shortcut
+  - exact diffuse initialization, in both univariate and multivariate forms
+  - univariate treatment, including correlated and time-varying H
+  - state, disturbance, fast, classical, two-filter, fixed-point and fixed-lag smoothers
+  - augmented and square-root filters
+  - collapsing large observation vectors, and linear restrictions
+- **Likelihood and estimation:**
+  - exact, diffuse, concentrated and marginal log likelihoods
+  - maximum likelihood with L-BFGS-B, using DK's analytic score where it applies and
+    numerical derivatives elsewhere
+  - EM for variance parameters
+  - standard errors, and the effect of parameter estimation on the smoothed states
+- **Simulation, forecasting and diagnostics:** simulation smoothers, forecasts,
+  standardized and auxiliary residuals, and residual tests.
+- **Built-in models (DK ch. 3):** irregular, level, trend, seasonal (dummy,
+  trigonometric, Harrison–Stevens), cycle, regression and intervention effects, ARIMA,
+  continuous-time components and splines. Components apply to one series or several
+  (SUTSE), and can load on common signals.
+
+The documentation (user guide, examples, design notes, and Python, Fortran and C
+references) builds with `make -C docs html`; see [docs/install.rst](docs/install.rst).
+The illustrations of DK chapter 8 are reproduced in `example/`. Differences from
+statsmodels' `tsa.statespace` are listed in
+[docs/statsmodels_differences.md](docs/statsmodels_differences.md).
+
+## Fortran
+
+The library builds with [fpm](https://fpm.fortran-lang.org) and needs gfortran,
+LAPACK and BLAS.
+
+```sh
+fpm test --profile release                              # the test suite
+fpm run --profile release --example nile_mle            # a model defined in Fortran
+fpm run --profile release --example dk_8_2_seatbelt     # needs data/fetch_dk_data.py first
+```
+
+Models are defined by extending `ssm_model_t` (see `example/nile_mle.f90`), or
+assembled from components with `structural_model` (see `example/dk_8_2_seatbelt.f90`).
+`fit_many` fits independent models in parallel when built with
+`--flag -fopenmp --link-flag -fopenmp`.
+
+## Python
+
+`pip` builds the shared library with CMake through scikit-build-core. It needs
+gfortran, LAPACK and BLAS installed.
+
+```sh
+pip install .              # or: pip install .[test] && pytest
+```
+
+```python
+import numpy as np
+import ssfortran as ss
+
+y = np.loadtxt("data/nile.csv", delimiter=",", skiprows=1)[:, 1]
+
+# Built-in components
+mod = ss.StructuralModel(y, [ss.Irregular(), ss.Level()])
+res = mod.fit()
+print(res.summary())
+smoothed = res.smooth().smoothed_state
+
+# Matrix-level: fill the system matrices yourself
+rep = ss.Representation(y, k_states=1)
+rep["design"] = [[1.0]]; rep["transition"] = [[1.0]]; rep["selection"] = [[1.0]]
+rep["obs_cov"] = [[15099.0]]; rep["state_cov"] = [[1469.1]]
+rep.initialize_diffuse()
+print(rep.loglike())
+```
+
+Fitting results have `summary()` (estimates with z-tests and intervals, fit
+statistics, residual tests), `fittedvalues`, `resid`, `get_forecast(steps)` with
+`conf_int()`, `components()` and `estimation_bias()`. A `Representation` also offers:
+- the other smoothers of DK ch. 4: fast, classical, two-filter, Whittle, fixed-point,
+  fixed-lag and updating
+- smoothed covariances between periods, and filtering and smoothing weights
+- the square-root and augmented filters (with the marginal likelihood)
+- EM, collapsing, and linear state restrictions
+- auxiliary residuals, de Jong–Penzer statistics, least squares residuals and R²_D
+- the mean-correction and de Jong–Shephard simulation smoothers
+
+A model with parameters can be defined in three ways:
+
+| | How | Speed |
+|---|---|---|
+| `StructuralModel` | built-in components | all in Fortran; works with `fit_many` |
+| `MappedModel` | declare which matrix entries each parameter sets | all in Fortran; works with `fit_many` |
+| `MLEModel` | subclass and write `update(params)`, as in statsmodels | calls Python for each likelihood evaluation |
+
+For the timing comparison with statsmodels from Python, run
+`bench/bench_python.py`. It shows 2–8× speedups for single models, and 36× for 1000
+series with `fit_many`. `example/bench.f90` and `bench/bench_statsmodels.py` compare
+the Fortran core directly.
+
+To develop without installing:
+
+```sh
+cmake -S . -B build/cmake -G Ninja && cmake --build build/cmake
+pytest            # uses python/src and build/cmake (pyproject.toml)
+```
+
+## License
+
+MIT (see [LICENSE](LICENSE)); third-party notices are in
+[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md), and citations in
+[docs/references.md](docs/references.md).

ssfortran-0.1.0/README.md

@@ -0,0 +1,113 @@
+# statespace
+
+Linear Gaussian state space models, following Part I of Durbin and Koopman,
+*Time Series Analysis by State Space Methods* (2nd ed., 2012). The core is a Fortran
+library; `ssfortran` is its Python package.
+
+- **Filtering and smoothing:**
+  - the Kalman filter with a steady-state shortcut
+  - exact diffuse initialization, in both univariate and multivariate forms
+  - univariate treatment, including correlated and time-varying H
+  - state, disturbance, fast, classical, two-filter, fixed-point and fixed-lag smoothers
+  - augmented and square-root filters
+  - collapsing large observation vectors, and linear restrictions
+- **Likelihood and estimation:**
+  - exact, diffuse, concentrated and marginal log likelihoods
+  - maximum likelihood with L-BFGS-B, using DK's analytic score where it applies and
+    numerical derivatives elsewhere
+  - EM for variance parameters
+  - standard errors, and the effect of parameter estimation on the smoothed states
+- **Simulation, forecasting and diagnostics:** simulation smoothers, forecasts,
+  standardized and auxiliary residuals, and residual tests.
+- **Built-in models (DK ch. 3):** irregular, level, trend, seasonal (dummy,
+  trigonometric, Harrison–Stevens), cycle, regression and intervention effects, ARIMA,
+  continuous-time components and splines. Components apply to one series or several
+  (SUTSE), and can load on common signals.
+
+The documentation (user guide, examples, design notes, and Python, Fortran and C
+references) builds with `make -C docs html`; see [docs/install.rst](docs/install.rst).
+The illustrations of DK chapter 8 are reproduced in `example/`. Differences from
+statsmodels' `tsa.statespace` are listed in
+[docs/statsmodels_differences.md](docs/statsmodels_differences.md).
+
+## Fortran
+
+The library builds with [fpm](https://fpm.fortran-lang.org) and needs gfortran,
+LAPACK and BLAS.
+
+```sh
+fpm test --profile release                              # the test suite
+fpm run --profile release --example nile_mle            # a model defined in Fortran
+fpm run --profile release --example dk_8_2_seatbelt     # needs data/fetch_dk_data.py first
+```
+
+Models are defined by extending `ssm_model_t` (see `example/nile_mle.f90`), or
+assembled from components with `structural_model` (see `example/dk_8_2_seatbelt.f90`).
+`fit_many` fits independent models in parallel when built with
+`--flag -fopenmp --link-flag -fopenmp`.
+
+## Python
+
+`pip` builds the shared library with CMake through scikit-build-core. It needs
+gfortran, LAPACK and BLAS installed.
+
+```sh
+pip install .              # or: pip install .[test] && pytest
+```
+
+```python
+import numpy as np
+import ssfortran as ss
+
+y = np.loadtxt("data/nile.csv", delimiter=",", skiprows=1)[:, 1]
+
+# Built-in components
+mod = ss.StructuralModel(y, [ss.Irregular(), ss.Level()])
+res = mod.fit()
+print(res.summary())
+smoothed = res.smooth().smoothed_state
+
+# Matrix-level: fill the system matrices yourself
+rep = ss.Representation(y, k_states=1)
+rep["design"] = [[1.0]]; rep["transition"] = [[1.0]]; rep["selection"] = [[1.0]]
+rep["obs_cov"] = [[15099.0]]; rep["state_cov"] = [[1469.1]]
+rep.initialize_diffuse()
+print(rep.loglike())
+```
+
+Fitting results have `summary()` (estimates with z-tests and intervals, fit
+statistics, residual tests), `fittedvalues`, `resid`, `get_forecast(steps)` with
+`conf_int()`, `components()` and `estimation_bias()`. A `Representation` also offers:
+- the other smoothers of DK ch. 4: fast, classical, two-filter, Whittle, fixed-point,
+  fixed-lag and updating
+- smoothed covariances between periods, and filtering and smoothing weights
+- the square-root and augmented filters (with the marginal likelihood)
+- EM, collapsing, and linear state restrictions
+- auxiliary residuals, de Jong–Penzer statistics, least squares residuals and R²_D
+- the mean-correction and de Jong–Shephard simulation smoothers
+
+A model with parameters can be defined in three ways:
+
+| | How | Speed |
+|---|---|---|
+| `StructuralModel` | built-in components | all in Fortran; works with `fit_many` |
+| `MappedModel` | declare which matrix entries each parameter sets | all in Fortran; works with `fit_many` |
+| `MLEModel` | subclass and write `update(params)`, as in statsmodels | calls Python for each likelihood evaluation |
+
+For the timing comparison with statsmodels from Python, run
+`bench/bench_python.py`. It shows 2–8× speedups for single models, and 36× for 1000
+series with `fit_many`. `example/bench.f90` and `bench/bench_statsmodels.py` compare
+the Fortran core directly.
+
+To develop without installing:
+
+```sh
+cmake -S . -B build/cmake -G Ninja && cmake --build build/cmake
+pytest            # uses python/src and build/cmake (pyproject.toml)
+```
+
+## License
+
+MIT (see [LICENSE](LICENSE)); third-party notices are in
+[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md), and citations in
+[docs/references.md](docs/references.md).

ssfortran-0.1.0/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,93 @@
+# Third-party notices
+
+This library is released under the MIT License (see `LICENSE`). It follows
+Durbin and Koopman, *Time Series Analysis by State Space Methods* (2nd ed., 2012), and
+the other papers cited in the source. Its code was written from those publications.
+
+## statsmodels
+
+We use statsmodels (`statsmodels.tsa.statespace`) as a reference:
+
+- Some conventions follow it on purpose: output layout, diffuse tolerances, the
+  Monahan stationarity transform, optimizer defaults and AIC/BIC.
+- The test fixtures in `test/fixtures/` are statsmodels output, generated by
+  `test/fixtures/make_fixtures.py`.
+
+statsmodels is not part of the library and is not required to build or use it. This
+project is not affiliated with or endorsed by the statsmodels developers. Its license:
+
+```
+Copyright (C) 2006, Jonathan E. Taylor
+All rights reserved.
+
+Copyright (c) 2006-2008 Scipy Developers.
+All rights reserved.
+
+Copyright (c) 2009-2018 statsmodels Developers.
+All rights reserved.
+
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. 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.
+  c. Neither the name of statsmodels 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 STATSMODELS 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.
+```
+
+## L-BFGS-B (bundled)
+
+`third_party/lbfgsb/` holds the Fortran sources of
+[jacobwilliams/lbfgsb](https://github.com/jacobwilliams/lbfgsb), unmodified: L-BFGS-B
+3.0 by Ciyou Zhu, Richard Byrd, Peihuang Lu, Jorge Nocedal and Jose Luis Morales,
+modernized by Jacob Williams. It is released under the BSD-3-Clause ("New BSD")
+license; the text distributed with it is `third_party/lbfgsb/License.txt`, and
+`third_party/lbfgsb/README.md` records the upstream commit. It is compiled into the
+library and into every wheel.
+
+## Build dependencies
+
+These are not copied into this repository.
+
+| Package | Use | License |
+|---|---|---|
+| [test-drive](https://github.com/fortran-lang/test-drive) | Tests only (fpm downloads it) | MIT or Apache-2.0 |
+| LAPACK, BLAS (system libraries, e.g. Reference LAPACK or OpenBLAS) | Linear algebra | BSD-3-Clause (modified BSD) |
+
+## Libraries in the binary wheels
+
+The binary Python wheels are built by `cibuildwheel`, and `auditwheel` copies these
+shared libraries into `ssfortran.libs/`. Their licenses apply to those copies.
+
+| Library | License |
+|---|---|
+| OpenBLAS (BLAS and LAPACK) | BSD-3-Clause |
+| libgfortran, libquadmath, libgomp (GCC runtime) | GPL-3.0 with the GCC Runtime Library Exception 3.1, which permits distribution with programs compiled by GCC under any license |
+
+## Citations
+
+[`docs/references.md`](docs/references.md) cites the methods, data and software,
+including the citations these projects ask for.
+
+## Data
+
+See `data/README.md` for the source of each dataset and why some are downloaded
+rather than committed.

ssfortran-0.1.0/fpm.toml

@@ -0,0 +1,27 @@
+name = "statespace"
+version = "0.1.0"
+license = "MIT"
+author = "zelpuz"
+maintainer = "td.edwards@yahoo.com"
+copyright = "Copyright 2026, zelpuz"
+[build]
+auto-executables = true
+auto-tests = true
+auto-examples = true
+module-naming = false
+link = ["lapack", "blas"]
+[install]
+library = false
+[fortran]
+implicit-typing = false
+implicit-external = false
+source-form = "free"
+
+[dependencies]
+# Modern Fortran port of L-BFGS-B 3.0 (Nocedal & Morales), BSD-3, bundled in
+# third_party/lbfgsb at commit ce1a9322 (see its README).
+lbfgsb.path = "third_party/lbfgsb"
+
+[dev-dependencies]
+test-drive.git = "https://github.com/fortran-lang/test-drive"
+test-drive.rev = "c506771aefd594e7e372240a8027b3fd06d61264"  # v0.6.1

ssfortran-0.1.0/pyproject.toml

@@ -0,0 +1,77 @@
+[build-system]
+requires = ["scikit-build-core>=1.1"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "ssfortran"
+dynamic = ["version"]
+description = "Linear Gaussian state space models (Durbin and Koopman, Part I) with a Fortran core"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE", "THIRD_PARTY_NOTICES.md", "third_party/lbfgsb/License.txt"]
+requires-python = ">=3.10"
+dependencies = ["numpy"]
+authors = [{ name = "zelpuz" }]
+keywords = ["state space", "kalman filter", "kalman smoother", "time series",
+            "structural time series", "unobserved components", "durbin koopman"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Fortran",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+[project.urls]
+Source = "https://github.com/Zelpuz/statespace"
+Issues = "https://github.com/Zelpuz/statespace/issues"
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[[tool.dynamic-metadata]]
+# The single source of the version: the string in the C interface. fpm.toml,
+# CMakeLists.txt and docs/conf.py must agree (python/tests/test_version.py).
+provider = "scikit_build_core.metadata.regex"
+field = "version"
+input = "src/statespace_capi.f90"
+regex = 'character\(len=\*\), parameter :: version = "(?P<value>[^"]+)"'
+
+[tool.scikit-build]
+cmake.build-type = "Release"
+wheel.packages = ["python/src/ssfortran"]
+# The library is loaded with ctypes, so the wheel is Python-version
+# independent but platform specific.
+wheel.py-api = "py3"
+# The source distribution holds what the build needs. Tests, fixtures (11 MB),
+# docs, examples and data stay in the repository.
+sdist.exclude = ["build", ".venv", "ref", "private", ".github", "docs", "test",
+                 "python/tests", "python/conftest.py", "example", "bench", "data",
+                 "project.md", "PLAN.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["python/tests", "python/src/ssfortran"]
+# The source tree for development; to test an installed wheel instead, run
+# pytest -o pythonpath= python/tests
+pythonpath = ["python/src"]
+addopts = "--doctest-modules"
+doctest_optionflags = ["NORMALIZE_WHITESPACE", "ELLIPSIS"]
+
+[tool.cibuildwheel]
+# One wheel per platform serves every Python version (wheel.py-api above), so
+# build with a single interpreter.
+build = "cp312-*"
+skip = "*-musllinux_*"
+test-requires = ["pytest"]
+# Test the installed wheel against the repository's tests and fixtures.
+test-command = "pytest -q -o pythonpath= -o addopts= {project}/python/tests"
+
+[tool.cibuildwheel.linux]
+# gfortran matching the image's gcc-toolset, and OpenBLAS for BLAS and LAPACK.
+# auditwheel then copies libgfortran, libgomp and libopenblas into the wheel.
+before-all = [
+  "dnf install -y 'dnf-command(config-manager)'",
+  "dnf config-manager --set-enabled powertools || dnf config-manager --set-enabled crb",
+  "dnf install -y $(basename /opt/rh/gcc-toolset-*)-gcc-gfortran openblas-devel",
+]

ssfortran-0.1.0/python/src/ssfortran/__init__.py

@@ -0,0 +1,60 @@
+"""Linear Gaussian state space models with a Fortran core.
+
+``ssfortran`` covers Part I of Durbin and Koopman, *Time Series Analysis by
+State Space Methods* (2nd ed., 2012), cited as DK:
+
+* :class:`Representation`: the model's matrices and the algorithms of DK
+  ch. 4-7 (filtering, smoothing, likelihood, simulation, forecasting,
+  diagnostics);
+* :class:`StructuralModel`, :class:`MappedModel`, :class:`MLEModel`:
+  models with parameters, estimated by maximum likelihood;
+* :mod:`ssfortran.diagnostics`: residual tests.
+"""
+
+from . import diagnostics
+from ._lib import StateSpaceError, version
+from .models import (
+    ARIMA,
+    Cycle,
+    ContinuousLevel,
+    ContinuousTrend,
+    FitResults,
+    ForecastResults,
+    Irregular,
+    Level,
+    MappedModel,
+    MLEModel,
+    Model,
+    Regression,
+    Seasonal,
+    StructuralModel,
+    Trend,
+    fit_many,
+)
+from .representation import (
+    AugmentedResults,
+    DIFFUSE_MULTIVARIATE,
+    DIFFUSE_UNIVARIATE,
+    FILTER_CONVENTIONAL,
+    FILTER_UNIVARIATE,
+    INIT_APPROX_DIFFUSE,
+    INIT_DIFFUSE,
+    INIT_GENERAL,
+    INIT_KNOWN,
+    INIT_STATIONARY,
+    FilterResults,
+    Representation,
+    SmootherResults,
+)
+
+__version__ = version()
+
+__all__ = [
+    "diagnostics", "Model", "StructuralModel", "MappedModel", "MLEModel", "FitResults", "ForecastResults",
+    "fit_many",
+    "Irregular", "Level", "Trend", "Seasonal", "Cycle", "Regression", "ARIMA",
+    "ContinuousLevel", "ContinuousTrend",
+    "Representation", "AugmentedResults", "FilterResults", "SmootherResults", "StateSpaceError",
+    "INIT_KNOWN", "INIT_APPROX_DIFFUSE", "INIT_STATIONARY", "INIT_DIFFUSE", "INIT_GENERAL",
+    "FILTER_CONVENTIONAL", "FILTER_UNIVARIATE", "DIFFUSE_UNIVARIATE", "DIFFUSE_MULTIVARIATE",
+]