Merge pull request #2 from LukeMathWalker/smart-debug-formatting-review

Smart debug formatting review

Author: Andrew

src/arrayformat.rs

@@ -17,10 +17,10 @@ use crate::dimension::IntoDimension;
 
 const PRINT_ELEMENTS_LIMIT: Ix = 3;
 
-fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
-                               f: &mut fmt::Formatter,
-                               mut format: F,
-                               limit: Ix) -> fmt::Result
+fn format_array<A, S, D, F>(view: &ArrayBase<S, D>,
+                            f: &mut fmt::Formatter,
+                            mut format: F,
+                            limit: Ix) -> fmt::Result
     where F: FnMut(&A, &mut fmt::Formatter) -> fmt::Result,
           D: Dimension,
           S: Data<Elem=A>,
@@ -37,8 +37,8 @@ fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
         .map(|(axis, _)| axis)
         .collect();
 
-    let ndim = view.dim().into_dimension().slice().len();
-    let nth_idx_max = view.shape().iter().last().unwrap();
+    let ndim = view.ndim();
+    let nth_idx_max = view.shape()[ndim-1];
 
     // None will be an empty iter.
     let mut last_index = match view.dim().into_dimension().first_index() {
@@ -58,7 +58,6 @@ fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
     // as cues for when to add []'s and how many to add.
     for (index, elt) in view.indexed_iter() {
         let index = index.into_dimension();
-        let take_n = if ndim == 0 { 1 } else { ndim - 1 };
         let mut update_index = false;
 
         let skip_row_for_axis = overflow_axes.iter()
@@ -78,7 +77,7 @@ fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
 
         for (i, (a, b)) in index.slice()
             .iter()
-            .take(take_n)
+            .take(ndim-1)
             .zip(last_index.slice().iter())
             .enumerate() {
             if a != b {
@@ -142,76 +141,6 @@ fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
     Ok(())
 }
 
-#[allow(dead_code)]
-fn format_array<A, S, D, F>(view: &ArrayBase<S, D>, f: &mut fmt::Formatter,
-                            mut format: F)
-    -> fmt::Result
-    where F: FnMut(&A, &mut fmt::Formatter) -> fmt::Result,
-          D: Dimension,
-          S: Data<Elem=A>,
-{
-    let ndim = view.dim.slice().len();
-    /* private nowadays
-    if ndim > 0 && f.width.is_none() {
-        f.width = Some(4)
-    }
-    */
-    // None will be an empty iter.
-    let mut last_index = match view.dim.first_index() {
-        None => view.dim.clone(),
-        Some(ix) => ix,
-    };
-    for _ in 0..ndim {
-        write!(f, "[")?;
-    }
-    let mut first = true;
-    // Simply use the indexed iterator, and take the index wraparounds
-    // as cues for when to add []'s and how many to add.
-    for (index, elt) in view.indexed_iter() {
-        let index = index.into_dimension();
-        let take_n = if ndim == 0 { 1 } else { ndim - 1 };
-        let mut update_index = false;
-        for (i, (a, b)) in index.slice()
-                                .iter()
-                                .take(take_n)
-                                .zip(last_index.slice().iter())
-                                .enumerate() {
-            if a != b {
-                // New row.
-                // # of ['s needed
-                let n = ndim - i - 1;
-                for _ in 0..n {
-                    write!(f, "]")?;
-                }
-                write!(f, ",")?;
-                write!(f, "\n")?;
-                for _ in 0..ndim - n {
-                    write!(f, " ")?;
-                }
-                for _ in 0..n {
-                    write!(f, "[")?;
-                }
-                first = true;
-                update_index = true;
-                break;
-            }
-        }
-        if !first {
-            write!(f, ", ")?;
-        }
-        first = false;
-        format(elt, f)?;
-
-        if update_index {
-            last_index = index;
-        }
-    }
-    for _ in 0..ndim {
-        write!(f, "]")?;
-    }
-    Ok(())
-}
-
 // NOTE: We can impl other fmt traits here
 /// Format the array using `Display` and apply the formatting parameters used
 /// to each element.
@@ -221,7 +150,7 @@ impl<'a, A: fmt::Display, S, D: Dimension> fmt::Display for ArrayBase<S, D>
     where S: Data<Elem=A>,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        format_array_v2(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
+        format_array(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
     }
 }
 
@@ -234,7 +163,7 @@ impl<'a, A: fmt::Debug, S, D: Dimension> fmt::Debug for ArrayBase<S, D>
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // Add extra information for Debug
-        format_array_v2(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)?;
+        format_array(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)?;
         write!(f, " shape={:?}, strides={:?}, layout={:?}",
                self.shape(), self.strides(), layout=self.view().layout())?;
         match D::NDIM {
@@ -253,7 +182,7 @@ impl<'a, A: fmt::LowerExp, S, D: Dimension> fmt::LowerExp for ArrayBase<S, D>
     where S: Data<Elem=A>,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        format_array_v2(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
+        format_array(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
     }
 }
 
@@ -265,7 +194,7 @@ impl<'a, A: fmt::UpperExp, S, D: Dimension> fmt::UpperExp for ArrayBase<S, D>
     where S: Data<Elem=A>,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        format_array_v2(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
+        format_array(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
     }
 }
 /// Format the array using `LowerHex` and apply the formatting parameters used
@@ -276,7 +205,7 @@ impl<'a, A: fmt::LowerHex, S, D: Dimension> fmt::LowerHex for ArrayBase<S, D>
     where S: Data<Elem=A>,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        format_array_v2(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
+        format_array(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
     }
 }
 
@@ -288,7 +217,7 @@ impl<'a, A: fmt::Binary, S, D: Dimension> fmt::Binary for ArrayBase<S, D>
     where S: Data<Elem=A>,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        format_array_v2(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
+        format_array(self, f, <_>::fmt, PRINT_ELEMENTS_LIMIT)
     }
 }
 
@@ -301,6 +230,31 @@ mod formatting_with_omit {
         println!("Expected output:\n{}\nActual output:\n{}", expected, actual);
     }
 
+    #[test]
+    fn empty_arrays() {
+        let a: Array2<u32> = arr2(&[[], []]);
+        let actual_output = format!("{}", a);
+        let expected_output = String::from("[[]]");
+        assert_eq!(actual_output, expected_output);
+    }
+
+    #[test]
+    fn zero_length_axes() {
+        let a = Array3::<f32>::zeros((3, 0, 4));
+        let actual_output = format!("{}", a);
+        let expected_output = String::from("[[[]]]");
+        assert_eq!(actual_output, expected_output);
+    }
+
+    #[test]
+    fn dim_0() {
+        let element = 12;
+        let a = arr0(element);
+        let actual_output = format!("{}", a);
+        let expected_output = format!("{}", element);
+        assert_eq!(actual_output, expected_output);
+    }
+
     #[test]
     fn dim_1() {
         let overflow: usize = 5;