grid/
lib.rs

1#![warn(clippy::all, clippy::pedantic)]
2/*!
3# Two Dimensional Grid
4Continuous growable 2D data structure.
5The purpose of this crate is to provide an universal data structure that is faster,
6uses less memory, and is easier to use than a naive `Vec<Vec<T>>` solution.
7
8This crate will always provide a 2D data structure. If you need three or more dimensions take a look at the
9[ndarray](https://docs.rs/ndarray/0.13.0/ndarray/) library. The `grid` crate is a container for all kind of data.
10If you need to perform matrix operations, you are better off with a linear algebra lib, such as
11[cgmath](https://docs.rs/cgmath/0.17.0/cgmath/) or [nalgebra](https://docs.rs/nalgebra/0.21.0/nalgebra/).
12No other dependencies except for the std lib are used.
13Most of the functions `std::Vec<T>` offer are also implemented in `grid` and slightly modified for a 2D data object.
14
15# Memory layout
16
17Similar to *C-like* arrays, `grid` uses a flat 1D `Vec<T>` data structure to have a continuous
18memory data layout. See also [this](https://stackoverflow.com/questions/17259877/1d-or-2d-array-whats-faster)
19explanation of why you should probably use a one-dimensional array approach.
20
21Note that this crate uses a [*row-major*](https://eli.thegreenplace.net/2015/memory-layout-of-multi-dimensional-arrays) memory layout by default.
22
23If you need a specific memory layout, please seek the `*_with_order` constructors. You should also take note that some transformation methods
24change the internal memory layout, like [`transpose`](Grid::transpose).
25
26This choice is important, because operations on rows are faster with a row-major memory layout.
27Likewise, operations on columns are faster with column-major memory layout.
28
29# Examples
30```
31use grid::*;
32let mut grid = grid![[1,2,3]
33                     [4,5,6]];
34assert_eq!(grid, Grid::from_vec(vec![1,2,3,4,5,6],3));
35assert_eq!(grid.get(0, 2), Some(&3));
36assert_eq!(grid[(1, 1)], 5);
37assert_eq!(grid.size(), (2, 3));
38grid.push_row(vec![7,8,9]);
39assert_eq!(grid, grid![[1,2,3][4,5,6][7,8,9]])
40 ```
41*/
42
43#![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/// Init a grid with values.
73///
74/// Each array within `[]` represents a row starting from top to button.
75///
76/// # Examples
77///
78/// In this example a grid of numbers from 1 to 9 is created:
79///
80///  
81/// ```
82/// use grid::grid;
83/// let grid = grid![[1, 2, 3]
84/// [4, 5, 6]
85/// [7, 8, 9]];
86/// assert_eq!(grid.size(), (3, 3))
87/// ```
88///
89/// Note that each row must be of the same length. The following example will not compile:
90///  
91/// ``` ignore
92/// use grid::grid;
93/// let grid = grid![[1, 2, 3]
94/// [4, 5] // This does not work!
95/// [7, 8, 9]];
96/// ```
97#[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/// Init a column-major grid with values.
130///
131/// Each array within `[]` represents a row starting from top to button.
132///
133/// # Examples
134///
135/// In this example a grid of numbers from 1 to 9 is created:
136///
137/// ```
138/// use grid::grid_cm;
139/// let grid = grid_cm![[1, 2, 3]
140/// [4, 5, 6]
141/// [7, 8, 9]];
142/// assert_eq!(grid.size(), (3, 3));
143/// assert_eq!(grid[(1, 1)], 5);
144/// ```
145///
146/// Note that each row must be of the same length. The following example will not compile:
147///
148/// ``` ignore
149/// use grid::grid_cm;
150/// let grid = grid_cm![[1, 2, 3]
151/// [4, 5] // This does not work!
152/// [7, 8, 9]];
153/// ```
154#[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/// Define the internal memory layout of the grid.
188#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
189#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
190pub enum Order {
191    /// The data is ordered row by row.
192    #[default]
193    RowMajor,
194
195    /// The data is ordered column by column.
196    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
208/// Stores elements of a certain type in a 2D grid structure.
209///
210/// Uses a rust `Vec<T>` type to reference the grid data on the heap.
211/// Also the internal memory layout as well as the number of
212/// rows and columns are stored in the grid data structure.
213///
214/// The size limit of a grid is `rows * cols < usize`.
215pub 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        // 3 is the number of fields in the struct.
310        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    /// Init a grid of size rows x columns with default values of the given type.
320    /// For example this will generate a 2x3 grid of zeros:
321    ///
322    /// ```
323    /// use grid::Grid;
324    /// let grid : Grid<u8> = Grid::new(2,3);
325    /// assert_eq!(grid[(0, 0)], 0);
326    /// ```
327    ///
328    /// If `rows == 0` or `cols == 0` the grid will be empty with no cols and rows.
329    ///
330    /// This create a grid with a row-major memory layout.
331    /// If you need a column-major one, see [`new_with_order`](Grid::new_with_order).
332    ///
333    /// # Panics
334    ///
335    /// Panics if `rows * cols > usize::MAX`.
336    #[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    /// Same as [`new`](Self::new) but with a specific [`Order`].
346    ///
347    /// # Panics
348    ///
349    /// Panics if `rows * cols > usize::MAX`.
350    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    /// Init a grid of size rows x columns with the given data element.
373    ///
374    /// If `rows == 0` or `cols == 0` the grid will be empty with no cols and rows.
375    ///
376    /// This create a grid with a row-major memory layout.
377    /// If you need a column-major one, see [`init_with_order`](Grid::init_with_order).
378    ///
379    /// # Panics
380    ///
381    /// Panics if `rows * cols > usize::MAX`.
382    #[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    /// Same as [`init`](Self::init) but with a specific [`Order`].
391    ///
392    /// # Panics
393    ///
394    /// Panics if `rows * cols > usize::MAX`.
395    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    /// Initialises an empty Grid with the capacity to store `cols * rows` elements.
416    /// Similar to `Vec::with_capacity`.
417    ///
418    /// # Panics
419    ///
420    /// Panics if `rows * cols > usize::MAX` or if `rows * cols * size_of::<T>() > isize::MAX`
421    pub fn with_capacity(rows: usize, cols: usize) -> Self {
422        Self::with_capacity_and_order(rows, cols, Order::default())
423    }
424
425    /// Same as [`with_capacity`](Self::with_capacity) but with a specified [`Order`]
426    ///
427    /// # Panics
428    ///
429    /// Panics if `rows * cols > usize::MAX` or if `rows * cols * size_of::<T>() > isize::MAX`
430    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    /// Returns a grid from a vector with a given column length.
440    /// The length of `vec` must be a multiple of `cols`.
441    ///
442    /// This create a grid with a row-major memory layout.
443    /// If you need a column-major one, see [`from_vec_with_order`](Grid::from_vec_with_order).
444    ///
445    /// For example:
446    ///
447    /// ```
448    /// use grid::Grid;
449    /// let grid = Grid::from_vec(vec![1,2,3,4,5,6], 3);
450    /// assert_eq!(grid.size(), (2, 3));
451    /// ```
452    ///
453    /// will create a grid with the following layout:
454    /// \[1,2,3\]
455    /// \[4,5,6\]
456    ///
457    /// This example will fail, because `vec.len()` is not a multiple of `cols`:
458    ///
459    /// ``` should_panic
460    /// use grid::Grid;
461    /// Grid::from_vec(vec![1,2,3,4,5], 3);
462    /// ```
463    ///
464    /// # Panics
465    ///
466    /// This panics if the vector length isn't a multiple of the number of columns.
467    #[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    /// Same as [`from_vec`](Self::from_vec) but with a specific [`Order`].
474    ///
475    /// # Panics
476    ///
477    /// This panics if the vector length isn't a multiple of the number of columns.
478    #[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    /// Returns the index of the coordinates in the internal vector.
506    #[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    /// Returns a reference to an element, without performing bound checks.
516    /// Generally not recommended, use with caution!
517    ///
518    /// # Safety
519    ///
520    /// Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.
521    #[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    /// Returns a mutable reference to an element, without performing bound checks.
529    /// Generally not recommended, use with caution!
530    ///
531    /// # Safety
532    ///
533    /// Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.
534    #[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    /// Access a certain element in the grid.
546    /// Returns `None` if an element beyond the grid bounds is tried to be accessed.
547    #[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    /// Mutable access to a certain element in the grid.
559    /// Returns `None` if an element beyond the grid bounds is tried to be accessed.
560    #[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    /// Returns the size of the grid as a two element tuple.
576    /// First element are the number of rows and the second the columns.
577    #[must_use]
578    pub fn size(&self) -> (usize, usize) {
579        (self.rows, self.cols)
580    }
581
582    /// Returns the number of rows of the grid.
583    #[must_use]
584    pub fn rows(&self) -> usize {
585        self.rows
586    }
587
588    /// Returns the number of columns of the grid.
589    #[must_use]
590    pub fn cols(&self) -> usize {
591        self.cols
592    }
593
594    /// Returns the internal memory layout of the grid.
595    #[must_use]
596    pub fn order(&self) -> Order {
597        self.order
598    }
599
600    /// Returns `true` if the grid contains no elements.
601    /// For example:
602    /// ```
603    /// use grid::*;
604    /// let grid : Grid<u8> = grid![];
605    /// assert!(grid.is_empty());
606    /// ```
607    #[must_use]
608    pub fn is_empty(&self) -> bool {
609        self.data.is_empty()
610    }
611
612    /// Clears the grid.
613    ///
614    /// This doesn't change the grid order.
615    pub fn clear(&mut self) {
616        self.rows = 0;
617        self.cols = 0;
618        self.data.clear();
619    }
620
621    /// Returns an iterator over the whole grid, starting from the first row and column.
622    ///
623    /// The iteration order is dependant on the internal memory layout.
624    /// If you need a specific order, see [`iter_rows`](Grid::iter_rows) or
625    /// [`iter_cols`](Grid::iter_cols).
626    ///
627    /// ```
628    /// use grid::*;
629    /// let grid: Grid<u8> = grid![[1,2][3,4]];
630    /// let mut iter = grid.iter();
631    /// assert_eq!(iter.next(), Some(&1));
632    /// assert_eq!(iter.next(), Some(&2));
633    /// assert_eq!(iter.next(), Some(&3));
634    /// assert_eq!(iter.next(), Some(&4));
635    /// assert_eq!(iter.next(), None);
636    /// ```
637    pub fn iter(&self) -> Iter<T> {
638        self.data.iter()
639    }
640
641    /// Returns an mutable iterator over the whole grid that allows modifying each value.
642    ///
643    /// The iteration order is dependant on the internal memory layout.
644    ///
645    /// ```
646    /// use grid::*;
647    /// let mut grid: Grid<u8> = grid![[1,2][3,4]];
648    /// let mut iter = grid.iter_mut();
649    /// let next = iter.next();
650    /// assert_eq!(next, Some(&mut 1));
651    /// *next.unwrap() = 10;
652    /// ```
653    pub fn iter_mut(&mut self) -> IterMut<T> {
654        self.data.iter_mut()
655    }
656
657    /// Returns an iterator over a column.
658    ///
659    /// # Examples
660    ///
661    /// ```
662    /// use grid::*;
663    /// let grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]];
664    /// let mut col_iter = grid.iter_col(1);
665    /// assert_eq!(col_iter.next(), Some(&2));
666    /// assert_eq!(col_iter.next(), Some(&4));
667    /// assert_eq!(col_iter.next(), None);
668    /// ```
669    ///
670    /// # Performance
671    ///
672    /// This method will be significantly slower if the grid uses a row-major memory layout,
673    /// which is the default.
674    ///
675    /// # Panics
676    ///
677    /// Panics if the col index is out of bounds.
678    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    /// Returns a mutable iterator over a column.
695    ///
696    /// # Examples
697    ///
698    /// ```
699    /// use grid::*;
700    /// let mut grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]];
701    /// let mut col_iter = grid.iter_col_mut(1);
702    /// let next = col_iter.next();
703    /// assert_eq!(next, Some(&mut 2));
704    /// *next.unwrap() = 10;
705    /// assert_eq!(grid[(0, 1)], 10);
706    /// ```
707    ///
708    /// # Performance
709    ///
710    /// This method will be significantly slower if the grid uses a row-major memory layout,
711    /// which is the default.
712    ///
713    /// # Panics
714    ///
715    /// Panics if the col index is out of bounds.
716    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    /// Returns an iterator over a row.
733    ///
734    /// # Examples
735    ///
736    /// ```
737    /// use grid::*;
738    /// let grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]];
739    /// let mut col_iter = grid.iter_row(1);
740    /// assert_eq!(col_iter.next(), Some(&3));
741    /// assert_eq!(col_iter.next(), Some(&4));
742    /// assert_eq!(col_iter.next(), Some(&5));
743    /// assert_eq!(col_iter.next(), None);
744    /// ```
745    ///
746    /// # Performance
747    ///
748    /// This method will be significantly slower if the grid uses a column-major memory layout.
749    ///
750    /// # Panics
751    ///
752    /// Panics if the row index is out of bounds.
753    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    /// Returns a mutable iterator over a row.
770    ///
771    /// # Examples
772    ///
773    /// ```
774    /// use grid::*;
775    /// let mut grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]];
776    /// let mut col_iter = grid.iter_row_mut(1);
777    /// let next = col_iter.next();
778    /// *next.unwrap() = 10;
779    /// assert_eq!(grid[(1, 0)], 10);
780    /// ```
781    ///
782    /// # Performance
783    ///
784    /// This method will be significantly slower if the grid uses a column-major memory layout.
785    ///
786    /// # Panics
787    ///
788    /// Panics if the row index is out of bounds.
789    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    /// Traverse the grid with row and column indexes.
806    ///
807    /// The iteration order is dependent on the internal memory layout,
808    /// but the indexes will be accurate either way.
809    ///
810    /// # Examples
811    ///
812    /// ```
813    /// use grid::*;
814    /// let grid: Grid<u8> = grid![[1,2][3,4]];
815    /// let mut iter = grid.indexed_iter();
816    /// assert_eq!(iter.next(), Some(((0, 0), &1)));
817    /// ```
818    ///
819    /// Or simply unpack in a `for` loop:
820    ///
821    /// ```
822    /// use grid::*;
823    /// let grid: Grid<u8> = grid![[1,2][3,4]];
824    /// for ((row, col), i) in grid.indexed_iter() {
825    ///     println!("value at row {row} and column {col} is: {i}");
826    /// }
827    /// ```
828    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    /// Traverse the grid with row and column indexes,
839    /// and mutable access to each element.
840    ///
841    /// The iteration order is dependent on the internal memory layout,
842    /// but the indexes will be accurate either way.
843    ///
844    /// # Examples
845    ///
846    /// ```
847    /// use grid::*;
848    /// let mut grid: Grid<u8> = grid![[1,2][3,4]];
849    /// let mut iter = grid.indexed_iter_mut();
850    /// assert_eq!(iter.next(), Some(((0, 0), &mut 1)));
851    /// ```
852    ///
853    /// Or simply unpack in a `for` loop:
854    ///
855    /// ```
856    /// use grid::*;
857    /// let mut grid: Grid<u8> = grid![[1,2][3,4]];
858    /// for ((row, col), i) in grid.indexed_iter_mut() {
859    ///     *i += 1;
860    ///     println!("value at row {row} and column {col} is: {i}");
861    /// }
862    ///
863    /// assert_eq!(grid[(0, 0)], 2);
864    /// assert_eq!(grid[(0, 1)], 3);
865    /// assert_eq!(grid[(1, 0)], 4);
866    /// assert_eq!(grid[(1, 1)], 5);
867    /// ```
868    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    /// Add a new row to the grid.
883    ///
884    /// # Examples
885    ///
886    /// ```
887    /// use grid::*;
888    /// let mut grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]];
889    /// let row = vec![6,7,8];
890    /// grid.push_row(row);
891    /// assert_eq!(grid.rows(), 3);
892    /// assert_eq!(grid[(2, 0)], 6);
893    /// assert_eq!(grid[(2, 1)], 7);
894    /// assert_eq!(grid[(2, 2)], 8);
895    /// ```
896    ///
897    /// Can also be used to init an empty grid:
898    ///
899    /// ```
900    /// use grid::*;
901    /// let mut grid: Grid<u8> = grid![];
902    /// let row = vec![1,2,3];
903    /// grid.push_row(row);
904    /// assert_eq!(grid.size(), (1, 3));
905    /// ```
906    ///
907    /// # Performance
908    ///
909    /// This method will be significantly slower if the grid uses a column-major memory layout.
910    ///
911    /// # Panics
912    ///
913    /// Panics if:
914    ///  - the grid is not empty and `row.len() != grid.cols()`
915    ///  - `row.len() == 0`
916    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    /// Add a new column to the grid.
938    ///
939    /// # Examples
940    ///
941    /// ```
942    /// use grid::*;
943    /// let mut grid: Grid<u8> = grid![[1, 2, 3][3, 4, 5]];
944    /// let col = vec![4,6];
945    /// grid.push_col(col);
946    /// assert_eq!(grid.cols(), 4);
947    /// assert_eq!(grid[(0, 3)], 4);
948    /// assert_eq!(grid[(1, 3)], 6);
949    /// ```
950    ///
951    /// Can also be used to init an empty grid:
952    ///
953    /// ```
954    /// use grid::*;
955    /// let mut grid: Grid<u8> = grid![];
956    /// let col = vec![1,2,3];
957    /// grid.push_col(col);
958    /// assert_eq!(grid.size(), (3, 1));
959    /// ```
960    ///
961    /// # Performance
962    ///
963    /// This method will be significantly slower if the grid uses a row-major memory layout,
964    /// which is the default.
965    ///
966    /// # Panics
967    ///
968    /// Panics if:
969    ///  - the grid is not empty and `col.len() != grid.rows()`
970    ///  - `col.len() == 0`
971    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    /// Removes the last row from a grid and returns it, or None if it is empty.
993    ///
994    /// # Examples
995    /// ```
996    /// use grid::*;
997    /// let mut grid = grid![[1,2,3][4,5,6]];
998    /// assert_eq![grid.pop_row(), Some(vec![4,5,6])];
999    /// assert_eq![grid.pop_row(), Some(vec![1,2,3])];
1000    /// assert_eq![grid.pop_row(), None];
1001    /// ```
1002    ///
1003    /// # Performance
1004    ///
1005    /// This method will be significantly slower if the grid uses a column-major memory layout.
1006    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    /// Remove a Row at the index and return a vector of it.
1025    ///
1026    /// # Examples
1027    /// ```
1028    /// use grid::*;
1029    /// let mut grid = grid![[1,2][3,4][5,6]];
1030    /// assert_eq![grid.remove_row(1), Some(vec![3,4])];   
1031    /// assert_eq![grid.remove_row(0), Some(vec![1,2])];
1032    /// assert_eq![grid.remove_row(0), Some(vec![5,6])];
1033    /// assert_eq![grid.remove_row(0), None];
1034    /// ```
1035    ///
1036    /// # Performance
1037    ///
1038    /// This method will be significantly slower if the grid uses a column-major memory layout.
1039    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    /// Removes the last column from a grid and returns it, or None if it is empty.
1065    ///
1066    /// Note that this operation is much slower than the `pop_row()` because the memory layout
1067    /// of `Grid` is row-major and removing a column requires a lot of move operations.
1068    ///
1069    /// # Examples
1070    /// ```
1071    /// use grid::*;
1072    /// let mut grid = grid![[1,2,3][4,5,6]];
1073    /// assert_eq![grid.pop_col(), Some(vec![3,6])];
1074    /// assert_eq![grid.pop_col(), Some(vec![2,5])];
1075    /// assert_eq![grid.pop_col(), Some(vec![1,4])];
1076    /// assert_eq![grid.pop_col(), None];
1077    /// ```
1078    ///
1079    /// # Performance
1080    ///
1081    /// This method will be significantly slower if the grid uses a row-major memory layout,
1082    /// which is the default.
1083    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    /// Remove a column at the index and return a vector of it.
1102    ///
1103    /// # Examples
1104    /// ```
1105    /// use grid::*;
1106    /// let mut grid = grid![[1,2,3,4][5,6,7,8][9,10,11,12][13,14,15,16]];
1107    /// assert_eq![grid.remove_col(3), Some(vec![4,8,12,16])];
1108    /// assert_eq![grid.remove_col(0), Some(vec![1,5,9,13])];
1109    /// assert_eq![grid.remove_col(1), Some(vec![3,7,11,15])];
1110    /// assert_eq![grid.remove_col(0), Some(vec![2,6,10,14])];
1111    /// assert_eq![grid.remove_col(0), None];
1112    /// ```
1113    ///
1114    /// # Performance
1115    ///
1116    /// This method will be significantly slower if the grid uses a row-major memory layout,
1117    /// which is the default.
1118    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    /// Insert a new row at the index and shifts all rows after down.
1144    ///
1145    /// # Examples
1146    /// ```
1147    /// use grid::*;
1148    /// let mut grid = grid![[1,2,3][4,5,6]];
1149    /// grid.insert_row(1, vec![7,8,9]);
1150    /// assert_eq!(grid, grid![[1,2,3][7,8,9][4,5,6]]);
1151    /// ```
1152    ///
1153    /// # Performance
1154    ///
1155    /// This method will be significantly slower if the grid uses a column-major memory layout.
1156    ///
1157    /// # Panics
1158    ///
1159    /// Panics if:
1160    /// - the grid is not empty and `row.len() != grid.cols()`.
1161    /// - the index is greater than the number of rows
1162    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    /// Insert a new column at the index.
1193    ///
1194    /// Important! Insertion of columns is a lot slower than the lines insertion.
1195    /// This is because of the memory layout of the grid data structure.
1196    ///
1197    /// # Examples
1198    /// ```
1199    /// use grid::*;
1200    /// let mut grid = grid![[1,2,3][4,5,6]];
1201    /// grid.insert_col(1, vec![9,9]);
1202    /// assert_eq!(grid, grid![[1,9,2,3][4,9,5,6]])
1203    /// ```
1204    ///
1205    /// # Performance
1206    ///
1207    /// This method will be significantly slower if the grid uses a row-major memory layout,
1208    /// which is the default.
1209    ///
1210    /// # Panics
1211    ///
1212    /// Panics if:
1213    /// - the grid is not empty and `col.len() != grid.rows()`.
1214    /// - the index is greater than the number of columns
1215    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    /// Returns a reference to the internal data structure of the grid.
1246    ///
1247    /// The order of the elements depends on the internal memory layout, which is
1248    /// row-major by default.
1249    ///
1250    /// # Examples
1251    /// ```
1252    /// use grid::*;
1253    /// let grid = grid![[1,2,3][4,5,6]];
1254    /// let flat = grid.flatten();
1255    /// assert_eq!(flat, &vec![1,2,3,4,5,6]);
1256    /// ```
1257    #[must_use]
1258    pub fn flatten(&self) -> &Vec<T> {
1259        &self.data
1260    }
1261
1262    /// Converts self into a vector without clones or allocation.
1263    ///
1264    /// The order of the elements depends on the internal memory layout, which is
1265    /// row-major by default.
1266    #[must_use]
1267    pub fn into_vec(self) -> Vec<T> {
1268        self.data
1269    }
1270
1271    /// Transpose the grid so that columns become rows in new grid.
1272    ///
1273    /// This method changes the internal memory layout.
1274    pub fn transpose(&mut self) {
1275        self.order = self.order.counterpart();
1276        core::mem::swap(&mut self.rows, &mut self.cols);
1277    }
1278
1279    /// Flip (or mirrors) the columns.
1280    ///
1281    /// # Examples
1282    ///
1283    /// ```
1284    /// use grid::*;
1285    /// let mut grid = grid![[1,2,3][4,5,6]];
1286    /// grid.flip_cols();
1287    /// assert_eq!(grid, grid![[3,2,1][6,5,4]])
1288    /// ```
1289    ///
1290    /// # Performance
1291    ///
1292    /// This method will be significantly slower if the grid uses a column-major memory layout.
1293    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    /// Flip (or mirrors) the rows.
1314    ///
1315    /// # Examples
1316    ///
1317    /// ```
1318    /// use grid::*;
1319    /// let mut grid = grid![[1,2,3][4,5,6]];
1320    /// grid.flip_rows();
1321    /// assert_eq!(grid, grid![[4,5,6][1,2,3]])
1322    /// ```
1323    ///
1324    /// # Performance
1325    ///
1326    /// This method will be significantly slower if the grid uses a row-major memory layout,
1327    /// which is the default.
1328    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    /// Rotate the grid 90° counter-clockwise.
1349    ///
1350    /// This method changes the internal memory layout.
1351    ///
1352    /// # Examples
1353    ///
1354    /// ```
1355    /// use grid::*;
1356    /// let mut grid = grid![[1,2][3,4]];
1357    /// grid.rotate_left();
1358    /// assert_eq!(grid, grid![[2,4][1,3]]);
1359    /// ```
1360    ///
1361    /// # Performance
1362    ///
1363    /// This method will be significantly slower if the grid initialy uses a column-major memory layout,
1364    /// which is the default.
1365    pub fn rotate_left(&mut self) {
1366        self.transpose();
1367        self.flip_rows();
1368    }
1369
1370    /// Rotate the grid 90° clockwise.
1371    ///
1372    /// This method changes the internal memory layout.
1373    ///
1374    /// # Examples
1375    ///
1376    /// ```
1377    /// use grid::*;
1378    /// let mut grid = grid![[1,2][3,4]];
1379    /// grid.rotate_right();
1380    /// assert_eq!(grid, grid![[3,1][4,2]]);
1381    /// ```
1382    ///
1383    /// # Performance
1384    ///
1385    /// This method will be significantly slower if the grid initialy uses a row-major memory layout,
1386    /// which is the default.
1387    pub fn rotate_right(&mut self) {
1388        self.transpose();
1389        self.flip_cols();
1390    }
1391
1392    /// Rotate the grid 180°.
1393    ///
1394    /// This method **doesn't** change the internal memory layout.
1395    ///
1396    /// # Examples
1397    ///
1398    /// ```
1399    /// use grid::*;
1400    /// let mut grid = grid![[1,2,3][4,5,6]];
1401    /// grid.rotate_half();
1402    /// assert_eq!(grid, grid![[6,5,4][3,2,1]]);
1403    /// ```
1404    ///
1405    /// # Performance
1406    ///
1407    /// The performances of this method is not affected by the internal memory layout.
1408    pub fn rotate_half(&mut self) {
1409        self.data.reverse();
1410    }
1411
1412    /// Fills the grid with elements by cloning `value`.
1413    ///
1414    /// # Examples
1415    ///
1416    /// ```
1417    /// use grid::*;
1418    /// let mut grid = grid![[1,2,3][4,5,6]];
1419    /// grid.fill(7);
1420    /// assert_eq!(grid, grid![[7,7,7][7,7,7]]);
1421    /// ```
1422    pub fn fill(&mut self, value: T)
1423    where
1424        T: Clone,
1425    {
1426        self.data.fill(value);
1427    }
1428
1429    /// Fills the grid with elements returned by calling a closure repeatedly.
1430    ///
1431    /// This method uses a closure to create new values. If you'd rather
1432    /// [`Clone`] a given value, use [`fill`]. If you want to use the [`Default`]
1433    /// trait to generate values, you can pass [`Default::default`] as the
1434    /// argument.
1435    ///
1436    /// [`fill`]: Grid::fill
1437    ///
1438    /// # Examples
1439    ///
1440    /// ```
1441    /// use grid::*;
1442    /// let mut grid = grid![[1,2,3][4,5,6]];
1443    /// grid.fill_with(Default::default);
1444    /// assert_eq!(grid, grid![[0,0,0][0,0,0]]);
1445    /// ```
1446    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    /// Iterate over the rows of the grid. Each time an iterator over a single
1454    /// row is returned.
1455    ///
1456    /// An item in this iterator is equal to a call to `Grid.iter_row(row_index)`
1457    /// of the corresponding row.
1458    ///
1459    /// # Examples
1460    ///
1461    /// ```
1462    /// use grid::*;
1463    /// let mut grid = grid![[1,2,3][4,5,6]];
1464    /// let sum_by_row: Vec<u8> = grid.iter_rows().map(|row| row.sum()).collect();
1465    /// assert_eq!(sum_by_row, vec![1+2+3, 4+5+6])
1466    /// ```
1467    #[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    /// Iterate over the columns of the grid. Each time an iterator over a single
1477    /// column is returned.
1478    ///
1479    /// An item in this iterator is equal to a call to `Grid.iter_col(col_index)`
1480    /// of the corresponding column.
1481    ///
1482    /// # Examples
1483    ///
1484    /// ```
1485    /// use grid::*;
1486    /// let mut grid = grid![[1,2,3][4,5,6]];
1487    /// let sum_by_col: Vec<u8> = grid.iter_cols().map(|col| col.sum()).collect();
1488    /// assert_eq!(sum_by_col, vec![1+4, 2+5, 3+6])
1489    /// ```
1490    #[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    /// Swaps two elements in the Grid.
1500    /// Similar to `Vec::swap()`.
1501    ///
1502    /// # Panics
1503    ///
1504    /// Panics if either index is out of bounds.
1505    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                /*
1595                    WARNING
1596
1597                    Compound types becoming enormous as the entire `fmt::Debug` width is applied to each item individually.
1598                    For tuples and structs define padding and precision arguments manually to improve readability.
1599                */
1600                let width = f.width().unwrap_or_else(|| {
1601                    // Conditionally calculate the longest item by default.
1602                    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        // doesn't impl Default
3079        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        // doesn't impl Default
3089        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        // doesn't impl Default
3101        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}