Linear algebra library for Rust.
Go to file
Sébastien Crozet 87c0d5b769 Make the struct and traits modules private.
Now that the documentation of public export of private modules is inlined on the exporter's
documentation, there is non need to export anything but the `na` module.
2014-01-14 09:40:12 +01:00
src Make the struct and traits modules private. 2014-01-14 09:40:12 +01:00
.gitignore Add the doc folder to the .gitignore. 2013-09-22 11:09:32 +02:00
.travis.yml Add travis.yml. 2013-10-18 11:47:07 +02:00
LICENSE Initial commit. 2013-05-14 11:34:28 +00:00
Makefile Fix pkgid. 2013-12-12 18:08:05 +01:00
README.md Add travis buid icon to the readme. 2013-10-20 23:55:58 +02:00

nalgebra Build Status

nalgebra is a linear algebra library written for Rust targeting:

  • general-purpose linear algebra (still misses a lot of features…).
  • real time computer graphics.
  • real time computer physics.

An on-line version of this documentation is available here.

Using nalgebra

All the functionalities of nalgebra are grouped in one place: the na module. This module re-exports everything and includes free functions for all traits methods doing out-of-place modifications.

  • You can import the whole prelude, including free functions, using:
use nalgebra::na::*;
  • If you dont want to import everything but only every trait:
use nalgebra::traits::*;
  • If you dont want to import everything but only every structure:
use nalgebra::structs::*;

The preffered way to use nalgebra is to import types and traits explicitly, and call free-functions using the na:: prefix:

extern mod nalgebra;
use nalgebra::na::{Vec3, Rot3, Rotation};
use nalgebra::na;

fn main() {
    let     a = Vec3::new(1.0f64, 1.0, 1.0);
    let mut b = Rot3::new(na::zero());

    b.append_rotation(&a);

    assert!(na::rotation(&b).approx_eq(&a));
}

Features

nalgebra is meant to be a general-purpose linear algebra library (but is very far from that…), and keeps an optimized set of tools for computational graphics and physics. Those features include:

  • Vectors with static sizes: Vec0, Vec1, Vec2, Vec3, Vec4, Vec5, Vec6.
  • Square matrices with static sizes: Mat1, Mat2, Mat3, Mat4, Mat5, Mat6 .
  • Rotation matrices: Rot2, Rot3, Rot4.
  • Isometries: Iso2, Iso3, Iso4.
  • Dynamically sized vector: DVec.
  • Dynamically sized (square or rectangular) matrix: DMat.
  • A few methods for data analysis: Cov, Mean.
  • Almost one trait per functionality: useful for generic programming.
  • Operator overloading using the double trait dispatch trick. For example, the following works:
extern mod nalgebra;
use nalgebra::na::{Vec3, Mat3};
use nalgebra::na;

fn main() {
    let v: Vec3<f64> = na::zero();
    let m: Mat3<f64> = na::one();

    let _ = m * v;   // matrix-vector multiplication.
    let _ = v * m;   // vector-matrix multiplication.
    let _ = m * m;   // matrix-matrix multiplication.
    let _ = v * 2.0; // vector-scalar multiplication.
}

Compilation

You will need the last rust compiler from the master branch. If you encounter problems, make sure you have the last version before creating an issue.

git clone git://github.com/sebcrozet/nalgebra.git
cd nalgebra
make

You can build the documentation on the doc folder using:

make doc

nalgebra in use

Here are some projects using nalgebra. Feel free to add your project to this list if you happen to use nalgebra!

  • nphysics: a real-time physics engine.
  • ncollide: a collision detection library.
  • kiss3d: a minimalistic graphics engine.
  • frog: a machine learning library.