1#![warn(clippy::all, clippy::pedantic)]
2#![cfg_attr(not(feature = "std"), no_std)]
44
45#[cfg(not(feature = "std"))]
46extern crate alloc;
47#[cfg(not(feature = "std"))]
48use alloc::{format, vec, vec::Vec};
49#[cfg(feature = "serde")]
50use serde::{
51 de::{self, Deserialize, Deserializer, MapAccess, SeqAccess, Visitor},
52 ser::{Serialize, SerializeStruct, Serializer},
53};
54
55use core::cmp::Eq;
56use core::fmt;
57use core::hash;
58use core::iter::StepBy;
59use core::ops::Index;
60use core::ops::IndexMut;
61use core::slice::Iter;
62use core::slice::IterMut;
63use core::{cmp, convert::TryInto};
64
65#[doc(hidden)]
66#[macro_export]
67macro_rules! count {
68 () => (0usize);
69 ( $x:tt $($xs:tt)* ) => (1usize + $crate::count!($($xs)*));
70}
71
72#[macro_export]
98macro_rules! grid {
99 () => {
100 $crate::Grid::from_vec(vec![], 0)
101 };
102 ( [$( $x:expr ),* ]) => { {
103 let vec = vec![$($x),*];
104 let len = vec.len();
105 $crate::Grid::from_vec(vec, len)
106 } };
107 ( [$( $x0:expr ),*] $([$( $x:expr ),*])* ) => {
108 {
109 let mut _assert_width0 = [(); $crate::count!($($x0)*)];
110 let cols = $crate::count!($($x0)*);
111 let rows = 1usize;
112
113 $(
114 let _assert_width = [(); $crate::count!($($x)*)];
115 _assert_width0 = _assert_width;
116 let rows = rows + 1usize;
117 )*
118
119 let mut vec = Vec::with_capacity(rows.checked_mul(cols).unwrap());
120
121 $( vec.push($x0); )*
122 $( $( vec.push($x); )* )*
123
124 $crate::Grid::from_vec(vec, cols)
125 }
126 };
127}
128
129#[macro_export]
155macro_rules! grid_cm {
156 () => {
157 $crate::Grid::from_vec_with_order(vec![], 0, $crate::Order::ColumnMajor)
158 };
159 ( [$( $x:expr ),* ]) => { {
160 let vec = vec![$($x),*];
161 let len = vec.len();
162 $crate::Grid::from_vec_with_order(vec, len, $crate::Order::ColumnMajor)
163 } };
164 ( [$( $x0:expr ),*] $([$( $x:expr ),*])* ) => {
165 {
166 let mut _assert_width0 = [(); $crate::count!($($x0)*)];
167 let cols = $crate::count!($($x0)*);
168 let rows = 1usize;
169
170 $(
171 let _assert_width = [(); $crate::count!($($x)*)];
172 _assert_width0 = _assert_width;
173 let rows = rows + 1usize;
174 )*
175
176 let vec = Vec::with_capacity(rows.checked_mul(cols).unwrap());
177 let mut grid = $crate::Grid::from_vec_with_order(vec, cols, $crate::Order::ColumnMajor);
178
179 grid.push_row(vec![$($x0),*]);
180 $( grid.push_row(vec![$($x),*]); )*
181
182 grid
183 }
184 };
185}
186
187#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
189#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
190pub enum Order {
191 #[default]
193 RowMajor,
194
195 ColumnMajor,
197}
198
199impl Order {
200 fn counterpart(self) -> Self {
201 match self {
202 Self::RowMajor => Self::ColumnMajor,
203 Self::ColumnMajor => Self::RowMajor,
204 }
205 }
206}
207
208pub struct Grid<T> {
216 data: Vec<T>,
217 cols: usize,
218 rows: usize,
219 order: Order,
220}
221
222#[cfg(feature = "serde")]
223impl<'de, T: Deserialize<'de>> Deserialize<'de> for Grid<T> {
224 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
225 where
226 D: Deserializer<'de>,
227 {
228 use std::marker::PhantomData;
229 #[derive(serde::Deserialize)]
230 #[serde(field_identifier, rename_all = "lowercase")]
231 enum Field {
232 Data,
233 Cols,
234 Order,
235 }
236
237 struct GridVisitor<T> {
238 _p: PhantomData<T>,
239 }
240
241 impl<'de, T: Deserialize<'de>> Visitor<'de> for GridVisitor<T> {
242 type Value = Grid<T>;
243
244 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
245 formatter.write_str("struct Grid")
246 }
247
248 fn visit_seq<V>(self, mut seq: V) -> Result<Grid<T>, V::Error>
249 where
250 V: SeqAccess<'de>,
251 {
252 let cols = seq
253 .next_element()?
254 .ok_or_else(|| de::Error::invalid_length(0, &self))?;
255 let data = seq
256 .next_element()?
257 .ok_or_else(|| de::Error::invalid_length(1, &self))?;
258 let order = seq.next_element()?.unwrap_or_default();
259 Ok(Grid::from_vec_with_order(data, cols, order))
260 }
261
262 fn visit_map<V>(self, mut map: V) -> Result<Grid<T>, V::Error>
263 where
264 V: MapAccess<'de>,
265 {
266 let mut cols = None;
267 let mut data = None;
268 let mut order = None;
269 while let Some(key) = map.next_key()? {
270 match key {
271 Field::Data => {
272 if data.is_some() {
273 return Err(de::Error::duplicate_field("data"));
274 }
275 data = Some(map.next_value()?);
276 }
277 Field::Cols => {
278 if cols.is_some() {
279 return Err(de::Error::duplicate_field("cols"));
280 }
281 cols = Some(map.next_value()?);
282 }
283 Field::Order => {
284 if order.is_some() {
285 return Err(de::Error::duplicate_field("order"));
286 }
287 order = Some(map.next_value()?);
288 }
289 }
290 }
291 let cols = cols.ok_or_else(|| de::Error::missing_field("cols"))?;
292 let data = data.ok_or_else(|| de::Error::missing_field("data"))?;
293 let order = order.unwrap_or_default();
294 Ok(Grid::from_vec_with_order(data, cols, order))
295 }
296 }
297
298 const FIELDS: &'static [&'static str] = &["cols", "data", "order"];
299 deserializer.deserialize_struct("Grid", FIELDS, GridVisitor { _p: PhantomData })
300 }
301}
302
303#[cfg(feature = "serde")]
304impl<T: Serialize> Serialize for Grid<T> {
305 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
306 where
307 S: Serializer,
308 {
309 let mut state = serializer.serialize_struct("Grid", 3)?;
311 state.serialize_field("cols", &self.cols)?;
312 state.serialize_field("data", &self.data)?;
313 state.serialize_field("order", &self.order)?;
314 state.end()
315 }
316}
317
318impl<T> Grid<T> {
319 #[must_use]
337 #[inline]
338 pub fn new(rows: usize, cols: usize) -> Self
339 where
340 T: Default,
341 {
342 Self::new_with_order(rows, cols, Order::default())
343 }
344
345 pub fn new_with_order(rows: usize, cols: usize, order: Order) -> Self
351 where
352 T: Default,
353 {
354 if rows == 0 || cols == 0 {
355 return Self {
356 data: Vec::new(),
357 rows: 0,
358 cols: 0,
359 order,
360 };
361 }
362 let mut data = Vec::new();
363 data.resize_with(rows.checked_mul(cols).unwrap(), T::default);
364 Self {
365 data,
366 cols,
367 rows,
368 order,
369 }
370 }
371
372 #[inline]
383 pub fn init(rows: usize, cols: usize, data: T) -> Self
384 where
385 T: Clone,
386 {
387 Self::init_with_order(rows, cols, Order::default(), data)
388 }
389
390 pub fn init_with_order(rows: usize, cols: usize, order: Order, data: T) -> Self
396 where
397 T: Clone,
398 {
399 if rows == 0 || cols == 0 {
400 return Self {
401 data: Vec::new(),
402 rows: 0,
403 cols: 0,
404 order,
405 };
406 }
407 Self {
408 data: vec![data; rows.checked_mul(cols).unwrap()],
409 cols,
410 rows,
411 order,
412 }
413 }
414
415 pub fn with_capacity(rows: usize, cols: usize) -> Self {
422 Self::with_capacity_and_order(rows, cols, Order::default())
423 }
424
425 pub fn with_capacity_and_order(rows: usize, cols: usize, order: Order) -> Self {
431 Self {
432 data: Vec::with_capacity(rows.checked_mul(cols).unwrap()),
433 cols: 0,
434 rows: 0,
435 order,
436 }
437 }
438
439 #[must_use]
468 #[inline]
469 pub fn from_vec(vec: Vec<T>, cols: usize) -> Self {
470 Self::from_vec_with_order(vec, cols, Order::default())
471 }
472
473 #[must_use]
479 pub fn from_vec_with_order(vec: Vec<T>, cols: usize, order: Order) -> Self {
480 let rows = vec.len().checked_div(cols).unwrap_or(0);
481 assert_eq!(
482 rows * cols,
483 vec.len(),
484 "Vector length {:?} should be a multiple of cols = {:?}",
485 vec.len(),
486 cols
487 );
488 if rows == 0 || cols == 0 {
489 Grid {
490 data: vec,
491 rows: 0,
492 cols: 0,
493 order,
494 }
495 } else {
496 Grid {
497 data: vec,
498 rows,
499 cols,
500 order,
501 }
502 }
503 }
504
505 #[inline]
507 #[must_use]
508 fn get_index(&self, row: usize, col: usize) -> usize {
509 match self.order {
510 Order::RowMajor => row * self.cols + col,
511 Order::ColumnMajor => col * self.rows + row,
512 }
513 }
514
515 #[inline]
522 #[must_use]
523 pub unsafe fn get_unchecked(&self, row: impl Into<usize>, col: impl Into<usize>) -> &T {
524 let index = self.get_index(row.into(), col.into());
525 self.data.get_unchecked(index)
526 }
527
528 #[inline]
535 #[must_use]
536 pub unsafe fn get_unchecked_mut(
537 &mut self,
538 row: impl Into<usize>,
539 col: impl Into<usize>,
540 ) -> &mut T {
541 let index = self.get_index(row.into(), col.into());
542 self.data.get_unchecked_mut(index)
543 }
544
545 #[must_use]
548 pub fn get(&self, row: impl TryInto<usize>, col: impl TryInto<usize>) -> Option<&T> {
549 let row_usize = row.try_into().ok()?;
550 let col_usize = col.try_into().ok()?;
551 if row_usize < self.rows && col_usize < self.cols {
552 unsafe { Some(self.get_unchecked(row_usize, col_usize)) }
553 } else {
554 None
555 }
556 }
557
558 #[must_use]
561 pub fn get_mut(
562 &mut self,
563 row: impl TryInto<usize>,
564 col: impl TryInto<usize>,
565 ) -> Option<&mut T> {
566 let row_usize = row.try_into().ok()?;
567 let col_usize = col.try_into().ok()?;
568 if row_usize < self.rows && col_usize < self.cols {
569 unsafe { Some(self.get_unchecked_mut(row_usize, col_usize)) }
570 } else {
571 None
572 }
573 }
574
575 #[must_use]
578 pub fn size(&self) -> (usize, usize) {
579 (self.rows, self.cols)
580 }
581
582 #[must_use]
584 pub fn rows(&self) -> usize {
585 self.rows
586 }
587
588 #[must_use]
590 pub fn cols(&self) -> usize {
591 self.cols
592 }
593
594 #[must_use]
596 pub fn order(&self) -> Order {
597 self.order
598 }
599
600 #[must_use]
608 pub fn is_empty(&self) -> bool {
609 self.data.is_empty()
610 }
611
612 pub fn clear(&mut self) {
616 self.rows = 0;
617 self.cols = 0;
618 self.data.clear();
619 }
620
621 pub fn iter(&self) -> Iter<T> {
638 self.data.iter()
639 }
640
641 pub fn iter_mut(&mut self) -> IterMut<T> {
654 self.data.iter_mut()
655 }
656
657 pub fn iter_col(&self, col: usize) -> StepBy<Iter<T>> {
679 assert!(
680 col < self.cols,
681 "out of bounds. Column must be less than {:?}, but is {:?}",
682 self.cols,
683 col
684 );
685 match self.order {
686 Order::RowMajor => self.data[col..].iter().step_by(self.cols),
687 Order::ColumnMajor => {
688 let start = col * self.rows;
689 self.data[start..(start + self.rows)].iter().step_by(1)
690 }
691 }
692 }
693
694 pub fn iter_col_mut(&mut self, col: usize) -> StepBy<IterMut<T>> {
717 assert!(
718 col < self.cols,
719 "out of bounds. Column must be less than {:?}, but is {:?}",
720 self.cols,
721 col
722 );
723 match self.order {
724 Order::RowMajor => self.data[col..].iter_mut().step_by(self.cols),
725 Order::ColumnMajor => {
726 let start = col * self.rows;
727 self.data[start..(start + self.rows)].iter_mut().step_by(1)
728 }
729 }
730 }
731
732 pub fn iter_row(&self, row: usize) -> StepBy<Iter<T>> {
754 assert!(
755 row < self.rows,
756 "out of bounds. Row must be less than {:?}, but is {:?}",
757 self.rows,
758 row
759 );
760 match self.order {
761 Order::RowMajor => {
762 let start = row * self.cols;
763 self.data[start..(start + self.cols)].iter().step_by(1)
764 }
765 Order::ColumnMajor => self.data[row..].iter().step_by(self.rows),
766 }
767 }
768
769 pub fn iter_row_mut(&mut self, row: usize) -> StepBy<IterMut<T>> {
790 assert!(
791 row < self.rows,
792 "out of bounds. Row must be less than {:?}, but is {:?}",
793 self.rows,
794 row
795 );
796 match self.order {
797 Order::RowMajor => {
798 let start = row * self.cols;
799 self.data[start..(start + self.cols)].iter_mut().step_by(1)
800 }
801 Order::ColumnMajor => self.data[row..].iter_mut().step_by(self.rows),
802 }
803 }
804
805 pub fn indexed_iter(&self) -> impl Iterator<Item = ((usize, usize), &T)> {
829 self.data.iter().enumerate().map(move |(idx, i)| {
830 let position = match self.order {
831 Order::RowMajor => (idx / self.cols, idx % self.cols),
832 Order::ColumnMajor => (idx % self.rows, idx / self.rows),
833 };
834 (position, i)
835 })
836 }
837
838 pub fn indexed_iter_mut(&mut self) -> impl Iterator<Item = ((usize, usize), &mut T)> {
869 let order = self.order;
870 let cols = self.cols;
871 let rows = self.rows;
872
873 self.data.iter_mut().enumerate().map(move |(idx, i)| {
874 let position = match order {
875 Order::RowMajor => (idx / cols, idx % cols),
876 Order::ColumnMajor => (idx % rows, idx / rows),
877 };
878 (position, i)
879 })
880 }
881
882 pub fn push_row(&mut self, row: Vec<T>) {
917 assert_ne!(row.len(), 0);
918 assert!(
919 !(self.rows > 0 && row.len() != self.cols),
920 "pushed row does not match. Length must be {:?}, but was {:?}.",
921 self.cols,
922 row.len()
923 );
924 self.data.extend(row);
925 if self.order == Order::ColumnMajor {
926 for i in (1..self.cols).rev() {
927 let col_idx = i * self.rows;
928 self.data[col_idx..col_idx + self.rows + i].rotate_right(i);
929 }
930 }
931 self.rows += 1;
932 if self.cols == 0 {
933 self.cols = self.data.len();
934 }
935 }
936
937 pub fn push_col(&mut self, col: Vec<T>) {
972 assert_ne!(col.len(), 0);
973 assert!(
974 !(self.cols > 0 && col.len() != self.rows),
975 "pushed column does not match. Length must be {:?}, but was {:?}.",
976 self.rows,
977 col.len()
978 );
979 self.data.extend(col);
980 if self.order == Order::RowMajor {
981 for i in (1..self.rows).rev() {
982 let row_idx = i * self.cols;
983 self.data[row_idx..row_idx + self.cols + i].rotate_right(i);
984 }
985 }
986 self.cols += 1;
987 if self.rows == 0 {
988 self.rows = self.data.len();
989 }
990 }
991
992 pub fn pop_row(&mut self) -> Option<Vec<T>> {
1007 if self.rows == 0 {
1008 return None;
1009 }
1010 if self.order == Order::ColumnMajor {
1011 for i in 1..self.cols {
1012 let col_idx = i * (self.rows - 1);
1013 self.data[col_idx..col_idx + self.rows + i - 1].rotate_left(i);
1014 }
1015 }
1016 let row = self.data.split_off(self.data.len() - self.cols);
1017 self.rows -= 1;
1018 if self.rows == 0 {
1019 self.cols = 0;
1020 }
1021 Some(row)
1022 }
1023
1024 pub fn remove_row(&mut self, row_index: usize) -> Option<Vec<T>> {
1040 if self.cols == 0 || self.rows == 0 || row_index >= self.rows {
1041 return None;
1042 }
1043 let row = match self.order {
1044 Order::RowMajor => self
1045 .data
1046 .drain((row_index * self.cols)..((row_index + 1) * self.cols))
1047 .collect(),
1048 Order::ColumnMajor => {
1049 for i in 0..self.cols {
1050 let col_idx = row_index + i * (self.rows - 1);
1051 let end = cmp::min(col_idx + self.rows + i, self.data.len());
1052 self.data[col_idx..end].rotate_left(i + 1);
1053 }
1054 self.data.split_off(self.data.len() - self.cols)
1055 }
1056 };
1057 self.rows -= 1;
1058 if self.rows == 0 {
1059 self.cols = 0;
1060 }
1061 Some(row)
1062 }
1063
1064 pub fn pop_col(&mut self) -> Option<Vec<T>> {
1084 if self.cols == 0 {
1085 return None;
1086 }
1087 if self.order == Order::RowMajor {
1088 for i in 1..self.rows {
1089 let row_idx = i * (self.cols - 1);
1090 self.data[row_idx..row_idx + self.cols + i - 1].rotate_left(i);
1091 }
1092 }
1093 let col = self.data.split_off(self.data.len() - self.rows);
1094 self.cols -= 1;
1095 if self.cols == 0 {
1096 self.rows = 0;
1097 }
1098 Some(col)
1099 }
1100
1101 pub fn remove_col(&mut self, col_index: usize) -> Option<Vec<T>> {
1119 if self.cols == 0 || self.rows == 0 || col_index >= self.cols {
1120 return None;
1121 }
1122 let col = match self.order {
1123 Order::RowMajor => {
1124 for i in 0..self.rows {
1125 let row_idx = col_index + i * (self.cols - 1);
1126 let end = cmp::min(row_idx + self.cols + i, self.data.len());
1127 self.data[row_idx..end].rotate_left(i + 1);
1128 }
1129 self.data.split_off(self.data.len() - self.rows)
1130 }
1131 Order::ColumnMajor => self
1132 .data
1133 .drain((col_index * self.rows)..((col_index + 1) * self.rows))
1134 .collect(),
1135 };
1136 self.cols -= 1;
1137 if self.cols == 0 {
1138 self.rows = 0;
1139 }
1140 Some(col)
1141 }
1142
1143 pub fn insert_row(&mut self, index: usize, row: Vec<T>) {
1163 let input_len = row.len();
1164 assert!(
1165 !(self.cols > 0 && input_len != self.cols),
1166 "Inserted row must be of length {}, but was {}.",
1167 self.cols,
1168 row.len()
1169 );
1170 assert!(
1171 index <= self.rows,
1172 "Out of range. Index was {}, but must be less or equal to {}.",
1173 index,
1174 self.rows
1175 );
1176 match self.order {
1177 Order::RowMajor => {
1178 let data_idx = index * input_len;
1179 self.data.splice(data_idx..data_idx, row);
1180 }
1181 Order::ColumnMajor => {
1182 for (col_iter, row_val) in row.into_iter().enumerate() {
1183 let data_idx = col_iter * self.rows + index + col_iter;
1184 self.data.insert(data_idx, row_val);
1185 }
1186 }
1187 }
1188 self.cols = input_len;
1189 self.rows += 1;
1190 }
1191
1192 pub fn insert_col(&mut self, index: usize, col: Vec<T>) {
1216 let input_len = col.len();
1217 assert!(
1218 !(self.rows > 0 && input_len != self.rows),
1219 "Inserted col must be of length {}, but was {}.",
1220 self.rows,
1221 col.len()
1222 );
1223 assert!(
1224 index <= self.cols,
1225 "Out of range. Index was {}, but must be less or equal to {}.",
1226 index,
1227 self.cols
1228 );
1229 match self.order {
1230 Order::RowMajor => {
1231 for (row_iter, col_val) in col.into_iter().enumerate() {
1232 let data_idx = row_iter * self.cols + index + row_iter;
1233 self.data.insert(data_idx, col_val);
1234 }
1235 }
1236 Order::ColumnMajor => {
1237 let data_idx = index * input_len;
1238 self.data.splice(data_idx..data_idx, col);
1239 }
1240 }
1241 self.rows = input_len;
1242 self.cols += 1;
1243 }
1244
1245 #[must_use]
1258 pub fn flatten(&self) -> &Vec<T> {
1259 &self.data
1260 }
1261
1262 #[must_use]
1267 pub fn into_vec(self) -> Vec<T> {
1268 self.data
1269 }
1270
1271 pub fn transpose(&mut self) {
1275 self.order = self.order.counterpart();
1276 core::mem::swap(&mut self.rows, &mut self.cols);
1277 }
1278
1279 pub fn flip_cols(&mut self) {
1294 match self.order {
1295 Order::RowMajor => {
1296 for row in 0..self.rows {
1297 let idx = row * self.cols;
1298 self.data[idx..idx + self.cols].reverse();
1299 }
1300 }
1301 Order::ColumnMajor => {
1302 for col in 0..self.cols / 2 {
1303 for row in 0..self.rows {
1304 let cell1 = self.get_index(row, col);
1305 let cell2 = self.get_index(row, self.cols - col - 1);
1306 self.data.swap(cell1, cell2);
1307 }
1308 }
1309 }
1310 }
1311 }
1312
1313 pub fn flip_rows(&mut self) {
1329 match self.order {
1330 Order::RowMajor => {
1331 for row in 0..self.rows / 2 {
1332 for col in 0..self.cols {
1333 let cell1 = self.get_index(row, col);
1334 let cell2 = self.get_index(self.rows - row - 1, col);
1335 self.data.swap(cell1, cell2);
1336 }
1337 }
1338 }
1339 Order::ColumnMajor => {
1340 for col in 0..self.cols {
1341 let idx = col * self.rows;
1342 self.data[idx..idx + self.rows].reverse();
1343 }
1344 }
1345 }
1346 }
1347
1348 pub fn rotate_left(&mut self) {
1366 self.transpose();
1367 self.flip_rows();
1368 }
1369
1370 pub fn rotate_right(&mut self) {
1388 self.transpose();
1389 self.flip_cols();
1390 }
1391
1392 pub fn rotate_half(&mut self) {
1409 self.data.reverse();
1410 }
1411
1412 pub fn fill(&mut self, value: T)
1423 where
1424 T: Clone,
1425 {
1426 self.data.fill(value);
1427 }
1428
1429 pub fn fill_with<F>(&mut self, f: F)
1447 where
1448 F: FnMut() -> T,
1449 {
1450 self.data.fill_with(f);
1451 }
1452
1453 #[must_use]
1468 pub fn iter_rows(&self) -> GridRowIter<'_, T> {
1469 GridRowIter {
1470 grid: self,
1471 row_start_index: 0,
1472 row_end_index: self.rows,
1473 }
1474 }
1475
1476 #[must_use]
1491 pub fn iter_cols(&self) -> GridColIter<'_, T> {
1492 GridColIter {
1493 grid: self,
1494 col_start_index: 0,
1495 col_end_index: self.cols,
1496 }
1497 }
1498
1499 pub fn swap(&mut self, (row_a, col_a): (usize, usize), (row_b, col_b): (usize, usize)) {
1506 assert!(
1507 !(row_a >= self.rows || col_a >= self.cols),
1508 "grid index out of bounds: ({row_a},{col_a}) out of ({},{})",
1509 self.rows,
1510 self.cols
1511 );
1512 assert!(
1513 !(row_b >= self.rows || col_b >= self.cols),
1514 "grid index out of bounds: ({row_b},{col_b}) out of ({},{})",
1515 self.rows,
1516 self.cols
1517 );
1518
1519 let a_idx = self.get_index(row_a, col_a);
1520 let b_idx = self.get_index(row_b, col_b);
1521
1522 self.data.swap(a_idx, b_idx);
1523 }
1524}
1525
1526impl<T> Default for Grid<T> {
1527 fn default() -> Self {
1528 Self {
1529 data: Vec::default(),
1530 cols: 0,
1531 rows: 0,
1532 order: Order::default(),
1533 }
1534 }
1535}
1536
1537impl<T: Clone> Clone for Grid<T> {
1538 fn clone(&self) -> Self {
1539 Grid {
1540 rows: self.rows,
1541 cols: self.cols,
1542 data: self.data.clone(),
1543 order: self.order,
1544 }
1545 }
1546}
1547
1548impl<T: hash::Hash> hash::Hash for Grid<T> {
1549 #[inline]
1550 fn hash<H: hash::Hasher>(&self, state: &mut H) {
1551 self.rows.hash(state);
1552 self.cols.hash(state);
1553 self.order.hash(state);
1554 self.data.hash(state);
1555 }
1556}
1557
1558impl<T> Index<(usize, usize)> for Grid<T> {
1559 type Output = T;
1560
1561 #[inline]
1562 fn index(&self, (row, col): (usize, usize)) -> &T {
1563 assert!(
1564 !(row >= self.rows || col >= self.cols),
1565 "grid index out of bounds: ({row},{col}) out of ({},{})",
1566 self.rows,
1567 self.cols
1568 );
1569 let index = self.get_index(row, col);
1570 &self.data[index]
1571 }
1572}
1573
1574impl<T> IndexMut<(usize, usize)> for Grid<T> {
1575 #[inline]
1576 fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut T {
1577 assert!(
1578 !(row >= self.rows || col >= self.cols),
1579 "grid index out of bounds: ({row},{col}) out of ({},{})",
1580 self.rows,
1581 self.cols
1582 );
1583 let index = self.get_index(row, col);
1584 &mut self.data[index]
1585 }
1586}
1587
1588impl<T: fmt::Debug> fmt::Debug for Grid<T> {
1589 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1590 write!(f, "[")?;
1591 if self.cols > 0 {
1592 if f.alternate() {
1593 writeln!(f)?;
1594 let width = f.width().unwrap_or_else(|| {
1601 self.data
1603 .iter()
1604 .map(|i| format!("{i:?}").len())
1605 .max()
1606 .unwrap()
1607 });
1608 let precision = f.precision().unwrap_or(2);
1609 for mut row in self.iter_rows().map(Iterator::peekable) {
1610 write!(f, " [")?;
1611 while let Some(item) = row.next() {
1612 write!(f, " {item:width$.precision$?}")?;
1613 if row.peek().is_some() {
1614 write!(f, ",")?;
1615 }
1616 }
1617 writeln!(f, "]")?;
1618 }
1619 } else {
1620 for row in self.iter_rows() {
1621 f.debug_list().entries(row).finish()?;
1622 }
1623 }
1624 }
1625 write!(f, "]")
1626 }
1627}
1628
1629impl<T: PartialEq> PartialEq for Grid<T> {
1630 fn eq(&self, other: &Self) -> bool {
1631 if self.rows != other.rows || self.cols != other.cols {
1632 return false;
1633 }
1634 if self.order == other.order {
1635 return self.data == other.data;
1636 }
1637 for (self_row, other_row) in core::iter::zip(self.iter_rows(), other.iter_rows()) {
1638 if self_row.ne(other_row) {
1639 return false;
1640 }
1641 }
1642 true
1643 }
1644}
1645
1646impl<T: Eq> Eq for Grid<T> {}
1647
1648impl<T> From<Vec<Vec<T>>> for Grid<T> {
1649 #[allow(clippy::redundant_closure_for_method_calls)]
1650 fn from(vec: Vec<Vec<T>>) -> Self {
1651 let cols = vec.first().map_or(0, |row| row.len());
1652 Self::from_vec_with_order(vec.into_iter().flatten().collect(), cols, Order::default())
1653 }
1654}
1655
1656impl<T: Clone> From<&Vec<Vec<T>>> for Grid<T> {
1657 #[allow(clippy::redundant_closure_for_method_calls)]
1658 fn from(vec: &Vec<Vec<T>>) -> Self {
1659 let cols = vec.first().map_or(0, |row| row.len());
1660 Self::from_vec_with_order(
1661 vec.clone().into_iter().flatten().collect(),
1662 cols,
1663 Order::default(),
1664 )
1665 }
1666}
1667
1668impl<T: Clone> From<&Vec<&Vec<T>>> for Grid<T> {
1669 #[allow(clippy::redundant_closure_for_method_calls)]
1670 fn from(vec: &Vec<&Vec<T>>) -> Self {
1671 let cols = vec.first().map_or(0, |row| row.len());
1672 Self::from_vec_with_order(
1673 vec.clone()
1674 .into_iter()
1675 .flat_map(|inner| inner.clone())
1676 .collect(),
1677 cols,
1678 Order::default(),
1679 )
1680 }
1681}
1682
1683impl<T> From<(Vec<T>, usize)> for Grid<T> {
1684 fn from(value: (Vec<T>, usize)) -> Self {
1685 Self::from_vec_with_order(value.0, value.1, Order::default())
1686 }
1687}
1688
1689impl<T: Clone> From<(&Vec<T>, usize)> for Grid<T> {
1690 fn from(value: (&Vec<T>, usize)) -> Self {
1691 Self::from_vec_with_order(value.0.clone(), value.1, Order::default())
1692 }
1693}
1694
1695impl<T: Clone> From<(&Vec<T>, &usize)> for Grid<T> {
1696 fn from(value: (&Vec<T>, &usize)) -> Self {
1697 Self::from_vec_with_order(value.0.clone(), *value.1, Order::default())
1698 }
1699}
1700
1701#[derive(Clone)]
1702pub struct GridRowIter<'a, T> {
1703 grid: &'a Grid<T>,
1704 row_start_index: usize,
1705 row_end_index: usize,
1706}
1707
1708#[derive(Clone)]
1709pub struct GridColIter<'a, T> {
1710 grid: &'a Grid<T>,
1711 col_start_index: usize,
1712 col_end_index: usize,
1713}
1714
1715impl<'a, T> Iterator for GridRowIter<'a, T> {
1716 type Item = StepBy<Iter<'a, T>>;
1717
1718 fn next(&mut self) -> Option<Self::Item> {
1719 if self.row_start_index >= self.row_end_index {
1720 return None;
1721 }
1722
1723 let row_iter = self.grid.iter_row(self.row_start_index);
1724 self.row_start_index += 1;
1725 Some(row_iter)
1726 }
1727
1728 fn size_hint(&self) -> (usize, Option<usize>) {
1729 let size = self.row_end_index - self.row_start_index;
1730 (size, Some(size))
1731 }
1732}
1733
1734impl<'a, T> ExactSizeIterator for GridRowIter<'a, T> {}
1735
1736impl<'a, T> DoubleEndedIterator for GridRowIter<'a, T> {
1737 fn next_back(&mut self) -> Option<Self::Item> {
1738 if self.row_start_index >= self.row_end_index {
1739 return None;
1740 }
1741
1742 let row_iter = self.grid.iter_row(self.row_end_index - 1);
1743 self.row_end_index -= 1;
1744 Some(row_iter)
1745 }
1746}
1747
1748impl<'a, T> Iterator for GridColIter<'a, T> {
1749 type Item = StepBy<Iter<'a, T>>;
1750
1751 fn next(&mut self) -> Option<Self::Item> {
1752 if self.col_start_index >= self.col_end_index {
1753 return None;
1754 }
1755
1756 let col_iter = self.grid.iter_col(self.col_start_index);
1757 self.col_start_index += 1;
1758 Some(col_iter)
1759 }
1760
1761 fn size_hint(&self) -> (usize, Option<usize>) {
1762 let size = self.col_end_index - self.col_start_index;
1763 (size, Some(size))
1764 }
1765}
1766
1767impl<'a, T> ExactSizeIterator for GridColIter<'a, T> {}
1768
1769impl<'a, T> DoubleEndedIterator for GridColIter<'a, T> {
1770 fn next_back(&mut self) -> Option<Self::Item> {
1771 if self.col_start_index >= self.col_end_index {
1772 return None;
1773 }
1774
1775 let col_iter = self.grid.iter_col(self.col_end_index - 1);
1776 self.col_end_index -= 1;
1777 Some(col_iter)
1778 }
1779}
1780
1781#[cfg(test)]
1782mod test {
1783 use super::*;
1784 #[cfg(not(feature = "std"))]
1785 use alloc::string::String;
1786
1787 fn test_grid<T>(grid: &Grid<T>, rows: usize, cols: usize, order: Order, data: &[T])
1788 where
1789 T: fmt::Debug + PartialEq,
1790 {
1791 assert_eq!(grid.rows, rows, "number of rows is unexpected");
1792 assert_eq!(grid.cols, cols, "number of cols is unexpected");
1793 assert_eq!(grid.order, order, "grid order is unexpected");
1794 assert_eq!(grid.data, data, "internal data is unexpected");
1795 }
1796
1797 #[test]
1798 fn from_1d_vec() {
1799 let grid: Grid<u8> = Grid::from((vec![1, 2, 3], 1));
1800 test_grid(&grid, 3, 1, Order::RowMajor, &[1, 2, 3]);
1801 }
1802
1803 #[test]
1804 #[should_panic]
1805 #[allow(clippy::should_panic_without_expect)]
1806 fn from_1d_vec_panic() {
1807 let _: Grid<u8> = Grid::from((vec![1, 2, 3], 2));
1808 }
1809
1810 #[test]
1811 fn from_1d_vec_reference() {
1812 let vec = vec![1, 2, 3];
1813 let grid: Grid<u8> = Grid::from((&vec, 1));
1814 test_grid(&grid, 3, 1, Order::RowMajor, &[1, 2, 3]);
1815 }
1816
1817 #[test]
1818 #[should_panic]
1819 #[allow(clippy::should_panic_without_expect)]
1820 fn from_1d_vec_reference_panic() {
1821 let vec = vec![1, 2, 3];
1822 let _: Grid<u8> = Grid::from((&vec, 2));
1823 }
1824
1825 #[test]
1826 fn from_1d_vec_reference_and_reference() {
1827 let vec = vec![1, 2, 3];
1828 let cols = 1;
1829 let grid: Grid<u8> = Grid::from((&vec, &cols));
1830 test_grid(&grid, 3, 1, Order::RowMajor, &[1, 2, 3]);
1831 }
1832
1833 #[test]
1834 #[should_panic]
1835 #[allow(clippy::should_panic_without_expect)]
1836 fn from_1d_vec_reference_and_reference_panic() {
1837 let vec = vec![1, 2, 3];
1838 let cols = 2;
1839 let _: Grid<u8> = Grid::from((&vec, &cols));
1840 }
1841
1842 #[test]
1843 fn from_2d_vec() {
1844 let grid: Grid<u8> = Grid::from(vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]);
1845 test_grid(&grid, 3, 3, Order::RowMajor, &[1, 2, 3, 4, 5, 6, 7, 8, 9]);
1846 }
1847
1848 #[test]
1849 #[should_panic]
1850 #[allow(clippy::should_panic_without_expect)]
1851 fn from_2d_vec_panic() {
1852 let _: Grid<u8> = Grid::from(vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8]]);
1853 }
1854
1855 #[test]
1856 fn from_2d_vec_reference() {
1857 let vec = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
1858 let grid: Grid<u8> = Grid::from(&vec);
1859 test_grid(&grid, 3, 3, Order::RowMajor, &[1, 2, 3, 4, 5, 6, 7, 8, 9]);
1860 }
1861
1862 #[test]
1863 #[should_panic]
1864 #[allow(clippy::should_panic_without_expect)]
1865 fn from_2d_vec_reference_panic() {
1866 let vec = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8]];
1867 let _: Grid<u8> = Grid::from(&vec);
1868 }
1869
1870 #[test]
1871 fn from_2d_vec_reference_of_references() {
1872 let inner_vec1 = vec![1, 2, 3];
1873 let inner_vec2 = vec![4, 5, 6];
1874 let inner_vec3 = vec![7, 8, 9];
1875 let vec = vec![&inner_vec1, &inner_vec2, &inner_vec3];
1876 let grid: Grid<u8> = Grid::from(&vec);
1877 test_grid(&grid, 3, 3, Order::RowMajor, &[1, 2, 3, 4, 5, 6, 7, 8, 9]);
1878 }
1879
1880 #[test]
1881 #[should_panic]
1882 #[allow(clippy::should_panic_without_expect)]
1883 fn from_2d_vec_reference_of_references_panic() {
1884 let inner_vec1 = vec![1, 2, 3];
1885 let inner_vec2 = vec![4, 5, 6];
1886 let inner_vec3 = vec![7, 8];
1887 let vec = vec![&inner_vec1, &inner_vec2, &inner_vec3];
1888 let _: Grid<u8> = Grid::from(&vec);
1889 }
1890
1891 #[test]
1892 fn from_vec_zero_with_cols() {
1893 let grid: Grid<u8> = Grid::from_vec(vec![], 1);
1894 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
1895 }
1896
1897 #[test]
1898 fn from_vec_zero() {
1899 let grid: Grid<u8> = Grid::from_vec(vec![], 0);
1900 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
1901 }
1902
1903 #[test]
1904 #[should_panic]
1905 #[allow(clippy::should_panic_without_expect)]
1906 fn from_vec_panics_1() {
1907 let _: Grid<u8> = Grid::from_vec(vec![1, 2, 3], 0);
1908 }
1909
1910 #[test]
1911 #[should_panic]
1912 #[allow(clippy::should_panic_without_expect)]
1913 fn from_vec_panics_2() {
1914 let _: Grid<u8> = Grid::from_vec(vec![1, 2, 3], 2);
1915 }
1916
1917 #[test]
1918 fn from_vec_uses_original_vec() {
1919 let capacity = 10_000_000;
1920 let vec = Vec::with_capacity(capacity);
1921 let grid: Grid<u8> = Grid::from_vec(vec, 0);
1922 assert!(grid.into_vec().capacity() >= capacity);
1923 }
1924
1925 #[test]
1926 fn from_vec_with_order_zero_with_cols() {
1927 let grid: Grid<u8> = Grid::from_vec_with_order(vec![], 1, Order::ColumnMajor);
1928 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
1929 }
1930
1931 #[test]
1932 fn from_vec_with_order_zero() {
1933 let grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::ColumnMajor);
1934 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
1935 }
1936
1937 #[test]
1938 #[should_panic]
1939 #[allow(clippy::should_panic_without_expect)]
1940 fn from_vec_with_order_panics_1() {
1941 let _: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3], 0, Order::ColumnMajor);
1942 }
1943
1944 #[test]
1945 #[should_panic]
1946 #[allow(clippy::should_panic_without_expect)]
1947 fn from_vec_with_order_panics_2() {
1948 let _: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3], 2, Order::ColumnMajor);
1949 }
1950
1951 #[test]
1952 fn from_vec_with_order_uses_original_vec() {
1953 let capacity = 10_000_000;
1954 let vec = Vec::with_capacity(capacity);
1955 let grid: Grid<u8> = Grid::from_vec_with_order(vec, 0, Order::ColumnMajor);
1956 assert!(grid.into_vec().capacity() >= capacity);
1957 }
1958
1959 #[test]
1960 fn insert_col_at_end() {
1961 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
1962 grid.insert_col(2, vec![5, 6]);
1963 test_grid(&grid, 2, 3, Order::RowMajor, &[1, 2, 5, 3, 4, 6]);
1964 }
1965
1966 #[test]
1967 #[should_panic]
1968 #[allow(clippy::should_panic_without_expect)]
1969 fn insert_col_out_of_idx() {
1970 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
1971 grid.insert_col(3, vec![4, 5]);
1972 }
1973
1974 #[test]
1975 fn insert_col_empty() {
1976 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::RowMajor);
1977 grid.insert_col(0, vec![1, 2, 3]);
1978 test_grid(&grid, 3, 1, Order::RowMajor, &[1, 2, 3]);
1979 }
1980
1981 #[test]
1982 fn insert_col_at_end_column_major() {
1983 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
1984 grid.insert_col(2, vec![5, 6]);
1985 test_grid(&grid, 2, 3, Order::ColumnMajor, &[1, 3, 2, 4, 5, 6]);
1986 }
1987
1988 #[test]
1989 #[should_panic]
1990 #[allow(clippy::should_panic_without_expect)]
1991 fn insert_col_out_of_idx_column_major() {
1992 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
1993 grid.insert_col(3, vec![4, 5]);
1994 }
1995
1996 #[test]
1997 fn insert_col_empty_column_major() {
1998 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::ColumnMajor);
1999 grid.insert_col(0, vec![1, 2, 3]);
2000 test_grid(&grid, 3, 1, Order::ColumnMajor, &[1, 2, 3]);
2001 }
2002
2003 #[test]
2004 fn insert_row_at_end() {
2005 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
2006 grid.insert_row(2, vec![5, 6]);
2007 test_grid(&grid, 3, 2, Order::RowMajor, &[1, 2, 3, 4, 5, 6]);
2008 }
2009
2010 #[test]
2011 fn insert_row_empty() {
2012 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::RowMajor);
2013 grid.insert_row(0, vec![1, 2, 3]);
2014 test_grid(&grid, 1, 3, Order::RowMajor, &[1, 2, 3]);
2015 }
2016
2017 #[test]
2018 #[should_panic]
2019 #[allow(clippy::should_panic_without_expect)]
2020 fn insert_row_out_of_idx() {
2021 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
2022 grid.insert_row(3, vec![4, 5]);
2023 }
2024
2025 #[test]
2026 #[should_panic]
2027 #[allow(clippy::should_panic_without_expect)]
2028 fn insert_row_wrong_size_of_idx() {
2029 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
2030 grid.insert_row(1, vec![4, 5, 4]);
2031 }
2032
2033 #[test]
2034 fn insert_row_start() {
2035 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
2036 grid.insert_row(1, vec![5, 6]);
2037 test_grid(&grid, 3, 2, Order::RowMajor, &[1, 2, 5, 6, 3, 4]);
2038 }
2039
2040 #[test]
2041 fn insert_row_at_end_column_major() {
2042 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
2043 grid.insert_row(2, vec![5, 6]);
2044 test_grid(&grid, 3, 2, Order::ColumnMajor, &[1, 3, 5, 2, 4, 6]);
2045 }
2046
2047 #[test]
2048 fn insert_row_empty_column_major() {
2049 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::ColumnMajor);
2050 grid.insert_row(0, vec![1, 2, 3]);
2051 test_grid(&grid, 1, 3, Order::ColumnMajor, &[1, 2, 3]);
2052 }
2053
2054 #[test]
2055 #[should_panic]
2056 #[allow(clippy::should_panic_without_expect)]
2057 fn insert_row_out_of_idx_column_major() {
2058 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::ColumnMajor);
2059 grid.insert_row(3, vec![4, 5]);
2060 }
2061
2062 #[test]
2063 #[should_panic]
2064 #[allow(clippy::should_panic_without_expect)]
2065 fn insert_row_wrong_size_of_idx_column_major() {
2066 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::ColumnMajor);
2067 grid.insert_row(1, vec![4, 5, 4]);
2068 }
2069
2070 #[test]
2071 fn insert_row_start_column_major() {
2072 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
2073 grid.insert_row(1, vec![5, 6]);
2074 test_grid(&grid, 3, 2, Order::ColumnMajor, &[1, 5, 3, 2, 6, 4]);
2075 }
2076
2077 #[test]
2078 fn pop_col_1x3() {
2079 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3], 3, Order::RowMajor);
2080 assert_eq!(grid.pop_col(), Some(vec![3]));
2081 test_grid(&grid, 1, 2, Order::RowMajor, &[1, 2]);
2082 assert_eq!(grid.pop_col(), Some(vec![2]));
2083 test_grid(&grid, 1, 1, Order::RowMajor, &[1]);
2084 assert_eq!(grid.pop_col(), Some(vec![1]));
2085 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2086 assert_eq!(grid.pop_col(), None);
2087 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2088 }
2089
2090 #[test]
2091 fn pop_col_3x1() {
2092 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3], 1, Order::RowMajor);
2093 assert_eq!(grid.pop_col(), Some(vec![1, 2, 3]));
2094 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2095 assert_eq!(grid.pop_col(), None);
2096 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2097 }
2098
2099 #[test]
2100 fn pop_col_2x2() {
2101 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
2102 assert_eq!(grid.pop_col(), Some(vec![2, 4]));
2103 assert_eq!(grid.size(), (2, 1));
2104 test_grid(&grid, 2, 1, Order::RowMajor, &[1, 3]);
2105 assert_eq!(grid.pop_col(), Some(vec![1, 3]));
2106 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2107 assert_eq!(grid.pop_col(), None);
2108 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2109 }
2110
2111 #[test]
2112 fn pop_col_3x4() {
2113 let internal = vec![1, 2, 3, 4, 11, 22, 33, 44, 111, 222, 333, 444];
2114 let mut grid: Grid<u16> = Grid::from_vec_with_order(internal, 4, Order::RowMajor);
2115 assert_eq!(grid.pop_col(), Some(vec![4, 44, 444]));
2116 let expected = [1, 2, 3, 11, 22, 33, 111, 222, 333];
2117 test_grid(&grid, 3, 3, Order::RowMajor, &expected);
2118 assert_eq!(grid.pop_col(), Some(vec![3, 33, 333]));
2119 test_grid(&grid, 3, 2, Order::RowMajor, &[1, 2, 11, 22, 111, 222]);
2120 assert_eq!(grid.pop_col(), Some(vec![2, 22, 222]));
2121 test_grid(&grid, 3, 1, Order::RowMajor, &[1, 11, 111]);
2122 assert_eq!(grid.pop_col(), Some(vec![1, 11, 111]));
2123 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2124 assert_eq!(grid.pop_col(), None);
2125 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2126 }
2127
2128 #[test]
2129 fn pop_col_empty() {
2130 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::RowMajor);
2131 assert_eq!(grid.pop_col(), None);
2132 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2133 }
2134
2135 #[test]
2136 fn pop_col_1x3_column_major() {
2137 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3], 3, Order::ColumnMajor);
2138 assert_eq!(grid.pop_col(), Some(vec![3]));
2139 test_grid(&grid, 1, 2, Order::ColumnMajor, &[1, 2]);
2140 assert_eq!(grid.pop_col(), Some(vec![2]));
2141 test_grid(&grid, 1, 1, Order::ColumnMajor, &[1]);
2142 assert_eq!(grid.pop_col(), Some(vec![1]));
2143 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2144 assert_eq!(grid.pop_col(), None);
2145 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2146 }
2147
2148 #[test]
2149 fn pop_col_3x1_column_major() {
2150 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 2, 3], 1, Order::ColumnMajor);
2151 assert_eq!(grid.pop_col(), Some(vec![1, 2, 3]));
2152 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2153 assert_eq!(grid.pop_col(), None);
2154 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2155 }
2156
2157 #[test]
2158 fn pop_col_2x2_column_major() {
2159 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
2160 assert_eq!(grid.pop_col(), Some(vec![2, 4]));
2161 assert_eq!(grid.size(), (2, 1));
2162 test_grid(&grid, 2, 1, Order::ColumnMajor, &[1, 3]);
2163 assert_eq!(grid.pop_col(), Some(vec![1, 3]));
2164 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2165 assert_eq!(grid.pop_col(), None);
2166 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2167 }
2168
2169 #[test]
2170 fn pop_col_3x4_column_major() {
2171 let internal = vec![1, 11, 111, 2, 22, 222, 3, 33, 333, 4, 44, 444];
2172 let mut grid: Grid<u16> = Grid::from_vec_with_order(internal, 4, Order::ColumnMajor);
2173 assert_eq!(grid.pop_col(), Some(vec![4, 44, 444]));
2174 let expected = [1, 11, 111, 2, 22, 222, 3, 33, 333];
2175 test_grid(&grid, 3, 3, Order::ColumnMajor, &expected);
2176 assert_eq!(grid.pop_col(), Some(vec![3, 33, 333]));
2177 test_grid(&grid, 3, 2, Order::ColumnMajor, &[1, 11, 111, 2, 22, 222]);
2178 assert_eq!(grid.pop_col(), Some(vec![2, 22, 222]));
2179 test_grid(&grid, 3, 1, Order::ColumnMajor, &[1, 11, 111]);
2180 assert_eq!(grid.pop_col(), Some(vec![1, 11, 111]));
2181 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2182 assert_eq!(grid.pop_col(), None);
2183 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2184 }
2185
2186 #[test]
2187 fn pop_col_empty_column_major() {
2188 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::ColumnMajor);
2189 assert_eq!(grid.pop_col(), None);
2190 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2191 }
2192
2193 #[test]
2194 fn pop_row_2x2() {
2195 let mut grid: Grid<u8> = Grid::from_vec(vec![1, 2, 3, 4], 2);
2196 assert_eq!(grid.pop_row(), Some(vec![3, 4]));
2197 test_grid(&grid, 1, 2, Order::RowMajor, &[1, 2]);
2198 assert_eq!(grid.pop_row(), Some(vec![1, 2]));
2199 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2200 assert_eq!(grid.pop_row(), None);
2201 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2202 }
2203
2204 #[test]
2205 fn pop_row_empty() {
2206 let mut grid: Grid<u8> = Grid::from_vec(vec![], 0);
2207 assert_eq!(grid.pop_row(), None);
2208 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2209 }
2210
2211 #[test]
2212 fn pop_row_2x2_column_major() {
2213 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
2214 assert_eq!(grid.pop_row(), Some(vec![3, 4]));
2215 test_grid(&grid, 1, 2, Order::ColumnMajor, &[1, 2]);
2216 assert_eq!(grid.pop_row(), Some(vec![1, 2]));
2217 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2218 assert_eq!(grid.pop_row(), None);
2219 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2220 }
2221
2222 #[test]
2223 fn pop_row_empty_column_major() {
2224 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::ColumnMajor);
2225 assert_eq!(grid.pop_row(), None);
2226 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2227 }
2228
2229 #[test]
2230 fn ne_full_empty() {
2231 let g1 = Grid::from_vec(vec![1, 2, 3, 4], 2);
2232 let g2: Grid<u8> = grid![];
2233 assert_ne!(g1, g2);
2234 }
2235
2236 #[test]
2237 fn ne() {
2238 let g1 = Grid::from_vec(vec![1, 2, 3, 5], 2);
2239 let g2 = Grid::from_vec(vec![1, 2, 3, 4], 2);
2240 assert_ne!(g1, g2);
2241 }
2242
2243 #[test]
2244 fn ne_dif_rows() {
2245 let g1 = Grid::from_vec(vec![1, 2, 3, 4], 2);
2246 let g2 = Grid::from_vec(vec![1, 2, 3, 4], 1);
2247 assert_ne!(g1, g2);
2248 }
2249
2250 #[test]
2251 fn equal_empty() {
2252 let grid: Grid<char> = grid![];
2253 let grid2: Grid<char> = grid![];
2254 assert_eq!(grid, grid2);
2255 }
2256
2257 #[test]
2258 fn equal() {
2259 let grid: Grid<char> = grid![['a', 'b', 'c', 'd']['a', 'b', 'c', 'd']['a', 'b', 'c', 'd']];
2260 let grid2: Grid<char> = grid![['a', 'b', 'c', 'd']['a', 'b', 'c', 'd']['a', 'b', 'c', 'd']];
2261 assert_eq!(grid, grid2);
2262 }
2263
2264 #[test]
2265 fn equal_different_order() {
2266 let grid = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
2267 let grid2 = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
2268 assert_eq!(grid, grid2);
2269 }
2270
2271 #[test]
2272 fn equal_partial_eq() {
2273 let grid = grid![[1.0]];
2274 let grid2 = Grid::from_vec(vec![1.0], 1);
2275 assert_eq!(grid, grid2);
2276 }
2277
2278 #[test]
2279 fn ne_partial_eq() {
2280 let grid = grid![[f64::NAN]];
2281 assert_ne!(grid, grid);
2282 }
2283
2284 #[test]
2285 #[should_panic]
2286 #[allow(clippy::should_panic_without_expect)]
2287 fn idx_tup_out_of_col_bounds() {
2288 let grid: Grid<char> = grid![['a', 'b', 'c', 'd']['a', 'b', 'c', 'd']['a', 'b', 'c', 'd']];
2289 let _ = grid[(0, 5)];
2290 }
2291
2292 #[test]
2293 fn push_col_2x3() {
2294 let mut grid: Grid<u8> = grid![
2295 [0, 1, 2]
2296 [10, 11, 12]];
2297 grid.push_col(vec![3, 13]);
2298 test_grid(&grid, 2, 4, Order::RowMajor, &[0, 1, 2, 3, 10, 11, 12, 13]);
2299 }
2300
2301 #[test]
2302 fn push_col_3x4() {
2303 let mut grid: Grid<char> = grid![
2304 ['a', 'b', 'c', 'd']
2305 ['a', 'b', 'c', 'd']
2306 ['a', 'b', 'c', 'd']];
2307 grid.push_col(vec!['x', 'y', 'z']);
2308 let expected = [
2309 'a', 'b', 'c', 'd', 'x', 'a', 'b', 'c', 'd', 'y', 'a', 'b', 'c', 'd', 'z',
2310 ];
2311 test_grid(&grid, 3, 5, Order::RowMajor, &expected);
2312 }
2313
2314 #[test]
2315 fn push_col_1x3() {
2316 let mut grid: Grid<char> = grid![['a', 'b', 'c']];
2317 grid.push_col(vec!['d']);
2318 test_grid(&grid, 1, 4, Order::RowMajor, &['a', 'b', 'c', 'd']);
2319 }
2320
2321 #[test]
2322 fn push_col_empty() {
2323 let mut grid: Grid<char> = grid![];
2324 grid.push_col(vec!['b', 'b', 'b', 'b']);
2325 test_grid(&grid, 4, 1, Order::RowMajor, &['b', 'b', 'b', 'b']);
2326 }
2327
2328 #[test]
2329 #[should_panic]
2330 #[allow(clippy::should_panic_without_expect)]
2331 fn push_col_wrong_size() {
2332 let mut grid: Grid<char> = grid![['a','a','a']['a','a','a']];
2333 grid.push_col(vec!['b']);
2334 grid.push_col(vec!['b', 'b']);
2335 }
2336
2337 #[test]
2338 #[should_panic]
2339 #[allow(clippy::should_panic_without_expect)]
2340 fn push_col_zero_len() {
2341 let mut grid: Grid<char> = grid![];
2342 grid.push_col(vec![]);
2343 }
2344
2345 #[test]
2346 fn push_col_2x3_column_major() {
2347 let internal = vec![0, 10, 1, 11, 2, 12];
2348 let mut grid: Grid<u8> = Grid::from_vec_with_order(internal, 3, Order::ColumnMajor);
2349 grid.push_col(vec![3, 13]);
2350 let expected = [0, 10, 1, 11, 2, 12, 3, 13];
2351 test_grid(&grid, 2, 4, Order::ColumnMajor, &expected);
2352 }
2353
2354 #[test]
2355 fn push_col_3x4_column_major() {
2356 let internal = vec!['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'];
2357 let mut grid: Grid<char> = Grid::from_vec_with_order(internal, 4, Order::ColumnMajor);
2358 grid.push_col(vec!['x', 'y', 'z']);
2359 let expected = [
2360 'a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'x', 'y', 'z',
2361 ];
2362 test_grid(&grid, 3, 5, Order::ColumnMajor, &expected);
2363 }
2364
2365 #[test]
2366 fn push_col_1x3_column_major() {
2367 let mut grid: Grid<char> =
2368 Grid::from_vec_with_order(vec!['a', 'b', 'c'], 3, Order::ColumnMajor);
2369 grid.push_col(vec!['d']);
2370 test_grid(&grid, 1, 4, Order::ColumnMajor, &['a', 'b', 'c', 'd']);
2371 }
2372
2373 #[test]
2374 fn push_col_empty_column_major() {
2375 let mut grid: Grid<char> = Grid::new_with_order(0, 0, Order::ColumnMajor);
2376 grid.push_col(vec!['b', 'b', 'b', 'b']);
2377 test_grid(&grid, 4, 1, Order::ColumnMajor, &['b', 'b', 'b', 'b']);
2378 }
2379
2380 #[test]
2381 #[should_panic]
2382 #[allow(clippy::should_panic_without_expect)]
2383 fn push_col_wrong_size_column_major() {
2384 let mut grid: Grid<char> = Grid::init_with_order(2, 3, Order::ColumnMajor, 'a');
2385 grid.push_col(vec!['b']);
2386 grid.push_col(vec!['b', 'b']);
2387 }
2388
2389 #[test]
2390 #[should_panic]
2391 #[allow(clippy::should_panic_without_expect)]
2392 fn push_col_zero_len_column_major() {
2393 let mut grid: Grid<char> = Grid::new_with_order(0, 0, Order::ColumnMajor);
2394 grid.push_col(vec![]);
2395 }
2396
2397 #[test]
2398 fn push_row() {
2399 let mut grid: Grid<u8> = grid![[1, 2][3, 4]];
2400 grid.push_row(vec![5, 6]);
2401 test_grid(&grid, 3, 2, Order::RowMajor, &[1, 2, 3, 4, 5, 6]);
2402 }
2403
2404 #[test]
2405 fn push_row_empty() {
2406 let mut grid: Grid<char> = grid![];
2407 grid.push_row(vec!['b', 'b', 'b', 'b']);
2408 test_grid(&grid, 1, 4, Order::RowMajor, &['b', 'b', 'b', 'b']);
2409 }
2410
2411 #[test]
2412 #[should_panic]
2413 #[allow(clippy::should_panic_without_expect)]
2414 fn push_empty_row() {
2415 let mut grid = Grid::init(0, 1, 0);
2416 grid.push_row(vec![]);
2417 }
2418
2419 #[test]
2420 #[should_panic]
2421 #[allow(clippy::should_panic_without_expect)]
2422 fn push_row_wrong_size() {
2423 let mut grid: Grid<char> = grid![['a','a','a']['a','a','a']];
2424 grid.push_row(vec!['b']);
2425 grid.push_row(vec!['b', 'b', 'b', 'b']);
2426 }
2427
2428 #[test]
2429 fn push_row_column_major() {
2430 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
2431 grid.push_row(vec![5, 6]);
2432 test_grid(&grid, 3, 2, Order::ColumnMajor, &[1, 3, 5, 2, 4, 6]);
2433 }
2434
2435 #[test]
2436 fn push_row_empty_column_major() {
2437 let mut grid: Grid<char> = Grid::new_with_order(0, 0, Order::ColumnMajor);
2438 grid.push_row(vec!['b', 'b', 'b', 'b']);
2439 test_grid(&grid, 1, 4, Order::ColumnMajor, &['b', 'b', 'b', 'b']);
2440 }
2441
2442 #[test]
2443 #[should_panic]
2444 #[allow(clippy::should_panic_without_expect)]
2445 fn push_empty_row_column_major() {
2446 let mut grid = Grid::init_with_order(0, 1, Order::ColumnMajor, 0);
2447 grid.push_row(vec![]);
2448 }
2449
2450 #[test]
2451 #[should_panic]
2452 #[allow(clippy::should_panic_without_expect)]
2453 fn push_row_wrong_size_column_major() {
2454 let mut grid: Grid<char> =
2455 Grid::from_vec_with_order(vec!['a', 'a', 'a', 'a', 'a', 'a'], 3, Order::ColumnMajor);
2456 grid.push_row(vec!['b']);
2457 grid.push_row(vec!['b', 'b', 'b', 'b']);
2458 }
2459
2460 #[test]
2461 fn iter_row() {
2462 let grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
2463 let row: Vec<_> = grid.iter_row(1).collect();
2464 assert_eq!(row, [&4, &5, &6]);
2465 }
2466
2467 #[test]
2468 #[should_panic]
2469 #[allow(clippy::should_panic_without_expect)]
2470 fn iter_row_out_of_bound() {
2471 let grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
2472 let _ = grid.iter_row(3);
2473 }
2474
2475 #[test]
2476 #[should_panic]
2477 #[allow(clippy::should_panic_without_expect)]
2478 fn iter_row_zero() {
2479 let grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::RowMajor);
2480 let _ = grid.iter_row(0);
2481 }
2482
2483 #[test]
2484 fn iter_row_rowumn_major() {
2485 let grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2486 let row: Vec<_> = grid.iter_row(1).collect();
2487 assert_eq!(row, [&4, &5, &6]);
2488 }
2489
2490 #[test]
2491 #[should_panic]
2492 #[allow(clippy::should_panic_without_expect)]
2493 fn iter_row_rowumn_major_out_of_bound() {
2494 let grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2495 let _ = grid.iter_row(3);
2496 }
2497
2498 #[test]
2499 #[should_panic]
2500 #[allow(clippy::should_panic_without_expect)]
2501 fn iter_row_rowumn_major_zero() {
2502 let grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::ColumnMajor);
2503 let _ = grid.iter_row(0);
2504 }
2505
2506 #[test]
2507 fn iter_row_mut() {
2508 let mut grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
2509 let row: Vec<_> = grid.iter_row_mut(1).collect();
2510 assert_eq!(row, [&mut 4, &mut 5, &mut 6]);
2511 }
2512
2513 #[test]
2514 #[should_panic]
2515 #[allow(clippy::should_panic_without_expect)]
2516 fn iter_row_mut_out_of_bound() {
2517 let mut grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
2518 let _ = grid.iter_row_mut(3);
2519 }
2520
2521 #[test]
2522 #[should_panic]
2523 #[allow(clippy::should_panic_without_expect)]
2524 fn iter_row_mut_zero() {
2525 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::RowMajor);
2526 let _ = grid.iter_row_mut(0);
2527 }
2528
2529 #[test]
2530 fn iter_row_mut_rowumn_major() {
2531 let mut grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2532 let row: Vec<_> = grid.iter_row_mut(1).collect();
2533 assert_eq!(row, [&mut 4, &mut 5, &mut 6]);
2534 }
2535
2536 #[test]
2537 #[should_panic]
2538 #[allow(clippy::should_panic_without_expect)]
2539 fn iter_row_mut_rowumn_major_out_of_bound() {
2540 let mut grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2541 let _ = grid.iter_row_mut(3);
2542 }
2543
2544 #[test]
2545 #[should_panic]
2546 #[allow(clippy::should_panic_without_expect)]
2547 fn iter_row_mut_rowumn_major_zero() {
2548 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::ColumnMajor);
2549 let _ = grid.iter_row_mut(0);
2550 }
2551
2552 #[test]
2553 fn iter_col() {
2554 let grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
2555 let col: Vec<_> = grid.iter_col(1).collect();
2556 assert_eq!(col, [&2, &5]);
2557 }
2558
2559 #[test]
2560 #[should_panic]
2561 #[allow(clippy::should_panic_without_expect)]
2562 fn iter_col_out_of_bound() {
2563 let grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
2564 let _ = grid.iter_col(3);
2565 }
2566
2567 #[test]
2568 #[should_panic]
2569 #[allow(clippy::should_panic_without_expect)]
2570 fn iter_col_zero() {
2571 let grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::RowMajor);
2572 let _ = grid.iter_col(0);
2573 }
2574
2575 #[test]
2576 fn iter_col_column_major() {
2577 let grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2578 let col: Vec<_> = grid.iter_col(1).collect();
2579 assert_eq!(col, [&2, &5]);
2580 }
2581
2582 #[test]
2583 #[should_panic]
2584 #[allow(clippy::should_panic_without_expect)]
2585 fn iter_col_column_major_out_of_bound() {
2586 let grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2587 let _ = grid.iter_col(3);
2588 }
2589
2590 #[test]
2591 #[should_panic]
2592 #[allow(clippy::should_panic_without_expect)]
2593 fn iter_col_column_major_zero() {
2594 let grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::ColumnMajor);
2595 let _ = grid.iter_col(0);
2596 }
2597
2598 #[test]
2599 fn iter_col_mut() {
2600 let mut grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
2601 let col: Vec<_> = grid.iter_col_mut(1).collect();
2602 assert_eq!(col, [&mut 2, &mut 5]);
2603 }
2604
2605 #[test]
2606 #[should_panic]
2607 #[allow(clippy::should_panic_without_expect)]
2608 fn iter_col_mut_out_of_bound() {
2609 let mut grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
2610 let _ = grid.iter_col_mut(3);
2611 }
2612
2613 #[test]
2614 #[should_panic]
2615 #[allow(clippy::should_panic_without_expect)]
2616 fn iter_col_mut_zero() {
2617 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::RowMajor);
2618 let _ = grid.iter_col_mut(0);
2619 }
2620
2621 #[test]
2622 fn iter_col_mut_column_major() {
2623 let mut grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2624 let col: Vec<_> = grid.iter_col_mut(1).collect();
2625 assert_eq!(col, [&mut 2, &mut 5]);
2626 }
2627
2628 #[test]
2629 #[should_panic]
2630 #[allow(clippy::should_panic_without_expect)]
2631 fn iter_col_mut_column_major_out_of_bound() {
2632 let mut grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2633 let _ = grid.iter_col_mut(3);
2634 }
2635
2636 #[test]
2637 #[should_panic]
2638 #[allow(clippy::should_panic_without_expect)]
2639 fn iter_col_mut_column_major_zero() {
2640 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![], 0, Order::ColumnMajor);
2641 let _ = grid.iter_col_mut(0);
2642 }
2643
2644 #[test]
2645 fn iter() {
2646 let grid: Grid<u8> = grid![[1,2][3,4]];
2647 let mut iter = grid.iter();
2648 assert_eq!(iter.next(), Some(&1));
2649 assert_eq!(iter.next(), Some(&2));
2650 assert_eq!(iter.next(), Some(&3));
2651 assert_eq!(iter.next(), Some(&4));
2652 assert_eq!(iter.next(), None);
2653 }
2654
2655 #[test]
2656 fn indexed_iter() {
2657 let grid: Grid<u8> = grid![[1,2][3,4]];
2658 let mut iter = grid.indexed_iter();
2659 assert_eq!(iter.next(), Some(((0, 0), &1)));
2660 assert_eq!(iter.next(), Some(((0, 1), &2)));
2661 assert_eq!(iter.next(), Some(((1, 0), &3)));
2662 assert_eq!(iter.next(), Some(((1, 1), &4)));
2663 assert_eq!(iter.next(), None);
2664 }
2665
2666 #[test]
2667 fn indexed_iter_empty() {
2668 let grid: Grid<u8> = Grid::new(0, 0);
2669 let mut iter = grid.indexed_iter();
2670 assert_eq!(iter.next(), None);
2671 }
2672
2673 #[test]
2674 fn indexed_iter_column_major() {
2675 let grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
2676 let mut iter = grid.indexed_iter();
2677 assert_eq!(iter.next(), Some(((0, 0), &1)));
2678 assert_eq!(iter.next(), Some(((1, 0), &3)));
2679 assert_eq!(iter.next(), Some(((0, 1), &2)));
2680 assert_eq!(iter.next(), Some(((1, 1), &4)));
2681 assert_eq!(iter.next(), None);
2682 }
2683
2684 #[test]
2685 fn indexed_iter_empty_column_major() {
2686 let grid: Grid<u8> = Grid::new_with_order(0, 0, Order::ColumnMajor);
2687 let mut iter = grid.indexed_iter();
2688 assert_eq!(iter.next(), None);
2689 }
2690
2691 #[test]
2692 fn indexed_iter_mut() {
2693 let mut grid: Grid<u8> = grid![[1,2][3,4]];
2694 let mut iter = grid.indexed_iter_mut();
2695 assert_eq!(iter.next(), Some(((0, 0), &mut 1)));
2696 assert_eq!(iter.next(), Some(((0, 1), &mut 2)));
2697 assert_eq!(iter.next(), Some(((1, 0), &mut 3)));
2698 assert_eq!(iter.next(), Some(((1, 1), &mut 4)));
2699 assert_eq!(iter.next(), None);
2700 }
2701
2702 #[test]
2703 fn indexed_iter_mut_empty() {
2704 let mut grid: Grid<u8> = Grid::new(0, 0);
2705 let mut iter = grid.indexed_iter_mut();
2706 assert_eq!(iter.next(), None);
2707 }
2708
2709 #[test]
2710 fn indexed_iter_mut_column_major() {
2711 let mut grid: Grid<u8> = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
2712 let mut iter = grid.indexed_iter_mut();
2713 assert_eq!(iter.next(), Some(((0, 0), &mut 1)));
2714 assert_eq!(iter.next(), Some(((1, 0), &mut 3)));
2715 assert_eq!(iter.next(), Some(((0, 1), &mut 2)));
2716 assert_eq!(iter.next(), Some(((1, 1), &mut 4)));
2717 assert_eq!(iter.next(), None);
2718 }
2719
2720 #[test]
2721 fn indexed_iter_mut_empty_column_major() {
2722 let mut grid: Grid<u8> = Grid::new_with_order(0, 0, Order::ColumnMajor);
2723 let mut iter = grid.indexed_iter_mut();
2724 assert_eq!(iter.next(), None);
2725 }
2726
2727 #[test]
2728 fn clear() {
2729 let mut grid: Grid<u8> = grid![[1, 2, 3]];
2730 assert!(!grid.is_empty());
2731 grid.clear();
2732 assert!(grid.is_empty());
2733 }
2734
2735 #[test]
2736 fn is_empty_false() {
2737 let grid: Grid<u8> = grid![[1, 2, 3]];
2738 assert!(!grid.is_empty());
2739 }
2740
2741 #[test]
2742 fn is_empty() {
2743 let mut g: Grid<u8> = grid![[]];
2744 assert!(g.is_empty());
2745 g = grid![];
2746 assert!(g.is_empty());
2747 g = Grid::from_vec(vec![], 0);
2748 assert!(g.is_empty());
2749 g = Grid::new(0, 0);
2750 assert!(g.is_empty());
2751 g = Grid::new(0, 1);
2752 assert!(g.is_empty());
2753 g = Grid::new(1, 0);
2754 assert!(g.is_empty());
2755 g = Grid::init(0, 0, 10);
2756 assert!(g.is_empty());
2757 }
2758
2759 #[test]
2760 fn fmt_empty() {
2761 let grid: Grid<u8> = grid![];
2762 assert_eq!(format!("{grid:?}"), "[]");
2763 }
2764
2765 #[test]
2766 fn fmt_row() {
2767 let grid: Grid<u8> = grid![[1, 2, 3]];
2768 assert_eq!(format!("{grid:?}"), "[[1, 2, 3]]");
2769 }
2770
2771 #[test]
2772 fn fmt_grid() {
2773 let grid: Grid<u8> = grid![[1,2,3][4,5,6][7,8,9]];
2774 assert_eq!(format!("{grid:?}"), "[[1, 2, 3][4, 5, 6][7, 8, 9]]");
2775 }
2776
2777 #[test]
2778 fn fmt_column_major() {
2779 let grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2780 assert_eq!(format!("{grid:?}"), "[[1, 2, 3][4, 5, 6]]");
2781 }
2782
2783 #[test]
2784 fn fmt_pretty_empty() {
2785 let grid: Grid<f32> = grid![];
2786 assert_eq!(format!("{grid:#?}"), "[]");
2787 }
2788
2789 #[test]
2790 fn fmt_pretty_int() {
2791 let grid: Grid<u8> = grid![
2792 [1,2,3]
2793 [4,5,6]
2794 [7,8,95]
2795 ];
2796
2797 let expected_output = r"[
2798 [ 1, 2, 3]
2799 [ 4, 5, 6]
2800 [ 7, 8, 95]
2801]";
2802
2803 assert_eq!(format!("{grid:#?}"), expected_output);
2804
2805 let expected_output = r"[
2806 [ 1, 2, 3]
2807 [ 4, 5, 6]
2808 [ 7, 8, 95]
2809]";
2810
2811 assert_eq!(format!("{grid:#3?}"), expected_output);
2812 }
2813
2814 #[test]
2815 fn fmt_pretty_float() {
2816 let grid: Grid<f32> = grid![
2817 [1.5,2.6,3.44]
2818 [4.775,5.,6.]
2819 [7.1,8.23444,95.55]
2820 ];
2821
2822 let expected_output = r"[
2823 [ 1.5, 2.6, 3.4]
2824 [ 4.8, 5.0, 6.0]
2825 [ 7.1, 8.2, 95.6]
2826]";
2827
2828 assert_eq!(format!("{grid:#5.1?}"), expected_output);
2829
2830 let expected_output = r"[
2831 [ 1.50000, 2.60000, 3.44000]
2832 [ 4.77500, 5.00000, 6.00000]
2833 [ 7.10000, 8.23444, 95.55000]
2834]";
2835
2836 assert_eq!(format!("{grid:#8.5?}"), expected_output);
2837 }
2838
2839 #[test]
2840 fn fmt_pretty_tuple() {
2841 let grid: Grid<(i32, i32)> = grid![
2842 [(5,66), (432, 55)]
2843 [(80, 90), (5, 6)]
2844 ];
2845
2846 let expected_output = r"[
2847 [ ( 5, 66), ( 432, 55)]
2848 [ ( 80, 90), ( 5, 6)]
2849]";
2850
2851 assert_eq!(format!("{grid:#?}"), expected_output);
2852
2853 let expected_output = r"[
2854 [ ( 5, 66), (432, 55)]
2855 [ ( 80, 90), ( 5, 6)]
2856]";
2857
2858 assert_eq!(format!("{grid:#3?}"), expected_output);
2859 }
2860
2861 #[test]
2862 fn fmt_pretty_struct_derived() {
2863 #[derive(Debug)]
2864 struct Person {
2865 _name: String,
2866 _precise_age: f32,
2867 }
2868
2869 impl Person {
2870 fn new(name: &str, precise_age: f32) -> Self {
2871 Person {
2872 _name: name.into(),
2873 _precise_age: precise_age,
2874 }
2875 }
2876 }
2877
2878 let grid: Grid<Person> = grid![
2879 [Person::new("Vic", 24.5), Person::new("Mr. Very Long Name", 1955.)]
2880 [Person::new("Sam", 8.9995), Person::new("John Doe", 40.14)]
2881 ];
2882
2883 let expected_output = r#"[
2884 [ Person { _name: "Vic", _precise_age: 24.50000 }, Person { _name: "Mr. Very Long Name", _precise_age: 1955.00000 }]
2885 [ Person { _name: "Sam", _precise_age: 8.99950 }, Person { _name: "John Doe", _precise_age: 40.14000 }]
2886]"#;
2887
2888 assert_eq!(format!("{grid:#5.5?}"), expected_output);
2889 }
2890
2891 #[test]
2892 fn fmt_pretty_column_major() {
2893 let grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
2894 let expected_output = r"[
2895 [ 1, 2, 3]
2896 [ 4, 5, 6]
2897]";
2898 assert_eq!(format!("{grid:#?}"), expected_output);
2899 }
2900
2901 #[test]
2902 fn clone() {
2903 let grid = grid![[1, 2, 3][4, 5, 6]];
2904 let mut clone = grid.clone();
2905 clone[(0, 2)] = 10;
2906 test_grid(&grid, 2, 3, Order::RowMajor, &[1, 2, 3, 4, 5, 6]);
2907 test_grid(&clone, 2, 3, Order::RowMajor, &[1, 2, 10, 4, 5, 6]);
2908 }
2909
2910 #[cfg(feature = "std")]
2911 #[test]
2912 fn hash_std() {
2913 let mut set = std::collections::HashSet::new();
2914 set.insert(grid![[1,2,3][4,5,6]]);
2915 set.insert(grid![[1,3,3][4,5,6]]);
2916 set.insert(grid![[1,2,3][4,5,6]]);
2917 assert_eq!(set.len(), 2);
2918 }
2919
2920 #[test]
2921 fn macro_init() {
2922 let grid = grid![[1, 2, 3][4, 5, 6]];
2923 test_grid(&grid, 2, 3, Order::RowMajor, &[1, 2, 3, 4, 5, 6]);
2924 }
2925
2926 #[test]
2927 fn macro_init_2() {
2928 let grid = grid![[1, 2, 3]
2929 [4, 5, 6]
2930 [7, 8, 9]];
2931 test_grid(&grid, 3, 3, Order::RowMajor, &[1, 2, 3, 4, 5, 6, 7, 8, 9]);
2932 }
2933
2934 #[test]
2935 fn macro_init_char() {
2936 let grid = grid![['a', 'b', 'c']
2937 ['a', 'b', 'c']
2938 ['a', 'b', 'c']];
2939 let expected = ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c'];
2940 test_grid(&grid, 3, 3, Order::RowMajor, &expected);
2941 }
2942
2943 #[test]
2944 fn macro_one_row() {
2945 let grid: Grid<usize> = grid![[1, 2, 3, 4]];
2946 test_grid(&grid, 1, 4, Order::RowMajor, &[1, 2, 3, 4]);
2947 }
2948
2949 #[test]
2950 fn macro2_empty() {
2951 let grid: Grid<u8> = grid_cm![];
2952 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
2953 }
2954
2955 #[test]
2956 fn macro2_init() {
2957 let grid = grid_cm![[1, 2, 3]
2958 [4, 5, 6]
2959 [7, 8, 9]];
2960 let expected = [1, 4, 7, 2, 5, 8, 3, 6, 9];
2961 test_grid(&grid, 3, 3, Order::ColumnMajor, &expected);
2962 }
2963
2964 #[test]
2965 fn macro2_init_char() {
2966 let grid = grid_cm![['a', 'b']['c', 'd']];
2967 test_grid(&grid, 2, 2, Order::ColumnMajor, &['a', 'c', 'b', 'd']);
2968 }
2969
2970 #[test]
2971 fn macro2_one_row() {
2972 let grid = grid_cm![[1, 2, 3, 4]];
2973 test_grid(&grid, 1, 4, Order::ColumnMajor, &[1, 2, 3, 4]);
2974 }
2975
2976 #[test]
2977 fn init() {
2978 let grid = Grid::init(1, 2, 3);
2979 test_grid(&grid, 1, 2, Order::RowMajor, &[3, 3]);
2980
2981 let grid = Grid::init(1, 2, 1.2);
2982 test_grid(&grid, 1, 2, Order::RowMajor, &[1.2, 1.2]);
2983
2984 let grid = Grid::init(1, 2, 'a');
2985 test_grid(&grid, 1, 2, Order::RowMajor, &['a', 'a']);
2986 }
2987
2988 #[test]
2989 #[should_panic]
2990 #[allow(clippy::should_panic_without_expect)]
2991 fn init_panics() {
2992 Grid::init(usize::MAX, 2, 3);
2993 }
2994
2995 #[test]
2996 fn init_empty() {
2997 let grid = Grid::init(0, 1, 0);
2998 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
2999
3000 let grid = Grid::init(1, 0, -1);
3001 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
3002 }
3003
3004 #[test]
3005 fn init_with_order() {
3006 let grid = Grid::init_with_order(1, 2, Order::RowMajor, 3);
3007 test_grid(&grid, 1, 2, Order::RowMajor, &[3, 3]);
3008
3009 let grid = Grid::init_with_order(1, 2, Order::ColumnMajor, 1.2);
3010 test_grid(&grid, 1, 2, Order::ColumnMajor, &[1.2, 1.2]);
3011
3012 let grid = Grid::init_with_order(1, 2, Order::ColumnMajor, 'a');
3013 test_grid(&grid, 1, 2, Order::ColumnMajor, &['a', 'a']);
3014 }
3015
3016 #[test]
3017 #[should_panic]
3018 #[allow(clippy::should_panic_without_expect)]
3019 fn init_with_order_panics() {
3020 Grid::init_with_order(usize::MAX, 2, Order::ColumnMajor, 3);
3021 }
3022
3023 #[test]
3024 fn init_with_order_empty() {
3025 let grid = Grid::init_with_order(0, 1, Order::ColumnMajor, 0);
3026 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
3027
3028 let grid = Grid::init_with_order(1, 0, Order::RowMajor, -1);
3029 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
3030 }
3031
3032 #[test]
3033 fn new() {
3034 let grid: Grid<u8> = Grid::new(1, 2);
3035 test_grid(&grid, 1, 2, Order::RowMajor, &[0, 0]);
3036 }
3037
3038 #[test]
3039 #[should_panic]
3040 #[allow(clippy::should_panic_without_expect)]
3041 fn new_panics() {
3042 let _: Grid<u8> = Grid::new(usize::MAX, 2);
3043 }
3044
3045 #[test]
3046 fn new_empty() {
3047 let grid: Grid<u8> = Grid::new(0, 1);
3048 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
3049
3050 let grid: Grid<u8> = Grid::new(1, 0);
3051 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
3052 }
3053
3054 #[test]
3055 fn new_with_order() {
3056 let grid: Grid<u8> = Grid::new_with_order(2, 2, Order::ColumnMajor);
3057 test_grid(&grid, 2, 2, Order::ColumnMajor, &[0, 0, 0, 0]);
3058 }
3059
3060 #[test]
3061 #[should_panic]
3062 #[allow(clippy::should_panic_without_expect)]
3063 fn new_with_order_panics() {
3064 let _: Grid<u8> = Grid::new_with_order(usize::MAX, 2, Order::ColumnMajor);
3065 }
3066
3067 #[test]
3068 fn new_with_order_empty() {
3069 let grid: Grid<u8> = Grid::new_with_order(0, 3, Order::RowMajor);
3070 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
3071
3072 let grid: Grid<u8> = Grid::new_with_order(3, 0, Order::ColumnMajor);
3073 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
3074 }
3075
3076 #[test]
3077 fn with_capacity() {
3078 struct Foo();
3080
3081 let grid: Grid<Foo> = Grid::with_capacity(20, 20);
3082 assert!(grid.is_empty());
3083 assert_eq!(grid.order(), Order::default());
3084 }
3085
3086 #[test]
3087 fn with_capacity_and_order() {
3088 struct Foo();
3090
3091 let grid: Grid<Foo> = Grid::with_capacity_and_order(20, 20, Order::ColumnMajor);
3092 assert!(grid.is_empty());
3093 assert_eq!(grid.order(), Order::ColumnMajor);
3094 }
3095
3096 #[test]
3097 #[should_panic]
3098 #[allow(clippy::should_panic_without_expect)]
3099 fn with_capacity_panics_internal() {
3100 struct Foo();
3102
3103 let _grid: Grid<Foo> = Grid::with_capacity_and_order(usize::MAX, 2, Order::RowMajor);
3104 }
3105
3106 #[test]
3107 #[should_panic]
3108 #[allow(clippy::should_panic_without_expect)]
3109 fn with_capacity_panics_vec() {
3110 let rows: usize = isize::MAX.try_into().expect("isize::MAX is positive");
3111 assert!(
3112 core::mem::size_of::<u8>() * rows < usize::MAX,
3113 "shows that panic is from Vec::with_capacity, not internal check"
3114 );
3115
3116 let _grid: Grid<u8> = Grid::with_capacity_and_order(rows, 2, Order::RowMajor);
3117 }
3118
3119 #[test]
3120 fn get() {
3121 let grid = Grid::from_vec_with_order(vec![1, 2], 2, Order::RowMajor);
3122 assert_eq!(grid.get(0_i64, 1_i32), Some(&2));
3123 }
3124
3125 #[test]
3126 fn get_column_major() {
3127 let grid = Grid::from_vec_with_order(vec![1, 2], 1, Order::ColumnMajor);
3128 assert_eq!(grid.get(1, 0), Some(&2));
3129 }
3130
3131 #[test]
3132 fn get_none() {
3133 let grid = Grid::from_vec_with_order(vec![1, 2], 2, Order::RowMajor);
3134 assert_eq!(grid.get(1, 0), None);
3135 }
3136
3137 #[test]
3138 fn get_none_column_major() {
3139 let grid = Grid::from_vec_with_order(vec![1, 2], 1, Order::ColumnMajor);
3140 assert_eq!(grid.get(0, 1), None);
3141 }
3142
3143 #[test]
3144 fn get_mut() {
3145 let mut grid = Grid::from_vec_with_order(vec![1, 2], 2, Order::RowMajor);
3146 assert_eq!(grid.get_mut(0_i64, 1_i32), Some(&mut 2));
3147 }
3148
3149 #[test]
3150 fn get_mut_column_major() {
3151 let mut grid = Grid::from_vec_with_order(vec![1, 2], 1, Order::ColumnMajor);
3152 assert_eq!(grid.get_mut(1, 0), Some(&mut 2));
3153 }
3154
3155 #[test]
3156 fn get_mut_none() {
3157 let mut grid = Grid::from_vec_with_order(vec![1, 2], 2, Order::RowMajor);
3158 assert_eq!(grid.get_mut(1, 0), None);
3159 }
3160
3161 #[test]
3162 fn get_mut_none_column_major() {
3163 let mut grid = Grid::from_vec_with_order(vec![1, 2], 1, Order::ColumnMajor);
3164 assert_eq!(grid.get_mut(0, 1), None);
3165 }
3166
3167 #[test]
3168 fn idx_tup() {
3169 let grid: Grid<u8> = Grid::from_vec(vec![1, 2, 3, 4], 2);
3170 assert_eq!(grid[(0, 0)], 1);
3171 assert_eq!(grid[(0, 1)], 2);
3172 assert_eq!(grid[(1, 0)], 3);
3173 assert_eq!(grid[(1, 1)], 4);
3174 }
3175
3176 #[test]
3177 #[should_panic]
3178 #[allow(clippy::should_panic_without_expect)]
3179 fn idx_tup_panic_1() {
3180 let grid = Grid::init(1, 2, 3);
3181 let _ = grid[(20, 0)];
3182 }
3183
3184 #[test]
3185 #[should_panic]
3186 #[allow(clippy::should_panic_without_expect)]
3187 fn idx_tup_panic_2() {
3188 let grid = Grid::init(1, 2, 3);
3189 let _ = grid[(0, 20)];
3190 }
3191
3192 #[test]
3193 fn idx_tup_set() {
3194 let mut grid = Grid::init(1, 2, 3);
3195 grid[(0, 0)] = 4;
3196 assert_eq!(grid[(0, 0)], 4);
3197 }
3198
3199 #[test]
3200 fn size() {
3201 let grid = Grid::init(1, 2, 3);
3202 assert_eq!(grid.size(), (1, 2));
3203 }
3204
3205 #[test]
3206 fn transpose() {
3207 let mut grid: Grid<u8> = grid![[1,2,3][4,5,6]];
3208 grid.transpose();
3209 assert_eq!(grid, grid![[1,4][2,5][3,6]]);
3210 }
3211
3212 #[test]
3213 fn fill() {
3214 let mut grid: Grid<u8> = grid![[1,2,3][4,5,6]];
3215 grid.fill(7);
3216 test_grid(&grid, 2, 3, Order::RowMajor, &[7, 7, 7, 7, 7, 7]);
3217 }
3218
3219 #[test]
3220 fn fill_with() {
3221 let mut grid: Grid<u8> = grid![[1,2,3][4,5,6]];
3222 grid.fill_with(Default::default);
3223 test_grid(&grid, 2, 3, Order::RowMajor, &[0, 0, 0, 0, 0, 0]);
3224 }
3225
3226 #[test]
3227 #[allow(clippy::redundant_closure_for_method_calls)]
3228 fn iter_rows() {
3229 let grid: Grid<u8> = grid![[1,2,3][4,5,6]];
3230 let max_by_row: Vec<u8> = grid
3231 .iter_rows()
3232 .map(|row| row.max().unwrap())
3233 .copied()
3234 .collect();
3235 assert_eq!(max_by_row, vec![3, 6]);
3236
3237 let sum_by_row: Vec<u8> = grid.iter_rows().map(|row| row.sum()).collect();
3238 assert_eq!(sum_by_row, vec![1 + 2 + 3, 4 + 5 + 6]);
3239 }
3240
3241 #[test]
3242 #[allow(clippy::redundant_closure_for_method_calls)]
3243 fn iter_rows_rev() {
3244 let grid: Grid<u8> = grid![[1,2,3][4,5,6]];
3245 let max_by_row: Vec<u8> = grid
3246 .iter_rows()
3247 .rev()
3248 .map(|row| row.max().unwrap())
3249 .copied()
3250 .collect();
3251 assert_eq!(max_by_row, vec![6, 3]);
3252
3253 let sum_by_row: Vec<u8> = grid.iter_rows().rev().map(|row| row.sum()).collect();
3254 assert_eq!(sum_by_row, vec![4 + 5 + 6, 1 + 2 + 3]);
3255 }
3256
3257 #[test]
3258 fn iter_rows_exact_size() {
3259 let grid: Grid<u8> = grid![[1,2,3][4,5,6]];
3260 let mut row_iter = grid.iter_rows();
3261 assert_eq!(row_iter.len(), 2);
3262 assert!(row_iter.next().is_some());
3263 assert_eq!(row_iter.len(), 1);
3264 assert!(row_iter.next().is_some());
3265 assert_eq!(row_iter.len(), 0);
3266 assert!(row_iter.next().is_none());
3267 }
3268
3269 #[test]
3270 #[allow(clippy::redundant_closure_for_method_calls)]
3271 fn iter_cols() {
3272 let grid: Grid<u8> = grid![[1,2,3][4,5,6]];
3273 let max_by_col: Vec<u8> = grid
3274 .iter_cols()
3275 .map(|col| col.max().unwrap())
3276 .copied()
3277 .collect();
3278
3279 assert_eq!(max_by_col, vec![4, 5, 6]);
3280
3281 let sum_by_col: Vec<u8> = grid.iter_cols().map(|row| row.sum()).collect();
3282 assert_eq!(sum_by_col, vec![1 + 4, 2 + 5, 3 + 6]);
3283 }
3284
3285 #[test]
3286 #[allow(clippy::redundant_closure_for_method_calls)]
3287 fn iter_cols_rev() {
3288 let grid: Grid<u8> = grid![[1,2,3][4,5,6]];
3289 let max_by_col: Vec<u8> = grid
3290 .iter_cols()
3291 .rev()
3292 .map(|col| col.max().unwrap())
3293 .copied()
3294 .collect();
3295
3296 assert_eq!(max_by_col, vec![6, 5, 4]);
3297
3298 let sum_by_col: Vec<u8> = grid.iter_cols().rev().map(|row| row.sum()).collect();
3299 assert_eq!(sum_by_col, vec![3 + 6, 2 + 5, 1 + 4]);
3300 }
3301
3302 #[test]
3303 fn iter_cols_exact_size() {
3304 let grid: Grid<u8> = grid![[1,2,3][4,5,6]];
3305 let mut col_iter = grid.iter_cols();
3306 assert_eq!(col_iter.len(), 3);
3307 assert!(col_iter.next().is_some());
3308 assert_eq!(col_iter.len(), 2);
3309 assert!(col_iter.next().is_some());
3310 assert_eq!(col_iter.len(), 1);
3311 assert!(col_iter.next().is_some());
3312 assert_eq!(col_iter.len(), 0);
3313 assert!(col_iter.next().is_none());
3314 }
3315
3316 #[test]
3317 fn remove_row() {
3318 let mut grid = grid![[1,2][3,4][5,6]];
3319 assert_eq![grid.remove_row(1), Some(vec![3, 4])];
3320 test_grid(&grid, 2, 2, Order::RowMajor, &[1, 2, 5, 6]);
3321 assert_eq![grid.remove_row(0), Some(vec![1, 2])];
3322 test_grid(&grid, 1, 2, Order::RowMajor, &[5, 6]);
3323 assert_eq![grid.remove_row(0), Some(vec![5, 6])];
3324 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
3325 assert_eq![grid.remove_row(0), None];
3326 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
3327 }
3328
3329 #[test]
3330 fn remove_row_out_of_bound() {
3331 let mut grid = grid![[1, 2][3, 4]];
3332 assert_eq![grid.remove_row(5), None];
3333 test_grid(&grid, 2, 2, Order::RowMajor, &[1, 2, 3, 4]);
3334 assert_eq![grid.remove_row(1), Some(vec![3, 4])];
3335 test_grid(&grid, 1, 2, Order::RowMajor, &[1, 2]);
3336 }
3337
3338 #[test]
3339 fn remove_row_column_major() {
3340 let mut grid = Grid::from_vec_with_order(vec![1, 3, 5, 2, 4, 6], 2, Order::ColumnMajor);
3341 assert_eq![grid.remove_row(1), Some(vec![3, 4])];
3342 test_grid(&grid, 2, 2, Order::ColumnMajor, &[1, 5, 2, 6]);
3343 assert_eq![grid.remove_row(0), Some(vec![1, 2])];
3344 test_grid(&grid, 1, 2, Order::ColumnMajor, &[5, 6]);
3345 assert_eq![grid.remove_row(0), Some(vec![5, 6])];
3346 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
3347 assert_eq![grid.remove_row(0), None];
3348 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
3349 }
3350
3351 #[test]
3352 fn remove_row_out_of_bound_column_major() {
3353 let mut grid = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
3354 assert_eq![grid.remove_row(5), None];
3355 test_grid(&grid, 2, 2, Order::ColumnMajor, &[1, 3, 2, 4]);
3356 assert_eq![grid.remove_row(1), Some(vec![3, 4])];
3357 test_grid(&grid, 1, 2, Order::ColumnMajor, &[1, 2]);
3358 }
3359
3360 #[test]
3361 fn remove_col() {
3362 let mut grid = grid![[1,2,3,4][5,6,7,8][9,10,11,12][13,14,15,16]];
3363 assert_eq![grid.remove_col(3), Some(vec![4, 8, 12, 16])];
3364 let expected = [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15];
3365 test_grid(&grid, 4, 3, Order::RowMajor, &expected);
3366 assert_eq![grid.remove_col(0), Some(vec![1, 5, 9, 13])];
3367 test_grid(&grid, 4, 2, Order::RowMajor, &[2, 3, 6, 7, 10, 11, 14, 15]);
3368 assert_eq![grid.remove_col(1), Some(vec![3, 7, 11, 15])];
3369 test_grid(&grid, 4, 1, Order::RowMajor, &[2, 6, 10, 14]);
3370 assert_eq![grid.remove_col(0), Some(vec![2, 6, 10, 14])];
3371 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
3372 assert_eq![grid.remove_col(0), None];
3373 test_grid(&grid, 0, 0, Order::RowMajor, &[]);
3374 }
3375
3376 #[test]
3377 fn remove_col_out_of_bound() {
3378 let mut grid = grid![[1, 2][3, 4]];
3379 assert_eq!(grid.remove_col(5), None);
3380 test_grid(&grid, 2, 2, Order::RowMajor, &[1, 2, 3, 4]);
3381 assert_eq!(grid.remove_col(1), Some(vec![2, 4]));
3382 test_grid(&grid, 2, 1, Order::RowMajor, &[1, 3]);
3383 }
3384
3385 #[test]
3386 fn remove_col_column_major() {
3387 let internal = vec![1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16];
3388 let mut grid = Grid::from_vec_with_order(internal, 4, Order::ColumnMajor);
3389 assert_eq![grid.remove_col(3), Some(vec![4, 8, 12, 16])];
3390 let expected = [1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15];
3391 test_grid(&grid, 4, 3, Order::ColumnMajor, &expected);
3392 assert_eq![grid.remove_col(0), Some(vec![1, 5, 9, 13])];
3393 let expected = [2, 6, 10, 14, 3, 7, 11, 15];
3394 test_grid(&grid, 4, 2, Order::ColumnMajor, &expected);
3395 assert_eq![grid.remove_col(1), Some(vec![3, 7, 11, 15])];
3396 test_grid(&grid, 4, 1, Order::ColumnMajor, &[2, 6, 10, 14]);
3397 assert_eq![grid.remove_col(0), Some(vec![2, 6, 10, 14])];
3398 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
3399 assert_eq![grid.remove_col(0), None];
3400 test_grid(&grid, 0, 0, Order::ColumnMajor, &[]);
3401 }
3402
3403 #[test]
3404 fn remove_col_out_of_bound_column_major() {
3405 let mut grid = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
3406 assert_eq!(grid.remove_col(5), None);
3407 test_grid(&grid, 2, 2, Order::ColumnMajor, &[1, 3, 2, 4]);
3408 assert_eq!(grid.remove_col(1), Some(vec![2, 4]));
3409 test_grid(&grid, 2, 1, Order::ColumnMajor, &[1, 3]);
3410 }
3411
3412 #[test]
3413 fn flip_cols() {
3414 let mut grid = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
3415 grid.flip_cols();
3416 test_grid(&grid, 2, 2, Order::RowMajor, &[2, 1, 4, 3]);
3417 }
3418
3419 #[test]
3420 fn flip_cols_column_major() {
3421 let mut grid = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
3422 grid.flip_cols();
3423 test_grid(&grid, 2, 2, Order::ColumnMajor, &[2, 4, 1, 3]);
3424 }
3425
3426 #[test]
3427 fn flip_rows() {
3428 let mut grid = Grid::from_vec_with_order(vec![1, 2, 3, 4], 2, Order::RowMajor);
3429 grid.flip_rows();
3430 test_grid(&grid, 2, 2, Order::RowMajor, &[3, 4, 1, 2]);
3431 }
3432
3433 #[test]
3434 fn flip_rows_column_major() {
3435 let mut grid = Grid::from_vec_with_order(vec![1, 3, 2, 4], 2, Order::ColumnMajor);
3436 grid.flip_rows();
3437 test_grid(&grid, 2, 2, Order::ColumnMajor, &[3, 1, 4, 2]);
3438 }
3439
3440 #[test]
3441 fn rotate_left() {
3442 let mut grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
3443 grid.rotate_left();
3444 test_grid(&grid, 3, 2, Order::ColumnMajor, &[3, 2, 1, 6, 5, 4]);
3445 assert_eq!(grid, grid![[3,6][2,5][1,4]]);
3446 }
3447
3448 #[test]
3449 fn rotate_left_column_major() {
3450 let mut grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
3451 grid.rotate_left();
3452 test_grid(&grid, 3, 2, Order::RowMajor, &[3, 6, 2, 5, 1, 4]);
3453 assert_eq!(grid, grid![[3,6][2,5][1,4]]);
3454 }
3455
3456 #[test]
3457 fn rotate_right() {
3458 let mut grid = Grid::from_vec_with_order(vec![1, 2, 3, 4, 5, 6], 3, Order::RowMajor);
3459 grid.rotate_right();
3460 test_grid(&grid, 3, 2, Order::ColumnMajor, &[4, 5, 6, 1, 2, 3]);
3461 assert_eq!(grid, grid![[4,1][5,2][6,3]]);
3462 }
3463
3464 #[test]
3465 fn rotate_right_column_major() {
3466 let mut grid = Grid::from_vec_with_order(vec![1, 4, 2, 5, 3, 6], 3, Order::ColumnMajor);
3467 grid.rotate_right();
3468 test_grid(&grid, 3, 2, Order::RowMajor, &[4, 1, 5, 2, 6, 3]);
3469 assert_eq!(grid, grid![[4,1][5,2][6,3]]);
3470 }
3471
3472 #[test]
3473 fn iter_cols_clone() {
3474 let grid = grid![[1,2,3][4,5,6]];
3475 let mut cols = grid.iter_cols().skip(1);
3476 let c3: u8 = cols.clone().nth(1).unwrap().sum();
3477 let c2: u8 = cols.next().unwrap().sum();
3478 assert_eq!(c2, 2 + 5);
3479 assert_eq!(c3, 3 + 6);
3480 }
3481
3482 #[test]
3483 fn iter_rows_clone() {
3484 let grid = grid![[1,2,3][4,5,6][7,8,9]];
3485 let mut rows = grid.iter_rows().skip(1);
3486 let r3: u8 = rows.clone().nth(1).unwrap().sum();
3487 let r2: u8 = rows.next().unwrap().sum();
3488 assert_eq!(r2, 4 + 5 + 6);
3489 assert_eq!(r3, 7 + 8 + 9);
3490 }
3491
3492 #[test]
3493 fn swap() {
3494 let mut grid = grid![[1,2][4,5]];
3495 grid.swap((0, 0), (1, 0));
3496 let end_grid = grid![[4,2][1,5]];
3497 assert_eq!(grid, end_grid);
3498 }
3499
3500 #[test]
3501 #[should_panic(expected = "grid index out of bounds: (2,0) out of (2,2)")]
3502 fn swap_out_of_bounds() {
3503 let mut grid = grid![[1,2][4,5]];
3504 grid.swap((0, 0), (2, 0));
3505 }
3506
3507 #[cfg(feature = "serde")]
3508 mod serde_tests {
3509 use super::*;
3510
3511 #[test]
3512 fn serialize() {
3513 let grid: Grid<u8> = grid![[1, 2][3, 4]];
3514 let s = serde_json::to_string(&grid).unwrap();
3515 assert_eq!(s, r#"{"cols":2,"data":[1,2,3,4],"order":"RowMajor"}"#);
3516 }
3517
3518 #[test]
3519 fn deserialize() {
3520 let s = "{ \"cols\": 2, \"data\": [1, 2, 3, 4] }";
3521 let grid: Grid<u8> = serde_json::from_str(&s).unwrap();
3522 assert_eq!(grid, grid![[1, 2][3, 4]]);
3523 }
3524
3525 #[test]
3526 fn deserialize_with_order() {
3527 let s = "{ \"cols\": 2, \"data\": [1, 3, 2, 4], \"order\": \"ColumnMajor\" }";
3528 let grid: Grid<u8> = serde_json::from_str(&s).unwrap();
3529 test_grid(&grid, 2, 2, Order::ColumnMajor, &[1, 3, 2, 4]);
3530 }
3531 }
3532}