Crate scirs2_interpolate 

SciRS2 Interpolate - Advanced Interpolation and Approximation

scirs2-interpolate provides comprehensive interpolation methods for 1D, 2D, and N-dimensional data, offering SciPy-compatible APIs with advanced features including splines, NURBS, RBF, kriging, physics-informed interpolation, and GPU acceleration for production workloads.

🎯 Key Features

• SciPy Compatibility: Drop-in replacement for scipy.interpolate functions
• Comprehensive Methods: Splines, B-splines, NURBS, Bézier, RBF, Kriging, and more
• High Dimensions: Efficient N-D interpolation with sparse grids and tensor products
• Advanced Features: Physics-informed, uncertainty quantification, adaptive sampling
• GPU Acceleration: CUDA/ROCm for large-scale scattered data interpolation
• Production Ready: Streaming interpolation, memory optimization, stress-tested
• Type Safety: Compile-time guarantees preventing interpolation errors

📦 Module Overview

SciRS2 Module	SciPy Equivalent	Description
interp1d	scipy.interpolate.interp1d	1D interpolation (linear, cubic, PCHIP)
spline	scipy.interpolate.CubicSpline	Cubic spline interpolation
bspline	scipy.interpolate.BSpline	B-spline basis and interpolation
nurbs	-	NURBS curves and surfaces
bezier	-	Bézier curves and surfaces
rbf	scipy.interpolate.RBFInterpolator	Radial basis function interpolation
kriging	-	Gaussian process regression
interpnd	scipy.interpolate.RegularGridInterpolator	N-D regular grid interpolation
griddata	scipy.interpolate.griddata	Scattered data interpolation
bivariate	scipy.interpolate.RectBivariateSpline	2D spline interpolation

🚀 Quick Start

Add to your Cargo.toml:

[dependencies]
scirs2-interpolate = "0.1.5"

1D Interpolation

use scirs2_core::ndarray::array;
use scirs2_interpolate::interp1d::{Interp1d, InterpolationMethod};

let x = array![0.0, 1.0, 2.0, 3.0, 4.0];
let y = array![0.0, 1.0, 4.0, 9.0, 16.0];

// Create cubic interpolator
let interp = Interp1d::new(x.view(), y.view(), InterpolationMethod::Cubic).expect("doc example: should succeed");

// Evaluate at new points
let x_new = array![0.5, 1.5, 2.5];
let y_new = interp.eval(&x_new.view()).expect("doc example: should succeed");

Spline Interpolation

use scirs2_core::ndarray::array;
use scirs2_interpolate::spline::{CubicSpline, SplineBoundaryCondition};

let x = array![0.0, 1.0, 2.0, 3.0];
let y = array![0.0, 1.0, 0.5, 0.0];

// Natural cubic spline (zero second derivative at boundaries)
let spline = CubicSpline::new(
    x.view(),
    y.view(),
    SplineBoundaryCondition::Natural,
    SplineBoundaryCondition::Natural
).expect("doc example: should succeed");

let y_interp = spline.evaluate(1.5).expect("doc example: should succeed");

Radial Basis Function (RBF) Interpolation

use scirs2_core::ndarray::array;
use scirs2_interpolate::advanced::rbf::{RBFInterpolator, RBFKernel};

// 2D scattered data
let x = array![[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]];
let y = array![0.0, 1.0, 1.0, 2.0];

// Create RBF interpolator with thin-plate spline kernel
let rbf = RBFInterpolator::new(x.view(), y.view(), RBFKernel::ThinPlate).expect("doc example: should succeed");

// Evaluate at new points
let x_new = array![[0.5, 0.5]];
let y_new = rbf.evaluate(&x_new.view()).expect("doc example: should succeed");

N-D Regular Grid Interpolation

use scirs2_core::ndarray::{Array1, Array3};
use scirs2_interpolate::interpnd::RegularGridInterpolator;

// 3D grid data: temperature(x, y, z)
let nx = 10;
let ny = 10;
let nz = 10;
let values = Array3::<f64>::zeros((nx, ny, nz));

let x = Array1::linspace(0.0, 1.0, nx);
let y = Array1::linspace(0.0, 1.0, ny);
let z = Array1::linspace(0.0, 1.0, nz);

let interp = RegularGridInterpolator::new(
    vec![x.view(), y.view(), z.view()],
    values.view(),
).expect("doc example: should succeed");

🏗️ Architecture

scirs2-interpolate
├── 1D Methods
│   ├── Linear, Nearest, Cubic
│   ├── PCHIP (shape-preserving)
│   ├── Akima spline
│   └── Monotonic interpolation
├── Splines
│   ├── Cubic splines (natural, clamped, periodic)
│   ├── B-splines (uniform, non-uniform knots)
│   ├── Hermite splines (derivatives specified)
│   ├── Tension splines (adjustable tightness)
│   └── Multiscale B-splines (adaptive refinement)
├── Parametric Curves/Surfaces
│   ├── NURBS (rational B-splines)
│   ├── Bézier curves and surfaces
│   └── Tensor product interpolation
├── Scattered Data
│   ├── RBF (radial basis functions)
│   ├── Kriging (Gaussian processes)
│   ├── Natural neighbor interpolation
│   └── Shepard's method
├── N-D Methods
│   ├── Regular grid interpolation
│   ├── Sparse grids (high dimensions)
│   ├── Tensor products
│   └── Hierarchical interpolation
├── Advanced Features
│   ├── Physics-informed interpolation
│   ├── Adaptive sampling strategies
│   ├── Uncertainty quantification
│   ├── Statistical interpolation (Bayesian, bootstrap)
│   └── Neural network enhancement
├── Performance Optimization
│   ├── SIMD-accelerated evaluation
│   ├── GPU acceleration (RBF, batch splines)
│   ├── Parallel processing
│   ├── Cache-aware algorithms
│   └── Streaming interpolation
└── Production Features
    ├── Memory monitoring
    ├── Stress testing
    ├── SciPy compatibility validation
    └── Cross-platform benchmarking

