FastLSQ 0.3.0__tar.gz → 0.4.1__tar.gz

{fastlsq-0.3.0 → fastlsq-0.4.1}/CHANGELOG.md

@@ -2,6 +2,91 @@
 
 All notable changes to FastLSQ will be documented in this file.
 
+## [0.4.1] - 2026-06-23
+
+### Added
+
+- **Solve-time diagnostics — `solve_lstsq(..., return_info=True)`.** Returns
+  `(x, info)` with `info = {t_solve, rank_used, residual, cond_estimate}`. `t_solve`
+  is the **device-synced wall-time of the solve step alone** (singular values for
+  the rank/cond diagnostics are computed *outside* the timed region), `rank_used` is
+  the rank-revealing effective numerical rank, and `cond_estimate` is `s_max/s_min`
+  over the retained subspace. The default `return_info=False` path is unchanged.
+- **Phased breakdown in `solve_linear` metrics.** `metrics` now reports
+  `scale_search_s`, `assemble_s`, `solve_s` (plus `rank_used`, `residual`,
+  `cond_estimate`) so the headline time is no longer dominated by the auto-scale
+  search — the reported solve time is a number the library hands you, not one a
+  benchmark reconstructs by hand.
+- **`fastlsq.benchmark.time_solve(fn, reps, warmup, device)`** — a device-correct
+  timing primitive (`synchronize` bracketing + warm-up + min-of-reps) returning the
+  reproducible solve-time *floor* in seconds (`return_all=True` for full stats). Also
+  exposes `fastlsq.benchmark.synchronize`.
+- **`SinusoidalBasis.random_covariance(d, N, Sigma=… | L=…)`** — fixed full-`Sigma`
+  constructor (`W = L @ W_hat`, `Sigma = L Lᵀ`), the symmetric counterpart to
+  `random` / `random_anisotropic`.
+- **`LearnableFastLSQ.freeze() -> SinusoidalBasis`** — freezes the learned bandwidth
+  into a plain, detached basis for one clean, timed one-shot deployment solve (the
+  `.basis` property still reconstructs-with-grad each access).
+- **Checkpoint provenance.** `save_checkpoint` auto-records a `provenance` block
+  (library version, device, dtype, timestamp, and the realized scale / `Sigma`) into
+  the metadata.
+
+## [0.4.0] - 2026-06-22
+
+### Added
+
+- **Closed-form projection (Radon) operator for windowed bases.** The integral
+  operator class now covers the *projection / Radon* (line/hyperplane-integral)
+  family, not just the single-axis integrals of 0.3.0. A tomographic measurement is
+  a projection onto a generally **non-axis-aligned** hyperplane,
+  `p(u) = ∫ f(z) δ(c·z − u) dz` (a Fredholm equation of the first kind) — beam
+  phase-space tomography, CT, Abel inversion — which the single-axis `IntegralOperator`
+  cannot express.
+- **`GaussianWindowedBasis`** — the windowed-Fourier (Gabor) member of the basis
+  family, `ψ_j(z) = exp(−‖ζ‖²/2)·sin(W_j·ζ + b_j)` with `ζ = T⁻¹(z − mean)`. The
+  Gaussian window is a **fixed prior** (set once from the data's second moments via
+  `GaussianWindowedBasis.from_data`, *not* trained): the projection of a bare unbounded
+  sinusoid over an infinite hyperplane diverges, and the window makes the hyperplane
+  integral integrable and analytic. Coefficients stay linear, so a fit is still one
+  linear least squares. The Gaussian envelope changes the derivative algebra, so this
+  class is deliberately scoped to **value** (`evaluate`) and **projection** — it does
+  not claim the full `DiffOperator` calculus of the bare `SinusoidalBasis`.
+- **`ProjectionOperator`** — assembles the `(M, N)` projection design matrix in
+  **closed form, with no quadrature**: in the whitened frame, with `q = Tᵀc`,
+  `σ_u² = ‖q‖²`, `u₀ = c·mean`, `jac = |det T|/‖q‖`,
+  `(P ψ_j)(u) = jac·(2π)^((d−1)/2)·exp(−‖ω_j‖²/2)·exp(−(u−u₀)²/(2σ_u²))·sin(α_j u + φ_j)`,
+  with `α_j = (W_j·q)/‖q‖²`, `‖ω_j‖² = ‖W_j‖² − (W_j·q̂)²`, `φ_j = b_j − α_j u₀`. The
+  rows are **differentiable in the direction `c` (the optics)**, for differentiable
+  experiment design (autodiff `d(posterior)/d(optics)`): the across-slice energy uses
+  the rotation-invariant `‖W‖²−(W·q̂)²` (no QR complement) and every quantity stays a
+  tensor (no `float()`/`.item()` casts), so autograd flows to `c` (verified
+  `autodiff == finite-difference` to ~5e-9). `from_transport(M, e)` builds the
+  tomography convention `c = Mᵀe` (transport by optics `M`, read on axis `e`). The
+  operator mirrors the `apply(basis, x, cache)` signature but is standalone (it needs
+  the windowed basis, so it does not compose into `IntegroDifferentialOperator`). Both
+  classes are exported from `fastlsq`.
+- **Tests / example.** `tests/test_projection.py` asserts the closed form equals a
+  Gauss--Hermite quadrature of the slice integral to machine precision in d = 2, 3, 4
+  (≤4e-13 observed), that autodiff of the rows wrt `c` matches finite differences, and
+  that a windowed field is recovered from its projections at several directions in one
+  LSQ. `examples/inverse/tomography_projection.py` demonstrates the full reconstruction
+  plus the differentiable-optics gradient.
+
+### Scope (honest)
+
+- The closed-form projection assembly works **only** for the Gaussian-windowed basis
+  (the Gaussian × plane-wave hyperplane integral is analytic); other windows
+  (compact / polynomial) generally are **not** closed form. Scope = *Gaussian-windowed*
+  tomographic / line-integral operators, not "any projection".
+- The window is a *fixed prior* (set from data moments), required for convergence — not
+  a tuned hyperparameter.
+- This is a **different** analytic-kernel mechanism from the Fourier-symbol
+  (convolution / fractional) class — it is the projection / Radon (line/hyperplane
+  integral) class.
+- No novelty is claimed over ELM / RBF-for-integral-equations prior art; the distinctive
+  parts are quadrature-free closed-form projection rows, differentiability in the optics,
+  and the unified operator algebra.
+
 ## [0.3.0] - 2026-06-21
 
 ### Added

