Revise cauchy support

Author: termoshtt

src/generate.rs

@@ -1,8 +1,7 @@
 //! Generator functions for matrices
 
 use ndarray::*;
-use rand::*;
-use std::ops::*;
+use rand::{distributions::Standard, prelude::*};
 
 use super::convert::*;
 use super::error::*;
@@ -11,40 +10,41 @@ use super::types::*;
 /// Hermite conjugate matrix
 pub fn conjugate<A, Si, So>(a: &ArrayBase<Si, Ix2>) -> ArrayBase<So, Ix2>
 where
-    A: Scalar + Lapack
+    A: Scalar,
     Si: Data<Elem = A>,
     So: DataOwned<Elem = A> + DataMut,
 {
-    let mut a = replicate(&a.t());
+    let mut a: ArrayBase<So, Ix2> = replicate(&a.t());
     for val in a.iter_mut() {
-        *val = Scalar::conj(*val);
+        *val = val.conj();
     }
     a
 }
 
 /// Generate random array
 pub fn random<A, S, Sh, D>(sh: Sh) -> ArrayBase<S, D>
 where
-    A: RandNormal,
     S: DataOwned<Elem = A>,
     D: Dimension,
     Sh: ShapeBuilder<Dim = D>,
+    Standard: Distribution<A>,
 {
     let mut rng = thread_rng();
-    ArrayBase::from_shape_fn(sh, |_| A::randn(&mut rng))
+    ArrayBase::from_shape_fn(sh, |_| rng.sample(Standard))
 }
 
 /// Random Hermite matrix
 pub fn random_hermite<A, S>(n: usize) -> ArrayBase<S, Ix2>
 where
-    A: RandNormal + Scalar + Add<Output = A>,
+    A: Scalar,
     S: DataOwned<Elem = A> + DataMut,
+    Standard: Distribution<A>,
 {
-    let mut a = random((n, n));
+    let mut a: ArrayBase<S, Ix2> = random((n, n));
     for i in 0..n {
-        a[(i, i)] = a[(i, i)] + Scalar::conj(a[(i, i)]);
+        a[(i, i)] = a[(i, i)] + a[(i, i)].conj();
         for j in (i + 1)..n {
-            a[(i, j)] = Scalar::conj(a[(j, i)])
+            a[(i, j)] = a[(j, i)].conj();
         }
     }
     a
@@ -56,8 +56,9 @@ where
 ///
 pub fn random_hpd<A, S>(n: usize) -> ArrayBase<S, Ix2>
 where
-    A: RandNormal + Scalar + LinalgScalar,
+    A: Scalar,
     S: DataOwned<Elem = A> + DataMut,
+    Standard: Distribution<A>,
 {
     let a: Array2<A> = random((n, n));
     let ah: Array2<A> = conjugate(&a);
@@ -67,7 +68,7 @@ where
 /// construct matrix from diag
 pub fn from_diag<A>(d: &[A]) -> Array2<A>
 where
-    A: LinalgScalar,
+    A: Scalar,
 {
     let n = d.len();
     let mut e = Array::zeros((n, n));
@@ -80,7 +81,7 @@ where
 /// stack vectors into matrix horizontally
 pub fn hstack<A, S>(xs: &[ArrayBase<S, Ix1>]) -> Result<Array<A, Ix2>>
 where
-    A: LinalgScalar,
+    A: Scalar,
     S: Data<Elem = A>,
 {
     let views: Vec<_> = xs
@@ -96,7 +97,7 @@ where
 /// stack vectors into matrix vertically
 pub fn vstack<A, S>(xs: &[ArrayBase<S, Ix1>]) -> Result<Array<A, Ix2>>
 where
-    A: LinalgScalar,
+    A: Scalar,
     S: Data<Elem = A>,
 {
     let views: Vec<_> = xs

src/lib.rs

@@ -23,7 +23,7 @@ pub mod convert;
 pub mod diagonal;
 pub mod eigh;
 pub mod error;
-// pub mod generate;
+pub mod generate;
 pub mod lapack_traits;
 pub mod layout;
 pub mod norm;
@@ -42,7 +42,7 @@ pub use cholesky::*;
 pub use convert::*;
 pub use diagonal::*;
 pub use eigh::*;
-// pub use generate::*;
+pub use generate::*;
 pub use layout::*;
 pub use norm::*;
 pub use operator::*;

src/solve.rs

@@ -438,7 +438,7 @@ where
             Ok(fac) => fac.sln_det(),
             Err(LinalgError::Lapack { return_code }) if return_code > 0 => {
                 // The determinant is zero.
-                Ok((A::zero(), A::Real::NEG_INFINITY))
+                Ok((A::zero(), A::Real::neg_infinity()))
             }
             Err(err) => Err(err),
         }
@@ -456,7 +456,7 @@ where
             Ok(fac) => fac.sln_det_into(),
             Err(LinalgError::Lapack { return_code }) if return_code > 0 => {
                 // The determinant is zero.
-                Ok((A::zero(), A::Real::NEG_INFINITY))
+                Ok((A::zero(), A::Real::neg_infinity()))
             }
             Err(err) => Err(err),
         }

src/solveh.rs

@@ -416,7 +416,7 @@ where
             Ok(fac) => Ok(fac.sln_deth()),
             Err(LinalgError::Lapack { return_code }) if return_code > 0 => {
                 // Determinant is zero.
-                Ok((A::Real::zero(), A::Real::NEG_INFINITY))
+                Ok((A::Real::zero(), A::Real::neg_infinity()))
             }
             Err(err) => Err(err),
         }
@@ -440,7 +440,7 @@ where
             Ok(fac) => Ok(fac.sln_deth_into()),
             Err(LinalgError::Lapack { return_code }) if return_code > 0 => {
                 // Determinant is zero.
-                Ok((A::Real::zero(), A::Real::NEG_INFINITY))
+                Ok((A::Real::zero(), A::Real::neg_infinity()))
             }
             Err(err) => Err(err),
         }

src/types.rs

@@ -1,7 +1,7 @@
 //! Basic types and their methods for linear algebra
 
 pub use super::lapack_traits::Lapack;
-pub use cauchy::{RealScalar, Scalar};
+pub use cauchy::Scalar;
 
 pub use num_complex::Complex32 as c32;
 pub use num_complex::Complex64 as c64;