implement ndg make (currently, it does not work properly)

Author: espdev

src/ndg.rs

@@ -111,10 +111,10 @@ pub struct GridCubicSmoothingSpline<'a, T, D>
     y: ArrayView<'a, T, D>,
 
     /// The optional data weights
-    weights: Option<Vec<Option<ArrayView1<'a, T>>>>,
+    weights: Vec<Option<ArrayView1<'a, T>>>,
 
     /// The optional smoothing parameter
-    smooth: Option<Vec<Option<T>>>,
+    smooth: Vec<Option<T>>,
 
     /// `NdSpline` struct with computed spline
     spline: Option<NdGridSpline<'a, T, D>>
@@ -131,11 +131,13 @@ impl<'a, T, D> GridCubicSmoothingSpline<'a, T, D>
         where
             Y: AsArray<'a, T, D>
     {
+        let ndim = x.len();
+
         GridCubicSmoothingSpline {
             x: x.to_vec(),
             y: y.into(),
-            weights: None,
-            smooth: None,
+            weights: vec![None; ndim],
+            smooth: vec![None; ndim],
             spline: None,
         }
     }
@@ -146,7 +148,7 @@ impl<'a, T, D> GridCubicSmoothingSpline<'a, T, D>
     ///
     pub fn with_weights(mut self, weights: &[Option<ArrayView1<'a, T>>]) -> Self {
         self.invalidate();
-        self.weights = Some(weights.to_vec());
+        self.weights = weights.to_vec();
         self
     }
 
@@ -162,7 +164,7 @@ impl<'a, T, D> GridCubicSmoothingSpline<'a, T, D>
     ///
     pub fn with_smooth(mut self, smooth: &[Option<T>]) -> Self {
         self.invalidate();
-        self.smooth = Some(smooth.to_vec());
+        self.smooth = smooth.to_vec();
         self
     }
 
@@ -193,8 +195,8 @@ impl<'a, T, D> GridCubicSmoothingSpline<'a, T, D>
     }
 
     /// Returns the ref to smoothing parameters vector or None
-    pub fn smooth(&self) -> Option<&Vec<Option<T>>> {
-        self.smooth.as_ref()
+    pub fn smooth(&self) -> &Vec<Option<T>> {
+        &self.smooth
     }
 
     /// Returns ref to `NdGridSpline` struct with data of computed spline or None

src/ndg/make.rs

@@ -1,7 +1,9 @@
 use ndarray::{NdFloat, Dimension};
 use almost::AlmostEqual;
 
-use crate::{Result, CsapsError::ReshapeError, CubicSmoothingSpline};
+use crate::{Result, CubicSmoothingSpline};
+use crate::ndarrayext::to_2d_simple;
+
 use super::{GridCubicSmoothingSpline, NdGridSpline};
 
 
@@ -15,10 +17,10 @@ impl<'a, T, D> GridCubicSmoothingSpline<'a, T, D>
         let ndim_m1 = ndim - 1;
 
         let breaks = self.x.to_vec();
-        let mut coeffs = self.y.view();
+        let mut coeffs = self.y.to_owned();
         let mut coeffs_shape = coeffs.shape().to_vec();
 
-        let mut smooth: Vec<Option<T>> = Vec::new();
+        let mut smooth: Vec<Option<T>> = vec![None; ndim];
 
         let mut permute_axes = D::zeros(ndim);
         permute_axes[0] = ndim_m1;
@@ -28,41 +30,47 @@ impl<'a, T, D> GridCubicSmoothingSpline<'a, T, D>
 
         for ax in (0..ndim).rev() {
             let x = breaks[ax].view();
+            let y = to_2d_simple(coeffs.view())?;
+
+            let weights = self.weights[ax].map(|v| v.reborrow());
+            let s = self.smooth[ax];
+
+            println!("\nx shape: {:?}", x.shape());
+            println!("y shape: {:?}", y.shape());
+
+            println!("\nx: {:?}", x);
+            println!("y: {:?}", y);
+
+            let sp = CubicSmoothingSpline::new(x, y)
+                .with_optional_weights(weights)
+                .with_optional_smooth(s)
+                .make()?;
+
+            smooth[ax] = sp.smooth();
+
+            coeffs = {
+                let spline = sp.spline().unwrap();
+
+                coeffs_shape[ndim_m1] = spline.pieces() * spline.order();
+                let mut new_shape = D::zeros(ndim);
+                for (ax, &sz) in coeffs_shape.iter().enumerate() {
+                    new_shape[ax] = sz
+                }
+
+                spline.coeffs()
+                    .into_shape(new_shape).unwrap()
+                    .permuted_axes(permute_axes.clone())
+                    .to_owned()
+            };
+
+            coeffs_shape = coeffs.shape().to_vec();
 
-            if ndim > 2 {
-                let coeffs_2d = {
-                    let shape = coeffs.shape().to_vec();
-                    let new_shape = [shape[0..ndim_m1].iter().product(), shape[ndim_m1]];
-
-                    match coeffs.view().into_shape(new_shape) {
-                        Ok(coeffs_2d) => coeffs_2d,
-                        Err(err) => {
-                            return Err(
-                                ReshapeError(
-                                    format!("Cannot reshape data array with shape {:?} to 2-d array with shape {:?}\n{}",
-                                            shape, new_shape, err)
-                                )
-                            )
-                        }
-                    }
-                };
-
-            //     CubicSmoothingSpline::new(x, coeffs_2d.view())
-            //         .make()?
-            //         .spline().unwrap()
-            //         .coeffs().to_owned()
-            //
-            // } else {
-            //
-            //     CubicSmoothingSpline::new(x, coeffs.view())
-            //         .make()?
-            //         .spline().unwrap()
-            //         .coeffs().to_owned()
-            }
+            println!("\ncoeffs shape: {:?}", coeffs.shape());
+            println!("coeffs: {:?}", coeffs);
         }
 
-        self.smooth = Some(smooth);
-        self.spline = Some(NdGridSpline::new(breaks, coeffs.to_owned()));
+        self.smooth = smooth;
+        self.spline = Some(NdGridSpline::new(breaks, coeffs));
 
         Ok(())
     }

