11 #ifndef EIGEN_TRIANGULARMATRIX_H
12 #define EIGEN_TRIANGULARMATRIX_H
18 template<
int S
ide,
typename TriangularType,
typename Rhs>
struct triangular_solve_retval;
29 template<
typename Derived>
class TriangularBase :
public EigenBase<Derived>
34 Mode = internal::traits<Derived>::Mode,
35 CoeffReadCost = internal::traits<Derived>::CoeffReadCost,
36 RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
37 ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
38 MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime,
39 MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime
41 typedef typename internal::traits<Derived>::Scalar Scalar;
42 typedef typename internal::traits<Derived>::StorageKind StorageKind;
43 typedef typename internal::traits<Derived>::Index Index;
44 typedef typename internal::traits<Derived>::DenseMatrixType DenseMatrixType;
45 typedef DenseMatrixType DenseType;
47 inline TriangularBase() { eigen_assert(!((Mode&
UnitDiag) && (Mode&
ZeroDiag))); }
49 inline Index rows()
const {
return derived().rows(); }
50 inline Index cols()
const {
return derived().cols(); }
51 inline Index outerStride()
const {
return derived().outerStride(); }
52 inline Index innerStride()
const {
return derived().innerStride(); }
54 inline Scalar coeff(Index row, Index col)
const {
return derived().coeff(row,col); }
55 inline Scalar& coeffRef(Index row, Index col) {
return derived().coeffRef(row,col); }
59 template<
typename Other>
60 EIGEN_STRONG_INLINE
void copyCoeff(Index row, Index col, Other& other)
62 derived().coeffRef(row, col) = other.coeff(row, col);
65 inline Scalar operator()(Index row, Index col)
const
67 check_coordinates(row, col);
68 return coeff(row,col);
70 inline Scalar& operator()(Index row, Index col)
72 check_coordinates(row, col);
73 return coeffRef(row,col);
76 #ifndef EIGEN_PARSED_BY_DOXYGEN
77 inline const Derived&
derived()
const {
return *
static_cast<const Derived*
>(
this); }
78 inline Derived&
derived() {
return *
static_cast<Derived*
>(
this); }
79 #endif // not EIGEN_PARSED_BY_DOXYGEN
81 template<
typename DenseDerived>
82 void evalTo(MatrixBase<DenseDerived> &other)
const;
83 template<
typename DenseDerived>
84 void evalToLazy(MatrixBase<DenseDerived> &other)
const;
86 DenseMatrixType toDenseMatrix()
const
88 DenseMatrixType res(rows(), cols());
95 void check_coordinates(Index row, Index col)
const
97 EIGEN_ONLY_USED_FOR_DEBUG(row);
98 EIGEN_ONLY_USED_FOR_DEBUG(col);
99 eigen_assert(col>=0 && col<cols() && row>=0 && row<rows());
101 EIGEN_ONLY_USED_FOR_DEBUG(mode);
102 eigen_assert((mode==
Upper && col>=row)
103 || (mode==
Lower && col<=row)
108 #ifdef EIGEN_INTERNAL_DEBUGGING
109 void check_coordinates_internal(Index row, Index col)
const
111 check_coordinates(row, col);
114 void check_coordinates_internal(Index , Index )
const {}
137 template<
typename MatrixType,
unsigned int _Mode>
138 struct traits<TriangularView<MatrixType, _Mode> > : traits<MatrixType>
140 typedef typename nested<MatrixType>::type MatrixTypeNested;
141 typedef typename remove_reference<MatrixTypeNested>::type MatrixTypeNestedNonRef;
142 typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
143 typedef MatrixType ExpressionType;
144 typedef typename MatrixType::PlainObject DenseMatrixType;
148 CoeffReadCost = MatrixTypeNestedCleaned::CoeffReadCost
153 template<
int Mode,
bool LhsIsTriangular,
154 typename Lhs,
bool LhsIsVector,
155 typename Rhs,
bool RhsIsVector>
156 struct TriangularProduct;
159 :
public TriangularBase<TriangularView<_MatrixType, _Mode> >
163 typedef TriangularBase<TriangularView> Base;
164 typedef typename internal::traits<TriangularView>::Scalar Scalar;
166 typedef _MatrixType MatrixType;
167 typedef typename internal::traits<TriangularView>::DenseMatrixType DenseMatrixType;
168 typedef DenseMatrixType PlainObject;
171 typedef typename internal::traits<TriangularView>::MatrixTypeNested MatrixTypeNested;
172 typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRef MatrixTypeNestedNonRef;
173 typedef typename internal::traits<TriangularView>::MatrixTypeNestedCleaned MatrixTypeNestedCleaned;
175 typedef typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType;
178 using Base::evalToLazy;
181 typedef typename internal::traits<TriangularView>::StorageKind StorageKind;
182 typedef typename internal::traits<TriangularView>::Index Index;
192 inline TriangularView(
const MatrixType& matrix) : m_matrix(matrix)
195 inline Index rows()
const {
return m_matrix.rows(); }
196 inline Index cols()
const {
return m_matrix.cols(); }
197 inline Index outerStride()
const {
return m_matrix.outerStride(); }
198 inline Index innerStride()
const {
return m_matrix.innerStride(); }
213 {
return *
this = MatrixType::Constant(rows(), cols(), value); }
222 inline Scalar
coeff(Index row, Index col)
const
224 Base::check_coordinates_internal(row, col);
225 return m_matrix.coeff(row, col);
233 Base::check_coordinates_internal(row, col);
234 return m_matrix.const_cast_derived().coeffRef(row, col);
237 const MatrixTypeNestedCleaned& nestedExpression()
const {
return m_matrix; }
238 MatrixTypeNestedCleaned& nestedExpression() {
return *
const_cast<MatrixTypeNestedCleaned*
>(&m_matrix); }
241 template<
typename OtherDerived>
242 TriangularView&
operator=(
const TriangularBase<OtherDerived>& other);
244 template<
typename OtherDerived>
245 TriangularView&
operator=(
const MatrixBase<OtherDerived>& other);
247 TriangularView&
operator=(
const TriangularView& other)
248 {
return *
this = other.nestedExpression(); }
250 template<
typename OtherDerived>
251 void lazyAssign(
const TriangularBase<OtherDerived>& other);
253 template<
typename OtherDerived>
254 void lazyAssign(
const MatrixBase<OtherDerived>& other);
258 {
return m_matrix.conjugate(); }
261 {
return m_matrix.conjugate(); }
265 {
return m_matrix.adjoint(); }
270 EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
271 return m_matrix.const_cast_derived().transpose();
276 return m_matrix.transpose();
280 template<
typename OtherDerived>
281 TriangularProduct<Mode,true,MatrixType,false,OtherDerived, OtherDerived::IsVectorAtCompileTime>
284 return TriangularProduct
285 <Mode,
true,MatrixType,
false,OtherDerived,OtherDerived::IsVectorAtCompileTime>
286 (m_matrix, rhs.derived());
290 template<
typename OtherDerived>
friend
291 TriangularProduct<Mode,false,OtherDerived,OtherDerived::IsVectorAtCompileTime,MatrixType,false>
294 return TriangularProduct
295 <Mode,
false,OtherDerived,OtherDerived::IsVectorAtCompileTime,MatrixType,
false>
296 (lhs.derived(),rhs.m_matrix);
299 #ifdef EIGEN2_SUPPORT
300 template<
typename OtherDerived>
301 struct eigen2_product_return_type
303 typedef typename TriangularView<MatrixType,Mode>::DenseMatrixType DenseMatrixType;
304 typedef typename OtherDerived::PlainObject::DenseType OtherPlainObject;
306 typedef typename ProdRetType::PlainObject type;
308 template<
typename OtherDerived>
309 const typename eigen2_product_return_type<OtherDerived>::type
310 operator*(
const EigenBase<OtherDerived>& rhs)
const
312 typename OtherDerived::PlainObject::DenseType rhsPlainObject;
313 rhs.evalTo(rhsPlainObject);
314 return this->toDenseMatrix() * rhsPlainObject;
316 template<
typename OtherMatrixType>
317 bool isApprox(
const TriangularView<OtherMatrixType, Mode>& other,
typename NumTraits<Scalar>::Real precision = NumTraits<Scalar>::dummy_precision())
const
319 return this->toDenseMatrix().isApprox(other.toDenseMatrix(), precision);
321 template<
typename OtherDerived>
322 bool isApprox(
const MatrixBase<OtherDerived>& other,
typename NumTraits<Scalar>::Real precision = NumTraits<Scalar>::dummy_precision())
const
324 return this->toDenseMatrix().isApprox(other, precision);
326 #endif // EIGEN2_SUPPORT
328 template<
int S
ide,
typename Other>
329 inline const internal::triangular_solve_retval<Side,TriangularView, Other>
330 solve(
const MatrixBase<Other>& other)
const;
332 template<
int S
ide,
typename OtherDerived>
333 void solveInPlace(
const MatrixBase<OtherDerived>& other)
const;
335 template<
typename Other>
336 inline const internal::triangular_solve_retval<OnTheLeft,TriangularView, Other>
337 solve(
const MatrixBase<Other>& other)
const
338 {
return solve<OnTheLeft>(other); }
340 template<
typename OtherDerived>
341 void solveInPlace(
const MatrixBase<OtherDerived>& other)
const
342 {
return solveInPlace<OnTheLeft>(other); }
344 const SelfAdjointView<MatrixTypeNestedNonRef,Mode> selfadjointView()
const
346 EIGEN_STATIC_ASSERT((Mode&
UnitDiag)==0,PROGRAMMING_ERROR);
347 return SelfAdjointView<MatrixTypeNestedNonRef,Mode>(m_matrix);
349 SelfAdjointView<MatrixTypeNestedNonRef,Mode> selfadjointView()
351 EIGEN_STATIC_ASSERT((Mode&
UnitDiag)==0,PROGRAMMING_ERROR);
352 return SelfAdjointView<MatrixTypeNestedNonRef,Mode>(m_matrix);
355 template<
typename OtherDerived>
356 void swap(TriangularBase<OtherDerived>
const & other)
358 TriangularView<SwapWrapper<MatrixType>,Mode>(
const_cast<MatrixType&
>(m_matrix)).lazyAssign(other.derived());
361 template<
typename OtherDerived>
362 void swap(MatrixBase<OtherDerived>
const & other)
364 SwapWrapper<MatrixType> swaper(const_cast<MatrixType&>(m_matrix));
365 TriangularView<SwapWrapper<MatrixType>,Mode>(swaper).lazyAssign(other.derived());
368 Scalar determinant()
const
375 return m_matrix.diagonal().prod();
379 template<
typename ProductDerived,
typename Lhs,
typename Rhs>
380 EIGEN_STRONG_INLINE TriangularView&
operator=(
const ProductBase<ProductDerived, Lhs,Rhs>& other)
383 return assignProduct(other,1);
386 template<
typename ProductDerived,
typename Lhs,
typename Rhs>
387 EIGEN_STRONG_INLINE TriangularView&
operator+=(
const ProductBase<ProductDerived, Lhs,Rhs>& other)
389 return assignProduct(other,1);
392 template<
typename ProductDerived,
typename Lhs,
typename Rhs>
393 EIGEN_STRONG_INLINE TriangularView&
operator-=(
const ProductBase<ProductDerived, Lhs,Rhs>& other)
395 return assignProduct(other,-1);
399 template<
typename ProductDerived>
400 EIGEN_STRONG_INLINE TriangularView&
operator=(
const ScaledProduct<ProductDerived>& other)
403 return assignProduct(other,other.alpha());
406 template<
typename ProductDerived>
407 EIGEN_STRONG_INLINE TriangularView&
operator+=(
const ScaledProduct<ProductDerived>& other)
409 return assignProduct(other,other.alpha());
412 template<
typename ProductDerived>
413 EIGEN_STRONG_INLINE TriangularView&
operator-=(
const ScaledProduct<ProductDerived>& other)
415 return assignProduct(other,-other.alpha());
420 template<
typename ProductDerived,
typename Lhs,
typename Rhs>
421 EIGEN_STRONG_INLINE TriangularView& assignProduct(
const ProductBase<ProductDerived, Lhs,Rhs>& prod,
const Scalar& alpha);
423 MatrixTypeNested m_matrix;
432 template<
typename Derived1,
typename Derived2,
unsigned int Mode,
int UnrollCount,
bool ClearOpposite>
433 struct triangular_assignment_selector
436 col = (UnrollCount-1) / Derived1::RowsAtCompileTime,
437 row = (UnrollCount-1) % Derived1::RowsAtCompileTime
440 typedef typename Derived1::Scalar Scalar;
442 static inline void run(Derived1 &dst,
const Derived2 &src)
444 triangular_assignment_selector<Derived1, Derived2, Mode, UnrollCount-1, ClearOpposite>::run(dst, src);
449 if((Mode ==
Upper && row <= col)
450 || (Mode ==
Lower && row >= col)
455 dst.copyCoeff(row, col, src);
456 else if(ClearOpposite)
458 if (Mode&UnitDiag && row==col)
459 dst.coeffRef(row, col) = Scalar(1);
461 dst.coeffRef(row, col) = Scalar(0);
467 template<
typename Derived1,
typename Derived2,
unsigned int Mode,
bool ClearOpposite>
468 struct triangular_assignment_selector<Derived1, Derived2, Mode, 0, ClearOpposite>
470 static inline void run(Derived1 &,
const Derived2 &) {}
473 template<
typename Derived1,
typename Derived2,
bool ClearOpposite>
474 struct triangular_assignment_selector<Derived1, Derived2,
Upper,
Dynamic, ClearOpposite>
476 typedef typename Derived1::Index Index;
477 typedef typename Derived1::Scalar Scalar;
478 static inline void run(Derived1 &dst,
const Derived2 &src)
480 for(Index j = 0; j < dst.cols(); ++j)
482 Index maxi = (std::min)(j, dst.rows()-1);
483 for(Index i = 0; i <= maxi; ++i)
484 dst.copyCoeff(i, j, src);
486 for(Index i = maxi+1; i < dst.rows(); ++i)
487 dst.coeffRef(i, j) = Scalar(0);
492 template<
typename Derived1,
typename Derived2,
bool ClearOpposite>
493 struct triangular_assignment_selector<Derived1, Derived2,
Lower,
Dynamic, ClearOpposite>
495 typedef typename Derived1::Index Index;
496 static inline void run(Derived1 &dst,
const Derived2 &src)
498 for(Index j = 0; j < dst.cols(); ++j)
500 for(Index i = j; i < dst.rows(); ++i)
501 dst.copyCoeff(i, j, src);
502 Index maxi = (std::min)(j, dst.rows());
504 for(Index i = 0; i < maxi; ++i)
505 dst.coeffRef(i, j) =
static_cast<typename Derived1::Scalar
>(0);
510 template<
typename Derived1,
typename Derived2,
bool ClearOpposite>
511 struct triangular_assignment_selector<Derived1, Derived2,
StrictlyUpper,
Dynamic, ClearOpposite>
513 typedef typename Derived1::Index Index;
514 typedef typename Derived1::Scalar Scalar;
515 static inline void run(Derived1 &dst,
const Derived2 &src)
517 for(Index j = 0; j < dst.cols(); ++j)
519 Index maxi = (std::min)(j, dst.rows());
520 for(Index i = 0; i < maxi; ++i)
521 dst.copyCoeff(i, j, src);
523 for(Index i = maxi; i < dst.rows(); ++i)
524 dst.coeffRef(i, j) = Scalar(0);
529 template<
typename Derived1,
typename Derived2,
bool ClearOpposite>
530 struct triangular_assignment_selector<Derived1, Derived2,
StrictlyLower,
Dynamic, ClearOpposite>
532 typedef typename Derived1::Index Index;
533 static inline void run(Derived1 &dst,
const Derived2 &src)
535 for(Index j = 0; j < dst.cols(); ++j)
537 for(Index i = j+1; i < dst.rows(); ++i)
538 dst.copyCoeff(i, j, src);
539 Index maxi = (std::min)(j, dst.rows()-1);
541 for(Index i = 0; i <= maxi; ++i)
542 dst.coeffRef(i, j) =
static_cast<typename Derived1::Scalar
>(0);
547 template<
typename Derived1,
typename Derived2,
bool ClearOpposite>
548 struct triangular_assignment_selector<Derived1, Derived2,
UnitUpper,
Dynamic, ClearOpposite>
550 typedef typename Derived1::Index Index;
551 static inline void run(Derived1 &dst,
const Derived2 &src)
553 for(Index j = 0; j < dst.cols(); ++j)
555 Index maxi = (std::min)(j, dst.rows());
556 for(Index i = 0; i < maxi; ++i)
557 dst.copyCoeff(i, j, src);
560 for(Index i = maxi+1; i < dst.rows(); ++i)
561 dst.coeffRef(i, j) = 0;
564 dst.diagonal().setOnes();
567 template<
typename Derived1,
typename Derived2,
bool ClearOpposite>
568 struct triangular_assignment_selector<Derived1, Derived2,
UnitLower,
Dynamic, ClearOpposite>
570 typedef typename Derived1::Index Index;
571 static inline void run(Derived1 &dst,
const Derived2 &src)
573 for(Index j = 0; j < dst.cols(); ++j)
575 Index maxi = (std::min)(j, dst.rows());
576 for(Index i = maxi+1; i < dst.rows(); ++i)
577 dst.copyCoeff(i, j, src);
580 for(Index i = 0; i < maxi; ++i)
581 dst.coeffRef(i, j) = 0;
584 dst.diagonal().setOnes();
591 template<
typename MatrixType,
unsigned int Mode>
592 template<
typename OtherDerived>
593 inline TriangularView<MatrixType, Mode>&
598 typename internal::plain_matrix_type<OtherDerived>::type other_evaluated(other.rows(), other.cols());
599 other_evaluated.template triangularView<Mode>().lazyAssign(other.derived());
600 lazyAssign(other_evaluated);
603 lazyAssign(other.derived());
608 template<
typename MatrixType,
unsigned int Mode>
609 template<
typename OtherDerived>
610 void TriangularView<MatrixType, Mode>::lazyAssign(
const MatrixBase<OtherDerived>& other)
613 unroll = MatrixType::SizeAtCompileTime !=
Dynamic
614 && internal::traits<OtherDerived>::CoeffReadCost !=
Dynamic
615 && MatrixType::SizeAtCompileTime*internal::traits<OtherDerived>::CoeffReadCost/2 <= EIGEN_UNROLLING_LIMIT
617 eigen_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols());
619 internal::triangular_assignment_selector
620 <MatrixType, OtherDerived, int(Mode),
621 unroll ? int(MatrixType::SizeAtCompileTime) :
Dynamic,
623 >::run(m_matrix.const_cast_derived(), other.derived());
628 template<
typename MatrixType,
unsigned int Mode>
629 template<
typename OtherDerived>
630 inline TriangularView<MatrixType, Mode>&
633 eigen_assert(Mode ==
int(OtherDerived::Mode));
634 if(internal::traits<OtherDerived>::Flags & EvalBeforeAssigningBit)
636 typename OtherDerived::DenseMatrixType other_evaluated(other.rows(), other.cols());
637 other_evaluated.template triangularView<Mode>().lazyAssign(other.derived().nestedExpression());
638 lazyAssign(other_evaluated);
641 lazyAssign(other.derived().nestedExpression());
645 template<
typename MatrixType,
unsigned int Mode>
646 template<
typename OtherDerived>
647 void TriangularView<MatrixType, Mode>::lazyAssign(
const TriangularBase<OtherDerived>& other)
650 unroll = MatrixType::SizeAtCompileTime !=
Dynamic
651 && internal::traits<OtherDerived>::CoeffReadCost !=
Dynamic
652 && MatrixType::SizeAtCompileTime * internal::traits<OtherDerived>::CoeffReadCost / 2
653 <= EIGEN_UNROLLING_LIMIT
655 eigen_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols());
657 internal::triangular_assignment_selector
658 <MatrixType, OtherDerived, int(Mode),
659 unroll ? int(MatrixType::SizeAtCompileTime) :
Dynamic,
661 >::run(m_matrix.const_cast_derived(), other.derived().nestedExpression());
670 template<
typename Derived>
671 template<
typename DenseDerived>
672 void TriangularBase<Derived>::evalTo(MatrixBase<DenseDerived> &other)
const
674 if(internal::traits<Derived>::Flags & EvalBeforeAssigningBit)
676 typename internal::plain_matrix_type<Derived>::type other_evaluated(rows(), cols());
677 evalToLazy(other_evaluated);
678 other.derived().swap(other_evaluated);
681 evalToLazy(other.derived());
686 template<
typename Derived>
687 template<
typename DenseDerived>
688 void TriangularBase<Derived>::evalToLazy(MatrixBase<DenseDerived> &other)
const
691 unroll = DenseDerived::SizeAtCompileTime !=
Dynamic
692 && internal::traits<Derived>::CoeffReadCost !=
Dynamic
693 && DenseDerived::SizeAtCompileTime * internal::traits<Derived>::CoeffReadCost / 2
694 <= EIGEN_UNROLLING_LIMIT
696 other.derived().resize(this->rows(), this->cols());
698 internal::triangular_assignment_selector
699 <DenseDerived,
typename internal::traits<Derived>::MatrixTypeNestedCleaned, Derived::Mode,
700 unroll ? int(DenseDerived::SizeAtCompileTime) :
Dynamic,
702 >::run(other.derived(), derived().nestedExpression());
713 #ifdef EIGEN2_SUPPORT
718 template<
typename MatrixType,
unsigned int Mode>
719 struct eigen2_part_return_type
721 typedef TriangularView<MatrixType, Mode> type;
724 template<
typename MatrixType>
725 struct eigen2_part_return_type<MatrixType,
SelfAdjoint>
727 typedef SelfAdjointView<MatrixType, Upper> type;
732 template<
typename Derived>
733 template<
unsigned int Mode>
734 const typename internal::eigen2_part_return_type<Derived, Mode>::type MatrixBase<Derived>::part()
const
740 template<
typename Derived>
741 template<
unsigned int Mode>
742 typename internal::eigen2_part_return_type<Derived, Mode>::type MatrixBase<Derived>::part()
759 template<
typename Derived>
760 template<
unsigned int Mode>
761 typename MatrixBase<Derived>::template TriangularViewReturnType<Mode>::Type
768 template<
typename Derived>
769 template<
unsigned int Mode>
781 template<
typename Derived>
785 RealScalar maxAbsOnUpperPart =
static_cast<RealScalar
>(-1);
786 for(
Index j = 0; j < cols(); ++j)
788 Index maxi = (std::min)(j, rows()-1);
789 for(
Index i = 0; i <= maxi; ++i)
791 RealScalar absValue = abs(coeff(i,j));
792 if(absValue > maxAbsOnUpperPart) maxAbsOnUpperPart = absValue;
795 RealScalar threshold = maxAbsOnUpperPart * prec;
796 for(
Index j = 0; j < cols(); ++j)
797 for(
Index i = j+1; i < rows(); ++i)
798 if(abs(coeff(i, j)) > threshold)
return false;
807 template<
typename Derived>
811 RealScalar maxAbsOnLowerPart =
static_cast<RealScalar
>(-1);
812 for(
Index j = 0; j < cols(); ++j)
813 for(
Index i = j; i < rows(); ++i)
815 RealScalar absValue = abs(coeff(i,j));
816 if(absValue > maxAbsOnLowerPart) maxAbsOnLowerPart = absValue;
818 RealScalar threshold = maxAbsOnLowerPart * prec;
819 for(
Index j = 1; j < cols(); ++j)
821 Index maxi = (std::min)(j, rows()-1);
822 for(
Index i = 0; i < maxi; ++i)
823 if(abs(coeff(i, j)) > threshold)
return false;
830 #endif // EIGEN_TRIANGULARMATRIX_H
Expression of the product of two general matrices or vectors.
Definition: GeneralProduct.h:36
Definition: Constants.h:175
TriangularView & operator*=(const typename internal::traits< MatrixType >::Scalar &other)
Definition: TriangularMatrix.h:205
TriangularView & operator-=(const DenseBase< Other > &other)
Definition: TriangularMatrix.h:203
bool isUpperTriangular(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition: TriangularMatrix.h:782
Definition: Constants.h:181
friend TriangularProduct< Mode, false, OtherDerived, OtherDerived::IsVectorAtCompileTime, MatrixType, false > operator*(const MatrixBase< OtherDerived > &lhs, const TriangularView &rhs)
Definition: TriangularMatrix.h:292
void solveInPlace(const MatrixBase< OtherDerived > &other) const
Definition: SolveTriangular.h:174
const TriangularView< MatrixConjugateReturnType, Mode > conjugate() const
Definition: TriangularMatrix.h:260
TriangularView & setConstant(const Scalar &value)
Definition: TriangularMatrix.h:212
const int Dynamic
Definition: Constants.h:21
void fill(const Scalar &value)
Definition: TriangularMatrix.h:210
const unsigned int PacketAccessBit
Definition: Constants.h:81
Base class for all dense matrices, vectors, and arrays.
Definition: DenseBase.h:41
Scalar coeff(Index row, Index col) const
Definition: TriangularMatrix.h:222
bool isLowerTriangular(const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const
Definition: TriangularMatrix.h:808
Definition: Constants.h:171
TriangularView< Transpose< MatrixType >, TransposeMode > transpose()
Definition: TriangularMatrix.h:268
Definition: Constants.h:169
const TriangularView< const typename MatrixType::AdjointReturnType, TransposeMode > adjoint() const
Definition: TriangularMatrix.h:264
Derived & derived()
Definition: EigenBase.h:34
TriangularView & setOnes()
Definition: TriangularMatrix.h:217
const unsigned int LinearAccessBit
Definition: Constants.h:117
Scalar & coeffRef(Index row, Index col)
Definition: TriangularMatrix.h:231
Definition: Constants.h:167
TriangularView & operator/=(const typename internal::traits< MatrixType >::Scalar &other)
Definition: TriangularMatrix.h:207
Definition: Constants.h:177
Definition: Constants.h:183
Definition: Constants.h:173
internal::traits< Derived >::Index Index
The type of indices.
Definition: DenseBase.h:61
const unsigned int EvalBeforeAssigningBit
Definition: Constants.h:63
const TriangularView< Transpose< MatrixType >, TransposeMode > transpose() const
Definition: TriangularMatrix.h:274
TriangularView & operator=(const TriangularBase< OtherDerived > &other)
Base class for triangular part in a matrix.
Definition: TriangularMatrix.h:158
const unsigned int DirectAccessBit
Definition: Constants.h:142
TriangularView & operator+=(const DenseBase< Other > &other)
Definition: TriangularMatrix.h:201
TriangularView & setZero()
Definition: TriangularMatrix.h:215
Definition: Constants.h:179
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48
TriangularProduct< Mode, true, MatrixType, false, OtherDerived, OtherDerived::IsVectorAtCompileTime > operator*(const MatrixBase< OtherDerived > &rhs) const
Definition: TriangularMatrix.h:282
TriangularView< MatrixConjugateReturnType, Mode > conjugate()
Definition: TriangularMatrix.h:257