Blaze 3.9
DMatTransExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_DMATTRANSEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_DMATTRANSEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Aliases.h>
62#include <blaze/system/Inline.h>
63#include <blaze/util/Assert.h>
64#include <blaze/util/EnableIf.h>
68#include <blaze/util/mpl/If.h>
69#include <blaze/util/Types.h>
71
72
73namespace blaze {
74
75//=================================================================================================
76//
77// CLASS DMATTRANSEXPR
78//
79//=================================================================================================
80
81//*************************************************************************************************
88template< typename MT // Type of the dense matrix
89 , bool SO > // Storage order
91 : public MatTransExpr< DenseMatrix< DMatTransExpr<MT,SO>, SO > >
92 , private If_t< IsComputation_v<MT>, Computation, Transformation >
93{
94 private:
95 //**Type definitions****************************************************************************
97 BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT( GetConstIterator, ConstIterator, INVALID_TYPE );
98 //**********************************************************************************************
99
100 //**Serial evaluation strategy******************************************************************
102
108 static constexpr bool useAssign = RequiresEvaluation_v<MT>;
109
112 template< typename MT2 >
113 static constexpr bool UseAssign_v = useAssign;
115 //**********************************************************************************************
116
117 //**Parallel evaluation strategy****************************************************************
119
125 template< typename MT2 >
126 static constexpr bool UseSMPAssign_v = ( MT2::smpAssignable && useAssign );
128 //**********************************************************************************************
129
130 public:
131 //**Type definitions****************************************************************************
134
137
143
146
148 using ConstIterator = GetConstIterator_t<MT>;
149
151 using Operand = If_t< IsExpression_v<MT>, const MT, const MT& >;
152 //**********************************************************************************************
153
154 //**Compilation flags***************************************************************************
156 static constexpr bool simdEnabled = MT::simdEnabled;
157
159 static constexpr bool smpAssignable = MT::smpAssignable;
160 //**********************************************************************************************
161
162 //**SIMD properties*****************************************************************************
164 static constexpr size_t SIMDSIZE = SIMDTrait<ElementType>::size;
165 //**********************************************************************************************
166
167 //**Constructor*********************************************************************************
172 explicit inline DMatTransExpr( const MT& dm ) noexcept
173 : dm_( dm ) // Dense matrix of the transposition expression
174 {}
175 //**********************************************************************************************
176
177 //**Access operator*****************************************************************************
184 inline ReturnType operator()( size_t i, size_t j ) const {
185 BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
186 BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
187 return dm_(j,i);
188 }
189 //**********************************************************************************************
190
191 //**At function*********************************************************************************
199 inline ReturnType at( size_t i, size_t j ) const {
200 if( i >= dm_.columns() ) {
201 BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
202 }
203 if( j >= dm_.rows() ) {
204 BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
205 }
206 return (*this)(i,j);
207 }
208 //**********************************************************************************************
209
210 //**Load function*******************************************************************************
217 BLAZE_ALWAYS_INLINE auto load( size_t i, size_t j ) const noexcept {
218 BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
219 BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
220 BLAZE_INTERNAL_ASSERT( !SO || ( i % SIMDSIZE == 0UL ), "Invalid row access index" );
221 BLAZE_INTERNAL_ASSERT( SO || ( j % SIMDSIZE == 0UL ), "Invalid column access index" );
222 return dm_.load(j,i);
223 }
224 //**********************************************************************************************
225
226 //**Low-level data access***********************************************************************
231 inline const ElementType* data() const noexcept {
232 return dm_.data();
233 }
234 //**********************************************************************************************
235
236 //**Begin function******************************************************************************
242 inline ConstIterator begin( size_t i ) const {
243 return ConstIterator( dm_.begin(i) );
244 }
245 //**********************************************************************************************
246
247 //**End function********************************************************************************
253 inline ConstIterator end( size_t i ) const {
254 return ConstIterator( dm_.end(i) );
255 }
256 //**********************************************************************************************
257
258 //**Rows function*******************************************************************************
263 inline size_t rows() const noexcept {
264 return dm_.columns();
265 }
266 //**********************************************************************************************
267
268 //**Columns function****************************************************************************
273 inline size_t columns() const noexcept {
274 return dm_.rows();
275 }
276 //**********************************************************************************************
277
278 //**Spacing function****************************************************************************
283 inline size_t spacing() const noexcept {
284 return dm_.spacing();
285 }
286 //**********************************************************************************************
287
288 //**NonZeros function***************************************************************************
293 inline size_t nonZeros() const {
294 return dm_.nonZeros();
295 }
296 //**********************************************************************************************
297
298 //**NonZeros function***************************************************************************
304 inline size_t nonZeros( size_t i ) const {
305 return dm_.nonZeros( i );
306 }
307 //**********************************************************************************************
308
309 //**Operand access******************************************************************************
314 inline Operand operand() const noexcept {
315 return dm_;
316 }
317 //**********************************************************************************************
318
319 //**********************************************************************************************
325 template< typename T >
326 inline bool canAlias( const T* alias ) const noexcept {
327 return dm_.isAliased( alias );
328 }
329 //**********************************************************************************************
330
331 //**********************************************************************************************
337 template< typename T >
338 inline bool isAliased( const T* alias ) const noexcept {
339 return dm_.isAliased( alias );
340 }
341 //**********************************************************************************************
342
343 //**********************************************************************************************
348 inline bool isAligned() const noexcept {
349 return dm_.isAligned();
350 }
351 //**********************************************************************************************
352
353 //**********************************************************************************************
358 inline bool canSMPAssign() const noexcept {
359 return dm_.canSMPAssign();
360 }
361 //**********************************************************************************************
362
363 private:
364 //**Member variables****************************************************************************
366 //**********************************************************************************************
367
368 //**Assignment to dense matrices****************************************************************
382 template< typename MT2 // Type of the target dense matrix
383 , bool SO2 > // Storage order of the target dense matrix
384 friend inline auto assign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
386 {
388
389 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
390 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
391
392 DMatTransposer<MT2,!SO2> tmp( *lhs );
393 assign( tmp, rhs.dm_ );
394 }
396 //**********************************************************************************************
397
398 //**Assignment to sparse matrices***************************************************************
412 template< typename MT2 // Type of the target sparse matrix
413 , bool SO2 > // Storage order of the target sparse matrix
414 friend inline auto assign( SparseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
416 {
418
420
427
428 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
429 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
430
431 const TmpType tmp( serial( rhs ) );
432 assign( *lhs, tmp );
433 }
435 //**********************************************************************************************
436
437 //**Addition assignment to dense matrices*******************************************************
451 template< typename MT2 // Type of the target dense matrix
452 , bool SO2 > // Storage order of the target dense matrix
453 friend inline auto addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
454 -> EnableIf_t< UseAssign_v<MT2> >
455 {
457
458 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
459 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
460
461 DMatTransposer<MT2,!SO2> tmp( *lhs );
462 addAssign( tmp, rhs.dm_ );
463 }
465 //**********************************************************************************************
466
467 //**Addition assignment to sparse matrices******************************************************
468 // No special implementation for the addition assignment to sparse matrices.
469 //**********************************************************************************************
470
471 //**Subtraction assignment to dense matrices****************************************************
485 template< typename MT2 // Type of the target dense matrix
486 , bool SO2 > // Storage order of the target dense matrix
487 friend inline auto subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
488 -> EnableIf_t< UseAssign_v<MT2> >
489 {
491
492 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
493 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
494
495 DMatTransposer<MT2,!SO2> tmp( *lhs );
496 subAssign( tmp, rhs.dm_ );
497 }
499 //**********************************************************************************************
500
501 //**Subtraction assignment to sparse matrices***************************************************
502 // No special implementation for the subtraction assignment to sparse matrices.
503 //**********************************************************************************************
504
505 //**Schur product assignment to dense matrices**************************************************
519 template< typename MT2 // Type of the target dense matrix
520 , bool SO2 > // Storage order of the target dense matrix
521 friend inline auto schurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
522 -> EnableIf_t< UseAssign_v<MT2> >
523 {
525
526 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
527 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
528
529 DMatTransposer<MT2,!SO2> tmp( *lhs );
530 schurAssign( tmp, rhs.dm_ );
531 }
533 //**********************************************************************************************
534
535 //**Schur product assignment to sparse matrices*************************************************
536 // No special implementation for the Schur product assignment to sparse matrices.
537 //**********************************************************************************************
538
539 //**Multiplication assignment to dense matrices*************************************************
540 // No special implementation for the multiplication assignment to dense matrices.
541 //**********************************************************************************************
542
543 //**Multiplication assignment to sparse matrices************************************************
544 // No special implementation for the multiplication assignment to sparse matrices.
545 //**********************************************************************************************
546
547 //**SMP assignment to dense matrices************************************************************
561 template< typename MT2 // Type of the target dense matrix
562 , bool SO2 > // Storage order of the target dense matrix
563 friend inline auto smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
564 -> EnableIf_t< UseSMPAssign_v<MT2> >
565 {
567
568 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
569 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
570
571 DMatTransposer<MT2,!SO2> tmp( *lhs );
572 smpAssign( tmp, rhs.dm_ );
573 }
575 //**********************************************************************************************
576
577 //**SMP assignment to sparse matrices***********************************************************
591 template< typename MT2 // Type of the target sparse matrix
592 , bool SO2 > // Storage order of the target sparse matrix
593 friend inline auto smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
594 -> EnableIf_t< UseSMPAssign_v<MT2> >
595 {
597
598 using TmpType = If_t< SO == SO2, ResultType, OppositeType >;
599
606
607 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
608 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
609
610 const TmpType tmp( rhs );
611 smpAssign( *lhs, tmp );
612 }
614 //**********************************************************************************************
615
616 //**SMP addition assignment to dense matrices***************************************************
630 template< typename MT2 // Type of the target dense matrix
631 , bool SO2 > // Storage order of the target dense matrix
632 friend inline auto smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
633 -> EnableIf_t< UseSMPAssign_v<MT2> >
634 {
636
637 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
638 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
639
640 DMatTransposer<MT2,!SO2> tmp( *lhs );
641 smpAddAssign( tmp, rhs.dm_ );
642 }
644 //**********************************************************************************************
645
646 //**SMP addition assignment to sparse matrices**************************************************
647 // No special implementation for the SMP addition assignment to sparse matrices.
648 //**********************************************************************************************
649
650 //**SMP subtraction assignment to dense matrices************************************************
664 template< typename MT2 // Type of the target dense matrix
665 , bool SO2 > // Storage order of the target dense matrix
666 friend inline auto smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
667 -> EnableIf_t< UseSMPAssign_v<MT2> >
668 {
670
671 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
672 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
673
674 DMatTransposer<MT2,!SO2> tmp( *lhs );
675 smpSubAssign( tmp, rhs.dm_ );
676 }
678 //**********************************************************************************************
679
680 //**SMP subtraction assignment to sparse matrices***********************************************
681 // No special implementation for the SMP subtraction assignment to sparse matrices.
682 //**********************************************************************************************
683
684 //**SMP Schur product assignment to dense matrices**********************************************
699 template< typename MT2 // Type of the target dense matrix
700 , bool SO2 > // Storage order of the target dense matrix
701 friend inline auto smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatTransExpr& rhs )
702 -> EnableIf_t< UseSMPAssign_v<MT2> >
703 {
705
706 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
707 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
708
709 DMatTransposer<MT2,!SO2> tmp( *lhs );
710 smpSchurAssign( tmp, rhs.dm_ );
711 }
713 //**********************************************************************************************
714
715 //**SMP Schur product assignment to sparse matrices*********************************************
716 // No special implementation for the SMP Schur product assignment to sparse matrices.
717 //**********************************************************************************************
718
719 //**SMP multiplication assignment to dense matrices*********************************************
720 // No special implementation for the SMP multiplication assignment to dense matrices.
721 //**********************************************************************************************
722
723 //**SMP multiplication assignment to sparse matrices********************************************
724 // No special implementation for the SMP multiplication assignment to sparse matrices.
725 //**********************************************************************************************
726
727 //**Compile time checks*************************************************************************
732 //**********************************************************************************************
733};
734//*************************************************************************************************
735
736
737
738
739//=================================================================================================
740//
741// GLOBAL OPERATORS
742//
743//=================================================================================================
744
745//*************************************************************************************************
764template< typename MT // Type of the dense matrix
765 , bool SO > // Storage order
766inline decltype(auto) trans( const DenseMatrix<MT,SO>& dm )
767{
769
770 using ReturnType = const DMatTransExpr<MT,!SO>;
771 return ReturnType( *dm );
772}
773//*************************************************************************************************
774
775
776//*************************************************************************************************
787template< typename MT // Type of the dense matrix
788 , bool SO > // Storage order
789inline decltype(auto) transIf( FalseType, const DenseMatrix<MT,SO>& dm )
790{
791 return *dm;
792}
794//*************************************************************************************************
795
796
797//*************************************************************************************************
808template< typename MT // Type of the dense matrix
809 , bool SO > // Storage order
810inline decltype(auto) transIf( TrueType, const DenseMatrix<MT,SO>& dm )
811{
812 return trans( *dm );
813}
815//*************************************************************************************************
816
817
818//*************************************************************************************************
829template< bool B // Compile time condition
830 , typename MT // Type of the dense matrix
831 , bool SO > // Storage order
832inline decltype(auto) transIf( const DenseMatrix<MT,SO>& dm )
833{
834 return transIf( BoolConstant<B>(), *dm );
835}
836//*************************************************************************************************
837
838
839
840
841//=================================================================================================
842//
843// HASCONSTDATAACCESS SPECIALIZATIONS
844//
845//=================================================================================================
846
847//*************************************************************************************************
849template< typename MT, bool SO >
850struct HasConstDataAccess< DMatTransExpr<MT,SO> >
851 : public HasConstDataAccess<MT>
852{};
854//*************************************************************************************************
855
856
857
858
859//=================================================================================================
860//
861// ISALIGNED SPECIALIZATIONS
862//
863//=================================================================================================
864
865//*************************************************************************************************
867template< typename MT, bool SO >
868struct IsAligned< DMatTransExpr<MT,SO> >
869 : public IsAligned<MT>
870{};
872//*************************************************************************************************
873
874
875
876
877//=================================================================================================
878//
879// ISPADDED SPECIALIZATIONS
880//
881//=================================================================================================
882
883//*************************************************************************************************
885template< typename MT, bool SO >
886struct IsPadded< DMatTransExpr<MT,SO> >
887 : public IsPadded<MT>
888{};
890//*************************************************************************************************
891
892} // namespace blaze
893
894#endif
Header file for auxiliary alias declarations.
typename T::ReturnType ReturnType_t
Alias declaration for nested ReturnType type definitions.
Definition: Aliases.h:470
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.
Definition: Aliases.h:450
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.
Definition: Aliases.h:190
typename T::OppositeType OppositeType_t
Alias declaration for nested OppositeType type definitions.
Definition: Aliases.h:310
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.
Definition: Aliases.h:550
Header file for run time assertion macros.
Header file for the dense matrix transposer.
Header file for the EnableIf class template.
Header file for the function trace functionality.
Header file for the GetMemberType type trait.
Header file for the HasConstDataAccess type trait.
Header file for the If class template.
Header file for the IntegralConstant class template.
Utility type for generic codes.
Header file for the IsAligned type trait.
Header file for the IsComputation type trait class.
Header file for the IsExpression type trait class.
Header file for the IsPadded type trait.
Header file for the SIMD trait.
Expression object for dense matrix transpositions.
Definition: DMatTransExpr.h:93
BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT(GetConstIterator, ConstIterator, INVALID_TYPE)
Definition of the GetConstIterator type trait.
GetConstIterator_t< MT > ConstIterator
Iterator over the elements of the dense matrix.
Definition: DMatTransExpr.h:148
If_t< useAssign, const ResultType, const DMatTransExpr & > CompositeType
Data type for composite expression templates.
Definition: DMatTransExpr.h:145
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: DMatTransExpr.h:156
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatTransExpr.h:326
Operand dm_
Dense matrix of the transposition expression.
Definition: DMatTransExpr.h:365
DMatTransExpr(const MT &dm) noexcept
Constructor for the DMatTransExpr class.
Definition: DMatTransExpr.h:172
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTransExpr.h:184
If_t< IsExpression_v< MT >, const MT, const MT & > Operand
Composite data type of the dense matrix expression.
Definition: DMatTransExpr.h:151
size_t nonZeros() const
Returns the number of non-zero elements in the dense matrix.
Definition: DMatTransExpr.h:293
ElementType_t< MT > ElementType
Resulting element type.
Definition: DMatTransExpr.h:141
static constexpr size_t SIMDSIZE
The number of elements packed within a single SIMD element.
Definition: DMatTransExpr.h:164
ReturnType_t< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatTransExpr.h:142
ResultType_t< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatTransExpr.h:140
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatTransExpr.h:199
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row/column.
Definition: DMatTransExpr.h:304
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatTransExpr.h:338
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatTransExpr.h:263
BLAZE_ALWAYS_INLINE auto load(size_t i, size_t j) const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatTransExpr.h:217
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatTransExpr.h:348
TransposeType_t< MT > ResultType
Result type for expression template evaluations.
Definition: DMatTransExpr.h:138
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatTransExpr.h:314
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: DMatTransExpr.h:159
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatTransExpr.h:358
const ElementType * data() const noexcept
Low-level data access to the matrix elements.
Definition: DMatTransExpr.h:231
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatTransExpr.h:253
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatTransExpr.h:242
OppositeType_t< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTransExpr.h:139
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatTransExpr.h:273
size_t spacing() const noexcept
Returns the spacing between the beginning of two rows/columns.
Definition: DMatTransExpr.h:283
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the transposition expression.
Definition: DMatTransExpr.h:108
Expression object for the transposition of a dense matrix.
Definition: DMatTransposer.h:79
MT & dm_
The dense matrix operand.
Definition: DMatTransposer.h:622
Base class for dense matrices.
Definition: DenseMatrix.h:82
SIMD characteristics of data types.
Definition: SIMDTrait.h:297
Base class for sparse matrices.
Definition: SparseMatrix.h:77
Constraint on the data type.
Constraint on the data type.
Header file for the Computation base class.
Header file for the DenseMatrix base class.
Header file for the MatTransExpr base class.
Header file for the Transformation base class.
decltype(auto) transIf(const DenseMatrix< MT, SO > &dm)
Conditional calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:832
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:766
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:812
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.
Definition: StorageOrder.h:84
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.
Definition: RequiresEvaluation.h:81
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.
Definition: DenseMatrix.h:61
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.
Definition: StorageOrder.h:63
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
auto smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:162
auto smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:100
auto smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:194
auto smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:131
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
BoolConstant< true > TrueType
Type traits base class.
Definition: IntegralConstant.h:132
BoolConstant< false > FalseType
Type/value traits base class.
Definition: IntegralConstant.h:121
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.
Definition: EnableIf.h:138
typename If< Condition >::template Type< T1, T2 > If_t
Auxiliary alias template for the If class template.
Definition: If.h:108
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.
Definition: Exception.h:331
#define BLAZE_FUNCTION_TRACE
Function trace macro.
Definition: FunctionTrace.h:94
Header file for the exception macros of the math module.
Constraints on the storage order of matrix types.
Header file for all forward declarations for expression class templates.
Header file for the serial shim.
Generic wrapper for a compile time constant integral value.
Definition: IntegralConstant.h:74
Base class for all matrix transposition expression templates.
Definition: MatTransExpr.h:69
System settings for the inline keywords.
Header file for the RequiresEvaluation type trait.
Header file for basic type definitions.