srenblad/nalgebra
1
0
Fork 0
forked from M-Labs/nalgebra
Code Pull Requests Activity

Fix to make it work with the new compiler.

Browse Source
This commit is contained in:
Sébastien Crozet 2013-06-19 12:26:59 +02:00
parent 854dda73bf
commit cfd7bac305
14 changed files with 184 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
doc/rust.css
View File

@ -12,41 +12,38 @@ body {
} }
h1 { h1 {
font-size: 20pt; font-size: 24pt;
margin-top: 2em; margin-top: 1.6em;
padding-left: 0.4em; padding-left: 0.4em;
line-height: 1.6em; line-height: 1.6em;
background-color:#FFF2CE; background-color:#FFF2CE;
border-radius: 0.2em; border-radius: 0.2em;
border: 1px solid rgba(0, 0, 0, 0.15);
} }
h2 { h2 {
font-size: 15pt; font-size: 16pt;
margin-top: 2em; margin-top: 1.6em;
padding-left: 0.4em; padding: 0.2em 0.5em;
background-color:#FFF2CE; background-color:#FFF2CE;
border-radius: 0.4em; border-radius: 0.4em;
border: 1px solid rgba(0, 0, 0, 0.15);
} }
h2 code { h2 code {
color: #097334; color: #097334;
font-size: 15pt; font-size: 16pt;
} }
h3 { h3 {
font-size: 13pt; font-size: 14pt;
color: black; color: black;
background-color:#D9E7FF; background-color:#D9E7FF;
border-radius: 0.4em; border-radius: 0.4em;
border: 1px solid rgba(0, 0, 0, 0.15); padding: 0.2em 0.5em;
padding: 0 0.4em 0 0.4em;
} }
h3 code { h3 code {
color: #541800; color: #541800;
font-size: 13pt; font-size: 14pt;
font-style: italic; font-style: italic;
} }

14
src/adaptors/rotmat.rs
View File

