SparseTriangularView.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) 2009-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
6 //
7 // This Source Code Form is subject to the terms of the Mozilla
8 // Public License v. 2.0. If a copy of the MPL was not distributed
9 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10 
11 #ifndef EIGEN_SPARSE_TRIANGULARVIEW_H
12 #define EIGEN_SPARSE_TRIANGULARVIEW_H
13 
14 namespace Eigen {
15 
25 template<typename MatrixType, unsigned int Mode> class TriangularViewImpl<MatrixType,Mode,Sparse>
26  : public SparseMatrixBase<TriangularView<MatrixType,Mode> >
27 {
28  enum { SkipFirst = ((Mode&Lower) && !(MatrixType::Flags&RowMajorBit))
29  || ((Mode&Upper) && (MatrixType::Flags&RowMajorBit)),
30  SkipLast = !SkipFirst,
31  SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
32  HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
33  };
34 
36 
37  protected:
38  // dummy solve function to make TriangularView happy.
39  void solve() const;
40 
42  public:
43 
44  EIGEN_SPARSE_PUBLIC_INTERFACE(TriangularViewType)
45 
46  typedef typename MatrixType::Nested MatrixTypeNested;
47  typedef typename internal::remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
48  typedef typename internal::remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
49 
50  template<typename RhsType, typename DstType>
52  EIGEN_STRONG_INLINE void _solve_impl(const RhsType &rhs, DstType &dst) const {
54  dst = rhs;
55  this->solveInPlace(dst);
56  }
57 
59  template<typename OtherDerived> void solveInPlace(MatrixBase<OtherDerived>& other) const;
60 
62  template<typename OtherDerived> void solveInPlace(SparseMatrixBase<OtherDerived>& other) const;
63 
64 };
65 
66 namespace internal {
67 
68 template<typename ArgType, unsigned int Mode>
70  : evaluator_base<TriangularView<ArgType,Mode> >
71 {
73 
74 protected:
75 
76  typedef typename XprType::Scalar Scalar;
77  typedef typename XprType::StorageIndex StorageIndex;
79 
80  enum { SkipFirst = ((Mode&Lower) && !(ArgType::Flags&RowMajorBit))
81  || ((Mode&Upper) && (ArgType::Flags&RowMajorBit)),
82  SkipLast = !SkipFirst,
83  SkipDiag = (Mode&ZeroDiag) ? 1 : 0,
84  HasUnitDiag = (Mode&UnitDiag) ? 1 : 0
85  };
86 
87 public:
88 
89  enum {
91  Flags = XprType::Flags
92  };
93 
94  explicit unary_evaluator(const XprType &xpr) : m_argImpl(xpr.nestedExpression()), m_arg(xpr.nestedExpression()) {}
95 
96  inline Index nonZerosEstimate() const {
97  return m_argImpl.nonZerosEstimate();
98  }
99 
100  class InnerIterator : public EvalIterator
101  {
102  typedef EvalIterator Base;
103  public:
104 
106  : Base(xprEval.m_argImpl,outer), m_returnOne(false), m_containsDiag(Base::outer()<xprEval.m_arg.innerSize())
107  {
108  if(SkipFirst)
109  {
110  while((*this) && ((HasUnitDiag||SkipDiag) ? this->index()<=outer : this->index()<outer))
112  if(HasUnitDiag)
113  m_returnOne = m_containsDiag;
114  }
115  else if(HasUnitDiag && ((!Base::operator bool()) || Base::index()>=Base::outer()))
116  {
117  if((!SkipFirst) && Base::operator bool())
119  m_returnOne = m_containsDiag;
120  }
121  }
122 
124  {
125  if(HasUnitDiag && m_returnOne)
126  m_returnOne = false;
127  else
128  {
130  if(HasUnitDiag && (!SkipFirst) && ((!Base::operator bool()) || Base::index()>=Base::outer()))
131  {
132  if((!SkipFirst) && Base::operator bool())
134  m_returnOne = m_containsDiag;
135  }
136  }
137  return *this;
138  }
139 
140  EIGEN_STRONG_INLINE operator bool() const
141  {
142  if(HasUnitDiag && m_returnOne)
143  return true;
144  if(SkipFirst) return Base::operator bool();
145  else
146  {
147  if (SkipDiag) return (Base::operator bool() && this->index() < this->outer());
148  else return (Base::operator bool() && this->index() <= this->outer());
149  }
150  }
151 
152 // inline Index row() const { return (ArgType::Flags&RowMajorBit ? Base::outer() : this->index()); }
153 // inline Index col() const { return (ArgType::Flags&RowMajorBit ? this->index() : Base::outer()); }
154  inline StorageIndex index() const
155  {
156  if(HasUnitDiag && m_returnOne) return internal::convert_index<StorageIndex>(Base::outer());
157  else return Base::index();
158  }
159  inline Scalar value() const
160  {
161  if(HasUnitDiag && m_returnOne) return Scalar(1);
162  else return Base::value();
163  }
164 
165  protected:
168  private:
169  Scalar& valueRef();
170  };
171 
172 protected:
174  const ArgType& m_arg;
175 };
176 
177 } // end namespace internal
178 
179 template<typename Derived>
180 template<int Mode>
183 {
184  return TriangularView<const Derived, Mode>(derived());
185 }
186 
187 } // end namespace Eigen
188 
189 #endif // EIGEN_SPARSE_TRIANGULARVIEW_H
SCALAR Scalar
Definition: bench_gemm.cpp:46
#define EIGEN_STRONG_INLINE
Definition: Macros.h:917
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE const T::Scalar * extract_data(const T &m)
Definition: BlasUtil.h:533
MatrixXf MatrixType
const unsigned int RowMajorBit
Definition: Constants.h:66
internal::traits< TriangularView >::Scalar Scalar
#define EIGEN_SPARSE_PUBLIC_INTERFACE(Derived)
Definition: SparseUtil.h:43
Base class of any sparse matrices or sparse expressions.
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
const TriangularView< const Derived, Mode > triangularView() const
#define EIGEN_DEVICE_FUNC
Definition: Macros.h:976
Expression of a triangular part in a matrix.
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48
Definition: pytypes.h:1370
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 operator++(bfloat16 &a)
Definition: BFloat16.h:200
An InnerIterator allows to loop over the element of any matrix expression.
Definition: CoreIterators.h:33


gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:36:16