Crate solvr 

solvr - Advanced Computing Library for Real-World Problem Solving

solvr provides production-ready algorithms for optimization, differential equations, interpolation, statistics, signal processing, and spatial computing. Built on numr’s foundational math primitives, it works across all backends (CPU, CUDA, WebGPU).

When to Use solvr vs numr

• numr: Foundational math (tensors, FFT, basic linalg). Most users only need this.
• solvr: Advanced algorithms for solving real-world problems (optimization, ODE, interpolation, statistical tests, etc.)

Architecture

┌─────────────────────────────────────────────────────────┐
│                      solvr                               │
│   (optimization, ODE, interpolation, stats, spatial)    │
└──────────────────────────┬──────────────────────────────┘
                           │ uses
┌──────────────────────────▼──────────────────────────────┐
│                       numr                               │
│     (tensors, FFT, matmul, basic linalg, special fn)    │
└─────────────────────────────────────────────────────────┘

Current Modules

• signal - Signal processing (convolution, correlation, STFT, spectrogram, N-D filters, edge detection)
• window - Window functions (Hann, Hamming, Blackman, Kaiser)
• interpolate - Interpolation (linear, cubic, splines, geometric transforms: affine, zoom, rotate)
• optimize - Root finding, minimization, least squares, linear programming
• integrate - ODE solvers and numerical quadrature
• stats - Statistical distributions, hypothesis tests, descriptive stats
• spatial - KDTree, BallTree, distance metrics, convex hull, Delaunay, Voronoi, rotations, distance transforms
• morphology - Morphological operations (binary/grey erosion, dilation, opening, closing, connected components)

Planned Modules

Backend Support

solvr is generic over numr’s Runtime trait. The same code works on:

• CPU (with SIMD acceleration)
• CUDA (NVIDIA GPUs)
• WebGPU (cross-platform GPU)

Feature Flags

Feature	Description	Dependencies
cuda	Enable CUDA GPU acceleration	CUDA 12.x, numr/cuda
wgpu	Enable WebGPU cross-platform GPU	numr/wgpu

Usage

# CPU only (default)
solvr = "0.1"

# With CUDA support
solvr = { version = "0.1", features = ["cuda"] }

# With WebGPU support
solvr = { version = "0.1", features = ["wgpu"] }

Backend Limitations

• WebGPU: Only supports F32 precision (no F64)
• CUDA: Requires CUDA 12.x toolkit installed

Example

use solvr::signal::{ConvolutionAlgorithms, ConvMode};
use solvr::window::WindowFunctions;
// Create a Hann window
// Perform convolution
let result = client.convolve(&signal, &kernel, ConvMode::Same)?;

Re-exports

pub use graph::AllPairsResult;

pub use graph::CentralityAlgorithms;

pub use graph::ComponentResult;

pub use graph::ConnectivityAlgorithms;

pub use graph::EigCentralityOptions;

pub use graph::FlowAlgorithms;

pub use graph::FlowResult;

pub use graph::GraphData;

pub use graph::GraphMatrixAlgorithms;

pub use graph::MSTAlgorithms;

pub use graph::MSTResult;

pub use graph::MinCostFlowOptions;

pub use graph::PageRankOptions;

pub use graph::PathResult;

pub use graph::ShortestPathAlgorithms;

pub use graph::ShortestPathResult;

pub use integrate::IntegrateError;

pub use integrate::IntegrateResult;

pub use integrate::IntegrationAlgorithms;

pub use integrate::ODEMethod;

pub use integrate::ODEOptions;

pub use integrate::ODEResultTensor;

pub use integrate::QuadOptions;

pub use integrate::QuadResult;

pub use integrate::RombergOptions;

pub use integrate::solve_ivp_impl;

pub use interpolate::AkimaAlgorithms;

pub use interpolate::BSplineCurve;

pub use interpolate::BSplineCurveAlgorithms;

pub use interpolate::BSplineSurface;

pub use interpolate::BSplineSurfaceAlgorithms;

pub use interpolate::BezierCurve;

pub use interpolate::BezierCurveAlgorithms;

pub use interpolate::BezierSurface;

pub use interpolate::BezierSurfaceAlgorithms;

pub use interpolate::CubicSplineAlgorithms;

pub use interpolate::ExtrapolateMode;

pub use interpolate::Interp1dAlgorithms;

pub use interpolate::InterpMethod;

pub use interpolate::InterpNdAlgorithms;

pub use interpolate::InterpNdMethod;

pub use interpolate::NurbsCurve;

pub use interpolate::NurbsCurveAlgorithms;

pub use interpolate::NurbsSurface;

pub use interpolate::NurbsSurfaceAlgorithms;

