269 return internal::make_triangular_base_cwise_view<Mode>(lhs.derived() + rhs.nestedExpression());
274 template <
typename OtherDerived,
unsigned int Mode_ = Mode,
275 std::enable_if_t<(int(Mode_) & (int(
UnitDiag) | int(
ZeroDiag))) == 0,
int> = 0>
277 return internal::make_triangular_base_cwise_view<Mode>(lhs.derived() - rhs.nestedExpression());
280 template <
typename OtherDerived>
282 const Derived& rhs) {
286 template <
typename OtherDerived>
287 friend EIGEN_DEVICE_FUNC
const Product<OtherDerived, Derived> operator*(
const DiagonalBase<OtherDerived>& lhs,
288 const Derived& rhs) {
289 return Product<OtherDerived, Derived>(lhs.derived(), rhs);
297 template <
typename OtherDerived>
303 template <
typename OtherDerived>
305 const InverseImpl<OtherDerived, PermutationStorage>& rhs)
const {
310 template <
typename OtherDerived>
312 const Derived& rhs) {
317 template <
typename OtherDerived>
319 const InverseImpl<OtherDerived, PermutationStorage>& lhs,
const Derived& rhs) {
324 EIGEN_DEVICE_FUNC
inline const ConjugateReturnType
conjugate()
const {
332 EIGEN_DEVICE_FUNC
inline std::conditional_t<Cond, ConjugateReturnType, ConstView>
conjugateIf()
const {
333 using ReturnType = std::conditional_t<Cond, ConjugateReturnType, ConstView>;
338 EIGEN_DEVICE_FUNC
inline const AdjointReturnType
adjoint()
const {
343 template <class Dummy = int, std::enable_if_t<Eigen::internal::is_lvalue<ExpressionType>::value, Dummy*> =
nullptr>
344 EIGEN_DEVICE_FUNC
inline TransposeReturnType
transpose() {
345 typename ExpressionType::TransposeReturnType tmp(
derived().nestedExpression());
346 return TransposeReturnType(tmp);
349 template <
class Dummy =
int>
350 EIGEN_DEPRECATED_WITH_REASON(
"Omit the implementation-only argument.")
351 EIGEN_DEVICE_FUNC inline TransposeReturnType
352 transpose(std::enable_if_t<Eigen::internal::is_lvalue<ExpressionType>::value, Dummy*>) {
357 EIGEN_DEVICE_FUNC
inline const ConstTransposeReturnType
transpose()
const {
361 EIGEN_DEVICE_FUNC DenseMatrixType toDenseMatrix()
const {
362 DenseMatrixType res(rows(), cols());
368 void check_coordinates(Index row, Index col)
const {
369 EIGEN_ONLY_USED_FOR_DEBUG(row);
370 EIGEN_ONLY_USED_FOR_DEBUG(col);
371 eigen_assert(col >= 0 && col < cols() && row >= 0 && row < rows());
372 const int mode = int(Mode) & ~SelfAdjoint;
373 EIGEN_ONLY_USED_FOR_DEBUG(mode);
374 eigen_assert((mode ==
Upper && col >= row) || (mode ==
Lower && col <= row) ||
379#ifdef EIGEN_INTERNAL_DEBUGGING
380 void check_coordinates_internal(
Index row,
Index col)
const { check_coordinates(row, col); }
382 void check_coordinates_internal(
Index,
Index)
const {}
405template <
typename MatrixType,
unsigned int Mode_>
406struct traits<TriangularView<MatrixType, Mode_>> : traits<MatrixType> {
407 using MatrixTypeNested =
typename ref_selector<MatrixType>::non_const_type;
408 using MatrixTypeNestedNonRef = std::remove_reference_t<MatrixTypeNested>;
409 using MatrixTypeNestedCleaned = remove_all_t<MatrixTypeNested>;
410 using FullMatrixType =
typename MatrixType::PlainObject;
411 using ExpressionType = MatrixType;
414 FlagsLvalueBit = is_lvalue<MatrixType>::value ?
LvalueBit : 0,
415 Flags = (MatrixTypeNestedCleaned::Flags & (HereditaryBits | FlagsLvalueBit) &
421template <
typename MatrixType_,
unsigned int Mode_,
typename StorageKind>
422class TriangularViewImpl;
424template <
typename MatrixType_,
unsigned int Mode_>
426 :
public TriangularViewImpl<MatrixType_, Mode_, typename internal::traits<MatrixType_>::StorageKind> {
428 using Base = TriangularViewImpl<MatrixType_, Mode_, typename internal::traits<MatrixType_>::StorageKind>;
429 using Scalar =
typename internal::traits<TriangularView>::Scalar;
430 using MatrixType = MatrixType_;
433 using MatrixTypeNested =
typename internal::traits<TriangularView>::MatrixTypeNested;
434 using MatrixTypeNestedNonRef =
typename internal::traits<TriangularView>::MatrixTypeNestedNonRef;
437 using StorageKind =
typename internal::traits<TriangularView>::StorageKind;
438 using NestedExpression =
typename internal::traits<TriangularView>::MatrixTypeNestedCleaned;
442 Flags = internal::traits<TriangularView>::Flags,
445 IsVectorAtCompileTime =
false
448 EIGEN_DEVICE_FUNC
explicit inline TriangularView(MatrixType& matrix) : m_matrix(matrix) {}
450 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(TriangularView)
453 EIGEN_DEVICE_FUNC constexpr const NestedExpression&
nestedExpression() const noexcept {
return m_matrix; }
456 EIGEN_DEVICE_FUNC
constexpr MatrixTypeNestedNonRef&
nestedExpression() noexcept {
return m_matrix; }
458 template <
typename Other>
470 EIGEN_STATIC_ASSERT((Mode & (
UnitDiag |
ZeroDiag)) == 0, PROGRAMMING_ERROR);
476 EIGEN_STATIC_ASSERT((Mode & (
UnitDiag |
ZeroDiag)) == 0, PROGRAMMING_ERROR);
483 EIGEN_IF_CONSTEXPR (
int(Mode) &
int(
UnitDiag)) {
485 }
else EIGEN_IF_CONSTEXPR (
int(Mode) &
int(
ZeroDiag)) {
487 return Scalar(m_matrix.rows() == 0 ? 1 : 0);
489 return internal::scaled_prod(m_matrix.diagonal()).value();
494 MatrixTypeNested m_matrix;
506template <
typename MatrixType_,
unsigned int Mode_>
507class TriangularViewImpl<MatrixType_, Mode_,
Dense> :
public TriangularBase<TriangularView<MatrixType_, Mode_>> {
511 using Base = TriangularBase<TriangularViewType>;
512 using Scalar =
typename internal::traits<TriangularViewType>::Scalar;
514 using MatrixType = MatrixType_;
515 using DenseMatrixType =
typename MatrixType::PlainObject;
516 using PlainObject = DenseMatrixType;
521 using Base::operator*;
523 using StorageKind =
typename internal::traits<TriangularViewType>::StorageKind;
525 enum { Mode = Mode_, Flags = internal::traits<TriangularViewType>::Flags };
528 template <
typename Other>
530 internal::call_assignment_no_alias(
derived(), other.derived(),
531 internal::add_assign_op<Scalar, typename Other::Scalar>());
535 template <
typename Other>
537 internal::call_assignment_no_alias(
derived(), other.derived(),
538 internal::sub_assign_op<Scalar, typename Other::Scalar>());
543 EIGEN_DEVICE_FUNC TriangularViewType&
operator*=(
const typename internal::traits<MatrixType>::Scalar& other) {
544 return *
this =
derived().nestedExpression() * other;
547 EIGEN_DEVICE_FUNC TriangularViewType&
operator/=(
const typename internal::traits<MatrixType>::Scalar& other) {
548 return *
this =
derived().nestedExpression() / other;
552 template <
typename OtherDerived>
553 EIGEN_DEVICE_FUNC TriangularViewType&
operator=(
const TriangularBase<OtherDerived>& other);
556 template <
typename OtherDerived>
559#ifndef EIGEN_PARSED_BY_DOXYGEN
560 EIGEN_DEVICE_FUNC TriangularViewType&
operator=(
const TriangularViewImpl& other) {
561 return *
this = other.derived().nestedExpression();
564 template <
typename OtherDerived>
568 template <
typename OtherDerived>
574 template <
unsigned int M = Mode, std::enable_if_t<(M & UnitDiag) == 0,
int> = 0>
576 const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(MatrixType, Scalar, internal::scalar_product_op), Mode>
577 operator*(
const Scalar& s)
const {
578 return (derived().nestedExpression() * s).template triangularView<Mode>();
581 template <
unsigned int M = Mode, std::enable_if_t<(M & UnitDiag) == 0,
int> = 0>
582 friend EIGEN_DEVICE_FUNC
const TriangularView<
583 const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar, MatrixType, internal::scalar_product_op), Mode>
584 operator*(
const Scalar& s,
const TriangularViewImpl& mat) {
585 return (s * mat.derived().nestedExpression()).template triangularView<Mode>();
611 template <
int S
ide,
typename Other>
612 inline const internal::triangular_solve_retval<Side, TriangularViewType, Other>
solve(
624 template <
int S
ide,
typename OtherDerived>
627 template <
typename OtherDerived>
649 template <
typename OtherDerived>
651#ifdef EIGEN_PARSED_BY_DOXYGEN
653 swap(TriangularBase<OtherDerived>& other)
656 swap(TriangularBase<OtherDerived>
const& other)
659 EIGEN_STATIC_ASSERT_LVALUE(OtherDerived);
660 call_assignment(
derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
664 template <
typename OtherDerived>
667 EIGEN_STATIC_ASSERT_LVALUE(OtherDerived);
668 call_assignment(
derived(), other.const_cast_derived(), internal::swap_assign_op<Scalar>());
671 template <
typename RhsType,
typename DstType>
672 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void _solve_impl(
const RhsType& rhs, DstType& dst)
const {
673 if (!internal::is_same_dense(dst, rhs)) dst = rhs;
674 this->solveInPlace(dst);
677 template <
typename ProductType>
678 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TriangularViewType& _assignProduct(
const ProductType& prod,
const Scalar& alpha,
682 EIGEN_DEFAULT_COPY_CONSTRUCTOR(TriangularViewImpl)
683 EIGEN_DEFAULT_EMPTY_CONSTRUCTOR_AND_DESTRUCTOR(TriangularViewImpl)
690#ifndef EIGEN_PARSED_BY_DOXYGEN
692template <
typename MatrixType,
unsigned int Mode>
693template <
typename OtherDerived>
696 internal::call_assignment_no_alias(derived(), other.derived(),
697 internal::assign_op<Scalar, typename OtherDerived::Scalar>());
702template <
typename MatrixType,
unsigned int Mode>
703template <
typename OtherDerived>
704EIGEN_DEVICE_FUNC
void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(
const MatrixBase<OtherDerived>& other) {
705 internal::call_assignment_no_alias(derived(), other.template triangularView<Mode>());
708template <
typename MatrixType,
unsigned int Mode>
709template <
typename OtherDerived>
712 eigen_assert(Mode ==
int(OtherDerived::Mode));
713 internal::call_assignment(derived(), other.derived());
717template <
typename MatrixType,
unsigned int Mode>
718template <
typename OtherDerived>
719EIGEN_DEVICE_FUNC
void TriangularViewImpl<MatrixType, Mode, Dense>::lazyAssign(
721 eigen_assert(Mode ==
int(OtherDerived::Mode));
722 internal::call_assignment_no_alias(derived(), other.derived());
732template <
typename Derived>
733template <
typename DenseDerived>
757template <
typename Derived>
758template <
unsigned int Mode>
760MatrixBase<Derived>::triangularView() {
761 return typename TriangularViewReturnType<Mode>::Type(derived());
765template <
typename Derived>
766template <
unsigned int Mode>
768MatrixBase<Derived>::triangularView()
const {
769 return typename ConstTriangularViewReturnType<Mode>::Type(derived());
777template <
typename Derived>
779 RealScalar maxAbsOnUpperPart =
static_cast<RealScalar
>(-1);
780 for (Index j = 0; j < cols(); ++j) {
781 Index maxi = numext::mini(j, rows() - 1);
782 for (Index i = 0; i <= maxi; ++i) {
783 RealScalar absValue = numext::abs(coeff(i, j));
784 if (absValue > maxAbsOnUpperPart) maxAbsOnUpperPart = absValue;
787 RealScalar threshold = maxAbsOnUpperPart * prec;
788 for (Index j = 0; j < cols(); ++j)
789 for (Index i = j + 1; i < rows(); ++i)
790 if (numext::abs(coeff(i, j)) > threshold)
return false;
799template <
typename Derived>
801 RealScalar maxAbsOnLowerPart =
static_cast<RealScalar
>(-1);
802 for (Index j = 0; j < cols(); ++j)
803 for (Index i = j; i < rows(); ++i) {
804 RealScalar absValue = numext::abs(coeff(i, j));
805 if (absValue > maxAbsOnLowerPart) maxAbsOnLowerPart = absValue;
807 RealScalar threshold = maxAbsOnLowerPart * prec;
808 for (Index j = 1; j < cols(); ++j) {
811 Index maxi = numext::mini(j, rows());
812 for (Index i = 0; i < maxi; ++i)
813 if (numext::abs(coeff(i, j)) > threshold)
return false;
830template <
typename MatrixType,
unsigned int Mode>
832 using Kind =
typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind;
833 using Shape =
typename glue_shapes<typename evaluator_traits<MatrixType>::Shape, TriangularShape>::type;
836template <
typename MatrixType,
unsigned int Mode>
837struct unary_evaluator<TriangularView<MatrixType, Mode>, IndexBased> : evaluator<internal::remove_all_t<MatrixType>> {
838 using XprType = TriangularView<MatrixType, Mode>;
839 using Base = evaluator<internal::remove_all_t<MatrixType>>;
840 EIGEN_DEVICE_FUNC unary_evaluator(
const XprType& xpr) : Base(xpr.nestedExpression()) {}
844struct Triangular2Triangular {};
845struct Triangular2Dense {};
846struct Dense2Triangular {};
848template <
typename Kernel,
unsigned int Mode,
int UnrollCount,
bool SetOpposite>
849struct triangular_assignment_loop;
852template <
typename DstEvaluatorType,
typename SrcEvaluatorType>
853struct triangular_assignment_unrolls {
854 static constexpr int Size = DstEvaluatorType::XprType::SizeAtCompileTime;
855 static constexpr bool value =
856 Size != Dynamic && SrcEvaluatorType::CoeffReadCost < HugeCost &&
857 Size * (int(DstEvaluatorType::CoeffReadCost) + int(SrcEvaluatorType::CoeffReadCost)) / 2 <= EIGEN_UNROLLING_LIMIT;
865template <
int UpLo,
int Mode,
int SetOpposite,
typename DstEvaluatorTypeT,
typename SrcEvaluatorTypeT,
typename Functor,
866 int Version = Specialized>
867class triangular_dense_assignment_kernel
868 :
public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> {
870 using Base = generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>;
871 using DstXprType =
typename Base::DstXprType;
872 using SrcXprType =
typename Base::SrcXprType;
874 using Base::m_functor;
878 using DstEvaluatorType =
typename Base::DstEvaluatorType;
879 using SrcEvaluatorType =
typename Base::SrcEvaluatorType;
880 using Scalar =
typename Base::Scalar;
881 using AssignmentTraits =
typename Base::AssignmentTraits;
883 EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType& dst,
const SrcEvaluatorType& src,
884 const Functor& func, DstXprType& dstExpr)
885 : Base(dst, src, func, dstExpr) {}
887#ifdef EIGEN_INTERNAL_DEBUGGING
888 EIGEN_DEVICE_FUNC
void assignCoeff(Index row, Index col) {
889 eigen_internal_assert(row != col);
890 Base::assignCoeff(row, col);
893 using Base::assignCoeff;
896 EIGEN_DEVICE_FUNC
void assignDiagonalCoeff(Index
id) {
897 EIGEN_IF_CONSTEXPR (Mode ==
UnitDiag && SetOpposite) {
898 m_functor.assignCoeff(m_dst.coeffRef(
id,
id), Scalar(1));
899 }
else EIGEN_IF_CONSTEXPR (Mode ==
ZeroDiag && SetOpposite) {
900 m_functor.assignCoeff(m_dst.coeffRef(
id,
id), Scalar(0));
901 }
else EIGEN_IF_CONSTEXPR (Mode == 0) {
902 Base::assignCoeff(
id,
id);
906 EIGEN_DEVICE_FUNC
void assignOppositeCoeff(Index row, Index col) {
907 eigen_internal_assert(row != col);
908 EIGEN_IF_CONSTEXPR (SetOpposite) {
909 m_functor.assignCoeff(m_dst.coeffRef(row, col), Scalar(0));
914template <
int Mode,
bool SetOpposite,
typename DstXprType,
typename SrcXprType,
typename Functor>
915EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_triangular_assignment_loop(DstXprType& dst,
const SrcXprType& src,
916 const Functor& func) {
917 using DstEvaluatorType = evaluator<DstXprType>;
918 using SrcEvaluatorType = evaluator<SrcXprType>;
920 SrcEvaluatorType srcEvaluator(src);
922 Index dstRows = src.rows();
923 Index dstCols = src.cols();
924 if ((dst.rows() != dstRows) || (dst.cols() != dstCols)) dst.resize(dstRows, dstCols);
925 DstEvaluatorType dstEvaluator(dst);
928 SetOpposite, DstEvaluatorType, SrcEvaluatorType, Functor>;
929 Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
931 constexpr bool unroll = triangular_assignment_unrolls<DstEvaluatorType, SrcEvaluatorType>::value;
932 triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(
936template <
int Mode,
bool SetOpposite,
typename DstXprType,
typename SrcXprType>
937EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_triangular_assignment_loop(DstXprType& dst,
const SrcXprType& src) {
938 call_triangular_assignment_loop<Mode, SetOpposite>(
939 dst, src, internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>());
943struct AssignmentKind<TriangularShape, TriangularShape> {
944 using Kind = Triangular2Triangular;
947struct AssignmentKind<DenseShape, TriangularShape> {
948 using Kind = Triangular2Dense;
951struct AssignmentKind<TriangularShape, DenseShape> {
952 using Kind = Dense2Triangular;
955template <
typename Shape>
956struct is_dense_structured_shape
957 : bool_constant<std::is_same<Shape, TriangularShape>::value || std::is_same<Shape, SelfAdjointShape>::value> {};
959template <
typename Lhs,
typename Rhs>
960struct is_dense_structured_diagonal_product
961 : bool_constant<(is_dense_structured_shape<typename evaluator_traits<Lhs>::Shape>::value &&
962 std::is_same<typename evaluator_traits<Rhs>::Shape, DiagonalShape>::value) ||
963 (std::is_same<typename evaluator_traits<Lhs>::Shape, DiagonalShape>::value &&
964 is_dense_structured_shape<typename evaluator_traits<Rhs>::Shape>::value)> {};
966template <
typename DstXprType,
typename SrcXprType,
typename Functor>
967struct Assignment<DstXprType, SrcXprType, Functor, Triangular2Triangular> {
968 EIGEN_DEVICE_FUNC
static void run(DstXprType& dst,
const SrcXprType& src,
const Functor& func) {
969 eigen_assert(
int(DstXprType::Mode) ==
int(SrcXprType::Mode));
971 call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);
975template <
typename DstXprType,
typename SrcXprType,
typename Functor>
976struct Assignment<DstXprType, SrcXprType, Functor, Triangular2Dense> {
977 EIGEN_DEVICE_FUNC
static void run(DstXprType& dst,
const SrcXprType& src,
const Functor& func) {
978 call_triangular_assignment_loop<SrcXprType::Mode, (int(SrcXprType::Mode) & int(SelfAdjoint)) == 0>(dst, src, func);
982template <
typename DstXprType,
typename SrcXprType,
typename Functor>
983struct Assignment<DstXprType, SrcXprType, Functor, Dense2Triangular> {
984 EIGEN_DEVICE_FUNC
static void run(DstXprType& dst,
const SrcXprType& src,
const Functor& func) {
985 call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);
989template <
typename Kernel,
unsigned int Mode,
int UnrollCount,
bool SetOpposite>
990struct triangular_assignment_loop {
992 using DstEvaluatorType =
typename Kernel::DstEvaluatorType;
993 using DstXprType =
typename DstEvaluatorType::XprType;
996 col = (UnrollCount - 1) / DstXprType::RowsAtCompileTime,
997 row = (UnrollCount - 1) % DstXprType::RowsAtCompileTime
1000 using Scalar =
typename Kernel::Scalar;
1002 EIGEN_DEVICE_FUNC
static inline void run(Kernel& kernel) {
1003 triangular_assignment_loop<Kernel, Mode, UnrollCount - 1, SetOpposite>::run(kernel);
1006 kernel.assignDiagonalCoeff(row);
1007 else if (((Mode &
Lower) && row > col) || ((Mode &
Upper) && row < col))
1008 kernel.assignCoeff(row, col);
1009 else EIGEN_IF_CONSTEXPR (SetOpposite) {
1010 kernel.assignOppositeCoeff(row, col);
1016template <
typename Kernel,
unsigned int Mode,
bool SetOpposite>
1017struct triangular_assignment_loop<Kernel, Mode, 0, SetOpposite> {
1018 EIGEN_DEVICE_FUNC
static inline void run(Kernel&) {}
1024template <
typename Kernel,
unsigned int Mode,
bool SetOpposite>
1025struct triangular_assignment_loop<Kernel, Mode, Dynamic, SetOpposite> {
1026 using Scalar =
typename Kernel::Scalar;
1027 using DstEvaluatorType =
typename Kernel::DstEvaluatorType;
1028 using AssignmentTraits =
typename Kernel::AssignmentTraits;
1031 IsRowMajor = (int(DstEvaluatorType::Flags) &
RowMajorBit) != 0,
1035 ActiveBeforeDiag = (
bool(Mode &
Upper) !=
bool(IsRowMajor))
1041 static constexpr Index row(Index outer, Index inner) {
return IsRowMajor ? outer : inner; }
1042 static constexpr Index col(Index outer, Index inner) {
return IsRowMajor ? inner : outer; }
1050 EIGEN_DEVICE_FUNC
static inline void run(Kernel& kernel) {
1051 const Index outerSize = IsRowMajor ? kernel.rows() : kernel.cols();
1052 const Index innerSize = IsRowMajor ? kernel.cols() : kernel.rows();
1054 for (Index outer = 0; outer < outerSize; ++outer) {
1055 const Index maxi = numext::mini(outer, innerSize);
1058 EIGEN_IF_CONSTEXPR (ActiveBeforeDiag) {
1059 for (; i < maxi; ++i) kernel.assignCoeff(row(outer, i), col(outer, i));
1060 }
else EIGEN_IF_CONSTEXPR (SetOpposite) {
1061 for (; i < maxi; ++i) kernel.assignOppositeCoeff(row(outer, i), col(outer, i));
1066 if (i < innerSize) kernel.assignDiagonalCoeff(i++);
1068 EIGEN_IF_CONSTEXPR (!ActiveBeforeDiag) {
1069 for (; i < innerSize; ++i) kernel.assignCoeff(row(outer, i), col(outer, i));
1070 }
else EIGEN_IF_CONSTEXPR (SetOpposite) {
1071 for (; i < innerSize; ++i) kernel.assignOppositeCoeff(row(outer, i), col(outer, i));
1081template <
typename Derived>
1082template <
typename DenseDerived>
1084 other.derived().
resize(this->rows(), this->cols());
1085 internal::call_triangular_assignment_loop<Derived::Mode,
1087 other.derived(),
derived().nestedExpression());
1092template <
bool UseTriangularAssignmentLoop>
1093struct triangular_product_assignment_dispatcher {
1094 template <
typename DstXprType,
typename SrcXprType,
typename Functor,
typename Scalar>
1095 static void run(DstXprType& dst,
const SrcXprType& src,
const Functor&,
const Scalar& alpha,
bool beta) {
1097 Index dstRows = src.rows();
1098 Index dstCols = src.cols();
1099 if ((dst.rows() != dstRows) || (dst.cols() != dstCols)) dst.resize(dstRows, dstCols);
1102 dst._assignProduct(src, alpha, beta);
1111template <
typename Op>
1112EIGEN_DEVICE_FUNC
inline const void* diagonal_operand_data(
const Op& op, DiagonalShape) {
1113 return extract_data(op.diagonal());
1115template <
typename Op,
typename Shape>
1116EIGEN_DEVICE_FUNC
inline const void* diagonal_operand_data(
const Op& , Shape) {
1120template <
typename DstXprType,
typename SrcXprType>
1121EIGEN_DEVICE_FUNC
inline bool structured_diagonal_product_aliases(
const DstXprType& dst,
const SrcXprType& src) {
1122 const void* dst_data = dst.nestedExpression().data();
1123 if (dst_data ==
nullptr)
return false;
1124 const void* lhs_diag_data =
1125 diagonal_operand_data(src.lhs(),
typename evaluator_traits<typename SrcXprType::Lhs>::Shape{});
1126 const void* rhs_diag_data =
1127 diagonal_operand_data(src.rhs(),
typename evaluator_traits<typename SrcXprType::Rhs>::Shape{});
1128 return (lhs_diag_data !=
nullptr && lhs_diag_data == dst_data) ||
1129 (rhs_diag_data !=
nullptr && rhs_diag_data == dst_data);
1133struct triangular_product_assignment_dispatcher<true> {
1134 template <
typename DstXprType,
typename SrcXprType,
typename Functor,
typename Scalar>
1135 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void run(DstXprType& dst,
const SrcXprType& src,
const Functor& func,
1136 const Scalar& alpha,
bool beta) {
1137 EIGEN_UNUSED_VARIABLE(alpha);
1138 EIGEN_UNUSED_VARIABLE(beta);
1139 EIGEN_STATIC_ASSERT((
int(DstXprType::Mode) &
int(
UnitDiag)) == 0,
1140 WRITING_TO_TRIANGULAR_PART_WITH_UNIT_DIAGONAL_IS_NOT_SUPPORTED);
1149 if (structured_diagonal_product_aliases(dst, src)) {
1150 typename SrcXprType::PlainObject tmp(src);
1151 call_triangular_assignment_loop<DstXprType::Mode, false>(dst, tmp, func);
1153 call_triangular_assignment_loop<DstXprType::Mode, false>(dst, src, func);
1159template <
typename DstXprType,
typename Lhs,
typename Rhs,
typename Scalar>
1160struct Assignment<DstXprType, Product<Lhs, Rhs, DefaultProduct>,
1161 internal::assign_op<Scalar, typename Product<Lhs, Rhs, DefaultProduct>::Scalar>, Dense2Triangular> {
1162 using SrcXprType = Product<Lhs, Rhs, DefaultProduct>;
1163 static void run(DstXprType& dst,
const SrcXprType& src,
1164 const internal::assign_op<Scalar, typename SrcXprType::Scalar>& func) {
1165 enum { UseTriangularAssignmentLoop = is_dense_structured_diagonal_product<Lhs, Rhs>::value };
1166 triangular_product_assignment_dispatcher<UseTriangularAssignmentLoop>::run(dst, src, func, Scalar(1),
false);
1171template <
typename DstXprType,
typename Lhs,
typename Rhs,
typename Scalar>
1172struct Assignment<DstXprType, Product<Lhs, Rhs, DefaultProduct>,
1173 internal::add_assign_op<Scalar, typename Product<Lhs, Rhs, DefaultProduct>::Scalar>,
1175 using SrcXprType = Product<Lhs, Rhs, DefaultProduct>;
1176 static void run(DstXprType& dst,
const SrcXprType& src,
1177 const internal::add_assign_op<Scalar, typename SrcXprType::Scalar>& func) {
1178 enum { UseTriangularAssignmentLoop = is_dense_structured_diagonal_product<Lhs, Rhs>::value };
1179 triangular_product_assignment_dispatcher<UseTriangularAssignmentLoop>::run(dst, src, func, Scalar(1),
true);
1184template <
typename DstXprType,
typename Lhs,
typename Rhs,
typename Scalar>
1185struct Assignment<DstXprType, Product<Lhs, Rhs, DefaultProduct>,
1186 internal::sub_assign_op<Scalar, typename Product<Lhs, Rhs, DefaultProduct>::Scalar>,
1188 using SrcXprType = Product<Lhs, Rhs, DefaultProduct>;
1189 static void run(DstXprType& dst,
const SrcXprType& src,
1190 const internal::sub_assign_op<Scalar, typename SrcXprType::Scalar>& func) {
1191 enum { UseTriangularAssignmentLoop = is_dense_structured_diagonal_product<Lhs, Rhs>::value };
1192 triangular_product_assignment_dispatcher<UseTriangularAssignmentLoop>::run(dst, src, func, Scalar(-1),
true);