@ -22,7 +22,7 @@ impl<M: Copy> Rotmat<M>
{ {
#[inline(always)] #[inline(always)]
fn submat(&self) -> M fn submat(&self) -> M
{ self.submat } { copy self.submat }
} }
pub fn rotmat2<N: Copy + Trigonometric + Neg<N>>(angle: N) -> Rotmat<Mat2<N>> pub fn rotmat2<N: Copy + Trigonometric + Neg<N>>(angle: N) -> Rotmat<Mat2<N>>
@ -31,7 +31,7 @@ pub fn rotmat2<N: Copy + Trigonometric + Neg<N>>(angle: N) -> Rotmat<Mat2<N>>
let sia = angle.sin(); let sia = angle.sin();
Rotmat Rotmat
{ submat: Mat2::new(coa, -sia, sia, coa) } { submat: Mat2::new(copy coa, -sia, copy sia, copy coa) }
} }
pub fn rotmat3<N: Copy + Trigonometric + Neg<N> + One + Sub<N, N> + Add<N, N> + pub fn rotmat3<N: Copy + Trigonometric + Neg<N> + One + Sub<N, N> + Add<N, N> +
@ -39,9 +39,9 @@ pub fn rotmat3<N: Copy + Trigonometric + Neg<N> + One + Sub<N, N> + Add<N, N> +
(axis: &Vec3<N>, angle: N) -> Rotmat<Mat3<N>> (axis: &Vec3<N>, angle: N) -> Rotmat<Mat3<N>>
{ {
let _1 = One::one::<N>(); let _1 = One::one::<N>();
let ux = axis.x; let ux = copy axis.x;
let uy = axis.y; let uy = copy axis.y;
let uz = axis.z; let uz = copy axis.z;
let sqx = ux * ux; let sqx = ux * ux;
let sqy = uy * uy; let sqy = uy * uy;
let sqz = uz * uz; let sqz = uz * uz;
@ -74,7 +74,7 @@ Rotation<Vec1<N>> for Rotmat<Mat2<N>>
#[inline(always)] #[inline(always)]
fn rotated(&self, rot: &Vec1<N>) -> Rotmat<Mat2<N>> fn rotated(&self, rot: &Vec1<N>) -> Rotmat<Mat2<N>>
{ rotmat2(rot.x) * *self } { rotmat2(copy rot.x) * *self }
#[inline(always)] #[inline(always)]
fn rotate(&mut self, rot: &Vec1<N>) fn rotate(&mut self, rot: &Vec1<N>)
@ -153,7 +153,7 @@ impl<M: Copy> DeltaTransform<M> for Rotmat<M>
{ {
#[inline(always)] #[inline(always)]
fn delta_transform(&self) -> M fn delta_transform(&self) -> M
{ self.submat } { copy self.submat }
} }
impl<M: RMul<V> + Copy, V: Copy> DeltaTransformVector<V> for Rotmat<M> impl<M: RMul<V> + Copy, V: Copy> DeltaTransformVector<V> for Rotmat<M>

6
src/adaptors/transform.rs
View File

@ -20,7 +20,7 @@ impl<M: Copy, V: Copy> Transform<M, V>
{ {
#[inline(always)] #[inline(always)]
pub fn new(mat: &M, trans: &V) -> Transform<M, V> pub fn new(mat: &M, trans: &V) -> Transform<M, V>
{ Transform { submat: *mat, subtrans: *trans } } { Transform { submat: copy *mat, subtrans: copy *trans } }
} }
impl<M:Dim, V> Dim for Transform<M, V> impl<M:Dim, V> Dim for Transform<M, V>
@ -118,7 +118,7 @@ impl<M: Copy, V> DeltaTransform<M> for Transform<M, V>
{ {
#[inline(always)] #[inline(always)]
fn delta_transform(&self) -> M fn delta_transform(&self) -> M
{ self.submat } { copy self.submat }
} }
impl<M: RMul<V> + Copy, V> DeltaTransformVector<V> for Transform<M, V> impl<M: RMul<V> + Copy, V> DeltaTransformVector<V> for Transform<M, V>
@ -141,7 +141,7 @@ Inv for Transform<M, V>
#[inline(always)] #[inline(always)]
fn inverse(&self) -> Transform<M, V> fn inverse(&self) -> Transform<M, V>
{ {
let mut res = *self; let mut res = copy *self;
res.invert(); res.invert();

10
src/dim1/mat1.rs
View File

@ -74,7 +74,7 @@ Inv for Mat1<N>
#[inline(always)] #[inline(always)]
fn inverse(&self) -> Mat1<N> fn inverse(&self) -> Mat1<N>
{ {
let mut res : Mat1<N> = *self; let mut res : Mat1<N> = copy *self;
res.invert(); res.invert();
@ -94,7 +94,7 @@ impl<N:Copy> Transpose for Mat1<N>
{ {
#[inline(always)] #[inline(always)]
fn transposed(&self) -> Mat1<N> fn transposed(&self) -> Mat1<N>
{ *self } { copy *self }
#[inline(always)] #[inline(always)]
fn transpose(&mut self) fn transpose(&mut self)
@ -131,13 +131,13 @@ impl<N: Copy> Flatten<N> for Mat1<N>
#[inline(always)] #[inline(always)]
fn from_flattened(l: &[N], off: uint) -> Mat1<N> fn from_flattened(l: &[N], off: uint) -> Mat1<N>
{ Mat1::new(l[off]) } { Mat1::new(copy l[off]) }
#[inline(always)] #[inline(always)]
fn flatten(&self) -> ~[N] fn flatten(&self) -> ~[N]
{ ~[ self.m11 ] } { ~[ copy self.m11 ] }
#[inline(always)] #[inline(always)]
fn flatten_to(&self, l: &mut [N], off: uint) fn flatten_to(&self, l: &mut [N], off: uint)
{ l[off] = self.m11 } { l[off] = copy self.m11 }
} }

20
src/dim1/vec1.rs
View File

@ -51,7 +51,7 @@ ScalarMul<N> for Vec1<N>
#[inline(always)] #[inline(always)]
fn scalar_mul_inplace(&mut self, s: &N) fn scalar_mul_inplace(&mut self, s: &N)
{ self.x *= *s; } { self.x = self.x * copy *s; }
} }
@ -64,7 +64,7 @@ ScalarDiv<N> for Vec1<N>
#[inline(always)] #[inline(always)]
fn scalar_div_inplace(&mut self, s: &N) fn scalar_div_inplace(&mut self, s: &N)
{ self.x /= *s; } { self.x = self.x / copy *s; }
} }
impl<N: Copy + Add<N, N>> impl<N: Copy + Add<N, N>>
@ -76,7 +76,7 @@ ScalarAdd<N> for Vec1<N>
#[inline(always)] #[inline(always)]
fn scalar_add_inplace(&mut self, s: &N) fn scalar_add_inplace(&mut self, s: &N)
{ self.x += *s; } { self.x = self.x + copy *s; }
} }
impl<N: Copy + Sub<N, N>> impl<N: Copy + Sub<N, N>>
@ -88,14 +88,14 @@ ScalarSub<N> for Vec1<N>
#[inline(always)] #[inline(always)]
fn scalar_sub_inplace(&mut self, s: &N) fn scalar_sub_inplace(&mut self, s: &N)
{ self.x -= *s; } { self.x = self.x - copy *s; }
} }
impl<N: Copy + Add<N, N>> Translation<Vec1<N>> for Vec1<N> impl<N: Copy + Add<N, N>> Translation<Vec1<N>> for Vec1<N>
{ {
#[inline(always)] #[inline(always)]
fn translation(&self) -> Vec1<N> fn translation(&self) -> Vec1<N>
{ *self } { copy *self }
#[inline(always)] #[inline(always)]
fn translated(&self, t: &Vec1<N>) -> Vec1<N> fn translated(&self, t: &Vec1<N>) -> Vec1<N>
@ -103,7 +103,7 @@ impl<N: Copy + Add<N, N>> Translation<Vec1<N>> for Vec1<N>
#[inline(always)] #[inline(always)]
fn translate(&mut self, t: &Vec1<N>) fn translate(&mut self, t: &Vec1<N>)
{ *self += *t } { *self = *self + copy *t }
} }
impl<N:Copy + Mul<N, N>> Dot<N> for Vec1<N> impl<N:Copy + Mul<N, N>> Dot<N> for Vec1<N>
@ -140,7 +140,7 @@ Norm<N> for Vec1<N>
{ {
let l = self.norm(); let l = self.norm();
self.x /= l; self.x = self.x / copy l;
l l
} }
@ -208,15 +208,15 @@ impl<N: Copy> Flatten<N> for Vec1<N>
#[inline(always)] #[inline(always)]
fn from_flattened(l: &[N], off: uint) -> Vec1<N> fn from_flattened(l: &[N], off: uint) -> Vec1<N>
{ Vec1::new(l[off]) } { Vec1::new(copy l[off]) }
#[inline(always)] #[inline(always)]
fn flatten(&self) -> ~[N] fn flatten(&self) -> ~[N]
{ ~[ self.x ] } { ~[ copy self.x ] }
#[inline(always)] #[inline(always)]
fn flatten_to(&self, l: &mut [N], off: uint) fn flatten_to(&self, l: &mut [N], off: uint)
{ l[off] = self.x } { l[off] = copy self.x }
} }
impl<N: Bounded + Copy> Bounded for Vec1<N> impl<N: Bounded + Copy> Bounded for Vec1<N>

