Fix bug for Layout detection

Author: termoshtt

src/error.rs

@@ -40,8 +40,8 @@ impl From<i32> for LapackError {
 
 #[derive(Debug, new)]
 pub struct NotSquareError {
-    pub rows: usize,
-    pub cols: usize,
+    pub rows: i32,
+    pub cols: i32,
 }
 
 impl fmt::Display for NotSquareError {

src/impl2/opnorm.rs

@@ -1,6 +1,7 @@
 //! Implement Operator norms for matrices
 
 use lapack::c;
+use lapack::c::Layout::ColumnMajor as cm;
 
 use types::*;
 use layout::*;
@@ -12,6 +13,16 @@ pub enum NormType {
     Frobenius = b'f',
 }
 
+impl NormType {
+    fn transpose(self) -> Self {
+        match self {
+            NormType::One => NormType::Infinity,
+            NormType::Infinity => NormType::One,
+            NormType::Frobenius => NormType::Frobenius,
+        }
+    }
+}
+
 pub trait OperatorNorm_: AssociatedReal {
     fn opnorm(NormType, Layout, &[Self]) -> Self::Real;
 }
@@ -20,8 +31,10 @@ macro_rules! impl_opnorm {
     ($scalar:ty, $lange:path) => {
 impl OperatorNorm_ for $scalar {
     fn opnorm(t: NormType, l: Layout, a: &[Self]) -> Self::Real {
-        let (m, n) = l.ffi_size();
-        $lange(l.ffi_layout(), t as u8, m, n, a, m)
+        match l {
+            Layout::F((col, lda)) => $lange(cm, t as u8, lda, col, a, lda),
+            Layout::C((row, lda)) => $lange(cm, t.transpose() as u8, lda, row, a, lda),
+        }
     }
 }
 }} // impl_opnorm!

src/layout.rs

@@ -2,36 +2,21 @@
 use ndarray::*;
 
 use super::error::*;
-use lapack::c::Layout as Layout_;
 
-pub type Row = usize;
-pub type Col = usize;
-
-pub type Row_ = i32;
-pub type Col_ = i32;
+pub type LDA = i32;
+pub type Col = i32;
+pub type Row = i32;
 
 pub enum Layout {
-    C((Row, Col)),
-    F((Row, Col)),
+    C((Row, LDA)),
+    F((Col, LDA)),
 }
 
 impl Layout {
     pub fn size(&self) -> (Row, Col) {
-        match self {
-            &Layout::C(s) => s,
-            &Layout::F(s) => s,
-        }
-    }
-
-    pub fn ffi_size(&self) -> (Row_, Col_) {
-        let (n, m) = self.size();
-        (n as Row_, m as Col_)
-    }
-
-    pub fn ffi_layout(&self) -> Layout_ {
-        match self {
-            &Layout::C(_) => Layout_::RowMajor,
-            &Layout::F(_) => Layout_::ColumnMajor,
+        match *self {
+            Layout::C((row, lda)) => (row, lda),
+            Layout::F((col, lda)) => (lda, col),
         }
     }
 }
@@ -53,10 +38,10 @@ impl<A, S> AllocatedArray for ArrayBase<S, Ix2>
         if ::std::cmp::min(strides[0], strides[1]) != 1 {
             return Err(StrideError::new(strides[0], strides[1]).into());
         }
-        if strides[0] < strides[1] {
-            Ok(Layout::C((self.rows(), self.cols())))
+        if strides[0] > strides[1] {
+            Ok(Layout::C((self.rows() as i32, self.cols() as i32)))
         } else {
-            Ok(Layout::F((self.rows(), self.cols())))
+            Ok(Layout::F((self.cols() as i32, self.rows() as i32)))
         }
     }
 

src/square.rs

@@ -25,8 +25,8 @@ pub trait SquareMatrix: Matrix {
             Ok(())
         } else {
             Err(NotSquareError {
-                rows: rows,
-                cols: cols,
+                rows: rows as i32,
+                cols: cols as i32,
             })
         }
     }

tests/opnorm.rs

@@ -5,9 +5,12 @@ macro_rules! impl_test {
 #[test]
 fn $funcname() {
     let a = $a;
-    assert_rclose!(a.opnorm_one().unwrap(), $op1, 1e-7);
-    assert_rclose!(a.opnorm_inf().unwrap(), $opi, 1e-7);
-    assert_rclose!(a.opnorm_fro().unwrap(), $opf, 1e-7);
+    println!("ONE = {:?}", a.opnorm_one());
+    println!("INF = {:?}", a.opnorm_inf());
+    println!("FRO = {:?}", a.opnorm_fro());
+    assert_rclose!(a.opnorm_fro().unwrap(), $opf, 1e-7; "Frobenius norm");
+    assert_rclose!(a.opnorm_one().unwrap(), $op1, 1e-7; "One norm");
+    assert_rclose!(a.opnorm_inf().unwrap(), $opi, 1e-7; "Infinity norm");
 }
 }} // impl_test