Remove Any bounds

benches/lib.rs

@@ -7,14 +7,15 @@ extern crate test;
 extern crate rand;
 
 pub mod linalg {
+	mod cholesky;
 	mod iter;
-	mod matrix;
-	mod svd;
 	mod lu;
-	mod cholesky;
-	mod qr;
+	mod matrix;
 	mod norm;
-	mod triangular;
 	mod permutation;
+	mod qr;
+	mod svd;
+	mod transpose;
+	mod triangular;
 	pub mod util;
 }

benches/linalg/transpose.rs

@@ -0,0 +1,47 @@
+use rulinalg::matrix::Matrix;
+use rulinalg::matrix::BaseMatrix;
+use test::Bencher;
+use test::black_box;
+
+macro_rules! bench_transpose {
+    ($name:ident, $rows:expr, $cols:expr) => {
+        #[bench]
+        fn $name(b: &mut Bencher) {
+            let a = Matrix::new($rows, $cols, vec![2.0; $rows * $cols]);
+
+            b.iter(|| {
+                let _ = black_box(a.transpose());
+            });
+        }
+    }
+}
+
+macro_rules! bench_in_place_transpose {
+    ($name:ident, $rows:expr, $cols:expr) => {
+        #[bench]
+        fn $name(b: &mut Bencher) {
+            let mut a = Matrix::new($rows, $cols, vec![2.0; $rows * $cols]);
+
+            b.iter(|| {
+                a.in_place_transpose();
+                let _ = black_box(&a);
+            });
+        }
+    }
+}
+
+bench_transpose!(bench_transpose_10_50, 10, 50);
+bench_transpose!(bench_transpose_50_10, 50, 10);
+bench_transpose!(bench_transpose_10_500, 10, 500);
+bench_transpose!(bench_transpose_500_10, 500, 10);
+bench_transpose!(bench_transpose_500_500, 500, 500);
+bench_transpose!(bench_transpose_100_5000, 100, 5000);
+bench_transpose!(bench_transpose_5000_100, 5000, 100);
+
+bench_in_place_transpose!(bench_in_place_transpose_10_50, 10, 50);
+bench_in_place_transpose!(bench_in_place_transpose_50_10, 50, 10);
+bench_in_place_transpose!(bench_in_place_transpose_10_500, 10, 500);
+bench_in_place_transpose!(bench_in_place_transpose_500_10, 500, 10);
+bench_in_place_transpose!(bench_in_place_transpose_500_500, 500, 500);
+bench_in_place_transpose!(bench_in_place_transpose_100_5000, 100, 5000);
+bench_in_place_transpose!(bench_in_place_transpose_5000_100, 5000, 100);

src/matrix/base/mod.rs

@@ -30,7 +30,6 @@ use utils;
 use libnum::{Zero, Float};
 use error::Error;
 
-use std::any::Any;
 use std::cmp::min;
 use std::marker::PhantomData;
 use std::mem;
