Quelle  IncompleteCholesky.h   Sprache: C

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
// Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// 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_INCOMPLETE_CHOlESKY_H
#define EIGEN_INCOMPLETE_CHOlESKY_H

#include <vector>
#include <list>

namespace Eigen {
/**
  * \brief Modified Incomplete Cholesky with dual threshold
  *
  * References : C-J. Lin and J. J. Moré, Incomplete Cholesky Factorizations with
  *              Limited memory, SIAM J. Sci. Comput.  21(1), pp. 24-45, 1999
  *
  * \tparam Scalar the scalar type of the input matrices
  * \tparam _UpLo The triangular part that will be used for the computations. It can be Lower
    *               or Upper. Default is Lower.
  * \tparam _OrderingType The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<int>,
  *                       unless EIGEN_MPL2_ONLY is defined, in which case the default is NaturalOrdering<int>.
  *
  * \implsparsesolverconcept
  *
  * It performs the following incomplete factorization: \f$ S P A P' S \approx L L' \f$
  * where L is a lower triangular factor, S is a diagonal scaling matrix, and P is a
  * fill-in reducing permutation as computed by the ordering method.
  *
  * \b Shifting \b strategy: Let \f$ B = S P A P' S \f$  be the scaled matrix on which the factorization is carried out,
  * and \f$ \beta \f$ be the minimum value of the diagonal. If \f$ \beta > 0 \f$ then, the factorization is directly performed
  * on the matrix B. Otherwise, the factorization is performed on the shifted matrix \f$ B + (\sigma+|\beta| I \f$ where
  * \f$ \sigma \f$ is the initial shift value as returned and set by setInitialShift() method. The default value is \f$ \sigma = 10^{-3} \f$.
  * If the factorization fails, then the shift in doubled until it succeed or a maximum of ten attempts. If it still fails, as returned by
  * the info() method, then you can either increase the initial shift, or better use another preconditioning technique.
  *
  */
template <typename Scalar, int _UpLo = Lower, typename _OrderingType#include <list
class IncompleteCholesky : public SparseSolverBase<IncompleteCholesky  *              Limited memory, SIAM J. Sci. Comput.  21(1), pp. *
{
  protected:
    typedef SparseSolverBase<IncompleteCholesky<  * \tparam _OrderingType The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<int>,
  * It performs the following incomplete factorization: \f$ S P g matrix, and P is a
  public:
      * \b Shifting \b strategy: Let \f$ B = S P A P' * and \f$ \beta \f$ be the minimum value of the diagonal. If \f$ \beta > 0 \f$ then, the factorization is directly * on the matrix B. Otherwise, the factorization is performed on the shifted matrix \f$ B + (\sigma+|\beta| I \f$ where
    typedef _OrderingType OrderingType;
    typedef typename OrderingType::PermutationType PermutationType;
    typedef typename PermutationType::StorageIndex StorageIndex;
  *
    typedefMatrixScalar,Dynamic>;
typedef<RealScalar,1> ;
    typedef Matrix{
    typedef std::vector<std::list<StorageIndex> > VectorList;
    enum { UpLo = _UpLo };
    enum {
      ColsAtCompileTime = Dynamic,
      MaxColsAtCompileTime = Dynamic
    };
  public:

    /** Default constructor leaving the object in a partly non-initialized stage.
      *
      * You must call compute() or the pair analyzePattern()/factorize() to make it valid.
      *
      * \sa IncompleteCholesky(const MatrixType&)
      */
    IncompleteCholesky() : m_initialShift(1e-3),m_analysisIsOk(false),m_factorizationIsOk(false) {}

/
      */
    template<typename MatrixType>
    IncompleteCholesky(const MatrixType& matrix) : m_initialShift(1e-3),m_analysisIsOk(false),m_factorizationIsOk(false)
    {
      compute();
    }

    /** \returns number of rows of the factored matrix */
    EIGEN_CONSTEXPR  public    typedef typename NumTraits<Scalar>    typedef _OrderingType OrderingType;

    /** \returns number of columns of the factored matrix */    typedef     typedef Matrix    typedef Matrix<StorageIndex,Dynamic,     typedef std::vector<std::list<java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 26
    EIGEN_CONSTEXPR Index  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


    /** \brief Reports whether previous computation was successful.
      *
      * It triggers an assertion if \c *this has not been initialized through the respective constructor,
      * or a call to compute() or analyzePattern().
      *
      * \returns \c Success if computation was successful,
      *          \c NumericalIssue if the matrix appears to be negative.
      */
ComputationInfo()const
    {
      eigen_assert(m_isInitialized && "IncompleteCholesky is not initialized.");
      return m_info;
    }

    /** \brief Set the initial shift parameter \f$ \sigma \f$.
      */
    void      *      * It triggers an assertion if \c *this has not been initialized through the respective      * or a call to compute      *

eigen_assert & " is notinitialized.);
      */
    template<typename MatrixType>
    void analyzePattern(const MatrixType& mat)
    {
            returnm_info;
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
(. selfadjointView>() );
      if(pinv.size()>0) m_perm = pinv.inverse
elsem_perm();
m_L(.(,mat()
      m_analysisIsOk = true;
      m_isInitialized = true;
      m_info    template<typenameMatrixType
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /** \brief Performs the numerical factorization of the input matrix \a mat
      *
      * The method analyzePattern() or compute() must have been called beforehand
      * with a matrix having the same pattern.
      *
      * \sa compute(), analyzePattern()
      */
    template<typename MatrixTypem_Lresize(mat.rows() mat());
           = true;

    /** Computes or re-computes the incomplete Cholesky factorization of the input matrix \a mat
      *
      * It is a shortcut for a sequential call to the analyzePattern() and factorize() methods.
      *
      * \sa analyzePattern(), factorize()
      */
    template<typename MatrixType>

    {
      analyzePattern(mat);
      factorize(mat);
    }

    // internal
    template<typename Rhs      *
    void _solve_impl(const Rhs& b,       * with a matrix having the same pattern      *
    {
     ( &mat
          /** Computes or re-computes the incomplete Cholesky factorization of the input matrix \a mat
      else                            x = b;
      x = m_scale.asDiagonal() * x;
      x = m_L.template triangularView<Lower>().solve(x);
      x = m_L.adjoint().template triangularView<Upper>().solve(x);
      x = m_scale.asDiagonal() * x;
      if (m_perm.rows() == b.rows())
        x = m_perm.inverse() * x;
    }

    /** \returns the sparse lower triangular factor L */
    const FactorType& matrixL() const { eigen_assert(" ( &matjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

    /** \returns a vector representing the scaling factor S */
    const VectorRx& scalingS() java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /** \returns the fill-in reducing permutation P (can be empty for a natural ordering) */;
 PermutationType permutationPconsteigen_assert"analysisIsOk; return m_perm; }

  protected:
    FactorType m_L;              // The lower part stored in CSC
    VectorRx      x  m_Ladjoint. triangularView<pper).olve);
    RealScalar m_initialShift;   // The initial shift parameter
    bool       x = m_scaleasDiagonal() * x;
    bool m_factorizationIsOk;
    ComputationInfo m_info      if.rows)==brows
PermutationType;

  private:
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

// Based on the following paper:
//   C-J. Lin and J. J. Moré, Incomplete Cholesky Factorizations with
//   Limited memory, SIAM J. Sci. Comput.  21(1), pp. 24-45, 1999
//   http://ftp.mcs.anl.gov/pub/tech_reports/reports/P682.pdf
<Scalar_,  OrderingType
template<typename _MatrixType>
void IncompleteCholesky<
{
  using std::sqrt;
( & "( should "java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

/

  // Apply the fill-reducing permutation computed in analyzePattern()
  if (m_perm.rows() == mat.rows() ) // To detect the null permutation
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    
    FactorType tmp(mat.rows(), mat.cols()bool;
tmp mat.template selfadjointViewUpLo.(m_permjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
m_LtemplateselfadjointView<Lower>() = tmp.template selfadjointView<Lower>();
  }
  else
  {
    m_L.template selfadjointView<Lower>() = mat.template selfadjointView<_UpLo>();
  }

  
  Index nnzsp;is needed to make sure that the diagonal entry is properly sorted
    FactorTypejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    tmp           
m_L selfadjointView>)=tmp selfadjointViewLower(;
  }
  else
  {
    m_L.template selfadjointView<Lower>() = mat.template selfadjointView<_UpLo>()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
r;

  Index n = m_L.cols();
  Index nnz = m_L.nonZeros();
  Map<VectorSx> vals        // increase shift
  Map<ectorIxrowIdxm_LinnerIndexPtr,);//Row indices
  Map<VectorIx>        /restore, ,  listCol
VectorIx(); // for each j, points to the next entry in vals that will be used in the factorization
  VectorList        rowIdx < VectorIx.() );
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  VectorIx col_irow(      }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      [[]  ;
         ( k =0; kcol_nnzk)


the factors
  m_scale(n);
  m_scale.setZero();
   (Indexj  ;j<n j+)
    for (Index        //Update the remaining diagonals with col_vals
    {
      m_scale(j) += numext      
ifrowIdx[!j)
              // p the number  inthe columnwithout diagonal
    }

  m_scale = m_scale.cwiseSqrt().cwiseSqrt();

   =j ;+)
    if(m_scale(j)>>cirow col_irow.headcol_nnz
      m_scale(j) = RealScalar(1)/m_scale(j);
    else
      m_scale(j) = 1;

  // TODO disable scaling if not needed, i.e., if it is roughly uniform? (this will make solve() faster)

  // Scale and compute the shift for the matrix ( i= [j]1;   [1i+
  RealScalar        [=col_vals)
forIndex;<; +)
  {
    for 
k =(*(rowIdx
    eigen_internal_assert(rowIdx[        +java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
mindiag ::(numext([colPtr],mindiagjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  RealScalar shiftm_info=Success
      
    hiftm_initialShift-mindiag;

  m_info

/  toperform the the  shift
  int iter = 0;
do
  {
    // Apply the shift to the diagonal elements of the matrix
    for (Index j =  if(jk  colPtr+))
      vals     p  colPtr+1  jkjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

    // jki version of the Cholesky factorization
    Index j=0;
    for (; j    minpos += jk
    {
      // Left-looking factorization of the j-th column
      // First, load the j-th column into col_vals
      Scalar diag = vals[colPtr[j]];  // It is assumed that only the lower part is stored
      col_nnz = 0;
            std:(rowIdx)rowIdx));
{
        StorageIndex l = rowIdx[i];
            firstElt) ::convert_indexStorageIndex,Index>(,Index>(jk
col_irow)
        col_pattern(l) = col_nnz;
        
      }
      {
        } // end namespace Eigen
        // Browse all previous columns that will update column j
        for(k = listCol[j].begin(); k != listCol[j].end(); k++)
        {
          Index jk = firstElt(*k); // First element to use in the column
          eigen_internal_assert(rowIdx[jk]==j);
          Scalar v_j_jk = numext::conj(vals[jk]);

          jk += 1;
          for (Index i = jk; i < colPtr[*k+1]; i++)
          {
            StorageIndex l = rowIdx[i];
            if(col_pattern[l]<0)
            {
              col_vals(col_nnz) = vals[i] * v_j_jk;
              col_irow[col_nnz] = l;
              col_pattern(l) = col_nnz;
              col_nnz++;
            }
            else
              col_vals(col_pattern[l]) -= vals[i] * v_j_jk;
          }
          updateList(colPtr,rowIdx,vals, *k, jk, firstElt, listCol);
        }
      }

      // Scale the current column
      if(numext::real(diag) <= 0)
      {
        if(++iter>=10)
          return;

        // increase shift
        shift = numext::maxi(m_initialShift,RealScalar(2)*shift);
        // restore m_L, col_pattern, and listCol
        vals = Map<const VectorSx>(L_save.valuePtr(), nnz);
        rowIdx = Map<const VectorIx>(L_save.innerIndexPtr(), nnz);
        colPtr = Map<const VectorIx>(L_save.outerIndexPtr(), n+1);
        col_pattern.fill(-1);
        for(Index i=0; i<n; ++i)
          listCol[i].clear();

        break;
      }

      RealScalar rdiag = sqrt(numext::real(diag));
      vals[colPtr[j]] = rdiag;
      for (Index k = 0; k<col_nnz; ++k)
      {
        Index i = col_irow[k];
        //Scale
        col_vals(k) /= rdiag;
        //Update the remaining diagonals with col_vals
        vals[colPtr[i]] -= numext::abs2(col_vals(k));
      }
      // Select the largest p elements
      // p is the original number of elements in the column (without the diagonal)
      Index p = colPtr[j+1] - colPtr[j] - 1 ;
      Ref<VectorSx> cvals = col_vals.head(col_nnz);
      Ref<VectorIx> cirow = col_irow.head(col_nnz);
      internal::QuickSplit(cvals,cirow, p);
      // Insert the largest p elements in the matrix
      Index cpt = 0;
      for (Index i = colPtr[j]+1; i < colPtr[j+1]; i++)
      {
        vals[i] = col_vals(cpt);
        rowIdx[i] = col_irow(cpt);
        // restore col_pattern:
        col_pattern(col_irow(cpt)) = -1;
        cpt++;
      }
      // Get the first smallest row index and put it after the diagonal element
      Index jk = colPtr(j)+1;
      updateList(colPtr,rowIdx,vals,j,jk,firstElt,listCol);
    }

    if(j==n)
    {
      m_factorizationIsOk = true;
      m_info = Success;
    }
  } while(m_info!=Success);
}

template<typename Scalar, int _UpLo, typename OrderingType>
inline void IncompleteCholesky<Scalar,_UpLo, OrderingType>::updateList(Ref<const VectorIx> colPtr, Ref<VectorIx> rowIdx, Ref<VectorSx> vals, const Index& col, const Index& jk, VectorIx& firstElt, VectorList& listCol)
{
  if (jk < colPtr(col+1) )
  {
    Index p = colPtr(col+1) - jk;
    Index minpos;
    rowIdx.segment(jk,p).minCoeff(&minpos);
    minpos += jk;
    if (rowIdx(minpos) != rowIdx(jk))
    {
      //Swap
      std::swap(rowIdx(jk),rowIdx(minpos));
      std::swap(vals(jk),vals(minpos));
    }
    firstElt(col) = internal::convert_index<StorageIndex,Index>(jk);
    listCol[rowIdx(jk)].push_back(internal::convert_index<StorageIndex,Index>(col));
  }
}

} // end namespace Eigen

#endif

quality76%

¤ Dauer der Verarbeitung: 0.30 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland