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

Update to work with the last compiler. 

Because of the unfortunate changes on type parameters resolution:
        - the Dim trait now needs an useless parameter to infer the Self type.
        - ApproxEps::epsilon() is broken.
This commit is contained in:
Sébastien Crozet 2013-08-28 14:22:12 +02:00
parent f465928085
commit 82ddda154f
13 changed files with 60 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/adaptors/rotmat.rs
View File

@ -54,7 +54,7 @@ impl<N: Clone + Trigonometric + Num + Algebraic> Rotmat<Mat3<N>> {
else {
let mut axis = axisangle;
let angle = axis.normalize();
let _1 = One::one::<N>();
let _1: N = One::one();
let ux = axis.x.clone();
let uy = axis.y.clone();
let uz = axis.z.clone();
@ -208,8 +208,9 @@ Rand for Rotmat<Mat3<N>> {
impl<M: Dim> Dim for Rotmat<M> {
#[inline]
fn dim() -> uint {
Dim::dim::<M>()
fn dim(_: Option<Rotmat<M>>) -> uint {
let _dim: Option<M> = None;
Dim::dim(_dim)
}
}
@ -278,7 +279,8 @@ impl<M: ToHomogeneous<M2>, M2> ToHomogeneous<M2> for Rotmat<M> {
impl<N: ApproxEq<N>, M: ApproxEq<N>> ApproxEq<N> for Rotmat<M> {
#[inline]
fn approx_epsilon() -> N {
ApproxEq::approx_epsilon::<N, N>()
// ApproxEq::<N>::approx_epsilon()
fail!("approx_epsilon is broken since rust revision 8693943676487c01fa09f5f3daf0df6a1f71e24d.")
}
#[inline]

19
src/adaptors/transform.rs
View File

@ -85,8 +85,9 @@ impl<N: Clone + Num + Algebraic> Transform<Rotmat<Mat3<N>>, Vec3<N>> {
impl<M: Dim, V> Dim for Transform<M, V> {
#[inline]
fn dim() -> uint {
Dim::dim::<M>()
fn dim(_: Option<Transform<M, V>>) -> uint {
let _dim: Option<M> = None;
Dim::dim(_dim)
}
}
@ -188,7 +189,7 @@ Rotation<AV> for Transform<M, V> {
#[inline]
fn rotate_by(&mut self, rot: &AV) {
// FIXME: this does not seem opitmal
let mut delta = One::one::<M>();
let mut delta: M = One::one();
delta.rotate_by(rot);
self.submat.rotate_by(rot);
self.subtrans = delta.rmul(&self.subtrans);
@ -197,7 +198,8 @@ Rotation<AV> for Transform<M, V> {
#[inline]
fn rotated(&self, rot: &AV) -> Transform<M, V> {
// FIXME: this does not seem opitmal
let delta = One::one::<M>().rotated(rot);
let _1: M = One::one();
let delta = _1.rotated(rot);
Transform::new(self.submat.rotated(rot), delta.rmul(&self.subtrans))
}
@ -283,7 +285,8 @@ ToHomogeneous<M2> for Transform<M, V> {
let mut res = self.submat.to_homogeneous();
// copy the translation
let dim = Dim::dim::<M2>();
let _dim: Option<M2> = None;
let dim = Dim::dim(_dim);
res.set_column(dim - 1, self.subtrans.to_homogeneous());
@ -294,7 +297,8 @@ ToHomogeneous<M2> for Transform<M, V> {
impl<M: Column<V> + Dim, M2: FromHomogeneous<M>, V>
FromHomogeneous<M> for Transform<M2, V> {
fn from(m: &M) -> Transform<M2, V> {
Transform::new(FromHomogeneous::from(m), m.column(Dim::dim::<M>() - 1))
let _dim: Option<M> = None;
Transform::new(FromHomogeneous::from(m), m.column(Dim::dim(_dim) - 1))
}
}
@ -302,7 +306,8 @@ impl<N: ApproxEq<N>, M:ApproxEq<N>, V:ApproxEq<N>>
ApproxEq<N> for Transform<M, V> {
#[inline]
fn approx_epsilon() -> N {
ApproxEq::approx_epsilon::<N, N>()
fail!("approx_epsilon is broken since rust revision 8693943676487c01fa09f5f3daf0df6a1f71e24d.")
// ApproxEq::<N>::approx_epsilon()
}
#[inline]

13
src/dmat.rs
View File

@ -36,8 +36,8 @@ pub fn is_zero_mat<N: Zero>(mat: &DMat<N>) -> bool {
/// components.
#[inline]
pub fn one_mat_with_dim<N: Clone + One + Zero>(dim: uint) -> DMat<N> {
let mut res = zero_mat_with_dim(dim);
let _1 = One::one::<N>();
let mut res = zero_mat_with_dim(dim);
let _1: N = One::one();
for i in range(0u, dim) {
res.set(i, i, &_1);
@ -94,7 +94,7 @@ Mul<DMat<N>, DMat<N>> for DMat<N> {
for i in range(0u, dim) {
for j in range(0u, dim) {
let mut acc = Zero::zero::<N>();
let mut acc: N = Zero::zero();
for k in range(0u, dim) {
acc = acc + self.at(i, k) * other.at(k, j);
@ -161,7 +161,7 @@ Inv for DMat<N> {
fn inplace_inverse(&mut self) -> bool {
let dim = self.dim;
let mut res = one_mat_with_dim::<N>(dim);
let _0T = Zero::zero::<N>();
let _0T: N = Zero::zero();
// inversion using Gauss-Jordan elimination
for k in range(0u, dim) {
@ -256,7 +256,10 @@ impl<N: Clone> Transpose for DMat<N> {
impl<N: ApproxEq<N>> ApproxEq<N> for DMat<N> {
#[inline]
fn approx_epsilon() -> N {
ApproxEq::approx_epsilon::<N, N>()
fail!("Fix this.")
// let res: N = ApproxEq::<N>::approx_epsilon();
// res
}
#[inline]

11
src/dvec.rs
View File

@ -21,7 +21,7 @@ pub struct DVec<N> {
/// * `dim` - The dimension of the vector.
#[inline]
pub fn zero_vec_with_dim<N: Zero + Clone>(dim: uint) -> DVec<N> {
DVec { at: from_elem(dim, Zero::zero::<N>()) }
DVec { at: from_elem(dim, Zero::zero()) }
}
/// Tests if all components of the vector are zeroes.
@ -140,7 +140,7 @@ impl<N: Num> DVec<N> {
fn dot(&self, other: &DVec<N>) -> N {
assert!(self.at.len() == other.at.len());
let mut res = Zero::zero::<N>();
let mut res: N = Zero::zero();
for i in range(0u, self.at.len()) {
res = res + self.at[i] * other.at[i];
@ -151,7 +151,7 @@ impl<N: Num> DVec<N> {
#[inline]
fn sub_dot(&self, a: &DVec<N>, b: &DVec<N>) -> N {
let mut res = Zero::zero::<N>();
let mut res: N = Zero::zero();
for i in range(0u, self.at.len()) {
res = res + (self.at[i] - a.at[i]) * b.at[i];
@ -261,7 +261,10 @@ impl<N: Num + Algebraic + Clone> DVec<N> {
impl<N: ApproxEq<N>> ApproxEq<N> for DVec<N> {
#[inline]
fn approx_epsilon() -> N {
ApproxEq::approx_epsilon::<N, N>()
fail!("Fix me.")
// let res: N = ApproxEq::<N>::approx_epsilon();
// res
}
#[inline]

21
src/mat_macros.rs
View File

@ -136,7 +136,7 @@ macro_rules! one_impl(
impl<N: Clone + One + Zero> One for $t<N> {
#[inline]
fn one() -> $t<N> {
let (_0, _1) = (Zero::zero::<N>(), One::one::<N>());
let (_0, _1): (N, N) = (Zero::zero(), One::one());
return $t::new($value0.clone() $(, $valueN.clone() )*)
}
}
@ -147,7 +147,7 @@ macro_rules! dim_impl(
($t: ident, $dim: expr) => (
impl<N> Dim for $t<N> {
#[inline]
fn dim() -> uint {
fn dim(_: Option<$t<N>>) -> uint {
$dim
}
}
@ -194,7 +194,7 @@ macro_rules! column_impl(
#[inline]
fn column(&self, col: uint) -> $tv<N> {
let mut res = Zero::zero::<$tv<N>>();
let mut res: $tv<N> = Zero::zero();
for (i, e) in res.mut_iter().enumerate() {
*e = self.at((i, col));
@ -218,7 +218,7 @@ macro_rules! row_impl(
#[inline]
fn row(&self, row: uint) -> $tv<N> {
let mut res = Zero::zero::<$tv<N>>();
let mut res: $tv<N> = Zero::zero();
for (i, e) in res.mut_iter().enumerate() {
*e = self.at((row, i));
@ -239,7 +239,7 @@ macro_rules! mul_impl(
for i in range(0u, $dim) {
for j in range(0u, $dim) {
let mut acc = Zero::zero::<N>();
let mut acc: N = Zero::zero();
for k in range(0u, $dim) {
acc = acc + self.at((i, k)) * other.at((k, j));
@ -429,7 +429,8 @@ macro_rules! approx_eq_impl(
impl<N: ApproxEq<N>> ApproxEq<N> for $t<N> {
#[inline]
fn approx_epsilon() -> N {
ApproxEq::approx_epsilon::<N, N>()
fail!("approx_epsilon is broken since rust revision 8693943676487c01fa09f5f3daf0df6a1f71e24d.")
// ApproxEq::<N>::approx_epsilon()
}
#[inline]
@ -499,10 +500,12 @@ macro_rules! outer_impl(
impl<N: Mul<N, N> + Zero + Clone> Outer<$t<N>, $m<N>> for $t<N> {
#[inline]
fn outer(&self, other: &$t<N>) -> $m<N> {
let mut res = Zero::zero::<$m<N>>();
let mut res: $m<N> = Zero::zero();
for i in range(0u, Dim::dim::<$t<N>>()) {
for j in range(0u, Dim::dim::<$t<N>>()) {
let _dim: Option<$t<N>> = None;
for i in range(0u, Dim::dim(_dim)) {
let _dim: Option<$t<N>> = None;
for j in range(0u, Dim::dim(_dim)) {
res.set((i, j), self.at(i) * other.at(j))
}
}

3
src/mat_spec.rs
View File

@ -25,7 +25,8 @@ Inv for Mat1<N> {
false
}
else {
self.m11 = One::one::<N>() / self.m11;
let _1: N = One::one();
self.m11 = _1 / self.m11;
true
}
}

4
src/tests/mat.rs
View File

@ -104,7 +104,7 @@ fn test_inv_mat6() {
#[test]
fn test_rotation2() {
do 10000.times {
let randmat = One::one::<Rotmat<Mat2<f64>>>();
let randmat: Rotmat<Mat2<f64>> = One::one();
let ang = &Vec1::new(abs::<f64>(random()) % Real::pi());
assert!(randmat.rotated(ang).rotation().approx_eq(ang));
@ -121,7 +121,7 @@ fn test_index_mat2() {
#[test]
fn test_inv_rotation3() {
do 10000.times {
let randmat = One::one::<Rotmat<Mat3<f64>>>();
let randmat: Rotmat<Mat3<f64>> = One::one();
let dir: Vec3<f64> = random();
let ang = &(dir.normalized() * (abs::<f64>(random()) % Real::pi()));
let rot = randmat.rotated(ang);

4
src/tests/vec.rs
View File

@ -76,8 +76,8 @@ macro_rules! test_scalar_op_impl(
macro_rules! test_basis_impl(
($t: ty) => (
do 10000.times {
do Basis::canonical_basis::<$t> |e1| {
do Basis::canonical_basis::<$t> |e2| {
do Basis::canonical_basis |e1: $t| {
do Basis::canonical_basis |e2: $t| {
assert!(e1 == e2 || e1.dot(&e2).approx_eq(&Zero::zero()));
true

2
src/traits/basis.rs
View File

@ -11,7 +11,7 @@ pub trait Basis {
fn canonical_basis_list() -> ~[Self] {
let mut res = ~[];
do Basis::canonical_basis::<Self> |elem| {
do Basis::canonical_basis |elem| {
res.push(elem);
true

2
src/traits/dim.rs
View File

@ -3,5 +3,5 @@
*/
pub trait Dim {
/// The dimension of the object.
fn dim() -> uint;
fn dim(unused_self: Option<Self>) -> uint;
}

2
src/traits/vector.rs
View File

@ -9,7 +9,7 @@ use traits::scalar_op::{ScalarAdd, ScalarSub};
// NOTE: cant call that `Vector` because it conflicts with std::Vector
/// Trait grouping most common operations on vectors.
pub trait Vec<N>: Dim + Sub<Self, Self> + Add<Self, Self> + Neg<Self> + Zero + Eq + Mul<N, Self>
+ Div<N, Self>
+ Div<N, Self>
{
/// Computes the dot (inner) product of two vectors.
#[inline]

5
src/vec0_spec.rs
View File

@ -61,7 +61,7 @@ impl<N> IterableMut<N> for vec::Vec0<N> {
impl<N> Dim for vec::Vec0<N> {
#[inline]
fn dim() -> uint {
fn dim(_: Option<vec::Vec0<N>>) -> uint {
0
}
}
@ -196,7 +196,8 @@ impl<N: Clone + Num + Algebraic> AlgebraicVec<N> for vec::Vec0<N> {
impl<N: ApproxEq<N>> ApproxEq<N> for vec::Vec0<N> {
#[inline]
fn approx_epsilon() -> N {
ApproxEq::approx_epsilon::<N, N>()
fail!("approx_epsilon is broken since rust revision 8693943676487c01fa09f5f3daf0df6a1f71e24d.")
// ApproxEq::<N>::approx_epsilon()
}
#[inline]

5
src/vec_macros.rs
View File

@ -174,7 +174,7 @@ macro_rules! dim_impl(
($t: ident, $dim: expr) => (
impl<N> Dim for $t<N> {
#[inline]
fn dim() -> uint {
fn dim(_: Option<$t<N>>) -> uint {
$dim
}
}
@ -427,7 +427,8 @@ macro_rules! approx_eq_impl(
impl<N: ApproxEq<N>> ApproxEq<N> for $t<N> {
#[inline]
fn approx_epsilon() -> N {
ApproxEq::approx_epsilon::<N, N>()
fail!("approx_epsilon is broken since rust revision 8693943676487c01fa09f5f3daf0df6a1f71e24d.")
// ApproxEq::<N>::approx_epsilon()
}
#[inline]