10 #ifndef EIGEN_INCOMPLETE_LUT_H
11 #define EIGEN_INCOMPLETE_LUT_H
43 template <
typename _Scalar>
46 typedef _Scalar Scalar;
51 typedef typename FactorType::Index Index;
58 m_analysisIsOk(
false), m_factorizationIsOk(
false), m_isInitialized(
false)
61 template<
typename MatrixType>
63 : m_droptol(droptol),m_fillfactor(fillfactor),
64 m_analysisIsOk(
false),m_factorizationIsOk(
false),m_isInitialized(
false)
66 eigen_assert(fillfactor != 0);
70 Index rows()
const {
return m_lu.
rows(); }
72 Index cols()
const {
return m_lu.
cols(); }
81 eigen_assert(m_isInitialized &&
"IncompleteLUT is not initialized.");
85 template<
typename MatrixType>
86 void analyzePattern(
const MatrixType& amat);
88 template<
typename MatrixType>
89 void factorize(
const MatrixType& amat);
96 template<
typename MatrixType>
101 eigen_assert(m_factorizationIsOk ==
true);
102 m_isInitialized =
true;
109 template<
typename Rhs,
typename Dest>
110 void _solve(
const Rhs& b, Dest& x)
const
113 x = m_lu.template triangularView<UnitLower>().solve(x);
114 x = m_lu.template triangularView<Upper>().solve(x);
118 template<
typename Rhs>
inline const internal::solve_retval<IncompleteLUT, Rhs>
119 solve(
const MatrixBase<Rhs>& b)
const
121 eigen_assert(m_isInitialized &&
"IncompleteLUT is not initialized.");
122 eigen_assert(cols()==b.rows()
123 &&
"IncompleteLUT::solve(): invalid number of rows of the right hand side matrix b");
124 return internal::solve_retval<IncompleteLUT, Rhs>(*
this, b.derived());
129 template <
typename VectorV,
typename VectorI>
130 int QuickSplit(VectorV &row, VectorI &ind,
int ncut);
135 inline bool operator() (
const Index& row,
const Index& col,
const Scalar&)
const
144 RealScalar m_droptol;
147 bool m_factorizationIsOk;
148 bool m_isInitialized;
158 template<
typename Scalar>
161 this->m_droptol = droptol;
168 template<
typename Scalar>
171 this->m_fillfactor = fillfactor;
184 template <
typename Scalar>
185 template <
typename VectorV,
typename VectorI>
196 if (ncut < first || ncut > last )
return 0;
200 RealScalar abskey = std::abs(row(mid));
201 for (
int j = first + 1; j <= last; j++) {
202 if ( std::abs(row(j)) > abskey) {
204 swap(row(mid), row(j));
205 swap(ind(mid), ind(j));
209 swap(row(mid), row(first));
210 swap(ind(mid), ind(first));
212 if (mid > ncut) last = mid - 1;
213 else if (mid < ncut ) first = mid + 1;
214 }
while (mid != ncut );
219 template <
typename Scalar>
220 template<
typename _MatrixType>
230 AtA.
prune(keep_diag());
231 internal::minimum_degree_ordering<Scalar, Index>(AtA, m_P);
233 m_Pinv = m_P.inverse();
235 m_analysisIsOk =
true;
238 template <
typename Scalar>
239 template<
typename _MatrixType>
240 void IncompleteLUT<Scalar>::factorize(
const _MatrixType& amat)
246 eigen_assert((amat.rows() == amat.cols()) &&
"The factorization should be done on a square matrix");
255 eigen_assert(m_analysisIsOk &&
"You must first call analyzePattern()");
256 SparseMatrix<Scalar,RowMajor, Index> mat;
257 mat = amat.twistedBy(m_Pinv);
265 int fill_in =
static_cast<int> (amat.nonZeros()*m_fillfactor)/n+1;
266 if (fill_in > n) fill_in = n;
269 int nnzL = fill_in/2;
271 m_lu.reserve(n * (nnzL + nnzU + 1));
274 for (
int ii = 0; ii < n; ii++)
283 RealScalar rownorm = 0;
285 typename FactorType::InnerIterator j_it(mat, ii);
288 int k = j_it.index();
293 u(sizel) = j_it.value();
299 u(ii) = j_it.value();
304 int jpos = ii + sizeu;
306 u(jpos) = j_it.value();
310 rownorm += internal::abs2(j_it.value());
320 rownorm = sqrt(rownorm);
330 int minrow = ju.segment(jj,sizel-jj).minCoeff(&k);
332 if (minrow != ju(jj))
337 jr(minrow) = jj; jr(j) = k;
344 typename FactorType::InnerIterator ki_it(m_lu, minrow);
345 while (ki_it && ki_it.index() < minrow) ++ki_it;
346 eigen_internal_assert(ki_it && ki_it.col()==minrow);
347 Scalar fact = u(jj) / ki_it.value();
350 if(abs(fact) <= m_droptol)
358 for (; ki_it; ++ki_it)
360 Scalar prod = fact * ki_it.value();
361 int j = ki_it.index();
370 eigen_internal_assert(sizeu<=n);
376 eigen_internal_assert(sizel<=ii);
394 for(
int k = 0; k <sizeu; k++) jr(ju(ii+k)) = -1;
400 len = (std::min)(sizel, nnzL);
401 typename Vector::SegmentReturnType ul(u.segment(0, sizel));
402 typename VectorXi::SegmentReturnType jul(ju.segment(0, sizel));
403 QuickSplit(ul, jul, len);
407 for(
int k = 0; k < len; k++)
408 m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
412 if (u(ii) == Scalar(0))
413 u(ii) = sqrt(m_droptol) * rownorm;
414 m_lu.insertBackByOuterInnerUnordered(ii, ii) = u(ii);
419 for(
int k = 1; k < sizeu; k++)
421 if(abs(u(ii+k)) > m_droptol * rownorm )
424 u(ii + len) = u(ii + k);
425 ju(ii + len) = ju(ii + k);
429 len = (std::min)(sizeu, nnzU);
430 typename Vector::SegmentReturnType uu(u.segment(ii+1, sizeu-1));
431 typename VectorXi::SegmentReturnType juu(ju.segment(ii+1, sizeu-1));
432 QuickSplit(uu, juu, len);
435 for(
int k = ii + 1; k < ii + len; k++)
436 m_lu.insertBackByOuterInnerUnordered(ii,ju(k)) = u(k);
440 m_lu.makeCompressed();
442 m_factorizationIsOk =
true;
448 template<
typename _MatrixType,
typename Rhs>
449 struct solve_retval<IncompleteLUT<_MatrixType>, Rhs>
450 : solve_retval_base<IncompleteLUT<_MatrixType>, Rhs>
452 typedef IncompleteLUT<_MatrixType> Dec;
453 EIGEN_MAKE_SOLVE_HELPERS(Dec,Rhs)
455 template<typename Dest>
void evalTo(Dest& dst)
const
457 dec()._solve(rhs(),dst);
465 #endif // EIGEN_INCOMPLETE_LUT_H