add validate data for ndg make

Author: espdev

src/ndg.rs

@@ -185,6 +185,7 @@ impl<'a, T, D> NdGridCubicSmoothingSpline<'a, T, D>
     /// - If the data or parameters are invalid
     ///
     pub fn make(mut self) -> Result<Self> {
+        self.make_validate()?;
         self.make_spline()?;
         Ok(self)
     }

src/ndg/validate.rs

@@ -8,16 +8,41 @@ use ndarray::{
 use almost::AlmostEqual;
 
 use crate::{Result, CsapsError::InvalidInputData};
-use crate::validate::validate_data_sites;
+use crate::validate::{validate_data_sites, validate_smooth_value};
 
+use super::NdGridCubicSmoothingSpline;
 
-pub(super) fn validate_xy<'a, T, D>(x: &'a [ArrayView1<'a, T>], y: ArrayView<'a, T, D>) -> Result<()>
-    where T: NdFloat + AlmostEqual, D: Dimension
+
+impl<'a, T, D> NdGridCubicSmoothingSpline<'a, T, D>
+    where
+        T: NdFloat + AlmostEqual + Default,
+        D: Dimension
+{
+    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)?;
+        }
+
+        Ok(())
+    }
+}
+
+
+pub(super) fn validate_xy<T, D>(x: &[ArrayView1<'_, T>], y: ArrayView<'_, T, D>) -> Result<()>
+    where
+        T: NdFloat + AlmostEqual,
+        D: Dimension
 {
     if x.len() != y.ndim() {
         return Err(
             InvalidInputData(
-                format!("The number of `X` data sites ({}) is not equal to `Y` data dimensionality ({})",
+                format!("The number of `x` data sites ({}) is not equal to `y` data dimensionality ({})",
                         x.len(), y.ndim())
             )
         )
@@ -28,17 +53,82 @@ pub(super) fn validate_xy<'a, T, D>(x: &'a [ArrayView1<'a, T>], y: ArrayView<'a,
         .zip(y.shape().iter())
         .enumerate()
     {
+        let xi_len = xi.len();
+
+        if xi_len < 2 {
+            return Err(
+                InvalidInputData(
+                    format!("The size of `x` site vectors must be greater or equal to 2, axis {}", ax)
+                )
+            )
+        }
+
         validate_data_sites(xi.view())?;
 
-        if xi.len() != ys {
+        if xi_len != ys {
             return Err(
                 InvalidInputData(
-                    format!("`X` data sites vector size ({}) is not equal to `Y` data size ({}) for axis {}",
-                            xi.len(), ys, ax)
+                    format!("`x` data sites vector size ({}) is not equal to `y` data size ({}) for axis {}",
+                            xi_len, ys, ax)
                 )
             )
         }
     }
 
     Ok(())
 }
+
+
+pub(super) fn validate_weights<T>(x: &[ArrayView1<'_, T>], w: &[Option<ArrayView1<'_, T>>]) -> Result<()>
+    where
+        T: NdFloat + AlmostEqual
+{
+    let x_len = x.len();
+    let w_len = w.len();
+
+    if w_len != x_len {
+        return Err(
+            InvalidInputData(
+                format!("The number of `weights` vectors ({}) is not equal to the number of `x` vectors ({})",
+                        w_len, x_len)
+            )
+        )
+    }
+
+    for (ax, (xi, wi)) in x.iter().zip(w.iter()).enumerate() {
+        if let Some(wi_view) = wi {
+            let xi_len = xi.len();
+            let wi_len = wi_view.len();
+
+            if wi_len != xi_len {
+                return Err(
+                    InvalidInputData(
+                        format!("`weights` vector size ({}) is not equal to `x` vector size ({}) for axis {}",
+                                wi_len, xi_len, ax)
+                    )
+                )
+            }
+        }
+    }
+
+    Ok(())
+}
+
+
+pub(super) fn validate_smooth<T>(smooth: &[Option<T>]) -> Result<()>
+    where
+        T: NdFloat
+{
+    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)))
+                }
+            };
+        }
+    }
+
+    Ok(())
+}

src/umv/validate.rs

@@ -12,14 +12,26 @@ use crate::{
     CubicSmoothingSpline,
     CsapsError::InvalidInputData,
     Result,
-    validate::validate_data_sites,
+    validate::{validate_data_sites, validate_smooth_value},
 };
 
 
 impl<'a, T, D> CubicSmoothingSpline<'a, T, D>
     where T: NdFloat + Default + AlmostEqual, D: Dimension
 {
     pub(super) fn make_validate_data(&self) -> Result<()> {
+        let x_size = self.x.len();
+
+        if x_size < 2 {
+            return Err(
+                InvalidInputData(
+                    "The size of data vectors must be greater or equal to 2".to_string()
+                )
+            )
+        }
+
+        validate_data_sites(self.x)?;
+
         if self.y.ndim() == 0 {
             return Err(
                 InvalidInputData("`y` has zero dimensionality".to_string())
@@ -38,7 +50,6 @@ impl<'a, T, D> CubicSmoothingSpline<'a, T, D>
             )
         }
 
-        let x_size = self.x.len();
         let y_size = self.y.len_of(axis);
 
         if x_size != y_size {
@@ -50,16 +61,6 @@ impl<'a, T, D> CubicSmoothingSpline<'a, T, D>
             )
         }
 
-        if x_size < 2 {
-            return Err(
-                InvalidInputData(
-                    "The size of data vectors must be greater or equal to 2".to_string()
-                )
-            )
-        }
-
-        validate_data_sites(self.x)?;
-
         if let Some(weights) = self.weights {
             let w_size = weights.len();
 
@@ -73,13 +74,7 @@ impl<'a, T, D> CubicSmoothingSpline<'a, T, D>
         }
 
         if let Some(smooth) = self.smooth {
-            if smooth < T::zero() || smooth > T::one() {
-                return Err(
-                    InvalidInputData(
-                        format!("`smooth` value must be in range 0..1, given {:?}", smooth)
-                    )
-                )
-            }
+            validate_smooth_value(smooth)?;
         }
 
         Ok(())

src/validate.rs

@@ -21,3 +21,19 @@ pub(crate) fn validate_data_sites<T>(x: ArrayView1<T>) -> Result<()>
 
     Ok(())
 }
+
+
+pub(crate) fn validate_smooth_value<T>(smooth: T) -> Result<()>
+    where
+        T: NdFloat
+{
+    if smooth < T::zero() || smooth > T::one() {
+        return Err(
+            InvalidInputData(
+                format!("`smooth` value must be in range 0..1, given {:?}", smooth)
+            )
+        )
+    }
+
+    Ok(())
+}