# Crate rulinalg [−] [src]

# The rulinalg crate.

A crate that provides high-dimensional linear algebra implemented entirely in Rust.

This crate provides two core data structures: `Matrix`

and
`Vector`

. These structs are designed to behave as you would expect
with relevant operator overloading.

The library currently contains (at least) the following linear algebra methods:

- Matrix inversion
- LUP decomposition
- QR decomposition
- SVD decomposition
- Cholesky decomposition
- Eigenvalue decomposition
- Upper Hessenberg decomposition
- Linear system solver
- Other standard transformations, e.g. Transposing, concatenation, etc.

## Usage

Specific usage of modules is described within the modules themselves. This section will highlight the basic usage.

We can create new matrices.

use rulinalg::matrix::Matrix; // A new matrix with 3 rows and 2 columns. let a = Matrix::new(3, 2, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);

The matrices are stored in row-major order. This means in the example above the top row will be [1,2,3].

We can perform operations on matrices.

use rulinalg::matrix::Matrix; // A new matrix with 3 rows and 2 columns. let a = Matrix::new(3, 2, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]); let b = Matrix::new(3, 2, vec![6.0, 5.0, 4.0, 3.0, 2.0, 1.0]); // Produces a 3x2 matrix filled with sevens. let c = a + b;

Sometimes we want to construct small matrices by hand, usually for writing unit tests
or examples. For this purpose, `rulinalg`

provides the `matrix!`

macro:

// Remember to enable macro usage in rulinalg! #[macro_use] extern crate rulinalg; // Construct a 3x3 matrix of f64 // Commas separate columns and semi-colons separate rows let mat = matrix![1.0, 2.0, 3.0; 4.0, 5.0, 6.0; 7.0, 8.0, 9.0];

Of course the library can support more complex operations but you should check the individual modules for more information.

# Matrix Slices

Often times it is desirable to operate on only a sub-section of a `Matrix`

without copying this block.
Rulinalg allows this via the `MatrixSlice`

and `MatrixSliceMut`

structs. These structs can be created
from `Matrix`

structs and follow all of the borrowing rules of Rust.

Note finally that much of the `Matrix`

/`MatrixSlice`

/`MatrixSliceMut`

functionality is contained behind
the `BaseMatrix`

/`BaseMatrixMut`

traits. This allows us to be generic over matrices or slices.

## Reexports

`pub use norm::VectorNorm;` |

`pub use norm::MatrixNorm;` |

`pub use norm::VectorMetric;` |

`pub use norm::MatrixMetric;` |

## Modules

convert |
The convert module. |

error |
Error handling for the linalg module. |

io |
I/O Module |

macros |
Macros for the linear algebra modules. |

matrix |
The matrix module. |

norm |
The norm module |

ulp |
Tools for ULP-based comparison of floating point numbers. |

utils |
Linear algebra utils module. |

vector |
The vector module. |

## Macros

assert_matrix_eq |
Compare matrices for exact or approximate equality. |

assert_vector_eq |
Compare vectors for exact or approximate equality. |

matrix |
The |

vector |
The |