29#ifndef EIGEN_STRUCTURED_DIAGONAL_PLUS_LOW_RANK_H
30#define EIGEN_STRUCTURED_DIAGONAL_PLUS_LOW_RANK_H
33#include "./InternalHeaderCheck.h"
37template <
typename Scalar_,
int Size_ = Dynamic,
int Rank_ = Dynamic>
42template <
typename Scalar_,
int Size_,
int Rank_>
43struct traits<DiagonalPlusLowRank<Scalar_, Size_, Rank_>> {
44 using Scalar = Scalar_;
45 using StorageKind = Dense;
46 using XprKind = MatrixXpr;
47 using StorageIndex = int;
48 static constexpr int RowsAtCompileTime = Size_;
49 static constexpr int ColsAtCompileTime = Size_;
50 static constexpr int MaxRowsAtCompileTime = Size_;
51 static constexpr int MaxColsAtCompileTime = Size_;
56 static constexpr unsigned int Flags = 0;
59template <
typename Scalar_,
int Size_,
int Rank_>
60struct evaluator_traits<DiagonalPlusLowRank<Scalar_, Size_, Rank_>> {
61 using Kind = IndexBased;
62 using Shape = StructuredShape;
68struct dplr_capacitance_impl {
71 template <
typename Op,
typename Dinv,
typename Workspace>
72 static void subtractSolveCorrection(
const Op& op,
const Dinv& dinv, Workspace& x) {
73 if (op.correctionRank() == 0 || x.size() == 0)
return;
74 PartialPivLU<typename Op::CapacitanceType> cap(op.capacitance());
75 x.noalias() -= dinv.asDiagonal() * (op.factorU() * cap.solve(op.factorV().adjoint() * x));
78 template <
typename Op,
typename Dinv,
typename Factor>
79 static void inverseFactor(
const Op& op,
const Dinv& dinv, Factor& Up) {
80 if (op.correctionRank() == 0)
return;
81 PartialPivLU<typename Op::CapacitanceType> cap(op.capacitance());
82 const typename Op::CapacitanceType K = cap.inverse();
83 Up.noalias() = -(dinv.asDiagonal() * op.factorU() * K);
89 template <
typename Op>
90 static typename Op::Scalar balancedCapacitanceDeterminant(
const Op& op, Index& exponent) {
91 using Scalar =
typename Op::Scalar;
92 if (op.correctionRank() == 0)
return Scalar(1);
93 const PartialPivLU<typename Op::CapacitanceType> lu(op.capacitance());
94 Scalar det(
static_cast<typename Op::RealScalar
>(lu.permutationP().determinant()));
95 for (Index i = 0; i < lu.matrixLU().rows(); ++i)
96 det = balance_exponent(det * balance_exponent(lu.matrixLU().coeff(i, i), exponent), exponent);
102struct dplr_capacitance_impl<0> {
103 template <
typename Op,
typename Dinv,
typename Workspace>
104 static void subtractSolveCorrection(
const Op&,
const Dinv&, Workspace&) {}
105 template <
typename Op,
typename Dinv,
typename Factor>
106 static void inverseFactor(
const Op&,
const Dinv&, Factor&) {}
107 template <
typename Op>
108 static typename Op::Scalar balancedCapacitanceDeterminant(
const Op&, Index&) {
109 return typename Op::Scalar(1);
152template <
typename Scalar_,
int Size_,
int Rank_>
155 using Scalar = Scalar_;
157 using StorageIndex = int;
162 static constexpr int RowsAtCompileTime = Size_;
163 static constexpr int ColsAtCompileTime = Size_;
164 static constexpr int MaxRowsAtCompileTime = Size_;
165 static constexpr int MaxColsAtCompileTime = Size_;
166 static constexpr int SizeAtCompileTime = internal::size_at_compile_time(Size_, Size_);
167 static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
168 static constexpr bool IsRowMajor =
false;
176 template <
typename DDerived,
typename UDerived,
typename VDerived>
178 : m_d(d), m_U(U), m_V(V) {
179 EIGEN_STATIC_ASSERT_VECTOR_ONLY(DDerived)
180 EIGEN_INTERNAL_ASSERT_NONEMPTY_MSG(m_d,
"DiagonalPlusLowRank must be non-empty");
181 EIGEN_INTERNAL_ASSERT_SIZE_MATCHES_ROWS_MSG(m_d, m_U,
"factor dimensions do not match");
182 EIGEN_INTERNAL_ASSERT_SIZE_MATCHES_ROWS_MSG(m_d, m_V,
"factor dimensions do not match");
183 EIGEN_INTERNAL_ASSERT_SAME_COLS_MSG(m_U, m_V,
"factor dimensions do not match");
186 EIGEN_DEVICE_FUNC Index rows()
const {
return m_d.size(); }
187 EIGEN_DEVICE_FUNC Index cols()
const {
return m_d.size(); }
192 const DiagonalVector&
diagonal()
const {
return m_d; }
194 const FactorType&
factorU()
const {
return m_U; }
196 const FactorType&
factorV()
const {
return m_V; }
200 Scalar r = m_V.row(col).dot(m_U.row(row));
201 if (row == col) r += m_d.coeff(row);
227 CapacitanceType c = CapacitanceType::Identity(k, k);
228 if (k == 0)
return c;
229 const DiagonalVector dinv = m_d.cwiseInverse();
230 c.noalias() += m_V.adjoint() * dinv.asDiagonal() * m_U;
244 template <
typename Rhs>
246 EIGEN_INTERNAL_ASSERT_SOLVER_RHS_MSG(*
this, b,
false,
"right-hand side has the wrong number of rows");
247 const DiagonalVector dinv = m_d.cwiseInverse();
249 internal::dplr_capacitance_impl<Rank_>::subtractSolveCorrection(*
this, dinv, x);
258 const DiagonalVector dinv = m_d.cwiseInverse();
260 internal::dplr_capacitance_impl<Rank_>::inverseFactor(*
this, dinv, Up);
261 FactorType Vp = dinv.conjugate().asDiagonal() * m_V;
287 for (
Index i = 0; i < rows(); ++i)
288 det = internal::balance_exponent(det * internal::balance_exponent(m_d.coeff(i), exponent), exponent);
289 const Scalar capDet = internal::dplr_capacitance_impl<Rank_>::balancedCapacitanceDeterminant(*
this, exponent);
290 det = internal::balance_exponent(det * capDet, exponent);
291 return internal::apply_exponent(det, exponent);
296 template <
typename Dest>
297 void evalTo(Dest& dst)
const {
298 dst.noalias() = m_U * m_V.adjoint();
299 dst.diagonal() += m_d;
303 template <
typename Dest>
304 void addTo(Dest& dst)
const {
305 dst.noalias() += m_U * m_V.adjoint();
306 dst.diagonal() += m_d;
310 template <
typename Dest>
311 void subTo(Dest& dst)
const {
312 dst.noalias() -= m_U * m_V.adjoint();
313 dst.diagonal() -= m_d;
321 template <
typename Rhs>
330 template <
typename Dest,
typename Rhs,
typename ProductScalar>
331 void addProduct(Dest& dst,
const Rhs& rhs,
const ProductScalar& alpha)
const {
332 EIGEN_INTERNAL_ASSERT_PRODUCT_SHAPE_MSG(*
this, rhs,
"invalid product: dimensions do not match");
334 dst += alpha * (m_d.asDiagonal() * r);
337 dst.noalias() += alpha * (m_U * t);
350template <
typename DDerived,
typename UDerived,
typename VDerived>
361template <
typename Scalar_,
int Size_,
int Rank_,
typename Rhs,
int ProductTag>
362struct generic_product_impl<DiagonalPlusLowRank<Scalar_, Size_, Rank_>, Rhs, StructuredShape, DenseShape, ProductTag>
363 : structured_product_impl<DiagonalPlusLowRank<Scalar_, Size_, Rank_>, Rhs> {};
367#if EIGEN_COMP_CXXVER < 17
368template <
typename Scalar_,
int Size_,
int Rank_>
369constexpr int DiagonalPlusLowRank<Scalar_, Size_, Rank_>::RowsAtCompileTime;
370template <
typename Scalar_,
int Size_,
int Rank_>
371constexpr int DiagonalPlusLowRank<Scalar_, Size_, Rank_>::ColsAtCompileTime;
372template <
typename Scalar_,
int Size_,
int Rank_>
373constexpr int DiagonalPlusLowRank<Scalar_, Size_, Rank_>::MaxRowsAtCompileTime;
374template <
typename Scalar_,
int Size_,
int Rank_>
375constexpr int DiagonalPlusLowRank<Scalar_, Size_, Rank_>::MaxColsAtCompileTime;
376template <
typename Scalar_,
int Size_,
int Rank_>
377constexpr int DiagonalPlusLowRank<Scalar_, Size_, Rank_>::SizeAtCompileTime;
378template <
typename Scalar_,
int Size_,
int Rank_>
379constexpr int DiagonalPlusLowRank<Scalar_, Size_, Rank_>::MaxSizeAtCompileTime;
380template <
typename Scalar_,
int Size_,
int Rank_>
381constexpr bool DiagonalPlusLowRank<Scalar_, Size_, Rank_>::IsRowMajor;
An n x n operator : a diagonal matrix plus a rank-k correction, stored as its diagonal and the two n ...
Definition DiagonalPlusLowRank.h:153
const FactorType & factorV() const
Definition DiagonalPlusLowRank.h:196
Scalar coeff(Index row, Index col) const
Definition DiagonalPlusLowRank.h:199
Matrix< Scalar, Size_, Rhs::ColsAtCompileTime > solve(const MatrixBase< Rhs > &b) const
Definition DiagonalPlusLowRank.h:245
DiagonalPlusLowRank conjugate() const
Definition DiagonalPlusLowRank.h:211
DiagonalPlusLowRank adjoint() const
Definition DiagonalPlusLowRank.h:217
const FactorType & factorU() const
Definition DiagonalPlusLowRank.h:194
Product< DiagonalPlusLowRank, Rhs > operator*(const MatrixBase< Rhs > &v) const
Definition DiagonalPlusLowRank.h:322
DiagonalPlusLowRank inverse() const
Definition DiagonalPlusLowRank.h:257
const DiagonalVector & diagonal() const
Definition DiagonalPlusLowRank.h:192
DiagonalPlusLowRank(const MatrixBase< DDerived > &d, const MatrixBase< UDerived > &U, const MatrixBase< VDerived > &V)
Definition DiagonalPlusLowRank.h:177
CapacitanceType capacitance() const
Definition DiagonalPlusLowRank.h:225
DiagonalPlusLowRank transpose() const
Definition DiagonalPlusLowRank.h:207
Index correctionRank() const
Definition DiagonalPlusLowRank.h:189
Scalar determinant() const
Definition DiagonalPlusLowRank.h:284
DiagonalPlusLowRank< typename DDerived::Scalar, DDerived::SizeAtCompileTime, UDerived::ColsAtCompileTime > makeDiagonalPlusLowRank(const MatrixBase< DDerived > &d, const MatrixBase< UDerived > &U, const MatrixBase< VDerived > &V)
Definition DiagonalPlusLowRank.h:352
Namespace containing all symbols from the Eigen library.