rbflab 0.1.0__tar.gz

rbflab-0.1.0/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.1.0
+
+- Curated six symbolic and numerical starting examples.
+- Added `unit_box_grid` for small 2D/3D problems without Gmsh.
+- Documented installation, optional backends, precision stages, and current
+  capability limits.
+- Added optional 2D field plots and GIF animation, with reproducible README
+  images generated from numerical heat and Stokes solutions.
+- Added a standalone Re=100 staggered RBF-FD Navier–Stokes cavity example and
+  an optional nodal-velocity GIF/streamline plotting helper.

rbflab-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Louis Breton
+
+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.

rbflab-0.1.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md README_PYPI.md CHANGELOG.md LICENSE RELEASE_CHECKLIST.md
+include docs/INSTALL.md docs/CAPABILITIES.md docs/VISUALIZATION.md docs/guides/LID_DRIVEN_CAVITY.md
+recursive-include docs/assets *.png *.gif
+recursive-include examples *.py
+recursive-include cpp *.cpp *.hpp *.cu *.sh *.md
+prune tests
+global-exclude __pycache__ *.py[cod] *.exe

rbflab-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: rbflab
+Version: 0.1.0
+Summary: RBFLAB: radial basis functions for interpolation and PDEs
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/LDBreton/RBFLAB
+Project-URL: Repository, https://github.com/LDBreton/RBFLAB
+Project-URL: Issues, https://github.com/LDBreton/RBFLAB/issues
+Keywords: radial basis functions,meshless,PDE,RBF-FD,collocation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.11
+Requires-Dist: sympy>=1.12
+Requires-Dist: mpmath>=1.3
+Requires-Dist: threadpoolctl>=3.5
+Provides-Extra: torch
+Requires-Dist: torch>=2.2; extra == "torch"
+Provides-Extra: fast
+Requires-Dist: gmpy2>=2.2; extra == "fast"
+Provides-Extra: mesh
+Requires-Dist: gmsh>=4.12; extra == "mesh"
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Provides-Extra: examples
+Requires-Dist: matplotlib>=3.8; extra == "examples"
+Requires-Dist: pillow>=10; extra == "examples"
+Dynamic: license-file
+
+# RBFLAB
+
+RBFLAB is a Python library for radial basis function interpolation and PDEs on
+point clouds. It supports global collocation, local Hermite interpolation
+(LHI), RBF-FD, symbolic linear operators and boundary conditions, and
+divergence-free velocity spaces. Scalar operators work in 2D and 3D.
+
+Source and examples: https://github.com/LDBreton/RBFLAB
+
+Install the Python core with:
+
+```sh
+python -m pip install rbflab
+```
+
+Optional extras include `rbflab[examples]` for Matplotlib plots and GIFs,
+`rbflab[mesh]` for Gmsh, and `rbflab[torch]` for the documented CPU Float64
+tensor backend. The C++ double/MPFR backends are source-build options.
+
+Here is a symbolic Poisson problem:
+
+```python
+import sympy as sp
+import rbflab as rbf
+
+model = rbf.SymbolicScalar(2)
+u = model.field
+x, y = model.coordinates
+exact = sp.sin(sp.pi*x) * sp.sin(sp.pi*y)
+lhs = -model.laplacian(u)
+problem = model.stationary(
+    sp.Eq(lhs, lhs.subs(u, exact).doit()),
+    boundary=[model.bc("boundary", sp.Eq(u, 0))],
+)
+cloud = rbf.unit_box_grid(5)
+solution = problem.solve(
+    cloud, rbf.GlobalCollocation(rbf.IMQ(2), scheme="asymmetric")
+)
+print(solution.evaluate([[0.3, 0.4]]))
+```
+
+The source repository also contains short heat, Stokes, 3D operator, custom
+kernel, and Re=100 lid-driven cavity examples. The cavity example is a
+showcase with a documented nonzero discrete divergence defect; it does not
+validate a general Navier–Stokes solver. LHI off-node reconstruction has its
+own accuracy limitations, and MPFR local weights do not automatically make a
+global sparse solve extended precision.
+
+RBFLAB is licensed under MIT.

rbflab-0.1.0/README.md

