[−][src]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]
nalgebra = "0.18"

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 an homogeneous matrix: Affine2, Affine3.
Projective (i.e. invertible) transformations stored as an homogeneous matrix: Projective2, Projective3.
General transformations that does not have to be invertible, stored as an 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.
Implements traits from the alga crate for generic programming.

Re-exports

pub use base as core;

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.
Id	The universal identity element wrt. a given operator, usually noted `Id` with a context-dependent subscript.

Traits

ComplexField	Trait shared by all complex fields and its subfields (like real numbers).
Real	Deprecated The field of reals. This has been renamed to `RealField`.
RealField	Trait shared by all reals.

Functions

abs	Deprecated The absolute value of `a`.
angle	Deprecated Computes the smallest angle between two vectors.
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.
dimension	The dimension of the given algebraic entity seen as a vector space.
distance	The distance between two points.
distance_squared	The squared distance between two points.
dot	Deprecated Computes the dot product of two vectors.
id	Deprecated Gets the ubiquitous multiplicative identity element.
inf	Returns the infimum of `a` and `b`.
inf_sup	Returns simultaneously the infimum and supremum of `a` and `b`.
inverse	Deprecated Computes the multiplicative inverse of an (always invertible) algebraic entity.
is_convertible	Indicates if `try_convert` will succeed without actually performing the conversion.
magnitude	Deprecated A synonym for `norm`, aka length.
magnitude_squared	Deprecated A synonym for `norm_squared`, aka length squared.
max	Same as `cmp::max`.
min	Same as `cmp::min`.
norm	Deprecated Computes the L2 (Euclidean) norm of a vector.
norm_squared	Deprecated Computes the squared L2 (Euclidean) norm of the vector `v`.
normalize	Deprecated Computes the normalized version of the vector `v`.
one	Gets the multiplicative identity element.
origin	Deprecated Gets the origin of the given point.
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	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.
try_inverse	Deprecated Tries to gets an inverted copy of a square matrix.
try_normalize	Deprecated Computes the normalized version of the vector `v` or returns `None` if its norm is smaller than `min_norm`.
wrap	Wraps `val` into the range `[min, max]` using modular arithmetics.
zero	Gets the additive identity element.