[−][src]Trait nannou::math::Matrix

pub trait Matrix: VectorSpace + Index<usize, Output = Self::Column, Output = Self::Column> + IndexMut<usize> + ApproxEq<Epsilon = Self::Scalar> where
    Self::Scalar: BaseFloat,
    <Self::Row as VectorSpace>::Scalar == Self::Scalar,
    <Self::Row as Array>::Element == Self::Scalar,
    <Self::Column as VectorSpace>::Scalar == Self::Scalar,
    <Self::Column as Array>::Element == Self::Scalar,
    <Self::Transpose as VectorSpace>::Scalar == Self::Scalar,
    <Self::Transpose as Matrix>::Row == Self::Column,
    <Self::Transpose as Matrix>::Column == Self::Row, {
    type Row: Array + VectorSpace;
    type Column: Array + VectorSpace;
    type Transpose: Matrix;
    fn row(&self, r: usize) -> Self::Row;

    fn swap_rows(&mut self, a: usize, b: usize);

    fn swap_columns(&mut self, a: usize, b: usize);

    fn swap_elements(&mut self, a: (usize, usize), b: (usize, usize));

    fn transpose(&self) -> Self::Transpose;

    fn as_ptr(&self) -> *const Self::Scalar { ... }

    fn as_mut_ptr(&mut self) -> *mut Self::Scalar { ... }

    fn replace_col(&mut self, c: usize, src: Self::Column) -> Self::Column { ... }
}

A column-major matrix of arbitrary dimensions.

Because this is constrained to the VectorSpace trait, this means that following operators are required to be implemented:

Matrix addition:

  • Add<Output = Self>
  • Sub<Output = Self>
  • Neg<Output = Self>

Scalar multiplication:

  • Mul<Self::Scalar, Output = Self>
  • Div<Self::Scalar, Output = Self>
  • Rem<Self::Scalar, Output = Self>

Note that matrix multiplication is not required for implementors of this trait. This is due to the complexities of implementing these operators with Rust's current type system. For the multiplication of square matrices, see SquareMatrix.

Associated Types

type Row: Array + VectorSpace

The row vector of the matrix.

type Column: Array + VectorSpace

The column vector of the matrix.

type Transpose: Matrix

The result of transposing the matrix

Loading content...

Required methods

fn row(&self, r: usize) -> Self::Row

Get a row from this matrix by-value.

fn swap_rows(&mut self, a: usize, b: usize)

Swap two rows of this array.

fn swap_columns(&mut self, a: usize, b: usize)

Swap two columns of this array.

fn swap_elements(&mut self, a: (usize, usize), b: (usize, usize))

Swap the values at index a and b

fn transpose(&self) -> Self::Transpose

Transpose this matrix, returning a new matrix.

Loading content...

Provided methods

fn as_ptr(&self) -> *const Self::Scalar

Get the pointer to the first element of the array.

fn as_mut_ptr(&mut self) -> *mut Self::Scalar

Get a mutable pointer to the first element of the array.

fn replace_col(&mut self, c: usize, src: Self::Column) -> Self::Column

Replace a column in the array.

Loading content...

Implementors

impl<S> Matrix for Matrix2<S> where
    S: BaseFloat, [src]

type Column = Vector2<S>

type Row = Vector2<S>

type Transpose = Matrix2<S>

fn as_ptr(&self) -> *const Self::Scalar[src]

fn as_mut_ptr(&mut self) -> *mut Self::Scalar[src]

fn replace_col(&mut self, c: usize, src: Self::Column) -> Self::Column[src]

impl<S> Matrix for Matrix3<S> where
    S: BaseFloat, [src]

type Column = Vector3<S>

type Row = Vector3<S>

type Transpose = Matrix3<S>

fn as_ptr(&self) -> *const Self::Scalar[src]

fn as_mut_ptr(&mut self) -> *mut Self::Scalar[src]

fn replace_col(&mut self, c: usize, src: Self::Column) -> Self::Column[src]

impl<S> Matrix for Matrix4<S> where
    S: BaseFloat, [src]

type Column = Vector4<S>

type Row = Vector4<S>

type Transpose = Matrix4<S>

fn as_ptr(&self) -> *const Self::Scalar[src]

fn as_mut_ptr(&mut self) -> *mut Self::Scalar[src]

fn replace_col(&mut self, c: usize, src: Self::Column) -> Self::Column[src]

Loading content...