pub use interpolate::PchipAlgorithms;

pub use interpolate::SplineBoundary;

pub use linalg::MatrixEquationAlgorithms;

pub use morphology::BinaryMorphologyAlgorithms;

pub use morphology::GreyMorphologyAlgorithms;

pub use morphology::MeasurementAlgorithms;

pub use morphology::RegionProperties;

pub use morphology::StructuringElement;

pub use optimize::OptimizeError;

pub use optimize::OptimizeResult;

pub use pde::BoundaryCondition;

pub use pde::BoundarySide;

pub use pde::BoundarySpec;

pub use pde::FdmOptions;

pub use pde::FdmResult;

pub use pde::FemResult;

pub use pde::FiniteDifferenceAlgorithms;

pub use pde::FiniteElementAlgorithms;

pub use pde::Grid2D;

pub use pde::Grid3D;

pub use pde::PdeError;

pub use pde::PdeResult;

pub use pde::SpectralAlgorithms;

pub use pde::SpectralResult;

pub use pde::TimeDependentOptions;

pub use pde::TimeResult;

pub use signal::ConvMode;

pub use signal::ConvolutionAlgorithms;

pub use signal::SpectrogramAlgorithms;

pub use signal::StftAlgorithms;

pub use spatial::BallTree;

pub use spatial::BallTreeAlgorithms;

pub use spatial::BallTreeOptions;

pub use spatial::ConvexHull;

pub use spatial::ConvexHullAlgorithms;

pub use spatial::Delaunay;

pub use spatial::DelaunayAlgorithms;

pub use spatial::DistanceAlgorithms;

pub use spatial::EulerOrder;

pub use spatial::HalfspaceIntersection;

pub use spatial::HalfspaceIntersectionAlgorithms;

pub use spatial::KDTree;

pub use spatial::KDTreeAlgorithms;

pub use spatial::KDTreeOptions;

pub use spatial::KNNResult;

pub use spatial::Mesh;

pub use spatial::MeshAlgorithms;

pub use spatial::ProcrustesAlgorithms;

pub use spatial::ProcrustesResult;

pub use spatial::RadiusResult;

pub use spatial::Rotation;

pub use spatial::RotationAlgorithms;

pub use spatial::SimplificationMethod;

pub use spatial::SmoothingMethod;

pub use spatial::SphericalVoronoi;

pub use spatial::SphericalVoronoiAlgorithms;

pub use spatial::Voronoi;

pub use spatial::VoronoiAlgorithms;

pub use stats::Beta;

pub use stats::Binomial;

pub use stats::Cauchy;

pub use stats::ChiSquared;

pub use stats::ContinuousDistribution;

pub use stats::DescriptiveStatisticsAlgorithms;

pub use stats::DiscreteDistribution;

pub use stats::DiscreteUniform;

pub use stats::Distribution;

pub use stats::Exponential;

pub use stats::FDistribution;

pub use stats::Gamma;

pub use stats::Geometric;

pub use stats::Gumbel;

pub use stats::GumbelMin;

pub use stats::Hypergeometric;

pub use stats::HypothesisTestingAlgorithms;

pub use stats::Laplace;

pub use stats::LinregressResult;

pub use stats::LogNormal;

pub use stats::NegativeBinomial;

pub use stats::Normal;

pub use stats::Pareto;

pub use stats::Poisson;

pub use stats::RegressionAlgorithms;

pub use stats::StatsError;

pub use stats::StatsResult;

pub use stats::StudentT;

pub use stats::TensorDescriptiveStats;

pub use stats::TensorTestResult;

pub use stats::Uniform;

pub use stats::Weibull;

pub use window::WindowFunctions;

pub use optimize::scalar::*;

Modules

cluster

Clustering algorithms.

common

Common utilities shared across solvr modules.

graph

Graph algorithms for network analysis.

integrate

Numerical integration and ODE solvers for solvr.

interpolate

Interpolation methods for solvr

linalg

Linear algebra algorithms.

morphology

Morphological operations for N-dimensional arrays.

optimize

Optimization algorithms for solvr.

pde

signal

Signal processing algorithms.

spatial

Spatial algorithms and data structures.

stats

Statistical distributions, hypothesis tests, and descriptive statistics.

window

Window function algorithms for signal processing

Structs

Tensor

N-dimensional array stored on a compute device

Enums

DType

Data types supported by numr tensors

DistanceMetric

Distance metric for pairwise distance computation.

Error

Errors that can occur in numr operations

Traits

Runtime

Core trait for compute backends

RuntimeClient

Trait for runtime clients that handle operation dispatch

Type Aliases

Result

Result type alias using numr’s Error