s/lapack/lax/g

Author: termoshtt

ndarray-linalg/src/cholesky.rs

@@ -52,7 +52,7 @@ use crate::layout::*;
 use crate::triangular::IntoTriangular;
 use crate::types::*;
 
-pub use crate::lapack::UPLO;
+pub use lax::UPLO;
 
 /// Cholesky decomposition of Hermitian (or real symmetric) positive definite matrix
 pub struct CholeskyFactorized<S: Data> {

ndarray-linalg/src/convert.rs

@@ -1,9 +1,9 @@
 //! utilities for convert array
 
+use lax::UPLO;
 use ndarray::*;
 
 use super::error::*;
-use super::lapack::UPLO;
 use super::layout::*;
 use super::types::*;
 

ndarray-linalg/src/error.rs

@@ -14,7 +14,7 @@ pub enum LinalgError {
 
     /// LAPACK subroutine returns non-zero code
     #[error(transparent)]
-    Lapack(#[from] lapack::error::Error),
+    Lapack(#[from] lax::error::Error),
 
     /// Strides of the array is not supported
     #[error("invalid stride: s0={}, s1={}", s0, s1)]

ndarray-linalg/src/layout.rs

@@ -3,7 +3,7 @@
 use super::error::*;
 use ndarray::*;
 
-pub use lapack::layout::MatrixLayout;
+pub use lax::layout::MatrixLayout;
 
 pub trait AllocatedArray {
     type Elem;

ndarray-linalg/src/least_squares.rs

@@ -60,10 +60,10 @@
 //! // `a` and `b` have been moved, no longer valid
 //! ```
 
+use lax::*;
 use ndarray::*;
 
 use crate::error::*;
-use crate::lapack::*;
 use crate::layout::*;
 use crate::types::*;
 

ndarray-linalg/src/lib.rs

@@ -47,7 +47,6 @@
 
 #[macro_use]
 extern crate ndarray;
-extern crate lax as lapack;
 
 pub mod assert;
 pub mod cholesky;

ndarray-linalg/src/lobpcg/eig.rs

@@ -1,5 +1,7 @@
 use super::lobpcg::{lobpcg, LobpcgResult, Order};
-use crate::{generate, Lapack, Scalar};
+use crate::{generate, Scalar};
+use lax::Lapack;
+
 ///! Implements truncated eigenvalue decomposition
 ///
 use ndarray::prelude::*;

ndarray-linalg/src/lobpcg/lobpcg.rs

@@ -4,7 +4,8 @@
 ///which can be used as a solver for large symmetric positive definite eigenproblems.
 use crate::error::{LinalgError, Result};
 use crate::{cholesky::*, close_l2, eigh::*, norm::*, triangular::*};
-use crate::{Lapack, Scalar};
+use cauchy::Scalar;
+use lax::Lapack;
 use ndarray::prelude::*;
 use ndarray::{Data, OwnedRepr, ScalarOperand};
 use num_traits::{Float, NumCast};
@@ -338,7 +339,7 @@ pub fn lobpcg<
         let result = p_ap
             .as_ref()
             .ok_or(LinalgError::Lapack(
-                lapack::error::Error::LapackComputationalFailure { return_code: 1 },
+                lax::error::Error::LapackComputationalFailure { return_code: 1 },
             ))
             .and_then(|(active_p, active_ap)| {
                 let xap = x.t().dot(active_ap);

ndarray-linalg/src/lobpcg/svd.rs

@@ -3,7 +3,9 @@
 ///! This module computes the k largest/smallest singular values/vectors for a dense matrix.
 use super::lobpcg::{lobpcg, LobpcgResult, Order};
 use crate::error::Result;
-use crate::{generate, Lapack, Scalar};
+use crate::generate;
+use cauchy::Scalar;
+use lax::Lapack;
 use ndarray::prelude::*;
 use ndarray::ScalarOperand;
 use num_traits::{Float, NumCast};

ndarray-linalg/src/opnorm.rs

@@ -1,14 +1,14 @@
 //! Operator norm
 
+use lax::Tridiagonal;
 use ndarray::*;
 
 use crate::convert::*;
 use crate::error::*;
-use crate::lapack::Tridiagonal;
 use crate::layout::*;
 use crate::types::*;
 
-pub use crate::lapack::NormType;
+pub use lax::NormType;
 
 /// Operator norm using `*lange` LAPACK routines
 ///

ndarray-linalg/src/qr.rs

@@ -11,7 +11,7 @@ use crate::layout::*;
 use crate::triangular::*;
 use crate::types::*;
 
-pub use crate::lapack::UPLO;
+pub use lax::UPLO;
 
 /// QR decomposition for matrix reference
 ///

ndarray-linalg/src/solve.rs

@@ -55,7 +55,7 @@ use crate::layout::*;
 use crate::opnorm::OperationNorm;
 use crate::types::*;
 
-pub use crate::lapack::{Pivot, Transpose};
+pub use lax::{Pivot, Transpose};
 
 /// An interface for solving systems of linear equations.
 ///
@@ -468,7 +468,7 @@ where
         self.ensure_square()?;
         match self.factorize() {
             Ok(fac) => fac.sln_det(),
-            Err(LinalgError::Lapack(e)) if matches!(e, lapack::error::Error::LapackComputationalFailure {..}) =>
+            Err(LinalgError::Lapack(e)) if matches!(e, lax::error::Error::LapackComputationalFailure {..}) =>
             {
                 // The determinant is zero.
                 Ok((A::zero(), A::Real::neg_infinity()))
@@ -487,7 +487,7 @@ where
         self.ensure_square()?;
         match self.factorize_into() {
             Ok(fac) => fac.sln_det_into(),
-            Err(LinalgError::Lapack(e)) if matches!(e, lapack::error::Error::LapackComputationalFailure { .. }) =>
+            Err(LinalgError::Lapack(e)) if matches!(e, lax::error::Error::LapackComputationalFailure { .. }) =>
             {
                 // The determinant is zero.
                 Ok((A::zero(), A::Real::neg_infinity()))

ndarray-linalg/src/solveh.rs

@@ -57,7 +57,7 @@ use crate::error::*;
 use crate::layout::*;
 use crate::types::*;
 
-pub use crate::lapack::{Pivot, UPLO};
+pub use lax::{Pivot, UPLO};
 
 /// An interface for solving systems of Hermitian (or real symmetric) linear equations.
 ///
@@ -426,7 +426,7 @@ where
     fn sln_deth(&self) -> Result<(A::Real, A::Real)> {
         match self.factorizeh() {
             Ok(fac) => Ok(fac.sln_deth()),
-            Err(LinalgError::Lapack(e)) if matches!(e, lapack::error::Error::LapackComputationalFailure {..}) =>
+            Err(LinalgError::Lapack(e)) if matches!(e, lax::error::Error::LapackComputationalFailure {..}) =>
             {
                 // Determinant is zero.
                 Ok((A::Real::zero(), A::Real::neg_infinity()))
@@ -451,7 +451,7 @@ where
     fn sln_deth_into(self) -> Result<(A::Real, A::Real)> {
         match self.factorizeh_into() {
             Ok(fac) => Ok(fac.sln_deth_into()),
-            Err(LinalgError::Lapack(e)) if matches!(e, lapack::error::Error::LapackComputationalFailure {..}) =>
+            Err(LinalgError::Lapack(e)) if matches!(e, lax::error::Error::LapackComputationalFailure {..}) =>
             {
                 // Determinant is zero.
                 Ok((A::Real::zero(), A::Real::neg_infinity()))

ndarray-linalg/src/svddc.rs

@@ -3,7 +3,7 @@
 use super::{convert::*, error::*, layout::*, types::*};
 use ndarray::*;
 
-pub use lapack::UVTFlag;
+pub use lax::UVTFlag;
 
 /// Singular-value decomposition of matrix (copying) by divide-and-conquer
 pub trait SVDDC {

ndarray-linalg/src/triangular.rs

@@ -1,15 +1,15 @@
 //! Methods for triangular matrices
 
+use lax::*;
 use ndarray::*;
 use num_traits::Zero;
 
 use super::convert::*;
 use super::error::*;
-use super::lapack::*;
 use super::layout::*;
 use super::types::*;
 
-pub use super::lapack::Diag;
+pub use lax::Diag;
 
 /// solve a triangular system with upper triangular matrix
 pub trait SolveTriangular<A, S, D>

ndarray-linalg/src/tridiagonal.rs

@@ -4,13 +4,13 @@
 
 use super::convert::*;
 use super::error::*;
-use super::lapack::*;
 use super::layout::*;
 use cauchy::Scalar;
+use lax::*;
 use ndarray::*;
 use num_traits::One;
 
-pub use lapack::{LUFactorizedTridiagonal, Tridiagonal};
+pub use lax::{LUFactorizedTridiagonal, Tridiagonal};
 
 /// An interface for making a Tridiagonal struct.
 pub trait ExtractTridiagonal<A: Scalar> {

ndarray-linalg/src/types.rs

@@ -1,7 +1,7 @@
 //! Basic types and their methods for linear algebra
 
-pub use super::lapack::Lapack;
 pub use cauchy::Scalar;
+pub use lax::Lapack;
 
 pub use num_complex::Complex32 as c32;
 pub use num_complex::Complex64 as c64;