Struct Matrix

pub struct Matrix<'a> {
    pub left_bracket: &'a str,
    pub right_bracket: &'a str,
    /* private fields */
}

A matrix e.g. “[[a, b], [x, y]]”

Individual expressions can be accessed with rows to get a random access iterator of row slices, or by indexing with a 2d array of indices, e.g. matrix[[0, 0]]

Fields

left_bracket: &'a str

The matrix’s left bracket

right_bracket: &'a str

The matrix’s right bracket

Implementations

impl<'a> Matrix<'a>

pub fn new<E>( left_bracket: &'a str, cells: E, num_cols: usize, right_bracket: &'a str, ) -> Self

where E: Into<Box<[Expression<'a>]>>,

Create a new matrix

cells is a slice of expressiongs in row-major top-down order. num_cols is how many columns exist in the final matrix.

Panics

When cells.into().len() is not divisible by num_cols.

pub fn num_cols(&self) -> usize

The number of columns

pub fn num_rows(&self) -> usize

The number of rows

pub fn num_cells(&self) -> usize

The number of total cells

pub fn rows(&self) -> MatrixRows<'a, '_>

A top-down iterator over rows as slices

Trait Implementations

impl<'a> Clone for Matrix<'a>

fn clone(&self) -> Matrix<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Matrix<'a>

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

Formats the value using the given formatter.

impl<'a> From<Matrix<'a>> for Simple<'a>

fn from(inp: Matrix<'a>) -> Self

Converts to this type from the input type.

impl<'a> Index<[usize; 2]> for Matrix<'a>

2D indices get individual expressions

fn index(&self, idx: [usize; 2]) -> &Self::Output

Get an individual expression

Panics

When indices are out of bounds [x, y], x >= num_cols, y >= num_rows

type Output = Expression<'a>

The returned type after indexing.

impl<'a> Index<usize> for Matrix<'a>

usize indices get rows

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

Get an individual expression

Panics

When index is out of bounds idx >= num_rows

type Output = [Expression<'a>]

The returned type after indexing.

impl<'a, 'b> IntoIterator for &'b Matrix<'a>

Matrix references iterate over rows

type IntoIter = MatrixRows<'a, 'b>

Which kind of iterator are we turning this into?

type Item = &'b [Expression<'a>]

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> PartialEq for Matrix<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Eq for Matrix<'a>

impl<'a> StructuralPartialEq for Matrix<'a>