📊 Performance

Method	Data Size	CPU	SIMD	GPU	Speedup
1D Cubic	10⁶ points	45ms	12ms	N/A	3.8×
B-spline eval	10⁶ points	38ms	9ms	N/A	4.2×
RBF (2D)	10⁴ points	2.5s	850ms	45ms	56×
Kriging (3D)	10³ points	1.8s	N/A	120ms	15×
Grid interp (3D)	100³ grid	180ms	42ms	8ms	22.5×

Note: Benchmarks on AMD Ryzen 9 5950X + NVIDIA RTX 3090. SIMD uses AVX2.

🔗 Integration

• scirs2-linalg: Matrix operations for RBF and kriging solvers
• scirs2-stats: Statistical distributions for uncertainty quantification
• scirs2-optimize: Parameter optimization for adaptive methods
• scirs2-fft: Spectral methods for periodic interpolation

🔒 Version Information

• Version: 0.1.5
• Release Date: January 15, 2026
• MSRV (Minimum Supported Rust Version): 1.70.0
• Documentation: docs.rs/scirs2-interpolate
• Repository: github.com/cool-japan/scirs

---

Detailed Module Descriptions

• B-spline basis functions and interpolation (bspline module):
  • BSpline - B-spline basis functions and interpolation
  • Support for derivatives, antiderivatives, and integration
  • Knot generation with different styles (uniform, average, clamped)
  • Least-squares fitting with B-splines
• NURBS curves and surfaces (nurbs module):
  • NurbsCurve - Non-Uniform Rational B-Spline curves
  • NurbsSurface - Non-Uniform Rational B-Spline surfaces
  • Utility functions for creating common NURBS shapes (circles, spheres)
  • Support for control point weights and derivatives
• Bezier curves and surfaces (bezier module):
  • BezierCurve - Parametric curves with control points
  • BezierSurface - Parametric surfaces with control points
  • Bernstein polynomial basis functions
  • Curve/surface evaluation, derivatives, and curve splitting
• Bivariate splines (bivariate module):
  • BivariateSpline - Base class for bivariate splines
  • SmoothBivariateSpline - Smooth bivariate spline approximation
  • RectBivariateSpline - Bivariate spline approximation over a rectangular mesh
• Multivariate interpolation (interpnd module)
• Advanced interpolation methods (advanced module):
  • Akima spline interpolation - robust to outliers
  • Radial Basis Function (RBF) interpolation - for scattered data
  • Enhanced RBF interpolation - with automatic parameter selection and multi-scale capabilities
  • Kriging (Gaussian process regression) - with uncertainty quantification
  • Barycentric interpolation - stable polynomial interpolation
  • Thin-plate splines - special case of RBF for smooth interpolation
• GPU-accelerated interpolation (gpu_accelerated module):
  • GPU-accelerated RBF interpolation for large datasets
  • Batch spline evaluation using GPU parallelism
  • Mixed CPU/GPU workloads for optimal performance
  • Multi-GPU support and memory-efficient operations
• Grid transformation and resampling (grid module):
  • Resample scattered data onto regular grids
  • Convert between grids of different resolutions
  • Map grid data to arbitrary points
• Tensor product interpolation (tensor module):
  • Efficient high-dimensional interpolation on structured grids
  • Higher-order interpolation using Lagrange polynomials
• Penalized splines (penalized module):
  • P-splines with various penalty types (ridge, derivatives)
  • Cross-validation for optimal smoothing parameter selection
• Constrained splines (constrained module):
  • Splines with explicit monotonicity and convexity constraints
  • Support for regional constraints and multiple constraint types
  • Constraint-preserving interpolation and least squares fitting
• Tension splines (tension module):
  • Splines with adjustable tension parameters
  • Control over the “tightness” of interpolation curves
  • Smooth transition between cubic splines and linear interpolation
• Hermite splines (hermite module):
  • Cubic and quintic Hermite interpolation with derivative constraints
  • Direct control over function values and derivatives at data points
  • Multiple derivative specification options (automatic, fixed, zero, periodic)
  • C1 and C2 continuity options (continuous first/second derivatives)
• Multiscale B-splines (multiscale module):
  • Hierarchical B-splines with adaptive refinement
  • Different refinement criteria (error-based, curvature-based, combined)
  • Multi-level representation with control over precision-complexity tradeoffs
  • Efficient representation of functions with varying detail across the domain
• Active learning for adaptive sampling (adaptive_learning module):
  • Intelligent sampling strategies for reducing function evaluations
  • Uncertainty-based, error-based, and gradient-based sampling
  • Exploration vs exploitation balance for optimal data collection
  • Expected improvement and combined sampling strategies
  • Statistics tracking and convergence monitoring
• Physics-informed interpolation (physics_informed module):
  • Interpolation methods that respect physical constraints and conservation laws
  • Mass, energy, and momentum conservation enforcement
  • Positivity-preserving and monotonicity-preserving interpolation
  • Boundary condition enforcement and smoothness constraints
  • Multi-physics coupling and constraint satisfaction monitoring
• Gaussian process regression with adaptive kernels (adaptive_gp module):
  • Automatic kernel selection and hyperparameter optimization
  • Multiple kernel types (RBF, Matérn, Periodic, Linear, Polynomial)
  • Uncertainty quantification and probabilistic interpolation
  • Model comparison and Bayesian model selection
  • Sparse GP methods for scalability to large datasets
• Advanced statistical methods (advanced_statistical module):
  • Functional Data Analysis (FDA) with multiple basis types
  • Multi-output regression for correlated response variables
  • Piecewise polynomial with automatic breakpoint detection
  • Variational sparse Gaussian processes with ELBO optimization
  • Statistical splines with confidence and prediction bands
  • Advanced bootstrap methods (BCa, block, residual, wild)
  • Savitzky-Golay filtering for smoothing and derivatives