26
src/dim2/mat2.rs
View File

@ -42,8 +42,8 @@ impl<N:Copy + One + Zero> One for Mat2<N>
fn one() -> Mat2<N> fn one() -> Mat2<N>
{ {
let (_0, _1) = (Zero::zero(), One::one()); let (_0, _1) = (Zero::zero(), One::one());
return Mat2::new(_1, _0, return Mat2::new(copy _1, copy _0,
_0, _1) copy _0, copy _1)
} }
} }
@ -53,8 +53,8 @@ impl<N:Copy + Zero> Zero for Mat2<N>
fn zero() -> Mat2<N> fn zero() -> Mat2<N>
{ {
let _0 = Zero::zero(); let _0 = Zero::zero();
return Mat2::new(_0, _0, return Mat2::new(copy _0, copy _0,
_0, _0) copy _0, copy _0)
} }
#[inline(always)] #[inline(always)]
@ -109,7 +109,7 @@ Inv for Mat2<N>
#[inline(always)] #[inline(always)]
fn inverse(&self) -> Mat2<N> fn inverse(&self) -> Mat2<N>
{ {
let mut res : Mat2<N> = *self; let mut res : Mat2<N> = copy *self;
res.invert(); res.invert();
@ -133,8 +133,8 @@ impl<N:Copy> Transpose for Mat2<N>
#[inline(always)] #[inline(always)]
fn transposed(&self) -> Mat2<N> fn transposed(&self) -> Mat2<N>
{ {
Mat2::new(self.m11, self.m21, Mat2::new(copy self.m11, copy self.m21,
self.m12, self.m22) copy self.m12, copy self.m22)
} }
#[inline(always)] #[inline(always)]
@ -184,18 +184,18 @@ impl<N: Copy> Flatten<N> for Mat2<N>
#[inline(always)] #[inline(always)]
fn from_flattened(l: &[N], off: uint) -> Mat2<N> fn from_flattened(l: &[N], off: uint) -> Mat2<N>
{ Mat2::new(l[off], l[off + 1], l[off + 2], l[off + 3]) } { Mat2::new(copy l[off], copy l[off + 1], copy l[off + 2], copy l[off + 3]) }
#[inline(always)] #[inline(always)]
fn flatten(&self) -> ~[N] fn flatten(&self) -> ~[N]
{ ~[ self.m11, self.m12, self.m21, self.m22 ] } { ~[ copy self.m11, copy self.m12, copy self.m21, copy self.m22 ] }
#[inline(always)] #[inline(always)]
fn flatten_to(&self, l: &mut [N], off: uint) fn flatten_to(&self, l: &mut [N], off: uint)
{ {
l[off] = self.m11; l[off] = copy self.m11;
l[off + 1] = self.m12; l[off + 1] = copy self.m12;
l[off + 2] = self.m21; l[off + 2] = copy self.m21;
l[off + 3] = self.m22; l[off + 3] = copy self.m22;
} }
} }

38
src/dim2/vec2.rs
View File

