1use crate::address_bound::AddressBound;
2use crate::matrix_address::MatrixAddress;
3use crate::tensor::Tensor;
4use std::fmt::{Display, Formatter};
5use std::io::ErrorKind;
6use std::io::ErrorKind::InvalidInput;
7
8#[derive(Clone, Debug, PartialEq)]
10pub struct Matrix<T> {
11 data: Vec<T>,
12 bounds: AddressBound<MatrixAddress>,
13}
14
15impl<T> Tensor<T, MatrixAddress> for Matrix<T> {
16 fn new<F>(bounds: AddressBound<MatrixAddress>, address_value_converter: F) -> Matrix<T>
17 where
18 F: Fn(MatrixAddress) -> T,
19 {
20 let data: Vec<T> = bounds.iter().map(address_value_converter).collect();
21 Matrix { data, bounds }
22 }
23
24 fn get(&self, address: &MatrixAddress) -> Option<&T> {
25 if !self.bounds.contains_address(address) {
26 return None;
27 }
28 self.data.get(self.bounds.index_address(address).unwrap())
29 }
30
31 fn get_mut(&mut self, address: &MatrixAddress) -> Option<&mut T> {
32 if !self.bounds.contains_address(address) {
33 return None;
34 }
35 self.data
36 .get_mut(self.bounds.index_address(address).unwrap())
37 }
38
39 fn set(&mut self, address: &MatrixAddress, value: T) -> Result<(), std::io::Error> {
40 if !self.bounds.contains_address(address) {
41 return Err(std::io::Error::new(
42 InvalidInput,
43 format!("The following address is out of bounds: {address}"),
44 ));
45 }
46 self.data[self.bounds.index_address(address).unwrap()] = value;
47 Ok(())
48 }
49
50 fn bounds(&self) -> &AddressBound<MatrixAddress> {
51 &self.bounds
52 }
53}
54
55impl<T> Matrix<T> {
56 pub fn to_display_string<T1: Display, F: Fn(&T) -> T1>(
57 &self,
58 display_func: F,
59 row_delimiter: &str,
60 column_delimiter: &str,
61 ) -> String {
62 self.address_iterator()
63 .enumerate()
64 .map(|(i, address)| {
65 format!(
66 "{}{}",
67 display_func(self.get(&address).unwrap()),
68 if (i as i64 + 1) % (self.bounds.largest_possible_position.x + 1) == 0 {
69 column_delimiter
70 } else {
71 row_delimiter
72 }
73 )
74 })
75 .fold("".to_string(), |a: String, b: String| a + &b)
76 }
77
78 pub fn parse_matrix<F>(
79 data_str: &str,
80 column_delimiter: &str,
81 row_delimiter: &str,
82 str_to_t_converter: F,
83 ) -> Result<Matrix<T>, std::io::Error>
84 where
85 F: Fn(&str) -> T,
86 {
87 let values: Vec<Vec<&str>> = data_str
88 .split(row_delimiter)
89 .map(|row| row.split(column_delimiter).filter(|string| *string != "").collect())
90 .filter(|row: &Vec<&str>| row.len() != 0)
91 .collect();
92 if values
93 .iter()
94 .skip(1)
95 .any(|row| row.len() != values.get(0).unwrap().len())
96 {
97 return Err(std::io::Error::new(
98 ErrorKind::InvalidData,
99 "Row Lengths are not constant",
100 ));
101 }
102 let height = values.len();
103 let width = values.get(0).unwrap().len();
104 let matrix_bounds = AddressBound {
105 smallest_possible_position: MatrixAddress { x: 0, y: 0 },
106 largest_possible_position: MatrixAddress {
107 x: (width - 1) as i64,
108 y: (height - 1) as i64,
109 },
110 };
111
112 Ok(Matrix::new(matrix_bounds, |address| {
113 str_to_t_converter(
114 values
115 .get(address.y as usize)
116 .unwrap()
117 .get(address.x as usize)
118 .unwrap(),
119 )
120 }))
121 }
122}
123
124impl<'a, T: Display + 'a> Display for Matrix<T> {
125 fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
126 write!(
127 f,
128 "{}",
129 self.to_display_string(|x: &T| x.to_string(), " ", "\n")
130 )
131 }
132}
133
134#[cfg(test)]
135mod tests {
136 use crate::address_bound::AddressBound;
137 use crate::matrix::Matrix;
138 use crate::matrix_address::MatrixAddress;
139 use crate::tensor::Tensor;
140 use proptest::num::usize;
141 use std::str::FromStr;
142
143 #[test]
144 fn display_test() {
145 let bound = AddressBound::new(MatrixAddress { x: 0, y: 0 }, MatrixAddress { x: 10, y: 10 });
146 assert_eq!(
147 "0 1 2 3 4 5 6 0 1 2 3\n4 5 6 0 1 2 3 4 5 6 0\n1 2 3 4 5 6 0 1 2 3 4\n5 6 0 1 2 3 4 5 6 0 1\n2 3 4 5 6 0 1 2 3 4 5\n6 0 1 2 3 4 5 6 0 1 2\n3 4 5 6 0 1 2 3 4 5 6\n0 1 2 3 4 5 6 0 1 2 3\n4 5 6 0 1 2 3 4 5 6 0\n1 2 3 4 5 6 0 1 2 3 4\n5 6 0 1 2 3 4 5 6 0 1\n",
148 format!(
149 "{}",
150 Matrix::new(bound.clone(), |address: MatrixAddress| bound
151 .index_address(&address)
152 .unwrap()
153 % 7)
154 )
155 )
156 }
157
158 #[test]
159 fn parse_test() {
160 let data_str = "0,1,2,3,4,5,6,0,1,2,3|4,5,6,0,1,2,3,4,5,6,0|1,2,3,4,5,6,0,1,2,3,4|5,6,0,1,2,3,4,5,6,0,1|2,3,4,5,6,0,1,2,3,4,5|6,0,1,2,3,4,5,6,0,1,2|3,4,5,6,0,1,2,3,4,5,6|0,1,2,3,4,5,6,0,1,2,3|4,5,6,0,1,2,3,4,5,6,0|1,2,3,4,5,6,0,1,2,3,4|5,6,0,1,2,3,4,5,6,0,1";
161 let bound = AddressBound::new(MatrixAddress { x: 0, y: 0 }, MatrixAddress { x: 10, y: 10 });
162 assert_eq!(
163 Matrix::new(bound.clone(), |address: MatrixAddress| bound
164 .index_address(&address)
165 .unwrap()
166 % 7),
167 Matrix::parse_matrix(data_str, ",", "|", |string| usize::from_str(string)
168 .expect(""))
169 .expect("")
170 );
171 }
172 #[test]
173 fn get_test() {
174 let bound = AddressBound {
175 smallest_possible_position: MatrixAddress { x: 0, y: 0 },
176 largest_possible_position: MatrixAddress { x: 1000, y: 1000 },
177 };
178 let matrix = Matrix::new(bound.clone(), |address| bound.index_address(&address));
179 matrix.address_iterator().for_each(|address| {
180 assert_eq!(
181 bound.index_address(&address),
182 *matrix.get(&address).unwrap()
183 )
184 })
185 }
186
187 #[test]
188 fn set_test() {
189 let bound = AddressBound {
190 smallest_possible_position: MatrixAddress { x: 0, y: 0 },
191 largest_possible_position: MatrixAddress { x: 1000, y: 1000 },
192 };
193 let mut matrix = Matrix::new(bound.clone(), |_address| 0usize);
194 matrix.address_iterator().for_each(|address| {
195 assert_eq!(matrix.get(&address).unwrap(), &0usize);
196 matrix
197 .set(&address, bound.index_address(&address).unwrap())
198 .expect("Index out of bounds error");
199 assert_eq!(
200 matrix.get(&address).unwrap(),
201 &(bound.index_address(&address).unwrap())
202 );
203 });
204 matrix.address_iterator().for_each(|address| {
205 assert_eq!(
206 bound.index_address(&address).unwrap(),
207 *(matrix.get(&address).unwrap())
208 )
209 })
210 }
211 #[test]
212 fn transform_test() {
213 let bound = AddressBound {
214 smallest_possible_position: MatrixAddress { x: 0, y: 0 },
215 largest_possible_position: MatrixAddress { x: 1000, y: 1000 },
216 };
217 let matrix = Matrix::new(bound.clone(), |address| {
218 bound.index_address(&address).unwrap()
219 });
220 let transformed_matrix: Matrix<f64> = matrix.transform(|value| *value as f64);
221 let transformed_by_address_matrix: Matrix<f64> =
222 matrix.transform_by_address(|_address, value| *value as f64);
223 matrix.address_iterator().for_each(|address| {
224 assert_eq!(
225 *matrix.get(&address).unwrap() as f64,
226 *transformed_matrix.get(&address).unwrap(),
227 );
228 assert_eq!(
229 *matrix.get(&address).unwrap() as f64,
230 *transformed_by_address_matrix.get(&address).unwrap()
231 );
232 })
233 }
234
235 #[test]
236 fn transform_in_place_test() {
237 let bound = AddressBound {
238 smallest_possible_position: MatrixAddress { x: 0, y: 0 },
239 largest_possible_position: MatrixAddress { x: 1000, y: 1000 },
240 };
241 let original_matrix = Matrix::new(bound.clone(), |address| {
242 bound.index_address(&address).unwrap() as i64
243 });
244 let mut working_matrix = original_matrix.clone();
245 let mut working_by_address_matrix = original_matrix.clone();
246
247 working_matrix.transform_in_place(|value| *value *= -2);
248 working_by_address_matrix.transform_by_address_in_place(|_address, value| *value *= -2);
249 assert_eq!(
250 original_matrix.transform::<_, i64, Matrix<i64>>(|value| *value * -2),
251 working_matrix
252 );
253 assert_eq!(working_matrix, working_by_address_matrix)
254 }
255
256 #[test]
257 fn equality_test() {
258 let bound = AddressBound {
259 smallest_possible_position: MatrixAddress { x: 0, y: 0 },
260 largest_possible_position: MatrixAddress { x: 1000, y: 1000 },
261 };
262 let m1 = Matrix::new(bound.clone(), |address| {
263 bound.index_address(&address).unwrap() as i32
264 });
265 let m2 = Matrix::new(bound.clone(), |address| {
266 bound.index_address(&address).unwrap() as i32
267 });
268 assert_eq!(m1, m2);
269 }
270}