All the PR issues are fixed. Tests are needed.

Author: andrei.papou

src/arrayformat.rs

@@ -6,7 +6,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 use std::fmt;
-use std::slice::Iter;
 use super::{
     ArrayBase,
     Data,
@@ -16,63 +15,8 @@ use super::{
 };
 use crate::dimension::IntoDimension;
 
-#[derive(Debug, PartialEq)]
-enum ArrayDisplayMode {
-    // Array is small enough to be printed without omitting any values.
-    Full,
-    // Omit central values of the nth axis.
-    OmitV,
-    // Omit central values of certain axes (but not the last one).
-    // Vector is guaranteed to be non-empty.
-    OmitH(Vec<Ix>),
-    // Both `OmitV` and `OmitH` hold.
-    OmitBoth(Vec<Ix>),
-}
-
 const PRINT_ELEMENTS_LIMIT: Ix = 2;
 
-impl ArrayDisplayMode {
-
-    fn from_shape(shape: &[Ix], limit: Ix) -> ArrayDisplayMode {
-        let last_dim = match shape.len().checked_sub(1) {
-            Some(v) => v,
-            None => {
-                return ArrayDisplayMode::Full;
-            }
-        };
-
-        let last_axis_ovf = shape[last_dim] >= 2 * limit + 1;
-        let mut overflow_axes: Vec<Ix> = Vec::with_capacity(shape.len());
-        for (axis, axis_size) in shape.iter().enumerate().rev() {
-            if axis == last_dim {
-                continue;
-            }
-            if *axis_size >= 2 * limit + 1 {
-                overflow_axes.push(axis);
-            }
-        }
-
-        if !overflow_axes.is_empty() && last_axis_ovf {
-            ArrayDisplayMode::OmitBoth(overflow_axes)
-        } else if !overflow_axes.is_empty() {
-            ArrayDisplayMode::OmitH(overflow_axes)
-        } else if last_axis_ovf {
-            ArrayDisplayMode::OmitV
-        } else {
-            ArrayDisplayMode::Full
-        }
-    }
-
-    fn h_axes_iter(&self) -> Option<Iter<Ix>> {
-        match self {
-            ArrayDisplayMode::OmitH(v) | ArrayDisplayMode::OmitBoth(v) => {
-                Some(v.iter())
-            },
-            _ => None
-        }
-    }
-}
-
 fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
                                f: &mut fmt::Formatter,
                                mut format: F,
@@ -81,19 +25,27 @@ fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
           D: Dimension,
           S: Data<Elem=A>,
 {
-    let display_mode = ArrayDisplayMode::from_shape(view.shape(), limit);
+    if view.shape().is_empty() {
+        // Handle weird 0-dimensional array case first
+        return writeln!(f, "[]")
+    }
+
+    let overflow_axes: Vec<Ix> = view.shape().iter()
+        .enumerate()
+        .rev()
+        .filter(|(_, axis_size)| **axis_size > 2 * limit)
+        .map(|(axis, _)| axis)
+        .collect();
 
     let ndim = view.dim().into_dimension().slice().len();
-    let nth_idx_max = if ndim > 0 { Some(view.shape().iter().last().unwrap()) } else { None };
+    let nth_idx_max = view.shape().iter().last().unwrap();
 
     // None will be an empty iter.
     let mut last_index = match view.dim().into_dimension().first_index() {
         None => view.dim().into_dimension().clone(),
         Some(ix) => ix,
     };
-    for _ in 0..ndim {
-        write!(f, "[")?;
-    }
+    write!(f, "{}", "[".repeat(ndim))?;
     let mut first = true;
     // Shows if ellipses for vertical split were printed.
     let mut printed_ellipses_v = false;
@@ -109,18 +61,17 @@ fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
         let take_n = if ndim == 0 { 1 } else { ndim - 1 };
         let mut update_index = false;
 
-        let skip_row_for_axis = match display_mode.h_axes_iter() {
-            Some(iter) => {
-                iter.filter(|axis| {
-                    let sa_idx_max = view.shape().iter().skip(**axis).next().unwrap();
-                    let sa_idx_val = index.slice().iter().skip(**axis).next().unwrap();
-                    sa_idx_val >= &limit && sa_idx_val < &(sa_idx_max - &limit)
-                })
-                    .min()
-                    .map(|v| *v)
-            },
-            None => None
-        };
+        let skip_row_for_axis = overflow_axes.iter()
+            .filter(|axis| {
+                if **axis == ndim - 1 {
+                    return false
+                };
+                let sa_idx_max = view.shape().iter().skip(**axis).next().unwrap();
+                let sa_idx_val = index.slice().iter().skip(**axis).next().unwrap();
+                sa_idx_val >= &limit && sa_idx_val < &(sa_idx_max - &limit)
+            })
+            .min()
+            .map(|v| *v);
         if let Some(_) = skip_row_for_axis {
             no_rows_after_skip_yet = true;
         }
@@ -139,31 +90,19 @@ fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
                     // # of ['s needed
                     let n = ndim - i - 1;
                     if !no_rows_after_skip_yet {
-                        for _ in 0..n {
-                            write!(f, "]")?;
-                        }
-                        write!(f, ",")?;
-                        write!(f, "\n")?;
+                        write!(f, "{}", "]".repeat(n))?;
+                        writeln!(f, ",")?;
                     }
                     no_rows_after_skip_yet = false;
-                    for _ in 0..ndim - n {
-                        write!(f, " ")?;
-                    }
-                    for _ in 0..n {
-                        write!(f, "[")?;
-                    }
+                    write!(f, "{}", " ".repeat(ndim - n))?;
+                    write!(f, "{}", "[".repeat(n))?;
                 } else if !printed_ellipses_h[skip_row_for_axis.unwrap()] {
                     let ax = skip_row_for_axis.unwrap();
                     let n = ndim - i - 1;
-                    for _ in 0..n {
-                        write!(f, "]")?;
-                    }
-                    write!(f, ",")?;
-                    write!(f, "\n")?;
-                    for _ in 0..(ax + 1) {
-                        write!(f, " ")?;
-                    }
-                    write!(f, "...,\n")?;
+                    write!(f, "{}", "]".repeat(n))?;
+                    writeln!(f, ",")?;
+                    write!(f, "{}", " ".repeat(ax + 1))?;
+                    writeln!(f, "...,")?;
                     printed_ellipses_h[ax] = true;
                 }
                 first = true;
@@ -175,18 +114,15 @@ fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
         if skip_row_for_axis.is_none() {
             let mut print_elt = true;
             let nth_idx_op = index.slice().iter().last();
-            match display_mode {
-                ArrayDisplayMode::OmitV | ArrayDisplayMode::OmitBoth(_) => {
-                    let nth_idx_val = nth_idx_op.unwrap();
-                    if nth_idx_val >= &limit && nth_idx_val < &(nth_idx_max.unwrap() - &limit) {
-                        print_elt = false;
-                        if !printed_ellipses_v {
-                            write!(f, ", ...")?;
-                            printed_ellipses_v = true;
-                        }
+            if overflow_axes.contains(&(ndim - 1)) {
+                let nth_idx_val = nth_idx_op.unwrap();
+                if nth_idx_val >= &limit && nth_idx_val < &(nth_idx_max - &limit) {
+                    print_elt = false;
+                    if !printed_ellipses_v {
+                        write!(f, ", ...")?;
+                        printed_ellipses_v = true;
                     }
                 }
-                _ => {}
             }
 
             if print_elt {
@@ -202,9 +138,7 @@ fn format_array_v2<A, S, D, F>(view: &ArrayBase<S, D>,
             last_index = index;
         }
     }
-    for _ in 0..ndim {
-        write!(f, "]")?;
-    }
+    write!(f, "{}", "]".repeat(ndim))?;
     Ok(())
 }
 
@@ -356,20 +290,3 @@ impl<'a, A: fmt::Binary, S, D: Dimension> fmt::Binary for ArrayBase<S, D>
         format_array(self, f, <_>::fmt)
     }
 }
-
-#[cfg(test)]
-mod format_tests {
-    use super::*;
-
-    #[test]
-    fn test_array_display_mode_from_shape() {
-        let mode = ArrayDisplayMode::from_shape(&[4, 4], 2);
-        assert_eq!(mode, ArrayDisplayMode::Full);
-
-        let mode = ArrayDisplayMode::from_shape(&[3, 6], 2);
-        assert_eq!(mode, ArrayDisplayMode::OmitV);
-
-        let mode = ArrayDisplayMode::from_shape(&[5, 6, 3], 2);
-        assert_eq!(mode, ArrayDisplayMode::OmitH(vec![1, 0]));
-    }
-}