@ -57,8 +57,8 @@ ScalarMul<N> for Vec2<N>
#[inline(always)] #[inline(always)]
fn scalar_mul_inplace(&mut self, s: &N) fn scalar_mul_inplace(&mut self, s: &N)
{ {
self.x *= *s; self.x = self.x * copy *s;
self.y *= *s; self.y = self.y * copy *s;
} }
} }
@ -73,8 +73,8 @@ ScalarDiv<N> for Vec2<N>
#[inline(always)] #[inline(always)]
fn scalar_div_inplace(&mut self, s: &N) fn scalar_div_inplace(&mut self, s: &N)
{ {
self.x /= *s; self.x = self.x / copy *s;
self.y /= *s; self.y = self.y / copy *s;
} }
} }
@ -88,8 +88,8 @@ ScalarAdd<N> for Vec2<N>
#[inline(always)] #[inline(always)]
fn scalar_add_inplace(&mut self, s: &N) fn scalar_add_inplace(&mut self, s: &N)
{ {
self.x += *s; self.x = self.x + copy *s;
self.y += *s; self.y = self.y + copy *s;
} }
} }
@ -103,8 +103,8 @@ ScalarSub<N> for Vec2<N>
#[inline(always)] #[inline(always)]
fn scalar_sub_inplace(&mut self, s: &N) fn scalar_sub_inplace(&mut self, s: &N)
{ {
self.x -= *s; self.x = self.x - copy *s;
self.y -= *s; self.y = self.y - copy *s;
} }
} }
@ -112,7 +112,7 @@ impl<N: Copy + Add<N, N>> Translation<Vec2<N>> for Vec2<N>
{ {
#[inline(always)] #[inline(always)]
fn translation(&self) -> Vec2<N> fn translation(&self) -> Vec2<N>
{ *self } { copy *self }
#[inline(always)] #[inline(always)]
fn translated(&self, t: &Vec2<N>) -> Vec2<N> fn translated(&self, t: &Vec2<N>) -> Vec2<N>
@ -120,7 +120,7 @@ impl<N: Copy + Add<N, N>> Translation<Vec2<N>> for Vec2<N>
#[inline(always)] #[inline(always)]
fn translate(&mut self, t: &Vec2<N>) fn translate(&mut self, t: &Vec2<N>)
{ *self += *t; } { *self = *self + copy *t; }
} }
impl<N:Copy + Mul<N, N> + Add<N, N>> Dot<N> for Vec2<N> impl<N:Copy + Mul<N, N> + Add<N, N>> Dot<N> for Vec2<N>
@ -161,10 +161,10 @@ Norm<N> for Vec2<N>
{ {
let l = self.norm(); let l = self.norm();
self.x /= l; self.x = self.x / copy l;
self.y /= l; self.y = self.y / copy l;
l copy l
} }
} }
@ -188,7 +188,7 @@ impl<N:Copy + Zero> Zero for Vec2<N>
fn zero() -> Vec2<N> fn zero() -> Vec2<N>
{ {
let _0 = Zero::zero(); let _0 = Zero::zero();
Vec2::new(_0, _0) Vec2::new(copy _0, copy _0)
} }
#[inline(always)] #[inline(always)]
@ -208,7 +208,7 @@ impl<N: Copy + One + Zero + Neg<N>> Basis for Vec2<N>
#[inline(always)] #[inline(always)]
fn orthogonal_subspace_basis(&self) -> ~[Vec2<N>] fn orthogonal_subspace_basis(&self) -> ~[Vec2<N>]
{ ~[ Vec2::new(-self.y, self.x) ] } { ~[ Vec2::new(-self.y, copy self.x) ] }
} }
impl<N:ApproxEq<N>> ApproxEq<N> for Vec2<N> impl<N:ApproxEq<N>> ApproxEq<N> for Vec2<N>
@ -244,17 +244,17 @@ impl<N: Copy> Flatten<N> for Vec2<N>
#[inline(always)] #[inline(always)]
fn from_flattened(l: &[N], off: uint) -> Vec2<N> fn from_flattened(l: &[N], off: uint) -> Vec2<N>
{ Vec2::new(l[off], l[off + 1]) } { Vec2::new(copy l[off], copy l[off + 1]) }
#[inline(always)] #[inline(always)]
fn flatten(&self) -> ~[N] fn flatten(&self) -> ~[N]
{ ~[ self.x, self.y ] } { ~[ copy self.x, copy self.y ] }
#[inline(always)] #[inline(always)]
fn flatten_to(&self, l: &mut [N], off: uint) fn flatten_to(&self, l: &mut [N], off: uint)
{ {
l[off] = self.x; l[off] = copy self.x;
l[off + 1] = self.y; l[off + 1] = copy self.y;
} }
} }

50
src/dim3/mat3.rs
View File