{fastlsq-0.3.0 → fastlsq-0.4.1}/FastLSQ.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.3.0
+Version: 0.4.1
 Summary: One-shot PDE solving via Fourier features with exact analytical derivatives; rank-revealing solvers, learnable anisotropic bandwidth, and CPU/CUDA/MPS support
 Author: Antonin Sulc
 License-Expression: MIT
@@ -278,6 +278,8 @@ derivative engine:
 | `SinusoidalBasis` | Evaluates basis functions and arbitrary-order derivatives in O(1) via the cyclic identity |
 | `BasisCache` | Pre-computes sin(Z)/cos(Z) once, reuses across multiple derivative evaluations |
 | `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar *; coefficients can be `nn.Parameter` for learnable PDEs |
+| `IntegralOperator` / `IntegroDifferentialOperator` | Closed-form **single-axis** definite / running (Volterra) integrals; compose with `Op` into one integro-differential design matrix |
+| `GaussianWindowedBasis` / `ProjectionOperator` | Windowed-Fourier (Gabor) basis + closed-form **projection (Radon)** operator `∫ f δ(c·z−u) dz` for tomographic / line-integral inverse problems; quadrature-free and differentiable in the optics `c` |
 | `FeatureBasis` | Adapter for non-sinusoidal solvers (e.g. PIELM with tanh) |
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
@@ -367,6 +369,7 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 
 - **Analytical derivative engine**: `SinusoidalBasis` computes arbitrary-order derivatives exactly in O(1) -- the foundation of the entire framework
 - **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
+- **Closed-form integral operators**: `IntegralOperator` (single-axis definite / Volterra integrals) composes with `Op` into one integro-differential least-squares block. The integral class now also includes the **projection (Radon) operator** (`ProjectionOperator` on a `GaussianWindowedBasis`) -- quadrature-free `∫ f δ(c·z−u) dz` line/hyperplane integrals for tomographic inverse problems, differentiable in the optics `c` for experiment design
 - **Vector-valued solutions**: First-class support for **u**: ℝᵈ → ℝᵏ (elasticity, Stokes, Maxwell). Problems declare `n_outputs = k`; `block_concat` assembles coupled block systems; `solver.predict(x)` returns shape `(M, k)`. Scalar problems are the `k=1` case
 - **High-level API**: Solve PDEs in one line with `solve_linear()` and `solve_nonlinear()`
 - **Robust linear solver**: Pluggable least-squares back-ends; the default `auto` routes Cholesky -> QR -> SVD, and backward-stable QR delivers SVD-grade accuracy at QR cost on the rank-deficient random-feature system

{fastlsq-0.3.0 → fastlsq-0.4.1}/FastLSQ.egg-info/SOURCES.txt

@@ -23,10 +23,12 @@ examples/inverse_heat_source.py
 examples/inverse_magnetostatics.py
 examples/inverse_source_position.py
 examples/learnable_helmholtz.py
+examples/memory_diffusion.py
 examples/orbit_hill.py
 examples/orbit_inverse.py
 examples/orbit_rl.py
 examples/pde_discovery.py
+examples/rlc_integro_differential.py
 examples/run_all_extensions.py
 examples/run_linear.py
 examples/run_nonlinear.py
@@ -90,9 +92,12 @@ examples/inverse/denoising_parameter_estimation.py
 examples/inverse/elastic_wave_animation.py
 examples/inverse/heat_from_video.py
 examples/inverse/inverse_memory_kernel.py
+examples/inverse/inverse_source_integral_sensors.py
 examples/inverse/inverse_turbulence.py
+examples/inverse/rlc_system_id.py
 examples/inverse/shape_ns.py
 examples/inverse/subsurface_imaging.py
+examples/inverse/tomography_projection.py
 examples/inverse/wing_optimize_simple.py
 examples/sindy/compare_sindy_methods.py
 examples/sindy/sindy_benchmarks.py
@@ -101,6 +106,7 @@ examples/sindy/sindy_minimal_diff.py
 fastlsq/__init__.py
 fastlsq/api.py
 fastlsq/basis.py
+fastlsq/benchmark.py
 fastlsq/block.py
 fastlsq/device.py
 fastlsq/diagnostics.py
@@ -135,9 +141,11 @@ tests/test_benchmarks_inverse.py
 tests/test_block.py
 tests/test_derivatives.py
 tests/test_device.py
+tests/test_diagnostics_timing.py
 tests/test_grad_shafranov.py
 tests/test_grid_swing.py
 tests/test_integral.py
 tests/test_learnable.py
 tests/test_orbit_hill.py
+tests/test_projection.py
 tests/test_vector_basis.py

{fastlsq-0.3.0 → fastlsq-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.3.0
+Version: 0.4.1
 Summary: One-shot PDE solving via Fourier features with exact analytical derivatives; rank-revealing solvers, learnable anisotropic bandwidth, and CPU/CUDA/MPS support
 Author: Antonin Sulc
 License-Expression: MIT
@@ -278,6 +278,8 @@ derivative engine:
 | `SinusoidalBasis` | Evaluates basis functions and arbitrary-order derivatives in O(1) via the cyclic identity |
 | `BasisCache` | Pre-computes sin(Z)/cos(Z) once, reuses across multiple derivative evaluations |
 | `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar *; coefficients can be `nn.Parameter` for learnable PDEs |
