pub struct Vecgrid<T> { /* private fields */ }
Expand description
A dynamically sized two-dimensional vec.
Implementations§
source§impl<T> Vecgrid<T>
impl<T> Vecgrid<T>
sourcepub fn from_rows(rows: Vec<Vec<T>>) -> Result<Self, Error>
pub fn from_rows(rows: Vec<Vec<T>>) -> Result<Self, Error>
Creates a new Vecgrid
from a Vec
of rows, each of which is a
Vec
of elements.
Returns an error if the rows are not all the same size.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid[(1, 2)], 6);
assert_eq!(vecgrid.as_rows(), rows);
sourcepub fn from_columns(columns: Vec<Vec<T>>) -> Result<Self, Error>where
T: Clone,
pub fn from_columns(columns: Vec<Vec<T>>) -> Result<Self, Error>where
T: Clone,
Creates a new Vecgrid
from a Vec
of columns, each of which
contains a Vec
of elements.
Returns an error if the columns are not all the same size.
Examples
let columns = vec![vec![1, 4], vec![2, 5], vec![3, 6]];
let vecgrid = Vecgrid::from_columns(columns.clone())?;
assert_eq!(vecgrid[(1, 2)], 6);
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);
sourcepub fn from_row_major(
elements: Vec<T>,
num_rows: usize,
num_columns: usize
) -> Result<Self, Error>
pub fn from_row_major(
elements: Vec<T>,
num_rows: usize,
num_columns: usize
) -> Result<Self, Error>
Creates a new Vecgrid
from the given flat Vec
in row major
order.
Returns an error if the number of elements in elements
is not the
product of num_rows
and num_columns
, i.e. the dimensions do not
match.
Examples
let row_major = vec![1, 2, 3, 4, 5, 6];
let vecgrid = Vecgrid::from_row_major(row_major, 2, 3)?;
assert_eq!(vecgrid[(1, 2)], 6);
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);
sourcepub fn from_column_major(
elements: Vec<T>,
num_rows: usize,
num_columns: usize
) -> Result<Self, Error>where
T: Clone,
pub fn from_column_major(
elements: Vec<T>,
num_rows: usize,
num_columns: usize
) -> Result<Self, Error>where
T: Clone,
Creates a new Vecgrid
from the given flat Vec
in column major
order.
Return an error if the number of elements in elements
is not the
product of num_rows
and num_columns
, i.e. the dimensions do not
match.
Examples
let column_major = vec![1, 4, 2, 5, 3, 6];
let vecgrid = Vecgrid::from_column_major(column_major, 2, 3)?;
assert_eq!(vecgrid[(1, 2)], 6);
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);
sourcepub fn filled_with(element: T, num_rows: usize, num_columns: usize) -> Selfwhere
T: Clone,
pub fn filled_with(element: T, num_rows: usize, num_columns: usize) -> Selfwhere
T: Clone,
sourcepub fn filled_by_row_major<F>(
generator: F,
num_rows: usize,
num_columns: usize
) -> Selfwhere
F: FnMut() -> T,
pub fn filled_by_row_major<F>(
generator: F,
num_rows: usize,
num_columns: usize
) -> Selfwhere
F: FnMut() -> T,
Creates a new Vecgrid
with the specified number of rows and columns
and fills each element with the result of calling the given
function. The function is called once for every location going in
row major order.
Examples
let mut counter = 1;
let increment = || {
let tmp = counter;
counter += 1;
tmp
};
let vecgrid = Vecgrid::filled_by_row_major(increment, 2, 3);
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);
sourcepub fn filled_by_column_major<F>(
generator: F,
num_rows: usize,
num_columns: usize
) -> Selfwhere
F: FnMut() -> T,
T: Clone,
pub fn filled_by_column_major<F>(
generator: F,
num_rows: usize,
num_columns: usize
) -> Selfwhere
F: FnMut() -> T,
T: Clone,
Creates a new Vecgrid
with the specified number of rows and columns
and fills each element with the result of calling the given
function. The function is called once for every location going in
column major order.
Examples
let mut counter = 1;
let increment = || {
let tmp = counter;
counter += 1;
tmp
};
let vecgrid = Vecgrid::filled_by_column_major(increment, 2, 3);
assert_eq!(vecgrid.as_columns(), vec![vec![1, 2], vec![3, 4], vec![5, 6]]);
sourcepub fn from_iter_row_major<I>(
iterator: I,
num_rows: usize,
num_columns: usize
) -> Result<Self, Error>where
I: Iterator<Item = T>,
pub fn from_iter_row_major<I>(
iterator: I,
num_rows: usize,
num_columns: usize
) -> Result<Self, Error>where
I: Iterator<Item = T>,
Creates a new Vecgrid
with the specified number of rows and columns
and fills each element with the elements produced from the provided
iterator. If the iterator produces more than enough elements, the
remaining are unused. Returns an error if the iterator does not produce
enough elements.
The elements are inserted into the vecgrid in row major order.
Examples
let iterator = (1..);
let vecgrid = Vecgrid::from_iter_row_major(iterator, 2, 3)?;
assert_eq!(vecgrid.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);
sourcepub fn from_iter_column_major<I>(
iterator: I,
num_rows: usize,
num_columns: usize
) -> Result<Self, Error>where
I: Iterator<Item = T>,
T: Clone,
pub fn from_iter_column_major<I>(
iterator: I,
num_rows: usize,
num_columns: usize
) -> Result<Self, Error>where
I: Iterator<Item = T>,
T: Clone,
Creates a new Vecgrid
with the specified number of rows and columns
and fills each element with the elements produced from the provided
iterator. If the iterator produces more than enough elements, the
remaining are unused. Returns an error if the iterator does not produce
enough elements.
The elements are inserted into the vecgrid in column major order.
Examples
let iterator = (1..);
let vecgrid = Vecgrid::from_iter_column_major(iterator, 2, 3)?;
assert_eq!(vecgrid.as_rows(), vec![vec![1, 3, 5], vec![2, 4, 6]]);
sourcepub fn num_columns(&self) -> usize
pub fn num_columns(&self) -> usize
The number of columns.
sourcepub fn num_elements(&self) -> usize
pub fn num_elements(&self) -> usize
The total number of elements, i.e. the product of num_rows
and
num_columns
.
sourcepub fn column_len(&self) -> usize
pub fn column_len(&self) -> usize
The number of elements in each column, i.e. the number of rows.
sourcepub fn get_row_major(&self, index: usize) -> Option<&T>
pub fn get_row_major(&self, index: usize) -> Option<&T>
Returns a reference to the element at the given index in row major
order. Returns None
if the index is out of bounds.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.get_row_major(2), Some(&3));
assert_eq!(vecgrid.get_row_major(4), Some(&5));
assert_eq!(vecgrid.get_row_major(10), None);
sourcepub fn get_column_major(&self, index: usize) -> Option<&T>
pub fn get_column_major(&self, index: usize) -> Option<&T>
Returns a reference to the element at the given index in column major
order. Returns None
if the index is out of bounds.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.get_column_major(2), Some(&2));
assert_eq!(vecgrid.get_column_major(4), Some(&3));
assert_eq!(vecgrid.get_column_major(10), None);
sourcepub fn get_mut(&mut self, row: usize, column: usize) -> Option<&mut T>
pub fn get_mut(&mut self, row: usize, column: usize) -> Option<&mut T>
Returns a mutable reference to the element at the given row
and
column
if the index is in bounds (wrapped in Some
). Returns
None
if the index is out of bounds.
Examples
let mut vecgrid = Vecgrid::filled_with(42, 2, 3);
assert_eq!(vecgrid.get_mut(0, 0), Some(&mut 42));
assert_eq!(vecgrid.get_mut(10, 10), None);
vecgrid.get_mut(0, 0).map(|x| *x = 100);
assert_eq!(vecgrid.get(0, 0), Some(&100));
vecgrid.get_mut(10, 10).map(|x| *x = 200);
assert_eq!(vecgrid.get(10, 10), None);
sourcepub fn get_mut_row_major(&mut self, index: usize) -> Option<&mut T>
pub fn get_mut_row_major(&mut self, index: usize) -> Option<&mut T>
Returns a mutable reference to the element at the given index in row
major order. Returns None
if the index is out of bounds.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.get_mut_row_major(1), Some(&mut 2));
assert_eq!(vecgrid.get_mut_row_major(10), None);
vecgrid.get_mut_row_major(3).map(|x| *x = 100);
assert_eq!(vecgrid.get(1, 0), Some(&100));
vecgrid.get_mut_row_major(10).map(|x| *x = 200);
assert_eq!(vecgrid.get(10, 10), None);
sourcepub fn get_mut_column_major(&mut self, index: usize) -> Option<&mut T>
pub fn get_mut_column_major(&mut self, index: usize) -> Option<&mut T>
Returns a mutable reference to the element at the given index in row
major order. Returns None
if the index is out of bounds.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.get_mut_column_major(1), Some(&mut 4));
assert_eq!(vecgrid.get_mut_column_major(10), None);
vecgrid.get_mut_column_major(4).map(|x| *x = 100);
assert_eq!(vecgrid.get(0, 2), Some(&100));
vecgrid.get_mut_column_major(10).map(|x| *x = 200);
assert_eq!(vecgrid.get(10, 10), None);
sourcepub fn set(&mut self, row: usize, column: usize, element: T) -> Result<(), Error>
pub fn set(&mut self, row: usize, column: usize, element: T) -> Result<(), Error>
Changes the element at given row
and column
to element
. Returns
Ok(())
if the indices were in bounds and returns an Err
otherwise.
Examples
let mut vecgrid = Vecgrid::filled_with(42, 2, 3);
let result = vecgrid.set(0, 0, 100);
assert_eq!(result, Ok(()));
assert_eq!(vecgrid.get(0, 0), Some(&100));
let result = vecgrid.set(10, 20, 200);
assert_eq!(result, Err(Error::IndicesOutOfBounds(10, 20)));
sourcepub fn set_row_major(&mut self, index: usize, element: T) -> Result<(), Error>
pub fn set_row_major(&mut self, index: usize, element: T) -> Result<(), Error>
Changes the element at the given index
to element
, in row major
order. Returns Ok(())
if the index is in bounds and returns an
Err
otherwise.
Examples
let mut vecgrid = Vecgrid::filled_with(42, 2, 3);
let result = vecgrid.set_row_major(4, 100);
assert_eq!(result, Ok(()));
assert_eq!(vecgrid.get(1, 1), Some(&100));
let result = vecgrid.set_row_major(10, 200);
assert_eq!(result, Err(Error::IndexOutOfBounds(10)));
sourcepub fn set_column_major(&mut self, index: usize, element: T) -> Result<(), Error>
pub fn set_column_major(&mut self, index: usize, element: T) -> Result<(), Error>
Changes the element at the given index
to element
, in column major
order. Returns Ok(())
if the index is in bounds and returns an
Err
otherwise.
Examples
let mut vecgrid = Vecgrid::filled_with(42, 2, 3);
let result = vecgrid.set_column_major(4, 100);
assert_eq!(result, Ok(()));
assert_eq!(vecgrid.get(0, 2), Some(&100));
let result = vecgrid.set_column_major(10, 200);
assert_eq!(result, Err(Error::IndexOutOfBounds(10)));
sourcepub fn elements_row_major_iter(
&self
) -> impl DoubleEndedIterator<Item = &T> + Clone
pub fn elements_row_major_iter(
&self
) -> impl DoubleEndedIterator<Item = &T> + Clone
Returns an Iterator
over references to all elements in row major
order.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let elements = vec![1, 2, 3, 4, 5, 6];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let row_major = vecgrid.elements_row_major_iter();
assert_eq!(row_major.cloned().collect::<Vec<_>>(), elements);
sourcepub fn elements_row_major_iter_mut(
&mut self
) -> impl DoubleEndedIterator<Item = &mut T>
pub fn elements_row_major_iter_mut(
&mut self
) -> impl DoubleEndedIterator<Item = &mut T>
Returns an Iterator
over mutable references to all elements in row major
order.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let elements = vec![1, 2, 3, 4, 5, 6];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
let row_major = vecgrid.elements_row_major_iter_mut();
for (i, val) in row_major
.map(|val| {
*val += 1;
val
})
.enumerate()
{
assert_eq!(*val, elements[i] + 1);
}
sourcepub fn elements_column_major_iter(
&self
) -> impl DoubleEndedIterator<Item = &T> + Clone
pub fn elements_column_major_iter(
&self
) -> impl DoubleEndedIterator<Item = &T> + Clone
Returns an Iterator
over references to all elements in column major
order.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let elements = vec![1, 4, 2, 5, 3, 6];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let column_major = vecgrid.elements_column_major_iter();
assert_eq!(column_major.cloned().collect::<Vec<_>>(), elements);
sourcepub fn elements_column_major_iter_mut(
&mut self
) -> impl DoubleEndedIterator<Item = &mut T>
pub fn elements_column_major_iter_mut(
&mut self
) -> impl DoubleEndedIterator<Item = &mut T>
Returns an Iterator
over mutable references to all elements in column major
order.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
let elements = vec![1, 4, 7, 2, 5, 8, 3, 6, 9];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
let column_major = vecgrid.elements_column_major_iter_mut();
for (i, val) in column_major
.map(|val| {
*val += 1;
val
})
.enumerate()
{
assert_eq!(*val, elements[i] + 1);
}
sourcepub fn row_iter(
&self,
row_index: usize
) -> Result<impl DoubleEndedIterator<Item = &T>, Error>
pub fn row_iter(
&self,
row_index: usize
) -> Result<impl DoubleEndedIterator<Item = &T>, Error>
Returns an Iterator
over references to all elements in the given
row. Returns an error if the index is out of bounds.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let mut row_iter = vecgrid.row_iter(1)?;
assert_eq!(row_iter.next(), Some(&4));
assert_eq!(row_iter.next(), Some(&5));
assert_eq!(row_iter.next(), Some(&6));
assert_eq!(row_iter.next(), None);
sourcepub fn row_iter_mut(
&mut self,
row_index: usize
) -> Result<impl DoubleEndedIterator<Item = &mut T>, Error>
pub fn row_iter_mut(
&mut self,
row_index: usize
) -> Result<impl DoubleEndedIterator<Item = &mut T>, Error>
Returns an Iterator
over mutable references to all elements in the given
row. Returns an error if the index is out of bounds.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
let mut row_iter = vecgrid.row_iter_mut(1)?;
assert_eq!(row_iter.next(), Some(&mut 4));
assert_eq!(row_iter.next(), Some(&mut 5));
assert_eq!(row_iter.next(), Some(&mut 6));
assert_eq!(row_iter.next(), None);
sourcepub fn column_iter(
&self,
column_index: usize
) -> Result<impl DoubleEndedIterator<Item = &T>, Error>
pub fn column_iter(
&self,
column_index: usize
) -> Result<impl DoubleEndedIterator<Item = &T>, Error>
Returns an Iterator
over references to all elements in the given
column. Returns an error if the index is out of bounds.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let mut column_iter = vecgrid.column_iter(1)?;
assert_eq!(column_iter.next(), Some(&2));
assert_eq!(column_iter.next(), Some(&5));
assert_eq!(column_iter.next(), None);
sourcepub fn column_iter_mut(
&mut self,
column_index: usize
) -> Result<impl DoubleEndedIterator<Item = &mut T>, Error>
pub fn column_iter_mut(
&mut self,
column_index: usize
) -> Result<impl DoubleEndedIterator<Item = &mut T>, Error>
Returns an Iterator
over mutable references to all elements in the given
column. Returns an error if the index is out of bounds.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
let mut column_iter = vecgrid.column_iter_mut(1)?;
assert_eq!(column_iter.next(), Some(&mut 2));
assert_eq!(column_iter.next(), Some(&mut 5));
assert_eq!(column_iter.next(), None);
sourcepub fn rows_iter(
&self
) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &T>> + Clone
pub fn rows_iter(
&self
) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &T>> + Clone
Returns an Iterator
over all rows. Each Item
is itself another
Iterator
over references to the elements in that row.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
for row_iter in vecgrid.rows_iter() {
for element in row_iter {
print!("{} ", element);
}
println!();
}
let mut rows_iter = vecgrid.rows_iter();
let mut first_row_iter = rows_iter.next().unwrap();
assert_eq!(first_row_iter.next(), Some(&1));
assert_eq!(first_row_iter.next(), Some(&2));
assert_eq!(first_row_iter.next(), Some(&3));
assert_eq!(first_row_iter.next(), None);
let mut second_row_iter = rows_iter.next().unwrap();
assert_eq!(second_row_iter.next(), Some(&4));
assert_eq!(second_row_iter.next(), Some(&5));
assert_eq!(second_row_iter.next(), Some(&6));
assert_eq!(second_row_iter.next(), None);
assert!(rows_iter.next().is_none());
sourcepub fn rows_iter_mut(
&mut self
) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &mut T>>
pub fn rows_iter_mut(
&mut self
) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &mut T>>
Returns an Iterator
over all rows. Each Item
is itself another
Iterator
over mutable references to the elements in that row.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
for row_iter in vecgrid.rows_iter() {
for element in row_iter {
print!("{} ", element);
}
println!();
}
let mut rows_iter = vecgrid.rows_iter_mut();
let mut first_row_iter = rows_iter.next().unwrap();
assert_eq!(first_row_iter.next(), Some(&mut 1));
assert_eq!(first_row_iter.next(), Some(&mut 2));
assert_eq!(first_row_iter.next(), Some(&mut 3));
assert_eq!(first_row_iter.next(), None);
let mut second_row_iter = rows_iter.next().unwrap();
assert_eq!(second_row_iter.next(), Some(&mut 4));
assert_eq!(second_row_iter.next(), Some(&mut 5));
assert_eq!(second_row_iter.next(), Some(&mut 6));
assert_eq!(second_row_iter.next(), None);
assert!(rows_iter.next().is_none());
sourcepub fn columns_iter(
&self
) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &T>> + Clone
pub fn columns_iter(
&self
) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &T>> + Clone
Returns an Iterator
over all columns. Each Item
is itself
another Iterator
over references to the elements in that column.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
for column_iter in vecgrid.columns_iter() {
for element in column_iter {
print!("{} ", element);
}
println!();
}
let mut columns_iter = vecgrid.columns_iter();
let mut first_column_iter = columns_iter.next().unwrap();
assert_eq!(first_column_iter.next(), Some(&1));
assert_eq!(first_column_iter.next(), Some(&4));
assert_eq!(first_column_iter.next(), None);
let mut second_column_iter = columns_iter.next().unwrap();
assert_eq!(second_column_iter.next(), Some(&2));
assert_eq!(second_column_iter.next(), Some(&5));
assert_eq!(second_column_iter.next(), None);
let mut third_column_iter = columns_iter.next().unwrap();
assert_eq!(third_column_iter.next(), Some(&3));
assert_eq!(third_column_iter.next(), Some(&6));
assert_eq!(third_column_iter.next(), None);
assert!(columns_iter.next().is_none());
sourcepub fn columns_iter_mut(
&mut self
) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &mut T>>
pub fn columns_iter_mut(
&mut self
) -> impl DoubleEndedIterator<Item = impl DoubleEndedIterator<Item = &mut T>>
Returns an Iterator
over all columns. Each Item
is itself
another Iterator
over mutable references to the elements in that column.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let mut vecgrid = Vecgrid::from_rows(rows.clone())?;
for column_iter in vecgrid.columns_iter_mut() {
for element in column_iter {
print!("{} ", element);
}
println!();
}
let mut columns_iter = vecgrid.columns_iter_mut();
let mut first_column_iter = columns_iter.next().unwrap();
assert_eq!(first_column_iter.next(), Some(&mut 1));
assert_eq!(first_column_iter.next(), Some(&mut 4));
assert_eq!(first_column_iter.next(), None);
let mut second_column_iter = columns_iter.next().unwrap();
assert_eq!(second_column_iter.next(), Some(&mut 2));
assert_eq!(second_column_iter.next(), Some(&mut 5));
assert_eq!(second_column_iter.next(), None);
let mut third_column_iter = columns_iter.next().unwrap();
assert_eq!(third_column_iter.next(), Some(&mut 3));
assert_eq!(third_column_iter.next(), Some(&mut 6));
assert_eq!(third_column_iter.next(), None);
assert!(columns_iter.next().is_none());
sourcepub fn as_columns(&self) -> Vec<Vec<T>>where
T: Clone,
pub fn as_columns(&self) -> Vec<Vec<T>>where
T: Clone,
sourcepub fn as_row_major(&self) -> Vec<T>where
T: Clone,
pub fn as_row_major(&self) -> Vec<T>where
T: Clone,
Collects the Vecgrid
into a Vec
of elements in row major
order.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.as_row_major(), vec![1, 2, 3, 4, 5, 6]);
sourcepub fn as_column_major(&self) -> Vec<T>where
T: Clone,
pub fn as_column_major(&self) -> Vec<T>where
T: Clone,
Collects the Vecgrid
into a Vec
of elements in column major
order.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
assert_eq!(vecgrid.as_column_major(), vec![1, 4, 2, 5, 3, 6]);
sourcepub fn indices_row_major(
&self
) -> impl DoubleEndedIterator<Item = (usize, usize)> + Clone
pub fn indices_row_major(
&self
) -> impl DoubleEndedIterator<Item = (usize, usize)> + Clone
Returns the indices of the vecgrid in row major order. Each index is a tuple of usize
.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let indices_row_major = vecgrid.indices_row_major().collect::<Vec<_>>();
assert_eq!(
indices_row_major,
vec![(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]
);
sourcepub fn indices_column_major(
&self
) -> impl DoubleEndedIterator<Item = (usize, usize)> + Clone
pub fn indices_column_major(
&self
) -> impl DoubleEndedIterator<Item = (usize, usize)> + Clone
Returns the indices of the vecgrid in column major order. Each index is a tuple of usize
.
Examples
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let vecgrid = Vecgrid::from_rows(rows.clone())?;
let indices_column_major = vecgrid.indices_column_major().collect::<Vec<_>>();
assert_eq!(
indices_column_major,
vec![(0, 0), (1, 0), (0, 1), (1, 1), (0, 2), (1, 2)]
);
sourcepub fn enumerate_row_major(
&self
) -> impl DoubleEndedIterator<Item = ((usize, usize), &T)> + Clone
pub fn enumerate_row_major(
&self
) -> impl DoubleEndedIterator<Item = ((usize, usize), &T)> + Clone
Iterate through the vecgrid in row major order along with the corresponding indices. Each
index is a tuple of usize
.
Examples
use vecgrid::{Vecgrid, Error};
fn main() -> Result<(), Error> {
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]]; let vecgrid = Vecgrid::from_rows(rows.clone())?; let enumerate_row_major = vecgrid.enumerate_row_major().collect::<Vec<_>>(); assert_eq!( enumerate_row_major, vec![ ((0, 0), &1), ((0, 1), &2), ((0, 2), &3), ((1, 0), &4), ((1, 1), &5), ((1, 2), &6) ] );
Ok(())
}
sourcepub fn enumerate_column_major(
&self
) -> impl DoubleEndedIterator<Item = ((usize, usize), &T)> + Clone
pub fn enumerate_column_major(
&self
) -> impl DoubleEndedIterator<Item = ((usize, usize), &T)> + Clone
Iterate through the vecgrid in column major order along with the corresponding indices. Each
index is a tuple of usize
.
Examples
use vecgrid::{Vecgrid, Error};
fn main() -> Result<(), Error> {
let rows = vec![vec![1, 2, 3], vec![4, 5, 6]]; let vecgrid = Vecgrid::from_rows(rows.clone())?; let enumerate_column_major = vecgrid.enumerate_column_major().collect::<Vec<_>>(); assert_eq!( enumerate_column_major, vec![ ((0, 0), &1), ((1, 0), &4), ((0, 1), &2), ((1, 1), &5), ((0, 2), &3), ((1, 2), &6) ] );
Ok(())
}
sourcepub fn insert_row(&mut self, row: Vec<T>, at: usize) -> Result<(), Error>
pub fn insert_row(&mut self, row: Vec<T>, at: usize) -> Result<(), Error>
Inserts a new row into the vecgrid at the provided index of the row. Guards ensure that the supplied row matches the expected dimensions and that the index is in bound.
Examples
use vecgrid::{Vecgrid, Error};
fn main() -> Result<(), Error> {
let rows = vec![vec![1, 2, 3], vec![7, 8, 9]]; let new_row = vec![4, 5, 6]; let result = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]; let mut vecgrid = Vecgrid::from_rows(rows.clone())?; vecgrid.insert_row(new_row, 1)?; assert_eq!(vecgrid.as_rows(), result);
Ok(())
}
sourcepub fn insert_rows(&mut self, rows: Vec<Vec<T>>, at: usize) -> Result<(), Error>
pub fn insert_rows(&mut self, rows: Vec<Vec<T>>, at: usize) -> Result<(), Error>
Inserts a slice of rows into the vecgrid at the provided index. Guards ensure that the supplied rows matches the expected dimensions and that the index is in bound.
Examples
use vecgrid::{Vecgrid, Error};
fn main() -> Result<(), Error> {
let rows = vec![vec![1, 2], vec![7, 8]]; let new_rows = vec![vec![3, 4], vec![5, 6]]; let result = vec![vec![1, 2], vec![3, 4], vec![5, 6], vec![7, 8]]; let mut vecgrid = Vecgrid::from_rows(rows.clone())?; vecgrid.insert_rows(new_row, 1)?; assert_eq!(vecgrid.as_rows(), result);
Ok(())
}
sourcepub fn append_rows(&mut self, rows: Vec<Vec<T>>) -> Result<(), Error>
pub fn append_rows(&mut self, rows: Vec<Vec<T>>) -> Result<(), Error>
Appends a vec of rows at the end of the vecgrid. Guards ensure that the supplied rows matches the expected dimensions.
Examples
use vecgrid::{Vecgrid, Error};
fn main() -> Result<(), Error> {
let rows = vec![vec![1, 2], vec![3, 4]]; let new_rows = vec![vec![5, 6], vec![7, 8]]; let result = vec![vec![1, 2], vec![3, 4], vec![5, 6], vec![7, 8]]; let mut vecgrid = Vecgrid::from_rows(rows.clone())?; vecgrid.append_rows(new_row)?; assert_eq!(vecgrid.as_rows(), result);
Ok(())
}
sourcepub fn remove_row(&mut self, at: usize) -> Result<(), Error>
pub fn remove_row(&mut self, at: usize) -> Result<(), Error>
Removes a row at the provided row index from the vecgrid. Guards ensure that the index is in bound.
Examples
use vecgrid::{Vecgrid, Error};
fn main() -> Result<(), Error> {
let rows = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]; let result = vec![vec![1, 2, 3], vec![7, 8, 9]]; let mut vecgrid = Vecgrid::from_rows(rows)?; vecgrid.remove_row(1)?; assert_eq!(vecgrid.as_rows(), result);
Ok(())
}
sourcepub fn remove_rows(&mut self, at: usize, n: usize) -> Result<(), Error>
pub fn remove_rows(&mut self, at: usize, n: usize) -> Result<(), Error>
Removes n
consecutive rows at the provided row index from the vecgrid.
Guards ensure that the index is in bound.
Examples
use vecgrid::{Vecgrid, Error};
fn main() -> Result<(), Error> {
let rows = vec![vec![1, 2], vec![3, 4], vec![5, 6], vec![7, 8]]; let result = vec![vec![1, 2], vec![7, 8]]; let mut vecgrid = Vecgrid::from_rows(rows)?; vecgrid.remove_rows(1, 2)?; assert_eq!(vecgrid.as_rows(), result);
Ok(())
}
Trait Implementations§
source§impl<T> Index<(usize, usize)> for Vecgrid<T>
impl<T> Index<(usize, usize)> for Vecgrid<T>
source§impl<T> IndexMut<(usize, usize)> for Vecgrid<T>
impl<T> IndexMut<(usize, usize)> for Vecgrid<T>
source§fn index_mut(&mut self, (row, column): (usize, usize)) -> &mut Self::Output
fn index_mut(&mut self, (row, column): (usize, usize)) -> &mut Self::Output
Returns a mutable version of the element at the given indices, given as
(row, column)
.
Examples
let mut vecgrid = Vecgrid::filled_with(42, 2, 3);
vecgrid[(0, 0)] = 100;
assert_eq!(vecgrid[(0, 0)], 100);
Panics
Panics if the indices are out of bounds.
let mut vecgrid = Vecgrid::filled_with(42, 2, 3);
vecgrid[(10, 10)] = 7;