FastLSQ 0.1.5__tar.gz → 0.2.2__tar.gz

fastlsq-0.2.2/CHANGELOG.md

@@ -0,0 +1,249 @@
+# Changelog
+
+All notable changes to FastLSQ will be documented in this file.
+
+## [0.2.2] - 2026-06-03
+
+### Fixed
+
+- **Learnable bandwidth now trains.** `LearnableFastLSQ.solve_inner` replaced the
+  backprop-through-`torch.linalg.svd` inner solve (which returned NaN gradients
+  w.r.t. the bandwidth on the clustered singular values of random-feature
+  matrices) with the SVD-based `gelsd` rank-revealing least-squares driver, so
+  `train_bandwidth` / `fit` no longer stall at step 0.
+- **Default-solve accuracy.** Tightened the `_auto_solve` Cholesky-acceptance
+  probe from `rcond**0.5` to `rcond**0.25`, so `method="auto"` falls back to SVD
+  before the normal-equations Cholesky loses half its float64 digits
+  (cond(A) ~ 1e7 previously returned a ~1e-3-accurate answer).
+- **Newton convergence and robustness.** The stop test now combines a *relative*
+  residual criterion (`res_norm < tol_res * R0`) with the relative solution
+  change (`||Δu||/||u|| < tol_du`); the previous unreachable absolute residual
+  tolerance forced every nonlinear solve to run the full `max_iter`. The
+  backtracking line search keeps the previous iterate when no step satisfies
+  Armijo instead of committing a worse point. `solve_nonlinear` default
+  tolerances loosened to `tol_res=1e-8`, `tol_du=1e-10`.
+- **Continuation guard.** `solve_nonlinear` no longer raises `TypeError` when a
+  problem sets `use_continuation=True` without a `nu_target`.
+- **Regression problems solvable via the public API.** Their `get_train_data`
+  now accepts the `n_pde`/`n_bc` signature used by `solve_linear`,
+  `auto_select_scale`, and `check_problem` (was `n_samples`, raising
+  `TypeError`); `auto_select_scale` now raises when every trial fails instead of
+  silently returning the first scale.
+- **Float32 inputs.** `SinusoidalBasis.cache` promotes inputs to the basis
+  dtype/device, so float32 collocation points no longer raise `float != double`.
+- **Checkpoint reload.** `load_checkpoint` passes `weights_only=False`, fixing
+  `UnpicklingError` on torch >= 2.6 (checkpoints store NumPy arrays).
+- **Vector per-component scale.** `VectorFastLSQSolver.add_block` accepts a NumPy
+  array of per-component bandwidths (previously list/tuple only, silently
+  misread as per-dimension).
+- **ElasticWave2D operator.** Scaled the spatial and cross terms by `t_max²`
+  (time normalisation), consistent with `Wave2D_MS`.
+
+### Changed
+
+- Problem modules (`nonlinear.py`, `regression.py`) resolve the device via the
+  live `get_device()` rather than an import-time snapshot.
+- Packaging: the source distribution no longer ships the `misc/` images (the
+  sdist was ~14 MB); project URLs point to `github.com/sulcantonin/FastLSQ`;
+  README images use absolute URLs so they render on PyPI.
+  `examples/orbit_hill.py` solves via rank-revealing `lstsq` rather than a
+  normal-equations Cholesky.
+
+## [0.2.1] - 2026-06-02
+
+### Added
+
+- **Device abstraction** (`fastlsq/device.py`): `resolve_device`, `set_device`,
+  `get_device`, `device_info` for CPU / CUDA / Apple-MPS. dtype-aware -- MPS is
+  auto-selected only for float32 (it has no float64), so the default float64
+  high-accuracy regime stays on CPU/CUDA. Override with `set_device(...)` or the
+  `FASTLSQ_DEVICE` environment variable; internal tensor creation respects the
+  active device at call time.
+- **Pluggable linear solver** `solve_lstsq(..., method=...)`:
+  - `"svd"` -- rank-revealing truncated SVD (LAPACK `gelsd` fast path on CPU);
+  - `"cholesky"` -- fast normal-equations solve for well-conditioned systems;
+  - `"rsvd"` -- torch-native randomized SVD (`O(MNk)`) for strongly low-rank `A`;
+  - `"auto"` (default) -- Cholesky with a cheap conditioning probe, falling back
+    to SVD when ill-conditioned (recovers the fast path without losing accuracy).
+  MPS factorizations run on CPU (no robust `svd`/`lstsq` there) and move back.
+- **Working anisotropic Sigma = L Lᵀ learner**: `LearnableFastLSQ` (diagonal &
+  cholesky modes) now converges -- `solve_inner` uses a differentiable
+  *rank-revealing* solve, the Cholesky factor is log-parameterized (clamped,
+  positive-definite), and `train_bandwidth` is robust (gradient clipping,
+  best-iterate restore, graceful SVD/gradient-failure handling). Chainable
+  `LearnableFastLSQ.fit(problem, ...)` for one-line learn-then-predict.
+- **Vector-valued solutions (`u: ℝᵈ → ℝᵏ`)**: first-class support for coupled and
+  decoupled multi-output PDEs via the new `fastlsq.block` module. Problems opt in
+  with `self.n_outputs = k`; `solver.beta` is `(N, k)` and `solver.predict(x)`
+  returns `(M, k)` (scalar `k=1` is bit-for-bit unchanged). `block_concat`
+  assembles a nested list of blocks (`None` = zero block); `pack_beta` /
+  `unpack_beta` convert between `(N, k)` and the block-stacked `(N*k, 1)` solve.
+  The block-stacked LSQ is solved by the rank-revealing solver, and the
+  Σ-learner computes its loss on the flat `_beta_flat` so it stays correct for
+  `k>1`.
+- **Learnable operator coefficients**: `Op` accepts `nn.Parameter` (and tensors)
+  as coefficients, e.g. `Op.laplacian(d=2) + k**2 * Op.identity(d=2)` with
+  `k = nn.Parameter(...)`; gradients flow through the prebuilt linear solve.
+
+### Changed
+
+- `solve_lstsq` defaults to the rank-revealing / `auto` solve instead of forming
+  the normal equations -- several orders of magnitude more accurate on the
+  rank-deficient random-feature systems (at a higher, still one-shot, cost).
+- `solve_linear` is one-shot: the bandwidth-learning hyper-parameters live on
+  `LearnableFastLSQ.fit()` / `train_bandwidth`, not the solve signature.
+- Packaging: `requires-python` lowered to `>=3.9` (+3.9 classifier); description
+  updated.
+
+### Fixed
+
+- The previously dead `LearnableFastLSQ(mode="cholesky")` path, which diverged
+  from an unstable inner `torch.linalg.lstsq` and an unconstrained `L`.
+
+## [0.1.5] - 2026-05-25
+
+### Added
+
+- **Vector-valued features**: new `VectorBasis` and `VectorFastLSQSolver`
+  (`fastlsq/vector.py`) for solving coupled systems where the unknown is a
+  vector field `u(x) = (u_1, ..., u_K)`.  Use cases include
+  streamfunction-vorticity NS `(psi, omega)`, incompressible NS primitive
+  variables `(u, v, p)`, multi-species transport, MHD, etc.
+
+  - `VectorBasis.random(input_dim, n_features, sigma, n_components, sigmas=...)`
+    creates K independent random-Fourier `SinusoidalBasis`es; per-component
+    bandwidth can be tuned via `sigmas`.
+  - Stacked evaluators: `evaluate(x) -> (M, K, N)`, `gradient -> (M, K, d, N)`,
+    `laplacian`, `hessian_diag`, `derivative(alpha)`.
+  - Block-diagonal assembly helpers (`block_diag_evaluate`,
+    `block_diag_laplacian`, `block_diag_derivative`) for systems whose
+    rows are independent per component.
+  - Coefficient packing utilities (`stack_betas`, `unstack_beta`,
+    `predict`) accept per-component lists, stacked columns, or
+    `(N, K)` matrices interchangeably.
+  - `VectorFastLSQSolver(input_dim, n_components, normalize=True)` is the
+    multi-component counterpart of `FastLSQSolver`; `add_block(scale=...)`
+    accepts either a scalar or a list of K scalars for per-component
+    bandwidth.
+  - `component(k)` / `component_solver(k)` give direct access to the k-th
+    scalar basis / solver for ad-hoc per-component work.
+
+### Other
+
+- Synchronised `pyproject.toml`, `fastlsq.__version__`, and CHANGELOG (the
+  package source had drifted to `__version__ = "0.1.0"` against
+  `pyproject.toml = "0.1.4"`; both now read `"0.1.5"`).
+
+## [0.2.0] - 2026-03-01
+
+### Added
+
+#### SinusoidalBasis -- analytical derivative engine (new foundation)
+- `SinusoidalBasis` class: evaluates arbitrary-order mixed partial derivatives
+  of sinusoidal features in O(1) via the cyclic derivative identity
+- `BasisCache`: pre-computes sin(Z)/cos(Z) once, reuses across all derivative
+  evaluations at the same points
+- `DiffOperator` / `Op`: symbolic linear differential operators that compose
+  via `+`, `-`, scalar `*`.  Factory methods: `Op.laplacian()`,
+  `Op.partial()`, `Op.identity()`, `Op.biharmonic()`, `Op.gradient_component()`
+- `FeatureBasis`: adapter wrapping non-sinusoidal solvers (e.g. PIELMSolver
+  with tanh) into the same basis interface
+
+#### Learnable bandwidth
+- `LearnableFastLSQ`: PyTorch `nn.Module` with learnable bandwidth via
+  reparameterisation trick (scalar, diagonal, or full Cholesky modes)
+- `train_bandwidth()`: hybrid training loop (inner exact solve + outer AdamW
+  on bandwidth parameters)
+
+#### PDE discovery example
+- `examples/pde_discovery.py`: sparse regression (SINDy-style) using
+  analytical derivatives from `SinusoidalBasis` as the dictionary
+
+### Changed
+
+#### Architecture: basis-centric API (breaking)
+- **`solver.basis`** is now the single entry point for all feature and
+  derivative computations.  Every solver exposes a `.basis` property
+  (`SinusoidalBasis` for FastLSQ, `FeatureBasis` for PIELM).
+- All problem classes (`linear.py`, `nonlinear.py`, `regression.py`) rewritten
+  to use `solver.basis.evaluate()`, `.gradient()`, `.hessian_diag()`,
+  `.laplacian()`, and `.cache()` instead of tuple unpacking.
+- `FastLSQSolver.predict()`, `.predict_with_grad()`, `.predict_with_laplacian()`
+  delegate directly to `self.basis`.
+- `PIELMSolver` now exposes `.basis` (via `FeatureBasis` adapter) so problem
+  classes work identically for both solver types.
+- `newton.py`: uses `solver.basis.evaluate()` for convergence metrics.
+
+#### Examples rewritten
+- `add_your_own_pde.py`: shows `Op`-based PDE definition only
+- `custom_features.py`: shows cosine features via phase shift only
+
+### Removed
+- `get_features()` method removed from public API (all solvers, all problems)
+- `SinusoidalBasis.get_features()` legacy tuple interface removed
+- `CustomFeatureSolver` subclass pattern removed
+- Legacy `build()` patterns using `(H, dH, ddH)` tuple unpacking
+
+### Fixed
+- Missing `sample_ball` import in `tests/test_basic.py`
+
+
+## [0.1.0] - 2026-02-12
+
+### Added
+
+#### High-level API
+- `solve_linear()` - One-line function to solve linear PDEs
+- `solve_nonlinear()` - One-line function to solve nonlinear PDEs via Newton-Raphson
+- Automatic scale selection via `auto_select_scale()`
+
+#### Plotting & Visualization
+- `plot_solution_1d()` - Plot 1D solutions with exact comparison
+- `plot_solution_2d_slice()` - Plot 2D solutions as 1D slices
+- `plot_solution_2d_contour()` - Contour plots for 2D solutions
+- `plot_convergence()` - Newton iteration convergence plots
+- `plot_spectral_sensitivity()` - Error vs scale analysis
+
+#### Geometry & Sampling
+- `sample_box()` - Uniform sampling from hypercubes
+- `sample_ball()` - Uniform sampling from balls
+- `sample_sphere()` - Uniform sampling from sphere surfaces
+- `sample_interval()` - 1D interval sampling
+- `sample_boundary_box()` - Boundary point generation for boxes
+- `get_sampler()` - Get sampler by name
+
+#### Diagnostics & Error Handling
+- `check_problem()` - Validate problem definitions (shapes, gradients, data)
+- `check_solver_conditioning()` - Check linear system conditioning
+- `suggest_scale()` - Heuristic scale suggestions
+
+#### Export & Interoperability
+- `to_numpy()` - Convert predictions to NumPy arrays
+- `to_dict()` / `from_dict()` - Serialize/deserialize solver state
+- `save_checkpoint()` / `load_checkpoint()` - Save/load solver checkpoints
+- `FastLSQModule` - PyTorch Lightning integration (optional)
+
+#### Documentation & Examples
+- `examples/tutorial_basic.py` - Basic linear PDE tutorial
+- `examples/tutorial_nonlinear.py` - Nonlinear PDE tutorial
+- `examples/add_your_own_pde.py` - Guide for adding custom PDEs
+- `examples/custom_features.py` - Extensibility example
+- Comprehensive README with usage examples
+
+#### Infrastructure
+- `benchmarks/run_all.py` - Reproducible benchmark suite
+- `tests/test_basic.py` - Basic test suite
+- `.github/workflows/ci.yml` - GitHub Actions CI/CD
+- `CHANGELOG.md` - This file
+
+### Changed
+
+- Restructured codebase from 2 monolithic files into a proper Python package
+- Unified `FastLSQSolver` with optional normalization parameter
+- Removed code duplication (Bratu, NL-Helmholtz regression inherit from nonlinear versions)
+- Removed non-scientific content (emojis, casual language)
+
+### Fixed
+
+- Fixed missing `solve_lstsq` import in linear solver (was only defined in nonlinear file)
+- Improved error messages and diagnostics