+| `IntegralOperator` / `IntegroDifferentialOperator` | Closed-form **single-axis** definite / running (Volterra) integrals; compose with `Op` into one integro-differential design matrix |
+| `GaussianWindowedBasis` / `ProjectionOperator` | Windowed-Fourier (Gabor) basis + closed-form **projection (Radon)** operator `∫ f δ(c·z−u) dz` for tomographic / line-integral inverse problems; quadrature-free and differentiable in the optics `c` |
 | `FeatureBasis` | Adapter for non-sinusoidal solvers (e.g. PIELM with tanh) |
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
@@ -367,6 +369,7 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 
 - **Analytical derivative engine**: `SinusoidalBasis` computes arbitrary-order derivatives exactly in O(1) -- the foundation of the entire framework
 - **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
+- **Closed-form integral operators**: `IntegralOperator` (single-axis definite / Volterra integrals) composes with `Op` into one integro-differential least-squares block. The integral class now also includes the **projection (Radon) operator** (`ProjectionOperator` on a `GaussianWindowedBasis`) -- quadrature-free `∫ f δ(c·z−u) dz` line/hyperplane integrals for tomographic inverse problems, differentiable in the optics `c` for experiment design
 - **Vector-valued solutions**: First-class support for **u**: ℝᵈ → ℝᵏ (elasticity, Stokes, Maxwell). Problems declare `n_outputs = k`; `block_concat` assembles coupled block systems; `solver.predict(x)` returns shape `(M, k)`. Scalar problems are the `k=1` case
 - **High-level API**: Solve PDEs in one line with `solve_linear()` and `solve_nonlinear()`
 - **Robust linear solver**: Pluggable least-squares back-ends; the default `auto` routes Cholesky -> QR -> SVD, and backward-stable QR delivers SVD-grade accuracy at QR cost on the rank-deficient random-feature system

{fastlsq-0.3.0 → fastlsq-0.4.1}/README.md

@@ -237,6 +237,8 @@ derivative engine:
 | `SinusoidalBasis` | Evaluates basis functions and arbitrary-order derivatives in O(1) via the cyclic identity |
 | `BasisCache` | Pre-computes sin(Z)/cos(Z) once, reuses across multiple derivative evaluations |
 | `DiffOperator` / `Op` | Symbolic linear differential operators that compose via +, -, scalar *; coefficients can be `nn.Parameter` for learnable PDEs |
+| `IntegralOperator` / `IntegroDifferentialOperator` | Closed-form **single-axis** definite / running (Volterra) integrals; compose with `Op` into one integro-differential design matrix |
+| `GaussianWindowedBasis` / `ProjectionOperator` | Windowed-Fourier (Gabor) basis + closed-form **projection (Radon)** operator `∫ f δ(c·z−u) dz` for tomographic / line-integral inverse problems; quadrature-free and differentiable in the optics `c` |
 | `FeatureBasis` | Adapter for non-sinusoidal solvers (e.g. PIELM with tanh) |
 | `FastLSQSolver` | Manages feature blocks; exposes `.basis` for all derivative computations |
 | `LearnableFastLSQ` | Differentiable solver with learnable bandwidth via reparameterisation trick |
