1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
use tensor::Tensor;
use std::fmt;
macro_rules! add_impl {
($t:ty, $name:tt) => (
impl fmt::Display for Tensor<$t> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut ret = "\n".to_string();
if self.is_scalar() {
} if self.ndim() <= 2 && self.size() <= 1000 {
let mut ss: Vec<String> = Vec::with_capacity(self.size());
let mut longest: usize = 0;
for v in self.iter() {
let s = format!("{}", v);
ss.push(s.to_string());
if s.len() > longest {
longest = s.len();
}
}
if self.ndim() == 1 {
for i in 0..self.shape[0] {
let s = &ss[i];
for _ in 0..(1 + longest - s.len()) {
ret.push_str(" ");
}
ret = format!("{}{}", ret, s);
}
} else if self.ndim() == 2 {
let s0 = self.shape[1] as isize;
for i in 0..self.shape[0] {
if i > 0 {
}
for j in 0..self.shape[1] {
let s = &ss[(i as isize * s0 + j as isize) as usize];
for _ in 0..(1 + longest - s.len()) {
ret.push_str(" ");
}
ret = format!("{}{}", ret, s);
}
if i == self.shape[0] - 1 {
} else {
ret.push_str("\n");
}
}
}
} else {
ret.push_str("...");
}
if self.is_scalar() {
write!(f, "{}", self.scalar_value())
} else {
let mut shape_str = "".to_string();
for i in 0..self.shape.len() {
if i == 0 {
shape_str.push_str(&format!("{}", self.shape[i])[..]);
} else {
shape_str.push_str(&format!("x{}", self.shape[i])[..]);
}
}
write!(f, "{}\n[Tensor<{}> of shape {}]", ret, $name, shape_str)
}
}
}
)
}
add_impl!(f32, "f32");
add_impl!(f64, "f64");
add_impl!(usize, "usize");
add_impl!(u8, "u8");
add_impl!(u16, "u16");
add_impl!(u32, "u32");
add_impl!(u64, "u64");
add_impl!(isize, "isize");
add_impl!(i8, "i8");
add_impl!(i16, "i16");
add_impl!(i32, "i32");
add_impl!(i64, "i64");
add_impl!(bool, "bool");