@ -46,9 +46,9 @@ impl<N:Copy + One + Zero> One for Mat3<N>
fn one() -> Mat3<N> fn one() -> Mat3<N>
{ {
let (_0, _1) = (Zero::zero(), One::one()); let (_0, _1) = (Zero::zero(), One::one());
return Mat3::new(_1, _0, _0, return Mat3::new(copy _1, copy _0, copy _0,
_0, _1, _0, copy _0, copy _1, copy _0,
_0, _0, _1) copy _0, copy _0, copy _1)
} }
} }
@ -58,9 +58,9 @@ impl<N:Copy + Zero> Zero for Mat3<N>
fn zero() -> Mat3<N> fn zero() -> Mat3<N>
{ {
let _0 = Zero::zero(); let _0 = Zero::zero();
return Mat3::new(_0, _0, _0, return Mat3::new(copy _0, copy _0, copy _0,
_0, _0, _0, copy _0, copy _0, copy _0,
_0, _0, _0) copy _0, copy _0, copy _0)
} }
#[inline(always)] #[inline(always)]
@ -125,7 +125,7 @@ Inv for Mat3<N>
#[inline(always)] #[inline(always)]
fn inverse(&self) -> Mat3<N> fn inverse(&self) -> Mat3<N>
{ {
let mut res = *self; let mut res = copy *self;
res.invert(); res.invert();
@ -166,9 +166,9 @@ impl<N:Copy> Transpose for Mat3<N>
#[inline(always)] #[inline(always)]
fn transposed(&self) -> Mat3<N> fn transposed(&self) -> Mat3<N>
{ {
Mat3::new(self.m11, self.m21, self.m31, Mat3::new(copy self.m11, copy self.m21, copy self.m31,
self.m12, self.m22, self.m32, copy self.m12, copy self.m22, copy self.m32,
self.m13, self.m23, self.m33) copy self.m13, copy self.m23, copy self.m33)
} }
#[inline(always)] #[inline(always)]
@ -238,31 +238,31 @@ impl<N: Copy> Flatten<N> for Mat3<N>
#[inline(always)] #[inline(always)]
fn from_flattened(l: &[N], off: uint) -> Mat3<N> fn from_flattened(l: &[N], off: uint) -> Mat3<N>
{ Mat3::new(l[off + 0], l[off + 1], l[off + 2], { Mat3::new(copy l[off + 0], copy l[off + 1], copy l[off + 2],
l[off + 3], l[off + 4], l[off + 5], copy l[off + 3], copy l[off + 4], copy l[off + 5],
l[off + 6], l[off + 7], l[off + 8]) } copy l[off + 6], copy l[off + 7], copy l[off + 8]) }
#[inline(always)] #[inline(always)]
fn flatten(&self) -> ~[N] fn flatten(&self) -> ~[N]
{ {
~[ ~[
self.m11, self.m12, self.m13, copy self.m11, copy self.m12, copy self.m13,
self.m21, self.m22, self.m23, copy self.m21, copy self.m22, copy self.m23,
self.m31, self.m32, self.m33 copy self.m31, copy self.m32, copy self.m33
] ]
} }
#[inline(always)] #[inline(always)]
fn flatten_to(&self, l: &mut [N], off: uint) fn flatten_to(&self, l: &mut [N], off: uint)
{ {
l[off + 0] = self.m11; l[off + 0] = copy self.m11;
l[off + 1] = self.m12; l[off + 1] = copy self.m12;
l[off + 2] = self.m13; l[off + 2] = copy self.m13;
l[off + 3] = self.m21; l[off + 3] = copy self.m21;
l[off + 4] = self.m22; l[off + 4] = copy self.m22;
l[off + 5] = self.m23; l[off + 5] = copy self.m23;
l[off + 6] = self.m31; l[off + 6] = copy self.m31;
l[off + 7] = self.m32; l[off + 7] = copy self.m32;
l[off + 8] = self.m33; l[off + 8] = copy self.m33;
} }
} }

54
src/dim3/vec3.rs
View File

