narr/arr/vec/
fmt.rs

1use crate::arr::{shape_iterator::ShapeIterator, vec::core::ArrVec};
2use std::fmt::{Debug, Display};
3
4fn right_pading(value: &String, nchar: usize) -> String {
5    let mut padding = String::new();
6    while padding.len() < nchar - value.len() {
7        padding.push_str(" ")
8    }
9    let mut out = value.clone();
10    out.push_str(&padding);
11    out
12}
13
14impl<T> Display for ArrVec<T>
15where
16    T: Display + Copy + Ord + Default,
17{
18    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
19        let shape_len = self.shape.len();
20        let max_result = self.buff.iter().max();
21        let min_result = self.buff.iter().min();
22        if max_result.is_none() || min_result.is_none() {
23            return write!(f, "[]");
24        }
25        let min_value = min_result.unwrap();
26        let max_value = max_result.unwrap();
27        let max_str = max_value.to_string();
28        let min_str = min_value.to_string();
29
30        let there_is_negatives = *min_value < T::default();
31
32        let item_len = if there_is_negatives && min_str.len() > max_str.len()  {
33            min_str.len()
34        } else if there_is_negatives {
35            max_str.len() + 1
36        } else {
37            max_str.len()
38        };
39
40        for index in ShapeIterator::new(&self.shape) {
41            for dim in 0..shape_len {
42                if index[dim..shape_len].iter().any(|x| *x != 0_usize) {
43                    continue;
44                }
45                for _ in 0..dim {
46                    let res = write!(f, "  ");
47                    if res.is_err() {
48                        return res;
49                    }
50                }
51                let res = write!(f, "[");
52                if res.is_err() {
53                    return res;
54                }
55                if dim < shape_len - 1 {
56                    let res = write!(f, "\n");
57                    if res.is_err() {
58                        return res;
59                    }
60                };
61            }
62
63            let item = self[&index];
64
65            let res = if there_is_negatives && item >= T::default() {
66                write!(f, " {}", right_pading(&(item.to_string()), item_len - 1))
67            } else {
68                write!(f, "{}", right_pading(&(item.to_string()), item_len))
69            };
70            if res.is_err() {
71                return res;
72            }
73            if index[shape_len - 1] != self.shape[shape_len - 1] - 1 {
74                let res = write!(f, " ");
75                if res.is_err() {
76                    return res;
77                }
78            }
79
80            for dim in (0..shape_len).rev() {
81                let dim_size = self.shape[dim];
82                if index[dim] != dim_size - 1 {
83                    break;
84                }
85
86                if dim != shape_len - 1 {
87                    let res = write!(f, "\n");
88                    if res.is_err() {
89                        return res;
90                    }
91                    for _ in 0..dim {
92                        let res = write!(f, "  ");
93                        if res.is_err() {
94                            return res;
95                        }
96                    }
97                }
98
99                let res = write!(f, "]");
100                if res.is_err() {
101                    return res;
102                }
103                if dim > 0 && (index[dim - 1] != self.shape[dim - 1] - 1) {
104                    let res = write!(f, "\n");
105                    if res.is_err() {
106                        return res;
107                    }
108                }
109            }
110        }
111        Ok(())
112    }
113}
114
115impl<T> Debug for ArrVec<T>
116where
117    T: Debug,
118{
119    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
120        f.debug_struct("ArrVec")
121            .field("buff", &self.buff)
122            .field("shape", &self.shape)
123            .finish()
124    }
125}