{fastlsq-0.1.5 → fastlsq-0.2.2/FastLSQ.egg-info}/PKG-INFO

@@ -1,25 +1,26 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.1.5
-Summary: Solving PDEs in one shot via Fourier features with exact analytical derivatives
+Version: 0.2.2
+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
-Project-URL: Homepage, https://github.com/asulc/FastLSQ
-Project-URL: Repository, https://github.com/asulc/FastLSQ
+Project-URL: Homepage, https://github.com/sulcantonin/FastLSQ
+Project-URL: Repository, https://github.com/sulcantonin/FastLSQ
 Project-URL: Paper, https://arxiv.org/abs/2602.10541
-Project-URL: Bug Tracker, https://github.com/asulc/FastLSQ/issues
-Project-URL: Changelog, https://github.com/asulc/FastLSQ/blob/main/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/sulcantonin/FastLSQ/issues
+Project-URL: Changelog, https://github.com/sulcantonin/FastLSQ/blob/main/CHANGELOG.md
 Keywords: pde,partial-differential-equations,fourier-features,least-squares,scientific-computing,neural-network,physics-informed,newton-raphson
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Physics
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: torch>=2.0
@@ -44,7 +45,7 @@ Dynamic: license-file
 
 
 <p align="center">
-  <img src="misc/fastlsq_teaser.png" alt="FastLSQ method overview" width="400"/>
+  <img src="https://raw.githubusercontent.com/sulcantonin/FastLSQ/main/misc/fastlsq_teaser.png" alt="FastLSQ method overview" width="400"/>
 </p>
 
 **Solving PDEs in one shot via Fourier features with exact analytical derivatives.**