@@ -326,6 +328,7 @@ See `examples/add_your_own_pde.py` for the complete tutorial.
 
 - **Analytical derivative engine**: `SinusoidalBasis` computes arbitrary-order derivatives exactly in O(1) -- the foundation of the entire framework
 - **Symbolic PDE operators**: Compose differential operators with `Op` (Laplacian, wave, Helmholtz, biharmonic, custom) via intuitive arithmetic; coefficients can be `nn.Parameter` for AdamW optimisation
+- **Closed-form integral operators**: `IntegralOperator` (single-axis definite / Volterra integrals) composes with `Op` into one integro-differential least-squares block. The integral class now also includes the **projection (Radon) operator** (`ProjectionOperator` on a `GaussianWindowedBasis`) -- quadrature-free `∫ f δ(c·z−u) dz` line/hyperplane integrals for tomographic inverse problems, differentiable in the optics `c` for experiment design
 - **Vector-valued solutions**: First-class support for **u**: ℝᵈ → ℝᵏ (elasticity, Stokes, Maxwell). Problems declare `n_outputs = k`; `block_concat` assembles coupled block systems; `solver.predict(x)` returns shape `(M, k)`. Scalar problems are the `k=1` case
 - **High-level API**: Solve PDEs in one line with `solve_linear()` and `solve_nonlinear()`
 - **Robust linear solver**: Pluggable least-squares back-ends; the default `auto` routes Cholesky -> QR -> SVD, and backward-stable QR delivers SVD-grade accuracy at QR cost on the rank-deficient random-feature system

