Struct array2d::Array2D

pub struct Array2D<T: Clone> { /* fields omitted */ }

A statically-sized two-dimensional array.

Methods

impl<T: Clone> Array2D<T>

pub fn fill_with(element: T, num_rows: usize, num_columns: usize) -> Self

Creates a new Array2D with the specified number of rows and columns that contains element in every location.

Examples

let array = Array2D::fill_with(42, 2, 3);
assert_eq!(array.as_rows(), vec![vec![42, 42, 42], vec![42, 42, 42]]);

pub fn from_rows(elements: &[Vec<T>]) -> Self

Creates a new Array2D from a Vec of rows, each of which is a Vec of elements.

Panics

Panics if the rows are not all the same size.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let array = Array2D::from_rows(&rows);
assert_eq!(array[(1, 2)], 6);
assert_eq!(array.as_rows(), rows);

pub fn from_columns(elements: &[Vec<T>]) -> Self

Creates a new Array2D from a Vec of columns, each of which contains a Vec of elements.

Panics

Panics if the columns are not all the same size.

Examples

let columns = vec![vec![1, 4], vec![2, 5], vec![3, 6]];
let array = Array2D::from_columns(&columns);
assert_eq!(array[(1, 2)], 6);
assert_eq!(array.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);

pub fn from_row_major(
    elements: &[T],
    num_rows: usize,
    num_columns: usize
) -> Self

Creates a new Array2D from the given flat Vec in row major order.

Panics

Panics 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 array = Array2D::from_row_major(&row_major, 2, 3);
assert_eq!(array[(1, 2)], 6);
assert_eq!(array.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);

pub fn from_column_major(
    elements: &[T],
    num_rows: usize,
    num_columns: usize
) -> Self

Creates a new Array2D from the given flat Vec in column major order.

Panics

Panics 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 array = Array2D::from_column_major(&column_major, 2, 3);
assert_eq!(array[(1, 2)], 6);
assert_eq!(array.as_rows(), vec![vec![1, 2, 3], vec![4, 5, 6]]);

pub fn num_rows(&self) -> usize

The number of rows.

pub fn num_columns(&self) -> usize

The number of columns.

pub fn num_elements(&self) -> usize

The total number of elements, i.e. the product of num_rows and num_columns

pub fn row_len(&self) -> usize

The number of elements in each row, i.e. the number of columns.

pub fn column_len(&self) -> usize

The number of elements in each column, i.e. the number of rows.

pub fn get(&self, row: usize, column: usize) -> Option<&T>

Returns a 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 array = Array2D::fill_with(42, 2, 3);
assert_eq!(array.get(0, 0), Some(&42));
assert_eq!(array.get(10, 10), None);

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 array = Array2D::fill_with(42, 2, 3);

assert_eq!(array.get_mut(0, 0), Some(&mut 42));
assert_eq!(array.get_mut(10, 10), None);

array.get_mut(0, 0).map(|x| *x = 100);
assert_eq!(array.get(0, 0), Some(&100));

array.get_mut(10, 10).map(|x| *x = 200);
assert_eq!(array.get(10, 10), None);

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(Error) otherwise.

Examples

let mut array = Array2D::fill_with(42, 2, 3);

let result = array.set(0, 0, 100);
assert_eq!(result, Ok(()));
assert_eq!(array.get(0, 0), Some(&100));

let result = array.set(10, 20, 200);
assert_eq!(result, Err(Error::IndexOutOfBounds(10, 20)));

pub fn elements_row_major_iter(&self) -> impl Iterator<Item = &T>

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 array = Array2D::from_rows(&rows);
let row_major = array.elements_row_major_iter();
assert_eq!(row_major.cloned().collect::<Vec<_>>(), elements);

pub fn elements_column_major_iter(&self) -> impl Iterator<Item = &T>

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 array = Array2D::from_rows(&rows);
let column_major = array.elements_column_major_iter();
assert_eq!(column_major.cloned().collect::<Vec<_>>(), elements);

pub fn row_iter(&self, row_index: usize) -> impl Iterator<Item = &T>

Returns an Iterator over references to all elements in the given row.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let array = Array2D::from_rows(&rows);
let mut row_iter = array.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);

Panics

Panics if row_index is out of bounds.

pub fn column_iter(&self, column_index: usize) -> impl Iterator<Item = &T>

Returns an Iterator over references to all elements in the given column.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let array = Array2D::from_rows(&rows);
let mut column_iter = array.column_iter(1);
assert_eq!(column_iter.next(), Some(&2));
assert_eq!(column_iter.next(), Some(&5));
assert_eq!(column_iter.next(), None);

Panics

Panics if column_index is out of bounds.

pub fn rows_iter(&self) -> impl Iterator<Item = impl Iterator<Item = &T>>

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 array = Array2D::from_rows(&rows);
for row_iter in array.rows_iter() {
    for element in row_iter {
        print!("{} ", element);
    }
    println!();
}

let mut rows_iter = array.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());

pub fn columns_iter(&self) -> impl Iterator<Item = impl Iterator<Item = &T>>

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 array = Array2D::from_rows(&rows);
for column_iter in array.columns_iter() {
    for element in column_iter {
        print!("{} ", element);
    }
    println!();
}

let mut columns_iter = array.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());

pub fn as_rows(&self) -> Vec<Vec<T>>

Collects the Array2D into a Vec of rows, each of which contains a Vec of elements.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let array = Array2D::from_rows(&rows);
assert_eq!(array.as_rows(), rows);

pub fn as_columns(&self) -> Vec<Vec<T>>

Collects the Array2D into a Vec of columns, each of which contains a Vec of elements.

Examples

let columns = vec![vec![1, 4], vec![2, 5], vec![3, 6]];
let array = Array2D::from_columns(&columns);
assert_eq!(array.as_columns(), columns);

pub fn as_row_major(&self) -> Vec<T>

Collects the Array2D into a Vec of elements in row major order.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let array = Array2D::from_rows(&rows);
assert_eq!(array.as_row_major(), vec![1, 2, 3, 4, 5, 6]);

pub fn as_column_major(&self) -> Vec<T>

Collects the Array2D into a Vec of elements in column major order.

Examples

let rows = vec![vec![1, 2, 3], vec![4, 5, 6]];
let array = Array2D::from_rows(&rows);
assert_eq!(array.as_column_major(), vec![1, 4, 2, 5, 3, 6]);

Trait Implementations

impl<T: PartialEq + Clone> PartialEq<Array2D<T>> for Array2D<T>

fn eq(&self, other: &Array2D<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Array2D<T>) -> bool

This method tests for !=.

impl<T: Eq + Clone> Eq for Array2D<T>

impl<T: Debug + Clone> Debug for Array2D<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Clone> Index<(usize, usize)> for Array2D<T>

type Output = T

The returned type after indexing.

fn index(&self, indices: (usize, usize)) -> &Self::Output

Returns the element at the given indices, given as (row, column).

Panics

Panics if the indices are out of bounds.

Examples

let array = Array2D::fill_with(42, 2, 3);
assert_eq!(array[(0, 0)], 42);

impl<T: Clone> IndexMut<(usize, usize)> for Array2D<T>

fn index_mut(&mut self, indices: (usize, usize)) -> &mut Self::Output

Returns a mutable version of the element at the given indices, given as (row, column).

Panics

Panics if the indices are out of bounds.

Examples

let mut array = Array2D::fill_with(42, 2, 3);
array[(0, 0)] = 100;
assert_eq!(array[(0, 0)], 100);