Make Display and Debug outputs concise and consistent

src/base/array_storage.rs

@@ -1,4 +1,4 @@
-use std::fmt::{self, Debug, Formatter};
+use std::fmt::Debug;
 // use std::hash::{Hash, Hasher};
 use std::ops::Mul;
 
@@ -9,6 +9,8 @@ use serde::ser::SerializeSeq;
 #[cfg(feature = "serde-serialize-no-std")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "serde-serialize-no-std")]
+use std::fmt::{self, Formatter};
+#[cfg(feature = "serde-serialize-no-std")]
 use std::marker::PhantomData;
 
 use crate::base::allocator::Allocator;
@@ -26,7 +28,7 @@ use std::mem;
  */
 /// A array-based statically sized matrix data storage.
 #[repr(transparent)]
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "rkyv-serialize", derive(bytecheck::CheckBytes))]
 #[cfg_attr(
     feature = "rkyv-serialize-no-std",
@@ -62,13 +64,6 @@ where
     }
 }
 
-impl<T: Debug, const R: usize, const C: usize> Debug for ArrayStorage<T, R, C> {
-    #[inline]
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
-        self.0.fmt(fmt)
-    }
-}
-
 unsafe impl<T, const R: usize, const C: usize> RawStorage<T, Const<R>, Const<C>>
     for ArrayStorage<T, R, C>
 {

src/base/matrix.rs

@@ -195,9 +195,32 @@ pub struct Matrix<T, R, C, S> {
     _phantoms: PhantomData<(T, R, C)>,
 }
 
-impl<T, R: Dim, C: Dim, S: fmt::Debug> fmt::Debug for Matrix<T, R, C, S> {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        self.data.fmt(formatter)
+impl<T: fmt::Debug, R: Dim, C: Dim, S: RawStorage<T, R, C> + fmt::Debug> fmt::Debug
+    for Matrix<T, R, C, S>
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        if f.alternate() {
+            writeln!(f, "")?;
+        }
+        write!(f, "[")?;
+
+        let row_separator = match f.alternate() {
+            true => ";\n ",
+            false => "; ",
+        };
+
+        for (i, row) in self.row_iter().enumerate() {
+            if i > 0 {
+                write!(f, "{row_separator}")?;
+            }
+            for (j, element) in row.iter().enumerate() {
+                if j > 0 {
+                    write!(f, ", ")?;
+                }
+                element.fmt(f)?;
+            }
+        }
+        write!(f, "]")
     }
 }
 