fastlsq-0.4.1/examples/inverse/inverse_source_integral_sensors.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Antonin Sulc
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""
+Inverse problem with the definite integral as a *measurement operator*: recover a source from
+a bank of finite-aperture detectors.
+
+Real sensors rarely sample a field pointwise -- a photodiode, a thermocouple bead, a gravimeter
+all report the field *integrated over their aperture*.  So the data are window integrals
+
+        d_i = ∫_{a_i}^{b_i} u(x) dx,        i = 1 … N_det,
+
+of a field u that is itself generated by an unknown source f through the steady diffusion law
+
+        -u''(x) = f(x),   u(0) = u(1) = 0.
+
+We recover both the field u and the source f = -u'' from the (noisy) integrated readings alone.
+Each detector is one row of an ``IntegralOperator.definite`` design block -- the *exact* integral
+of every Fourier feature over the detector window -- so the forward measurement operator is
+assembled in closed form and the inverse is one regularised least-squares solve:
+
+        [ ∫_{a_i}^{b_i} φ ds ]            [ d_i ]
+        [   w · φ(0)         ]  · β  =    [  0  ]      ->   u(x)=φ(x)·β,   f(x)=-φ''(x)·β.
+        [   w · φ(1)         ]            [  0  ]
+
+Recovering a function from finitely many integral functionals is ill-posed, so the rank-revealing
+solver + a light Tikhonov ridge return the smoothest field consistent with the apertures and the
+boundary conditions.  The field u is recovered sharply; the source f = -u'' is harder (a second
+derivative amplifies measurement noise), which the error plot makes honest.
+
+Usage:  python inverse_source_integral_sensors.py
+"""
+
+import numpy as np
+import torch
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+from fastlsq import SinusoidalBasis, Op, IntegralOperator, solve_lstsq
+
+PI = np.pi
+
+
+def main():
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(0)
+    rng = np.random.default_rng(0)
+
+    # ------------------------------------------------------------------
+    # Ground truth:  -u'' = f,  u(0)=u(1)=0,  multi-scale source
+    # ------------------------------------------------------------------
+    amps = [(1, 1.0), (3, 0.6), (5, 0.3)]                     # (mode k, amplitude)
+    f_true = lambda x: sum(a * torch.sin(k * PI * x) for k, a in amps)
+    u_true = lambda x: sum(a / (k * PI) ** 2 * torch.sin(k * PI * x) for k, a in amps)
+
+    # ------------------------------------------------------------------
+    # Detector bank: contiguous windows tiling [0, 1]; reading = ∫ window u
+    # ------------------------------------------------------------------
+    n_det = 32
+    edges = torch.linspace(0.0, 1.0, n_det + 1)
+    basis = SinusoidalBasis.random(input_dim=1, n_features=400, sigma=5.0, normalize=False)
+
+    det_rows, d_clean = [], []
+    for i in range(n_det):
+        a_i, b_i = float(edges[i]), float(edges[i + 1])
+        # one detector = exact closed-form integral of every feature over [a_i, b_i]
+        det_rows.append(IntegralOperator.definite(0, a_i, b_i, d=1).apply(basis, torch.zeros(1, 1)))
+        # true reading via fine quadrature of the exact field
+        xs = torch.linspace(a_i, b_i, 400)
+        d_clean.append(float(torch.trapz(u_true(xs), xs)))
+    A_det = torch.cat(det_rows)                                # (n_det, N)
+    d_clean = torch.tensor(d_clean).reshape(-1, 1)
+
+    noise_pct = 0.005                                          # 0.5 % detector noise
+    d_meas = d_clean + noise_pct * torch.std(d_clean) * torch.from_numpy(
+        rng.normal(0.0, 1.0, d_clean.shape))
+
+    # ------------------------------------------------------------------
+    # Inverse solve:  detectors + Dirichlet BCs, rank-revealing + light ridge
+    # ------------------------------------------------------------------
+    W_BC = 30.0
+    x_bc = torch.tensor([[0.0], [1.0]])
+    A = torch.cat([A_det, W_BC * basis.evaluate(x_bc)])
+    b = torch.cat([d_meas, torch.zeros(2, 1)])
+    beta = solve_lstsq(A, b, mu=1e-7)
+
+    # ------------------------------------------------------------------
+    # Recover field u and source f = -u'' ; report accuracy
+    # ------------------------------------------------------------------
+    xt = torch.linspace(0, 1, 400).reshape(-1, 1)
+    u_rec = (basis.evaluate(xt) @ beta).squeeze()
+    f_rec = (-Op.partial(0, 2, d=1).apply(basis, xt) @ beta).squeeze()
+    u_ref, f_ref = u_true(xt).squeeze(), f_true(xt).squeeze()
+    u_err = (torch.norm(u_rec - u_ref) / torch.norm(u_ref)).item()
+    f_err = (torch.norm(f_rec - f_ref) / torch.norm(f_ref)).item()
+    print(f"detectors: {n_det} windows, {noise_pct*100:.1f}% noise")
+    print(f"  field   u(x)        rel-L2 : {u_err:.2e}")
+    print(f"  source  f(x)=-u''   rel-L2 : {f_err:.2e}")
+
+    # ------------------------------------------------------------------
+    # Plot: recovered source | recovered field + detector readings
+    # ------------------------------------------------------------------
+    xg = xt.squeeze().numpy()
+    fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(12, 4.2))
+    ax0.plot(xg, f_ref.numpy(), "k-", lw=2.5, label="true source f")
+    ax0.plot(xg, f_rec.numpy(), "C1--", lw=1.6, label="recovered  -u''")
+    ax0.set_title(f"source f(x)   (rel-L2 = {f_err:.1e})")
+    ax0.set_xlabel("x"); ax0.set_ylabel("f(x)"); ax0.legend()
+
+    ax1.plot(xg, u_ref.numpy(), "k-", lw=2.5, label="true field u")
+    ax1.plot(xg, u_rec.numpy(), "C1--", lw=1.6, label="recovered u")
+    centers = (0.5 * (edges[:-1] + edges[1:])).numpy()
+    widths = (edges[1:] - edges[:-1]).numpy()
+    ax1.bar(centers, (d_meas.squeeze() / torch.from_numpy(widths)).numpy(), width=widths * 0.9,
+            color="C0", alpha=0.25, label="detector readings (÷ width)")
+    ax1.set_title(f"field u(x) + integrating detectors   (rel-L2 = {u_err:.1e})")
+    ax1.set_xlabel("x"); ax1.set_ylabel("u(x)"); ax1.legend(fontsize=8)
+
+    fig.suptitle("Inverse source from finite-aperture detectors:  d_i = ∫ u  ->  recover u, f", y=1.02)
+    plt.tight_layout()
+    out = "inverse_source_integral_sensors.pdf"
+    plt.savefig(out, dpi=150, bbox_inches="tight")
+    plt.close()
+    print(f"  -> Saved: {out}")
+
+
+if __name__ == "__main__":
+    main()

fastlsq-0.4.1/examples/inverse/rlc_system_id.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Antonin Sulc
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""
+Inverse problem / system identification: recover (L, R, C) of an RLC circuit from a noisy
+current trace -- in closed form, with NO optimiser.
+
+The forward law is the series-RLC integro-differential equation
+
+        L i'(t) + R i(t) + (1/C) ∫_0^t i(s) ds = V(t).
+
+Given a *known* drive V(t) and *noisy* measurements of the current i(t), we recover the three
+device parameters.  The trick that makes this optimiser-free is that FastLSQ supplies *exact*
+derivatives AND integrals of the fitted current:
+
+  1. Denoise: fit the noisy samples i_meas(t) into the Fourier-feature basis in one ridge LSQ.
+     The fitted β then yields i, i', and ∫_0^t i in closed form at any t (no finite differences,
+     no quadrature -- the two operations most corrupted by noise).
+  2. Identify: build the feature library  Φ = [ i'(t) | i(t) | ∫_0^t i ds ]  and regress the
+     known drive  V(t) = Φ · θ  in a single 3-column least squares.  Then
+        L = θ_0,   R = θ_1,   1/C = θ_2.
+
+This is the SINDy-style "fit then linearly regress" inverse (cf. the AdamW single-coefficient
+version in ``inverse_memory_kernel.py``, and ``denoising_parameter_estimation.py``), here
+recovering THREE coupled coefficients of a heterogeneous derivative+value+integral library.
+
+A note on excitation: at a *single* drive frequency the steady-state i, i', ∫i are all one
+sinusoid (only sin/cos span), so the library columns are nearly collinear and L vs 1/C trade
+off -- the system is weakly identifiable.  As in real system identification, we therefore
+probe with a *spectrally rich* multi-tone drive (below / at / above resonance), which excites
+independent column directions and pins all three coefficients to ~1 %.
+
+Usage:  python rlc_system_id.py
+"""
+
+import numpy as np
+import torch
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+from fastlsq import SinusoidalBasis, Op, IntegralOperator, solve_lstsq
+from fastlsq.geometry import sample_box
+
+
+def rk4_current(L, R, C, V_fn, T, n=20001):
+    """Fine RK4 of  q' = i,  L i' = V - R i - q/C  from rest -> (t, i)."""
+    t = np.linspace(0.0, T, n)
+    h = t[1] - t[0]
+    y = np.zeros((n, 2))  # [q, i]
+
+    def rhs(tt, yy):
+        q, i = yy
+        return np.array([i, (V_fn(tt) - R * i - q / C) / L])
+
+    for k in range(n - 1):
+        tk, yk = t[k], y[k]
+        k1 = rhs(tk, yk)
+        k2 = rhs(tk + 0.5 * h, yk + 0.5 * h * k1)
+        k3 = rhs(tk + 0.5 * h, yk + 0.5 * h * k2)
+        k4 = rhs(tk + h, yk + h * k3)
+        y[k + 1] = yk + (h / 6.0) * (k1 + 2 * k2 + 2 * k3 + k4)
+    return t, y[:, 1]
+
+
+def main():
+    torch.set_default_dtype(torch.float64)
+    torch.manual_seed(0)
+    rng = np.random.default_rng(0)
+
+    # ------------------------------------------------------------------
+    # True circuit (unknown to the estimator) + measurement model
+    # ------------------------------------------------------------------
+    L_true, R_true, C_true = 1.0, 0.8, 1.0 / 64.0
+    w0 = 1.0 / np.sqrt(L_true * C_true)
+    # Spectrally-rich probe: three tones below / at / above resonance.
+    freqs = [0.45 * w0, 1.0 * w0, 1.7 * w0]
+    V0, T = 4.0, 8.0
+    V_fn_np = lambda t: V0 * sum(np.sin(f * t) for f in freqs)
+    V_fn_t = lambda t: V0 * sum(torch.sin(f * t) for f in freqs)
+
+    # Noisy current measurements at a coarse sampling rate
+    t_dense, i_dense = rk4_current(L_true, R_true, C_true, V_fn_np, T, n=40001)
+    M_meas = 800
+    idx = np.linspace(0, len(t_dense) - 1, M_meas).astype(int)
+    t_meas = t_dense[idx]
+    i_clean = i_dense[idx]
+    noise_pct = 0.02                                   # 2 % RMS Gaussian noise
+    sigma_n = noise_pct * np.sqrt(np.mean(i_clean ** 2))
+    i_meas = i_clean + rng.normal(0.0, sigma_n, size=i_clean.shape)
+    print(f"True   : L={L_true:.4f}, R={R_true:.4f}, C={C_true:.6f}  (noise {noise_pct*100:.0f}%)")
+
+    # ------------------------------------------------------------------
+    # Step 1 -- denoise: fit i_meas into the basis (one ridge LSQ)
+    # ------------------------------------------------------------------
+    basis = SinusoidalBasis.random(input_dim=1, n_features=500, sigma=5.0, normalize=False)
+    t_m = torch.from_numpy(t_meas).reshape(-1, 1)
+    i_m = torch.from_numpy(i_meas).reshape(-1, 1)
+    beta = solve_lstsq(basis.evaluate(t_m), i_m, mu=1e-6)   # ridge denoises the fit
+
+    # ------------------------------------------------------------------
+    # Step 2 -- identify: regress V(t) = L i' + R i + (1/C) ∫_0^t i
+    # ------------------------------------------------------------------
+    t_col = sample_box(4000, 1, bounds=(0.0, T))
+    D1 = Op.partial(0, 1, d=1)                                # i'
+    Iden = Op.identity(d=1)                                   # i
+    Vol = IntegralOperator.volterra(dim=0, lower=0.0, d=1)    # ∫_0^t i
+
+    i_dt = D1.apply(basis, t_col) @ beta                     # (M,1) exact derivative
+    i_val = Iden.apply(basis, t_col) @ beta                   # (M,1)
+    i_int = Vol.apply(basis, t_col) @ beta                    # (M,1) exact running integral
+    Phi = torch.cat([i_dt, i_val, i_int], dim=1)             # (M, 3) library
+    rhs = V_fn_t(t_col)                                       # (M, 1) known drive
+
+    theta = solve_lstsq(Phi, rhs, mu=0.0)                    # one 3-column LSQ -> (3, 1)
+    L_hat, R_hat, invC_hat = (float(theta[0]), float(theta[1]), float(theta[2]))
+    C_hat = 1.0 / invC_hat
+
+    def err(a, b):
+        return abs(a - b) / abs(b) * 100.0
+
+    print(f"Recover: L={L_hat:.4f}, R={R_hat:.4f}, C={C_hat:.6f}")
+    print(f"  rel-error  L: {err(L_hat,L_true):5.2f}%   "
+          f"R: {err(R_hat,R_true):5.2f}%   C: {err(C_hat,C_true):5.2f}%")
+
+    # ------------------------------------------------------------------
+    # Plot:  noisy data + denoised fit  |  recovered-vs-true parameter bars
+    # ------------------------------------------------------------------
+    tt = torch.from_numpy(t_dense).reshape(-1, 1)
+    i_fit = (basis.evaluate(tt) @ beta).squeeze().numpy()
+
+    fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(12, 4.2))
+    ax0.plot(t_meas, i_meas, ".", ms=2.5, color="0.6", label=f"measured (+{noise_pct*100:.0f}% noise)")
+    ax0.plot(t_dense, i_dense, "k-", lw=2.0, label="true current")
+    ax0.plot(t_dense, i_fit, "C1--", lw=1.4, label="basis fit (denoised)")
+    ax0.set_title("Step 1: denoise current i(t)")
+    ax0.set_xlabel("t [s]"); ax0.set_ylabel("i(t) [A]"); ax0.legend(fontsize=8)
+
+    names = ["L", "R", "1/C"]
+    true_v = [L_true, R_true, 1.0 / C_true]
+    hat_v = [L_hat, R_hat, invC_hat]
+    xpos = np.arange(3)
+    ax1.bar(xpos - 0.18, true_v, width=0.36, label="true", color="k")
+    ax1.bar(xpos + 0.18, hat_v, width=0.36, label="recovered", color="C1")
+    ax1.set_xticks(xpos); ax1.set_xticklabels(names)
+    ax1.set_yscale("log")
+    ax1.set_title("Step 2: recovered parameters (closed form, no optimiser)")
+    ax1.set_ylabel("coefficient value"); ax1.legend()
+
+    plt.tight_layout()
+    out = "rlc_system_id.pdf"
+    plt.savefig(out, dpi=150, bbox_inches="tight")
+    plt.close()
+    print(f"  -> Saved: {out}")
+
+
+if __name__ == "__main__":
+    main()

