## Expand description

## nalgebra

**nalgebra** is a linear algebra library written for Rust targeting:

- General-purpose linear algebra (still lacks a lot of features…)
- Real-time computer graphics.
- Real-time computer physics.

### Using **nalgebra**

You will need the last stable build of the rust compiler and the official package manager: cargo.

Simply add the following to your `Cargo.toml`

file:

ⓘ

```
[dependencies]
// TODO: replace the * by the latest version.
nalgebra = "*"
```

Most useful functionalities of **nalgebra** are grouped in the root module `nalgebra::`

.

However, the recommended way to use **nalgebra** is to import types and traits
explicitly, and call free-functions using the `na::`

prefix:

```
#[macro_use]
extern crate approx; // For the macro relative_eq!
extern crate nalgebra as na;
use na::{Vector3, Rotation3};
fn main() {
let axis = Vector3::x_axis();
let angle = 1.57;
let b = Rotation3::from_axis_angle(&axis, angle);
relative_eq!(b.axis().unwrap(), axis);
relative_eq!(b.angle(), angle);
}
```

### Features

**nalgebra** is meant to be a general-purpose, low-dimensional, linear algebra library, with
an optimized set of tools for computer graphics and physics. Those features include:

- A single parametrizable type
`Matrix`

for vectors, (square or rectangular) matrices, and slices with dimensions known either at compile-time (using type-level integers) or at runtime. - Matrices and vectors with compile-time sizes are statically allocated while dynamic ones are allocated on the heap.
- Convenient aliases for low-dimensional matrices and vectors:
`Vector1`

to`Vector6`

and`Matrix1x1`

to`Matrix6x6`

, including rectangular matrices like`Matrix2x5`

. - Points sizes known at compile time, and convenience aliases:
`Point1`

to`Point6`

. - Translation (seen as a transformation that composes by multiplication):
`Translation2`

,`Translation3`

. - Rotation matrices:
`Rotation2`

,`Rotation3`

. - Quaternions:
`Quaternion`

,`UnitQuaternion`

(for 3D rotation). - Unit complex numbers can be used for 2D rotation:
`UnitComplex`

. - Algebraic entities with a norm equal to one:
`Unit<T>`

, e.g.,`Unit<Vector3<f32>>`

. - Isometries (translation ⨯ rotation):
`Isometry2`

,`Isometry3`

- Similarity transformations (translation ⨯ rotation ⨯ uniform scale):
`Similarity2`

,`Similarity3`

. - Affine transformations stored as a homogeneous matrix:
`Affine2`

,`Affine3`

. - Projective (i.e. invertible) transformations stored as a homogeneous matrix:
`Projective2`

,`Projective3`

. - General transformations that does not have to be invertible, stored as a homogeneous matrix:
`Transform2`

,`Transform3`

. - 3D projections for computer graphics:
`Perspective3`

,`Orthographic3`

. - Matrix factorizations:
`Cholesky`

,`QR`

,`LU`

,`FullPivLU`

,`SVD`

,`Schur`

,`Hessenberg`

,`SymmetricEigen`

. - Insertion and removal of rows of columns of a matrix.

## Re-exports

`pub use base as core;`

`pub use crate::base::*;`

`pub use crate::geometry::*;`

`pub use crate::linalg::*;`

`pub use crate::sparse::*;`

## Modules

- [Reexported at the root of this crate.] Data structures for vector and matrix computations.
- Various tools useful for testing/debugging/benchmarking.
- [Reexported at the root of this crate.] Data structures for points and usual transformations (rotations, isometries, etc.)
- Parsers for various matrix formats.
- [Reexported at the root of this crate.] Factorization of real matrices.
`proptest`

-related features for`nalgebra`

data structures.- Sparse matrices.

## Macros

- Construct a dynamic matrix directly from data.
- Construct a dynamic column vector directly from data.
- Construct a fixed-size matrix directly from data.
- Construct a fixed-size point directly from data.
- Construct a fixed-size column vector directly from data.

## Structs

- A complex number in Cartesian form.

## Traits

- Trait
**alias**for`Add`

and`AddAssign`

with result of type`Self`

. - Trait
**alias**for`Div`

and`DivAssign`

with result of type`Self`

. - Trait
**alias**for`Mul`

and`MulAssign`

with result of type`Self`

. - Trait
**alias**for`Sub`

and`SubAssign`

with result of type`Self`

. - Trait shared by all complex fields and its subfields (like real numbers).
- Trait implemented by fields, i.e., complex numbers and floats.
- Trait shared by all reals.
- Lane-wise generalization of
`bool`

for SIMD booleans. - Lane-wise generalisation of
`ComplexField`

for SIMD complex fields. - Lane-wise generalization of the standard
`PartialOrd`

for SIMD values. - Lanewise generalization of
`RealField`

for SIMD reals. - Base trait for every SIMD types.

## Functions

- absDeprecatedThe absolute value of
`a`

. - The center of two points.
- Returns a reference to the input value clamped to the interval
`[min, max]`

. - Converts an object from one type to an equivalent or more general one.
- Converts an object from one type to an equivalent or more general one.
- Use with care! Same as
`try_convert`

but without any property checks. - Use with care! Same as
`try_convert`

but without any property checks. - The distance between two points.
- The squared distance between two points.
- infDeprecatedReturns the infimum of
`a`

and`b`

. - inf_supDeprecatedReturns simultaneously the infimum and supremum of
`a`

and`b`

. - Indicates if
`try_convert`

will succeed without actually performing the conversion. - Same as
`cmp::max`

. - Same as
`cmp::min`

. - Gets the multiplicative identity element.
- Clamp
`value`

between`min`

and`max`

. Returns`None`

if`value`

is not comparable to`min`

or`max`

. - Compare
`a`

and`b`

using a partial ordering relation. - Returns
`true`

iff`a`

and`b`

are comparable and`a >= b`

. - Returns
`true`

iff`a`

and`b`

are comparable and`a > b`

. - Returns
`true`

iff`a`

and`b`

are comparable and`a <= b`

. - Returns
`true`

iff`a`

and`b`

are comparable and`a < b`

. - Return the maximum of
`a`

and`b`

if they are comparable. - Return the minimum of
`a`

and`b`

if they are comparable. - Sorts two values in increasing order using a partial ordering.
- supDeprecatedReturns the supremum of
`a`

and`b`

. - Attempts to convert an object to a more specific one.
- Attempts to convert an object to a more specific one.
- Wraps
`val`

into the range`[min, max]`

using modular arithmetics. - Gets the additive identity element.