fix based on code review

doraneko94 · doraneko94 · commit 4624ff2a22c8 · 2020-06-27T16:26:46.000+09:00
diff --git a/examples/tridiagonal.rs b/examples/tridiagonal.rs
@@ -27,4 +27,8 @@ fn factorize() -> Result<(), error::LinalgError> {
 fn main() {
     solve().unwrap();
     factorize().unwrap();
+    match arr2(&[[0.0]]).extract_tridiagonal() {
+        Ok(_) => {}
+        Err(err) => println!("{}", err),
+    }
 }
diff --git a/src/error.rs b/src/error.rs
@@ -17,6 +17,12 @@ pub enum LinalgError {
     InvalidStride { s0: Ixs, s1: Ixs },
     /// Memory is not aligned continously
     MemoryNotCont,
+    /// Obj cannot be made from a (rows, cols) matrix
+    NotStandardShape {
+        obj: &'static str,
+        rows: i32,
+        cols: i32,
+    },
     /// Strides of the array is not supported
     Shape(ShapeError),
 }
@@ -34,6 +40,11 @@ impl fmt::Display for LinalgError {
                 write!(f, "invalid stride: s0={}, s1={}", s0, s1)
             }
             LinalgError::MemoryNotCont => write!(f, "Memory is not contiguous"),
+            LinalgError::NotStandardShape { obj, rows, cols } => write!(
+                f,
+                "{} cannot be made from a ({}, {}) matrix",
+                obj, rows, cols
+            ),
             LinalgError::Shape(err) => write!(f, "Shape Error: {}", err),
         }
     }
diff --git a/src/lapack/mod.rs b/src/lapack/mod.rs
@@ -41,7 +41,7 @@ pub trait Lapack:
     + Eig_
     + Eigh_
     + Triangular_
-    + TriDiagonal_
+    + Tridiagonal_
 {
 }
 
diff --git a/src/lapack/tridiagonal.rs b/src/lapack/tridiagonal.rs
@@ -2,7 +2,6 @@
 //! for tridiagonal matrix
 
 use lapacke;
-use ndarray::*;
 use num_traits::Zero;
 
 use super::NormType;
@@ -11,20 +10,18 @@ use super::{into_result, Pivot, Transpose};
 use crate::error::*;
 use crate::layout::MatrixLayout;
 use crate::opnorm::*;
-use crate::tridiagonal::{LUFactorizedTriDiagonal, TriDiagonal};
+use crate::tridiagonal::{LUFactorizedTridiagonal, Tridiagonal};
 use crate::types::*;
 
 /// Wraps `*gttrf`, `*gtcon` and `*gttrs`
