ccbc8b4429
Before, it was too easy to use an out of place method instead of the inplace one since they name were pretty mutch the same. This kind of confusion may lead to silly bugs very hard to understand. Thus the following changes have been made when a method is available both inplace and out-of-place: * inplace version keep a short name. * out-of-place version are suffixed by `_cpy` (meaning `copy`), and are static methods. Methods applying transformations (rotation, translation or general transform) are now prefixed by `append`, and a `prepend` version is available too. Also, free functions doing in-place modifications dont really make sense. They have been removed. Here are the naming changes: * `invert` -> `inv` * `inverted` -> `Inv::inv_cpy` * `transpose` -> `transpose` * `transposed` -> `Transpose::transpose_cpy` * `transform_by` -> `append_transformation` * `transformed` -> `Transform::append_transformation_cpy` * `rotate_by` -> `apppend_rotation` * `rotated` -> `Rotation::append_rotation_cpy` * `translate_by` -> `apppend_translation` * `translate` -> `Translation::append_translation_cpy` * `normalized` -> `Norm::normalize_cpy` * `rotated_wrt_point` -> `RotationWithTranslation::append_rotation_wrt_point_cpy` * `rotated_wrt_center` -> `RotationWithTranslation::append_rotation_wrt_center_cpy` Note that using those static methods is very verbose, and using in-place methods require an explicit import of the related trait. This is a way to convince the user to use free functions most of the time. |
||
---|---|---|
src | ||
.gitignore | ||
LICENSE | ||
Makefile | ||
README.md |
nalgebra
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.
Free functions are useful if you prefer doing something like na::dot(v1, v2)
instead of
v1.dot(v2)
.
- 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::*;
Of course, you can still import nalgebra::na
alone, and get anything you want using the prefix
na
.
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!