• Neural network enhanced interpolation (neural_enhanced module):
  • Hybrid interpolation combining traditional methods with neural networks
  • Residual learning to improve base interpolation accuracy
  • Multiple neural architectures (MLP, Bayesian, PINN, Transformer)
  • Adaptive training with early stopping and regularization
  • Uncertainty-aware neural interpolation with Bayesian networks
• Advanced extrapolation methods (extrapolation module):
  • Configurable extrapolation beyond domain boundaries
  • Multiple methods: constant, linear, polynomial, periodic, reflected
  • Physics-informed extrapolation (exponential, power law)
  • Customizable for specific domain knowledge
• Enhanced boundary handling (boundarymode module):
  • Physical boundary conditions for PDEs (Dirichlet, Neumann)
  • Domain extension via symmetry, periodicity, and custom mappings
  • Separate control of upper and lower boundary behavior
  • Support for mixed boundary conditions
• Optimization-based parameter fitting (optimization module):
  • Cross-validation based model selection (K-fold, leave-one-out)
  • Regularization parameter optimization with grid search
  • Hyperparameter tuning for RBF kernels and spline smoothing
  • Model comparison and validation metrics (MSE, MAE, R²)
  • Bayesian optimization for efficient parameter search
• Time series specific interpolation (timeseries module):
  • Temporal pattern recognition (trends, seasonality, irregularities)
  • Missing data handling with forward/backward fill and interpolation
  • Seasonal decomposition and trend-aware interpolation
  • Outlier detection and robust temporal smoothing
  • Uncertainty estimation for time-dependent predictions
  • Holiday and event-aware interpolation strategies
• Streaming interpolation for online systems (streaming module):
  • Online learning with incremental model updates
  • Bounded memory usage for continuous operation
  • Real-time predictions with microsecond latency
  • Adaptive models that handle concept drift
  • Built-in outlier detection and quality control
  • Multiple streaming methods (splines, RBF, ensemble)
• Geospatial interpolation methods (geospatial module):
  • Geographic coordinate handling (latitude/longitude, projections)
  • Spherical interpolation with great circle distances
  • Spatial autocorrelation and kriging for Earth science data
  • Multi-scale interpolation from local to global coverage
  • Elevation-aware 3D interpolation and topographic considerations
  • Boundary handling for coastal and land/water transitions
• Comprehensive benchmarking suite (benchmarking module):
  • Performance validation against SciPy 1.13+
  • SIMD acceleration measurement and validation
  • Memory usage profiling and optimization analysis
  • Scalability testing across different data sizes
  • Cross-platform performance validation
  • Automated regression detection and reporting
• Utility functions (utils module):
  • Error estimation with cross-validation
  • Parameter optimization
  • Differentiation and integration of interpolated functions

Re-exports

pub use error::InterpolateError;

pub use error::InterpolateResult;

pub use advanced_coordinator::create_advanced_interpolation_coordinator;

pub use advanced_coordinator::create_balanced_coordinator;

pub use advanced_coordinator::create_default_advanced_coordinator;

pub use advanced_coordinator::create_high_performance_coordinator;

pub use advanced_coordinator::create_memory_efficient_coordinator;

pub use advanced_coordinator::AdvancedInterpolationConfig;

pub use advanced_coordinator::AdvancedInterpolationCoordinator;

pub use advanced_coordinator::CacheOptimizationResult;

pub use advanced_coordinator::InterpolationPerformanceMetrics;

pub use advanced_coordinator::InterpolationRecommendation;

pub use advanced_coordinator::MethodPerformanceEstimate;

pub use advanced_coordinator::SystemOptimizationResult;

pub use adaptive_gp::make_adaptive_gp;

pub use adaptive_gp::AdaptiveGPConfig;

pub use adaptive_gp::AdaptiveGaussianProcess;

pub use adaptive_gp::GPStats;

pub use adaptive_gp::KernelHyperparameters;

pub use adaptive_gp::KernelModel;

pub use adaptive_gp::KernelType as GPKernelType;

pub use adaptive_learning::make_active_learner;

pub use adaptive_learning::ActiveLearner;

pub use adaptive_learning::ActiveLearningConfig;

pub use adaptive_learning::LearningStats;

pub use adaptive_learning::SamplingCandidate;

pub use adaptive_learning::SamplingStrategy;

pub use adaptive_singularity::apply_singularity_handling;

pub use adaptive_singularity::SingularityDetector;

pub use adaptive_singularity::SingularityDetectorConfig;

pub use adaptive_singularity::SingularityInfo;

pub use adaptive_singularity::SingularityType;

pub use adaptive_singularity::TreatmentStrategy;

pub use advanced::akima::make_akima_spline;

pub use advanced::akima::AkimaSpline;

pub use advanced::barycentric::make_barycentric_interpolator;

pub use advanced::barycentric::BarycentricInterpolator;

pub use advanced::barycentric::BarycentricTriangulation;

pub use advanced::enhanced_kriging::make_bayesian_kriging;

pub use advanced::enhanced_kriging::make_enhanced_kriging;

pub use advanced::enhanced_kriging::make_universal_kriging;

pub use advanced::enhanced_kriging::AnisotropicCovariance;

pub use advanced::enhanced_kriging::BayesianKrigingBuilder;

pub use advanced::enhanced_kriging::BayesianPredictionResult;

pub use advanced::enhanced_kriging::EnhancedKriging;

pub use advanced::enhanced_kriging::EnhancedKrigingBuilder;

pub use advanced::enhanced_kriging::TrendFunction;

pub use advanced::enhanced_rbf::make_accurate_rbf;

pub use advanced::enhanced_rbf::make_auto_rbf;

pub use advanced::enhanced_rbf::make_fast_rbf;

pub use advanced::enhanced_rbf::EnhancedRBFInterpolator;

pub use advanced::enhanced_rbf::EnhancedRBFKernel;

pub use advanced::enhanced_rbf::KernelType;

pub use advanced::enhanced_rbf::KernelWidthStrategy;

pub use advanced::fast_kriging::make_fixed_rank_kriging;

pub use advanced::fast_kriging::make_hodlr_kriging;

pub use advanced::fast_kriging::make_local_kriging;

