update structure and documentation

Author: jonasBoss

src/interp1d.rs

@@ -10,7 +10,7 @@
 //!
 //! # Strategies
 //!  - [`Linear`] Linear interpolation strategy
-//!  - [`CubicSpline`] Cubic spline interpolation strategy
+//!  - [`cubic_spline`] Cubic spline interpolation strategy
 
 use std::{any::TypeId, fmt::Debug, ops::Sub};
 
@@ -30,10 +30,14 @@ use crate::{
 mod aliases;
 mod strategies;
 pub use aliases::*;
-pub use strategies::{
-    BoundaryCondition, CubicSpline, Interp1DStrategy, Interp1DStrategyBuilder, Linear, RowBoundary,
-    SingleBoundary,
-};
+pub use strategies::linear::Linear;
+pub use strategies::{Interp1DStrategy, Interp1DStrategyBuilder};
+
+pub mod cubic_spline {
+    pub use super::strategies::cubic_spline::{
+        BoundaryCondition, CubicSpline, RowBoundary, SingleBoundary,
+    };
+}
 
 /// One dimensional interpolator
 #[derive(Debug)]

src/interp1d/strategies.rs

@@ -6,11 +6,8 @@ use num_traits::Num;
 use super::Interp1D;
 use crate::{BuilderError, InterpolateError};
 
-mod cubic_spline;
-mod linear;
-
-pub use cubic_spline::{BoundaryCondition, CubicSpline, RowBoundary, SingleBoundary};
-pub use linear::Linear;
+pub mod cubic_spline;
+pub mod linear;
 
 pub trait Interp1DStrategyBuilder<Sd, Sx, D>
 where

src/interp1d/strategies/cubic_spline.rs

@@ -52,6 +52,7 @@ impl<T> SplineNum for T where
 /// ```
 /// # use ndarray_interp::*;
 /// # use ndarray_interp::interp1d::*;
+///  # use ndarray_interp::interp1d::cubic_spline::*;
 /// # use ndarray::*;
 /// # use approx::*;
 ///
@@ -97,6 +98,7 @@ pub struct CubicSpline<T, D: Dimension> {
 /// ``` rust
 /// # use ndarray_interp::*;
 /// # use ndarray_interp::interp1d::*;
+/// # use ndarray_interp::interp1d::cubic_spline::*;
 /// # use ndarray::*;
 /// # use approx::*;
 ///

src/lib.rs

@@ -5,13 +5,114 @@
 //! The ndarray-interp crate provides interpolation algorithms
 //! for interpolating _n_-dimesional data.
 //!
-//! 1D and 2D interpolation is supported. See the modules [interp1d] and [interp2d]
+//! # 1D Interpolation
+//! The [interp1d] module provides the [`Interp1D`](interp1d::Interp1D) interpolator
+//! and different interpolation strategies
+//!
+//! **1D Strategies**
+//!  - [`interp1d::Linear`] - Linear interpolation and extrapolation
+//!  - [`interp1d::cubic_spline`] - Cubic Spline interpolation with different boundary conditions.
+//!
+//! # 2D Interpolation
+//! The [interp2d] module provides the [`Interp2D`](interp2d::Interp2D) interpolator
+//! and different interpolation strategies
+//!
+//! **2D Strategies**
+//!  - [`interp2d::Biliniar`] - Biliniar interpolation and extrapolation
 //!
 //! # Custom interpolation strategy
 //! This crate defines traits to allow implementation of user
 //! defined interpolation algorithms.
-//! see the `custom_strategy.rs` example.
+//! A 1D interpolation strategy can be created by implementing the
+//! [`Interp1DStrategy`](interp1d::Interp1DStrategy) and
+//! [`Interp1DStrategyBuilder`](interp1d::Interp1DStrategyBuilder) traits.
+//! A 2D interpolation strategy can be created by implementing the
+//! [`Interp2DStrategy`](interp2d::Interp2DStrategy) and
+//! [`Interp2DStrategyBuilder`](interp2d::Interp2DStrategyBuilder) traits.
+//!
+//! See also the `custom_strategy.rs` example.
+//!
+//! # Examples
+//! **1D Example**
+//! ``` rust
+//! use ndarray_interp::interp1d::*;
+//! use ndarray::*;
+//!
+//! let data = array![0.0, 1.0, 1.5, 1.0, 0.0 ];
+//! let interp = Interp1DBuilder::new(data).build().unwrap();
+//!
+//! let result = interp.interp_scalar(3.5).unwrap();
+//! assert!(result == 0.5);
+//! let result = interp.interp_array(&array![0.0, 0.5, 1.5]).unwrap();
+//! assert!(result == array![0.0, 0.5, 1.25])
+//! ```
+//!
+//! **1D Example with multidimensional data**
+//! ```rust
+//! use ndarray_interp::interp1d::*;
+//! use ndarray::*;
+//!
+//! let data = array![
+//!     [0.0, 1.0],
+//!     [1.0, 2.0],
+//!     [1.5, 2.5],
+//!     [1.0, 2.0],
+//! ];
+//! let x = array![1.0, 2.0, 3.0, 4.0];
+//!
+//! let interp = Interp1D::builder(data)
+//!     .strategy(Linear::new().extrapolate(true))
+//!     .x(x)
+//!     .build().unwrap();
+//!
+//! let result = interp.interp(0.5).unwrap();
+//! assert!(result == array![-0.5, 0.5]);
+//! let result = interp.interp_array(&array![0.5, 4.0]).unwrap();
+//! assert!(result == array![[-0.5, 0.5], [1.0, 2.0]]);
+//! ```
+//!
+//! **2D Example**
+//! ```rust
+//! use ndarray_interp::interp2d::*;
+//! use ndarray::*;
+//!
+//! let data = array![
+//!     [1.0, 2.0, 2.5],
+//!     [3.0, 4.0, 3.5],
+//! ];
+//! let interp = Interp2D::builder(data).build().unwrap();
+//!
+//! let result = interp.interp_scalar(0.0, 0.5).unwrap();
+//! assert!(result == 1.5);
+//! let result = interp.interp_array(&array![0.0, 1.0], &array![0.5, 2.0]).unwrap();
+//! assert!(result == array![1.5, 3.5]);
+//! ```
+//!
+//! **1D Example with multidimensional data**
+//! ``` rust
+//! use ndarray_interp::interp2d::*;
+//! use ndarray::*;
+//!
+//! let data = array![
+//!     // ---------------------------------> y
+//!     [[1.0, -1.0], [2.0, -2.0], [3.0, -3.0]], // |
+//!     [[4.0, -4.0], [5.0, -5.0], [6.0, -6.0]], // |
+//!     [[7.0, -7.0], [8.0, -8.0], [9.0, -9.0]], // V
+//!     [[7.5, -7.5], [8.5, -8.5], [9.5, -9.5]], // x
+//! ];
+//! let x = array![1.0, 2.0, 3.0, 4.0];
+//! let y = array![1.0, 2.0, 3.0];
+//!
+//! let interp = Interp2D::builder(data)
+//!     .x(x)
+//!     .y(y)
+//!     .build().unwrap();
 //!
+//! let result = interp.interp(1.5, 2.0).unwrap();
+//! assert!(result == array![3.5, -3.5]);
+//! let result = interp.interp_array(&array![1.5, 1.5], &array![2.0, 2.5]).unwrap();
+//! assert!(result == array![[3.5, -3.5],[4.0, -4.0]]);
+//! ```
 
 use std::mem::ManuallyDrop;
 

tests/cubic_spline_strat.rs

@@ -1,8 +1,9 @@
 use approx::assert_relative_eq;
 use ndarray::{array, Array1};
-use ndarray_interp::interp1d::{
-    BoundaryCondition, CubicSpline, Interp1D, Interp1DBuilder, RowBoundary, SingleBoundary,
+use ndarray_interp::interp1d::cubic_spline::{
+    BoundaryCondition, CubicSpline, RowBoundary, SingleBoundary,
 };
+use ndarray_interp::interp1d::{Interp1D, Interp1DBuilder};
 use ndarray_interp::{BuilderError, InterpolateError};
 
 #[test]
@@ -202,7 +203,7 @@ fn multidim_multi_bounds() {
         }
     ],];
     let strat = CubicSpline::new().boundary(BoundaryCondition::Individual(boundaries));
-    let interpolator = Interp1DBuilder::new(y)
+    let _interpolator = Interp1DBuilder::new(y)
         .x(x)
         .strategy(strat)
         .build()