@@ -87,7 +86,7 @@ pub trait BaseMatrix<T>: Sized {
     /// ```
     /// # #[macro_use] extern crate rulinalg; fn main() {
     /// use rulinalg::matrix::{Matrix, BaseMatrix};
-    /// 
+    ///
     /// let mat = matrix![0, 1;
     ///                   3, 4;
     ///                   6, 7];
@@ -1013,7 +1012,7 @@ pub trait BaseMatrix<T>: Sized {
     /// - There is no valid solution to the system (matrix is singular).
     /// - The matrix is empty.
     fn solve_u_triangular(&self, y: Vector<T>) -> Result<Vector<T>, Error>
-        where T: Any + Float
+        where T: Float
     {
         assert!(self.cols() == y.size(),
                 format!("Vector size {0} != {1} Matrix column count.",
@@ -1056,7 +1055,7 @@ pub trait BaseMatrix<T>: Sized {
     /// - There is no valid solution to the system (matrix is singular).
     /// - The matrix is empty.
     fn solve_l_triangular(&self, y: Vector<T>) -> Result<Vector<T>, Error>
-        where T: Any + Float
+        where T: Float
     {
         assert!(self.cols() == y.size(),
                 format!("Vector size {0} != {1} Matrix column count.",

src/matrix/decomposition/bidiagonal.rs

@@ -2,12 +2,11 @@ use matrix::{Matrix, BaseMatrix, BaseMatrixMut, MatrixSlice, MatrixSliceMut};
 use error::{Error, ErrorKind};
 
 use std;
-use std::any::Any;
 
 use libnum::Float;
 
 impl<T> Matrix<T>
-    where T: Any + Float
+    where T: Float + 'static
 {
     /// Converts matrix to bidiagonal form
     ///

src/matrix/decomposition/cholesky.rs

@@ -5,8 +5,6 @@ use matrix::forward_substitution;
 use vector::Vector;
 use utils::dot;
 
-use std::any::Any;
-
 use libnum::{Zero, Float};
 
 /// Cholesky decomposition.
@@ -247,7 +245,7 @@ impl<T: Zero> Decomposition for Cholesky<T> {
 
 
 impl<T> Matrix<T>
-    where T: Any + Float
+    where T: Float
 {
     /// Cholesky decomposition
     ///

src/matrix/decomposition/eigen.rs

@@ -3,12 +3,11 @@ use norm::Euclidean;
 use error::{Error, ErrorKind};
 
 use std::cmp;
-use std::any::Any;
 
 use libnum::{Float, Signed};
 use libnum::{cast, abs};
 
-impl<T: Any + Float + Signed> Matrix<T> {
+impl<T: Float + Signed + 'static> Matrix<T> {
     fn balance_matrix(&mut self) {
         let n = self.rows();
         let radix = T::one() + T::one();

src/matrix/decomposition/hessenberg.rs

@@ -1,11 +1,9 @@
 use matrix::{Matrix, BaseMatrix, BaseMatrixMut, MatrixSlice, MatrixSliceMut};
 use error::{Error, ErrorKind};
 
-use std::any::Any;
-
 use libnum::{Float};
 
-impl<T: Any + Float> Matrix<T> {
+impl<T: Float + 'static> Matrix<T> {
     /// Returns H, where H is the upper hessenberg form.
     ///
     /// If the transformation matrix is also required, you should

src/matrix/decomposition/lu.rs

@@ -4,7 +4,6 @@ use matrix::PermutationMatrix;
 use vector::Vector;
 use error::{Error, ErrorKind};
 
-use std::any::Any;
 use std::cmp;
 
 use libnum::{Float, Zero, One};
@@ -194,9 +193,7 @@ impl<T: 'static + Float> PartialPivLu<T> {
     }
 }
 
-// TODO: Remove Any bound (cannot for the time being, since
-// back substitution uses Any bound)
-impl<T> PartialPivLu<T> where T: Any + Float {
+impl<T> PartialPivLu<T> where T: Float {
     /// Solves the linear system `Ax = b`.
     ///
     /// Here, `A` is the decomposed matrix satisfying
@@ -430,9 +427,7 @@ impl<T: 'static + Float> FullPivLu<T> {
     }
 }
 
-// TODO: Remove Any bound (cannot for the time being, since
-// back substitution uses Any bound)
-impl<T> FullPivLu<T> where T: Any + Float {
+impl<T> FullPivLu<T> where T: Float {
 
     /// Solves the linear system `Ax = b`.
     ///
@@ -663,7 +658,7 @@ fn unit_lower_triangular_part<T, M>(matrix: &M) -> Matrix<T>
 }
 
 
-impl<T> Matrix<T> where T: Any + Float
+impl<T> Matrix<T> where T: Float
 {
     /// Computes L, U, and P for LUP decomposition.
     ///
@@ -938,7 +933,7 @@ mod tests {
                         -12.0,   5.0,  17.0;
                          15.0,   0.0, -18.0;
                          -6.0,   0.0,   20.0];
-                         
+
         FullPivLu::decompose(x.clone()).unwrap();
     }
 

src/matrix/decomposition/mod.rs

@@ -133,8 +133,6 @@ mod lu;
 mod eigen;
 mod householder;
 
-use std::any::Any;
-
 use matrix::{Matrix, BaseMatrix};
 use norm::Euclidean;
 use vector::Vector;
@@ -166,7 +164,7 @@ pub trait Decomposition {
 }
 
 impl<T> Matrix<T>
-    where T: Any + Float
+    where T: Float + 'static
 {
     /// Compute the cos and sin values for the givens rotation.
     ///

src/matrix/decomposition/qr.rs

@@ -8,8 +8,6 @@ use matrix::decomposition::{
 };
 use matrix::decomposition::householder;
 
-use std::any::Any;
-
 use libnum::Float;
 
 /// The result of unpacking a QR decomposition.
@@ -315,7 +313,7 @@ fn extract_r1<T: Float>(qr: &Matrix<T>) -> Matrix<T> {
 }
 
 impl<T> Matrix<T>
-    where T: Any + Float
+    where T: Float + 'static
 {
     /// Compute the QR decomposition of the matrix.
     ///

src/matrix/decomposition/svd.rs

@@ -1,7 +1,6 @@
 use matrix::{Matrix, BaseMatrix, BaseMatrixMut, MatrixSlice, MatrixSliceMut};
 use error::{Error, ErrorKind};
 
-use std::any::Any;
 use std::cmp;
 
 use libnum::{Float, Signed};
@@ -16,7 +15,7 @@ fn correct_svd_signs<T>(mut b: Matrix<T>,
                         mut u: Matrix<T>,
                         mut v: Matrix<T>)
                         -> (Matrix<T>, Matrix<T>, Matrix<T>)
-    where T: Any + Float + Signed
+    where T: Float + Signed
 {
 
     // When correcting the signs of the singular vectors, we can choose
@@ -47,7 +46,7 @@ fn sort_svd<T>(mut b: Matrix<T>,
                mut u: Matrix<T>,
                mut v: Matrix<T>)
                -> (Matrix<T>, Matrix<T>, Matrix<T>)
-    where T: Any + Float + Signed
+    where T: Float + Signed
 {
 
     assert!(u.cols() == b.cols() && b.cols() == v.cols());
@@ -89,7 +88,7 @@ fn sort_svd<T>(mut b: Matrix<T>,
     (b, u, v)
 }
 
-impl<T: Any + Float + Signed> Matrix<T> {
+impl<T: Float + Signed + 'static> Matrix<T> {
     /// Singular Value Decomposition
     ///
     /// Computes the SVD using the Golub-Reinsch algorithm.