Merge pull request dimforge#55 from sebcrozet/rustup

Update to the last rust-nightly.

Author: sebcrozet

benches/common/macros.rs

@@ -16,7 +16,7 @@ macro_rules! bench_binop(
                 i = (i + 1) & (LEN - 1);
 
                 unsafe {
-                    test::black_box(elems1.unsafe_get(i).$binop(elems2.unsafe_get(i)))
+                    test::black_box(elems1.unsafe_get(i).$binop(*elems2.unsafe_get(i)))
                 }
             })
         }

benches/dmat.rs

@@ -9,12 +9,13 @@ use na::{DVec, DMat};
 macro_rules! bench_mul_dmat(
     ($bh: expr, $nrows: expr, $ncols: expr) => {
         {
-            let a:     DMat<f64> = DMat::new_random($nrows, $ncols);
-            let mut b: DMat<f64> = DMat::new_random($nrows, $ncols);
-
             $bh.iter(|| {
+                let a:     DMat<f64> = DMat::new_random($nrows, $ncols);
+                let mut b: DMat<f64> = DMat::new_random($nrows, $ncols);
+
                 for _ in range(0u, 1000) {
-                    b = a * b;
+                    // XXX: the clone here is highly undesirable!
+                    b = a.clone() * b;
                 }
             })
         }
@@ -49,12 +50,14 @@ fn bench_mul_dmat6(bh: &mut Bencher) {
 macro_rules! bench_mul_dmat_dvec(
     ($bh: expr, $nrows: expr, $ncols: expr) => {
         {
-            let m : DMat<f64>     = DMat::new_random($nrows, $ncols);
-            let mut v : DVec<f64> = DVec::new_random($ncols);
 
             $bh.iter(|| {
+                let m : DMat<f64>     = DMat::new_random($nrows, $ncols);
+                let mut v : DVec<f64> = DVec::new_random($ncols);
+
                 for _ in range(0u, 1000) {
-                    v = m * v
+                    // XXX: the clone here is highly undesirable!
+                    v = m.clone() * v
                 }
             })
         }

src/lib.rs

@@ -315,7 +315,7 @@ pub fn orig<P: Orig>() -> P {
 
 /// Returns the center of two points.
 #[inline]
-pub fn center<N: BaseFloat, P: FloatPnt<N, V>, V>(a: &P, b: &P) -> P {
+pub fn center<N: BaseFloat, P: FloatPnt<N, V>, V: Copy>(a: &P, b: &P) -> P {
     let _2 = one::<N>() + one();
     (*a + *b.as_vec()) / _2
 }

src/linalg/decompositions.rs

@@ -40,11 +40,11 @@ pub fn householder_matrix<N, V, M>(dim: uint, start: uint, vec: V) -> M
 pub fn qr<N, V, M>(m: &M) -> (M, M)
     where N: BaseFloat,
           V: Indexable<uint, N> + Norm<N>,
-          M: Clone + Eye + ColSlice<V> + Transpose + Indexable<(uint, uint), N> + Mul<M, M> {
+          M: Copy + Eye + ColSlice<V> + Transpose + Indexable<(uint, uint), N> + Mul<M, M> {
     let (rows, cols) = m.shape();
     assert!(rows >= cols);
     let mut q : M = Eye::new_identity(rows);
-    let mut r = m.clone();
+    let mut r = *m;
 
     let iterations = min(rows - 1, cols);
 
@@ -76,9 +76,9 @@ pub fn eigen_qr<N, V, VS, M>(m: &M, eps: &N, niter: uint) -> (M, V)
     where N:  BaseFloat,
           VS: Indexable<uint, N> + Norm<N>,
           M:  Indexable<(uint, uint), N> + SquareMat<N, V> + Add<M, M> + Sub<M, M> + ColSlice<VS> +
-              ApproxEq<N> + Clone {
+              ApproxEq<N> + Copy {
     let mut eigenvectors: M = ::one::<M>();
-    let mut eigenvalues = m.clone();
+    let mut eigenvalues = *m;
     // let mut shifter: M = Eye::new_identity(rows);
 
     let mut iter = 0u;

src/structs/dmat.rs

@@ -36,7 +36,7 @@ impl<N> DMat<N> {
     }
 }
 
-impl<N: Zero + Clone> DMat<N> {
+impl<N: Zero + Clone + Copy> DMat<N> {
     /// Builds a matrix filled with zeros.
     ///
     /// # Arguments
@@ -69,15 +69,15 @@ impl<N: Rand> DMat<N> {
     }
 }
 
-impl<N: One + Clone> DMat<N> {
+impl<N: One + Clone + Copy> DMat<N> {
     /// Builds a matrix filled with a given constant.
     #[inline]
     pub fn new_ones(nrows: uint, ncols: uint) -> DMat<N> {
         DMat::from_elem(nrows, ncols, ::one())
     }
 }
 
-impl<N: Clone> DMat<N> {
+impl<N: Clone + Copy> DMat<N> {
     /// Builds a matrix filled with a given constant.
     #[inline]
     pub fn from_elem(nrows: uint, ncols: uint, val: N) -> DMat<N> {
@@ -169,7 +169,7 @@ impl<N> DMat<N> {
 
 // FIXME: add a function to modify the dimension (to avoid useless allocations)?
 
-impl<N: One + Zero + Clone> Eye for DMat<N> {
+impl<N: One + Zero + Clone + Copy> Eye for DMat<N> {
     /// Builds an identity matrix.
     ///
     /// # Arguments
@@ -196,7 +196,7 @@ impl<N> DMat<N> {
 
 }
 
-impl<N: Clone> Indexable<(uint, uint), N> for DMat<N> {
+impl<N: Copy> Indexable<(uint, uint), N> for DMat<N> {
     /// Changes the value of a component of the matrix.
     ///
     /// # Arguments
@@ -235,7 +235,8 @@ impl<N: Clone> Indexable<(uint, uint), N> for DMat<N> {
     #[inline]
     unsafe fn unsafe_at(&self, rowcol: (uint,  uint)) -> N {
         let (row, col) = rowcol;
-        (*self.mij.as_slice().unsafe_get(self.offset(row, col))).clone()
+
+        *self.mij.as_slice().unsafe_get(self.offset(row, col))
     }
 
     #[inline]
@@ -283,8 +284,8 @@ impl<N> IndexMut<(uint, uint), N> for DMat<N> {
     }
 }
 
-impl<N: Clone + Mul<N, N> + Add<N, N> + Zero> Mul<DMat<N>, DMat<N>> for DMat<N> {
-    fn mul(&self, right: &DMat<N>) -> DMat<N> {
+impl<N: Copy + Mul<N, N> + Add<N, N> + Zero> Mul<DMat<N>, DMat<N>> for DMat<N> {
+    fn mul(self, right: DMat<N>) -> DMat<N> {
         assert!(self.ncols == right.nrows);
 
         let mut res = unsafe { DMat::new_uninitialized(self.nrows, right.ncols) };
@@ -308,8 +309,8 @@ impl<N: Clone + Mul<N, N> + Add<N, N> + Zero> Mul<DMat<N>, DMat<N>> for DMat<N>
     }
 }
 
-impl<N: Clone + Add<N, N> + Mul<N, N> + Zero> Mul<DVec<N>, DVec<N>> for DMat<N> {
-    fn mul(&self, right: &DVec<N>) -> DVec<N> {
+impl<N: Copy + Add<N, N> + Mul<N, N> + Zero> Mul<DVec<N>, DVec<N>> for DMat<N> {
+    fn mul(self, right: DVec<N>) -> DVec<N> {
         assert!(self.ncols == right.at.len());
 
         let mut res : DVec<N> = unsafe { DVec::new_uninitialized(self.nrows) };
@@ -331,8 +332,8 @@ impl<N: Clone + Add<N, N> + Mul<N, N> + Zero> Mul<DVec<N>, DVec<N>> for DMat<N>
 }
 
 
-impl<N: Clone + Add<N, N> + Mul<N, N> + Zero> Mul<DMat<N>, DVec<N>> for DVec<N> {
-    fn mul(&self, right: &DMat<N>) -> DVec<N> {
+impl<N: Copy + Add<N, N> + Mul<N, N> + Zero> Mul<DMat<N>, DVec<N>> for DVec<N> {
+    fn mul(self, right: DMat<N>) -> DVec<N> {
         assert!(right.nrows == self.at.len());
 
         let mut res : DVec<N> = unsafe { DVec::new_uninitialized(right.ncols) };
@@ -353,7 +354,7 @@ impl<N: Clone + Add<N, N> + Mul<N, N> + Zero> Mul<DMat<N>, DVec<N>> for DVec<N>
     }
 }
 
-impl<N: Clone + BaseNum + Zero + One> Inv for DMat<N> {
+impl<N: BaseNum + Clone> Inv for DMat<N> {
     #[inline]
     fn inv_cpy(&self) -> Option<DMat<N>> {
         let mut res: DMat<N> = self.clone();
@@ -439,7 +440,7 @@ impl<N: Clone + BaseNum + Zero + One> Inv for DMat<N> {
     }
 }
 
-impl<N: Clone> Transpose for DMat<N> {
+impl<N: Clone + Copy> Transpose for DMat<N> {
     #[inline]
     fn transpose_cpy(&self) -> DMat<N> {
         if self.nrows == self.ncols {
@@ -485,7 +486,7 @@ impl<N: Clone> Transpose for DMat<N> {
     }
 }
 
-impl<N: BaseNum + Cast<f64> + Zero + Clone> Mean<DVec<N>> for DMat<N> {
+impl<N: BaseNum + Cast<f64> + 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.0f64 / Cast::from(self.nrows));
@@ -503,7 +504,7 @@ impl<N: BaseNum + Cast<f64> + Zero + Clone> Mean<DVec<N>> for DMat<N> {
     }
 }
 
-impl<N: Clone + BaseNum + Cast<f64> + Div<N, N>> Cov<DMat<N>> for DMat<N> {
+impl<N: BaseNum + Cast<f64> + Clone> 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);
@@ -528,7 +529,7 @@ impl<N: Clone + BaseNum + Cast<f64> + Div<N, N>> Cov<DMat<N>> for DMat<N> {
     }
 }
 
-impl<N: Clone> ColSlice<DVec<N>> for DMat<N> {
+impl<N: Copy + Clone> ColSlice<DVec<N>> for DMat<N> {
     fn col_slice(&self, col_id :uint, row_start: uint, row_end: uint) -> DVec<N> {
         assert!(col_id < self.ncols);
         assert!(row_start < row_end);
@@ -542,7 +543,7 @@ impl<N: Clone> ColSlice<DVec<N>> for DMat<N> {
     }
 }
 
-impl<N: Clone> RowSlice<DVec<N>> for DMat<N> {
+impl<N: Copy> RowSlice<DVec<N>> for DMat<N> {
     fn row_slice(&self, row_id :uint, col_start: uint, col_end: uint) -> DVec<N> {
         assert!(row_id < self.nrows);
         assert!(col_start < col_end);
@@ -561,7 +562,7 @@ impl<N: Clone> RowSlice<DVec<N>> for DMat<N> {
     }
 }
 
-impl<N: Clone + Zero>  Diag<DVec<N>> for DMat<N> {
+impl<N: Copy + Clone + Zero>  Diag<DVec<N>> for DMat<N> {
     #[inline]
     fn from_diag(diag: &DVec<N>) -> DMat<N> {
         let mut res = DMat::new_zeros(diag.len(), diag.len());
@@ -609,7 +610,7 @@ impl<N: ApproxEq<N>> ApproxEq<N> for DMat<N> {
     }
 }
 
-impl<N: Show + Clone> Show for DMat<N> {
+impl<N: Show + Copy> Show for DMat<N> {
     fn fmt(&self, form:&mut Formatter) -> Result {
         for i in range(0u, self.nrows()) {
             for j in range(0u, self.ncols()) {
@@ -621,46 +622,54 @@ impl<N: Show + Clone> Show for DMat<N> {
     }
 }
 
-impl<N: Mul<N, N>> Mul<N, DMat<N>> for DMat<N> {
+impl<N: Copy + Mul<N, N>> Mul<N, DMat<N>> for DMat<N> {
     #[inline]
-    fn mul(&self, right: &N) -> DMat<N> {
-        DMat {
-            nrows: self.nrows,
-            ncols: self.ncols,
-            mij:   self.mij.iter().map(|a| *a * *right).collect()
+    fn mul(self, right: N) -> DMat<N> {
+        let mut res = self;
+
+        for mij in res.mij.iter_mut() {
+            *mij = *mij * right;
         }
+
+        res
     }
 }
 
-impl<N: Div<N, N>> Div<N, DMat<N>> for DMat<N> {
+impl<N: Copy + Div<N, N>> Div<N, DMat<N>> for DMat<N> {
     #[inline]
-    fn div(&self, right: &N) -> DMat<N> {
-        DMat {
-            nrows: self.nrows,
-            ncols: self.ncols,
-            mij:   self.mij.iter().map(|a| *a / *right).collect()
+    fn div(self, right: N) -> DMat<N> {
+        let mut res = self;
+
+        for mij in res.mij.iter_mut() {
+            *mij = *mij / right;
         }
+
+        res
     }
 }
 
-impl<N: Add<N, N>> Add<N, DMat<N>> for DMat<N> {
+impl<N: Copy + Add<N, N>> Add<N, DMat<N>> for DMat<N> {
     #[inline]
-    fn add(&self, right: &N) -> DMat<N> {
-        DMat {
-            nrows: self.nrows,
-            ncols: self.ncols,
-            mij:   self.mij.iter().map(|a| *a + *right).collect()
+    fn add(self, right: N) -> DMat<N> {
+        let mut res = self;
+
+        for mij in res.mij.iter_mut() {
+            *mij = *mij + right;
         }
+
+        res
     }
 }
 
-impl<N: Sub<N, N>> Sub<N, DMat<N>> for DMat<N> {
+impl<N: Copy + Sub<N, N>> Sub<N, DMat<N>> for DMat<N> {
     #[inline]
-    fn sub(&self, right: &N) -> DMat<N> {
-        DMat {
-            nrows: self.nrows,
-            ncols: self.ncols,
-            mij:   self.mij.iter().map(|a| *a - *right).collect()
+    fn sub(self, right: N) -> DMat<N> {
+        let mut res = self;
+
+        for mij in res.mij.iter_mut() {
+            *mij = *mij - right;
         }
+
+        res
     }
 }

src/structs/dvec.rs

@@ -5,8 +5,8 @@
 use std::rand::Rand;
 use std::rand;
 use std::slice::{Items, MutItems};
-use traits::operations::ApproxEq;
 use std::iter::FromIterator;
+use traits::operations::{ApproxEq, Axpy};
 use traits::geometry::{Dot, Norm};
 use traits::structure::{Iterable, IterableMut, Indexable, Shape, BaseFloat, BaseNum, Zero, One};