Blaze 3.9
DMatScalarMultExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_DMATSCALARMULTEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_DMATSCALARMULTEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <iterator>
44#include <utility>
45#include <blaze/math/Aliases.h>
57#include <blaze/math/SIMD.h>
71#include <blaze/system/Inline.h>
73#include <blaze/util/Assert.h>
75#include <blaze/util/EnableIf.h>
77#include <blaze/util/mpl/If.h>
78#include <blaze/util/Types.h>
80
81
82namespace blaze {
83
84//=================================================================================================
85//
86// CLASS DMATSCALARMULTEXPR
87//
88//=================================================================================================
89
90//*************************************************************************************************
97template< typename MT // Type of the left-hand side dense matrix
98 , typename ST // Type of the right-hand side scalar value
99 , bool SO > // Storage order
101 : public MatScalarMultExpr< DenseMatrix< DMatScalarMultExpr<MT,ST,SO>, SO > >
102 , private Computation
103{
104 private:
105 //**Type definitions****************************************************************************
110 //**********************************************************************************************
111
112 //**Return type evaluation**********************************************************************
114
119 static constexpr bool returnExpr = !IsTemporary_v<RN>;
120
122 using ExprReturnType = decltype( std::declval<RN>() * std::declval<ST>() );
123 //**********************************************************************************************
124
125 //**Serial evaluation strategy******************************************************************
127
133 static constexpr bool useAssign = ( IsComputation_v<MT> && RequiresEvaluation_v<MT> );
134
137 template< typename MT2 >
138 static constexpr bool UseAssign_v = useAssign;
140 //**********************************************************************************************
141
142 //**Parallel evaluation strategy****************************************************************
144
150 template< typename MT2 >
151 static constexpr bool UseSMPAssign_v =
152 ( ( !MT2::smpAssignable || !MT::smpAssignable ) && useAssign );
154 //**********************************************************************************************
155
156 public:
157 //**Type definitions****************************************************************************
160
163
168
171
174
176 using LeftOperand = If_t< IsExpression_v<MT>, const MT, const MT& >;
177
179 using RightOperand = ST;
180 //**********************************************************************************************
181
182 //**ConstIterator class definition**************************************************************
186 {
187 public:
188 //**Type definitions*************************************************************************
189 using IteratorCategory = std::random_access_iterator_tag;
193 using DifferenceType = ptrdiff_t;
194
195 // STL iterator requirements
201
204 //*******************************************************************************************
205
206 //**Constructor******************************************************************************
212 inline ConstIterator( IteratorType iterator, RightOperand scalar )
213 : iterator_( iterator ) // Iterator to the current element
214 , scalar_ ( scalar ) // Scalar of the multiplication expression
215 {}
216 //*******************************************************************************************
217
218 //**Addition assignment operator*************************************************************
225 iterator_ += inc;
226 return *this;
227 }
228 //*******************************************************************************************
229
230 //**Subtraction assignment operator**********************************************************
237 iterator_ -= dec;
238 return *this;
239 }
240 //*******************************************************************************************
241
242 //**Prefix increment operator****************************************************************
248 ++iterator_;
249 return *this;
250 }
251 //*******************************************************************************************
252
253 //**Postfix increment operator***************************************************************
259 return ConstIterator( iterator_++, scalar_ );
260 }
261 //*******************************************************************************************
262
263 //**Prefix decrement operator****************************************************************
269 --iterator_;
270 return *this;
271 }
272 //*******************************************************************************************
273
274 //**Postfix decrement operator***************************************************************
280 return ConstIterator( iterator_--, scalar_ );
281 }
282 //*******************************************************************************************
283
284 //**Element access operator******************************************************************
289 inline ReturnType operator*() const {
290 return *iterator_ * scalar_;
291 }
292 //*******************************************************************************************
293
294 //**Load function****************************************************************************
299 inline auto load() const noexcept {
300 return iterator_.load() * set( scalar_ );
301 }
302 //*******************************************************************************************
303
304 //**Equality operator************************************************************************
310 inline bool operator==( const ConstIterator& rhs ) const {
311 return iterator_ == rhs.iterator_;
312 }
313 //*******************************************************************************************
314
315 //**Inequality operator**********************************************************************
321 inline bool operator!=( const ConstIterator& rhs ) const {
322 return iterator_ != rhs.iterator_;
323 }
324 //*******************************************************************************************
325
326 //**Less-than operator***********************************************************************
332 inline bool operator<( const ConstIterator& rhs ) const {
333 return iterator_ < rhs.iterator_;
334 }
335 //*******************************************************************************************
336
337 //**Greater-than operator********************************************************************
343 inline bool operator>( const ConstIterator& rhs ) const {
344 return iterator_ > rhs.iterator_;
345 }
346 //*******************************************************************************************
347
348 //**Less-or-equal-than operator**************************************************************
354 inline bool operator<=( const ConstIterator& rhs ) const {
355 return iterator_ <= rhs.iterator_;
356 }
357 //*******************************************************************************************
358
359 //**Greater-or-equal-than operator***********************************************************
365 inline bool operator>=( const ConstIterator& rhs ) const {
366 return iterator_ >= rhs.iterator_;
367 }
368 //*******************************************************************************************
369
370 //**Subtraction operator*********************************************************************
376 inline DifferenceType operator-( const ConstIterator& rhs ) const {
377 return iterator_ - rhs.iterator_;
378 }
379 //*******************************************************************************************
380
381 //**Addition operator************************************************************************
388 friend inline const ConstIterator operator+( const ConstIterator& it, size_t inc ) {
389 return ConstIterator( it.iterator_ + inc, it.scalar_ );
390 }
391 //*******************************************************************************************
392
393 //**Addition operator************************************************************************
400 friend inline const ConstIterator operator+( size_t inc, const ConstIterator& it ) {
401 return ConstIterator( it.iterator_ + inc, it.scalar_ );
402 }
403 //*******************************************************************************************
404
405 //**Subtraction operator*********************************************************************
412 friend inline const ConstIterator operator-( const ConstIterator& it, size_t dec ) {
413 return ConstIterator( it.iterator_ - dec, it.scalar_ );
414 }
415 //*******************************************************************************************
416
417 private:
418 //**Member variables*************************************************************************
421 //*******************************************************************************************
422 };
423 //**********************************************************************************************
424
425 //**Compilation flags***************************************************************************
427 static constexpr bool simdEnabled =
428 ( MT::simdEnabled && IsNumeric_v<ET> &&
429 ( HasSIMDMult_v<ET,ST> || HasSIMDMult_v<UnderlyingElement_t<ET>,ST> ) );
430
432 static constexpr bool smpAssignable = MT::smpAssignable;
433 //**********************************************************************************************
434
435 //**SIMD properties*****************************************************************************
437 static constexpr size_t SIMDSIZE = SIMDTrait<ElementType>::size;
438 //**********************************************************************************************
439
440 //**Constructor*********************************************************************************
446 inline DMatScalarMultExpr( const MT& matrix, ST scalar ) noexcept
447 : matrix_( matrix ) // Left-hand side dense matrix of the multiplication expression
448 , scalar_( scalar ) // Right-hand side scalar of the multiplication expression
449 {}
450 //**********************************************************************************************
451
452 //**Access operator*****************************************************************************
459 inline ReturnType operator()( size_t i, size_t j ) const {
460 BLAZE_INTERNAL_ASSERT( i < matrix_.rows() , "Invalid row access index" );
461 BLAZE_INTERNAL_ASSERT( j < matrix_.columns(), "Invalid column access index" );
462 return matrix_(i,j) * scalar_;
463 }
464 //**********************************************************************************************
465
466 //**At function*********************************************************************************
474 inline ReturnType at( size_t i, size_t j ) const {
475 if( i >= matrix_.rows() ) {
476 BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
477 }
478 if( j >= matrix_.columns() ) {
479 BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
480 }
481 return (*this)(i,j);
482 }
483 //**********************************************************************************************
484
485 //**Load function*******************************************************************************
492 BLAZE_ALWAYS_INLINE auto load( size_t i, size_t j ) const noexcept {
493 BLAZE_INTERNAL_ASSERT( i < matrix_.rows() , "Invalid row access index" );
494 BLAZE_INTERNAL_ASSERT( j < matrix_.columns(), "Invalid column access index" );
495 BLAZE_INTERNAL_ASSERT( !SO || ( i % SIMDSIZE == 0UL ), "Invalid row access index" );
496 BLAZE_INTERNAL_ASSERT( SO || ( j % SIMDSIZE == 0UL ), "Invalid column access index" );
497 return matrix_.load(i,j) * set( scalar_ );
498 }
499 //**********************************************************************************************
500
501 //**Begin function******************************************************************************
507 inline ConstIterator begin( size_t i ) const {
508 return ConstIterator( matrix_.begin(i), scalar_ );
509 }
510 //**********************************************************************************************
511
512 //**End function********************************************************************************
518 inline ConstIterator end( size_t i ) const {
519 return ConstIterator( matrix_.end(i), scalar_ );
520 }
521 //**********************************************************************************************
522
523 //**Rows function*******************************************************************************
528 inline size_t rows() const noexcept {
529 return matrix_.rows();
530 }
531 //**********************************************************************************************
532
533 //**Columns function****************************************************************************
538 inline size_t columns() const noexcept {
539 return matrix_.columns();
540 }
541 //**********************************************************************************************
542
543 //**Left operand access*************************************************************************
548 inline LeftOperand leftOperand() const noexcept {
549 return matrix_;
550 }
551 //**********************************************************************************************
552
553 //**Right operand access************************************************************************
558 inline RightOperand rightOperand() const noexcept {
559 return scalar_;
560 }
561 //**********************************************************************************************
562
563 //**********************************************************************************************
569 template< typename T >
570 inline bool canAlias( const T* alias ) const noexcept {
571 return IsExpression_v<MT> && matrix_.canAlias( alias );
572 }
573 //**********************************************************************************************
574
575 //**********************************************************************************************
581 template< typename T >
582 inline bool isAliased( const T* alias ) const noexcept {
583 return matrix_.isAliased( alias );
584 }
585 //**********************************************************************************************
586
587 //**********************************************************************************************
592 inline bool isAligned() const noexcept {
593 return matrix_.isAligned();
594 }
595 //**********************************************************************************************
596
597 //**********************************************************************************************
602 inline bool canSMPAssign() const noexcept {
603 return matrix_.canSMPAssign() ||
604 ( rows() * columns() >= SMP_DMATSCALARMULT_THRESHOLD );
605 }
606 //**********************************************************************************************
607
608 private:
609 //**Member variables****************************************************************************
612 //**********************************************************************************************
613
614 //**Assignment to dense matrices****************************************************************
628 template< typename MT2 // Type of the target dense matrix
629 , bool SO2 > // Storage order of the target dense matrix
630 friend inline auto assign( DenseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
632 {
634
635 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
636 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
637
638 assign( *lhs, rhs.matrix_ );
639 assign( *lhs, (*lhs) * rhs.scalar_ );
640 }
642 //**********************************************************************************************
643
644 //**Assignment to sparse matrices***************************************************************
658 template< typename MT2 // Type of the target sparse matrix
659 , bool SO2 > // Storage order of the target sparse matrix
660 friend inline auto assign( SparseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
662 {
664
665 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
666 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
667
668 assign( *lhs, rhs.matrix_ );
669 (*lhs) *= rhs.scalar_;
670 }
672 //**********************************************************************************************
673
674 //**Addition assignment to dense matrices*******************************************************
688 template< typename MT2 // Type of the target dense matrix
689 , bool SO2 > // Storage order of the target dense matrix
690 friend inline auto addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
691 -> EnableIf_t< UseAssign_v<MT2> >
692 {
694
698
699 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
700 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
701
702 const ResultType tmp( serial( rhs ) );
703 addAssign( *lhs, tmp );
704 }
706 //**********************************************************************************************
707
708 //**Addition assignment to sparse matrices******************************************************
709 // No special implementation for the addition assignment to sparse matrices.
710 //**********************************************************************************************
711
712 //**Subtraction assignment to dense matrices****************************************************
726 template< typename MT2 // Type of the target dense matrix
727 , bool SO2 > // Storage order of the target dense matrix
728 friend inline auto subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
729 -> EnableIf_t< UseAssign_v<MT2> >
730 {
732
736
737 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
738 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
739
740 const ResultType tmp( serial( rhs ) );
741 subAssign( *lhs, tmp );
742 }
744 //**********************************************************************************************
745
746 //**Subtraction assignment to sparse matrices***************************************************
747 // No special implementation for the subtraction assignment to sparse matrices.
748 //**********************************************************************************************
749
750 //**Schur product assignment to dense matrices**************************************************
764 template< typename MT2 // Type of the target dense matrix
765 , bool SO2 > // Storage order of the target dense matrix
766 friend inline auto schurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
767 -> EnableIf_t< UseAssign_v<MT2> >
768 {
770
774
775 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
776 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
777
778 const ResultType tmp( serial( rhs ) );
779 schurAssign( *lhs, tmp );
780 }
782 //**********************************************************************************************
783
784 //**Schur product assignment to sparse matrices*************************************************
785 // No special implementation for the Schur product assignment to sparse matrices.
786 //**********************************************************************************************
787
788 //**Multiplication assignment to dense matrices*************************************************
789 // No special implementation for the multiplication assignment to dense matrices.
790 //**********************************************************************************************
791
792 //**Multiplication assignment to sparse matrices************************************************
793 // No special implementation for the multiplication assignment to sparse matrices.
794 //**********************************************************************************************
795
796 //**SMP assignment to dense matrices************************************************************
810 template< typename MT2 // Type of the target dense matrix
811 , bool SO2 > // Storage order of the target dense matrix
812 friend inline auto smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
813 -> EnableIf_t< UseSMPAssign_v<MT2> >
814 {
816
817 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
818 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
819
820 smpAssign( *lhs, rhs.matrix_ );
821 smpAssign( *lhs, (*lhs) * rhs.scalar_ );
822 }
824 //**********************************************************************************************
825
826 //**SMP assignment to sparse matrices***********************************************************
840 template< typename MT2 // Type of the target sparse matrix
841 , bool SO2 > // Storage order of the target sparse matrix
842 friend inline auto smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
843 -> EnableIf_t< UseSMPAssign_v<MT2> >
844 {
846
847 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
848 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
849
850 smpAssign( *lhs, rhs.matrix_ );
851 (*lhs) *= rhs.scalar_;
852 }
854 //**********************************************************************************************
855
856 //**SMP addition assignment to dense matrices***************************************************
870 template< typename MT2 // Type of the target dense matrix
871 , bool SO2 > // Storage order of the target dense matrix
872 friend inline auto smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
873 -> EnableIf_t< UseSMPAssign_v<MT2> >
874 {
876
880
881 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
882 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
883
884 const ResultType tmp( rhs );
885 smpAddAssign( *lhs, tmp );
886 }
888 //**********************************************************************************************
889
890 //**SMP addition assignment to sparse matrices**************************************************
891 // No special implementation for the SMP addition assignment to sparse matrices.
892 //**********************************************************************************************
893
894 //**SMP subtraction assignment to dense matrices************************************************
908 template< typename MT2 // Type of the target dense matrix
909 , bool SO2 > // Storage order of the target dense matrix
910 friend inline auto smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
911 -> EnableIf_t< UseSMPAssign_v<MT2> >
912 {
914
918
919 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
920 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
921
922 const ResultType tmp( rhs );
923 smpSubAssign( *lhs, tmp );
924 }
926 //**********************************************************************************************
927
928 //**SMP subtraction assignment to sparse matrices***********************************************
929 // No special implementation for the SMP subtraction assignment to sparse matrices.
930 //**********************************************************************************************
931
932 //**SMP Schur product assignment to dense matrices**********************************************
946 template< typename MT2 // Type of the target dense matrix
947 , bool SO2 > // Storage order of the target dense matrix
948 friend inline auto smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatScalarMultExpr& rhs )
949 -> EnableIf_t< UseSMPAssign_v<MT2> >
950 {
952
956
957 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
958 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
959
960 const ResultType tmp( rhs );
961 smpSchurAssign( *lhs, tmp );
962 }
964 //**********************************************************************************************
965
966 //**SMP Schur product assignment to sparse matrices*********************************************
967 // No special implementation for the SMP Schur product assignment to sparse matrices.
968 //**********************************************************************************************
969
970 //**SMP multiplication assignment to dense matrices*********************************************
971 // No special implementation for the SMP multiplication assignment to dense matrices.
972 //**********************************************************************************************
973
974 //**SMP multiplication assignment to sparse matrices********************************************
975 // No special implementation for the SMP multiplication assignment to sparse matrices.
976 //**********************************************************************************************
977
978 //**Compile time checks*************************************************************************
985 //**********************************************************************************************
986};
987//*************************************************************************************************
988
989
990
991
992//=================================================================================================
993//
994// GLOBAL UNARY ARITHMETIC OPERATORS
995//
996//=================================================================================================
997
998//*************************************************************************************************
1015template< typename MT // Type of the dense matrix
1016 , bool SO > // Storage order
1017inline decltype(auto) operator-( const DenseMatrix<MT,SO>& dm )
1018{
1020
1021 using ScalarType = UnderlyingBuiltin_t<MT>;
1022 using ReturnType = const DMatScalarMultExpr<MT,ScalarType,SO>;
1023 return ReturnType( *dm, ScalarType(-1) );
1024}
1025//*************************************************************************************************
1026
1027
1028
1029
1030//=================================================================================================
1031//
1032// GLOBAL BINARY ARITHMETIC OPERATORS
1033//
1034//=================================================================================================
1035
1036//*************************************************************************************************
1057template< typename MT // Type of the left-hand side dense matrix
1058 , bool SO // Storage order of the left-hand side dense matrix
1059 , typename ST // Type of the right-hand side scalar
1060 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
1061inline decltype(auto) operator*( const DenseMatrix<MT,SO>& mat, ST scalar )
1062{
1064
1065 using ScalarType = MultTrait_t< UnderlyingBuiltin_t<MT>, ST >;
1066 using ReturnType = const DMatScalarMultExpr<MT,ScalarType,SO>;
1067 return ReturnType( *mat, scalar );
1068}
1069//*************************************************************************************************
1070
1071
1072//*************************************************************************************************
1093template< typename ST // Type of the left-hand side scalar
1094 , typename MT // Type of the right-hand side dense matrix
1095 , bool SO // Storage order of the right-hand side dense matrix
1096 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
1097inline decltype(auto) operator*( ST scalar, const DenseMatrix<MT,SO>& mat )
1098{
1100
1101 using ScalarType = MultTrait_t< ST, UnderlyingBuiltin_t<MT> >;
1102 using ReturnType = const DMatScalarMultExpr<MT,ScalarType,SO>;
1103 return ReturnType( *mat, scalar );
1104}
1105//*************************************************************************************************
1106
1107
1108
1109
1110//=================================================================================================
1111//
1112// ISALIGNED SPECIALIZATIONS
1113//
1114//=================================================================================================
1115
1116//*************************************************************************************************
1118template< typename MT, typename ST, bool SO >
1119struct IsAligned< DMatScalarMultExpr<MT,ST,SO> >
1120 : public IsAligned<MT>
1121{};
1123//*************************************************************************************************
1124
1125
1126
1127
1128//=================================================================================================
1129//
1130// ISPADDED SPECIALIZATIONS
1131//
1132//=================================================================================================
1133
1134//*************************************************************************************************
1136template< typename MT, typename ST, bool SO >
1137struct IsPadded< DMatScalarMultExpr<MT,ST,SO> >
1138 : public IsPadded<MT>
1139{};
1141//*************************************************************************************************
1142
1143} // namespace blaze
1144
1145#endif
Header file for auxiliary alias declarations.
typename T::CompositeType CompositeType_t
Alias declaration for nested CompositeType type definitions.
Definition: Aliases.h:110
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::ConstIterator ConstIterator_t
Alias declaration for nested ConstIterator type definitions.
Definition: Aliases.h:130
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 EnableIf class template.
Header file for the function trace functionality.
Header file for the HasSIMDMult type trait.
Macro for CUDA compatibility.
Header file for the If class template.
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 IsInvertible type trait.
Header file for the IsNumeric type trait.
Header file for the IsPadded type trait.
Header file for the IsScalar type trait.
Header file for the IsTemporary type trait class.
Header file for the multiplication trait.
Header file for all SIMD functionality.
Data type constraint.
Constraint on the data type.
Header file for the UnderlyingBuiltin type trait.
Header file for the UnderlyingElement type trait.
Iterator over the elements of the dense matrix.
Definition: DMatScalarMultExpr.h:186
ElementType * PointerType
Pointer return type.
Definition: DMatScalarMultExpr.h:191
ElementType ValueType
Type of the underlying elements.
Definition: DMatScalarMultExpr.h:190
BLAZE_DEVICE_CALLABLE ConstIterator & operator--()
Pre-decrement operator.
Definition: DMatScalarMultExpr.h:268
bool operator<=(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatScalarMultExpr.h:354
RightOperand scalar_
Scalar of the multiplication expression.
Definition: DMatScalarMultExpr.h:420
ConstIterator(IteratorType iterator, RightOperand scalar)
Constructor for the ConstIterator class.
Definition: DMatScalarMultExpr.h:212
BLAZE_DEVICE_CALLABLE const ConstIterator operator++(int)
Post-increment operator.
Definition: DMatScalarMultExpr.h:258
ElementType & ReferenceType
Reference return type.
Definition: DMatScalarMultExpr.h:192
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two iterators.
Definition: DMatScalarMultExpr.h:376
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DMatScalarMultExpr.h:321
bool operator>(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatScalarMultExpr.h:343
IteratorType iterator_
Iterator to the current element.
Definition: DMatScalarMultExpr.h:419
BLAZE_DEVICE_CALLABLE const ConstIterator operator--(int)
Post-decrement operator.
Definition: DMatScalarMultExpr.h:279
friend const ConstIterator operator+(const ConstIterator &it, size_t inc)
Addition between a ConstIterator and an integral value.
Definition: DMatScalarMultExpr.h:388
ConstIterator_t< MT > IteratorType
ConstIterator type of the dense matrix expression.
Definition: DMatScalarMultExpr.h:203
ReturnType operator*() const
Direct access to the element at the current iterator position.
Definition: DMatScalarMultExpr.h:289
ReferenceType reference
Reference return type.
Definition: DMatScalarMultExpr.h:199
std::random_access_iterator_tag IteratorCategory
The iterator category.
Definition: DMatScalarMultExpr.h:189
friend const ConstIterator operator-(const ConstIterator &it, size_t dec)
Subtraction between a ConstIterator and an integral value.
Definition: DMatScalarMultExpr.h:412
PointerType pointer
Pointer return type.
Definition: DMatScalarMultExpr.h:198
bool operator>=(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatScalarMultExpr.h:365
friend const ConstIterator operator+(size_t inc, const ConstIterator &it)
Addition between an integral value and a ConstIterator.
Definition: DMatScalarMultExpr.h:400
bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DMatScalarMultExpr.h:310
IteratorCategory iterator_category
The iterator category.
Definition: DMatScalarMultExpr.h:196
ValueType value_type
Type of the underlying elements.
Definition: DMatScalarMultExpr.h:197
BLAZE_DEVICE_CALLABLE ConstIterator & operator++()
Pre-increment operator.
Definition: DMatScalarMultExpr.h:247
DifferenceType difference_type
Difference between two iterators.
Definition: DMatScalarMultExpr.h:200
auto load() const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatScalarMultExpr.h:299
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DMatScalarMultExpr.h:193
BLAZE_DEVICE_CALLABLE ConstIterator & operator-=(size_t dec)
Subtraction assignment operator.
Definition: DMatScalarMultExpr.h:236
BLAZE_DEVICE_CALLABLE ConstIterator & operator+=(size_t inc)
Addition assignment operator.
Definition: DMatScalarMultExpr.h:224
bool operator<(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatScalarMultExpr.h:332
Expression object for dense matrix-scalar multiplications.
Definition: DMatScalarMultExpr.h:103
CompositeType_t< MT > CT
Composite type of the dense matrix expression.
Definition: DMatScalarMultExpr.h:109
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatScalarMultExpr.h:592
ReturnType_t< MT > RN
Return type of the dense matrix expression.
Definition: DMatScalarMultExpr.h:107
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense matrix operand.
Definition: DMatScalarMultExpr.h:548
const If_t< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: DMatScalarMultExpr.h:170
ElementType_t< MT > ET
Element type of the dense matrix expression.
Definition: DMatScalarMultExpr.h:108
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatScalarMultExpr.h:602
ElementType_t< ResultType > ElementType
Resulting element type.
Definition: DMatScalarMultExpr.h:167
If_t< IsExpression_v< MT >, const MT, const MT & > LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatScalarMultExpr.h:176
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatScalarMultExpr.h:474
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatScalarMultExpr.h:570
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatScalarMultExpr.h:538
ResultType_t< MT > RT
Result type of the dense matrix expression.
Definition: DMatScalarMultExpr.h:106
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatScalarMultExpr.h:518
ST RightOperand
Composite type of the right-hand side scalar value.
Definition: DMatScalarMultExpr.h:179
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatScalarMultExpr.h:507
If_t< useAssign, const ResultType, const DMatScalarMultExpr & > CompositeType
Data type for composite expression templates.
Definition: DMatScalarMultExpr.h:173
RightOperand scalar_
Right-hand side scalar of the multiplication expression.
Definition: DMatScalarMultExpr.h:611
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: DMatScalarMultExpr.h:427
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: DMatScalarMultExpr.h:558
static constexpr size_t SIMDSIZE
The number of elements packed within a single SIMD element.
Definition: DMatScalarMultExpr.h:437
BLAZE_ALWAYS_INLINE auto load(size_t i, size_t j) const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatScalarMultExpr.h:492
DMatScalarMultExpr(const MT &matrix, ST scalar) noexcept
Constructor for the DMatScalarMultExpr class.
Definition: DMatScalarMultExpr.h:446
OppositeType_t< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatScalarMultExpr.h:165
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatScalarMultExpr.h:582
MultTrait_t< RT, ST > ResultType
Result type for expression template evaluations.
Definition: DMatScalarMultExpr.h:164
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatScalarMultExpr.h:528
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatScalarMultExpr.h:459
decltype(std::declval< RN >() *std::declval< ST >()) ExprReturnType
Expression return type for the subscript operator.
Definition: DMatScalarMultExpr.h:122
TransposeType_t< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatScalarMultExpr.h:166
LeftOperand matrix_
Left-hand side dense matrix of the multiplication expression.
Definition: DMatScalarMultExpr.h:610
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: DMatScalarMultExpr.h:432
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the multiplication expression.
Definition: DMatScalarMultExpr.h:133
static constexpr bool returnExpr
Compilation switch for the selection of the subscript operator return type.
Definition: DMatScalarMultExpr.h:119
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 DenseVector base class.
Header file for the MatScalarMultExpr base class.
#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE(A, B)
Data type constraint.
Definition: SameType.h:71
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_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_SCALAR_TYPE(T)
Constraint on the data type.
Definition: Scalar.h:61
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.
Definition: StorageOrder.h:63
typename MultTrait< T1, T2 >::Type MultTrait_t
Auxiliary alias declaration for the MultTrait class template.
Definition: MultTrait.h:165
typename UnderlyingBuiltin< T >::Type UnderlyingBuiltin_t
Auxiliary alias declaration for the UnderlyingBuiltin type trait.
Definition: UnderlyingBuiltin.h:117
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > set(T value) noexcept
Sets all values in the vector to the given 1-byte integral value.
Definition: Set.h:75
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
#define BLAZE_DEVICE_CALLABLE
Conditional macro that sets host and device attributes when compiled with CUDA.
Definition: HostDevice.h:94
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.
Base class for all compute expression templates.
Definition: Computation.h:68
Base class for all matrix/scalar multiplication expression templates.
Definition: MatScalarMultExpr.h:77
System settings for the inline keywords.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
Header file for the RequiresEvaluation type trait.
Header file for basic type definitions.