@@ -0,0 +1,129 @@
+# RBFLAB
+
+RBFLAB solves interpolation and linear PDE problems on point clouds with radial
+basis functions. Write an equation with SymPy, choose global collocation,
+local Hermite interpolation (LHI), or RBF-FD, then inspect the result.
+
+The default installation uses Python, NumPy, and SciPy. C++ and PyTorch are
+optional numerical backends for supported local methods. The package supports
+2D and 3D scalar methods and divergence-free approximation spaces.
+
+![Three snapshots of a numerical heat pulse evolving on a point cloud](docs/assets/heat_diffusion.png)
+
+*The heat pulse comes from a symbolic PDE solved with global RBF collocation;
+the faint dots in the first panel are the collocation nodes. The display grid
+only samples the computed solution.*
+
+## Install
+
+From this source checkout:
+
+```sh
+python -m pip install .
+```
+
+The default installation does not require Gmsh, a compiler, or PyTorch. See
+[the installation guide](docs/INSTALL.md) for optional features. A PyPI
+release will add `python -m pip install rbflab`.
+
+## A symbolic PDE in a few lines
+
+```python
+import sympy as sp
+import rbflab as rbf
+
+model = rbf.SymbolicScalar(2)
+u = model.field
+x, y = model.coordinates
+exact = sp.sin(sp.pi*x) * sp.sin(sp.pi*y)
+lhs = -model.laplacian(u)
+problem = model.stationary(
+    sp.Eq(lhs, lhs.subs(u, exact).doit()),
+    boundary=[model.bc("boundary", sp.Eq(u, 0))],
+)
+cloud = rbf.unit_box_grid(5)
+solution = problem.solve(cloud, rbf.GlobalCollocation(rbf.IMQ(2), scheme="asymmetric"))
+print(solution.evaluate([[0.3, 0.4]]))
+```
+
+Change the last method to `rbf.LHI(rbf.PHS(5), 20, polynomial_degree=2)`
+or `rbf.RBFFD(rbf.PHS(5), 20, polynomial_degree=2)` to compare methods on
+the same equation and cloud. The complete example reports errors against the
+known solution.
+
+## Six starting examples
+
+| Example | What it shows |
+|---|---|
+| [Symbolic Poisson](examples/symbolic_poisson.py) | One equation with global, LHI, and RBF-FD |
+| [Mixed boundary](examples/symbolic_boundary.py) | Variable diffusion and a Robin condition |
+| [Heat](examples/symbolic_heat.py) | Symbolic time evolution |
+| [Stokes spaces](examples/stokes_spaces.py) | Divergence-free velocity and pressure gradient |
+| [3D operators](examples/operators_3d.py) | Sparse matrices, local reconstruction, backend choice |
+| [Custom kernel](examples/custom_kernel.py) | Symbolic kernel definition and optional C++ cache |
+
+Run, for example, `python examples/symbolic_poisson.py --method lhi` after
+installing the package. The [capability table](docs/CAPABILITIES.md) identifies
+which methods and backends are supported. These small examples use deterministic
+points and do not require mesh generation.
+
+## Plot a result
+
+Install the optional plotting tools with `python -m pip install "rbflab[examples]"`.
+The plotting code is separate from the numerical solver:
+
+```python
+from rbflab import viz
+
+fig, ax = viz.plot_scalar(solution, title="My solution")
+fig.savefig("solution.png", dpi=160)
+# For a time-dependent result: viz.animate_scalar(trajectory, "heat.gif")
+```
+
+![Animated heat pulse solved by RBFLAB](docs/assets/heat_diffusion.gif)
+
+The [gallery generator](examples/make_gallery.py) rebuilds this animation and
+the figures with `python -m examples.make_gallery`. It also plots the solved
+divergence-free Stokes velocity field:
+
+![Speed and streamlines from the steady Stokes example](docs/assets/stokes_velocity.png)
+
+See the short [plotting guide](docs/VISUALIZATION.md) for the plotting calls and
+their 2D scope.
+
+## A moving fluid: Navier–Stokes cavity
+
+From a source checkout, the [cavity example](examples/navier_stokes_cavity.py)
+solves a Re=100 lid-driven flow with staggered RBF-FD and makes an animation
+in one command:
+
+```sh
+python -m examples.navier_stokes_cavity
+```
+
+![Final Re=100 cavity velocity and streamlines](docs/assets/navier_stokes_cavity.png)
+
+![Re=100 lid-driven cavity startup](docs/assets/navier_stokes_cavity.gif)
+
+It uses a unit square built directly from NumPy, PHS7 kernels with degree-three
+polynomials, and a coupled velocity–pressure time step. The
+[cavity guide](docs/guides/LID_DRIVEN_CAVITY.md) reports the refinement comparison and the
+remaining divergence defect. The animation interpolates nodal values solely
+for display. The final frame is also saved as a PNG.
+
+The core library lives in `python/rbflab/`; runnable examples are in
+`examples/`, and focused contributor tests are in `tests/`.
+
+## Numerical scope
+
+The Stokes example uses a divergence-free velocity kernel: incompressibility
+is built into the approximation space. LHI reconstructs pressure gradients
+locally; it does not automatically produce a globally normalized pressure.
+Off-node LHI evaluation currently uses the nearest stencil and can have a
+different error from nodal values. Report solution error, algebraic residual,
+and PDE residual separately.
+
+The cavity showcase is not validation of a general Navier–Stokes solver.
+
+See [installation](docs/INSTALL.md), [capabilities](docs/CAPABILITIES.md),
+the [MIT license](LICENSE), and the [release checklist](RELEASE_CHECKLIST.md).

