sequenzo 0.1.17__cp39-cp39-macosx_10_9_universal2.whl → 0.1.19__cp39-cp39-macosx_10_9_universal2.whl

sequenzo/dissimilarity_measures/src/eigen/Eigen/src/KLUSupport/KLUSupport.h

@@ -1,358 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2017 Kyle Macfarlan <kyle.macfarlan@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_KLUSUPPORT_H
-#define EIGEN_KLUSUPPORT_H
-
-namespace Eigen {
-
-/* TODO extract L, extract U, compute det, etc... */
-
-/** \ingroup KLUSupport_Module
-  * \brief A sparse LU factorization and solver based on KLU
-  *
-  * This class allows to solve for A.X = B sparse linear problems via a LU factorization
-  * using the KLU library. The sparse matrix A must be squared and full rank.
-  * The vectors or matrices X and B can be either dense or sparse.
-  *
-  * \warning The input matrix A should be in a \b compressed and \b column-major form.
-  * Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.
-  * \tparam _MatrixType the type of the sparse matrix A, it must be a SparseMatrix<>
-  *
-  * \implsparsesolverconcept
-  *
-  * \sa \ref TutorialSparseSolverConcept, class UmfPackLU, class SparseLU
-  */
-
-
-inline int klu_solve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B [ ], klu_common *Common, double) {
-   return klu_solve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), B, Common);
-}
-
-inline int klu_solve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex<double>B[], klu_common *Common, std::complex<double>) {
-   return klu_z_solve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), &numext::real_ref(B[0]), Common);
-}
-
-inline int klu_tsolve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, double B[], klu_common *Common, double) {
-   return klu_tsolve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), B, Common);
-}
-
-inline int klu_tsolve(klu_symbolic *Symbolic, klu_numeric *Numeric, Index ldim, Index nrhs, std::complex<double>B[], klu_common *Common, std::complex<double>) {
-   return klu_z_tsolve(Symbolic, Numeric, internal::convert_index<int>(ldim), internal::convert_index<int>(nrhs), &numext::real_ref(B[0]), 0, Common);
-}
-
-inline klu_numeric* klu_factor(int Ap [ ], int Ai [ ], double Ax [ ], klu_symbolic *Symbolic, klu_common *Common, double) {
-   return klu_factor(Ap, Ai, Ax, Symbolic, Common);
-}
-
-inline klu_numeric* klu_factor(int Ap[], int Ai[], std::complex<double> Ax[], klu_symbolic *Symbolic, klu_common *Common, std::complex<double>) {
-   return klu_z_factor(Ap, Ai, &numext::real_ref(Ax[0]), Symbolic, Common);
-}
-
-
-template<typename _MatrixType>
-class KLU : public SparseSolverBase<KLU<_MatrixType> >
-{
-  protected:
-    typedef SparseSolverBase<KLU<_MatrixType> > Base;
-    using Base::m_isInitialized;
-  public:
-    using Base::_solve_impl;
-    typedef _MatrixType MatrixType;
-    typedef typename MatrixType::Scalar Scalar;
-    typedef typename MatrixType::RealScalar RealScalar;
-    typedef typename MatrixType::StorageIndex StorageIndex;
-    typedef Matrix<Scalar,Dynamic,1> Vector;
-    typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
-    typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
-    typedef SparseMatrix<Scalar> LUMatrixType;
-    typedef SparseMatrix<Scalar,ColMajor,int> KLUMatrixType;
-    typedef Ref<const KLUMatrixType, StandardCompressedFormat> KLUMatrixRef;
-    enum {
-      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
-      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
-    };
-
-  public:
-
-    KLU()
-      : m_dummy(0,0), mp_matrix(m_dummy)
-    {
-      init();
-    }
-
-    template<typename InputMatrixType>
-    explicit KLU(const InputMatrixType& matrix)
-      : mp_matrix(matrix)
-    {
-      init();
-      compute(matrix);
-    }
-
-    ~KLU()
-    {
-      if(m_symbolic) klu_free_symbolic(&m_symbolic,&m_common);
-      if(m_numeric)  klu_free_numeric(&m_numeric,&m_common);
-    }
-
-    EIGEN_CONSTEXPR inline Index rows() const EIGEN_NOEXCEPT { return mp_matrix.rows(); }
-    EIGEN_CONSTEXPR inline Index cols() const EIGEN_NOEXCEPT { return mp_matrix.cols(); }
-
-    /** \brief Reports whether previous computation was successful.
-      *
-      * \returns \c Success if computation was successful,
-      *          \c NumericalIssue if the matrix.appears to be negative.
-      */
-    ComputationInfo info() const
-    {
-      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
-      return m_info;
-    }
-#if 0 // not implemented yet
-    inline const LUMatrixType& matrixL() const
-    {
-      if (m_extractedDataAreDirty) extractData();
-      return m_l;
-    }
-
-    inline const LUMatrixType& matrixU() const
-    {
-      if (m_extractedDataAreDirty) extractData();
-      return m_u;
-    }
-
-    inline const IntColVectorType& permutationP() const
-    {
-      if (m_extractedDataAreDirty) extractData();
-      return m_p;
-    }
-
-    inline const IntRowVectorType& permutationQ() const
-    {
-      if (m_extractedDataAreDirty) extractData();
-      return m_q;
-    }
-#endif
-    /** Computes the sparse Cholesky decomposition of \a matrix
-     *  Note that the matrix should be column-major, and in compressed format for best performance.
-     *  \sa SparseMatrix::makeCompressed().
-     */
-    template<typename InputMatrixType>
-    void compute(const InputMatrixType& matrix)
-    {
-      if(m_symbolic) klu_free_symbolic(&m_symbolic, &m_common);
-      if(m_numeric)  klu_free_numeric(&m_numeric, &m_common);
-      grab(matrix.derived());
-      analyzePattern_impl();
-      factorize_impl();
-    }
-
-    /** Performs a symbolic decomposition on the sparcity of \a matrix.
-      *
-      * This function is particularly useful when solving for several problems having the same structure.
-      *
-      * \sa factorize(), compute()
-      */
-    template<typename InputMatrixType>
-    void analyzePattern(const InputMatrixType& matrix)
-    {
-      if(m_symbolic) klu_free_symbolic(&m_symbolic, &m_common);
-      if(m_numeric)  klu_free_numeric(&m_numeric, &m_common);
-
-      grab(matrix.derived());
-
-      analyzePattern_impl();
-    }
-
-
-    /** Provides access to the control settings array used by KLU.
-      *
-      * See KLU documentation for details.
-      */
-    inline const klu_common& kluCommon() const
-    {
-      return m_common;
-    }
-
-    /** Provides access to the control settings array used by UmfPack.
-      *
-      * If this array contains NaN's, the default values are used.
-      *
-      * See KLU documentation for details.
-      */
-    inline klu_common& kluCommon()
-    {
-      return m_common;
-    }
-
-    /** Performs a numeric decomposition of \a matrix
-      *
-      * The given matrix must has the same sparcity than the matrix on which the pattern anylysis has been performed.
-      *
-      * \sa analyzePattern(), compute()
-      */
-    template<typename InputMatrixType>
-    void factorize(const InputMatrixType& matrix)
-    {
-      eigen_assert(m_analysisIsOk && "KLU: you must first call analyzePattern()");
-      if(m_numeric)
-        klu_free_numeric(&m_numeric,&m_common);
-
-      grab(matrix.derived());
-
-      factorize_impl();
-    }
-
-    /** \internal */
-    template<typename BDerived,typename XDerived>
-    bool _solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const;
-
-#if 0 // not implemented yet
-    Scalar determinant() const;
-
-    void extractData() const;
-#endif
-
-  protected:
-
-    void init()
-    {
-      m_info                  = InvalidInput;
-      m_isInitialized         = false;
-      m_numeric               = 0;
-      m_symbolic              = 0;
-      m_extractedDataAreDirty = true;
-
-      klu_defaults(&m_common);
-    }
-
-    void analyzePattern_impl()
-    {
-      m_info = InvalidInput;
-      m_analysisIsOk = false;
-      m_factorizationIsOk = false;
-      m_symbolic = klu_analyze(internal::convert_index<int>(mp_matrix.rows()),
-                                     const_cast<StorageIndex*>(mp_matrix.outerIndexPtr()), const_cast<StorageIndex*>(mp_matrix.innerIndexPtr()),
-                                     &m_common);
-      if (m_symbolic) {
-         m_isInitialized = true;
-         m_info = Success;
-         m_analysisIsOk = true;
-         m_extractedDataAreDirty = true;
-      }
-    }
-
-    void factorize_impl()
-    {
-
-      m_numeric = klu_factor(const_cast<StorageIndex*>(mp_matrix.outerIndexPtr()), const_cast<StorageIndex*>(mp_matrix.innerIndexPtr()), const_cast<Scalar*>(mp_matrix.valuePtr()),
-                                    m_symbolic, &m_common, Scalar());
-
-
-      m_info = m_numeric ? Success : NumericalIssue;
-      m_factorizationIsOk = m_numeric ? 1 : 0;
-      m_extractedDataAreDirty = true;
-    }
-
-    template<typename MatrixDerived>
-    void grab(const EigenBase<MatrixDerived> &A)
-    {
-      mp_matrix.~KLUMatrixRef();
-      ::new (&mp_matrix) KLUMatrixRef(A.derived());
-    }
-
-    void grab(const KLUMatrixRef &A)
-    {
-      if(&(A.derived()) != &mp_matrix)
-      {
-        mp_matrix.~KLUMatrixRef();
-        ::new (&mp_matrix) KLUMatrixRef(A);
-      }
-    }
-
-    // cached data to reduce reallocation, etc.
-#if 0 // not implemented yet
-    mutable LUMatrixType m_l;
-    mutable LUMatrixType m_u;
-    mutable IntColVectorType m_p;
-    mutable IntRowVectorType m_q;
-#endif
-
-    KLUMatrixType m_dummy;
-    KLUMatrixRef mp_matrix;
-
-    klu_numeric* m_numeric;
-    klu_symbolic* m_symbolic;
-    klu_common m_common;
-    mutable ComputationInfo m_info;
-    int m_factorizationIsOk;
-    int m_analysisIsOk;
-    mutable bool m_extractedDataAreDirty;
-
-  private:
-    KLU(const KLU& ) { }
-};
-
-#if 0 // not implemented yet
-template<typename MatrixType>
-void KLU<MatrixType>::extractData() const
-{
-  if (m_extractedDataAreDirty)
-  {
-     eigen_assert(false && "KLU: extractData Not Yet Implemented");
-
-    // get size of the data
-    int lnz, unz, rows, cols, nz_udiag;
-    umfpack_get_lunz(&lnz, &unz, &rows, &cols, &nz_udiag, m_numeric, Scalar());
-
-    // allocate data
-    m_l.resize(rows,(std::min)(rows,cols));
-    m_l.resizeNonZeros(lnz);
-
-    m_u.resize((std::min)(rows,cols),cols);
-    m_u.resizeNonZeros(unz);
-
-    m_p.resize(rows);
-    m_q.resize(cols);
-
-    // extract
-    umfpack_get_numeric(m_l.outerIndexPtr(), m_l.innerIndexPtr(), m_l.valuePtr(),
-                        m_u.outerIndexPtr(), m_u.innerIndexPtr(), m_u.valuePtr(),
-                        m_p.data(), m_q.data(), 0, 0, 0, m_numeric);
-
-    m_extractedDataAreDirty = false;
-  }
-}
-
-template<typename MatrixType>
-typename KLU<MatrixType>::Scalar KLU<MatrixType>::determinant() const
-{
-  eigen_assert(false && "KLU: extractData Not Yet Implemented");
-  return Scalar();
-}
-#endif
-
-template<typename MatrixType>
-template<typename BDerived,typename XDerived>
-bool KLU<MatrixType>::_solve_impl(const MatrixBase<BDerived> &b, MatrixBase<XDerived> &x) const
-{
-  Index rhsCols = b.cols();
-  EIGEN_STATIC_ASSERT((XDerived::Flags&RowMajorBit)==0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
-  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
-
-  x = b;
-  int info = klu_solve(m_symbolic, m_numeric, b.rows(), rhsCols, x.const_cast_derived().data(), const_cast<klu_common*>(&m_common), Scalar());
-
-  m_info = info!=0 ? Success : NumericalIssue;
-  return true;
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_KLUSUPPORT_H

sequenzo/dissimilarity_measures/src/eigen/Eigen/src/LU/Determinant.h

@@ -1,117 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_DETERMINANT_H
-#define EIGEN_DETERMINANT_H
-
-namespace Eigen { 
-
-namespace internal {
-
-template<typename Derived>
-EIGEN_DEVICE_FUNC
-inline const typename Derived::Scalar bruteforce_det3_helper
-(const MatrixBase<Derived>& matrix, int a, int b, int c)
-{
-  return matrix.coeff(0,a)
-         * (matrix.coeff(1,b) * matrix.coeff(2,c) - matrix.coeff(1,c) * matrix.coeff(2,b));
-}
-
-template<typename Derived,
-         int DeterminantType = Derived::RowsAtCompileTime
-> struct determinant_impl
-{
-  static inline typename traits<Derived>::Scalar run(const Derived& m)
-  {
-    if(Derived::ColsAtCompileTime==Dynamic && m.rows()==0)
-      return typename traits<Derived>::Scalar(1);
-    return m.partialPivLu().determinant();
-  }
-};
-
-template<typename Derived> struct determinant_impl<Derived, 1>
-{
-  static inline EIGEN_DEVICE_FUNC
-  typename traits<Derived>::Scalar run(const Derived& m)
-  {
-    return m.coeff(0,0);
-  }
-};
-
-template<typename Derived> struct determinant_impl<Derived, 2>
-{
-  static inline EIGEN_DEVICE_FUNC
-  typename traits<Derived>::Scalar run(const Derived& m)
-  {
-    return m.coeff(0,0) * m.coeff(1,1) - m.coeff(1,0) * m.coeff(0,1);
-  }
-};
-
-template<typename Derived> struct determinant_impl<Derived, 3>
-{
-  static inline EIGEN_DEVICE_FUNC
-  typename traits<Derived>::Scalar run(const Derived& m)
-  {
-    return bruteforce_det3_helper(m,0,1,2)
-          - bruteforce_det3_helper(m,1,0,2)
-          + bruteforce_det3_helper(m,2,0,1);
-  }
-};
-
-template<typename Derived> struct determinant_impl<Derived, 4>
-{
-  typedef typename traits<Derived>::Scalar Scalar;
-  static EIGEN_DEVICE_FUNC
-  Scalar run(const Derived& m)
-  {
-    Scalar d2_01 = det2(m, 0, 1);
-    Scalar d2_02 = det2(m, 0, 2);
-    Scalar d2_03 = det2(m, 0, 3);
-    Scalar d2_12 = det2(m, 1, 2);
-    Scalar d2_13 = det2(m, 1, 3);
-    Scalar d2_23 = det2(m, 2, 3);
-    Scalar d3_0 = det3(m, 1,d2_23, 2,d2_13, 3,d2_12);
-    Scalar d3_1 = det3(m, 0,d2_23, 2,d2_03, 3,d2_02);
-    Scalar d3_2 = det3(m, 0,d2_13, 1,d2_03, 3,d2_01);
-    Scalar d3_3 = det3(m, 0,d2_12, 1,d2_02, 2,d2_01);
-    return internal::pmadd(-m(0,3),d3_0, m(1,3)*d3_1) +
-           internal::pmadd(-m(2,3),d3_2, m(3,3)*d3_3);
-  }
-protected:
-  static EIGEN_DEVICE_FUNC
-  Scalar det2(const Derived& m, Index i0, Index i1)
-  {
-    return m(i0,0) * m(i1,1) - m(i1,0) * m(i0,1);
-  }
-
-  static EIGEN_DEVICE_FUNC
-  Scalar det3(const Derived& m, Index i0, const Scalar& d0, Index i1, const Scalar& d1, Index i2, const Scalar& d2)
-  {
-    return internal::pmadd(m(i0,2), d0, internal::pmadd(-m(i1,2), d1, m(i2,2)*d2));
-  }
-};
-
-} // end namespace internal
-
-/** \lu_module
-  *
-  * \returns the determinant of this matrix
-  */
-template<typename Derived>
-EIGEN_DEVICE_FUNC
-inline typename internal::traits<Derived>::Scalar MatrixBase<Derived>::determinant() const
-{
-  eigen_assert(rows() == cols());
-  typedef typename internal::nested_eval<Derived,Base::RowsAtCompileTime>::type Nested;
-  return internal::determinant_impl<typename internal::remove_all<Nested>::type>::run(derived());
-}
-
-} // end namespace Eigen
-
-#endif // EIGEN_DETERMINANT_H