@ -57,9 +57,9 @@ ScalarMul<N> for Vec3<N>
#[inline(always)] #[inline(always)]
fn scalar_mul_inplace(&mut self, s: &N) fn scalar_mul_inplace(&mut self, s: &N)
{ {
self.x *= *s; self.x = self.x * copy *s;
self.y *= *s; self.y = self.y * copy *s;
self.z *= *s; self.z = self.z * copy *s;
} }
} }
@ -74,9 +74,9 @@ ScalarDiv<N> for Vec3<N>
#[inline(always)] #[inline(always)]
fn scalar_div_inplace(&mut self, s: &N) fn scalar_div_inplace(&mut self, s: &N)
{ {
self.x /= *s; self.x = self.x / copy *s;
self.y /= *s; self.y = self.y / copy *s;
self.z /= *s; self.z = self.z / copy *s;
} }
} }
@ -90,9 +90,9 @@ ScalarAdd<N> for Vec3<N>
#[inline(always)] #[inline(always)]
fn scalar_add_inplace(&mut self, s: &N) fn scalar_add_inplace(&mut self, s: &N)
{ {
self.x += *s; self.x = self.x + copy *s;
self.y += *s; self.y = self.y + copy *s;
self.z += *s; self.z = self.z + copy *s;
} }
} }
@ -106,9 +106,9 @@ ScalarSub<N> for Vec3<N>
#[inline(always)] #[inline(always)]
fn scalar_sub_inplace(&mut self, s: &N) fn scalar_sub_inplace(&mut self, s: &N)
{ {
self.x -= *s; self.x = self.x - copy *s;
self.y -= *s; self.y = self.y - copy *s;
self.z -= *s; self.z = self.z - copy *s;
} }
} }
@ -116,7 +116,7 @@ impl<N: Copy + Add<N, N>> Translation<Vec3<N>> for Vec3<N>
{ {
#[inline(always)] #[inline(always)]
fn translation(&self) -> Vec3<N> fn translation(&self) -> Vec3<N>
{ *self } { copy *self }
#[inline(always)] #[inline(always)]
fn translated(&self, t: &Vec3<N>) -> Vec3<N> fn translated(&self, t: &Vec3<N>) -> Vec3<N>
@ -124,7 +124,7 @@ impl<N: Copy + Add<N, N>> Translation<Vec3<N>> for Vec3<N>
#[inline(always)] #[inline(always)]
fn translate(&mut self, t: &Vec3<N>) fn translate(&mut self, t: &Vec3<N>)
{ *self += *t; } { *self = *self + copy *t; }
} }
@ -174,9 +174,9 @@ Norm<N> for Vec3<N>
{ {
let l = self.norm(); let l = self.norm();
self.x /= l; self.x = self.x / copy l;
self.y /= l; self.y = self.y / copy l;
self.z /= l; self.z = self.z / copy l;
l l
} }
@ -201,7 +201,7 @@ impl<N:Copy + Zero> Zero for Vec3<N>
fn zero() -> Vec3<N> fn zero() -> Vec3<N>
{ {
let _0 = Zero::zero(); let _0 = Zero::zero();
Vec3::new(_0, _0, _0) Vec3::new(copy _0, copy _0, copy _0)
} }
#[inline(always)] #[inline(always)]
@ -226,12 +226,12 @@ Basis for Vec3<N>
fn orthogonal_subspace_basis(&self) -> ~[Vec3<N>] fn orthogonal_subspace_basis(&self) -> ~[Vec3<N>]
{ {
let a = let a =
if (abs(self.x) > abs(self.y)) if (abs(copy self.x) > abs(copy self.y))
{ Vec3::new(self.z, Zero::zero(), -self.x).normalized() } { Vec3::new(copy self.z, Zero::zero(), -copy self.x).normalized() }
else else
{ Vec3::new(Zero::zero(), -self.z, self.y).normalized() }; { Vec3::new(Zero::zero(), -self.z, copy self.y).normalized() };
~[ a, a.cross(self) ] ~[ a.cross(self), a ]
} }
} }
@ -273,18 +273,18 @@ impl<N: Copy> Flatten<N> for Vec3<N>
#[inline(always)] #[inline(always)]
fn from_flattened(l: &[N], off: uint) -> Vec3<N> fn from_flattened(l: &[N], off: uint) -> Vec3<N>
{ Vec3::new(l[off], l[off + 1], l[off + 2]) } { Vec3::new(copy l[off], copy l[off + 1], copy l[off + 2]) }
#[inline(always)] #[inline(always)]
fn flatten(&self) -> ~[N] fn flatten(&self) -> ~[N]
{ ~[ self.x, self.y, self.z ] } { ~[ copy self.x, copy self.y, copy self.z ] }
#[inline(always)] #[inline(always)]
fn flatten_to(&self, l: &mut [N], off: uint) fn flatten_to(&self, l: &mut [N], off: uint)
{ {
l[off] = self.x; l[off] = copy self.x;
l[off + 1] = self.y; l[off + 1] = copy self.y;
l[off + 2] = self.z; l[off + 2] = copy self.z;
} }
} }

8
src/ndim/dmat.rs
View File

@ -47,7 +47,7 @@ impl<N: Copy> DMat<N>
{ {
assert!(i < self.dim); assert!(i < self.dim);
assert!(j < self.dim); assert!(j < self.dim);
self.mij[self.offset(i, j)] = *t self.mij[self.offset(i, j)] = copy *t
} }
#[inline(always)] #[inline(always)]
@ -55,7 +55,7 @@ impl<N: Copy> DMat<N>
{ {
assert!(i < self.dim); assert!(i < self.dim);
assert!(j < self.dim); assert!(j < self.dim);
self.mij[self.offset(i, j)] copy self.mij[self.offset(i, j)]
} }
} }
@ -83,7 +83,7 @@ Mul<DMat<N>, DMat<N>> for DMat<N>
let mut acc = Zero::zero::<N>(); let mut acc = Zero::zero::<N>();
for iterate(0u, dim) |k| for iterate(0u, dim) |k|
{ acc += self.at(i, k) * other.at(k, j); } { acc = acc + self.at(i, k) * other.at(k, j); }
res.set(i, j, &acc); res.set(i, j, &acc);
} }
@ -166,7 +166,7 @@ Inv for DMat<N>
if (self.at(n0, k) != _0T) if (self.at(n0, k) != _0T)
{ break; } { break; }
n0 += 1; n0 = n0 + 1;
} }
assert!(n0 != dim); // non inversible matrix assert!(n0 != dim); // non inversible matrix