@@ -1855,68 +1878,94 @@ macro_rules! impl_fmt {
             S: RawStorage<T, R, C>,
         {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                #[cfg(feature = "std")]
-                fn val_width<T: Scalar + $trait>(val: &T, f: &mut fmt::Formatter<'_>) -> usize {
-                    match f.precision() {
-                        Some(precision) => format!($fmt_str_with_precision, val, precision)
-                            .chars()
-                            .count(),
-                        None => format!($fmt_str_without_precision, val).chars().count(),
+                if !f.alternate() {
+                    // pretty print in 2D layout
+                    #[cfg(feature = "std")]
+                    fn val_width<T: Scalar + $trait>(val: &T, f: &mut fmt::Formatter<'_>) -> usize {
+                        match f.precision() {
+                            Some(precision) => format!($fmt_str_with_precision, val, precision)
+                                .chars()
+                                .count(),
+                            None => format!($fmt_str_without_precision, val).chars().count(),
+                        }
                     }
-                }
 
-                #[cfg(not(feature = "std"))]
-                fn val_width<T: Scalar + $trait>(_: &T, _: &mut fmt::Formatter<'_>) -> usize {
-                    4
-                }
+                    #[cfg(not(feature = "std"))]
+                    fn val_width<T: Scalar + $trait>(_: &T, _: &mut fmt::Formatter<'_>) -> usize {
+                        4
+                    }
 
-                let (nrows, ncols) = self.shape();
+                    let (nrows, ncols) = self.shape();
 
-                if nrows == 0 || ncols == 0 {
-                    return write!(f, "[ ]");
-                }
+                    if nrows == 0 || ncols == 0 {
+                        return write!(f, "[ ]");
+                    }
+
+                    let mut max_length = 0;
 
-                let mut max_length = 0;
+                    for i in 0..nrows {
+                        for j in 0..ncols {
+                            max_length = crate::max(max_length, val_width(&self[(i, j)], f));
+                        }
+                    }
 
-                for i in 0..nrows {
-                    for j in 0..ncols {
-                        max_length = crate::max(max_length, val_width(&self[(i, j)], f));
+                    let max_length_with_space = max_length + 1;
+
+                    writeln!(f)?; // leading newline to ensure no offset from previous prints
+                    writeln!(
+                        f,
+                        "  ┌ {:>width$} ┐",
+                        "",
+                        width = max_length_with_space * ncols - 1
+                    )?;
+
+                    for i in 0..nrows {
+                        write!(f, "  │")?;
+                        for j in 0..ncols {
+                            let number_length = val_width(&self[(i, j)], f) + 1;
+                            let pad = max_length_with_space - number_length;
+                            write!(f, " {:>thepad$}", "", thepad = pad)?;
+                            match f.precision() {
+                                Some(precision) => {
+                                    write!(f, $fmt_str_with_precision, (*self)[(i, j)], precision)?
+                                }
+                                None => write!(f, $fmt_str_without_precision, (*self)[(i, j)])?,
+                            }
+                        }
+                        writeln!(f, " │")?;
                     }
-                }
 
-                let max_length_with_space = max_length + 1;
-
-                writeln!(f)?;
-                writeln!(
-                    f,
-                    "  ┌ {:>width$} ┐",
-                    "",
-                    width = max_length_with_space * ncols - 1
-                )?;
-
-                for i in 0..nrows {
-                    write!(f, "  │")?;
-                    for j in 0..ncols {
-                        let number_length = val_width(&self[(i, j)], f) + 1;
-                        let pad = max_length_with_space - number_length;
-                        write!(f, " {:>thepad$}", "", thepad = pad)?;
-                        match f.precision() {
-                            Some(precision) => {
-                                write!(f, $fmt_str_with_precision, (*self)[(i, j)], precision)?
+                    write!(
+                        f,
+                        "  └ {:>width$} ┘",
+                        "",
+                        width = max_length_with_space * ncols - 1
+                    )
+                } else {
+                    // print on single line with semicolon-delimited rows and comma-delimited columns
+                    let (nrows, ncols) = self.shape();
+                    write!(f, "[")?;
+                    for row in 0..nrows {
+                        for col in 0..ncols {
+                            if col != 0 {
+                                write!(f, ", ")?;
                             }
-                            None => write!(f, $fmt_str_without_precision, (*self)[(i, j)])?,
+                            match f.precision() {
+                                Some(precision) => write!(
+                                    f,
+                                    $fmt_str_with_precision,
+                                    (*self)[(row, col)],
+                                    precision
+                                )?,
+                                None => write!(f, $fmt_str_without_precision, (*self)[(row, col)])?,
+                            }
+                        }
+                        if row != nrows - 1 {
+                            write!(f, "; ")?;
                         }
                     }
-                    writeln!(f, " │")?;
+                    write!(f, "]")
                 }
-
-                writeln!(
-                    f,
-                    "  └ {:>width$} ┘",
-                    "",
-                    width = max_length_with_space * ncols - 1
-                )?;
-                writeln!(f)
             }
         }
     };
@@ -1930,6 +1979,28 @@ impl_fmt!(fmt::UpperHex, "{:X}", "{:1$X}");
 impl_fmt!(fmt::Binary, "{:b}", "{:.1$b}");
 impl_fmt!(fmt::Pointer, "{:p}", "{:.1$p}");
 
+/// Displays a vector using commas as the delimiter
+pub fn format_column_vec_as_row<T: Scalar + fmt::Display, D: crate::DimName>(
+    vector: &OVector<T, D>,
+    f: &mut fmt::Formatter<'_>,
+) -> fmt::Result
+where
+    DefaultAllocator: Allocator<T, D>,
+{
+    if vector.is_empty() {
+        return write!(f, "[ ]");
+    }
+
+    write!(f, "[")?;
+    let mut it = vector.iter();
+    std::fmt::Display::fmt(it.next().unwrap(), f)?;
+    for comp in it {
+        write!(f, ", ")?;
+        std::fmt::Display::fmt(comp, f)?;
+    }
+    write!(f, "]")
+}
+
 #[cfg(test)]
 mod tests {
     #[test]
@@ -1948,9 +2019,7 @@ mod tests {
   ┌           ┐
   │  1e6  2e5 │
   │ 2e-5  1e0 │
-  └           ┘
-
-"
+  └           ┘"
         )
     }
 }

src/geometry/dual_quaternion.rs

@@ -951,25 +951,12 @@ impl<T: RealField> Default for UnitDualQuaternion<T> {
 
 impl<T: RealField + fmt::Display> fmt::Display for UnitDualQuaternion<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(axis) = self.rotation().axis() {
-            let axis = axis.into_inner();
-            write!(
-                f,
-                "UnitDualQuaternion translation: {} − angle: {} − axis: ({}, {}, {})",
-                self.translation().vector,
-                self.rotation().angle(),
-                axis[0],
-                axis[1],
-                axis[2]
-            )
-        } else {
-            write!(
-                f,
-                "UnitDualQuaternion translation: {} − angle: {} − axis: (undefined)",
-                self.translation().vector,
-                self.rotation().angle()
-            )
-        }
+        write!(f, "{{ translation: ")?;
+        crate::format_column_vec_as_row(&self.translation().vector, f)?;
+        write!(f, ", ")?;
+        write!(f, "rotation: ")?;
+        std::fmt::Display::fmt(&self.rotation(), f)?;
+        write!(f, " }}")
     }
 }
 

src/geometry/isometry.rs

@@ -548,11 +548,11 @@ where
     R: fmt::Display,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let precision = f.precision().unwrap_or(3);
-
-        writeln!(f, "Isometry {{")?;
-        write!(f, "{:.*}", precision, self.translation)?;
-        write!(f, "{:.*}", precision, self.rotation)?;
-        writeln!(f, "}}")
+        write!(f, "{{ translation: ")?;
+        crate::format_column_vec_as_row(&self.translation.vector, f)?;
+        write!(f, ", ")?;
+        write!(f, "rotation: ")?;
+        std::fmt::Display::fmt(&self.rotation, f)?;
+        write!(f, " }}")
     }
 }

src/geometry/point.rs

@@ -457,17 +457,19 @@ impl<T: Scalar + fmt::Display, D: DimName> fmt::Display for OPoint<T, D>
 where
     DefaultAllocator: Allocator<T, D>,
 {
+    /// ```rust
+    /// # use nalgebra::Point3;
+    /// let point = Point3::new(1.12345678, 2.12345678, 3.12345678);
+    /// let rounded = format!("{:#.4}", point); // print point in compact representation
+    /// assert_eq!(rounded, "[1.1235, 2.1235, 3.1235]");
+    /// let vertical = format!("{}", point); // print point as a column
+    /// assert_eq!(vertical, "\n  ┌            ┐\n  │ 1.12345678 │\n  │ 2.12345678 │\n  │ 3.12345678 │\n  └            ┘");
+    /// ```
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{{")?;
-
-        let mut it = self.coords.iter();
-
-        write!(f, "{}", *it.next().unwrap())?;
-
-        for comp in it {
-            write!(f, ", {}", *comp)?;
+        if f.alternate() {
+            crate::format_column_vec_as_row(&self.coords, f)
+        } else {
+            std::fmt::Display::fmt(&self.coords, f) // pretty-prints vector
         }
-
-        write!(f, "}}")
     }
 }