Re-export struct/enum moved into lax::

Author: termoshtt

ndarray-linalg/src/svddc.rs

@@ -7,19 +7,7 @@ use super::error::*;
 use super::layout::*;
 use super::types::*;
 
-/// Specifies how many of the columns of *U* and rows of *V*ᵀ are computed and returned.
-///
-/// For an input array of shape *m*×*n*, the following are computed:
-#[derive(Clone, Copy, Eq, PartialEq)]
-#[repr(u8)]
-pub enum UVTFlag {
-    /// All *m* columns of *U* and all *n* rows of *V*ᵀ.
-    Full = b'A',
-    /// The first min(*m*,*n*) columns of *U* and the first min(*m*,*n*) rows of *V*ᵀ.
-    Some = b'S',
-    /// No columns of *U* or rows of *V*ᵀ.
-    None = b'N',
-}
+pub use lapack::svddc::UVTFlag;
 
 /// Singular-value decomposition of matrix (copying) by divide-and-conquer
 pub trait SVDDC {

ndarray-linalg/src/tridiagonal.rs

@@ -2,94 +2,15 @@
 //! &
 //! Methods for tridiagonal matrices
 
-use std::ops::{Index, IndexMut};
-
-use cauchy::Scalar;
-use ndarray::*;
-use num_traits::One;
-
 use super::convert::*;
 use super::error::*;
 use super::lapack::*;
 use super::layout::*;
+use cauchy::Scalar;
+use ndarray::*;
+use num_traits::One;
 
-/// Represents a tridiagonal matrix as 3 one-dimensional vectors.
-/// This struct also holds the layout of the raw matrix.
-#[derive(Clone, PartialEq)]
-pub struct Tridiagonal<A: Scalar> {
-    /// layout of raw matrix
-    pub l: MatrixLayout,
-    /// (n-1) sub-diagonal elements of matrix.
-    pub dl: Vec<A>,
-    /// (n) diagonal elements of matrix.
-    pub d: Vec<A>,
-    /// (n-1) super-diagonal elements of matrix.
-    pub du: Vec<A>,
-}
-
-pub trait TridiagIndex {
-    fn to_tuple(&self) -> (i32, i32);
-}
-impl TridiagIndex for [Ix; 2] {
-    fn to_tuple(&self) -> (i32, i32) {
-        (self[0] as i32, self[1] as i32)
-    }
-}
-
-impl<A, I> Index<I> for Tridiagonal<A>
-where
-    A: Scalar,
-    I: TridiagIndex,
-{
-    type Output = A;
-    #[inline]
-    fn index(&self, index: I) -> &A {
-        let (n, _) = self.l.size();
-        let (row, col) = index.to_tuple();
-        assert!(
-            std::cmp::max(row, col) < n,
-            "ndarray: index {:?} is out of bounds for array of shape {}",
-            [row, col],
-            n
-        );
-        match row - col {
-            0 => &self.d[row as usize],
-            1 => &self.dl[col as usize],
-            -1 => &self.du[row as usize],
-            _ => panic!(
-                "ndarray-linalg::tridiagonal: index {:?} is not tridiagonal element",
-                [row, col]
-            ),
-        }
-    }
-}
-
-impl<A, I> IndexMut<I> for Tridiagonal<A>
-where
-    A: Scalar,
-    I: TridiagIndex,
-{
-    #[inline]
-    fn index_mut(&mut self, index: I) -> &mut A {
-        let (n, _) = self.l.size();
-        let (row, col) = index.to_tuple();
-        assert!(
-            std::cmp::max(row, col) < n,
-            "ndarray: index {:?} is out of bounds for array of shape {}",
-            [row, col],
-            n
-        );
-        match row - col {
-            0 => &mut self.d[row as usize],
-            1 => &mut self.dl[col as usize],
-            -1 => &mut self.du[row as usize],
-            _ => panic!(
-                "ndarray-linalg::tridiagonal: index {:?} is not tridiagonal element",
-                [row, col]
-            ),
-        }
-    }
-}
+pub use lapack::tridiagonal::{LUFactorizedTridiagonal, Tridiagonal};
 
 /// An interface for making a Tridiagonal struct.
 pub trait ExtractTridiagonal<A: Scalar> {
@@ -188,23 +109,6 @@ pub trait SolveTridiagonalInplace<A: Scalar, D: Dimension> {
     ) -> Result<&'a mut ArrayBase<S, D>>;
 }
 
-/// Represents the LU factorization of a tridiagonal matrix `A` as `A = P*L*U`.
-#[derive(Clone)]
-pub struct LUFactorizedTridiagonal<A: Scalar> {
-    /// A tridiagonal matrix which consists of
-    /// - l : layout of raw matrix
-    /// - dl: (n-1) multipliers that define the matrix L.
-    /// - d : (n) diagonal elements of the upper triangular matrix U.
-    /// - du: (n-1) elements of the first super-diagonal of U.
-    pub a: Tridiagonal<A>,
-    /// (n-2) elements of the second super-diagonal of U.
-    pub du2: Vec<A>,
-    /// 1-norm of raw matrix (used in .rcond_tridiagonal()).
-    pub anom: A::Real,
-    /// The pivot indices that define the permutation matrix `P`.
-    pub ipiv: Pivot,
-}
-
 impl<A> SolveTridiagonal<A, Ix2> for LUFactorizedTridiagonal<A>
 where
     A: Scalar + Lapack,