First and last elements have to be special cased. Done for multidimensional

LukeMathWalker · LukeMathWalker · commit c1036fb273e0 · 2019-04-20T17:30:04.000+01:00
diff --git a/src/arrayformat.rs b/src/arrayformat.rs
@@ -14,47 +14,10 @@ use super::{
     NdProducer,
     Ix
 };
-use crate::dimension::IntoDimension;
 use crate::aliases::Ix1;
 
 const PRINT_ELEMENTS_LIMIT: Ix = 3;
 
-fn get_overflow_axes(shape: &[Ix], limit: usize) -> Vec<usize> {
-    shape.iter()
-        .enumerate()
-        .rev()
-        .filter(|(_, axis_size)| **axis_size > 2 * limit)
-        .map(|(axis, _)| axis)
-        .collect()
-}
-
-fn get_highest_axis_to_skip(overflow_axes: &Vec<usize>,
-                            shape: &[Ix],
-                            index: &[Ix],
-                            limit: &usize) -> Option<usize> {
-    overflow_axes.iter()
-        .filter(|&axis| {
-            if *axis == shape.len() - 1 {
-                return false
-            };
-            let sa_idx_max = shape[*axis];
-            let sa_idx_val = index[*axis];
-            sa_idx_val >= *limit && sa_idx_val < sa_idx_max - *limit
-        })
-        .min()
-        .map(|v| *v)
-}
-
-fn get_highest_changed_axis(index: &[Ix], prev_index: &[Ix]) -> Option<usize> {
-    index.iter()
-        .take(index.len() - 1)
-        .zip(prev_index.iter())
-        .enumerate()
-        .filter(|(_, (a, b))| a != b)
-        .map(|(i, _)| i)
-        .next()
-}
-
 fn format_1d_array<A, S, F>(
     view: &ArrayBase<S, Ix1>,
     f: &mut fmt::Formatter,
@@ -64,10 +27,27 @@ fn format_1d_array<A, S, F>(
         F: FnMut(&A, &mut fmt::Formatter) -> fmt::Result,
         S: Data<Elem=A>,
 {
-    unimplemented!()
+    let n = view.len();
+    let indexes_to_be_printed: Vec<Option<usize>> = if n <= 2 * limit {
+        (0..n).map(|x| Some(x)).collect()
+    } else {
+        let mut v: Vec<Option<usize>> = (0..limit).map(|x| Some(x)).collect();
+        v.push(None);
+        v.extend((n-limit..n).map(|x| Some(x)));
+        v
+    };
+    write!(f, "[")?;
+    for index in indexes_to_be_printed {
+        match index {
+            Some(i) => format(&view[i], f)?,
+            None => write!(f, ", ..., ")?,
+        }
+    }
+    write!(f, "]")?;
+    Ok(())
 }
 
-fn format_array_v2<A, S, D, F>(
+fn format_array<A, S, D, F>(
     view: &ArrayBase<S, D>,
     f: &mut fmt::Formatter,
     mut format: F,
@@ -91,113 +71,24 @@ where
                 v.extend((first_axis_length-limit..first_axis_length).map(|x| Some(x)));
                 v
             };
-            write!(f, "[")?;
+            writeln!(f, "[")?;
             for index in indexes_to_be_printed {
                 match index {
-                    Some(i) => format_array_v2(
-                        &view.index_axis(Axis(0), i), f, format.clone(), limit
-                    )?,
+                    Some(i) => {
+                        write!(f, " ")?;
+                        format_array(
+                            &view.index_axis(Axis(0), i), f, format.clone(), limit
+                        )?;
+                        writeln!(f, ",")?
+                    },
                     None => {
-                        writeln!(f, "...,")?
+                        writeln!(f, " ...,")?
                     }
                 }
             }
-            write!(f, "]")?;
-        }
-    }
-    Ok(())
-}
-
-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>,
-{
-    if view.shape().is_empty() {
-        // Handle 0-dimensional array case first
-        return format(view.iter().next().unwrap(), f)
-    }
-
-    let overflow_axes: Vec<Ix> = get_overflow_axes(view.shape(), limit);
-
-    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() {
-        None => view.dim().into_dimension().clone(),
-        Some(ix) => ix,
-    };
-    write!(f, "{}", "[".repeat(ndim))?;
-    // Shows if ellipses for horizontal split were printed.
-    let mut printed_ellipses_h = vec![false; ndim];
-    // Shows if the row was printed for the first time after horizontal split.
-    let mut no_rows_after_skip_yet = false;
-
-    // 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 skip_row_for_axis = get_highest_axis_to_skip(
-            &overflow_axes,
-            view.shape(),
-            index.slice(),
-            &limit
-        );
-        if skip_row_for_axis.is_some() {
-            no_rows_after_skip_yet = true;
-        }
-
-        let max_changed_idx = get_highest_changed_axis(index.slice(), last_index.slice());
-        if let Some(i) = max_changed_idx {
-            printed_ellipses_h.iter_mut().skip(i + 1).for_each(|e| { *e = false; });
-
-            if skip_row_for_axis.is_none() {
-                // New row.
-                // # of ['s needed
-                let n = ndim - i - 1;
-                if !no_rows_after_skip_yet {
-                    write!(f, "{}", "]".repeat(n))?;
-                    writeln!(f, ",")?;
-                }
-                no_rows_after_skip_yet = false;
-                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;
-                write!(f, "{}", "]".repeat(n))?;
-                writeln!(f, ",")?;
-                write!(f, "{}", " ".repeat(ax + 1))?;
-                writeln!(f, "...,")?;
-                printed_ellipses_h[ax] = true;
-            }
-            last_index = index.clone();
-        }
-
-        if skip_row_for_axis.is_none() {
-            let nth_idx_op = index.slice().iter().last();
-            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) {
-                    if nth_idx_val == &limit {
-                        write!(f, ", ...")?;
-                    }
-                    continue;
-                }
-            }
-
-            if max_changed_idx.is_none() && !index.slice().iter().all(|x| *x == 0) {
-                write!(f, ", ")?;
-            }
-            format(elt, f)?;
+            writeln!(f, "]")?;
         }
     }
-    write!(f, "{}", "]".repeat(ndim))?;
     Ok(())
 }
 
