Use Layout in eigh

Author: termoshtt

src/eigh.rs

@@ -1,30 +1,20 @@
 //! Implement eigenvalue decomposition of Hermite matrix
 
-use lapack::fortran::*;
+use lapack::c::*;
 use num_traits::Zero;
 
 use error::LapackError;
 
 pub trait ImplEigh: Sized {
-    fn eigh(n: usize, mut a: Vec<Self>) -> Result<(Vec<Self>, Vec<Self>), LapackError>;
+    fn eigh(layout: Layout, n: usize, mut a: Vec<Self>) -> Result<(Vec<Self>, Vec<Self>), LapackError>;
 }
 
 macro_rules! impl_eigh {
     ($scalar:ty, $syev:path) => {
 impl ImplEigh for $scalar {
-    fn eigh(n: usize, mut a: Vec<Self>) -> Result<(Vec<Self>, Vec<Self>), LapackError> {
+    fn eigh(layout: Layout, n: usize, mut a: Vec<Self>) -> Result<(Vec<Self>, Vec<Self>), LapackError> {
         let mut w = vec![Self::zero(); n];
-        let mut work = vec![Self::zero(); 4 * n];
-        let mut info = 0;
-        $syev(b'V',
-              b'U',
-              n as i32,
-              &mut a,
-              n as i32,
-              &mut w,
-              &mut work,
-              4 * n as i32,
-              &mut info);
+        let info = $syev(layout, b'V', b'U', n as i32, &mut a, n as i32, &mut w);
         if info == 0 {
             Ok((w, a))
         } else {

src/hermite.rs

@@ -30,10 +30,14 @@ impl<A> HermiteMatrix for Array<A, Ix2>
 {
     fn eigh(self) -> Result<(Self::Vector, Self), LinalgError> {
         try!(self.check_square());
+        let layout = self.layout()?;
         let (rows, cols) = self.size();
-        let (w, a) = try!(ImplEigh::eigh(rows, self.into_raw_vec()));
+        let (w, a) = ImplEigh::eigh(layout, rows, self.into_raw_vec())?;
         let ea = Array::from_vec(w);
-        let va = Array::from_vec(a).into_shape((rows, cols)).unwrap().reversed_axes();
+        let va = match layout {
+            Layout::ColumnMajor => Array::from_vec(a).into_shape((rows, cols)).unwrap().reversed_axes(),
+            Layout::RowMajor => Array::from_vec(a).into_shape((rows, cols)).unwrap(),
+        };
         Ok((ea, va))
     }
     fn ssqrt(self) -> Result<Self, LinalgError> {