Struct Matrix

pub struct Matrix<T> { /* private fields */ }

A tensor of two dimensions accessed using MatrixAddress.

Implementations

impl<T> Matrix<T>

pub fn to_display_string<T1: Display, F: Fn(&T) -> T1>( &self, display_func: F, row_delimiter: &str, column_delimiter: &str, ) -> String

pub fn parse_matrix<F>( data_str: &str, column_delimiter: &str, row_delimiter: &str, str_to_t_converter: F, ) -> Result<Matrix<T>, Error>

where F: Fn(&str) -> T,

Trait Implementations

impl<T: Clone> Clone for Matrix<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Matrix<T>

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

Formats the value using the given formatter.

impl<'a, T: Display + 'a> Display for Matrix<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Matrix<T>

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

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

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<T> Tensor<T, MatrixAddress> for Matrix<T>

fn new<F>( bounds: AddressBound<MatrixAddress>, address_value_converter: F, ) -> Matrix<T>

where F: Fn(MatrixAddress) -> T,

Creates a new instance of a tensor with the given inclusive bounds and an address value mapper closure

fn get(&self, address: &MatrixAddress) -> Option<&T>

Attempts to retrieve a reference to the value at the address. Returns None if the address is outside the given bound

fn get_mut(&mut self, address: &MatrixAddress) -> Option<&mut T>

fn set(&mut self, address: &MatrixAddress, value: T) -> Result<(), Error>

Attempts to reassign the value at the given index. Returns Err if the given address is out of bounds.

fn bounds(&self) -> &AddressBound<MatrixAddress>

Returns a reference to the bounds of the tensor

fn address_iterator<'a>(&'a self) -> AddressIterator<A>

where T: 'a,

Returns an iterator who generates addresses in row-major order. Can’t give an address who is out of bounds.

fn transform<F, TNew, TENew>(&self, mapping_function: F) -> TENew

where F: Fn(&T) -> TNew, TENew: Tensor<TNew, A>,

Returns a new tensor, which is a copy of this tensor with the values mapped by the given function.

fn transform_by_address<F, TNew, TENew>(&self, mapping_function: F) -> TENew

where F: Fn(&A, &T) -> TNew, TENew: Tensor<TNew, A>,

Returns a new tensor, which is a copy of this tensor with the values mapped by the given function.

fn transform_in_place<F>(&mut self, mapping_function: F)

where F: Fn(&mut T),

Alters every value in the tensor by some mapping function. Note: the mapping function must have the same input value and output value type.

fn transform_by_address_in_place<F>(&mut self, mapping_function: F)

where F: Fn(&A, &mut T),

Alters every value in the tensor by some mapping function. Note: the mapping function must have the same input value and output value type.

fn eq(&self, other: &Self) -> bool

where T: PartialEq,

A canonical means of testing equality. Implementors may choose to use other more efficient means, but this is always viable.

impl<T> StructuralPartialEq for Matrix<T>