Struct pathfinding::matrix::Matrix

pub struct Matrix<C> {
    pub rows: usize,
    pub columns: usize,
    /* private fields */
}

Matrix of an arbitrary type. Data are stored consecutively in memory, by rows. Raw data can be accessed using as_ref() or as_mut().

Fields

rows: usize

Rows

columns: usize

Columns

Implementations

impl<C: Clone> Matrix<C>

pub fn new(rows: usize, columns: usize, value: C) -> Matrix<C>

Create new matrix with an initial value.

pub fn new_square(size: usize, value: C) -> Matrix<C>

Create new square matrix with initial value.

pub fn fill(&mut self, value: C)

Fill with a known value.

pub fn slice(&self, rows: Range<usize>, columns: Range<usize>) -> Matrix<C>

Return a copy of a sub-matrix.

pub fn rotated_cw(&self, times: usize) -> Matrix<C>

Return a copy of a matrix rotated clock-wise a number of times.

pub fn rotated_ccw(&self, times: usize) -> Matrix<C>

Return a copy of a matrix rotated counter-clock-wise a number of times.

pub fn flipped_lr(&self) -> Matrix<C>

Return a copy of the matrix flipped along the vertical axis.

pub fn flipped_ud(&self) -> Matrix<C>

Return a copy of the matrix flipped along the horizontal axis.

pub fn transposed(&self) -> Matrix<C>

Return a copy of the matrix after transposition.

pub fn extend(&mut self, row: &[C])

Extend the matrix in place by adding one full row.

Panics

This function panics if the row does not have the expected number of elements.

impl<C: Copy> Matrix<C>

pub fn set_slice(&mut self, pos: &(usize, usize), slice: &Matrix<C>)

Replace a slice of the current matrix with the content of another one.

impl<C> Matrix<C>

pub fn from_vec(rows: usize, columns: usize, values: Vec<C>) -> Matrix<C>

Create new matrix from vector values. The first value will be assigned to index (0, 0), the second one to index (0, 1), and so on.

Panics

This function will panic if the number of values does not correspond to the announced size.

pub fn square_from_vec(values: Vec<C>) -> Matrix<C>

Create new square matrix from vector values. The first value will be assigned to index (0, 0), the second one to index (0, 1), and so on.

Panics

This function will panic if the number of values is not a square number.

pub fn new_empty(columns: usize) -> Matrix<C>

Create new empty matrix with a predefined number of rows. This is useful to gradually build the matrix and extend it later using extend and does not require a filler element compared to Matrix::new.

pub fn from_rows<IR, IC>(rows: IR) -> Result<Matrix<C>, MatrixFormatError>where
    IR: IntoIterator<Item = IC>,
    IC: IntoIterator<Item = C>,

Create a matrix from something convertible to an iterator on rows, each row being convertible to an iterator on columns.

An error will be returned if length of rows differ.

use pathfinding::matrix::*;

let input = "abc\ndef";
let matrix = Matrix::from_rows(input.lines().map(|l| l.chars()))?;
assert_eq!(matrix.rows, 2);
assert_eq!(matrix.columns, 3);
assert_eq!(matrix[&(1, 1)], 'e');

pub fn to_vec(self) -> Vec<C>

Retrieve the content of the matrix as a vector. The content starts with the first row, then the second one, and so on.

pub fn is_square(&self) -> bool

Check if a matrix is a square one.

pub fn idx(&self, i: &(usize, usize)) -> usize

Index in raw data of a given position.

Panics

This function panics if the coordinates do not designated a cell.

pub fn flip_lr(&mut self)

Flip the matrix around the vertical axis.

pub fn flip_ud(&mut self)

Flip the matrix around the horizontal axis.

pub fn rotate_cw(&mut self, times: usize)

Rotate a square matrix clock-wise a number of times.

Panics

This function panics if the matrix is not square.

pub fn rotate_ccw(&mut self, times: usize)

Rotate a square matrix counter-clock-wise a number of times.

Panics

This function panics if the matrix is not square.

pub fn neighbours(
    &self,
    index: &(usize, usize),
    diagonals: bool
) -> impl Iterator<Item = (usize, usize)>

Return an iterator on neighbours of a given matrix cell, with or without considering diagonals.

Trait Implementations

impl<C> AsMut<[C]> for Matrix<C>

fn as_mut(&mut self) -> &mut [C]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C> AsRef<[C]> for Matrix<C>

fn as_ref(&self) -> &[C]

Converts this type into a shared reference of the (usually inferred) input type.

impl<C: Clone> Clone for Matrix<C>

fn clone(&self) -> Matrix<C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug> Debug for Matrix<C>

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

Formats the value using the given formatter.

impl<C: Hash> Hash for Matrix<C>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, C> Index<&'a (usize, usize)> for Matrix<C>

type Output = C

The returned type after indexing.

fn index(&self, index: &'a (usize, usize)) -> &C

Performs the indexing (container[index]) operation.

impl<'a, C> IndexMut<&'a (usize, usize)> for Matrix<C>

fn index_mut(&mut self, index: &'a (usize, usize)) -> &mut C

Performs the mutable indexing (container[index]) operation.

impl<C: Clone + Signed> Neg for Matrix<C>

type Output = Matrix<C>

The resulting type after applying the - operator.

fn neg(self) -> Matrix<C>

Performs the unary - operation.

impl<C: PartialEq> PartialEq<Matrix<C>> for Matrix<C>

fn eq(&self, other: &Matrix<C>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<C: Copy> Weights<C> for Matrix<C>

fn rows(&self) -> usize

Return the number of rows.

fn columns(&self) -> usize

Return the number of columns.

fn at(&self, row: usize, col: usize) -> C

Return the element at position.

fn neg(&self) -> Selfwhere
    C: Signed,

Return the negated weights.

impl<C: Eq> Eq for Matrix<C>

impl<C> StructuralEq for Matrix<C>

impl<C> StructuralPartialEq for Matrix<C>