35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATDMATMULTEXPR_H_ 36 #define _BLAZE_MATH_EXPRESSIONS_TSMATDMATMULTEXPR_H_ 119 template<
typename MT1
125 class TSMatDMatMultExpr
126 :
public MatMatMultExpr< DenseMatrix< TSMatDMatMultExpr<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 TSMatDMatMultExpr::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);
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 )
644 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
646 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
648 for(
size_t i=0UL; i<A.columns(); ++i )
653 const size_t nonzeros( A.nonZeros(i) );
654 const size_t kpos( nonzeros &
size_t(-4) );
657 for(
size_t k=0UL; k<kpos; k+=4UL )
659 const size_t i1( element->index() );
660 const ET1 v1( element->value() );
662 const size_t i2( element->index() );
663 const ET1 v2( element->value() );
665 const size_t i3( element->index() );
666 const ET1 v3( element->value() );
668 const size_t i4( element->index() );
669 const ET1 v4( element->value() );
675 ?( ( SYM || HERM || UPP )
678 :( SYM || HERM || UPP ?
max(i1,jj) : jj ) );
683 :( LOW ?
min(i4+1UL,jpos) : jpos ) );
688 for(
size_t j=jbegin; j<jend; ++j ) {
689 C(i1,j) += v1 * B(i,j);
690 C(i2,j) += v2 * B(i,j);
691 C(i3,j) += v3 * B(i,j);
692 C(i4,j) += v4 * B(i,j);
696 for( ; element!=
end; ++element )
698 const size_t i1( element->index() );
701 ?( ( SYM || HERM || UPP )
704 :( SYM || HERM || UPP ?
max(i1,jj) : jj ) );
709 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
714 for(
size_t j=jbegin; j<jend; ++j ) {
715 C(i1,j) += element->value() * B(i,j);
722 for(
size_t j=0UL; j<B.columns(); ++j ) {
723 for(
size_t i=j+1UL; i<A.rows(); ++i ) {
724 C(i,j) = HERM ?
conj( C(j,i) ) : C(j,i);
746 template<
typename MT3
750 selectLargeAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
752 selectDefaultAssignKernel( C, A, B );
772 template<
typename MT3
776 selectLargeAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
780 const ForwardFunctor fwd;
783 assign( C, fwd( tmp * B ) );
801 template<
typename MT
820 const ForwardFunctor fwd;
822 const TmpType tmp(
serial( rhs ) );
823 assign( ~lhs, fwd( tmp ) );
843 template<
typename MT
855 const ForwardFunctor fwd;
857 assign( ~lhs, fwd(
trans( rhs.lhs_ ) * rhs.rhs_ ) );
875 template<
typename MT
895 TSMatDMatMultExpr::selectAddAssignKernel( ~lhs, A, B );
911 template<
typename MT3
914 static inline void selectAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
916 const size_t size( C.rows() * C.columns() );
920 selectSmallAddAssignKernel( C, A, B );
922 selectLargeAddAssignKernel( C, A, B );
942 template<
typename MT3
945 static inline void selectDefaultAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
951 for(
size_t i=0UL; i<A.columns(); ++i )
956 for( ; element!=
end; ++element ) {
957 C(element->index(),i) += element->value() * B(i,i);
965 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
967 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
969 for(
size_t i=0UL; i<A.columns(); ++i )
974 for( ; element!=
end; ++element )
976 const size_t i1( element->index() );
982 :( UPP ?
max(i1,jj) : jj ) );
987 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
992 for(
size_t j=jbegin; j<jend; ++j ) {
993 C(i1,j) += element->value() * B(i,j);
1017 template<
typename MT3
1021 selectSmallAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1023 selectDefaultAddAssignKernel( C, A, B );
1043 template<
typename MT3
1047 selectSmallAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1053 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
1055 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
1057 for(
size_t i=0UL; i<A.columns(); ++i )
1062 const size_t nonzeros( A.nonZeros(i) );
1063 const size_t kpos( nonzeros &
size_t(-4) );
1066 for(
size_t k=0UL; k<kpos; k+=4UL )
1068 const size_t i1( element->index() );
1069 const ET1 v1( element->value() );
1071 const size_t i2( element->index() );
1072 const ET1 v2( element->value() );
1074 const size_t i3( element->index() );
1075 const ET1 v3( element->value() );
1077 const size_t i4( element->index() );
1078 const ET1 v4( element->value() );
1087 :( UPP ?
max(i1,jj) : jj ) );
1092 :( LOW ?
min(i4+1UL,jpos) : jpos ) );
1094 if( jbegin >= jend )
1097 for(
size_t j=jbegin; j<jend; ++j ) {
1098 C(i1,j) += v1 * B(i,j);
1099 C(i2,j) += v2 * B(i,j);
1100 C(i3,j) += v3 * B(i,j);
1101 C(i4,j) += v4 * B(i,j);
1105 for( ; element!=
end; ++element )
1107 const size_t i1( element->index() );
1113 :( UPP ?
max(i1,jj) : jj ) );
1118 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
1120 if( jbegin >= jend )
1123 for(
size_t j=jbegin; j<jend; ++j ) {
1124 C(i1,j) += element->value() * B(i,j);
1147 template<
typename MT3
1151 selectLargeAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1153 selectDefaultAddAssignKernel( C, A, B );
1173 template<
typename MT3
1177 selectLargeAddAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1181 const ForwardFunctor fwd;
1184 addAssign( C, fwd( tmp * B ) );
1204 template<
typename MT
1216 const ForwardFunctor fwd;
1218 addAssign( ~lhs, fwd(
trans( rhs.lhs_ ) * rhs.rhs_ ) );
1240 template<
typename MT
1260 TSMatDMatMultExpr::selectSubAssignKernel( ~lhs, A, B );
1276 template<
typename MT3
1279 static inline void selectSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1281 const size_t size( C.rows() * C.columns() );
1285 selectSmallSubAssignKernel( C, A, B );
1287 selectLargeSubAssignKernel( C, A, B );
1307 template<
typename MT3
1310 static inline void selectDefaultSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1316 for(
size_t i=0UL; i<A.columns(); ++i )
1321 for( ; element!=
end; ++element ) {
1322 C(element->index(),i) -= element->value() * B(i,i);
1330 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
1332 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
1334 for(
size_t i=0UL; i<A.columns(); ++i )
1339 for( ; element!=
end; ++element )
1341 const size_t i1( element->index() );
1347 :( UPP ?
max(i1,jj) : jj ) );
1352 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
1354 if( jbegin >= jend )
1357 for(
size_t j=jbegin; j<jend; ++j ) {
1358 C(i1,j) -= element->value() * B(i,j);
1382 template<
typename MT3
1386 selectSmallSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1388 selectDefaultSubAssignKernel( C, A, B );
1408 template<
typename MT3
1412 selectSmallSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1418 for(
size_t jj=0UL; jj<B.columns(); jj+=block )
1420 const size_t jpos( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
1422 for(
size_t i=0UL; i<A.columns(); ++i )
1427 const size_t nonzeros( A.nonZeros(i) );
1428 const size_t kpos( nonzeros &
size_t(-4) );
1431 for(
size_t k=0UL; k<kpos; k+=4UL )
1433 const size_t i1( element->index() );
1434 const ET1 v1( element->value() );
1436 const size_t i2( element->index() );
1437 const ET1 v2( element->value() );
1439 const size_t i3( element->index() );
1440 const ET1 v3( element->value() );
1442 const size_t i4( element->index() );
1443 const ET1 v4( element->value() );
1452 :( UPP ?
max(i1,jj) : jj ) );
1457 :( LOW ?
min(i4+1UL,jpos) : jpos ) );
1459 if( jbegin >= jend )
1462 for(
size_t j=jbegin; j<jend; ++j ) {
1463 C(i1,j) -= v1 * B(i,j);
1464 C(i2,j) -= v2 * B(i,j);
1465 C(i3,j) -= v3 * B(i,j);
1466 C(i4,j) -= v4 * B(i,j);
1470 for( ; element!=
end; ++element )
1472 const size_t i1( element->index() );
1478 :( UPP ?
max(i1,jj) : jj ) );
1483 :( LOW ?
min(i1+1UL,jpos) : jpos ) );
1485 if( jbegin >= jend )
1488 for(
size_t j=jbegin; j<jend; ++j ) {
1489 C(i1,j) -= element->value() * B(i,j);
1512 template<
typename MT3
1516 selectLargeSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1518 selectDefaultSubAssignKernel( C, A, B );
1538 template<
typename MT3
1542 selectLargeSubAssignKernel( MT3& C,
const MT4& A,
const MT5& B )
1546 const ForwardFunctor fwd;
1549 subAssign( C, fwd( tmp * B ) );
1569 template<
typename MT
1581 const ForwardFunctor fwd;
1583 subAssign( ~lhs, fwd(
trans( rhs.lhs_ ) * rhs.rhs_ ) );
1605 template<
typename MT
1619 schurAssign( ~lhs, tmp );
1652 template<
typename MT
1693 template<
typename MT
1712 const ForwardFunctor fwd;
1714 const TmpType tmp( rhs );
1735 template<
typename MT
1745 const ForwardFunctor fwd;
1768 template<
typename MT
1808 template<
typename MT
1818 const ForwardFunctor fwd;
1845 template<
typename MT
1885 template<
typename MT
1895 const ForwardFunctor fwd;
1919 template<
typename MT
2002 template<
typename MT1
2004 inline decltype(
auto)
2053 template<
typename MT1
2068 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2100 template<
typename MT1
2115 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2147 template<
typename MT1
2162 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2194 template<
typename MT1
2209 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2241 template<
typename MT1
2256 return ReturnType( dm.leftOperand(), dm.rightOperand() );
2272 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2273 struct Rows< TSMatDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2290 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2291 struct Columns< TSMatDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2308 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2309 struct IsAligned< TSMatDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2326 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2327 struct IsSymmetric< TSMatDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2330 , IsBuiltin< ElementType_< TSMatDMatMultExpr<MT1,MT2,false,true,false,false> > > >
2331 , And< Bool<LF>, Bool<UF> > >::value >
2347 template<
typename MT1,
typename MT2,
bool SF,
bool LF,
bool UF >
2348 struct IsHermitian< TSMatDMatMultExpr<MT1,MT2,SF,true,LF,UF> >
2365 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2366 struct IsLower< TSMatDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2368 , And< IsLower<MT1>, IsLower<MT2> >
2369 , And< Or< Bool<SF>, Bool<HF> >
2370 , IsUpper<MT1>, IsUpper<MT2> > >::value >
2386 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2387 struct IsUniLower< TSMatDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2388 :
public BoolConstant< Or< And< IsUniLower<MT1>, IsUniLower<MT2> >
2389 , And< Or< Bool<SF>, Bool<HF> >
2390 , IsUniUpper<MT1>, IsUniUpper<MT2> > >::value >
2406 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2408 :
public BoolConstant< Or< And< IsStrictlyLower<MT1>, IsLower<MT2> >
2409 , And< IsStrictlyLower<MT2>, IsLower<MT1> >
2410 , And< Or< Bool<SF>, Bool<HF> >
2411 , Or< And< IsStrictlyUpper<MT1>, IsUpper<MT2> >
2412 , And< IsStrictlyUpper<MT2>, IsUpper<MT1> > > > >::value >
2428 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2429 struct IsUpper< TSMatDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2431 , And< IsUpper<MT1>, IsUpper<MT2> >
2432 , And< Or< Bool<SF>, Bool<HF> >
2433 , IsLower<MT1>, IsLower<MT2> > >::value >
2449 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2450 struct IsUniUpper< TSMatDMatMultExpr<MT1,MT2,SF,HF,LF,UF> >
2451 :
public BoolConstant< Or< And< IsUniUpper<MT1>, IsUniUpper<MT2> >
2452 , And< Or< Bool<SF>, Bool<HF> >
2453 , IsUniLower<MT1>, IsUniLower<MT2> > >::value >
2469 template<
typename MT1,
typename MT2,
bool SF,
bool HF,
bool LF,
bool UF >
2471 :
public BoolConstant< Or< And< IsStrictlyUpper<MT1>, IsUpper<MT2> >
2472 , And< IsStrictlyUpper<MT2>, IsUpper<MT1> >
2473 , And< Or< Bool<SF>, Bool<HF> >
2474 , Or< And< IsStrictlyLower<MT1>, IsLower<MT2> >
2475 , 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
ResultType_< MT2 > RT2
Result type of the right-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:132
decltype(auto) decldiag(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as diagonal.
Definition: DMatDeclDiagExpr.h:996
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: TSMatDMatMultExpr.h:417
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
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_< ResultType > ElementType
Resulting element type.
Definition: TSMatDMatMultExpr.h:242
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
CompositeType_< MT1 > CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:135
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatDMatMultExpr.h:289
Header file for the serial shim.
ElementType_< RT2 > ET2
Element type of the right-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:134
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: TSMatDMatMultExpr.h:363
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
Header file for the DeclUpp functor.
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatDMatMultExpr.h:434
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
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
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
LeftOperand leftOperand() const noexcept
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatDMatMultExpr.h:373
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.
IfTrue_< evaluateRight, const RT2, CT2 > RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TSMatDMatMultExpr.h:256
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
CompositeType_< MT2 > CT2
Composite type of the right-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:136
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: TSMatDMatMultExpr.h:353
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:78
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatDMatMultExpr.h:244
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
IfTrue_< evaluateLeft, const RT1, CT1 > LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatDMatMultExpr.h:253
RightOperand rhs_
Right-hand side dense matrix of the multiplication expression.
Definition: TSMatDMatMultExpr.h:435
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
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
If_< IsExpression< MT2 >, const MT2, const MT2 &> RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:250
Constraint on the data type.
Constraint on the data type.
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
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
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: TSMatDMatMultExpr.h:241
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.
If_< IsExpression< MT1 >, const MT1, const MT1 &> LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:247
#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.
Flag for Hermitian matrices.
Definition: TSMatDMatMultExpr.h:153
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
MultTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: TSMatDMatMultExpr.h:239
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
Flag for upper matrices.
Definition: TSMatDMatMultExpr.h:155
ElementType_< RT1 > ET1
Element type of the left-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:133
Generic wrapper for the null function.
Definition: Noop.h:58
Header file for the IsTriangular type trait.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: TSMatDMatMultExpr.h:337
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: TSMatDMatMultExpr.h:427
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.
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
RightOperand rightOperand() const noexcept
Returns the right-hand side dense matrix operand.
Definition: TSMatDMatMultExpr.h:383
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
#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
TSMatDMatMultExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the TSMatDMatMultExpr class.
Definition: TSMatDMatMultExpr.h:274
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.
#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
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatDMatMultExpr.h:240
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
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatDMatMultExpr.h:243
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
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: TSMatDMatMultExpr.h:407
decltype(auto) declherm(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as Hermitian.
Definition: DMatDeclHermExpr.h:1029
Header file for the IsRowMajorMatrix type trait.
Flag for symmetric matrices.
Definition: TSMatDMatMultExpr.h:152
Header file for the IsComputation type trait class.
Header file for the IsBuiltin type trait.
Expression object for transpose sparse matrix-dense matrix multiplications.The TSMatDMatMultExpr clas...
Definition: Forward.h:160
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
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: TSMatDMatMultExpr.h:395
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.
Flag for lower matrices.
Definition: TSMatDMatMultExpr.h:154
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.
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.
ResultType_< MT1 > RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:131