fastlsq-0.4.1/examples/inverse/tomography_projection.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Antonin Sulc
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""
+Tomographic reconstruction via the closed-form projection (Radon) operator.
+
+A tomographic measurement integrates an unknown field along lines: each detector reading
+is a projection of f onto a hyperplane with normal c,
+
+        p(u) = ∫ f(z) δ(c·z − u) dz        (a Fredholm equation of the first kind),
+
+which the single-axis ``IntegralOperator`` cannot express (the hyperplane is generally
+non-axis-aligned).  ``ProjectionOperator`` assembles these projection rows in *closed
+form* for a ``GaussianWindowedBasis`` -- the Gaussian × plane-wave hyperplane integral is
+analytic, so there is no quadrature error.  The Gaussian window is a *fixed prior* (set
+from the data's second moments, not trained); it is what makes the line integral of every
+feature converge, and it keeps the feature coefficients linear -- so the reconstruction is
+**one linear least-squares solve**.
+
+This script:
+  1. builds a windowed basis over a 2-D support (`GaussianWindowedBasis.from_data`),
+  2. picks a ground-truth field in that basis and synthesises noisy projections at a sweep
+     of angles c = (cos θ, sin θ) (parallel-beam tomography),
+  3. recovers the field coefficients in one ``solve_lstsq`` and reports the rel-L2 error,
+  4. demonstrates that a projection is **differentiable in the optics c** -- the gradient
+     of a detector functional wrt c matches finite differences -- which is what makes the
+     operator usable for differentiable experiment / optics design.
+
+Usage:  python tomography_projection.py
+"""
+
+import os
+import math
+
+import numpy as np
+import torch
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+from fastlsq import GaussianWindowedBasis, ProjectionOperator, solve_lstsq
+
+torch.set_default_dtype(torch.float64)
+PI = np.pi
+
+
+def main():
+    torch.manual_seed(0)
+    d, N = 2, 300
+
+    # ------------------------------------------------------------------
+    # 1. Windowed basis: the Gaussian window is a FIXED prior from the
+    #    support's second moments (mean + covariance), not a trained knob.
+    # ------------------------------------------------------------------
+    mean_true = torch.tensor([0.15, -0.1])
+    scale_true = torch.tensor([1.0, 0.55])
+    z_support = torch.randn(6000, d) * scale_true + mean_true
+    basis = GaussianWindowedBasis.from_data(z_support, n_features=N, sigma=1.4)
+
+    # ------------------------------------------------------------------
+    # 2. Ground-truth field lives in the same windowed basis, so an exact
+    #    target exists; synthesise projections at a half-circle of angles.
+    # ------------------------------------------------------------------
+    beta_true = torch.randn(N, 1) / math.sqrt(N)
+
+    angles = torch.linspace(0.0, PI, 24)[:-1]            # tomographic view angles
+    u_grid = torch.linspace(-5.0, 5.0, 120)              # detector bins per view
+    noise = 1e-3
+
+    A_blocks, p_blocks = [], []
+    for th in angles:
+        c = torch.stack([torch.cos(th), torch.sin(th)])  # projection direction
+        A = ProjectionOperator(c).apply(basis, u_grid)   # (len(u), N), closed form
+        A_blocks.append(A)
+        p_blocks.append(A @ beta_true)
+    A_all = torch.cat(A_blocks, dim=0)
+    p_clean = torch.cat(p_blocks, dim=0)
+    p_obs = p_clean + noise * torch.randn_like(p_clean)
+
+    # ------------------------------------------------------------------
+    # 3. One-shot least-squares reconstruction of the field coefficients.
+    # ------------------------------------------------------------------
+    beta_hat = solve_lstsq(A_all, p_obs, mu=1e-8)
+
+    gx = torch.linspace(-2.5, 2.5, 120)
+    GX, GY = torch.meshgrid(gx, gx, indexing="ij")
+    zt = torch.stack([GX.reshape(-1), GY.reshape(-1)], dim=1)
+    f_true = (basis.evaluate(zt) @ beta_true).reshape(GX.shape)
+    f_hat = (basis.evaluate(zt) @ beta_hat).reshape(GX.shape)
+    rel = (torch.norm(f_hat - f_true) / torch.norm(f_true)).item()
+
+    print("Tomographic reconstruction via closed-form projection (Radon) operator")
+    print(f"  views={len(angles)}  detector bins/view={len(u_grid)}  features N={N}")
+    print(f"  measurements={A_all.shape[0]}  noise floor ~ {noise:.0e}")
+    print(f"  field reconstruction rel-L2 = {rel:.3e}")
+
+    # ------------------------------------------------------------------
+    # 4. Differentiable optics: gradient of a detector functional wrt c.
+    #    autodiff matches finite differences -> usable for experiment design.
+    # ------------------------------------------------------------------
+    c0 = torch.tensor([0.6, 0.8])
+
+    def detector_functional(cc):
+        # total recorded intensity of the reconstructed field at one view
+        return (ProjectionOperator(cc).apply(basis, u_grid) @ beta_hat).pow(2).sum()
+
+    c = c0.clone().requires_grad_(True)
+    detector_functional(c).backward()
+    g_ad = c.grad.detach().clone()
+
+    eps = 1e-6
+    g_fd = torch.zeros(d)
+    for i in range(d):
+        cp = c0.clone(); cp[i] += eps
+        cm = c0.clone(); cm[i] -= eps
+        g_fd[i] = (detector_functional(cp) - detector_functional(cm)) / (2 * eps)
+    rel_grad = (torch.norm(g_ad - g_fd) / torch.norm(g_fd)).item()
+    print(f"  d(detector)/dc : autodiff={g_ad.tolist()}  vs FD rel-diff={rel_grad:.2e}")
+
+    # ------------------------------------------------------------------
+    # Plot: sinogram, truth, reconstruction.
+    # ------------------------------------------------------------------
+    sino = p_clean.reshape(len(angles), len(u_grid)).numpy()
+    fig, (ax0, ax1, ax2) = plt.subplots(1, 3, figsize=(15, 4.4))
+    ax0.imshow(sino, aspect="auto", origin="lower",
+               extent=[u_grid.min(), u_grid.max(), 0.0, float(PI)], cmap="magma")
+    ax0.set_title("sinogram  p(θ, u)"); ax0.set_xlabel("detector u"); ax0.set_ylabel("angle θ")
+
+    vmax = float(f_true.abs().max())
+    ax1.contourf(GX.numpy(), GY.numpy(), f_true.numpy(), 40, cmap="RdBu_r", vmin=-vmax, vmax=vmax)
+    ax1.set_title("true field f(z)"); ax1.set_aspect("equal")
+    ax2.contourf(GX.numpy(), GY.numpy(), f_hat.numpy(), 40, cmap="RdBu_r", vmin=-vmax, vmax=vmax)
+    ax2.set_title(f"reconstruction (rel-L2 {rel:.1e})"); ax2.set_aspect("equal")
+    plt.tight_layout()
+
+    out_dir = os.path.dirname(os.path.abspath(__file__))
+    out = os.path.join(out_dir, "tomography_projection.pdf")
+    fig.savefig(out, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    print(f"  -> Saved: {out}")
+
+
+if __name__ == "__main__":
+    main()