FastLSQ 0.4.0__tar.gz → 0.4.1__tar.gz

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

@@ -2,6 +2,35 @@
 
 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.4.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

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

@@ -106,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
@@ -140,6 +141,7 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.4.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

{fastlsq-0.4.0 → fastlsq-0.4.1}/fastlsq/__init__.py

@@ -53,8 +53,9 @@ from fastlsq.export import (
     load_checkpoint,
 )
 from fastlsq import viz
+from fastlsq import benchmark
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 __all__ = [
     # Device selection (CPU / CUDA / Apple-MPS, dtype-aware)
     "resolve_device",

{fastlsq-0.4.0 → fastlsq-0.4.1}/fastlsq/api.py

@@ -105,16 +105,20 @@ def solve_linear(
     if n_bc is None:
         n_bc = max(800, n_pde // 5)
 
-    # Auto-select scale if needed
+    # Auto-select scale if needed (timed as its own phase: it is a search that can
+    # be amortised / skipped at deployment, so it must not inflate the solve time).
+    scale_search_s = 0.0
     if scale is None and auto_scale:
         if verbose:
             print("Auto-selecting optimal scale...")
+        t_phase = time.perf_counter()
         scale = auto_select_scale(
             problem, solver_class=FastLSQSolver,
             n_blocks=n_blocks, hidden_size=hidden_size,
             n_pde=n_pde, n_bc=n_bc, n_trials=auto_scale_trials,
             verbose=verbose,
         )
+        scale_search_s = time.perf_counter() - t_phase
         if verbose:
             print(f"Selected scale: {scale:.3f}")
 
@@ -137,10 +141,25 @@ def solve_linear(
         x_pde, bcs = data
         build_args = (bcs,)
 
-    # Assemble and solve
+    # Assemble (timed phase)
+    t_phase = time.perf_counter()
     A, b = problem.build(solver, x_pde, *build_args)
-    beta_raw = solve_lstsq(A, b, mu=mu, method=method)
+    assemble_s = time.perf_counter() - t_phase
+
+    # Solve (timed phase).  With metrics on, ``solve_lstsq`` hands back the
+    # device-synced solve time plus rank/residual/cond diagnostics directly; with
+    # metrics off, keep the plain fast solve and just time it externally.
     n_outputs = getattr(problem, "n_outputs", 1)
+    if return_metrics:
+        beta_raw, solve_info = solve_lstsq(
+            A, b, mu=mu, method=method, return_info=True
+        )
+        solve_s = solve_info["t_solve"]
+    else:
+        t_phase = time.perf_counter()
+        beta_raw = solve_lstsq(A, b, mu=mu, method=method)
+        solve_s = time.perf_counter() - t_phase
+        solve_info = None
     solver.beta = unpack_beta(beta_raw, solver.n_features, n_outputs)
 
     runtime = time.time() - t0
@@ -169,6 +188,15 @@ def solve_linear(
             "val_err": val_err,
             "grad_err": grad_err,
             "runtime": runtime,
+            # Phased breakdown: the conflated ``runtime`` split into its parts so
+            # the headline solve time is no longer dominated by the scale search.
+            "scale_search_s": scale_search_s,
+            "assemble_s": assemble_s,
+            "solve_s": solve_s,
+            # Rank-revealing solve diagnostics (the paper's central mechanism).
+            "rank_used": solve_info["rank_used"],
+            "residual": solve_info["residual"],
+            "cond_estimate": solve_info["cond_estimate"],
         }
         if verbose:
             print(f"Value error: {val_err:.2e}, Gradient error: {grad_err:.2e}")

{fastlsq-0.4.0 → fastlsq-0.4.1}/fastlsq/basis.py

@@ -197,6 +197,43 @@ class SinusoidalBasis:
         b = torch.rand(1, n_features, device=get_device()) * 2 * np.pi
         return cls(W, b, normalize=normalize, dc_eps=dc_eps)
 
+    @classmethod
+    def random_covariance(
+        cls,
+        input_dim: int,
+        n_features: int,
+        Sigma: Optional[Union[list, np.ndarray, torch.Tensor]] = None,
+        L: Optional[Union[list, np.ndarray, torch.Tensor]] = None,
+        normalize: bool = True,
+        dc_eps: float = 1e-8,
+    ) -> SinusoidalBasis:
+        """Create a basis with full-covariance Gaussian frequencies.
+
+        Frequencies are drawn ``W[:, j] ~ N(0, Sigma)`` via ``W = L @ W_hat`` with
+        ``W_hat ~ N(0, I_d)`` and ``Sigma = L L^T``.  Provide **exactly one** of
+        ``Sigma`` (the ``d x d`` covariance) or its lower-triangular Cholesky factor
+        ``L``.  This is the fixed full-``Sigma`` analogue of :meth:`random`
+        (isotropic) and :meth:`random_anisotropic` (axis-aligned), and uses the same
+        ``W = L @ W_hat`` reparameterisation as
+        :class:`~fastlsq.learnable.LearnableFastLSQ` -- so a swept covariance no
+        longer needs a hand-rolled ``chol(Sigma) @ randn``.
+        """
+        if (Sigma is None) == (L is None):
+            raise ValueError(
+                "random_covariance: provide exactly one of Sigma or L."
+            )
+        dev = get_device()
+        dt = torch.get_default_dtype()
+        if L is None:
+            Sigma_t = torch.as_tensor(Sigma, device=dev, dtype=dt)
+            L_t = torch.linalg.cholesky(Sigma_t)
+        else:
+            L_t = torch.as_tensor(L, device=dev, dtype=dt)
+        W_hat = torch.randn(input_dim, n_features, device=dev, dtype=L_t.dtype)
+        W = L_t @ W_hat
+        b = torch.rand(1, n_features, device=dev, dtype=L_t.dtype) * 2 * np.pi
+        return cls(W, b, normalize=normalize, dc_eps=dc_eps)
+
     # ------------------------------------------------------------------
     # Caching
     # ------------------------------------------------------------------

fastlsq-0.4.1/fastlsq/benchmark.py

@@ -0,0 +1,100 @@
+# Copyright (c) 2026 Antonin Sulc
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""Device-correct timing primitives for FastLSQ.
+
+Naively wall-clock-timing a CUDA solve is wrong: kernels are launched
+asynchronously, so ``t1 - t0`` measures launch overhead, not compute.  Without a
+``synchronize`` bracket every GPU number is meaningless (and irreproducible).
+:func:`time_solve` adds the missing primitive -- ``synchronize`` bracketing plus
+warm-up and a min-of-reps reduction -- so the reported solve time is the
+reproducible compute *floor* on any device (CPU / CUDA / Apple-MPS).
+
+    import fastlsq as fl
+    t = fl.benchmark.time_solve(lambda: fl.solve_lstsq(A, b))   # seconds, floor
+"""
+
+import time
+
+import torch
+
+from fastlsq.device import get_device
+
+
+def synchronize(device=None):
+    """Block until all queued work on ``device`` has finished.
+
+    No-op on CPU; calls ``torch.cuda.synchronize`` on CUDA and
+    ``torch.mps.synchronize`` on Apple-MPS (when available).  ``device=None``
+    uses the active FastLSQ device.
+    """
+    device = get_device() if device is None else torch.device(device)
+    if device.type == "cuda":
+        torch.cuda.synchronize(device)
+    elif device.type == "mps":
+        sync = getattr(getattr(torch, "mps", None), "synchronize", None)
+        if sync is not None:
+            sync()
+
+
+def time_solve(fn, reps=10, warmup=2, device=None, return_all=False):
+    """Device-correct timing floor for a callable.
+
+    Runs ``warmup`` unmeasured calls (allocator / autotune warm-up), then ``reps``
+    measured calls, each bracketed by :func:`synchronize` so CUDA/MPS asynchronous
+    execution is fully accounted for.  Returns the **minimum** elapsed time in
+    seconds -- the reproducible solve-time floor -- which is the right summary for
+    a deterministic op whose variance is pure system noise.
+
+    Parameters
+    ----------
+    fn : callable
+        Zero-argument callable performing the work to time, e.g.
+        ``lambda: solve_lstsq(A, b)``.
+    reps : int
+        Number of measured repetitions (>= 1).
+    warmup : int
+        Number of unmeasured warm-up repetitions.
+    device : str | torch.device | None
+        Device to synchronize around each call.  ``None`` uses the active FastLSQ
+        device.
+    return_all : bool
+        If True, return a stats dict
+        ``{"min", "median", "mean", "std", "times", "reps", "warmup", "device"}``
+        instead of the bare floor.
+
+    Returns
+    -------
+    float
+        The minimum solve time in seconds (``return_all=False``).
+    dict
+        Full timing statistics (``return_all=True``).
+    """
+    device = get_device() if device is None else torch.device(device)
+
+    for _ in range(max(0, warmup)):
+        fn()
+    synchronize(device)
+
+    times = []
+    for _ in range(max(1, reps)):
+        synchronize(device)
+        t0 = time.perf_counter()
+        fn()
+        synchronize(device)
+        times.append(time.perf_counter() - t0)
+
+    t = torch.tensor(times, dtype=torch.float64)
+    floor = float(t.min())
+    if not return_all:
+        return floor
+    return {
+        "min": floor,
+        "median": float(t.median()),
+        "mean": float(t.mean()),
+        "std": float(t.std(unbiased=False)),
+        "times": times,
+        "reps": len(times),
+        "warmup": max(0, warmup),
+        "device": str(device),
+    }

{fastlsq-0.4.0 → fastlsq-0.4.1}/fastlsq/export.py

@@ -3,6 +3,8 @@
 
 """Export utilities for FastLSQ solutions (NumPy, VTK, etc.)."""
 
+import time
+
 import torch
 import numpy as np
 from typing import Optional, Union, Dict, Any
@@ -10,6 +12,32 @@ from typing import Optional, Union, Dict, Any
 from fastlsq.solvers import FastLSQSolver
 
 
+def _provenance(solver: FastLSQSolver) -> Dict[str, Any]:
+    """Auto-recorded provenance for a saved model: library version, device, dtype,
+    and the realized frequency bandwidth (scale / Sigma) the model actually uses."""
+    import fastlsq  # lazy: avoids a circular import at module load
+
+    prov: Dict[str, Any] = {
+        "fastlsq_version": getattr(fastlsq, "__version__", None),
+        "created": time.time(),
+        "input_dim": solver.input_dim,
+        "n_features": solver.n_features,
+    }
+    W = torch.cat(solver.W_list, dim=1) if solver.W_list else None
+    ref = W if W is not None else solver.beta
+    if ref is not None:
+        prov["device"] = str(ref.device)
+        prov["dtype"] = str(ref.dtype).replace("torch.", "")
+    if W is not None:
+        # Realized frequency second moment Sigma = (W Wᵀ)/N and per-axis scale.
+        freq_cov = (W @ W.transpose(-2, -1)) / W.shape[1]
+        prov["freq_cov"] = freq_cov.cpu().numpy()
+        prov["freq_std"] = torch.sqrt(
+            torch.diagonal(freq_cov).clamp_min(0.0)
+        ).cpu().numpy()
+    return prov
+
+
 def to_numpy(
     solver: FastLSQSolver,
     x: Union[torch.Tensor, np.ndarray],
@@ -138,11 +166,14 @@ def save_checkpoint(
     path : str
         File path (.pt or .pth extension recommended).
     metadata : dict, optional
-        Additional metadata to save.
+        Additional metadata to save.  A ``provenance`` block (library version,
+        device, dtype, timestamp, and realized scale / Sigma) is auto-recorded
+        unless the caller supplies its own ``provenance`` key.
     """
     state = to_dict(solver, include_weights=True, include_metadata=True)
-    if metadata:
-        state["metadata"] = metadata
+    meta = dict(metadata) if metadata else {}
+    meta.setdefault("provenance", _provenance(solver))
+    state["metadata"] = meta
     torch.save(state, path)
 
 

{fastlsq-0.4.0 → fastlsq-0.4.1}/fastlsq/learnable.py

@@ -153,6 +153,20 @@ class LearnableFastLSQ(nn.Module):
         """
         return SinusoidalBasis(self._W(), self.b, normalize=self._normalize)
 
+    def freeze(self) -> SinusoidalBasis:
+        """Freeze the learned bandwidth into a plain, detached ``SinusoidalBasis``.
+
+        Unlike the :attr:`basis` property -- which reconstructs *with grad* on every
+        access -- this returns a fixed basis built from the current
+        ``W = L @ W_hat`` with the weights detached and cloned.  Run the (untimed)
+        bandwidth search, then ``freeze()`` the learned ``Sigma`` into this plain
+        basis for one clean, timed one-shot solve: the deployment artifact.
+        """
+        with torch.no_grad():
+            W = self._W().detach().clone()
+            b = self.b.detach().clone()
+        return SinusoidalBasis(W, b, normalize=self._normalize)
+
     # ------------------------------------------------------------------
     # Prediction
     # ------------------------------------------------------------------

{fastlsq-0.4.0 → fastlsq-0.4.1}/fastlsq/linalg.py

@@ -36,6 +36,7 @@ All back-ends are device/dtype-aware.  Apple-MPS lacks a robust ``svd``/``lstsq`
 so the factorization is run on CPU and the result moved back (one-time warning).
 """
 
+import time
 import warnings
 
 import torch
@@ -64,15 +65,18 @@ def _maybe_cpu(A, b):
 
 
 def _svd_solve(A, b, mu, rcond):
+    """Returns ``(x, S)`` where ``S`` is the singular values (descending) when an
+    explicit SVD is formed, else ``None`` (the fast LAPACK gelsd path)."""
     # Fast LAPACK rank-revealing driver for the common CPU / mu==0 case.
     if not mu and A.device.type == "cpu":
         try:
-            return torch.linalg.lstsq(A, b, rcond=rcond, driver="gelsd").solution
+            return torch.linalg.lstsq(A, b, rcond=rcond, driver="gelsd").solution, None
         except (RuntimeError, ValueError):
             pass  # fall through to the explicit SVD
     U, S, Vh = torch.linalg.svd(A, full_matrices=False)
     filt = torch.where(S > rcond * S[0], S / (S * S + mu), torch.zeros_like(S))
-    return Vh.transpose(-2, -1) @ (filt.unsqueeze(-1) * (U.transpose(-2, -1) @ b))
+    x = Vh.transpose(-2, -1) @ (filt.unsqueeze(-1) * (U.transpose(-2, -1) @ b))
+    return x, S
 
 
 def _cholesky_solve(A, b, mu):
@@ -99,7 +103,8 @@ def _rsvd_solve(A, b, mu, rcond, rank, oversample, n_iter):
     Ub, S, Vh = torch.linalg.svd(B, full_matrices=False)
     U = Q @ Ub                                     # (m, k)
     filt = torch.where(S > rcond * S[0], S / (S * S + mu), torch.zeros_like(S))
-    return Vh.transpose(-2, -1) @ (filt.unsqueeze(-1) * (U.transpose(-2, -1) @ b))
+    x = Vh.transpose(-2, -1) @ (filt.unsqueeze(-1) * (U.transpose(-2, -1) @ b))
+    return x, S                                    # S is the truncated (rank-k) spectrum
 
 
 def _qr_solve(A, b, mu):
@@ -116,13 +121,15 @@ def _qr_solve(A, b, mu):
 
 
 def _auto_solve(A, b, mu, rcond):
+    """Returns ``(x, S)``; ``S`` is the singular values only when the SVD safety
+    net is taken (the Cholesky / QR fast paths return ``None``)."""
     # Cheap conditioning probe: cond(A) ~ max/min Cholesky pivot.  If well within
     # float64's reach use the fast Cholesky.
     try:
         x, L = _cholesky_solve(A, b, mu)
         d = torch.diagonal(L).abs()
         if torch.isfinite(d).all() and d.min() > (rcond ** 0.25) * d.max():
-            return x
+            return x, None
     except torch.linalg.LinAlgError:
         pass
     # Ill-conditioned.  On CPU with no ridge the LAPACK gelsd driver is both
@@ -137,12 +144,43 @@ def _auto_solve(A, b, mu, rcond):
     x = _qr_solve(A, b, mu)
     nx = torch.linalg.vector_norm(x)
     if torch.isfinite(nx) and nx <= _QR_AUTO_NORM_GUARD * (1.0 + torch.linalg.vector_norm(b)):
-        return x
+        return x, None
     return _svd_solve(A, b, mu, rcond)
 
 
+def _dispatch(A, b, mu, rcond, method, rank, oversample, n_iter):
+    """Run the requested back-end; returns ``(x, S)`` where ``S`` is the singular
+    values when the back-end already computed an SVD, else ``None``."""
+    if method == "auto":
+        return _auto_solve(A, b, mu, rcond)
+    elif method == "svd":
+        return _svd_solve(A, b, mu, rcond)
+    elif method == "qr":
+        return _qr_solve(A, b, mu), None
+    elif method == "cholesky":
+        return _cholesky_solve(A, b, mu)[0], None
+    elif method == "rsvd":
+        return _rsvd_solve(A, b, mu, rcond, rank, oversample, n_iter)
+    else:
+        raise ValueError(f"Unknown method {method!r}; "
+                         "choose 'auto', 'qr', 'svd', 'cholesky', or 'rsvd'.")
+
+
+def _sync_device(device):
+    """Block until queued work on ``device`` finishes (no-op off CUDA/MPS).
+
+    Without this an async CUDA solve's wall-clock measures only kernel-launch
+    overhead, not compute -- the same primitive ``fastlsq.benchmark`` uses."""
+    if device.type == "cuda":
+        torch.cuda.synchronize(device)
+    elif device.type == "mps":
+        sync = getattr(getattr(torch, "mps", None), "synchronize", None)
+        if sync is not None:
+            sync()
+
+
 def solve_lstsq(A, b, mu=0.0, rcond=1e-12, method="auto",
-                rank=None, oversample=10, n_iter=4):
+                rank=None, oversample=10, n_iter=4, *, return_info=False):
     """Solve  min ||A x - b||^2 + mu ||x||^2.
 
     Parameters
@@ -159,23 +197,50 @@ def solve_lstsq(A, b, mu=0.0, rcond=1e-12, method="auto",
     rank, oversample, n_iter : int
         Randomized-SVD parameters (``method="rsvd"`` only).  Set ``rank`` << N for
         the speed-up; ``None`` uses the full rank (correct but no acceleration).
+    return_info : bool, optional
+        If True, return ``(x, info)`` with a per-solve diagnostics dict
+        ``{"t_solve", "rank_used", "residual", "cond_estimate"}`` instead of just
+        ``x``.  ``t_solve`` is the device-synced wall-time of the **solve step
+        only** (not assembly or scale search); ``rank_used`` is the rank-revealing
+        effective numerical rank (singular values above ``rcond``); ``residual`` is
+        the data residual ``||A x - b||``; ``cond_estimate`` is ``s_max / s_min``
+        over the retained subspace.  The diagnostic singular values are computed
+        *outside* the timed region (one extra ``svdvals`` when the chosen back-end
+        did not already form an SVD), so ``t_solve`` stays honest.
 
     Returns
     -------
     x : Tensor, shape (N, K)
+    info : dict, only if ``return_info=True``
     """
     A2, b2, mps_dev = _maybe_cpu(A, b)
-    if method == "auto":
-        x = _auto_solve(A2, b2, mu, rcond)
-    elif method == "svd":
-        x = _svd_solve(A2, b2, mu, rcond)
-    elif method == "qr":
-        x = _qr_solve(A2, b2, mu)
-    elif method == "cholesky":
-        x = _cholesky_solve(A2, b2, mu)[0]
-    elif method == "rsvd":
-        x = _rsvd_solve(A2, b2, mu, rcond, rank, oversample, n_iter)
+
+    if not return_info:
+        x, _ = _dispatch(A2, b2, mu, rcond, method, rank, oversample, n_iter)
+        return x.to(mps_dev) if mps_dev is not None else x
+
+    _sync_device(A2.device)
+    t0 = time.perf_counter()
+    x, S = _dispatch(A2, b2, mu, rcond, method, rank, oversample, n_iter)
+    _sync_device(A2.device)
+    t_solve = time.perf_counter() - t0
+
+    # Diagnostics (untimed): reuse the back-end's spectrum, else one extra SVD.
+    if S is None:
+        S = torch.linalg.svdvals(A2)
+    smax = S[0]
+    keep = S > rcond * smax
+    rank_used = int(keep.sum().item())
+    if rank_used > 0:
+        cond_estimate = float((smax / S[keep][-1]).item())
     else:
-        raise ValueError(f"Unknown method {method!r}; "
-                         "choose 'auto', 'qr', 'svd', 'cholesky', or 'rsvd'.")
-    return x.to(mps_dev) if mps_dev is not None else x
+        cond_estimate = float("inf")
+    residual = float((A2 @ x - b2).norm().item())
+    info = {
+        "t_solve": t_solve,
+        "rank_used": rank_used,
+        "residual": residual,
+        "cond_estimate": cond_estimate,
+    }
+    x_out = x.to(mps_dev) if mps_dev is not None else x
+    return x_out, info

{fastlsq-0.4.0 → fastlsq-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "FastLSQ"
-version = "0.4.0"
+version = "0.4.1"
 description = "One-shot PDE solving via Fourier features with exact analytical derivatives; rank-revealing solvers, learnable anisotropic bandwidth, and CPU/CUDA/MPS support"
 readme = "README.md"
 license = "MIT"