[][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:

This example is not tested
[dependencies]
nalgebra = "0.16"

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, RealSchur, 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 base::*;
pub use geometry::*;
pub use 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

Id

The universal identity element wrt. a given operator, usually noted Id with a context-dependent subscript.

Traits

Real

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

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

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

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.