-pub trait TriDiagonal_: Scalar + Sized {
+pub trait Tridiagonal_: Scalar + Sized {
     /// Computes the LU factorization of a tridiagonal `m x n` matrix `a` using
     /// partial pivoting with row interchanges.
-    unsafe fn lu_tridiagonal(
-        a: &mut TriDiagonal<Self>,
-    ) -> Result<(Array1<Self>, Self::Real, Pivot)>;
+    unsafe fn lu_tridiagonal(a: &mut Tridiagonal<Self>) -> Result<(Vec<Self>, Self::Real, Pivot)>;
     /// Estimates the the reciprocal of the condition number of the tridiagonal matrix in 1-norm.
-    unsafe fn rcond_tridiagonal(lu: &LUFactorizedTriDiagonal<Self>) -> Result<Self::Real>;
+    unsafe fn rcond_tridiagonal(lu: &LUFactorizedTridiagonal<Self>) -> Result<Self::Real>;
     unsafe fn solve_tridiagonal(
-        lu: &LUFactorizedTriDiagonal<Self>,
+        lu: &LUFactorizedTridiagonal<Self>,
         bl: MatrixLayout,
         t: Transpose,
         b: &mut [Self],
@@ -33,37 +30,30 @@ pub trait TriDiagonal_: Scalar + Sized {
 
 macro_rules! impl_tridiagonal {
     ($scalar:ty, $gttrf:path, $gtcon:path, $gttrs:path) => {
-        impl TriDiagonal_ for $scalar {
+        impl Tridiagonal_ for $scalar {
             unsafe fn lu_tridiagonal(
-                a: &mut TriDiagonal<Self>,
-            ) -> Result<(Array1<Self>, Self::Real, Pivot)> {
+                a: &mut Tridiagonal<Self>,
+            ) -> Result<(Vec<Self>, Self::Real, Pivot)> {
                 let (n, _) = a.l.size();
                 let anom = a.opnorm_one()?;
-                let dl = a.dl.as_slice_mut().unwrap();
-                let d = a.d.as_slice_mut().unwrap();
-                let du = a.du.as_slice_mut().unwrap();
                 let mut du2 = vec![Zero::zero(); (n - 2) as usize];
                 let mut ipiv = vec![0; n as usize];
-                let info = $gttrf(n, dl, d, du, &mut du2, &mut ipiv);
-                into_result(info, (arr1(&du2), anom, ipiv))
+                let info = $gttrf(n, &mut a.dl, &mut a.d, &mut a.du, &mut du2, &mut ipiv);
+                into_result(info, (du2, anom, ipiv))
             }
 
-            unsafe fn rcond_tridiagonal(lu: &LUFactorizedTriDiagonal<Self>) -> Result<Self::Real> {
+            unsafe fn rcond_tridiagonal(lu: &LUFactorizedTridiagonal<Self>) -> Result<Self::Real> {
                 let (n, _) = lu.a.l.size();
-                let dl = lu.a.dl.as_slice().unwrap();
-                let d = lu.a.d.as_slice().unwrap();
-                let du = lu.a.du.as_slice().unwrap();
-                let du2 = lu.du2.as_slice().unwrap();
                 let ipiv = &lu.ipiv;
                 let anorm = lu.anom;
                 let mut rcond = Self::Real::zero();
                 let info = $gtcon(
                     NormType::One as u8,
                     n,
-                    dl,
-                    d,
-                    du,
-                    du2,
+                    &lu.a.dl,
+                    &lu.a.d,
+                    &lu.a.du,
+                    &lu.du2,
                     ipiv,
                     anorm,
                     &mut rcond,
@@ -72,28 +62,24 @@ macro_rules! impl_tridiagonal {
             }
 
             unsafe fn solve_tridiagonal(
-                lu: &LUFactorizedTriDiagonal<Self>,
+                lu: &LUFactorizedTridiagonal<Self>,
                 bl: MatrixLayout,
                 t: Transpose,
                 b: &mut [Self],
             ) -> Result<()> {
                 let (n, _) = lu.a.l.size();
                 let (_, nrhs) = bl.size();
-                let dl = lu.a.dl.as_slice().unwrap();
-                let d = lu.a.d.as_slice().unwrap();
-                let du = lu.a.du.as_slice().unwrap();
-                let du2 = lu.du2.as_slice().unwrap();
                 let ipiv = &lu.ipiv;
                 let ldb = bl.lda();
                 let info = $gttrs(
                     lu.a.l.lapacke_layout(),
                     t as u8,
                     n,
                     nrhs,
-                    dl,
-                    d,
-                    du,
-                    du2,
+                    &lu.a.dl,
+                    &lu.a.d,
+                    &lu.a.du,
+                    &lu.du2,
                     ipiv,
                     b,
                     ldb,
diff --git a/src/opnorm.rs b/src/opnorm.rs
@@ -5,7 +5,7 @@ use ndarray::*;
 use crate::convert::*;
 use crate::error::*;
 use crate::layout::*;
-use crate::tridiagonal::TriDiagonal;
+use crate::tridiagonal::Tridiagonal;
 use crate::types::*;
 
 pub use crate::lapack::NormType;
@@ -49,7 +49,7 @@ where
     }
 }
 
-impl<A> OperationNorm for TriDiagonal<A>
+impl<A> OperationNorm for Tridiagonal<A>
 where
     A: Scalar + Lapack,
 {
@@ -73,12 +73,7 @@ where
                 let zu: Array1<A> = Array::zeros(1);
                 let dl = stack![Axis(0), self.dl.to_owned(), zl];
                 let du = stack![Axis(0), zu, self.du.to_owned()];
-                let arr = stack![
-                    Axis(0),
-                    into_row(du),
-                    into_row(self.d.to_owned()),
-                    into_row(dl)
-                ];
+                let arr = stack![Axis(0), into_row(du), into_row(arr1(&self.d)), into_row(dl)];
                 arr
             }
             // opnorm_inf() calculates muximum row sum.
@@ -93,12 +88,7 @@ where
                 let zu: Array1<A> = Array::zeros(1);
                 let dl = stack![Axis(0), zl, self.dl.to_owned()];
                 let du = stack![Axis(0), self.du.to_owned(), zu];
-                let arr = stack![
-                    Axis(1),
-                    into_col(dl),
-                    into_col(self.d.to_owned()),
-                    into_col(du)
-                ];
+                let arr = stack![Axis(1), into_col(dl), into_col(arr1(&self.d)), into_col(du)];
                 arr
             }
             // opnorm_fro() calculates square root of sum of squares.
@@ -108,9 +98,9 @@ where
             NormType::Frobenius => {
                 let arr = stack![
                     Axis(1),
-                    into_row(self.dl.to_owned()),
-                    into_row(self.d.to_owned()),
-                    into_row(self.du.to_owned())
+                    into_row(arr1(&self.dl)),
+                    into_row(arr1(&self.d)),
+                    into_row(arr1(&self.du))
                 ];
                 arr
             }
diff --git a/src/tridiagonal.rs b/src/tridiagonal.rs
diff --git a/tests/tridiagonal.rs b/tests/tridiagonal.rs

Original file line number	Diff line number	Diff line change
`@@ -27,4 +27,8 @@ fn factorize() -> Result<(), error::LinalgError> {`
`27`	`27`	`fn main() {`
`28`	`28`	`solve().unwrap();`
`29`	`29`	`factorize().unwrap();`
	`30`	`+ match arr2(&[[0.0]]).extract_tridiagonal() {`
	`31`	`+ Ok(_) => {}`
	`32`	`+ Err(err) => println!("{}", err),`
	`33`	`+ }`
`30`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,12 @@ pub enum LinalgError {`
`17`	`17`	`InvalidStride { s0: Ixs, s1: Ixs },`
`18`	`18`	`/// Memory is not aligned continously`
`19`	`19`	`MemoryNotCont,`
	`20`	`+ /// Obj cannot be made from a (rows, cols) matrix`
	`21`	`+ NotStandardShape {`
	`22`	`+ obj: &'static str,`
	`23`	`+ rows: i32,`
	`24`	`+ cols: i32,`
	`25`	`+ },`
`20`	`26`	`/// Strides of the array is not supported`
`21`	`27`	`Shape(ShapeError),`
`22`	`28`	`}`
`@@ -34,6 +40,11 @@ impl fmt::Display for LinalgError {`
`34`	`40`	`write!(f, "invalid stride: s0={}, s1={}", s0, s1)`
`35`	`41`	`}`
`36`	`42`	`LinalgError::MemoryNotCont => write!(f, "Memory is not contiguous"),`
	`43`	`+ LinalgError::NotStandardShape { obj, rows, cols } => write!(`
	`44`	`+ f,`
	`45`	`+ "{} cannot be made from a ({}, {}) matrix",`
	`46`	`+ obj, rows, cols`
	`47`	`+ ),`
`37`	`48`	`LinalgError::Shape(err) => write!(f, "Shape Error: {}", err),`
`38`	`49`	`}`
`39`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ pub trait Lapack:`
`41`	`41`	`+ Eig_`
`42`	`42`	`+ Eigh_`
`43`	`43`	`+ Triangular_`
`44`		`- + TriDiagonal_`
	`44`	`+ + Tridiagonal_`
`45`	`45`	`{`
`46`	`46`	`}`
`47`	`47`