matrixable 0.4.0

Traits and structs extending capabilities of matrix-like structures.
Documentation

matrixable

A crate providing utilities for matrix manipulation.

Example

use matrixable::MatrixExt;

struct IdentityMatrix { dim_size: usize }

impl MatrixExt for IdentityMatrix {
    type Element = i32;

    fn num_rows(&self) -> usize { self.dim_size }

    fn num_cols(&self) -> usize { self.dim_size }

    fn get(&self, i: usize, j: usize) -> Option<&Self::Element> {
        if i >= self.dim_size || j >= self.dim_size {
            None
        }
        else if i == j {
            Some(&1)
        }
        else {
            Some(&0)
        }
    }
}

fn main() {
    let identity = IdentityMatrix { dim_size: 3 };

    matrixable::print_rows_debug(&identity);
    println!();

    matrixable::print_columns_debug(&identity);
    println!();

    matrixable::print_diagonals_debug(&identity);
    println!();

    println!("Properties:");
    println!("* Dimensions: {:?}", identity.dimensions());
    println!("* Square matrix: {}", identity.is_square());
    println!("* Symmetric: {}", identity.is_symmetric());
    println!("* Skew-symmetric: {}", identity.is_skew_symmetric());
    println!("* Diagonal matrix: {}", identity.is_diagonal().0);
    println!("* Scalar matrix: {}", identity.is_scalar().0);
    println!("* Constant matrix: {}", identity.is_constant().0);
}

Output:

Rows
0: [1, 0, 0]
1: [0, 1, 0]
2: [0, 0, 1]

Columns
0: [1, 0, 0]
1: [0, 1, 0]
2: [0, 0, 1]

Diagonals
0: [0]
1: [0, 0]
2: [1, 1, 1]
3: [0, 0]
4: [0]

Properties:
* Dimensions: (3, 3)
* Square matrix: true
* Symmetric: true
* Skew-symmetric: false
* Diagonal matrix: true
* Scalar matrix: true
* Constant matrix: false

This library has two main traits: MatrixExt and MatrixMutExt.

MatrixExt

This trait requires three methods to be implemented:

  • num_rows: which should give the number of rows of the matrix.
  • num_cols: which should give the the number of columns.
  • get: which may return a reference to an element of the matrix.

Once these methods are implemented, the following features automatically become available:

  • immutability: All the functions provided by this trait does not modify elements of the matrix-like struct unless that struct is consumed in the process.
  • iterators: iteratate over all elements and also over rows, columns and diagonals.
  • access: elements differently without changing their positions: transpose access, rotate access, submatrix...
  • transformation: transform struct into another type, maybe another matrix.
  • metadata: obtain information about the matrix: symmetry, dimensions, diagonality...

MatrixMutExt

This traits requires for the struct to first implement MatrixExt as well as its single required method: get_mut.

Once implemented MatrixMutExt structs inherits features from MatrixExt plus the following:

  • mutability: Functions provided by this trait allow elements to be mutated. Mutable versions of the above features also become available (iterators, access).
  • in-place modification.

Important

  • Note also that this crate extends the standard 2D array [[T; N]; M].
  • This crate support no_std environments since ver0.3.0.

More

See this documentation for additional informations.

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.