@@ -234,8 +235,8 @@ python examples/learnable_helmholtz.py
 The analytical derivatives enable gradients through the pre-factored solve, making inverse problems tractable. Example: recovering 4 anisotropic Gaussian heat sources (24 parameters) from 4 sparse sensors. The heat equation is solved in space-time; L-BFGS-B optimises source positions and shapes to match sensor time-series. *(Click image for animation.)*
 
 <p align="center">
-  <a href="misc/inverse_heat_source.gif">
-    <img src="misc/inverse_heat_source.png" alt="Inverse heat source localisation" width="700"/>
+  <a href="https://raw.githubusercontent.com/sulcantonin/FastLSQ/main/misc/inverse_heat_source.gif">
+    <img src="https://raw.githubusercontent.com/sulcantonin/FastLSQ/main/misc/inverse_heat_source.png" alt="Inverse heat source localisation" width="700"/>
   </a>
 </p>
 

fastlsq-0.2.2/FastLSQ.egg-info/SOURCES.txt

@@ -0,0 +1,106 @@
+CHANGELOG.md
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+FastLSQ.egg-info/PKG-INFO
+FastLSQ.egg-info/SOURCES.txt
+FastLSQ.egg-info/dependency_links.txt
+FastLSQ.egg-info/requires.txt
+FastLSQ.egg-info/top_level.txt
+examples/add_your_own_pde.py
+examples/benchmark_comparison.py
+examples/custom_features.py
+examples/grad_shafranov.py
+examples/grid_inverse.py
+examples/grid_rl_control.py
+examples/grid_swing.py
+examples/gs_inverse.py
+examples/gs_rl_control.py
+examples/inverse_heat_source.py
+examples/inverse_magnetostatics.py
+examples/inverse_source_position.py
+examples/learnable_helmholtz.py
+examples/orbit_hill.py
+examples/orbit_inverse.py
+examples/orbit_rl.py
+examples/pde_discovery.py
+examples/run_all_extensions.py
+examples/run_linear.py
+examples/run_nonlinear.py
+examples/tutorial_basic.py
+examples/tutorial_nonlinear.py
+examples/vector_basis_stream_vorticity.py
+examples/extras/fred_sde.py
+examples/extras/fred_sde_fastlsq.py
+examples/extras/gaia_potential.py
+examples/extras/gaia_potential_fastlsq.py
+examples/extras/horizons_ephemeris.py
+examples/extras/numerai_alpha.py
+examples/extras/numerai_alpha_fastlsq.py
+examples/extras/run_all_fastlsq.py
+examples/extras/spectral_expansion.py
+examples/extras/scenarios/__init__.py
+examples/extras/scenarios/_alsu_lattice.py
+examples/extras/scenarios/_common.py
+examples/extras/scenarios/run_all.py
+examples/extras/scenarios/s01_beamloss_ode.py
+examples/extras/scenarios/s01_betatron_tune.py
+examples/extras/scenarios/s01_green_fff.py
+examples/extras/scenarios/s01_hill_ivp.py
+examples/extras/scenarios/s01_observe_fit_act_simulator.py
+examples/extras/scenarios/s01_orbit_inverse.py
+examples/extras/scenarios/s01_passive_loco.py
+examples/extras/scenarios/s01_perturbed_hill.py
+examples/extras/scenarios/s01_sofb_observe_fit_act.py
+examples/extras/scenarios/s01_streaming_archive_growth.py
+examples/extras/scenarios/s01_synchrotron_ode.py
+examples/extras/scenarios/s01_tides_3months.py
+examples/extras/scenarios/s01_topoff_impulse.py
+examples/extras/scenarios/s01_visualize.py
+examples/extras/scenarios/s02_plasma_wakefield.py
+examples/extras/scenarios/s03_synchrobetatron.py
+examples/extras/scenarios/s04_sunspots.py
+examples/extras/scenarios/s05_helioseismology.py
+examples/extras/scenarios/s06_tides.py
+examples/extras/scenarios/s07_iers_earth_rotation.py
+examples/extras/scenarios/s08_mauna_loa_co2.py
+examples/extras/scenarios/s09_enso_qbo.py
+examples/extras/scenarios/s10_pulsar_timing.py
+examples/extras/scenarios/s11_modal_analysis.py
+examples/extras/scenarios/s12_mems_resonator.py
+examples/extras/scenarios/s13_variable_stars_kepler.py
+examples/extras/scenarios/s14_eeg.py
+examples/extras/scenarios/s15_circadian.py
+fastlsq/__init__.py
+fastlsq/api.py
+fastlsq/basis.py
+fastlsq/block.py
+fastlsq/device.py
+fastlsq/diagnostics.py
+fastlsq/export.py
+fastlsq/geometry.py
+fastlsq/learnable.py
+fastlsq/lightning.py
+fastlsq/linalg.py
+fastlsq/newton.py
+fastlsq/plotting.py
+fastlsq/solvers.py
+fastlsq/tuning.py
+fastlsq/utils.py
+fastlsq/vector.py
+fastlsq/viz.py
+fastlsq/problems/__init__.py
+fastlsq/problems/linear.py
+fastlsq/problems/nonlinear.py
+fastlsq/problems/regression.py
+tests/test_basic.py
+tests/test_block.py
+tests/test_derivatives.py
+tests/test_device.py
+tests/test_grad_shafranov.py
+tests/test_grid_swing.py
+tests/test_learnable.py
+tests/test_orbit_hill.py
+tests/test_vector_basis.py