rbflab-0.1.0/README_PYPI.md

@@ -0,0 +1,49 @@
+# RBFLAB
+
+RBFLAB is a Python library for radial basis function interpolation and PDEs on
+point clouds. It supports global collocation, local Hermite interpolation
+(LHI), RBF-FD, symbolic linear operators and boundary conditions, and
+divergence-free velocity spaces. Scalar operators work in 2D and 3D.
+
+Source and examples: https://github.com/LDBreton/RBFLAB
+
+Install the Python core with:
+
+```sh
+python -m pip install rbflab
+```
+
+Optional extras include `rbflab[examples]` for Matplotlib plots and GIFs,
+`rbflab[mesh]` for Gmsh, and `rbflab[torch]` for the documented CPU Float64
+tensor backend. The C++ double/MPFR backends are source-build options.
+
+Here is a symbolic Poisson problem:
+
+```python
+import sympy as sp
+import rbflab as rbf
+
+model = rbf.SymbolicScalar(2)
+u = model.field
+x, y = model.coordinates
+exact = sp.sin(sp.pi*x) * sp.sin(sp.pi*y)
+lhs = -model.laplacian(u)
+problem = model.stationary(
+    sp.Eq(lhs, lhs.subs(u, exact).doit()),
+    boundary=[model.bc("boundary", sp.Eq(u, 0))],
+)
+cloud = rbf.unit_box_grid(5)
+solution = problem.solve(
+    cloud, rbf.GlobalCollocation(rbf.IMQ(2), scheme="asymmetric")
+)
+print(solution.evaluate([[0.3, 0.4]]))
+```
+
+The source repository also contains short heat, Stokes, 3D operator, custom
+kernel, and Re=100 lid-driven cavity examples. The cavity example is a
+showcase with a documented nonzero discrete divergence defect; it does not
+validate a general Navier–Stokes solver. LHI off-node reconstruction has its
+own accuracy limitations, and MPFR local weights do not automatically make a
+global sparse solve extended precision.
+
+RBFLAB is licensed under MIT.

rbflab-0.1.0/RELEASE_CHECKLIST.md