18
src/ndim/dvec.rs
View File

@ -62,10 +62,10 @@ impl<N: Copy + DivisionRing + Algebraic + Clone + ApproxEq<N>> DVec<N>
let mut elt = basis_element.clone(); let mut elt = basis_element.clone();
elt -= self.scalar_mul(&basis_element.dot(self)); elt = elt - self.scalar_mul(&basis_element.dot(self));
for res.each |v| for res.each |v|
{ elt -= v.scalar_mul(&elt.dot(v)) }; { elt = elt - v.scalar_mul(&elt.dot(v)) };
if (!elt.sqnorm().approx_eq(&Zero::zero())) if (!elt.sqnorm().approx_eq(&Zero::zero()))
{ res.push(elt.normalized()); } { res.push(elt.normalized()); }
@ -115,7 +115,7 @@ Dot<N> for DVec<N>
let mut res = Zero::zero::<N>(); let mut res = Zero::zero::<N>();
for iterate(0u, self.at.len()) |i| for iterate(0u, self.at.len()) |i|
{ res += self.at[i] * other.at[i]; } { res = res + self.at[i] * other.at[i]; }
res res
} }
@ -129,7 +129,7 @@ impl<N: Copy + Ring> SubDot<N> for DVec<N>
let mut res = Zero::zero::<N>(); let mut res = Zero::zero::<N>();
for iterate(0u, self.at.len()) |i| for iterate(0u, self.at.len()) |i|
{ res += (self.at[i] - a.at[i]) * b.at[i]; } { res = res + (self.at[i] - a.at[i]) * b.at[i]; }
res res
} }
@ -146,7 +146,7 @@ ScalarMul<N> for DVec<N>
fn scalar_mul_inplace(&mut self, s: &N) fn scalar_mul_inplace(&mut self, s: &N)
{ {
for iterate(0u, self.at.len()) |i| for iterate(0u, self.at.len()) |i|
{ self.at[i] *= *s; } { self.at[i] = self.at[i] * copy *s; }
} }
} }
@ -162,7 +162,7 @@ ScalarDiv<N> for DVec<N>
fn scalar_div_inplace(&mut self, s: &N) fn scalar_div_inplace(&mut self, s: &N)
{ {
for iterate(0u, self.at.len()) |i| for iterate(0u, self.at.len()) |i|
{ self.at[i] /= *s; } { self.at[i] = self.at[i] / copy *s; }
} }
} }
@ -177,7 +177,7 @@ ScalarAdd<N> for DVec<N>
fn scalar_add_inplace(&mut self, s: &N) fn scalar_add_inplace(&mut self, s: &N)
{ {
for iterate(0u, self.at.len()) |i| for iterate(0u, self.at.len()) |i|
{ self.at[i] += *s; } { self.at[i] = self.at[i] + copy *s; }
} }
} }
@ -192,7 +192,7 @@ ScalarSub<N> for DVec<N>
fn scalar_sub_inplace(&mut self, s: &N) fn scalar_sub_inplace(&mut self, s: &N)
{ {
for iterate(0u, self.at.len()) |i| for iterate(0u, self.at.len()) |i|
{ self.at[i] -= *s; } { self.at[i] = self.at[i] - copy *s; }
} }
} }
@ -238,7 +238,7 @@ Norm<N> for DVec<N>
let l = self.norm(); let l = self.norm();
for iterate(0u, self.at.len()) |i| for iterate(0u, self.at.len()) |i|
{ self.at[i] /= l; } { self.at[i] = self.at[i] / copy l; }
l l
} }

8
src/ndim/nmat.rs
View File

@ -77,7 +77,7 @@ Mul<NMat<D, N>, NMat<D, N>> for NMat<D, N>
let mut acc: N = Zero::zero(); let mut acc: N = Zero::zero();
for iterate(0u, dim) |k| for iterate(0u, dim) |k|
{ acc += self[(i, k)] * other[(k, j)]; } { acc = acc + self[(i, k)] * other[(k, j)]; }
res.set(i, j, &acc); res.set(i, j, &acc);
} }
@ -197,7 +197,7 @@ impl<D: Dim, N: Zero + Copy> Flatten<N> for NMat<D, N>
let mut res = Zero::zero::<NMat<D, N>>(); let mut res = Zero::zero::<NMat<D, N>>();
for iterate(0u, dim * dim) |i| for iterate(0u, dim * dim) |i|
{ res.mij.mij[i] = l[off + i] } { res.mij.mij[i] = copy l[off + i] }
res res
} }
@ -209,7 +209,7 @@ impl<D: Dim, N: Zero + Copy> Flatten<N> for NMat<D, N>
let mut res = ~[]; let mut res = ~[];
for iterate(0u, dim * dim) |i| for iterate(0u, dim * dim) |i|
{ res.push(self.mij.mij[i]) } { res.push(copy self.mij.mij[i]) }
res res
} }
@ -220,6 +220,6 @@ impl<D: Dim, N: Zero + Copy> Flatten<N> for NMat<D, N>
let dim = Dim::dim::<D>(); let dim = Dim::dim::<D>();
for iterate(0u, dim * dim) |i| for iterate(0u, dim * dim) |i|
{ l[off + i] = self.mij.mij[i] } { l[off + i] = copy self.mij.mij[i] }
} }
} }