{fastlsq-0.1.5 → fastlsq-0.2.2}/MANIFEST.in

@@ -2,7 +2,6 @@ include LICENSE
 include README.md
 include CHANGELOG.md
 include requirements.txt
-recursive-include misc *.png *.gif
 recursive-include examples *.py
 recursive-include tests *.py
 recursive-exclude * __pycache__

{fastlsq-0.1.5/FastLSQ.egg-info → fastlsq-0.2.2}/PKG-INFO

@@ -1,25 +1,26 @@
 Metadata-Version: 2.4
 Name: FastLSQ
-Version: 0.1.5
-Summary: Solving PDEs in one shot via Fourier features with exact analytical derivatives
+Version: 0.2.2
+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
-Project-URL: Homepage, https://github.com/asulc/FastLSQ
-Project-URL: Repository, https://github.com/asulc/FastLSQ
+Project-URL: Homepage, https://github.com/sulcantonin/FastLSQ
+Project-URL: Repository, https://github.com/sulcantonin/FastLSQ
 Project-URL: Paper, https://arxiv.org/abs/2602.10541
-Project-URL: Bug Tracker, https://github.com/asulc/FastLSQ/issues
-Project-URL: Changelog, https://github.com/asulc/FastLSQ/blob/main/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/sulcantonin/FastLSQ/issues
+Project-URL: Changelog, https://github.com/sulcantonin/FastLSQ/blob/main/CHANGELOG.md
 Keywords: pde,partial-differential-equations,fourier-features,least-squares,scientific-computing,neural-network,physics-informed,newton-raphson
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Physics
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: torch>=2.0
@@ -44,7 +45,7 @@ Dynamic: license-file
 
 
 <p align="center">