pub use advanced::fast_kriging::make_tapered_kriging;

pub use advanced::fast_kriging::FastKriging;

pub use advanced::fast_kriging::FastKrigingBuilder;

pub use advanced::fast_kriging::FastKrigingMethod;

pub use advanced::fast_kriging::FastPredictionResult;

pub use advanced::kriging::make_kriging_interpolator;

pub use advanced::kriging::CovarianceFunction;

pub use advanced::kriging::KrigingInterpolator;

pub use advanced::rbf::RBFInterpolator;

pub use advanced::rbf::RBFKernel;

pub use advanced::thinplate::make_thinplate_interpolator;

pub use advanced::thinplate::ThinPlateSpline;

pub use advanced_statistical::make_fda_interpolator;

pub use advanced_statistical::make_multi_output_interpolator;

pub use advanced_statistical::make_piecewise_polynomial_interpolator;

pub use advanced_statistical::BasisType;

pub use advanced_statistical::FDAConfig;

pub use advanced_statistical::FunctionalDataInterpolator;

pub use advanced_statistical::MultiOutputInterpolator;

pub use advanced_statistical::PiecewisePolynomialInterpolator;

pub use benchmarking::run_benchmarks_with_config;

pub use benchmarking::run_comprehensive_benchmarks;

pub use benchmarking::run_quick_validation;

pub use benchmarking::AccuracyMetrics;

pub use benchmarking::BenchmarkConfig;

pub use benchmarking::BenchmarkReport;

pub use benchmarking::BenchmarkResult;

pub use benchmarking::InterpolationBenchmarkSuite;

pub use benchmarking::MemoryStatistics;

pub use benchmarking::PerformanceBaseline;

pub use benchmarking::SimdMetrics;

pub use benchmarking::SystemInfo;

pub use benchmarking::SystemLoad;

pub use benchmarking::TimingStatistics;

pub use bezier::bernstein;

pub use bezier::compute_bernstein_all;

pub use bezier::BezierCurve;

pub use bezier::BezierSurface;

pub use bivariate::BivariateInterpolator;

pub use bivariate::BivariateSpline;

pub use bivariate::RectBivariateSpline;

pub use bivariate::SmoothBivariateSpline;

pub use bivariate::SmoothBivariateSplineBuilder;

pub use boundarymode::make_antisymmetric_boundary;

pub use boundarymode::make_linear_gradient_boundary;

pub use boundarymode::make_periodic_boundary;

pub use boundarymode::make_symmetric_boundary;

pub use boundarymode::make_zero_gradient_boundary;

pub use boundarymode::make_zero_value_boundary;

pub use boundarymode::BoundaryMode;

pub use boundarymode::BoundaryParameters;

pub use boundarymode::BoundaryResult;

pub use bspline::generate_knots;

pub use bspline::make_interp_bspline;

pub use bspline::make_lsq_bspline;

pub use bspline::BSpline;

pub use bspline::BSplineWorkspace;

pub use bspline::ExtrapolateMode as BSplineExtrapolateMode;

pub use bspline::WorkspaceMemoryStats;

pub use cache::make_cached_bspline;

pub use cache::make_cached_bspline_with_config;

pub use cache::BSplineCache;

pub use cache::CacheConfig;

pub use cache::CacheStats;

pub use cache::CachedBSpline;

pub use cache::DistanceMatrixCache;

pub use cache_aware::make_cache_aware_rbf;

pub use cache_aware::CacheAwareBSpline;

pub use cache_aware::CacheAwareRBF;

pub use cache_aware::CacheOptimizedConfig;

pub use cache_aware::CacheOptimizedStats;

pub use cache_aware::CacheSizes;

pub use constrained::ConstrainedSpline;

pub use constrained::Constraint;

pub use constrained::ConstraintRegion;

pub use constrained::ConstraintSatisfactionSummary;

pub use constrained::ConstraintType;

pub use constrained::ConstraintViolationInfo;

pub use constrained::FittingMethod;

pub use deprecation::configure_deprecation;

pub use deprecation::init_deprecation_system;

pub use deprecation::issue_deprecation_warning;

pub use deprecation::DeprecationConfig;

pub use deprecation::DeprecationInfo;

pub use deprecation::DeprecationLevel;

pub use deprecation::FeatureRegistry;

pub use doc_enhancements::get_method_documentation;

pub use doc_enhancements::print_method_comparison;

pub use doc_enhancements::ComputationalComplexity;

pub use doc_enhancements::MemoryComplexity;

pub use doc_enhancements::MethodDocumentation;

pub use doc_enhancements::PerformanceCharacteristics;

pub use doc_enhancements::UsageRecommendation;

pub use extrapolation::make_adaptive_extrapolator;

pub use extrapolation::make_autoregressive_extrapolator;

pub use extrapolation::make_boundary_preserving_extrapolator;

pub use extrapolation::make_confidence_extrapolator;

pub use extrapolation::make_cubic_extrapolator;

pub use extrapolation::make_ensemble_extrapolator;

pub use extrapolation::make_exponential_extrapolator;

pub use extrapolation::make_linear_extrapolator;

pub use extrapolation::make_periodic_extrapolator;

pub use extrapolation::make_physics_informed_extrapolator;

pub use extrapolation::make_reflection_extrapolator;

pub use extrapolation::make_smart_adaptive_extrapolator;

pub use extrapolation::ARFittingMethod;

pub use extrapolation::AdaptiveExtrapolationConfig;

pub use extrapolation::AdaptiveSelectionCriterion;

pub use extrapolation::AdvancedExtrapolator;

pub use extrapolation::AutoregressiveExtrapolationConfig;

pub use extrapolation::BoundaryType;

pub use extrapolation::ConfidenceExtrapolationConfig;

pub use extrapolation::ConfidenceExtrapolationResult;

pub use extrapolation::DataCharacteristics;

pub use extrapolation::EnsembleCombinationStrategy;

pub use extrapolation::EnsembleExtrapolationConfig;

