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.0-rc.2"

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).unwrap();

// Evaluate at new points
let x_new = array![0.5, 1.5, 2.5];
let y_new = interp.eval(&x_new.view()).unwrap();

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
).unwrap();

let y_interp = spline.evaluate(1.5).unwrap();

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).unwrap();

// Evaluate at new points
let x_new = array![[0.5, 0.5]];
let y_new = rbf.evaluate(&x_new.view()).unwrap();

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(),
).unwrap();

🏗️ 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.0-rc.2
• Release Date: October 03, 2025
• 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::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_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 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

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

scattered_optimized

Optimized scattered data interpolation for large datasets

scipy_compatibility

SciPy compatibility validation and API parity checker

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

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

timeseries

Time series specific interpolation methods

traits

Common traits for interpolation types

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