-  <img src="misc/fastlsq_teaser.png" alt="FastLSQ method overview" width="400"/>
+  <img src="https://raw.githubusercontent.com/sulcantonin/FastLSQ/main/misc/fastlsq_teaser.png" alt="FastLSQ method overview" width="400"/>
 </p>
 
 **Solving PDEs in one shot via Fourier features with exact analytical derivatives.**
@@ -234,8 +235,8 @@ python examples/learnable_helmholtz.py
 The analytical derivatives enable gradients through the pre-factored solve, making inverse problems tractable. Example: recovering 4 anisotropic Gaussian heat sources (24 parameters) from 4 sparse sensors. The heat equation is solved in space-time; L-BFGS-B optimises source positions and shapes to match sensor time-series. *(Click image for animation.)*
 
 <p align="center">
-  <a href="misc/inverse_heat_source.gif">
-    <img src="misc/inverse_heat_source.png" alt="Inverse heat source localisation" width="700"/>
+  <a href="https://raw.githubusercontent.com/sulcantonin/FastLSQ/main/misc/inverse_heat_source.gif">
+    <img src="https://raw.githubusercontent.com/sulcantonin/FastLSQ/main/misc/inverse_heat_source.png" alt="Inverse heat source localisation" width="700"/>
   </a>
 </p>
 

