Crate simple_matrix[][src]

Matrix-rs: A generic matrix library in Rust

Matrix-rs is a simple matrix library designed to be easy to use.


This crate should not be considered mature enough for professional use, check alternatives like cgmath or nalgebra if you are in that case.

If you are still interested, feel free to continue!


Link it in your project's Cargo.toml file:

# Example Cargo.toml

simple-matrix = "0.1"

Then, you can use it in your project:

Rust 2015

// Specify the extern crate in your or
extern crate simple_matrix;

// You can now use it
use simple_matrix::Matrix;

let mat: Matrix<i32> = Matrix::new();

Rust 2018

// No need to specify an extern crate
// You can use it directly
use simple_matrix::Matrix;

let mat: Matrix<i32> = Matrix::new();

Example: Basic matrix usage

// Create a matrix of default cells
let zero: Matrix<u32> = Matrix::new(3, 3);

// Create a 2x4 matrix from an iterator (fill it row by row)
let mat1: Matrix<u32> = Matrix::from_iter(2, 4, 0..);

// Clone a matrix
let mat2 = mat1.clone();

// Add by reference (do not consume them)
let mut add = &mat1 + &mat2;

// Subtract by value (consume them)
let mut sub = mat1 - mat2;

// OpAssign are also available
sub += &zero;
sub -= zero;

// Get cells
let val: &u32 = add.get(0, 3).unwrap();

// Set cells
add.set(0, 3, 0);

// Iterate through the matrix (row by row)
for val in add {
    print!("{} ", val);

Example: Dot product

let mat: Matrix<f64> = Matrix::from_iter(2, 4, 0..);

// Construct the transposed matrix
let mat_t = mat.transpose();

// Construct the dot product
let dot = mat * mat_t;


  • Features are extensions of the library left to opt-in by the user.
  • They can increase compilation time and library size.

To include a feature, add it to your Cargo.toml file:

# Example Cargo.toml with added feature (replace values with your own)

simple-matrix = { version = "0.1", features = ["impl_from"] }

Current available features are listed below with a little description:


Implements the From Trait for basic numeric types.

let m1: Matrix<i8> = Matrix::new(3, 5);
let m2: Matrix<i64> = m1.into();



A 2-Dimensional, non-resisable container.