1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
//! Cubic spline interpolation with comprehensive boundary condition support
//!
//! This module provides production-ready cubic spline interpolation that offers C2 continuity
//! (continuous function, first, and second derivatives) making it ideal for smooth curve fitting
//! and scientific applications requiring high-quality interpolation.
//!
//! ## Overview
//!
//! Cubic splines construct piecewise cubic polynomials that pass through all data points while
//! maintaining smoothness properties. Each segment between adjacent data points is represented
//! by a cubic polynomial of the form:
//!
//! ```text
//! y(x) = a + b(x-xᵢ) + c(x-xᵢ)² + d(x-xᵢ)³
//! ```
//!
//! ## Computational Complexity
//!
//! | Operation | Time Complexity | Space Complexity | Notes |
//! |-----------|----------------|------------------|-------|
//! | Construction | O(n) | O(n) | Tridiagonal solve |
//! | Single Evaluation | O(log n) | O(1) | Binary search + polynomial eval |
//! | Batch Evaluation | O(m log n) | O(1) | m = number of evaluation points |
//! | Derivative | O(log n) | O(1) | Analytical differentiation |
//!
//! ## Boundary Conditions
//!
//! Multiple boundary conditions are supported to handle different physical constraints:
//!
//! - **Natural**: Zero second derivative at endpoints (default)
//! - **Not-a-knot**: Maximum smoothness at second and second-to-last points
//! - **Clamped**: Specified first derivatives at endpoints
//! - **Periodic**: Function and derivatives match at endpoints
//! - **Second derivative**: Specified second derivatives at endpoints
//!
//! ## SciPy Compatibility
//!
//! This implementation maintains API compatibility with SciPy's `CubicSpline` class,
//! allowing for easy migration from Python-based workflows.
//!
//! ## Performance Characteristics
//!
//! - **Numerical stability**: Excellent for well-conditioned data
//! - **Memory efficiency**: O(n) storage for unlimited evaluations
//! - **Real-time capable**: Sub-microsecond evaluation after construction
//! - **SIMD optimized**: Vectorized evaluation for batch operations
//!
//! ## Example Usage
//!
//! ```rust
//! use scirs2_core::ndarray::array;
//! use scirs2_interpolate::spline::{CubicSpline, SplineBoundaryCondition};
//!
//! // Basic usage with natural boundary conditions
//! let x = array![0.0, 1.0, 2.0, 3.0];
//! let y = array![0.0, 1.0, 4.0, 9.0];
//! let spline = CubicSpline::new(&x.view(), &y.view()).expect("doc example: should succeed");
//!
//! // Evaluate at a point
//! let result = spline.evaluate(1.5).expect("doc example: should succeed");
//!
//! // Compute derivatives
//! let derivative = spline.derivative(1.5).expect("doc example: should succeed");
//! let second_deriv = spline.derivative_n(1.5, 2).expect("doc example: should succeed");
//!
//! // Integration
//! let integral = spline.integrate(0.5, 2.5).expect("doc example: should succeed");
//!
//! // Advanced usage with builder pattern
//! let spline = CubicSpline::builder()
//! .x(x.clone())
//! .y(y.clone())
//! .boundary_condition(SplineBoundaryCondition::Clamped(0.0, 6.0))
//! .build()
//! .expect("doc example: should succeed");
//!
//! // SciPy-compatible interface
//! let spline = scirs2_interpolate::spline::cubic_spline_scipy(
//! &x.view(),
//! &y.view(),
//! "not-a-knot",
//! None,
//! false
//! ).expect("doc example: should succeed");
//! ```
//!
//! ## Architecture
//!
//! This module has been refactored into focused submodules for better maintainability:
//!
//! - **types**: Core type definitions and boundary conditions
//! - **algorithms**: Computational algorithms for different boundary conditions
//! - **core**: Main data structures (CubicSpline, CubicSplineBuilder)
//! - **evaluation**: Evaluation and derivative computation methods
//! - **integration**: Integration methods and extrapolation support
//! - **traits_impl**: Trait implementations for framework compatibility
//! - **api**: Public SciPy-compatible API functions
//! - **utils**: Utility functions and helpers
// Re-export the spline module contents from the subdirectory
pub use *;