@@ -0,0 +1,51 @@
+# First PyPI release checklist
+
+This directory is a fresh public source snapshot. It has no commit history from the
+private research repository and contains no legacy reference code, experiments,
+or historical research outputs. The README media are regenerated by the
+included examples.
+
+## Prepared
+
+- MIT text in `LICENSE` and SPDX metadata in `pyproject.toml`.
+- Core package, optional C++ source, focused examples/tests, and README media.
+- Separate text-only `README_PYPI.md` keeps local image paths out of PyPI
+  metadata while the repository URL is not yet known.
+- `.github/workflows/publish-pypi.yml` builds, tests, checks metadata, and
+  publishes a matching non-prerelease GitHub release through PyPI Trusted
+  Publishing. It has no API token in the repository.
+- Windows Python 3.12: fresh install, source archive and wheel builds, and
+  focused tests passed (60 passed; 29 optional checks skipped).
+- WSL Ubuntu Python 3.12: editable install and focused tests passed (60 passed;
+  29 optional checks skipped). Both final distributions passed `twine check`;
+  the PyPI README example ran successfully. A fresh Linux wheel install ran
+  symbolic Poisson, divergence-free Stokes, and 3D operator examples.
+- The selected source has one Git author in the private working history and no
+  embedded third-party license notices; that is evidence, not a legal rights
+  determination for any material adapted from older projects.
+- PyPI's `rbflab` JSON endpoint returned HTTP 404 on 2026-10-08. This is not a
+  reservation or guarantee of availability.
+- The public repository is `https://github.com/LDBreton/RBFLAB`; package
+  metadata points to that URL. The user confirmed MIT release rights for the
+  selected code and generated images on 2026-10-08.
+- Its [first GitHub release smoke run](https://github.com/LDBreton/RBFLAB/actions/runs/37827256816)
+  passed all six jobs: Python 3.11/3.12
+  installed-wheel examples on Windows and Ubuntu, native C++ local operators,
+  and gallery generation. The workflows were then updated to current
+  Node 24-based actions and a pinned Ubuntu 24.04 runner. The
+  [updated six-job run](https://github.com/LDBreton/RBFLAB/actions/runs/37827767996)
+  also passed.
+- The GitHub `pypi` environment requires `LDBreton` as a reviewer. A private
+  draft `v0.1.0` release contains the wheel and source archive from the
+  CI-tested commit.
+
+## Before PyPI upload
+
+- Confirm the `rbflab` name remains available on PyPI.
+- In PyPI, configure a pending Trusted Publisher for package `rbflab`, owner
+  `LDBreton`, repository `RBFLAB`, workflow `publish-pypi.yml`, and environment
+  `pypi`.
+- Review the draft release and publish it only after the Trusted Publisher is
+  configured. Publishing the GitHub Release triggers the PyPI workflow; approve
+  its `pypi` environment job when ready. Then verify the uploaded distributions
+  and update the repository README installation text.

rbflab-0.1.0/cpp/README.md

@@ -0,0 +1,60 @@
+# C++ local numerical backend
+
+The production LHI local factorization is Eigen `PartialPivLU`. Float64 uses
+`Eigen::Matrix<double,...>`; arbitrary precision uses the existing MPFR `Real`
+wrapper with `Eigen::NumTraits<Real>`. No conversion through double occurs in
+MPFR factorization or triangular solves. Shape policy, kernel assembly,
+symmetric row-max equilibration and reconstruction formulas are unchanged.
+
+OpenMP parallelizes stencils. Eigen internal parallelism is disabled. MPFR
+precision is thread-local and set in each worker before allocating matrices.
+A factorization serves all four reconstruction RHS and the optional inverse
+used to estimate the infinity-norm condition number. Exact zero pivots raise
+an error; LU is not a rank-revealing solver and does not regularize ill-conditioned
+matrices. Eigen cannot recover digits lost to an excessively flat Float64 kernel.
+
+## Dependencies and build
+
+GCC, OpenMP, MPFR/GMP runtime libraries and development headers are required.
+Eigen 3.4.0 was validated. On Ubuntu/WSL, extract the distribution's
+development packages into the ignored project dependency directory:
+
+```sh
+bash cpp/prepare_dependencies.sh
+```
+
+From the repository root, using its Python environment:
+
+```sh
+python -m examples.build_cpp_backend
+RBFLAB_CPP_TESTS=1 python -m pytest tests/test_discrete_operators.py tests/test_symbolic_kernel.py -q
+```
+
+On PowerShell set `$env:RBFLAB_CPP_TESTS='1'` before invoking pytest.
+The public `CppBackend(threads=..., compute_condition=...)` API is unchanged.
+`Precision(local_digits=None)` selects Float64; `Precision(local_digits=80)`
+selects MPFR for local assembly/solves. Global precision remains separately
+controlled by `global_dtype`.
+
+Custom symbolic Stokes kernels compile against the same Eigen solver.
+The adapter and Eigen header content hashes participate in cache identity;
+previous custom binaries cannot be reused accidentally. Build manifests record
+the Eigen header hash. Dependencies and generated executables remain untracked.
+Off-node lazy Python reconstruction and global sparse solvers are unchanged.
+
+## Optional Float64 SVD
+
+`CppBackend(local_solver="svd", svd_rcond=None)` selects Eigen JacobiSVD.
+`svd_rcond` is the relative singular-value cutoff; `None` uses Eigen's default
+(matrix dimension times machine epsilon). Set an explicit value such as
+`1e-12` when testing regularization. MPFR currently supports LU only.
+SVD solves the equilibrated system with a truncated pseudoinverse; this can
+change the discretization substantially. It is not an automatic fallback.
+
+Diagnostics include each stencil's retained rank, dimension, relative cutoff,
+and condition number from the untruncated computed singular values. If condition
+reporting is enabled, SVD reports the 2-norm condition, whereas LU reports the
+infinity-norm estimate. Tiny singular values of an unresolved Float64 matrix
+cannot certify its mathematical condition number. Lazy off-node reconstruction
+uses NumPy SVD with the same scaling and cutoff; kernel evaluation/rounding may
+differ from C++, as in the existing Python reconstruction path.

rbflab-0.1.0/cpp/cuda_lhi.cu

@@ -0,0 +1,78 @@
+// Experimental Float64 local Stokes assembly + cuBLAS batched pivoted LU.
+#include <cuda_runtime.h>
+#include <cublas_v2.h>
+#include <vector>
+#include <map>
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+#include <cmath>
+#include <chrono>
+#include <stdexcept>
+#include <algorithm>
+#include <string>
+// RBFLAB_GENERATED_SPACE
+void check(cudaError_t e){if(e!=cudaSuccess)throw std::runtime_error(cudaGetErrorString(e));}
+void blas(cublasStatus_t e){if(e!=CUBLAS_STATUS_SUCCESS)throw std::runtime_error("cuBLAS status "+std::to_string(e));}
+using Clock=std::chrono::steady_clock;
+double elapsed(Clock::time_point t){return std::chrono::duration<double>(Clock::now()-t).count();}
+struct Node{int op;double x,y;};
+struct Task{double mu,x,y;std::vector<double> v,p;std::vector<Node> nodes;};
+template<class T>struct Device{
+ T* p=nullptr;size_t count;
+ explicit Device(size_t n):count(n){check(cudaMalloc((void**)&p,sizeof(T)*n));}
+ ~Device(){if(p)cudaFree(p);}
+ Device(const Device&)=delete;Device& operator=(const Device&)=delete;
+ void upload(const T* src){check(cudaMemcpy(p,src,count*sizeof(T),cudaMemcpyHostToDevice));}
+ void download(T* dst){check(cudaMemcpy(dst,p,count*sizeof(T),cudaMemcpyDeviceToHost));}
+};
+__global__ void assemble(int n,int count,int nv,int np,const Node* nodes,const double* params,const double* meta,double* G,double* B){
+ int total=count*n*(n+4);
+ for(int index=blockIdx.x*blockDim.x+threadIdx.x;index<total;index+=blockDim.x*gridDim.x){
+  int t=index/(n*(n+4)),entry=index%(n*(n+4));
+  KernelSpec v{params+t*(nv+np)},p{params+t*(nv+np)+nv};const Node* pts=nodes+t*n;
+  if(entry<n*n){int row=entry%n,col=entry/n;if(row<col)continue;
+   double value=custom_eval(pts[col].op,pts[row].op,pts[row].x-pts[col].x,pts[row].y-pts[col].y,meta[3*t],v,p);
+   G[t*n*n+col*n+row]=value;G[t*n*n+row*n+col]=value;
+  }else{int j=entry-n*n,row=j%n,target=j/n;
+   B[t*n*4+target*n+row]=custom_eval(pts[row].op,target+5,meta[3*t+1]-pts[row].x,meta[3*t+2]-pts[row].y,meta[3*t],v,p);
+  }
+ }
+}
+__global__ void scales(int n,int count,const double* G,double* scale){
+ for(int i=blockIdx.x*blockDim.x+threadIdx.x;i<count*n;i+=gridDim.x*blockDim.x){int t=i/n,row=i%n;double mx=0;for(int j=0;j<n;j++)mx=fmax(mx,fabs(G[t*n*n+j*n+row]));scale[i]=mx>0?1/sqrt(mx):nan("");}
+}
+__global__ void equilibrate(int n,int count,const double* G,const double* B,const double* scale,double* A,double* R){
+ for(int i=blockIdx.x*blockDim.x+threadIdx.x;i<count*n*(n+4);i+=gridDim.x*blockDim.x){int t=i/(n*(n+4)),j=i%(n*(n+4));if(j<n*n)A[t*n*n+j]=G[t*n*n+j]*scale[t*n+j%n]*scale[t*n+j/n];else{j-=n*n;R[t*n*4+j]=B[t*n*4+j]*scale[t*n+j%n];}}
+}
+__global__ void unscale(int n,int count,const double* scale,double* W){for(int i=blockIdx.x*blockDim.x+threadIdx.x;i<count*n*4;i+=gridDim.x*blockDim.x){int t=i/(n*4);W[i]*=scale[t*n+i%n];}}
+__global__ void residuals(int n,int count,const double* G,const double* B,const double* W,double* error,double* denom){
+ for(int i=blockIdx.x*blockDim.x+threadIdx.x;i<count*n*4;i+=gridDim.x*blockDim.x){int t=i/(n*4),j=i%(n*4),row=j%n,k=j/n;double d=-B[i];for(int col=0;col<n;col++)d+=G[t*n*n+col*n+row]*W[t*n*4+k*n+col];double a=isfinite(d)?fabs(d):INFINITY;atomicMax((unsigned long long*)(error+t),(unsigned long long)__double_as_longlong(a));atomicMax((unsigned long long*)(denom+t),(unsigned long long)__double_as_longlong(fabs(B[i])));}
+}
+int main(int argc,char**argv){try{
+ if(argc!=3)throw std::runtime_error("Usage: cuda_lhi INPUT OUTPUT");
+ std::ifstream in(argv[1]);int count,chunk,nv,np;if(!(in>>count>>chunk>>nv>>np)||count<1||chunk<1||nv<0||np<0)throw std::runtime_error("Invalid header");
+ std::vector<Task> tasks(count);std::map<int,std::vector<int>> groups;
+ for(int i=0;i<count;i++){auto&t=tasks[i];int n;in>>n>>t.mu>>t.x>>t.y;if(n<1||n>4096)throw std::runtime_error("Invalid matrix size");t.v.resize(nv);t.p.resize(np);for(auto&v:t.v)in>>v;for(auto&v:t.p)in>>v;t.nodes.resize(n);for(auto&v:t.nodes)in>>v.op>>v.x>>v.y;if(!in)throw std::runtime_error("Invalid task input");groups[n].push_back(i);}
+ auto initial=Clock::now();check(cudaFree(0));cudaDeviceProp prop;check(cudaGetDeviceProperties(&prop,0));cublasHandle_t handle;blas(cublasCreate(&handle));double init=elapsed(initial);
+ std::vector<std::vector<double>> weights(count);std::vector<double> residual(count);double h2d=0,assembly=0,solve=0,d2h=0;int batches=0;
+ auto begin=Clock::now();
+ for(auto&group:groups){int n=group.first;auto&ids=group.second;
+  for(size_t offset=0;offset<ids.size();offset+=chunk){int b=std::min(size_t(chunk),ids.size()-offset);batches++;
+   std::vector<Node> nodes;std::vector<double> params,meta;
+   for(int j=0;j<b;j++){auto&t=tasks[ids[offset+j]];nodes.insert(nodes.end(),t.nodes.begin(),t.nodes.end());params.insert(params.end(),t.v.begin(),t.v.end());params.insert(params.end(),t.p.begin(),t.p.end());meta.insert(meta.end(),{t.mu,t.x,t.y});}
+   Device<Node> dn(b*n);Device<double> dp(std::max(1,b*(nv+np))),dm(b*3),G(size_t(b)*n*n),A(size_t(b)*n*n),B(b*n*4),W(b*n*4),scale(b*n),error(b),denom(b);Device<int> piv(b*n),info(b);Device<double*> aa(b),ww(b);
+   std::vector<double*> ap(b),wp(b);for(int j=0;j<b;j++){ap[j]=A.p+size_t(j)*n*n;wp[j]=W.p+j*n*4;}
+   auto t=Clock::now();dn.upload(nodes.data());if(!params.empty())check(cudaMemcpy(dp.p,params.data(),params.size()*sizeof(double),cudaMemcpyHostToDevice));dm.upload(meta.data());aa.upload(ap.data());ww.upload(wp.data());check(cudaMemset(error.p,0,b*sizeof(double)));check(cudaMemset(denom.p,0,b*sizeof(double)));h2d+=elapsed(t);
+   int blocks=std::min(4096,(b*n*(n+4)+127)/128);t=Clock::now();
+   assemble<<<blocks,128>>>(n,b,nv,np,dn.p,dp.p,dm.p,G.p,B.p);scales<<<blocks,128>>>(n,b,G.p,scale.p);equilibrate<<<blocks,128>>>(n,b,G.p,B.p,scale.p,A.p,W.p);check(cudaGetLastError());check(cudaDeviceSynchronize());assembly+=elapsed(t);
+   t=Clock::now();blas(cublasDgetrfBatched(handle,n,aa.p,n,piv.p,info.p,b));std::vector<int> status(b);info.download(status.data());for(int j=0;j<b;j++)if(status[j])throw std::runtime_error("LU failure at stencil "+std::to_string(ids[offset+j])+", info="+std::to_string(status[j]));int result=0;blas(cublasDgetrsBatched(handle,CUBLAS_OP_N,n,4,(const double**)aa.p,n,piv.p,ww.p,n,&result,b));if(result)throw std::runtime_error("Batched solve failed");unscale<<<blocks,128>>>(n,b,scale.p,W.p);residuals<<<blocks,128>>>(n,b,G.p,B.p,W.p,error.p,denom.p);check(cudaGetLastError());check(cudaDeviceSynchronize());solve+=elapsed(t);
+   t=Clock::now();std::vector<double> host(b*n*4),err(b),norm(b);W.download(host.data());error.download(err.data());denom.download(norm.data());d2h+=elapsed(t);
+   for(int j=0;j<b;j++){int id=ids[offset+j];weights[id].assign(host.begin()+j*n*4,host.begin()+(j+1)*n*4);residual[id]=err[j]/(norm[j]?norm[j]:1);if(!std::isfinite(residual[id]))throw std::runtime_error("Nonfinite residual");for(double v:weights[id])if(!std::isfinite(v))throw std::runtime_error("Nonfinite weight");}
+  }
+ }
+ double compute=elapsed(begin);blas(cublasDestroy(handle));
+ std::ofstream out(argv[2]);out<<std::setprecision(17);for(int i=0;i<count;i++){out<<i<<" "<<tasks[i].nodes.size()<<" none "<<residual[i];for(double v:weights[i])out<<" "<<v;out<<"\n";}if(!out)throw std::runtime_error("Output write failed");
+ std::cout<<std::setprecision(9)<<"{\"device\":\""<<prop.name<<"\",\"context_seconds\":"<<init<<",\"compute_seconds\":"<<compute<<",\"h2d_seconds\":"<<h2d<<",\"assembly_seconds\":"<<assembly<<",\"solve_seconds\":"<<solve<<",\"d2h_seconds\":"<<d2h<<",\"groups\":"<<groups.size()<<",\"batches\":"<<batches<<"}\n";
+ return 0;
+}catch(const std::exception&e){std::cerr<<e.what()<<"\n";return 1;}}

rbflab-0.1.0/cpp/eigen_solver.hpp

@@ -0,0 +1,92 @@
+#pragma once
+// Keep parallelism across stencils; Eigen must not create nested workers.
+#define EIGEN_DONT_PARALLELIZE
+#include "real.hpp"
+#ifndef RBFLAB_DOUBLE
+inline bool operator!=(const Real&a,const Real&b){return !(a==b);}
+inline bool operator<=(const Real&a,const Real&b){return !(a>b);}
+inline bool operator>=(const Real&a,const Real&b){return !(a<b);}
+inline Real abs2(const Real&a){return a*a;}
+inline Real conj(const Real&a){return a;}
+inline Real real(const Real&a){return a;}
+inline Real imag(const Real&){return Real(0);}
+#endif
+#include <Eigen/Core>
+#ifndef RBFLAB_DOUBLE
+namespace Eigen {
+template<> struct NumTraits<::Real>:GenericNumTraits<::Real> {
+ using Real=::Real; using NonInteger=::Real; using Nested=::Real; using Literal=::Real;
+ enum {IsComplex=0,IsInteger=0,IsSigned=1,RequireInitialization=1,ReadCost=10,AddCost=20,MulCost=40};
+ static Real epsilon(){Real x(1);mpfr_div_2si(x.v,x.v,::Real::bits-1,MPFR_RNDN);return x;}
+ static Real dummy_precision(){return sqrt(epsilon());}
+ static int digits10(){return int((::Real::bits-1)*0.3010299956639812);}
+};
+}
+#endif
+#include <Eigen/LU>
+#include <vector>
+#ifdef RBFLAB_DOUBLE
+using EigenScalar=double;
+inline double eigen_value(const Real&x){return x.v;}
+#else
+using EigenScalar=Real;
+inline const Real& eigen_value(const Real&x){return x;}
+#endif
+// Own the factorization once and reuse it for all reconstruction/diagnostic RHS.
+struct EigenLocalLU {
+ using Dense=Eigen::Matrix<EigenScalar,Eigen::Dynamic,Eigen::Dynamic>;
+ using Rows=std::vector<std::vector<Real>>;
+ Eigen::PartialPivLU<Dense> factor;
+ static Dense dense(const Rows& rows){
+  Dense a(rows.size(),rows.at(0).size());
+  for(int i=0;i<a.rows();++i)for(int j=0;j<a.cols();++j)a(i,j)=eigen_value(rows[i][j]);
+  return a;
+ }
+ explicit EigenLocalLU(const Rows& a):factor(dense(a)){
+  for(int i=0;i<factor.matrixLU().rows();++i)
+   if(factor.matrixLU()(i,i)==EigenScalar(0))throw std::runtime_error("Singular local matrix at selected precision");
+ }
+ Rows solve(const Rows& b)const{
+  Dense x=factor.solve(dense(b));
+  Rows result(x.rows(),std::vector<Real>(x.cols()));
+  for(int i=0;i<x.rows();++i)for(int j=0;j<x.cols();++j)result[i][j]=Real(x(i,j));
+  return result;
+ }
+};
+
+#include <memory>
+#ifdef RBFLAB_DOUBLE
+#include <Eigen/SVD>
+#endif
+struct EigenLocalSolver {
+ using Rows=EigenLocalLU::Rows;
+ std::unique_ptr<EigenLocalLU> lu;
+#ifdef RBFLAB_DOUBLE
+ Eigen::JacobiSVD<EigenLocalLU::Dense> svd;
+#endif
+ int size,rank; double threshold=0,condition2=0;
+ EigenLocalSolver(const Rows& a,const std::string& solver,double cutoff):size(a.size()),rank(size){
+  if(solver=="lu"){lu=std::make_unique<EigenLocalLU>(a);return;}
+#ifdef RBFLAB_DOUBLE
+  svd.compute(EigenLocalLU::dense(a),Eigen::ComputeThinU|Eigen::ComputeThinV);
+  if(svd.info()!=Eigen::Success)throw std::runtime_error("Local SVD failed");
+  if(cutoff>=0)svd.setThreshold(cutoff);
+  threshold=svd.threshold();rank=svd.rank();
+  const auto& values=svd.singularValues();
+  condition2=values(size-1)>0 ? values(0)/values(size-1) : std::numeric_limits<double>::infinity();
+#else
+  throw std::runtime_error("SVD local solver currently requires Float64");
+#endif
+ }
+ Rows solve(const Rows& b)const{
+  if(lu)return lu->solve(b);
+#ifdef RBFLAB_DOUBLE
+  EigenLocalLU::Dense x=svd.solve(EigenLocalLU::dense(b));
+  Rows result(x.rows(),std::vector<Real>(x.cols()));
+  for(int i=0;i<x.rows();++i)for(int j=0;j<x.cols();++j)result[i][j]=Real(x(i,j));
+  return result;
+#else
+  throw std::runtime_error("SVD local solver currently requires Float64");
+#endif
+ }
+};