src/ndg/validate.rs

@@ -20,14 +20,8 @@ impl<'a, T, D> GridCubicSmoothingSpline<'a, T, D>
 {
     pub(super) fn make_validate(&self) -> Result<()> {
         validate_xy(&self.x, self.y.view())?;
-
-        if let Some(weights) = self.weights.as_ref() {
-            validate_weights(&self.x, weights)?;
-        }
-
-        if let Some(smooth) = self.smooth.as_ref() {
-            validate_smooth(smooth)?;
-        }
+        validate_weights(&self.x, &self.weights)?;
+        validate_smooth(&self.x, &self.smooth)?;
 
         Ok(())
     }
@@ -89,7 +83,7 @@ pub(super) fn validate_weights<T>(x: &[ArrayView1<'_, T>], w: &[Option<ArrayView
     if w_len != x_len {
         return Err(
             InvalidInputData(
-                format!("The number of `weights` vectors ({}) is not equal to the number of `x` vectors ({})",
+                format!("The number of `weights` vectors ({}) is not equal to the number of dimensions ({})",
                         w_len, x_len)
             )
         )
@@ -115,17 +109,26 @@ pub(super) fn validate_weights<T>(x: &[ArrayView1<'_, T>], w: &[Option<ArrayView
 }
 
 
-pub(super) fn validate_smooth<T>(smooth: &[Option<T>]) -> Result<()>
+pub(super) fn validate_smooth<T>(x: &[ArrayView1<'_, T>], smooth: &[Option<T>]) -> Result<()>
     where
         T: NdFloat
 {
+    let x_len = x.len();
+    let s_len = smooth.len();
+
+    if s_len != x_len {
+        return Err(
+            InvalidInputData(
+                format!("The number of `smooth` values ({}) is not equal to the number of dimensions ({})",
+                        s_len, x_len)
+            )
+        )
+    }
+
     for (ax, s_opt) in smooth.iter().enumerate() {
         if let Some(s) = s_opt {
-            match validate_smooth_value(*s) {
-                Ok(res) => (),
-                Err(err) => {
-                    return Err(InvalidInputData(format!("{} for axis {}", err, ax)))
-                }
+            if let Err(err) = validate_smooth_value(*s) {
+                return Err(InvalidInputData(format!("{} for axis {}", err, ax)))
             };
         }
     }

src/umv.rs

@@ -237,6 +237,12 @@ impl<'a, T, D> CubicSmoothingSpline<'a, T, D>
         self
     }
 
+    pub(crate) fn with_optional_weights(mut self, weights: Option<ArrayView1<'a, T>>) -> Self {
+        self.invalidate();
+        self.weights = weights;
+        self
+    }
+
     /// Sets the smoothing parameter
     ///
     /// The smoothing parameter should be in range `[0, 1]`,
@@ -251,6 +257,12 @@ impl<'a, T, D> CubicSmoothingSpline<'a, T, D>
         self
     }
 
+    pub(crate) fn with_optional_smooth(mut self, smooth: Option<T>) -> Self {
+        self.invalidate();
+        self.smooth = smooth;
+        self
+    }
+
     /// Makes (computes) the spline for given data and parameters
     ///
     /// # Errors