Use FiniteBounds to only allow a..b and a..=b ranges.

Author: Kwonunn

benches/iter.rs

@@ -47,7 +47,7 @@ fn iter_sum_2d_transpose(bench: &mut Bencher)
 #[bench]
 fn iter_filter_sum_2d_u32(bench: &mut Bencher)
 {
-    let a = Array::linspace(0., 1., 256)
+    let a = Array::linspace(0.0..=1.0, 256)
         .into_shape_with_order((16, 16))
         .unwrap();
     let b = a.mapv(|x| (x * 100.) as u32);
@@ -58,7 +58,7 @@ fn iter_filter_sum_2d_u32(bench: &mut Bencher)
 #[bench]
 fn iter_filter_sum_2d_f32(bench: &mut Bencher)
 {
-    let a = Array::linspace(0., 1., 256)
+    let a = Array::linspace(0.0..=1.0, 256)
         .into_shape_with_order((16, 16))
         .unwrap();
     let b = a * 100.;
@@ -69,7 +69,7 @@ fn iter_filter_sum_2d_f32(bench: &mut Bencher)
 #[bench]
 fn iter_filter_sum_2d_stride_u32(bench: &mut Bencher)
 {
-    let a = Array::linspace(0., 1., 256)
+    let a = Array::linspace(0.0..=1.0, 256)
         .into_shape_with_order((16, 16))
         .unwrap();
     let b = a.mapv(|x| (x * 100.) as u32);
@@ -81,7 +81,7 @@ fn iter_filter_sum_2d_stride_u32(bench: &mut Bencher)
 #[bench]
 fn iter_filter_sum_2d_stride_f32(bench: &mut Bencher)
 {
-    let a = Array::linspace(0., 1., 256)
+    let a = Array::linspace(0.0..=1.0, 256)
         .into_shape_with_order((16, 16))
         .unwrap();
     let b = a * 100.;
@@ -93,7 +93,7 @@ fn iter_filter_sum_2d_stride_f32(bench: &mut Bencher)
 #[bench]
 fn iter_rev_step_by_contiguous(bench: &mut Bencher)
 {
-    let a = Array::linspace(0., 1., 512);
+    let a = Array::linspace(0.0..=1.0, 512);
     bench.iter(|| {
         a.iter().rev().step_by(2).for_each(|x| {
             black_box(x);
@@ -105,7 +105,7 @@ fn iter_rev_step_by_contiguous(bench: &mut Bencher)
 #[bench]
 fn iter_rev_step_by_discontiguous(bench: &mut Bencher)
 {
-    let mut a = Array::linspace(0., 1., 1024);
+    let mut a = Array::linspace(0.0..=1.0, 1024);
     a.slice_axis_inplace(Axis(0), Slice::new(0, None, 2));
     bench.iter(|| {
         a.iter().rev().step_by(2).for_each(|x| {

src/finite_bounds.rs

@@ -0,0 +1,38 @@
+use num_traits::Float;
+
+pub enum Bound<F> {
+    Included(F),
+    Excluded(F),
+}
+
+/// A version of std::ops::RangeBounds that only implements a..b and a..=b ranges.
+pub trait FiniteBounds<F> {
+    fn start_bound(&self) -> F;
+    fn end_bound(&self) -> Bound<F>;
+}
+
+impl<F> FiniteBounds<F> for std::ops::Range<F>
+where
+    F: Float,
+{
+    fn start_bound(&self) -> F {
+        self.start
+    }
+
+    fn end_bound(&self) -> Bound<F> {
+        Bound::Excluded(self.end)
+    }
+}
+
+impl<F> FiniteBounds<F> for std::ops::RangeInclusive<F>
+where
+    F: Float,
+{
+    fn start_bound(&self) -> F {
+        *self.start()
+    }
+
+    fn end_bound(&self) -> Bound<F> {
+        Bound::Included(*self.end())
+    }
+}

src/impl_constructors.rs

@@ -98,7 +98,7 @@ where S: DataOwned<Elem = A>
     #[cfg(feature = "std")]
     pub fn linspace<R>(range: R, n: usize) -> Self
     where
-        R: std::ops::RangeBounds<A>,
+        R: crate::finite_bounds::FiniteBounds<A>,
         A: Float,
     {
         Self::from(to_vec(linspace::linspace(range, n)))
@@ -146,7 +146,7 @@ where S: DataOwned<Elem = A>
     #[cfg(feature = "std")]
     pub fn logspace<R>(base: A, range: R, n: usize) -> Self
     where
-        R: std::ops::RangeBounds<A>,
+        R: crate::finite_bounds::FiniteBounds<A>,
         A: Float,
     {
         Self::from(to_vec(logspace::logspace(base, range, n)))

src/lib.rs

@@ -199,6 +199,8 @@ mod indexes;
 mod iterators;
 mod layout;
 mod linalg_traits;
+#[cfg(feature = "std")]
+mod finite_bounds;
 mod linspace;
 #[cfg(feature = "std")]
 pub use crate::linspace::{linspace, range, Linspace};

src/linspace.rs

@@ -7,29 +7,28 @@
 // except according to those terms.
 #![cfg(feature = "std")]
 
-use std::ops::{Bound, RangeBounds};
+use crate::finite_bounds::{Bound, FiniteBounds};
 
 use num_traits::Float;
 
 /// An iterator of a sequence of evenly spaced floats.
 ///
 /// Iterator element type is `F`.
-pub struct Linspace<F>
-{
+pub struct Linspace<F> {
     start: F,
     step: F,
     index: usize,
     len: usize,
 }
 
 impl<F> Iterator for Linspace<F>
-where F: Float
+where
+    F: Float,
 {
     type Item = F;
 
     #[inline]
-    fn next(&mut self) -> Option<F>
-    {
+    fn next(&mut self) -> Option<F> {
         if self.index >= self.len {
             None
         } else {
@@ -41,19 +40,18 @@ where F: Float
     }
 
     #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>)
-    {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let n = self.len - self.index;
         (n, Some(n))
     }
 }
 
 impl<F> DoubleEndedIterator for Linspace<F>
-where F: Float
+where
+    F: Float,
 {
     #[inline]
-    fn next_back(&mut self) -> Option<F>
-    {
+    fn next_back(&mut self) -> Option<F> {
         if self.index >= self.len {
             None
         } else {
@@ -80,15 +78,12 @@ impl<F> ExactSizeIterator for Linspace<F> where Linspace<F>: Iterator {}
 #[inline]
 pub fn linspace<R, F>(range: R, n: usize) -> Linspace<F>
 where
-    R: RangeBounds<F>,
+    R: FiniteBounds<F>,
     F: Float,
 {
     let (a, b, num_steps) = match (range.start_bound(), range.end_bound()) {
-        (Bound::Included(a), Bound::Included(b)) =>
-            (*a, *b, F::from(n - 1).expect("Converting number of steps to `A` must not fail.")),
-        (Bound::Included(a), Bound::Excluded(b)) =>
-            (*a, *b, F::from(n).expect("Converting number of steps to `A` must not fail.")),
-        _ => panic!("Only a..b and a..=b ranges are supported."),
+        (a, Bound::Included(b)) => (a, b, F::from(n - 1).expect("Converting number of steps to `A` must not fail.")),
+        (a, Bound::Excluded(b)) => (a, b, F::from(n).expect("Converting number of steps to `A` must not fail.")),
     };
 
     let step = if num_steps > F::zero() {
@@ -116,7 +111,8 @@ where
 /// **Panics** if converting `((b - a) / step).ceil()` to type `F` fails.
 #[inline]
 pub fn range<F>(a: F, b: F, step: F) -> Linspace<F>
-where F: Float
+where
+    F: Float,
 {
     let len = b - a;
     let steps = F::ceil(len / step);

src/logspace.rs

@@ -7,14 +7,14 @@
 // except according to those terms.
 #![cfg(feature = "std")]
 
+use crate::finite_bounds::{Bound, FiniteBounds};
+
 use num_traits::Float;
-use std::ops::{Bound, RangeBounds};
 
 /// An iterator of a sequence of logarithmically spaced number.
 ///
 /// Iterator element type is `F`.
-pub struct Logspace<F>
-{
+pub struct Logspace<F> {
     sign: F,
     base: F,
     start: F,
@@ -24,13 +24,13 @@ pub struct Logspace<F>
 }
 
 impl<F> Iterator for Logspace<F>
-where F: Float
+where
+    F: Float,
 {
     type Item = F;
 
     #[inline]
-    fn next(&mut self) -> Option<F>
-    {
+    fn next(&mut self) -> Option<F> {
         if self.index >= self.len {
             None
         } else {
@@ -43,19 +43,18 @@ where F: Float
     }
 
     #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>)
-    {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let n = self.len - self.index;
         (n, Some(n))
     }
 }
 
 impl<F> DoubleEndedIterator for Logspace<F>
-where F: Float
+where
+    F: Float,
 {
     #[inline]
-    fn next_back(&mut self) -> Option<F>
-    {
+    fn next_back(&mut self) -> Option<F> {
         if self.index >= self.len {
             None
         } else {
@@ -83,15 +82,12 @@ impl<F> ExactSizeIterator for Logspace<F> where Logspace<F>: Iterator {}
 #[inline]
 pub fn logspace<R, F>(base: F, range: R, n: usize) -> Logspace<F>
 where
-    R: RangeBounds<F>,
+    R: FiniteBounds<F>,
     F: Float,
 {
     let (a, b, num_steps) = match (range.start_bound(), range.end_bound()) {
-        (Bound::Included(a), Bound::Included(b)) =>
-            (*a, *b, F::from(n - 1).expect("Converting number of steps to `A` must not fail.")),
-        (Bound::Included(a), Bound::Excluded(b)) =>
-            (*a, *b, F::from(n).expect("Converting number of steps to `A` must not fail.")),
-        _ => panic!("Only a..b and a..=b ranges are supported."),
+        (a, Bound::Included(b)) => (a, b, F::from(n - 1).expect("Converting number of steps to `A` must not fail.")),
+        (a, Bound::Excluded(b)) => (a, b, F::from(n).expect("Converting number of steps to `A` must not fail.")),
     };
 
     let step = if num_steps > F::zero() {
@@ -111,14 +107,12 @@ where
 }
 
 #[cfg(test)]
-mod tests
-{
+mod tests {
     use super::logspace;
 
     #[test]
     #[cfg(feature = "approx")]
-    fn valid()
-    {
+    fn valid() {
         use crate::{arr1, Array1};
         use approx::assert_abs_diff_eq;
 
@@ -136,8 +130,7 @@ mod tests
     }
 
     #[test]
-    fn iter_forward()
-    {
+    fn iter_forward() {
         let mut iter = logspace(10.0f64, 0.0..=3.0, 4);
 
         assert!(iter.size_hint() == (4, Some(4)));
@@ -152,8 +145,7 @@ mod tests
     }
 
     #[test]
-    fn iter_backward()
-    {
+    fn iter_backward() {
         let mut iter = logspace(10.0f64, 0.0..=3.0, 4);
 
         assert!(iter.size_hint() == (4, Some(4)));