pub use extrapolation::ExtrapolationMethod;

pub use extrapolation::ExtrapolationParameters;

pub use extrapolation::Extrapolator;

pub use extrapolation::PhysicsLaw;

pub use fast_bspline::make_cached_fast_bspline_evaluator;

pub use fast_bspline::make_fast_bspline_evaluator;

pub use fast_bspline::make_fast_bspline_evaluator_owned;

pub use fast_bspline::FastBSplineEvaluator;

pub use fast_bspline::TensorProductFastEvaluator;

pub use geospatial::make_climate_interpolator;

pub use geospatial::make_elevation_interpolator;

pub use geospatial::CoordinateSystem;

pub use geospatial::GeospatialConfig;

pub use geospatial::GeospatialInterpolator;

pub use geospatial::GeospatialResult;

pub use geospatial::InterpolationModel;

pub use geospatial::SpatialStats;

pub use gpu_accelerated::get_gpu_device_info;

pub use gpu_accelerated::gpu_utils;

pub use gpu_accelerated::is_gpu_acceleration_available;

pub use gpu_accelerated::make_gpu_rbf_interpolator;

pub use gpu_accelerated::GpuBatchSplineEvaluator;

pub use gpu_accelerated::GpuConfig;

pub use gpu_accelerated::GpuDeviceInfo;

pub use gpu_accelerated::GpuKernelConfig;

pub use gpu_accelerated::GpuMemoryManager;

pub use gpu_accelerated::GpuRBFInterpolator;

pub use gpu_accelerated::GpuRBFKernel;

pub use gpu_accelerated::GpuStats;

pub use statistical_advanced::AdvancedBootstrap;

pub use statistical_advanced::BcaBootstrap;

pub use statistical_advanced::BootstrapMethod;

pub use statistical_advanced::KernelParameters;

pub use statistical_advanced::SavitzkyGolayFilter;

pub use statistical_advanced::StatisticalSpline;

pub use statistical_advanced::VariationalSparseGP;

pub use gpu_production::DeviceMetrics;

pub use gpu_production::GpuDevice;

pub use gpu_production::GpuMemoryPool;

pub use gpu_production::ProductionGpuAccelerator;

pub use gpu_production::ProductionGpuConfig;

pub use gpu_production::ProductionPerformanceReport;

pub use gpu_production::SystemMetrics;

pub use gpu_production::WorkloadDistribution;

pub use grid::create_regular_grid;

pub use grid::map_grid_to_points;

pub use grid::resample_grid_to_grid;

pub use grid::resample_to_grid;

pub use grid::GridTransformMethod;

pub use hermite::make_hermite_spline;

pub use hermite::make_hermite_spline_with_derivatives;

pub use hermite::make_natural_hermite_spline;

pub use hermite::make_periodic_hermite_spline;

pub use hermite::make_quintic_hermite_spline;

pub use hermite::DerivativeSpec;

pub use hermite::HermiteSpline;

pub use high_dimensional::make_knn_interpolator;

pub use high_dimensional::make_local_rbf_interpolator;

pub use high_dimensional::make_pca_interpolator;

pub use high_dimensional::DimensionReductionMethod;

pub use high_dimensional::HighDimensionalInterpolator;

pub use high_dimensional::HighDimensionalInterpolatorBuilder;

pub use high_dimensional::InterpolatorStats;

pub use high_dimensional::LocalMethod;

pub use high_dimensional::LocalRBFType;

pub use high_dimensional::SparseStrategy;

pub use high_dimensional::SpatialIndexType;

pub use interp1d::cubic_interpolate;

pub use interp1d::hyman_interpolate;

pub use interp1d::linear_interpolate;

pub use interp1d::modified_akima_interpolate;

pub use interp1d::monotonic_interpolate;

pub use interp1d::nearest_interpolate;

pub use interp1d::pchip_interpolate;

pub use interp1d::steffen_interpolate;

pub use interp1d::Interp1d;

pub use interp1d::InterpolationMethod;

pub use interp1d::MonotonicInterpolator;

pub use interp1d::MonotonicMethod;

pub use interp1d::PchipExtrapolateMode;

pub use interp1d::PchipInterpolator;

pub use interpnd::make_interp_nd;

pub use interpnd::make_interp_scattered;

pub use interpnd::map_coordinates;

pub use interpnd::ExtrapolateMode;

pub use interpnd::GridType;

pub use interpnd::RegularGridInterpolator;

pub use interpnd::ScatteredInterpolator;

pub use local::mls::MovingLeastSquares;

pub use local::mls::PolynomialBasis;

pub use local::mls::WeightFunction;

pub use local::polynomial::make_loess;

pub use local::polynomial::make_robust_loess;

pub use local::polynomial::LocalPolynomialConfig;

pub use local::polynomial::LocalPolynomialRegression;

pub use local::polynomial::RegressionResult;

pub use memory_monitor::get_all_reports;

pub use memory_monitor::get_global_stats;

pub use memory_monitor::get_monitor_report;

pub use memory_monitor::start_monitoring;

pub use memory_monitor::stop_monitoring;

pub use memory_monitor::GlobalMemoryStats;

pub use memory_monitor::LeakIndicators;

pub use memory_monitor::MemoryMonitor;

pub use memory_monitor::MemoryReport;

pub use memory_monitor::PerformanceGrade;

pub use memory_monitor::PerformanceSummary;

pub use multiscale::make_adaptive_bspline;

pub use multiscale::MultiscaleBSpline;

pub use multiscale::RefinementCriterion;

pub use numerical_stability::analyze_interpolation_edge_cases;

pub use numerical_stability::apply_adaptive_regularization;

pub use numerical_stability::apply_tikhonov_regularization;

pub use numerical_stability::assess_matrix_condition;

pub use numerical_stability::check_safe_division;

pub use numerical_stability::machine_epsilon;

pub use numerical_stability::safe_reciprocal;

pub use numerical_stability::solve_with_stability_monitoring;

pub use numerical_stability::BoundaryAnalysis;

pub use numerical_stability::ConditionReport;

