Crate nalgebra

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::*;

pub use base as core;

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.

Macros

dmatrix

Construct a dynamic matrix directly from data.

dvector

Construct a dynamic column vector directly from data.

matrix

Construct a fixed-size matrix directly from data.

point

Construct a fixed-size point directly from data.

vector

Construct a fixed-size column vector directly from data.

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

absDeprecated

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.

infDeprecated

Returns the infimum of a and b.

inf_supDeprecated

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.

supDeprecated

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.