M-Labs/nalgebra
3
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make most out-of-place methods static.

Browse Source 
This is to make people prefer the functional style.
Things like `a.dot(b)` dont make sense per se (there is no reason for `a` to have a different
status than `b`). Using static methods avoid this.

In-place methods are left unchanged.
This commit is contained in:
Sébastien Crozet 2013-10-16 21:44:33 +02:00
parent dcd1e7719b
commit 90e40aaec0
14 changed files with 130 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/lib.rs
View File

@ -113,7 +113,7 @@ Feel free to add your project to this list if you happen to use **nalgebra**!
#[deny(non_camel_case_types)];
#[deny(non_uppercase_statics)];
#[deny(unnecessary_qualification)];
#[deny(missing_doc)];
#[warn(missing_doc)];
#[feature(macro_rules)];
extern mod std;

36
src/na.rs
View File

@ -300,11 +300,11 @@ pub fn append_rotation_wrt_point<LV: Neg<LV>,
/// Rotates a copy of `m` by `amount` using `m.translation()` as the pivot point.
#[inline(always)]
pub fn rotate_wrt_center<LV: Neg<LV>,
AV,
M: RotationWithTranslation<LV, AV>>(
m: &M,
amount: &AV) -> M {
pub fn append_rotation_wrt_center<LV: Neg<LV>,
AV,
M: RotationWithTranslation<LV, AV>>(
m: &M,
amount: &AV) -> M {
RotationWithTranslation::append_rotation_wrt_center_cpy(m, amount)
}
@ -373,13 +373,13 @@ pub fn inv_transform<V, M: Transform<V>>(m: &M, v: &V) -> V {
/// Computes the dot product of two vectors.
#[inline(always)]
pub fn dot<V: Dot<N>, N>(a: &V, b: &V) -> N {
a.dot(b)
Dot::dot(a, b)
}
/// Computes a subtraction followed by a dot product.
#[inline(always)]
pub fn sub_dot<V: Dot<N>, N>(a: &V, b: &V, c: &V) -> N {
a.sub_dot(b, c)
Dot::sub_dot(a, b, c)
}
/*
@ -389,13 +389,13 @@ pub fn sub_dot<V: Dot<N>, N>(a: &V, b: &V, c: &V) -> N {
/// Computes the L2 norm of a vector.
#[inline(always)]
pub fn norm<V: Norm<N>, N: Algebraic>(v: &V) -> N {
v.norm()
Norm::norm(v)
}
/// Computes the squared L2 norm of a vector.
#[inline(always)]
pub fn sqnorm<V: Norm<N>, N: Algebraic>(v: &V) -> N {
v.sqnorm()
Norm::sqnorm(v)
}
/// Gets the normalized version of a vector.
@ -411,7 +411,7 @@ pub fn normalize<V: Norm<N>, N: Algebraic>(v: &V) -> V {
/// Computes the cross product of two vectors.
#[inline(always)]
pub fn cross<LV: Cross<AV>, AV>(a: &LV, b: &LV) -> AV {
a.cross(b)
Cross::cross(a, b)
}
/*
@ -422,7 +422,7 @@ pub fn cross<LV: Cross<AV>, AV>(a: &LV, b: &LV) -> AV {
/// product.
#[inline(always)]
pub fn cross_matrix<V: CrossMatrix<M>, M>(v: &V) -> M {
v.cross_matrix()
CrossMatrix::cross_matrix(v)
}
/*
@ -432,7 +432,7 @@ pub fn cross_matrix<V: CrossMatrix<M>, M>(v: &V) -> M {
/// Converts a matrix or vector to homogoneous coordinates.
#[inline(always)]
pub fn to_homogeneous<M: ToHomogeneous<Res>, Res>(m: &M) -> Res {
m.to_homogeneous()
ToHomogeneous::to_homogeneous(m)
}
/*
@ -472,8 +472,8 @@ pub fn sample_sphere<V: UniformSphereSample>(f: &fn(V)) {
/// Computes a component-wise absolute value.
#[inline(always)]
pub fn absolute<M: Absolute<Res>, Res>(m: &M) -> Res {
m.absolute()
pub fn abs<M: Absolute<Res>, Res>(m: &M) -> Res {
Absolute::abs(m)
}
/*
@ -503,7 +503,7 @@ pub fn transpose<M: Transpose>(m: &M) -> M {
/// Computes the outer product of two vectors.
#[inline(always)]
pub fn outer<V: Outer<M>, M>(a: &V, b: &V) -> M {
a.outer(b)
Outer::outer(a, b)
}
/*
@ -513,7 +513,7 @@ pub fn outer<V: Outer<M>, M>(a: &V, b: &V) -> M {
/// Computes the covariance of a set of observations.
#[inline(always)]
pub fn cov<M: Cov<Res>, Res>(observations: &M) -> Res {
observations.cov()
Cov::cov(observations)
}
/*
@ -523,7 +523,7 @@ pub fn cov<M: Cov<Res>, Res>(observations: &M) -> Res {
/// Computes the mean of a set of observations.
#[inline(always)]
pub fn mean<N, M: Mean<N>>(observations: &M) -> N {
observations.mean()
Mean::mean(observations)
}
//
@ -545,7 +545,7 @@ pub fn canonical_basis<V: Basis>(f: &fn(V) -> bool) {
/// Computes the basis of the orthonormal subspace of a given vector.
#[inline(always)]
pub fn orthonormal_subspace_basis<V: Basis>(v: &V, f: &fn(V) -> bool) {
v.orthonormal_subspace_basis(f)
Basis::orthonormal_subspace_basis(v, f)
}
/*

29
src/structs/dmat.rs
View File

@ -65,6 +65,7 @@ impl<N: Zero + Clone> DMat<N> {
self.mij.iter().all(|e| e.is_zero())
}
#[inline]
pub fn reset(&mut self) {
for mij in self.mij.mut_iter() {
*mij = Zero::zero();
@ -416,14 +417,14 @@ impl<N: Clone> Transpose for DMat<N> {
}
impl<N: Num + Cast<f32> + Clone> Mean<DVec<N>> for DMat<N> {
fn mean(&self) -> DVec<N> {
let mut res: DVec<N> = DVec::new_zeros(self.ncols);
let normalizer: N = Cast::from(1.0f32 / Cast::from(self.nrows));
fn mean(m: &DMat<N>) -> DVec<N> {
let mut res: DVec<N> = DVec::new_zeros(m.ncols);
let normalizer: N = Cast::from(1.0f32 / Cast::from(m.nrows));
for i in range(0u, self.nrows) {
for j in range(0u, self.ncols) {
for i in range(0u, m.nrows) {
for j in range(0u, m.ncols) {
unsafe {
let acc = res.at_fast(j) + self.at_fast(i, j) * normalizer;
let acc = res.at_fast(j) + m.at_fast(i, j) * normalizer;
res.set_fast(j, acc);
}
}
@ -435,23 +436,23 @@ impl<N: Num + Cast<f32> + Clone> Mean<DVec<N>> for DMat<N> {
impl<N: Clone + Num + Cast<f32> + DMatDivRhs<N, DMat<N>> + ToStr > Cov<DMat<N>> for DMat<N> {
// FIXME: this could be heavily optimized, removing all temporaries by merging loops.
fn cov(&self) -> DMat<N> {
assert!(self.nrows > 1);
fn cov(m: &DMat<N>) -> DMat<N> {
assert!(m.nrows > 1);
let mut centered = unsafe { DMat::new_uninitialized(self.nrows, self.ncols) };
let mean = self.mean();
let mut centered = unsafe { DMat::new_uninitialized(m.nrows, m.ncols) };
let mean = Mean::mean(m);
// FIXME: use the rows iterator when available
for i in range(0u, self.nrows) {
for j in range(0u, self.ncols) {
for i in range(0u, m.nrows) {
for j in range(0u, m.ncols) {
unsafe {
centered.set_fast(i, j, self.at_fast(i, j) - mean.at_fast(j));
centered.set_fast(i, j, m.at_fast(i, j) - mean.at_fast(j));
}
}
}
// FIXME: return a triangular matrix?
let fnormalizer: f32 = Cast::from(self.nrows() - 1);
let fnormalizer: f32 = Cast::from(m.nrows() - 1);
let normalizer: N = Cast::from(fnormalizer);
// FIXME: this will do 2 allocations for temporaries!
(Transpose::transpose_cpy(&centered) * centered) / normalizer

33
src/structs/dvec.rs
View File

@ -92,6 +92,7 @@ impl<N> DVec<N> {
*self.at.unsafe_mut_ref(i) = val
}
/// Gets a reference to of this vector datas.
#[inline]
pub fn as_vec<'r>(&'r self) -> &'r [N] {
let data: &'r [N] = self.at;
@ -99,6 +100,7 @@ impl<N> DVec<N> {
data
}
/// Gets a mutable reference to of this vector datas.
#[inline]
pub fn as_mut_vec<'r>(&'r mut self) -> &'r mut [N] {
let data: &'r mut [N] = self.at;
@ -106,6 +108,7 @@ impl<N> DVec<N> {
data
}
/// Extracts this vector datas.
#[inline]
pub fn to_vec(self) -> ~[N] {
self.at
@ -211,13 +214,13 @@ impl<N: Clone + Num + Algebraic + ApproxEq<N> + DVecMulRhs<N, DVec<N>>> DVec<N>
let mut elt = basis_element.clone();
elt = elt - self * basis_element.dot(self);
elt = elt - self * Dot::dot(&basis_element, self);
for v in res.iter() {
elt = elt - v * elt.dot(v)
elt = elt - v * Dot::dot(&elt, v)
};
if !elt.sqnorm().approx_eq(&Zero::zero()) {
if !Norm::sqnorm(&elt).approx_eq(&Zero::zero()) {
res.push(Norm::normalize_cpy(&elt));
}
}
@ -257,24 +260,24 @@ impl<N: Neg<N>> Neg<DVec<N>> for DVec<N> {
impl<N: Num + Clone> Dot<N> for DVec<N> {
#[inline]
fn dot(&self, other: &DVec<N>) -> N {
assert!(self.at.len() == other.at.len());
fn dot(a: &DVec<N>, b: &DVec<N>) -> N {
assert!(a.at.len() == b.at.len());
let mut res: N = Zero::zero();
for i in range(0u, self.at.len()) {
res = res + unsafe { self.at_fast(i) * other.at_fast(i) };
for i in range(0u, a.at.len()) {
res = res + unsafe { a.at_fast(i) * b.at_fast(i) };
}
res
}
#[inline]
fn sub_dot(&self, a: &DVec<N>, b: &DVec<N>) -> N {
fn sub_dot(a: &DVec<N>, b: &DVec<N>, c: &DVec<N>) -> N {
let mut res: N = Zero::zero();
for i in range(0u, self.at.len()) {
res = res + unsafe { (self.at_fast(i) - a.at_fast(i)) * b.at_fast(i) };
for i in range(0u, a.at.len()) {
res = res + unsafe { (a.at_fast(i) - b.at_fast(i)) * c.at_fast(i) };
}
res
@ -283,13 +286,13 @@ impl<N: Num + Clone> Dot<N> for DVec<N> {
impl<N: Num + Algebraic + Clone> Norm<N> for DVec<N> {
#[inline]
fn sqnorm(&self) -> N {
self.dot(self)
fn sqnorm(v: &DVec<N>) -> N {
Dot::dot(v, v)
}
#[inline]
fn norm(&self) -> N {
self.sqnorm().sqrt()
fn norm(v: &DVec<N>) -> N {
Norm::sqnorm(v).sqrt()
}
#[inline]
@ -303,7 +306,7 @@ impl<N: Num + Algebraic + Clone> Norm<N> for DVec<N> {
#[inline]
fn normalize(&mut self) -> N {
let l = self.norm();
let l = Norm::norm(self);
for i in range(0u, self.at.len()) {
self.at[i] = self.at[i] / l;

6
src/structs/iso_macros.rs
View File

@ -297,13 +297,13 @@ macro_rules! inv_impl(
macro_rules! to_homogeneous_impl(
($t: ident, $th: ident) => (
impl<N: One + Zero + Clone> ToHomogeneous<$th<N>> for $t<N> {
fn to_homogeneous(&self) -> $th<N> {
let mut res = self.rotation.to_homogeneous();
fn to_homogeneous(m: &$t<N>) -> $th<N> {
let mut res = ToHomogeneous::to_homogeneous(&m.rotation);
// copy the translation
let dim = Dim::dim(None::<$th<N>>);
res.set_col(dim - 1, self.translation.to_homogeneous());
res.set_col(dim - 1, ToHomogeneous::to_homogeneous(&m.translation));
res
}

12
src/structs/mat_macros.rs
View File

@ -113,8 +113,8 @@ macro_rules! absolute_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Signed> Absolute<$t<N>> for $t<N> {
#[inline]
fn absolute(&self) -> $t<N> {
$t::new(self.$comp0.abs() $(, self.$compN.abs() )*)
fn abs(m: &$t<N>) -> $t<N> {
$t::new(m.$comp0.abs() $(, m.$compN.abs() )*)
}
}
)
@ -469,12 +469,12 @@ macro_rules! to_homogeneous_impl(
($t: ident, $t2: ident, $dim: expr, $dim2: expr) => (
impl<N: One + Zero + Clone> ToHomogeneous<$t2<N>> for $t<N> {
#[inline]
fn to_homogeneous(&self) -> $t2<N> {
fn to_homogeneous(m: &$t<N>) -> $t2<N> {
let mut res: $t2<N> = One::one();
for i in range(0u, $dim) {
for j in range(0u, $dim) {
res.set((i, j), self.at((i, j)))
res.set((i, j), m.at((i, j)))
}
}
@ -510,12 +510,12 @@ macro_rules! outer_impl(
($t: ident, $m: ident) => (
impl<N: Mul<N, N> + Zero + Clone> Outer<$m<N>> for $t<N> {
#[inline]
fn outer(&self, other: &$t<N>) -> $m<N> {
fn outer(a: &$t<N>, b: &$t<N>) -> $m<N> {
let mut res: $m<N> = Zero::zero();
for i in range(0u, Dim::dim(None::<$t<N>>)) {
for j in range(0u, Dim::dim(None::<$t<N>>)) {
res.set((i, j), self.at(i) * other.at(j))
res.set((i, j), a.at(i) * b.at(j))
}
}

10
src/structs/rot.rs
View File

@ -106,7 +106,7 @@ impl<N: Clone + Trigonometric + Num + Algebraic> Rot3<N> {
/// * `axisangle` - A vector representing the rotation. Its magnitude is the amount of rotation
/// in radian. Its direction is the axis of rotation.
pub fn new(axisangle: Vec3<N>) -> Rot3<N> {
if axisangle.sqnorm().is_zero() {
if Norm::sqnorm(&axisangle).is_zero() {
One::one()
}
else {
@ -152,8 +152,8 @@ impl<N: Clone + Num + Algebraic> Rot3<N> {
/// with `at`. Non-colinearity is not checked.
pub fn look_at(&mut self, at: &Vec3<N>, up: &Vec3<N>) {
let xaxis = Norm::normalize_cpy(at);
let zaxis = Norm::normalize_cpy(&up.cross(&xaxis));
let yaxis = zaxis.cross(&xaxis);
let zaxis = Norm::normalize_cpy(&Cross::cross(up, &xaxis));
let yaxis = Cross::cross(&zaxis, &xaxis);
self.submat = Mat3::new(
xaxis.x.clone(), yaxis.x.clone(), zaxis.x.clone(),
@ -170,8 +170,8 @@ impl<N: Clone + Num + Algebraic> Rot3<N> {
/// with `at`. Non-colinearity is not checked.
pub fn look_at_z(&mut self, at: &Vec3<N>, up: &Vec3<N>) {
let zaxis = Norm::normalize_cpy(at);
let xaxis = Norm::normalize_cpy(&up.cross(&zaxis));
let yaxis = zaxis.cross(&xaxis);
let xaxis = Norm::normalize_cpy(&Cross::cross(up, &zaxis));
let yaxis = Cross::cross(&zaxis, &xaxis);
self.submat = Mat3::new(
xaxis.x.clone(), yaxis.x.clone(), zaxis.x.clone(),

8
src/structs/rot_macros.rs
View File

@ -190,8 +190,8 @@ macro_rules! to_homogeneous_impl(
($t: ident, $tm: ident) => (
impl<N: One + Zero + Clone> ToHomogeneous<$tm<N>> for $t<N> {
#[inline]
fn to_homogeneous(&self) -> $tm<N> {
self.submat.to_homogeneous()
fn to_homogeneous(m: &$t<N>) -> $tm<N> {
ToHomogeneous::to_homogeneous(&m.submat)
}
}
)
@ -223,8 +223,8 @@ macro_rules! absolute_impl(
($t: ident, $tm: ident) => (
impl<N: Signed> Absolute<$tm<N>> for $t<N> {
#[inline]
fn absolute(&self) -> $tm<N> {
self.submat.absolute()
fn abs(m: &$t<N>) -> $tm<N> {
Absolute::abs(&m.submat)
}
}
)

40
src/structs/spec/vec.rs
View File

@ -6,37 +6,37 @@ use structs::mat::Mat3;
impl<N: Mul<N, N> + Sub<N, N>> Cross<Vec1<N>> for Vec2<N> {
#[inline]
fn cross(&self, other : &Vec2<N>) -> Vec1<N> {
Vec1::new(self.x * other.y - self.y * other.x)
fn cross(a: &Vec2<N>, b: &Vec2<N>) -> Vec1<N> {
Vec1::new(a.x * b.y - a.y * b.x)
}
}
// FIXME: instead of returning a Vec2, define a Mat2x1 matrix?
impl<N: Neg<N> + Clone> CrossMatrix<Vec2<N>> for Vec2<N> {
#[inline]
fn cross_matrix(&self) -> Vec2<N> {
Vec2::new(-self.y, self.x.clone())
fn cross_matrix(v: &Vec2<N>) -> Vec2<N> {
Vec2::new(-v.y, v.x.clone())
}
}
impl<N: Mul<N, N> + Sub<N, N>> Cross<Vec3<N>> for Vec3<N> {
#[inline]
fn cross(&self, other : &Vec3<N>) -> Vec3<N> {
fn cross(a: &Vec3<N>, b: &Vec3<N>) -> Vec3<N> {
Vec3::new(
self.y * other.z - self.z * other.y,
self.z * other.x - self.x * other.z,
self.x * other.y - self.y * other.x
a.y * b.z - a.z * b.y,
a.z * b.x - a.x * b.z,
a.x * b.y - a.y * b.x
)
}
}
impl<N: Neg<N> + Zero + Clone> CrossMatrix<Mat3<N>> for Vec3<N> {
#[inline]
fn cross_matrix(&self) -> Mat3<N> {
fn cross_matrix(v: &Vec3<N>) -> Mat3<N> {
Mat3::new(
Zero::zero() , -self.z, self.y.clone(),
self.z.clone(), Zero::zero(), -self.x,
-self.y , self.x.clone(), Zero::zero()
Zero::zero(), -v.z , v.y.clone(),
v.z.clone() , Zero::zero(), -v.x,
-v.y , v.x.clone() , Zero::zero()
)
}
}
@ -75,7 +75,7 @@ impl<N: One> Basis for Vec1<N> {
}
#[inline(always)]
fn orthonormal_subspace_basis(&self, _: &fn(Vec1<N>) -> bool ) { }
fn orthonormal_subspace_basis(_: &Vec1<N>, _: &fn(Vec1<N>) -> bool ) { }
}
impl<N: Clone + One + Zero + Neg<N>> Basis for Vec2<N> {
@ -86,8 +86,8 @@ impl<N: Clone + One + Zero + Neg<N>> Basis for Vec2<N> {
}
#[inline]
fn orthonormal_subspace_basis(&self, f: &fn(Vec2<N>) -> bool) {
f(Vec2::new(-self.y, self.x.clone()));
fn orthonormal_subspace_basis(n: &Vec2<N>, f: &fn(Vec2<N>) -> bool) {
f(Vec2::new(-n.y, n.x.clone()));
}
}
@ -100,16 +100,16 @@ impl<N: Clone + Ord + Algebraic + Signed> Basis for Vec3<N> {
}
#[inline(always)]
fn orthonormal_subspace_basis(&self, f: &fn(Vec3<N>) -> bool) {
fn orthonormal_subspace_basis(n: &Vec3<N>, f: &fn(Vec3<N>) -> bool) {
let a =
if self.x.clone().abs() > self.y.clone().abs() {
Norm::normalize_cpy(&Vec3::new(self.z.clone(), Zero::zero(), -self.x))
if n.x.clone().abs() > n.y.clone().abs() {
Norm::normalize_cpy(&Vec3::new(n.z.clone(), Zero::zero(), -n.x))
}
else {
Norm::normalize_cpy(&Vec3::new(Zero::zero(), -self.z, self.y.clone()))
Norm::normalize_cpy(&Vec3::new(Zero::zero(), -n.z, n.y.clone()))
};
if !f(a.cross(self)) { return };
if !f(Cross::cross(&a, n)) { return };
f(a);
}
}

18
src/structs/spec/vec0.rs
View File

@ -66,7 +66,7 @@ impl<N> Basis for vec::Vec0<N> {
fn canonical_basis(_: &fn(vec::Vec0<N>) -> bool) { }
#[inline(always)]
fn orthonormal_subspace_basis(&self, _: &fn(vec::Vec0<N>) -> bool) { }
fn orthonormal_subspace_basis(_: &vec::Vec0<N>, _: &fn(vec::Vec0<N>) -> bool) { }
}
impl<N, T> Add<T, vec::Vec0<N>> for vec::Vec0<N> {
@ -92,12 +92,12 @@ impl<N: Neg<N>> Neg<vec::Vec0<N>> for vec::Vec0<N> {
impl<N: Num + Clone> Dot<N> for vec::Vec0<N> {
#[inline]
fn dot(&self, _: &vec::Vec0<N>) -> N {
fn dot(_: &vec::Vec0<N>, _: &vec::Vec0<N>) -> N {
Zero::zero()
}
#[inline]
fn sub_dot(&self, _: &vec::Vec0<N>, _: &vec::Vec0<N>) -> N {
fn sub_dot(_: &vec::Vec0<N>, _: &vec::Vec0<N>, _: &vec::Vec0<N>) -> N {
Zero::zero()
}
}
@ -154,18 +154,18 @@ impl<N: Clone + Add<N, N> + Neg<N>> Translation<vec::Vec0<N>> for vec::Vec0<N> {
impl<N: Clone + Num + Algebraic> Norm<N> for vec::Vec0<N> {
#[inline]
fn sqnorm(&self) -> N {
self.dot(self)
fn sqnorm(_: &vec::Vec0<N>) -> N {
Zero::zero()
}
#[inline]
fn norm(&self) -> N {
self.sqnorm().sqrt()
fn norm(_: &vec::Vec0<N>) -> N {
Zero::zero()
}
#[inline]
fn normalize_cpy(v: &vec::Vec0<N>) -> vec::Vec0<N> {
v.clone()
fn normalize_cpy(_: &vec::Vec0<N>) -> vec::Vec0<N> {
Zero::zero()
}
#[inline]

32
src/structs/vec_macros.rs
View File

@ -228,7 +228,7 @@ macro_rules! basis_impl(
}
#[inline]
fn orthonormal_subspace_basis(&self, f: &fn($t<N>) -> bool) {
fn orthonormal_subspace_basis(n: &$t<N>, f: &fn($t<N>) -> bool) {
// compute the basis of the orthogonal subspace using Gram-Schmidt
// orthogonalization algorithm
let mut basis: ~[$t<N>] = ~[];
@ -246,13 +246,13 @@ macro_rules! basis_impl(
let mut elt = basis_element.clone();
elt = elt - *self * basis_element.dot(self);
elt = elt - *n * Dot::dot(&basis_element, n);
for v in basis.iter() {
elt = elt - v * elt.dot(v)
elt = elt - v * Dot::dot(&elt, v)
};
if !elt.sqnorm().approx_eq(&Zero::zero()) {
if !Norm::sqnorm(&elt).approx_eq(&Zero::zero()) {
let new_element = Norm::normalize_cpy(&elt);
if !f(new_element.clone()) { return };
@ -324,13 +324,13 @@ macro_rules! dot_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Num + Clone> Dot<N> for $t<N> {
#[inline]
fn dot(&self, other: &$t<N>) -> N {
self.$comp0 * other.$comp0 $(+ self.$compN * other.$compN )*
fn dot(a: &$t<N>, b: &$t<N>) -> N {
a.$comp0 * b.$comp0 $(+ a.$compN * b.$compN )*
}
#[inline]
fn sub_dot(&self, a: &$t<N>, b: &$t<N>) -> N {
(self.$comp0 - a.$comp0) * b.$comp0 $(+ (self.$compN - a.$compN) * b.$compN )*
fn sub_dot(a: &$t<N>, b: &$t<N>, c: &$t<N>) -> N {
(a.$comp0 - b.$comp0) * c.$comp0 $(+ (a.$compN - b.$compN) * c.$compN )*
}
}
)
@ -425,13 +425,13 @@ macro_rules! norm_impl(
($t: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Clone + Num + Algebraic> Norm<N> for $t<N> {
#[inline]
fn sqnorm(&self) -> N {
self.dot(self)
fn sqnorm(v: &$t<N>) -> N {
Dot::dot(v, v)
}
#[inline]
fn norm(&self) -> N {
self.sqnorm().sqrt()
fn norm(v: &$t<N>) -> N {
Norm::sqnorm(v).sqrt()
}
#[inline]
@ -445,7 +445,7 @@ macro_rules! norm_impl(
#[inline]
fn normalize(&mut self) -> N {
let l = self.norm();
let l = Norm::norm(self);
self.$comp0 = self.$comp0 / l;
$(self.$compN = self.$compN / l;)*
@ -545,11 +545,11 @@ macro_rules! bounded_impl(
macro_rules! to_homogeneous_impl(
($t: ident, $t2: ident, $extra: ident, $comp0: ident $(,$compN: ident)*) => (
impl<N: Clone + One + Zero> ToHomogeneous<$t2<N>> for $t<N> {
fn to_homogeneous(&self) -> $t2<N> {
fn to_homogeneous(v: &$t<N>) -> $t2<N> {
let mut res: $t2<N> = One::one();
res.$comp0 = self.$comp0.clone();
$( res.$compN = self.$compN.clone(); )*
res.$comp0 = v.$comp0.clone();
$( res.$compN = v.$compN.clone(); )*
res
}

16
src/traits/geometry.rs
View File

@ -201,7 +201,7 @@ pub trait Transform<V> {
pub trait Dot<N> {
/// Computes the dot (inner) product of two vectors.
#[inline]
fn dot(&self, &Self) -> N;
fn dot(&Self, &Self) -> N;
/**
* Short-cut to compute the projection of a point on a vector, but without
@ -214,22 +214,22 @@ pub trait Dot<N> {
*
*/
#[inline]
fn sub_dot(&self, b: &Self, c: &Self) -> N;
fn sub_dot(a: &Self, b: &Self, c: &Self) -> N;
}
/// Traits of objects having an euclidian norm.
pub trait Norm<N: Algebraic> {
/// Computes the norm of `self`.
#[inline]
fn norm(&self) -> N {
self.sqnorm().sqrt()
fn norm(v: &Self) -> N {
Norm::sqnorm(v).sqrt()
}
/// Computes the squared norm of `self`.
///
/// This is usually faster than computing the norm itself.
#[inline]
fn sqnorm(&self) -> N;
fn sqnorm(&Self) -> N;
/// Gets the normalized version of a copy of `v`.
#[inline]
@ -245,7 +245,7 @@ pub trait Norm<N: Algebraic> {
*/
pub trait Cross<V> {
/// Computes the cross product between two elements (usually vectors).
fn cross(&self, other: &Self) -> V;
fn cross(&Self, other: &Self) -> V;
}
/**
@ -254,13 +254,13 @@ pub trait Cross<V> {
pub trait CrossMatrix<M> {
/// The matrix associated to any cross product with this vector. I.e. `v.cross(anything)` =
/// `v.cross_matrix().rmul(anything)`.
fn cross_matrix(&self) -> M;
fn cross_matrix(&Self) -> M;
}
/// Traits of objects which can be put in homogeneous coordinates form.
pub trait ToHomogeneous<U> {
/// Gets the homogeneous coordinates form of this object.
fn to_homogeneous(&self) -> U;
fn to_homogeneous(&Self) -> U;
}
/// Traits of objects which can be build from an homogeneous coordinate form.

12
src/traits/operations.rs
View File

@ -6,7 +6,7 @@
pub trait Absolute<A> {
/// Computes some absolute value of this object.
/// Typically, this will make all component of a matrix or vector positive.
fn absolute(&self) -> A;
fn abs(&Self) -> A;
}
/// Trait of objects having an inverse. Typically used to implement matrix inverse.
@ -30,7 +30,7 @@ pub trait Transpose {
/// Traits of objects having an outer product.
pub trait Outer<M> {
/// Computes the outer product: `self * other`
fn outer(&self, other: &Self) -> M;
fn outer(a: &Self, b: &Self) -> M;
}
/// Trait for computing the covariance of a set of data.
@ -39,14 +39,14 @@ pub trait Cov<M> {
///
/// * For matrices, observations are stored in its rows.
/// * For vectors, observations are stored in its components (thus are 1-dimensional).
fn cov(&self) -> M;
fn cov(&Self) -> M;
/// Computes the covariance of the obsevations stored by `self`:
///
/// * For matrices, observations are stored in its rows.
/// * For vectors, observations are stored in its components (thus are 1-dimensional).
fn cov_to(&self, out: &mut M) {
*out = self.cov()
fn cov_to(m: &Self, out: &mut M) {
*out = Cov::cov(m)
}
}
@ -56,7 +56,7 @@ pub trait Mean<N> {
///
/// * For matrices, observations are stored in its rows.
/// * For vectors, observations are stored in its components (thus are 1-dimensional).
fn mean(&self) -> N;
fn mean(&Self) -> N;
}
// /// Cholesky decomposition.

2
src/traits/structure.rs
View File

@ -60,7 +60,7 @@ pub trait Basis {
fn canonical_basis(&fn(Self) -> bool);
/// Iterates through a basis of the subspace orthogonal to `self`.
fn orthonormal_subspace_basis(&self, &fn(Self) -> bool);
fn orthonormal_subspace_basis(&Self, &fn(Self) -> bool);
}
/// Trait to access rows of a matrix or a vector.