pub use numerical_stability::EdgeCaseAnalysis;

pub use numerical_stability::StabilityDiagnostics;

pub use numerical_stability::StabilityLevel;

pub use nurbs::make_nurbs_circle;

pub use nurbs::make_nurbs_sphere;

pub use nurbs::NurbsCurve;

pub use nurbs::NurbsSurface;

pub use optimization::grid_search;

pub use optimization::make_cross_validator;

pub use optimization::CrossValidationResult;

pub use optimization::CrossValidationStrategy;

pub use optimization::CrossValidator;

pub use optimization::ModelSelector;

pub use optimization::OptimizationConfig;

pub use optimization::OptimizationResult;

pub use optimization::ValidationMetric;

pub use parallel::make_parallel_loess;

pub use parallel::make_parallel_mls;

pub use parallel::make_parallel_robust_loess;

pub use parallel::ParallelConfig;

pub use parallel::ParallelEvaluate;

pub use parallel::ParallelLocalPolynomialRegression;

pub use parallel::ParallelMovingLeastSquares;

pub use penalized::cross_validate_lambda;

pub use penalized::pspline_with_custom_penalty;

pub use penalized::PSpline;

pub use penalized::PenaltyType;

pub use physics_informed::make_mass_conserving_interpolator;

pub use physics_informed::make_monotonic_physics_interpolator;

pub use physics_informed::make_smooth_physics_interpolator;

pub use physics_informed::ConservationLaw;

pub use physics_informed::PhysicalConstraint;

pub use physics_informed::PhysicsInformedConfig;

pub use physics_informed::PhysicsInformedInterpolator;

pub use physics_informed::PhysicsInformedResult;

pub use production_validation::validate_production_readiness;

pub use production_validation::validate_production_readiness_with_config;

pub use production_validation::ProductionValidationConfig;

pub use production_validation::ProductionValidationReport;

pub use production_validation::ProductionValidator;

pub use scattered_optimized::make_optimized_scattered_interpolator;

pub use scattered_optimized::OptimizedScatteredInterpolator;

pub use scattered_optimized::OptimizedScatteredStats;

pub use scattered_optimized::ScatteredConfig;

pub use simd_bspline::SimdBSplineEvaluator;

pub use simd_optimized::get_simd_config;

pub use simd_optimized::is_simd_available;

pub use simd_optimized::simd_bspline_basis_functions;

pub use simd_optimized::simd_bspline_batch_evaluate;

pub use simd_optimized::simd_distance_matrix;

pub use simd_optimized::simd_rbf_evaluate;

pub use simd_optimized::RBFKernel as SimdRBFKernel;

pub use simd_optimized::SimdConfig;

pub use simd_performance_validation::run_simd_validation;

pub use simd_performance_validation::run_simd_validation_with_config;

pub use simd_performance_validation::SimdPerformanceValidator;

pub use simd_performance_validation::SimdValidationConfig;

pub use simd_performance_validation::ValidationSummary;

pub use simd_comprehensive_validation::quick_simd_validation;

pub use simd_comprehensive_validation::validate_simd_performance;

pub use simd_comprehensive_validation::validate_simd_with_config;

pub use simd_comprehensive_validation::AccuracyValidationResult;

pub use simd_comprehensive_validation::CpuArchitecture;

pub use simd_comprehensive_validation::InstructionSet;

pub use simd_comprehensive_validation::PerformanceSummary as SimdPerformanceSummary;

pub use simd_comprehensive_validation::SimdPerformanceResult;

pub use simd_comprehensive_validation::SimdPerformanceValidator as ComprehensiveSimdValidator;

pub use simd_comprehensive_validation::SimdValidationConfig as ComprehensiveSimdConfig;

pub use simd_comprehensive_validation::SimdValidationReport;

pub use simd_comprehensive_validation::SimdValidationResult;

pub use simd_comprehensive_validation::SystemSimdCapabilities;

pub use smoothing::make_adaptive_smoothing_spline;

pub use smoothing::make_error_based_smoothing_spline;

pub use smoothing::make_optimized_smoothing_spline;

pub use smoothing::KnotStrategy;

pub use smoothing::VariableKnotSpline;

pub use sparse_grid::make_adaptive_sparse_grid_interpolator;

pub use sparse_grid::make_sparse_grid_from_data;

pub use sparse_grid::make_sparse_grid_interpolator;

pub use sparse_grid::GridPoint;

pub use sparse_grid::MultiIndex;

pub use sparse_grid::SparseGridBuilder;

pub use sparse_grid::SparseGridInterpolator;

pub use sparse_grid::SparseGridStats;

pub use spatial::balltree::BallTree;

pub use spatial::kdtree::KdTree;

pub use spatial::AdvancedSimdOps;

pub use spatial::SimdBenchmark;

pub use spline::cubic_spline_scipy;

pub use spline::interp1d_scipy;

pub use spline::make_interp_spline;

pub use spline::CubicSpline;

pub use spline::CubicSplineBuilder;

pub use spline::SplineBoundaryCondition;

pub use statistical::make_auto_kde_interpolator;

pub use statistical::make_bayesian_interpolator;

pub use statistical::make_bootstrap_linear_interpolator;

pub use statistical::make_decreasing_isotonic_interpolator;

pub use statistical::make_empirical_bayes_interpolator;

pub use statistical::make_ensemble_interpolator;

pub use statistical::make_isotonic_interpolator;

pub use statistical::make_kde_interpolator;

pub use statistical::make_kfold_uncertainty;

pub use statistical::make_loocv_uncertainty;

pub use statistical::make_median_interpolator;

pub use statistical::make_robust_interpolator;

pub use statistical::make_stochastic_interpolator;

pub use statistical::BayesianConfig;

pub use statistical::BayesianInterpolator;

pub use statistical::BootstrapConfig;

pub use statistical::BootstrapInterpolator;

pub use statistical::BootstrapResult;

pub use statistical::CrossValidationUncertainty;

pub use statistical::EmpiricalBayesInterpolator;