6
src/ndim/nvec.rs
View File

@ -239,7 +239,7 @@ impl<D: Dim, N: Zero + Copy> Flatten<N> for NVec<D, N>
let mut res = Zero::zero::<NVec<D, N>>(); let mut res = Zero::zero::<NVec<D, N>>();
for iterate(0u, dim) |i| for iterate(0u, dim) |i|
{ res.at.at[i] = l[off + i] } { res.at.at[i] = copy l[off + i] }
res res
} }
@ -251,7 +251,7 @@ impl<D: Dim, N: Zero + Copy> Flatten<N> for NVec<D, N>
let mut res = ~[]; let mut res = ~[];
for iterate(0u, dim) |i| for iterate(0u, dim) |i|
{ res.push(self.at.at[i]) } { res.push(copy self.at.at[i]) }
res res
} }
@ -262,7 +262,7 @@ impl<D: Dim, N: Zero + Copy> Flatten<N> for NVec<D, N>
let dim = Dim::dim::<D>(); let dim = Dim::dim::<D>();
for iterate(0u, dim) |i| for iterate(0u, dim) |i|
{ l[off + i] = self.at.at[i] } { l[off + i] = copy self.at.at[i] }
} }
} }

48
src/tests/vec.rs
View File

@ -28,6 +28,8 @@ use traits::dot::Dot;
use traits::norm::Norm; use traits::norm::Norm;
#[test] #[test]
use traits::flatten::Flatten; use traits::flatten::Flatten;
#[test]
use traits::scalar_op::{ScalarMul, ScalarDiv, ScalarAdd, ScalarSub};
macro_rules! test_commut_dot_impl( macro_rules! test_commut_dot_impl(
($t: ty) => ( ($t: ty) => (
@ -41,6 +43,30 @@ macro_rules! test_commut_dot_impl(
); );
) )
macro_rules! test_scalar_op_impl(
($t: ty, $n: ty) => (
for 10000.times
{
let v1 : $t = random();
let n : $n = random();
assert!(v1.scalar_mul(&n).scalar_div(&n).approx_eq(&v1));
assert!(v1.scalar_div(&n).scalar_mul(&n).approx_eq(&v1));
assert!(v1.scalar_sub(&n).scalar_add(&n).approx_eq(&v1));
assert!(v1.scalar_add(&n).scalar_sub(&n).approx_eq(&v1));
let mut v1 : $t = random();
let v0 : $t = copy v1;
let n : $n = random();
v1.scalar_mul_inplace(&n);
v1.scalar_div_inplace(&n);
assert!(v1.approx_eq(&v0));
}
);
)
macro_rules! test_basis_impl( macro_rules! test_basis_impl(
($t: ty) => ( ($t: ty) => (
for 10000.times for 10000.times
@ -62,9 +88,9 @@ macro_rules! test_subspace_basis_impl(
($t: ty) => ( ($t: ty) => (
for 10000.times for 10000.times
{ {
let v : Vec3<f64> = random(); let v : $t = random();
let v1 = v.normalized(); let v1 = v.normalized();
let subbasis = v1.orthogonal_subspace_basis(); let subbasis = v1.orthogonal_subspace_basis();
// check vectors are orthogonal to v1 // check vectors are orthogonal to v1
assert!(subbasis.all(|e| v1.dot(e).approx_eq(&Zero::zero()))); assert!(subbasis.all(|e| v1.dot(e).approx_eq(&Zero::zero())));
@ -171,3 +197,19 @@ fn test_flatten_vec3()
#[test] #[test]
fn test_flatten_nvec() fn test_flatten_nvec()
{ test_flatten_impl!(NVec<d7, f64>, f64); } { test_flatten_impl!(NVec<d7, f64>, f64); }
#[test]
fn test_scalar_op_vec1()
{ test_scalar_op_impl!(Vec1<f64>, f64); }
#[test]
fn test_scalar_op_vec2()
{ test_scalar_op_impl!(Vec2<f64>, f64); }
#[test]
fn test_scalar_op_vec3()
{ test_scalar_op_impl!(Vec3<f64>, f64); }
#[test]
fn test_scalar_op_nvec()
{ test_scalar_op_impl!(NVec<d7, f64>, f64); }