Create generate mod

Author: termoshtt

Cargo.toml

@@ -15,6 +15,7 @@ openblas = ["blas/openblas", "lapack/openblas"]
 netlib   = ["blas/netlib", "lapack/netlib"]
 
 [dependencies]
+rand = "0.3"
 derive-new = "0.4"
 enum-error-derive = "0.1"
 num-traits  = "0.1"

src/assert.rs

@@ -4,6 +4,7 @@ use std::iter::Sum;
 use num_traits::Float;
 use ndarray::*;
 
+use super::types::*;
 use super::vector::*;
 
 pub fn rclose<A, Tol>(test: A, truth: A, rtol: Tol) -> Result<Tol, Tol>

src/generate.rs

@@ -0,0 +1,70 @@
+
+use ndarray::*;
+use rand::*;
+use std::ops::*;
+
+use super::types::*;
+use super::error::*;
+
+pub fn random_square<A, S>(n: usize) -> ArrayBase<S, Ix2>
+    where A: Rand,
+          S: DataOwned<Elem = A>
+{
+    let mut rng = thread_rng();
+    let v: Vec<A> = (0..n * n).map(|_| rng.gen()).collect();
+    ArrayBase::from_shape_vec((n, n), v).unwrap()
+}
+
+pub fn random_hermite<A, S>(n: usize) -> ArrayBase<S, Ix2>
+    where A: Rand + Conjugate + Add<Output = A>,
+          S: DataOwned<Elem = A> + DataMut
+{
+    let mut a = random_square(n);
+    for i in 0..n {
+        a[(i, i)] = a[(i, i)] + Conjugate::conj(a[(i, i)]);
+        for j in i..n {
+            a[(i, j)] = a[(j, i)];
+        }
+    }
+    a
+}
+
+/// construct matrix from diag
+pub fn from_diag<A>(d: &[A]) -> Array2<A>
+    where A: LinalgScalar
+{
+    let n = d.len();
+    let mut e = Array::zeros((n, n));
+    for i in 0..n {
+        e[(i, i)] = d[i];
+    }
+    e
+}
+
+/// stack vectors into matrix horizontally
+pub fn hstack<A, S>(xs: &[ArrayBase<S, Ix1>]) -> Result<Array<A, Ix2>>
+    where A: LinalgScalar,
+          S: Data<Elem = A>
+{
+    let views: Vec<_> = xs.iter()
+        .map(|x| {
+            let n = x.len();
+            x.view().into_shape((n, 1)).unwrap()
+        })
+        .collect();
+    stack(Axis(1), &views).map_err(|e| e.into())
+}
+
+/// stack vectors into matrix vertically
+pub fn vstack<A, S>(xs: &[ArrayBase<S, Ix1>]) -> Result<Array<A, Ix2>>
+    where A: LinalgScalar,
+          S: Data<Elem = A>
+{
+    let views: Vec<_> = xs.iter()
+        .map(|x| {
+            let n = x.len();
+            x.view().into_shape((1, n)).unwrap()
+        })
+        .collect();
+    stack(Axis(0), &views).map_err(|e| e.into())
+}

src/lib.rs

@@ -35,6 +35,7 @@ extern crate blas;
 extern crate lapack;
 extern crate num_traits;
 extern crate num_complex;
+extern crate rand;
 #[macro_use(s)]
 extern crate ndarray;
 #[macro_use]
@@ -61,5 +62,6 @@ pub mod square;
 pub mod triangular;
 
 pub mod util;
+pub mod generate;
 pub mod assert;
 pub mod prelude;

src/triangular.rs

@@ -7,7 +7,7 @@ use super::impl2::UPLO;
 use super::matrix::{Matrix, MFloat};
 use super::square::SquareMatrix;
 use super::error::LinalgError;
-use super::util::hstack;
+use super::generate::hstack;
 use super::impls::solve::ImplSolve;
 
 pub trait SolveTriangular<Rhs>: Matrix + SquareMatrix {

src/util.rs

@@ -3,48 +3,10 @@
 use std::iter::Sum;
 use ndarray::*;
 use num_traits::Float;
-use super::vector::*;
 use std::ops::Div;
 
-/// construct matrix from diag
-pub fn from_diag<A>(d: &[A]) -> Array2<A>
-    where A: LinalgScalar
-{
-    let n = d.len();
-    let mut e = Array::zeros((n, n));
-    for i in 0..n {
-        e[(i, i)] = d[i];
-    }
-    e
-}
-
-/// stack vectors into matrix horizontally
-pub fn hstack<A, S>(xs: &[ArrayBase<S, Ix1>]) -> Result<Array<A, Ix2>, ShapeError>
-    where A: LinalgScalar,
-          S: Data<Elem = A>
-{
-    let views: Vec<_> = xs.iter()
-        .map(|x| {
-            let n = x.len();
-            x.view().into_shape((n, 1)).unwrap()
-        })
-        .collect();
-    stack(Axis(1), &views)
-}
-
-/// stack vectors into matrix vertically
-pub fn vstack<A, S>(xs: &[ArrayBase<S, Ix1>]) -> Result<Array<A, Ix2>, ShapeError>
-    where A: LinalgScalar,
-          S: Data<Elem = A>
-{
-    let views: Vec<_> = xs.iter()
-        .map(|x| {
-            let n = x.len();
-            x.view().into_shape((1, n)).unwrap()
-        })
-        .collect();
-    stack(Axis(0), &views)
-}
+use super::types::*;
+use super::vector::*;
 
 pub enum NormalizeAxis {
     Row = 0,