pub use statistical::EnsembleInterpolator;

pub use statistical::IsotonicInterpolator;

pub use statistical::KDEInterpolator;

pub use statistical::KDEKernel;

pub use statistical::QuantileInterpolator;

pub use statistical::RobustInterpolator;

pub use statistical::StochasticInterpolator;

pub use scipy_compatibility::create_compatibility_checker;

pub use scipy_compatibility::quick_compatibility_check;

pub use scipy_compatibility::ApiCoverageResults;

pub use scipy_compatibility::BehaviorValidationResults;

pub use scipy_compatibility::CompatibilityConfig;

pub use scipy_compatibility::CompatibilityReport;

pub use scipy_compatibility::DifferenceSeverity;

pub use scipy_compatibility::ErrorType;

pub use scipy_compatibility::FeaturePriority;

pub use scipy_compatibility::ImplementationEffort;

pub use scipy_compatibility::MissingFeature;

pub use scipy_compatibility::ParameterCompatibilityResults;

pub use scipy_compatibility::ParameterDifference;

pub use scipy_compatibility::SciPyCompatibilityChecker;

pub use streaming::make_ensemble_streaming_interpolator;

pub use streaming::make_online_spline_interpolator;

pub use streaming::make_streaming_rbf_interpolator;

pub use streaming::EnsembleStreamingInterpolator;

pub use streaming::OnlineSplineInterpolator;

pub use streaming::StreamingConfig;

pub use streaming::StreamingInterpolator;

pub use streaming::StreamingMethod;

pub use streaming::StreamingPoint;

pub use streaming::StreamingRBFInterpolator;

pub use streaming::StreamingStats;

pub use structured_matrix::create_bspline_band_matrix;

pub use structured_matrix::solve_band_system;

pub use structured_matrix::solve_sparse_system;

pub use structured_matrix::solve_structured_least_squares;

pub use structured_matrix::BandMatrix;

pub use structured_matrix::CSRMatrix;

pub use tension::make_tension_spline;

pub use tension::TensionSpline;

pub use tensor::lagrange_tensor_interpolate;

pub use tensor::tensor_product_interpolate;

pub use tensor::LagrangeTensorInterpolator;

pub use tensor::TensorProductInterpolator;

pub use timeseries::backward_fill;

pub use timeseries::forward_fill;

pub use timeseries::make_daily_interpolator;

pub use timeseries::make_weekly_interpolator;

pub use timeseries::MissingDataStrategy;

pub use timeseries::SeasonalityType;

pub use timeseries::TemporalPattern;

pub use timeseries::TemporalStats;

pub use timeseries::TimeSeriesConfig;

pub use timeseries::TimeSeriesInterpolator;

pub use timeseries::TimeSeriesResult;

pub use voronoi::constant_value_extrapolation;

pub use voronoi::inverse_distance_extrapolation;

pub use voronoi::linear_gradient_extrapolation;

pub use voronoi::make_laplace_interpolator;

pub use voronoi::make_natural_neighbor_interpolator;

pub use voronoi::make_parallel_laplace_interpolator;

pub use voronoi::make_parallel_natural_neighbor_interpolator;

pub use voronoi::make_parallel_sibson_interpolator;

pub use voronoi::make_sibson_interpolator;

pub use voronoi::nearest_neighbor_extrapolation;

pub use voronoi::Extrapolation;

pub use voronoi::ExtrapolationMethod as VoronoiExtrapolationMethod;

pub use voronoi::ExtrapolationParams;

pub use voronoi::GradientEstimation;

pub use voronoi::InterpolateWithGradient;

pub use voronoi::InterpolateWithGradientResult;

pub use voronoi::InterpolationMethod as VoronoiInterpolationMethod;

pub use voronoi::NaturalNeighborInterpolator;

pub use voronoi::ParallelNaturalNeighborInterpolator;

pub use scattered_nd::make_knn_nd_interpolator;

pub use scattered_nd::make_natural_neighbor_nd_interpolator;

pub use scattered_nd::make_nearest_neighbor_interpolator as make_nearest_neighbor_nd_interpolator;

pub use scattered_nd::make_shepard_interpolator;

pub use scattered_nd::DistanceMetric;

pub use scattered_nd::ScatteredNdInterpolator;

pub use scattered_nd::ScatteredNdMethod;

pub use tensor_product::make_multilinear_interpolator;

pub use tensor_product::make_tensor_bspline_interpolator;

pub use tensor_product::BoundaryHandling;

pub use tensor_product::TensorProductGridInterpolator;

pub use tensor_product::TensorProductMethod;

pub use triangulation_interp::make_clough_tocher_interpolator;

pub use triangulation_interp::make_linear_triangulation;

pub use triangulation_interp::make_nearest_vertex_interpolator;

pub use triangulation_interp::DelaunayTriangulation;

pub use triangulation_interp::ExteriorHandling;

pub use triangulation_interp::Triangle;

pub use triangulation_interp::TriangulationInterpolator;

pub use triangulation_interp::TriangulationMethod;

pub use spline_calculus::spline_antiderivative;

pub use spline_calculus::spline_derivative;

pub use spline_calculus::spline_integral;

pub use spline_calculus::spline_roots;

pub use spline_calculus::spline_solve;

pub use spline_calculus::PiecewisePolynomial;

pub use monotone::make_fritsch_carlson;

pub use monotone::make_steffen;

pub use monotone::FritschCarlsonInterpolator;

pub use monotone::SteffenInterpolator;

pub use rbf_interpolation::make_gaussian_rbf;

pub use rbf_interpolation::make_inverse_multiquadric_rbf;

pub use rbf_interpolation::make_multiquadric_rbf;

pub use rbf_interpolation::make_thin_plate_rbf;

pub use rbf_interpolation::RbfKernel;

pub use rbf_interpolation::ScatteredRbf;

pub use rational_interpolation::auto_select_order;

pub use rational_interpolation::make_floater_hormann;

pub use rational_interpolation::make_floater_hormann_auto;

