nalgebra - Rust
Description: nalgebra
Keywords: rust, rustlang, rust-lang, nalgebra

# Crate nalgebra

source ·
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 crate::base::*;`
`pub use crate::geometry::*;`
`pub use crate::linalg::*;`

## Modules

base
[Reexported at the root of this crate.] Data structures for vector and matrix computations.
geometry
[Reexported at the root of this crate.] Data structures for points and usual transformations (rotations, isometries, etc.)
linalg
[Reexported at the root of this crate.] Factorization of real matrices.

## Structs

Complex
A complex number in Cartesian form.

## Traits

ClosedAdd
Trait alias for `Add` and `AddAssign` with result of type `Self`.
ClosedDiv
Trait alias for `Div` and `DivAssign` with result of type `Self`.
ClosedMul
Trait alias for `Mul` and `MulAssign` with result of type `Self`.
ClosedSub
Trait alias for `Sub` and `SubAssign` with result of type `Self`.
ComplexField
Trait shared by all complex fields and its subfields (like real numbers).
Field
Trait implemented by fields, i.e., complex numbers and floats.
RealField
Trait shared by all reals.
SimdBool
Lane-wise generalization of `bool` for SIMD booleans.
SimdComplexField
Lane-wise generalisation of `ComplexField` for SIMD complex fields.
SimdPartialOrd
Lane-wise generalization of the standard `PartialOrd` for SIMD values.
SimdRealField
Lanewise generalization of `RealField` for SIMD reals.
SimdValue
Base trait for every SIMD types.

## Functions

abs Deprecated
The absolute value of `a`.
center
The center of two points.
clamp
Returns a reference to the input value clamped to the interval `[min, max]`.
convert
Converts an object from one type to an equivalent or more general one.
convert_ref
Converts an object from one type to an equivalent or more general one.
convert_ref_unchecked
Use with care! Same as `try_convert` but without any property checks.
convert_unchecked
Use with care! Same as `try_convert` but without any property checks.
distance
The distance between two points.
distance_squared
The squared distance between two points.
inf Deprecated
Returns the infimum of `a` and `b`.
inf_sup Deprecated
Returns simultaneously the infimum and supremum of `a` and `b`.
is_convertible
Indicates if `try_convert` will succeed without actually performing the conversion.
max
Same as `cmp::max`.
min
Same as `cmp::min`.
one
Gets the multiplicative identity element.
partial_clamp
Clamp `value` between `min` and `max`. Returns `None` if `value` is not comparable to `min` or `max`.
partial_cmp
Compare `a` and `b` using a partial ordering relation.
partial_ge
Returns `true` iff `a` and `b` are comparable and `a >= b`.
partial_gt
Returns `true` iff `a` and `b` are comparable and `a > b`.
partial_le
Returns `true` iff `a` and `b` are comparable and `a <= b`.
partial_lt
Returns `true` iff `a` and `b` are comparable and `a < b`.
partial_max
Return the maximum of `a` and `b` if they are comparable.
partial_min
Return the minimum of `a` and `b` if they are comparable.
partial_sort2
Sorts two values in increasing order using a partial ordering.
sup Deprecated
Returns the supremum of `a` and `b`.
try_convert
Attempts to convert an object to a more specific one.
try_convert_ref
Attempts to convert an object to a more specific one.
wrap
Wraps `val` into the range `[min, max]` using modular arithmetics.
zero
Gets the additive identity element.