35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATTDMATMULTEXPR_H_ 36 #define _BLAZE_MATH_EXPRESSIONS_TSMATTDMATMULTEXPR_H_ 119 template<
typename MT1
125 class TSMatTDMatMultExpr
126 :
public MatMatMultExpr< DenseMatrix< TSMatTDMatMultExpr<MT1,MT2,SF,HF,LF,UF>, true > >
127 ,
private Computation
152 SYM = ( SF && !( HF || LF || UF ) ),
153 HERM = ( HF && !( LF || UF ) ),
154 LOW = ( LF || ( ( SF || HF ) && UF ) ),
155 UPP = ( UF || ( ( SF || HF ) && LF ) )
166 template<
typename T1,
typename T2,
typename T3 >
167 struct CanExploitSymmetry {
179 template<
typename T1,
typename T2,
typename T3 >
180 struct IsEvaluationRequired {
181 enum :
bool { value = ( evaluateLeft || evaluateRight ) &&
182 !CanExploitSymmetry<T1,T2,T3>::value };
193 template<
typename T1,
typename T2,
typename T3 >
194 struct UseOptimizedKernel {
195 enum :
bool { value = useOptimizedKernels &&
208 template<
typename T1,
typename T2,
typename T3 >
209 struct UseDefaultKernel {
210 enum :
bool { value = !UseOptimizedKernel<T1,T2,T3>::value };
261 enum :
bool { simdEnabled =
false };
264 enum :
bool { smpAssignable = !evaluateLeft && MT1::smpAssignable &&
265 !evaluateRight && MT2::smpAssignable };
315 :(
lhs_.columns() ) ) );
319 const size_t n(
end - begin );
338 if( i >=
lhs_.rows() ) {
341 if( j >=
rhs_.columns() ) {
353 inline size_t rows() const noexcept {
364 return rhs_.columns();
394 template<
typename T >
395 inline bool canAlias(
const T* alias )
const noexcept {
396 return (
lhs_.isAliased( alias ) ||
rhs_.isAliased( alias ) );
406 template<
typename T >
407 inline bool isAliased(
const T* alias )
const noexcept {
408 return (
lhs_.isAliased( alias ) ||
rhs_.isAliased( alias ) );
418 return rhs_.isAligned();
451 template<
typename MT
471 TSMatTDMatMultExpr::selectAssignKernel( ~lhs, A, B );
487 template<
typename MT3
490 static inline void selectAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
492 const size_t size( C.rows() * C.columns() );
496 selectSmallAssignKernel( C, A, B );
498 selectLargeAssignKernel( C, A, B );
518 template<
typename MT3
521 static inline void selectDefaultAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
529 for(
size_t i=0UL; i<A.columns(); ++i )
534 for( ; element!=
end; ++element ) {
535 C(element->index(),i) = element->value() * B(i,i);
541 const size_t block( 64UL );
543 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
545 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
547 for(
size_t i=0UL; i<A.columns(); ++i )
552 for( ; element!=
end; ++element )
554 const size_t i1( element->index() );
557 ?( ( SYM || HERM || UPP )
560 :( SYM || HERM || UPP ?
max(i1,jj) : jj ) );
565 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
570 for(
size_t j=jbegin; j<jend; ++j ) {
572 C(i1,j) = element->value() * B(i,j);
574 C(i1,j) += element->value() * B(i,j);
582 for(
size_t j=0UL; j<B.columns(); ++j ) {
583 for(
size_t i=j+1UL; i<A.rows(); ++i ) {
584 C(i,j) = HERM ?
conj( C(j,i) ) : C(j,i);
606 template<
typename MT3
610 selectSmallAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
612 selectDefaultAssignKernel( C, A, B );
632 template<
typename MT3
636 selectSmallAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
642 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
644 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
646 for(
size_t i=0UL; i<A.rows(); ++i ) {
647 for(
size_t j=jj; j<jpos; ++j ) {
652 for(
size_t i=0UL; i<A.columns(); ++i )
657 const size_t nonzeros( A.nonZeros(i) );
658 const size_t kpos( nonzeros &
size_t(-4) );
661 for(
size_t k=0UL; k<kpos; k+=4UL )
663 const size_t i1( element->index() );
664 const ET1 v1( element->value() );
666 const size_t i2( element->index() );
667 const ET1 v2( element->value() );
669 const size_t i3( element->index() );
670 const ET1 v3( element->value() );
672 const size_t i4( element->index() );
673 const ET1 v4( element->value() );
679 ?( ( SYM || HERM || UPP )
682 :( SYM || HERM || UPP ?
max(i1,jj) : jj ) );
687 :( LOW ?
min(i4+1UL,jpos) : jpos ) );
692 for(
size_t j=jbegin; j<jend; ++j ) {
693 C(i1,j) += v1 * B(i,j);
694 C(i2,j) += v2 * B(i,j);
695 C(i3,j) += v3 * B(i,j);
696 C(i4,j) += v4 * B(i,j);
700 for( ; element!=
end; ++element )
702 const size_t i1( element->index() );
705 ?( ( SYM || HERM || UPP )
708 :( SYM || HERM || UPP ?
max(i1,jj) : jj ) );
713 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
718 for(
size_t j=jbegin; j<jend; ++j ) {
719 C(i1,j) += element->value() * B(i,j);
726 for(
size_t j=0UL; j<B.columns(); ++j ) {
727 for(
size_t i=j+1UL; i<A.rows(); ++i ) {
728 C(i,j) = HERM ?
conj( C(j,i) ) : C(j,i);
750 template<
typename MT3
754 selectLargeAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
756 selectDefaultAssignKernel( C, A, B );
776 template<
typename MT3
780 selectLargeAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
784 const ForwardFunctor fwd;
787 assign( C, fwd( tmp * B ) );
805 template<
typename MT
824 const ForwardFunctor fwd;
826 const TmpType tmp(
serial( rhs ) );
827 assign( ~lhs, fwd( tmp ) );
847 template<
typename MT
859 const ForwardFunctor fwd;
862 assign( ~lhs, fwd(
trans( rhs.lhs_ ) *
trans( rhs.rhs_ ) ) );
864 assign( ~lhs, fwd(
trans( rhs.lhs_ ) * rhs.rhs_ ) );
866 assign( ~lhs, fwd( rhs.lhs_ *
trans( rhs.rhs_ ) ) );
884 template<
typename MT
904 TSMatTDMatMultExpr::selectAddAssignKernel( ~lhs, A, B );
920 template<
typename MT3
923 static inline void selectAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
925 const size_t size( C.rows() * C.columns() );
929 selectSmallAddAssignKernel( C, A, B );
931 selectLargeAddAssignKernel( C, A, B );
951 template<
typename MT3
954 static inline void selectDefaultAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
960 for(
size_t i=0UL; i<A.columns(); ++i )
965 for( ; element!=
end; ++element ) {
966 C(element->index(),i) += element->value() * B(i,i);
972 const size_t block( 64UL );
974 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
976 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
978 for(
size_t i=0UL; i<A.columns(); ++i )
983 for( ; element!=
end; ++element )
985 const size_t i1( element->index() );
991 :( UPP ?
max(i1,jj) : jj ) );
996 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
1001 for(
size_t j=jbegin; j<jend; ++j ) {
1002 C(i1,j) += element->value() * B(i,j);
1026 template<
typename MT3
1030 selectSmallAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1032 selectDefaultAddAssignKernel( C, A, B );
1052 template<
typename MT3
1056 selectSmallAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1062 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
1064 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
1066 for(
size_t i=0UL; i<A.columns(); ++i )
1071 const size_t nonzeros( A.nonZeros(i) );
1072 const size_t kpos( nonzeros &
size_t(-4) );
1075 for(
size_t k=0UL; k<kpos; k+=4UL )
1077 const size_t i1( element->index() );
1078 const ET1 v1( element->value() );
1080 const size_t i2( element->index() );
1081 const ET1 v2( element->value() );
1083 const size_t i3( element->index() );
1084 const ET1 v3( element->value() );
1086 const size_t i4( element->index() );
1087 const ET1 v4( element->value() );
1096 :( UPP ?
max(i1,jj) : jj ) );
1101 :( LOW ?
min(i4+1UL,jpos) : jpos ) );
1103 if( jbegin >= jend )
1106 for(
size_t j=jbegin; j<jend; ++j ) {
1107 C(i1,j) += v1 * B(i,j);
1108 C(i2,j) += v2 * B(i,j);
1109 C(i3,j) += v3 * B(i,j);
1110 C(i4,j) += v4 * B(i,j);
1114 for( ; element!=
end; ++element )
1116 const size_t i1( element->index() );
1122 :( UPP ?
max(i1,jj) : jj ) );
1127 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
1129 if( jbegin >= jend )
1132 for(
size_t j=jbegin; j<jend; ++j ) {
1133 C(i1,j) += element->value() * B(i,j);
1156 template<
typename MT3
1160 selectLargeAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1162 selectDefaultAddAssignKernel( C, A, B );
1182 template<
typename MT3
1186 selectLargeAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1190 const ForwardFunctor fwd;
1193 addAssign( C, fwd( tmp * B ) );
1213 template<
typename MT
1225 const ForwardFunctor fwd;
1228 addAssign( ~lhs, fwd(
trans( rhs.lhs_ ) *
trans( rhs.rhs_ ) ) );
1230 addAssign( ~lhs, fwd(
trans( rhs.lhs_ ) * rhs.rhs_ ) );
1232 addAssign( ~lhs, fwd( rhs.lhs_ *
trans( rhs.rhs_ ) ) );
1254 template<
typename MT
1274 TSMatTDMatMultExpr::selectSubAssignKernel( ~lhs, A, B );
1290 template<
typename MT3
1293 static inline void selectSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1295 const size_t size( C.rows() * C.columns() );
1299 selectSmallSubAssignKernel( C, A, B );
1301 selectLargeSubAssignKernel( C, A, B );
1321 template<
typename MT3
1324 static inline void selectDefaultSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1330 for(
size_t i=0UL; i<A.columns(); ++i )
1335 for( ; element!=
end; ++element ) {
1336 C(element->index(),i) -= element->value() * B(i,i);
1342 const size_t block( 64UL );
1344 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
1346 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
1348 for(
size_t i=0UL; i<A.columns(); ++i )
1353 for( ; element!=
end; ++element )
1355 const size_t i1( element->index() );
1361 :( UPP ?
max(i1,jj) : jj ) );
1366 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
1368 if( jbegin >= jend )
1371 for(
size_t j=jbegin; j<jend; ++j ) {
1372 C(i1,j) -= element->value() * B(i,j);
1396 template<
typename MT3
1400 selectSmallSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1402 selectDefaultSubAssignKernel( C, A, B );
1422 template<
typename MT3
1426 selectSmallSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1432 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
1434 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
1436 for(
size_t i=0UL; i<A.columns(); ++i )
1441 const size_t nonzeros( A.nonZeros(i) );
1442 const size_t kpos( nonzeros &
size_t(-4) );
1445 for(
size_t k=0UL; k<kpos; k+=4UL )
1447 const size_t i1( element->index() );
1448 const ET1 v1( element->value() );
1450 const size_t i2( element->index() );
1451 const ET1 v2( element->value() );
1453 const size_t i3( element->index() );
1454 const ET1 v3( element->value() );
1456 const size_t i4( element->index() );
1457 const ET1 v4( element->value() );
1466 :( UPP ?
max(i1,jj) : jj ) );
1471 :( LOW ?
min(i4+1UL,jpos) : jpos ) );
1473 if( jbegin >= jend )
1476 for(
size_t j=jbegin; j<jend; ++j ) {
1477 C(i1,j) -= v1 * B(i,j);
1478 C(i2,j) -= v2 * B(i,j);
1479 C(i3,j) -= v3 * B(i,j);
1480 C(i4,j) -= v4 * B(i,j);
1484 for( ; element!=
end; ++element )
1486 const size_t i1( element->index() );
1492 :( UPP ?
max(i1,jj) : jj ) );
1497 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
1499 if( jbegin >= jend )
1502 for(
size_t j=jbegin; j<jend; ++j ) {
1503 C(i1,j) -= element->value() * B(i,j);
1526 template<
typename MT3
1530 selectLargeSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1532 selectDefaultSubAssignKernel( C, A, B );
1552 template<
typename MT3
1556 selectLargeSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1560 const ForwardFunctor fwd;
1563 subAssign( C, fwd( tmp * B ) );
1583 template<
typename MT
1595 const ForwardFunctor fwd;
1598 subAssign( ~lhs, fwd(
trans( rhs.lhs_ ) *
trans( rhs.rhs_ ) ) );
1600 subAssign( ~lhs, fwd(
trans( rhs.lhs_ ) * rhs.rhs_ ) );
1602 subAssign( ~lhs, fwd( rhs.lhs_ *
trans( rhs.rhs_ ) ) );
1624 template<
typename MT
1638 schurAssign( ~lhs, tmp );
1671 template<
typename MT
1712 template<
typename MT
1731 const ForwardFunctor fwd;
1733 const TmpType tmp( rhs );
1754 template<
typename MT
1766 const ForwardFunctor fwd;
1794 template<
typename MT
1834 template<
typename MT
1846 const ForwardFunctor fwd;
1878 template<
typename MT
1918 template<
typename MT
1930 const ForwardFunctor fwd;
1959 template<
typename MT
2040 template<
typename MT1
2042 inline decltype(
auto)
2089 template<
typename MT1
2104 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2134 template<
typename MT1
2149 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2179 template<
typename MT1
2194 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2224 template<
typename MT1
2239 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2269 template<
typename MT1
2284 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2300 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2301 struct Rows< TSMatTDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2318 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2319 struct Columns< TSMatTDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2336 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2337 struct IsAligned< TSMatTDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2354 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2355 struct IsSymmetric< TSMatTDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2358 , IsBuiltin< ElementType_< TSMatTDMatMultExpr<MT1,MT2,false,true,false,false> > > >
2359 , And< Bool<LF>, Bool<UF> > >::value >
2375 template<
typename MT1,
typename MT2,
bool SF,
bool LF,
bool UF >
2376 struct IsHermitian< TSMatTDMatMultExpr<MT1,MT2,SF,true,LF,UF> >
2393 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2394 struct IsLower< TSMatTDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2396 , And< IsLower<MT1>, IsLower<MT2> >
2397 , And< Or< Bool<SF>, Bool<HF> >
2398 , IsUpper<MT1>, IsUpper<MT2> > >::value >
2414 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2415 struct IsUniLower< TSMatTDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2416 :
public BoolConstant< Or< And< IsUniLower<MT1>, IsUniLower<MT2> >
2417 , And< Or< Bool<SF>, Bool<HF> >
2418 , IsUniUpper<MT1>, IsUniUpper<MT2> > >::value >
2434 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2436 :
public BoolConstant< Or< And< IsStrictlyLower<MT1>, IsLower<MT2> >
2437 , And< IsStrictlyLower<MT2>, IsLower<MT1> >
2438 , And< Or< Bool<SF>, Bool<HF> >
2439 , Or< And< IsStrictlyUpper<MT1>, IsUpper<MT2> >
2440 , And< IsStrictlyUpper<MT2>, IsUpper<MT1> > > > >::value >
2456 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2457 struct IsUpper< TSMatTDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2459 , And< IsUpper<MT1>, IsUpper<MT2> >
2460 , And< Or< Bool<SF>, Bool<HF> >
2461 , IsLower<MT1>, IsLower<MT2> > >::value >
2477 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2478 struct IsUniUpper< TSMatTDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2479 :
public BoolConstant< Or< And< IsUniUpper<MT1>, IsUniUpper<MT2> >
2480 , And< Or< Bool<SF>, Bool<HF> >
2481 , IsUniLower<MT1>, IsUniLower<MT2> > >::value >
2497 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2499 :
public BoolConstant< Or< And< IsStrictlyUpper<MT1>, IsUpper<MT2> >
2500 , And< IsStrictlyUpper<MT2>, IsUpper<MT1> >
2501 , And< Or< Bool<SF>, Bool<HF> >
2502 , Or< And< IsStrictlyLower<MT1>, IsLower<MT2> >
2503 , And< IsStrictlyLower<MT2>, IsLower<MT1> > > > >::value >
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
Headerfile for the generic min algorithm.
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:72
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TSMatTDMatMultExpr.h:427
decltype(auto) decldiag(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as diagonal.
Definition: DMatDeclDiagExpr.h:996
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
EnableIf_< IsDenseMatrix< MT1 > > smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:196
ResultType_< MT2 > RT2
Result type of the right-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:132
Compile time check for triangular matrix types.This type trait tests whether or not the given templat...
Definition: IsTriangular.h:87
Header file for basic type definitions.
ElementType_< RT2 > ET2
Element type of the right-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:134
Expression object for transpose sparse matrix-transpose dense matrix multiplications.The TSMatTDMatMultExpr class represents the compile time expression for multiplications between a column-major sparse matrix and a column-major dense matrix.
Definition: Forward.h:168
Subvector< VT, AF > subvector(Vector< VT, TF > &vector, size_t index, size_t size)
Creating a view on a specific subvector of the given vector.
Definition: Subvector.h:322
ElementType_< RT1 > ET1
Element type of the left-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:133
EnableIf_< IsDenseMatrix< MT1 > > smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:164
Header file for the serial shim.
Header file for the IsDiagonal type trait.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:265
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:61
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSMatTDMatMultExpr.h:417
Header file for the DeclUpp functor.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSMatTDMatMultExpr.h:407
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:198
Header file for the IsColumnMajorMatrix type trait.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:560
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:224
IfTrue_< evaluateRight, const RT2, CT2 > RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TSMatTDMatMultExpr.h:256
Header file for the And class template.
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1762
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
MultTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:239
decltype(auto) declupp(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as upper.
Definition: DMatDeclUppExpr.h:1027
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:250
Column< MT > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:124
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Constraints on the storage order of matrix types.
Header file for the RequiresEvaluation type trait.
System settings for performance optimizations.
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1809
EnableIf_< IsDenseMatrix< MT1 > > smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:133
RightOperand rhs_
Right-hand side dense matrix of the multiplication expression.
Definition: TSMatTDMatMultExpr.h:435
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:78
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
Row< MT > row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:124
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:240
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatTDMatMultExpr.h:244
Constraint on the data type.
Constraint on the data type.
Flag for symmetric matrices.
Definition: TSMatTDMatMultExpr.h:152
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Flag for Hermitian matrices.
Definition: TSMatTDMatMultExpr.h:153
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSMatTDMatMultExpr.h:395
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
Headerfile for the generic max algorithm.
Header file for the DisableIf class template.
Header file for the multiplication trait.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the DeclLow functor.
Header file for the If class template.
Compile time check for row-major matrix types.This type trait tests whether or not the given template...
Definition: IsRowMajorMatrix.h:110
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: ColumnMajorMatrix.h:61
ResultType_< MT1 > RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:131
Generic wrapper for the decllow() function.
Definition: DeclLow.h:58
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:102
Header file for the Or class template.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatTDMatMultExpr.h:289
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatTDMatMultExpr.h:434
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3087
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
TSMatTDMatMultExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the TSMatTDMatMultExpr class.
Definition: TSMatTDMatMultExpr.h:274
decltype(auto) decllow(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as lower.
Definition: DMatDeclLowExpr.h:1027
Header file for the IsLower type trait.
Header file for the IsAligned type trait.
Compile time check for diagonal matrices.This type trait tests whether or not the given template para...
Definition: IsDiagonal.h:90
Generic wrapper for the null function.
Definition: Noop.h:58
Header file for the IsTriangular type trait.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: TSMatTDMatMultExpr.h:353
CompositeType_< MT1 > CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:135
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatTDMatMultExpr.h:373
Constraints on the storage order of matrix types.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
Header file for the exception macros of the math module.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:264
Header file for the DeclDiag functor.
Constraint on the data type.
Header file for all forward declarations for expression class templates.
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:243
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatMultExpr.h:108
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
Header file for the conjugate shim.
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
Flag for lower matrices.
Definition: TSMatTDMatMultExpr.h:154
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: RowMajorMatrix.h:61
Header file for run time assertion macros.
Compile time check for column-major matrix types.This type trait tests whether or not the given templ...
Definition: IsColumnMajorMatrix.h:110
Utility type for generic codes.
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:154
ElementType_< ResultType > ElementType
Resulting element type.
Definition: TSMatTDMatMultExpr.h:242
Header file for the reset shim.
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
decltype(auto) declsym(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as symmetric.
Definition: DMatDeclSymExpr.h:1029
Header file for the isDefault shim.
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:101
Constraint on the data type.
Constraints on the storage order of matrix types.
Generic wrapper for the declherm() function.
Definition: DeclHerm.h:58
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:819
Header file for the Noop functor.
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:241
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:224
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:84
Generic wrapper for the declupp() function.
Definition: DeclUpp.h:58
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3082
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:790
decltype(auto) declherm(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as Hermitian.
Definition: DMatDeclHermExpr.h:1029
Flag for upper matrices.
Definition: TSMatTDMatMultExpr.h:155
If_< IsExpression< MT1 >, const MT1, const MT1 &> LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:247
Header file for the IsRowMajorMatrix type trait.
Header file for the IsComputation type trait class.
RightOperand rightOperand() const noexcept
Returns the right-hand side transpose dense matrix operand.
Definition: TSMatTDMatMultExpr.h:383
Header file for the IsBuiltin type trait.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: TSMatTDMatMultExpr.h:363
If_< IsExpression< MT2 >, const MT2, const MT2 &> RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:250
CompositeType_< MT2 > CT2
Composite type of the right-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:136
Header file for the IntegralConstant class template.
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
Generic wrapper for the decldiag() function.
Definition: DeclDiag.h:58
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
Header file for the DeclHerm functor.
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:600
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Header file for the IsUpper type trait.
decltype(auto) conj(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the complex conjugate of each single element of dm.
Definition: DMatMapExpr.h:1321
Constraint on the data type.
Generic wrapper for the declsym() function.
Definition: DeclSym.h:58
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:742
Header file for the IsResizable type trait.
IfTrue_< evaluateLeft, const RT1, CT1 > LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatTDMatMultExpr.h:253
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for the Bool class template.
Header file for the DeclSym functor.
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:61
Header file for the IsExpression type trait class.
Header file for the function trace functionality.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: TSMatTDMatMultExpr.h:337