123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462 |
- // 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) 2014 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_LUT_H
- #define EIGEN_INCOMPLETE_LUT_H
- namespace Eigen {
- namespace internal {
-
- /** \internal
- * Compute a quick-sort split of a vector
- * On output, the vector row is permuted such that its elements satisfy
- * abs(row(i)) >= abs(row(ncut)) if i<ncut
- * abs(row(i)) <= abs(row(ncut)) if i>ncut
- * \param row The vector of values
- * \param ind The array of index for the elements in @p row
- * \param ncut The number of largest elements to keep
- **/
- template <typename VectorV, typename VectorI>
- Index QuickSplit(VectorV &row, VectorI &ind, Index ncut)
- {
- typedef typename VectorV::RealScalar RealScalar;
- using std::swap;
- using std::abs;
- Index mid;
- Index n = row.size(); /* length of the vector */
- Index first, last ;
-
- ncut--; /* to fit the zero-based indices */
- first = 0;
- last = n-1;
- if (ncut < first || ncut > last ) return 0;
-
- do {
- mid = first;
- RealScalar abskey = abs(row(mid));
- for (Index j = first + 1; j <= last; j++) {
- if ( abs(row(j)) > abskey) {
- ++mid;
- swap(row(mid), row(j));
- swap(ind(mid), ind(j));
- }
- }
- /* Interchange for the pivot element */
- swap(row(mid), row(first));
- swap(ind(mid), ind(first));
-
- if (mid > ncut) last = mid - 1;
- else if (mid < ncut ) first = mid + 1;
- } while (mid != ncut );
-
- return 0; /* mid is equal to ncut */
- }
- }// end namespace internal
- /** \ingroup IterativeLinearSolvers_Module
- * \class IncompleteLUT
- * \brief Incomplete LU factorization with dual-threshold strategy
- *
- * \implsparsesolverconcept
- *
- * During the numerical factorization, two dropping rules are used :
- * 1) any element whose magnitude is less than some tolerance is dropped.
- * This tolerance is obtained by multiplying the input tolerance @p droptol
- * by the average magnitude of all the original elements in the current row.
- * 2) After the elimination of the row, only the @p fill largest elements in
- * the L part and the @p fill largest elements in the U part are kept
- * (in addition to the diagonal element ). Note that @p fill is computed from
- * the input parameter @p fillfactor which is used the ratio to control the fill_in
- * relatively to the initial number of nonzero elements.
- *
- * The two extreme cases are when @p droptol=0 (to keep all the @p fill*2 largest elements)
- * and when @p fill=n/2 with @p droptol being different to zero.
- *
- * References : Yousef Saad, ILUT: A dual threshold incomplete LU factorization,
- * Numerical Linear Algebra with Applications, 1(4), pp 387-402, 1994.
- *
- * NOTE : The following implementation is derived from the ILUT implementation
- * in the SPARSKIT package, Copyright (C) 2005, the Regents of the University of Minnesota
- * released under the terms of the GNU LGPL:
- * http://www-users.cs.umn.edu/~saad/software/SPARSKIT/README
- * However, Yousef Saad gave us permission to relicense his ILUT code to MPL2.
- * See the Eigen mailing list archive, thread: ILUT, date: July 8, 2012:
- * http://listengine.tuxfamily.org/lists.tuxfamily.org/eigen/2012/07/msg00064.html
- * alternatively, on GMANE:
- * http://comments.gmane.org/gmane.comp.lib.eigen/3302
- */
- template <typename _Scalar, typename _StorageIndex = int>
- class IncompleteLUT : public SparseSolverBase<IncompleteLUT<_Scalar, _StorageIndex> >
- {
- protected:
- typedef SparseSolverBase<IncompleteLUT> Base;
- using Base::m_isInitialized;
- public:
- typedef _Scalar Scalar;
- typedef _StorageIndex StorageIndex;
- typedef typename NumTraits<Scalar>::Real RealScalar;
- typedef Matrix<Scalar,Dynamic,1> Vector;
- typedef Matrix<StorageIndex,Dynamic,1> VectorI;
- typedef SparseMatrix<Scalar,RowMajor,StorageIndex> FactorType;
- enum {
- ColsAtCompileTime = Dynamic,
- MaxColsAtCompileTime = Dynamic
- };
- public:
-
- IncompleteLUT()
- : m_droptol(NumTraits<Scalar>::dummy_precision()), m_fillfactor(10),
- m_analysisIsOk(false), m_factorizationIsOk(false)
- {}
-
- template<typename MatrixType>
- explicit IncompleteLUT(const MatrixType& mat, const RealScalar& droptol=NumTraits<Scalar>::dummy_precision(), int fillfactor = 10)
- : m_droptol(droptol),m_fillfactor(fillfactor),
- m_analysisIsOk(false),m_factorizationIsOk(false)
- {
- eigen_assert(fillfactor != 0);
- compute(mat);
- }
-
- Index rows() const { return m_lu.rows(); }
-
- Index cols() const { return m_lu.cols(); }
- /** \brief Reports whether previous computation was successful.
- *
- * \returns \c Success if computation was succesful,
- * \c NumericalIssue if the matrix.appears to be negative.
- */
- ComputationInfo info() const
- {
- eigen_assert(m_isInitialized && "IncompleteLUT is not initialized.");
- return m_info;
- }
-
- template<typename MatrixType>
- void analyzePattern(const MatrixType& amat);
-
- template<typename MatrixType>
- void factorize(const MatrixType& amat);
-
- /**
- * Compute an incomplete LU factorization with dual threshold on the matrix mat
- * No pivoting is done in this version
- *
- **/
- template<typename MatrixType>
- IncompleteLUT& compute(const MatrixType& amat)
- {
- analyzePattern(amat);
- factorize(amat);
- return *this;
- }
- void setDroptol(const RealScalar& droptol);
- void setFillfactor(int fillfactor);
-
- template<typename Rhs, typename Dest>
- void _solve_impl(const Rhs& b, Dest& x) const
- {
- x = m_Pinv * b;
- x = m_lu.template triangularView<UnitLower>().solve(x);
- x = m_lu.template triangularView<Upper>().solve(x);
- x = m_P * x;
- }
- protected:
- /** keeps off-diagonal entries; drops diagonal entries */
- struct keep_diag {
- inline bool operator() (const Index& row, const Index& col, const Scalar&) const
- {
- return row!=col;
- }
- };
- protected:
- FactorType m_lu;
- RealScalar m_droptol;
- int m_fillfactor;
- bool m_analysisIsOk;
- bool m_factorizationIsOk;
- ComputationInfo m_info;
- PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_P; // Fill-reducing permutation
- PermutationMatrix<Dynamic,Dynamic,StorageIndex> m_Pinv; // Inverse permutation
- };
- /**
- * Set control parameter droptol
- * \param droptol Drop any element whose magnitude is less than this tolerance
- **/
- template<typename Scalar, typename StorageIndex>
- void IncompleteLUT<Scalar,StorageIndex>::setDroptol(const RealScalar& droptol)
- {
- this->m_droptol = droptol;
- }
- /**
- * Set control parameter fillfactor
- * \param fillfactor This is used to compute the number @p fill_in of largest elements to keep on each row.
- **/
- template<typename Scalar, typename StorageIndex>
- void IncompleteLUT<Scalar,StorageIndex>::setFillfactor(int fillfactor)
- {
- this->m_fillfactor = fillfactor;
- }
- template <typename Scalar, typename StorageIndex>
- template<typename _MatrixType>
- void IncompleteLUT<Scalar,StorageIndex>::analyzePattern(const _MatrixType& amat)
- {
- // Compute the Fill-reducing permutation
- // Since ILUT does not perform any numerical pivoting,
- // it is highly preferable to keep the diagonal through symmetric permutations.
- #ifndef EIGEN_MPL2_ONLY
- // To this end, let's symmetrize the pattern and perform AMD on it.
- SparseMatrix<Scalar,ColMajor, StorageIndex> mat1 = amat;
- SparseMatrix<Scalar,ColMajor, StorageIndex> mat2 = amat.transpose();
- // FIXME for a matrix with nearly symmetric pattern, mat2+mat1 is the appropriate choice.
- // on the other hand for a really non-symmetric pattern, mat2*mat1 should be prefered...
- SparseMatrix<Scalar,ColMajor, StorageIndex> AtA = mat2 + mat1;
- AMDOrdering<StorageIndex> ordering;
- ordering(AtA,m_P);
- m_Pinv = m_P.inverse(); // cache the inverse permutation
- #else
- // If AMD is not available, (MPL2-only), then let's use the slower COLAMD routine.
- SparseMatrix<Scalar,ColMajor, StorageIndex> mat1 = amat;
- COLAMDOrdering<StorageIndex> ordering;
- ordering(mat1,m_Pinv);
- m_P = m_Pinv.inverse();
- #endif
- m_analysisIsOk = true;
- m_factorizationIsOk = false;
- m_isInitialized = true;
- }
- template <typename Scalar, typename StorageIndex>
- template<typename _MatrixType>
- void IncompleteLUT<Scalar,StorageIndex>::factorize(const _MatrixType& amat)
- {
- using std::sqrt;
- using std::swap;
- using std::abs;
- using internal::convert_index;
- eigen_assert((amat.rows() == amat.cols()) && "The factorization should be done on a square matrix");
- Index n = amat.cols(); // Size of the matrix
- m_lu.resize(n,n);
- // Declare Working vectors and variables
- Vector u(n) ; // real values of the row -- maximum size is n --
- VectorI ju(n); // column position of the values in u -- maximum size is n
- VectorI jr(n); // Indicate the position of the nonzero elements in the vector u -- A zero location is indicated by -1
- // Apply the fill-reducing permutation
- eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
- SparseMatrix<Scalar,RowMajor, StorageIndex> mat;
- mat = amat.twistedBy(m_Pinv);
- // Initialization
- jr.fill(-1);
- ju.fill(0);
- u.fill(0);
- // number of largest elements to keep in each row:
- Index fill_in = (amat.nonZeros()*m_fillfactor)/n + 1;
- if (fill_in > n) fill_in = n;
- // number of largest nonzero elements to keep in the L and the U part of the current row:
- Index nnzL = fill_in/2;
- Index nnzU = nnzL;
- m_lu.reserve(n * (nnzL + nnzU + 1));
- // global loop over the rows of the sparse matrix
- for (Index ii = 0; ii < n; ii++)
- {
- // 1 - copy the lower and the upper part of the row i of mat in the working vector u
- Index sizeu = 1; // number of nonzero elements in the upper part of the current row
- Index sizel = 0; // number of nonzero elements in the lower part of the current row
- ju(ii) = convert_index<StorageIndex>(ii);
- u(ii) = 0;
- jr(ii) = convert_index<StorageIndex>(ii);
- RealScalar rownorm = 0;
- typename FactorType::InnerIterator j_it(mat, ii); // Iterate through the current row ii
- for (; j_it; ++j_it)
- {
- Index k = j_it.index();
- if (k < ii)
- {
- // copy the lower part
- ju(sizel) = convert_index<StorageIndex>(k);
- u(sizel) = j_it.value();
- jr(k) = convert_index<StorageIndex>(sizel);
- ++sizel;
- }
- else if (k == ii)
- {
- u(ii) = j_it.value();
- }
- else
- {
- // copy the upper part
- Index jpos = ii + sizeu;
- ju(jpos) = convert_index<StorageIndex>(k);
- u(jpos) = j_it.value();
- jr(k) = convert_index<StorageIndex>(jpos);
- ++sizeu;
- }
- rownorm += numext::abs2(j_it.value());
- }
- // 2 - detect possible zero row
- if(rownorm==0)
- {
- m_info = NumericalIssue;
- return;
- }
- // Take the 2-norm of the current row as a relative tolerance
- rownorm = sqrt(rownorm);
- // 3 - eliminate the previous nonzero rows
- Index jj = 0;
- Index len = 0;
- while (jj < sizel)
- {
- // In order to eliminate in the correct order,
- // we must select first the smallest column index among ju(jj:sizel)
- Index k;
- Index minrow = ju.segment(jj,sizel-jj).minCoeff(&k); // k is relative to the segment
- k += jj;
- if (minrow != ju(jj))
- {
- // swap the two locations
- Index j = ju(jj);
- swap(ju(jj), ju(k));
- jr(minrow) = convert_index<StorageIndex>(jj);
- jr(j) = convert_index<StorageIndex>(k);
- swap(u(jj), u(k));
- }
- // Reset this location
- jr(minrow) = -1;
- // Start elimination
- typename FactorType::InnerIterator ki_it(m_lu, minrow);
- while (ki_it && ki_it.index() < minrow) ++ki_it;
- eigen_internal_assert(ki_it && ki_it.col()==minrow);
- Scalar fact = u(jj) / ki_it.value();
- // drop too small elements
- if(abs(fact) <= m_droptol)
- {
- jj++;
- continue;
- }
- // linear combination of the current row ii and the row minrow
- ++ki_it;
- for (; ki_it; ++ki_it)
- {
- Scalar prod = fact * ki_it.value();
- Index j = ki_it.index();
- Index jpos = jr(j);
- if (jpos == -1) // fill-in element
- {
- Index newpos;
- if (j >= ii) // dealing with the upper part
- {
- newpos = ii + sizeu;
- sizeu++;
- eigen_internal_assert(sizeu<=n);
- }
- else // dealing with the lower part
- {
- newpos = sizel;
- sizel++;
- eigen_internal_assert(sizel<=ii);
- }
- ju(newpos) = convert_index<StorageIndex>(j);
- u(newpos) = -prod;
- jr(j) = convert_index<StorageIndex>(newpos);
- }
- else
- u(jpos) -= prod;
- }
- // store the pivot element
- u(len) = fact;
- ju(len) = convert_index<StorageIndex>(minrow);
- ++len;
- jj++;
- } // end of the elimination on the row ii
- // reset the upper part of the pointer jr to zero
- for(Index k = 0; k <sizeu; k++) jr(ju(ii+k)) = -1;
- // 4 - partially sort and insert the elements in the m_lu matrix
- // sort the L-part of the row
- sizel = len;
- len = (std::min)(sizel, nnzL);
- typename Vector::SegmentReturnType ul(u.segment(0, sizel));
- typename VectorI::SegmentReturnType jul(ju.segment(0, sizel));
- internal::QuickSplit(ul, jul, len);
- // store the largest m_fill elements of the L part
- m_lu.startVec(ii);
- for(Index k = 0; k < len; k++)
- m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
- // store the diagonal element
- // apply a shifting rule to avoid zero pivots (we are doing an incomplete factorization)
- if (u(ii) == Scalar(0))
- u(ii) = sqrt(m_droptol) * rownorm;
- m_lu.insertBackByOuterInnerUnordered(ii, ii) = u(ii);
- // sort the U-part of the row
- // apply the dropping rule first
- len = 0;
- for(Index k = 1; k < sizeu; k++)
- {
- if(abs(u(ii+k)) > m_droptol * rownorm )
- {
- ++len;
- u(ii + len) = u(ii + k);
- ju(ii + len) = ju(ii + k);
- }
- }
- sizeu = len + 1; // +1 to take into account the diagonal element
- len = (std::min)(sizeu, nnzU);
- typename Vector::SegmentReturnType uu(u.segment(ii+1, sizeu-1));
- typename VectorI::SegmentReturnType juu(ju.segment(ii+1, sizeu-1));
- internal::QuickSplit(uu, juu, len);
- // store the largest elements of the U part
- for(Index k = ii + 1; k < ii + len; k++)
- m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
- }
- m_lu.finalize();
- m_lu.makeCompressed();
- m_factorizationIsOk = true;
- m_info = Success;
- }
- } // end namespace Eigen
- #endif // EIGEN_INCOMPLETE_LUT_H
|