{fastlsq-0.1.5 → fastlsq-0.2.2}/README.md

@@ -4,7 +4,7 @@
 
 
 <p align="center">
-  <img src="misc/fastlsq_teaser.png" alt="FastLSQ method overview" width="400"/>
+  <img src="https://raw.githubusercontent.com/sulcantonin/FastLSQ/main/misc/fastlsq_teaser.png" alt="FastLSQ method overview" width="400"/>
 </p>
 
 **Solving PDEs in one shot via Fourier features with exact analytical derivatives.**
@@ -194,8 +194,8 @@ python examples/learnable_helmholtz.py
 The analytical derivatives enable gradients through the pre-factored solve, making inverse problems tractable. Example: recovering 4 anisotropic Gaussian heat sources (24 parameters) from 4 sparse sensors. The heat equation is solved in space-time; L-BFGS-B optimises source positions and shapes to match sensor time-series. *(Click image for animation.)*
 
 <p align="center">
-  <a href="misc/inverse_heat_source.gif">
-    <img src="misc/inverse_heat_source.png" alt="Inverse heat source localisation" width="700"/>
+  <a href="https://raw.githubusercontent.com/sulcantonin/FastLSQ/main/misc/inverse_heat_source.gif">
+    <img src="https://raw.githubusercontent.com/sulcantonin/FastLSQ/main/misc/inverse_heat_source.png" alt="Inverse heat source localisation" width="700"/>
   </a>
 </p>