Make geomspace return None instead of panicking

This helps to make the user more aware of the constraints on
`geomspace` and allows recovering in case of bad input.

Author: jturner314

src/geomspace.rs

@@ -71,21 +71,17 @@ impl<F> ExactSizeIterator for Geomspace<F> where Geomspace<F>: Iterator {}
 ///
 /// Iterator element type is `F`, where `F` must be either `f32` or `f64`.
 ///
-/// **Panics** if the interval `[a, b]` contains zero (including the end points).
+/// Returns `None` if `start` and `end` have different signs or if either one
+/// is zero. Conceptually, this means that in order to obtain a `Some` result,
+/// `end / start` must be positive.
 #[inline]
-pub fn geomspace<F>(a: F, b: F, n: usize) -> Geomspace<F>
+pub fn geomspace<F>(a: F, b: F, n: usize) -> Option<Geomspace<F>>
 where
     F: Float,
 {
-    assert!(
-        a != F::zero() && b != F::zero(),
-        "Start and/or end of geomspace cannot be zero.",
-    );
-    assert!(
-        a.is_sign_negative() == b.is_sign_negative(),
-        "Logarithmic interval cannot cross 0."
-    );
-
+    if a == F::zero() || b == F::zero() || a.is_sign_negative() != b.is_sign_negative() {
+        return None;
+    }
     let log_a = a.abs().ln();
     let log_b = b.abs().ln();
     let step = if n > 1 {
@@ -94,13 +90,13 @@ where
     } else {
         F::zero()
     };
-    Geomspace {
+    Some(Geomspace {
         sign: a.signum(),
         start: log_a,
         step: step,
         index: 0,
         len: n,
-    }
+    })
 }
 
 #[cfg(test)]
@@ -113,22 +109,22 @@ mod tests {
         use approx::assert_abs_diff_eq;
         use crate::{arr1, Array1};
 
-        let array: Array1<_> = geomspace(1e0, 1e3, 4).collect();
+        let array: Array1<_> = geomspace(1e0, 1e3, 4).unwrap().collect();
         assert_abs_diff_eq!(array, arr1(&[1e0, 1e1, 1e2, 1e3]), epsilon = 1e-12);
 
-        let array: Array1<_> = geomspace(1e3, 1e0, 4).collect();
+        let array: Array1<_> = geomspace(1e3, 1e0, 4).unwrap().collect();
         assert_abs_diff_eq!(array, arr1(&[1e3, 1e2, 1e1, 1e0]), epsilon = 1e-12);
 
-        let array: Array1<_> = geomspace(-1e3, -1e0, 4).collect();
+        let array: Array1<_> = geomspace(-1e3, -1e0, 4).unwrap().collect();
         assert_abs_diff_eq!(array, arr1(&[-1e3, -1e2, -1e1, -1e0]), epsilon = 1e-12);
 
-        let array: Array1<_> = geomspace(-1e0, -1e3, 4).collect();
+        let array: Array1<_> = geomspace(-1e0, -1e3, 4).unwrap().collect();
         assert_abs_diff_eq!(array, arr1(&[-1e0, -1e1, -1e2, -1e3]), epsilon = 1e-12);
     }
 
     #[test]
     fn iter_forward() {
-        let mut iter = geomspace(1.0f64, 1e3, 4);
+        let mut iter = geomspace(1.0f64, 1e3, 4).unwrap();
 
         assert!(iter.size_hint() == (4, Some(4)));
 
@@ -143,7 +139,7 @@ mod tests {
 
     #[test]
     fn iter_backward() {
-        let mut iter = geomspace(1.0f64, 1e3, 4);
+        let mut iter = geomspace(1.0f64, 1e3, 4).unwrap();
 
         assert!(iter.size_hint() == (4, Some(4)));
 
@@ -157,20 +153,17 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
     fn zero_lower() {
-        geomspace(0.0, 1.0, 4);
+        assert!(geomspace(0.0, 1.0, 4).is_none());
     }
 
     #[test]
-    #[should_panic]
     fn zero_upper() {
-        geomspace(1.0, 0.0, 4);
+        assert!(geomspace(1.0, 0.0, 4).is_none());
     }
 
     #[test]
-    #[should_panic]
     fn zero_included() {
-        geomspace(-1.0, 1.0, 4);
+        assert!(geomspace(-1.0, 1.0, 4).is_none());
     }
 }

src/impl_constructors.rs

@@ -133,28 +133,34 @@ impl<S, A> ArrayBase<S, Ix1>
     /// end]` with `n` elements geometrically spaced. `A` must be a floating
     /// point type.
     ///
-    /// The interval can be either all positive or all negative; however, it
-    /// cannot contain 0 (including the end points).
+    /// Returns `None` if `start` and `end` have different signs or if either
+    /// one is zero. Conceptually, this means that in order to obtain a `Some`
+    /// result, `end / start` must be positive.
     ///
     /// **Panics** if `n` is greater than `isize::MAX`.
     ///
     /// ```rust
     /// use approx::assert_abs_diff_eq;
     /// use ndarray::{Array, arr1};
     ///
+    /// # fn example() -> Option<()> {
     /// # #[cfg(feature = "approx")] {
-    /// let array = Array::geomspace(1e0, 1e3, 4);
+    /// let array = Array::geomspace(1e0, 1e3, 4)?;
     /// assert_abs_diff_eq!(array, arr1(&[1e0, 1e1, 1e2, 1e3]), epsilon = 1e-12);
     ///
-    /// let array = Array::geomspace(-1e3, -1e0, 4);
+    /// let array = Array::geomspace(-1e3, -1e0, 4)?;
     /// assert_abs_diff_eq!(array, arr1(&[-1e3, -1e2, -1e1, -1e0]), epsilon = 1e-12);
     /// # }
+    /// # Some(())
+    /// # }
+    /// #
+    /// # fn main() { example().unwrap() }
     /// ```
-    pub fn geomspace(start: A, end: A, n: usize) -> Self
+    pub fn geomspace(start: A, end: A, n: usize) -> Option<Self>
     where
         A: Float,
     {
-        Self::from_vec(to_vec(geomspace::geomspace(start, end, n)))
+        Some(Self::from_vec(to_vec(geomspace::geomspace(start, end, n)?)))
     }
 }