BasicPreconditioners.h
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #ifndef EIGEN_BASIC_PRECONDITIONERS_H
11 #define EIGEN_BASIC_PRECONDITIONERS_H
12 
13 namespace Eigen {
14 
35 template <typename _Scalar>
37 {
38  typedef _Scalar Scalar;
40  public:
41  typedef typename Vector::StorageIndex StorageIndex;
42  enum {
45  };
46 
48 
49  template<typename MatType>
50  explicit DiagonalPreconditioner(const MatType& mat) : m_invdiag(mat.cols())
51  {
52  compute(mat);
53  }
54 
55  EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_invdiag.size(); }
56  EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_invdiag.size(); }
57 
58  template<typename MatType>
60  {
61  return *this;
62  }
63 
64  template<typename MatType>
66  {
67  m_invdiag.resize(mat.cols());
68  for(int j=0; j<mat.outerSize(); ++j)
69  {
70  typename MatType::InnerIterator it(mat,j);
71  while(it && it.index()!=j) ++it;
72  if(it && it.index()==j && it.value()!=Scalar(0))
73  m_invdiag(j) = Scalar(1)/it.value();
74  else
75  m_invdiag(j) = Scalar(1);
76  }
77  m_isInitialized = true;
78  return *this;
79  }
80 
81  template<typename MatType>
83  {
84  return factorize(mat);
85  }
86 
88  template<typename Rhs, typename Dest>
89  void _solve_impl(const Rhs& b, Dest& x) const
90  {
91  x = m_invdiag.array() * b.array() ;
92  }
93 
94  template<typename Rhs> inline const Solve<DiagonalPreconditioner, Rhs>
95  solve(const MatrixBase<Rhs>& b) const
96  {
97  eigen_assert(m_isInitialized && "DiagonalPreconditioner is not initialized.");
98  eigen_assert(m_invdiag.size()==b.rows()
99  && "DiagonalPreconditioner::solve(): invalid number of rows of the right hand side matrix b");
100  return Solve<DiagonalPreconditioner, Rhs>(*this, b.derived());
101  }
102 
104 
105  protected:
106  Vector m_invdiag;
108 };
109 
127 template <typename _Scalar>
129 {
130  typedef _Scalar Scalar;
133  using Base::m_invdiag;
134  public:
135 
137 
138  template<typename MatType>
139  explicit LeastSquareDiagonalPreconditioner(const MatType& mat) : Base()
140  {
141  compute(mat);
142  }
143 
144  template<typename MatType>
146  {
147  return *this;
148  }
149 
150  template<typename MatType>
152  {
153  // Compute the inverse squared-norm of each column of mat
154  m_invdiag.resize(mat.cols());
155  if(MatType::IsRowMajor)
156  {
157  m_invdiag.setZero();
158  for(Index j=0; j<mat.outerSize(); ++j)
159  {
160  for(typename MatType::InnerIterator it(mat,j); it; ++it)
161  m_invdiag(it.index()) += numext::abs2(it.value());
162  }
163  for(Index j=0; j<mat.cols(); ++j)
166  }
167  else
168  {
169  for(Index j=0; j<mat.outerSize(); ++j)
170  {
171  RealScalar sum = mat.col(j).squaredNorm();
172  if(sum>RealScalar(0))
173  m_invdiag(j) = RealScalar(1)/sum;
174  else
175  m_invdiag(j) = RealScalar(1);
176  }
177  }
178  Base::m_isInitialized = true;
179  return *this;
180  }
181 
182  template<typename MatType>
184  {
185  return factorize(mat);
186  }
187 
189 
190  protected:
191 };
192 
201 {
202  public:
203 
205 
206  template<typename MatrixType>
207  explicit IdentityPreconditioner(const MatrixType& ) {}
208 
209  template<typename MatrixType>
211 
212  template<typename MatrixType>
213  IdentityPreconditioner& factorize(const MatrixType& ) { return *this; }
214 
215  template<typename MatrixType>
216  IdentityPreconditioner& compute(const MatrixType& ) { return *this; }
217 
218  template<typename Rhs>
219  inline const Rhs& solve(const Rhs& b) const { return b; }
220 
222 };
223 
224 } // end namespace Eigen
225 
226 #endif // EIGEN_BASIC_PRECONDITIONERS_H
A preconditioner based on the digonal entries.
EIGEN_DEVICE_FUNC Derived & setZero(Index size)
float real
Definition: datatypes.h:10
Scalar * b
Definition: benchVecAdd.cpp:17
LeastSquareDiagonalPreconditioner & compute(const MatType &mat)
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
MatrixXf MatrixType
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:232
IdentityPreconditioner & analyzePattern(const MatrixType &)
LeastSquareDiagonalPreconditioner & factorize(const MatType &mat)
DiagonalPreconditioner< _Scalar > Base
Jacobi preconditioner for LeastSquaresConjugateGradient.
DiagonalPreconditioner & factorize(const MatType &mat)
EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
DiagonalPreconditioner & compute(const MatType &mat)
const Solve< DiagonalPreconditioner, Rhs > solve(const MatrixBase< Rhs > &b) const
#define EIGEN_NOEXCEPT
Definition: Macros.h:1418
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
#define eigen_assert(x)
Definition: Macros.h:1037
LeastSquareDiagonalPreconditioner & analyzePattern(const MatType &)
DiagonalPreconditioner & analyzePattern(const MatType &)
#define EIGEN_CONSTEXPR
Definition: Macros.h:787
NumTraits< Scalar >::Real RealScalar
Definition: bench_gemm.cpp:47
void _solve_impl(const Rhs &b, Dest &x) const
const Rhs & solve(const Rhs &b) const
IdentityPreconditioner & compute(const MatrixType &)
Matrix< Scalar, Dynamic, 1 > Vector
DiagonalPreconditioner(const MatType &mat)
A naive preconditioner which approximates any matrix as the identity matrix.
const int Dynamic
Definition: Constants.h:22
Pseudo expression representing a solving operation.
Definition: Solve.h:62
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
IdentityPreconditioner & factorize(const MatrixType &)
ComputationInfo
Definition: Constants.h:440
EIGEN_DEVICE_FUNC bool abs2(bool x)
EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48
std::ptrdiff_t j
IdentityPreconditioner(const MatrixType &)


gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:33:57