Add high-level API

Author: termoshtt

src/impl2/mod.rs

@@ -11,10 +11,8 @@ pub use self::solve::*;
 
 use super::error::*;
 
-use super::error::*;
-
-pub trait LapackScalar: OperatorNorm_ + QR_ + SVD_ {}
-impl<A> LapackScalar for A where A: OperatorNorm_ + QR_ + SVD_ {}
+pub trait LapackScalar: OperatorNorm_ + QR_ + SVD_ + Solve_ {}
+impl<A> LapackScalar for A where A: OperatorNorm_ + QR_ + SVD_ + Solve_ {}
 
 pub fn into_result<T>(info: i32, val: T) -> Result<T> {
     if info == 0 {

src/impl2/solve.rs

@@ -9,6 +9,7 @@ use super::into_result;
 
 pub type Pivot = Vec<i32>;
 
+#[derive(Debug, Clone, Copy)]
 #[repr(u8)]
 pub enum Transpose {
     No = b'N',

src/lib.rs

@@ -51,6 +51,7 @@ pub mod impl2;
 pub mod qr;
 pub mod svd;
 pub mod opnorm;
+pub mod solve;
 
 pub mod vector;
 pub mod matrix;

src/solve.rs

@@ -0,0 +1,66 @@
+
+use ndarray::*;
+use super::layout::*;
+use super::error::*;
+use super::impl2::*;
+
+pub use impl2::{Pivot, Transpose};
+
+pub struct Factorized<S: Data> {
+    pub a: ArrayBase<S, Ix2>,
+    pub ipiv: Pivot,
+}
+
+impl<A, S> Factorized<S>
+    where A: LapackScalar,
+          S: Data<Elem = A>
+{
+    pub fn solve<Sb>(&self, t: Transpose, mut rhs: ArrayBase<Sb, Ix1>) -> Result<ArrayBase<Sb, Ix1>>
+        where Sb: DataMut<Elem = A>
+    {
+        A::solve(self.a.layout()?,
+                 t,
+                 self.a.as_allocated()?,
+                 &self.ipiv,
+                 rhs.as_slice_mut().unwrap())?;
+        Ok(rhs)
+    }
+}
+
+impl<A, S> Factorized<S>
+    where A: LapackScalar,
+          S: DataMut<Elem = A>
+{
+    pub fn into_inverse(mut self) -> Result<ArrayBase<S, Ix2>> {
+        A::inv(self.a.layout()?, self.a.as_allocated_mut()?, &self.ipiv)?;
+        Ok(self.a)
+    }
+}
+
+pub trait Factorize<S: Data> {
+    fn factorize(self) -> Result<Factorized<S>>;
+}
+
+impl<A, S> Factorize<S> for ArrayBase<S, Ix2>
+    where A: LapackScalar,
+          S: DataMut<Elem = A>
+{
+    fn factorize(mut self) -> Result<Factorized<S>> {
+        let ipiv = A::lu(self.layout()?, self.as_allocated_mut()?)?;
+        Ok(Factorized {
+            a: self,
+            ipiv: ipiv,
+        })
+    }
+}
+
+impl<'a, A, S> Factorize<OwnedRepr<A>> for &'a ArrayBase<S, Ix2>
+    where A: LapackScalar + Clone,
+          S: Data<Elem = A>
+{
+    fn factorize(self) -> Result<Factorized<OwnedRepr<A>>> {
+        let mut a = self.to_owned();
+        let ipiv = A::lu(a.layout()?, a.as_allocated_mut()?)?;
+        Ok(Factorized { a: a, ipiv: ipiv })
+    }
+}