pub use rational_interpolation::FloaterHormann;

pub use production_stress_testing::run_production_stress_tests;

pub use production_stress_testing::run_quick_stress_tests;

pub use production_stress_testing::run_stress_tests_with_config;

pub use production_stress_testing::ProductionImpact;

pub use production_stress_testing::ProductionReadiness as StressProductionReadiness;

pub use production_stress_testing::ProductionStressTester;

pub use production_stress_testing::StressTestCategory;

pub use production_stress_testing::StressTestConfig as StressTestingConfig;

pub use production_stress_testing::StressTestIssue;

pub use production_stress_testing::StressTestReport;

pub use production_stress_testing::StressTestResult;

pub use production_stress_testing::TestStatus;

pub use documentation_enhancement::enhance_documentation_for_stable_release;

pub use documentation_enhancement::enhance_documentation_with_config;

pub use documentation_enhancement::quick_documentation_analysis;

pub use documentation_enhancement::AudienceLevel;

pub use documentation_enhancement::DocumentationAnalysisResult;

pub use documentation_enhancement::DocumentationConfig;

pub use documentation_enhancement::DocumentationEnhancer;

pub use documentation_enhancement::DocumentationIssue as EnhancementDocumentationIssue;

pub use documentation_enhancement::DocumentationItemType;

pub use documentation_enhancement::DocumentationReadiness;

pub use documentation_enhancement::DocumentationReport;

pub use documentation_enhancement::ExampleValidation;

pub use documentation_enhancement::QualityAssessment as EnhancementQualityAssessment;

pub use documentation_enhancement::Tutorial as EnhancementTutorial;

pub use documentation_enhancement::UserGuide;

Modules

adaptive_gp

Gaussian process regression with adaptive kernels

adaptive_learning

Active learning approaches for adaptive sampling in interpolation

adaptive_singularity

Automatic singularity detection and handling for interpolation

advanced

Advanced interpolation methods for specialized use cases.

advanced_coordinator

Advanced Mode Coordinator for Interpolation Operations

advanced_coordinator_modules

Advanced Interpolation Coordinator Modules

advanced_statistical

Advanced statistical interpolation methods for complete SciPy compatibility

api_standards

API standardization guidelines and examples

benchmarking

Comprehensive benchmarking suite for performance validation

bezier

Bezier curve and surface implementations

bivariate

Bivariate interpolation modules

boundarymode

bspline

B-spline basis functions and B-spline curves

bspline_modules

B-spline modules - organized implementation of B-spline functionality

cache

Cache-aware algorithm implementations for interpolation

cache_aware

Cache-aware algorithm implementations for high-performance interpolation

constrained

Constrained splines with monotonicity and convexity constraints

deprecation

Deprecation policy and warnings for SciRS2 interpolation library

doc_enhancements

Documentation enhancements and complexity analysis for interpolation methods

documentation_enhancement

Documentation enhancement and polish for 0.1.0 stable release

error

Error types for the SciRS2 interpolation module

extrapolation

Enhanced extrapolation methods for interpolation

extrapolation_modules

Extrapolation Modules

fast_bspline

Fast evaluation of B-splines using recursive algorithms

geospatial

Geospatial interpolation methods

gpu_accelerated

GPU-accelerated interpolation methods

gpu_production

Production-ready GPU acceleration enhancements for interpolation workloads

grid

Grid transformation and resampling utilities

griddata

Grid data interpolation - SciPy-compatible griddata implementation

hermite

high_dimensional

High-dimensional interpolation methods

interp1d

One-dimensional interpolation methods

interp2d

2D interpolation - SciPy-compatible interp2d implementation

interpnd

N-dimensional interpolation methods

local

Local interpolation methods

memory_monitor

Memory leak detection and monitoring for continuous use

monotone

Monotone interpolation: Fritsch-Carlson and Steffen methods

multiscale

numerical_stability

Numerical Stability Monitoring and Condition Assessment

numerical_stability_modules

Numerical stability monitoring and assessment modules

nurbs

NURBS (Non-Uniform Rational B-Splines) implementation

optimization

Optimization-based parameter fitting for interpolation

parallel

Parallel processing utilities for interpolation

penalized

Penalized splines (P-splines) with various penalty terms

physics_informed

Physics-informed interpolation methods

production_stress_testing

Production stress testing and edge case validation

production_stress_testing_modules

Production stress testing modules

production_validation

Production validation and hardening for interpolation methods

rational_interpolation

Barycentric rational interpolation (Floater-Hormann)

rbf_interpolation

Radial Basis Function (RBF) interpolation for N-dimensional scattered data

scattered_nd

N-dimensional scattered data interpolation

scattered_optimized

Optimized scattered data interpolation for large datasets

scipy_compatibility

SciPy compatibility validation and API parity checker

simd_bspline

SIMD-optimized B-spline evaluation routines

simd_comprehensive_validation

Comprehensive SIMD Performance Validation for 0.1.0 stable release

simd_optimized

SIMD-optimized interpolation functions

simd_performance_validation

Comprehensive SIMD performance validation across architectures

smoothing

Variable knot smoothing splines

sparse_grid

Sparse grid interpolation methods

spatial

Spatial data structures for efficient nearest neighbor search

spline

Cubic spline interpolation with comprehensive boundary condition support

spline_calculus

Spline calculus: derivatives, integrals, antiderivatives, and root-finding

statistical

Advanced statistical interpolation methods

statistical_advanced

Advanced statistical interpolation methods

streaming

Streaming interpolation for online and real-time systems

structured_matrix

Structured coefficient matrix operations for interpolation algorithms

tension

tensor

Tensor product interpolation

tensor_product

Tensor product grid interpolation

timeseries

Time series specific interpolation methods

traits

Common traits for interpolation types

triangulation_interp

Triangulation-based interpolation for 2D scattered data

utils

Utility functions for interpolation

voronoi

Voronoi-based interpolation methods

Macros

deprecated_function

Macro to mark a function as deprecated with structured information

experimental_feature

Experimental feature marker