Blaze 3.9
DMatMapExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_DMATMAPEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_DMATMAPEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <iterator>
44#include <utility>
45#include <blaze/math/Aliases.h>
54#include <blaze/math/Functors.h>
56#include <blaze/math/SIMD.h>
73#include <blaze/system/Inline.h>
74#include <blaze/util/Assert.h>
75#include <blaze/util/EnableIf.h>
78#include <blaze/util/mpl/If.h>
79#include <blaze/util/Types.h>
84
85
86namespace blaze {
87
88//=================================================================================================
89//
90// CLASS DMATMAPEXPR
91//
92//=================================================================================================
93
94//*************************************************************************************************
101template< typename MT // Type of the dense matrix
102 , typename OP // Type of the custom operation
103 , bool SO > // Storage order
105 : public MatMapExpr< DenseMatrix< DMatMapExpr<MT,OP,SO>, SO > >
106 , private Computation
107{
108 private:
109 //**Type definitions****************************************************************************
114 //**********************************************************************************************
115
116 //**Serial evaluation strategy******************************************************************
118
124 static constexpr bool useAssign = ( IsComputation_v<MT> && RequiresEvaluation_v<MT> );
125
128 template< typename MT2 >
129 static constexpr bool UseAssign_v = useAssign;
131 //**********************************************************************************************
132
133 //**Parallel evaluation strategy****************************************************************
135
141 template< typename MT2 >
142 static constexpr bool UseSMPAssign_v =
143 ( ( !MT2::smpAssignable || !MT::smpAssignable ) && useAssign );
145 //**********************************************************************************************
146
147 public:
148 //**Type definitions****************************************************************************
151
154
159
161 using ReturnType = decltype( std::declval<OP>()( std::declval<RN>() ) );
162
165
167 using Operand = If_t< IsExpression_v<MT>, const MT, const MT& >;
168
170 using Operation = OP;
171 //**********************************************************************************************
172
173 //**ConstIterator class definition**************************************************************
177 {
178 public:
179 //**Type definitions*************************************************************************
180 using IteratorCategory = std::random_access_iterator_tag;
184 using DifferenceType = ptrdiff_t;
185
186 // STL iterator requirements
192
195 //*******************************************************************************************
196
197 //**Constructor******************************************************************************
204 : it_( it ) // Iterator to the current matrix element
205 , op_( std::move(op) ) // The custom unary operation
206 {}
207 //*******************************************************************************************
208
209 //**Addition assignment operator*************************************************************
216 it_ += inc;
217 return *this;
218 }
219 //*******************************************************************************************
220
221 //**Subtraction assignment operator**********************************************************
228 it_ -= dec;
229 return *this;
230 }
231 //*******************************************************************************************
232
233 //**Prefix increment operator****************************************************************
239 ++it_;
240 return *this;
241 }
242 //*******************************************************************************************
243
244 //**Postfix increment operator***************************************************************
250 return ConstIterator( it_++, op_ );
251 }
252 //*******************************************************************************************
253
254 //**Prefix decrement operator****************************************************************
260 --it_;
261 return *this;
262 }
263 //*******************************************************************************************
264
265 //**Postfix decrement operator***************************************************************
271 return ConstIterator( it_--, op_ );
272 }
273 //*******************************************************************************************
274
275 //**Element access operator******************************************************************
281 return op_( *it_ );
282 }
283 //*******************************************************************************************
284
285 //**Load function****************************************************************************
290 inline auto load() const noexcept {
291 return op_.load( it_.load() );
292 }
293 //*******************************************************************************************
294
295 //**Equality operator************************************************************************
301 inline BLAZE_DEVICE_CALLABLE bool operator==( const ConstIterator& rhs ) const {
302 return it_ == rhs.it_;
303 }
304 //*******************************************************************************************
305
306 //**Inequality operator**********************************************************************
312 inline BLAZE_DEVICE_CALLABLE bool operator!=( const ConstIterator& rhs ) const {
313 return it_ != rhs.it_;
314 }
315 //*******************************************************************************************
316
317 //**Less-than operator***********************************************************************
323 inline BLAZE_DEVICE_CALLABLE bool operator<( const ConstIterator& rhs ) const {
324 return it_ < rhs.it_;
325 }
326 //*******************************************************************************************
327
328 //**Greater-than operator********************************************************************
334 inline BLAZE_DEVICE_CALLABLE bool operator>( const ConstIterator& rhs ) const {
335 return it_ > rhs.it_;
336 }
337 //*******************************************************************************************
338
339 //**Less-or-equal-than operator**************************************************************
345 inline BLAZE_DEVICE_CALLABLE bool operator<=( const ConstIterator& rhs ) const {
346 return it_ <= rhs.it_;
347 }
348 //*******************************************************************************************
349
350 //**Greater-or-equal-than operator***********************************************************
356 inline BLAZE_DEVICE_CALLABLE bool operator>=( const ConstIterator& rhs ) const {
357 return it_ >= rhs.it_;
358 }
359 //*******************************************************************************************
360
361 //**Subtraction operator*********************************************************************
368 return it_ - rhs.it_;
369 }
370 //*******************************************************************************************
371
372 //**Addition operator************************************************************************
379 friend inline BLAZE_DEVICE_CALLABLE const ConstIterator operator+( const ConstIterator& it, size_t inc ) {
380 return ConstIterator( it.it_ + inc, it.op_ );
381 }
382 //*******************************************************************************************
383
384 //**Addition operator************************************************************************
391 friend inline BLAZE_DEVICE_CALLABLE const ConstIterator operator+( size_t inc, const ConstIterator& it ) {
392 return ConstIterator( it.it_ + inc, it.op_ );
393 }
394 //*******************************************************************************************
395
396 //**Subtraction operator*********************************************************************
403 friend inline BLAZE_DEVICE_CALLABLE const ConstIterator operator-( const ConstIterator& it, size_t dec ) {
404 return ConstIterator( it.it_ - dec, it.op_ );
405 }
406 //*******************************************************************************************
407
408 private:
409 //**Member variables*************************************************************************
411 OP op_;
412 //*******************************************************************************************
413 };
414 //**********************************************************************************************
415
416 //**Compilation flags***************************************************************************
418 static constexpr bool simdEnabled =
419 ( MT::simdEnabled &&
420 If_t< HasSIMDEnabled_v<OP>, GetSIMDEnabled<OP,ET>, HasLoad<OP> >::value );
421
423 static constexpr bool smpAssignable = MT::smpAssignable;
424 //**********************************************************************************************
425
426 //**SIMD properties*****************************************************************************
428 static constexpr size_t SIMDSIZE = SIMDTrait<ElementType>::size;
429 //**********************************************************************************************
430
431 //**Constructor*********************************************************************************
437 inline DMatMapExpr( const MT& dm, OP op ) noexcept
438 : dm_( dm ) // Dense matrix of the map expression
439 , op_( std::move(op) ) // The custom unary operation
440 {}
441 //**********************************************************************************************
442
443 //**Access operator*****************************************************************************
450 inline ReturnType operator()( size_t i, size_t j ) const noexcept {
451 BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
452 BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
453 return op_( dm_(i,j) );
454 }
455 //**********************************************************************************************
456
457 //**At function*********************************************************************************
465 inline ReturnType at( size_t i, size_t j ) const {
466 if( i >= dm_.rows() ) {
467 BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
468 }
469 if( j >= dm_.columns() ) {
470 BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
471 }
472 return (*this)(i,j);
473 }
474 //**********************************************************************************************
475
476 //**Load function*******************************************************************************
483 BLAZE_ALWAYS_INLINE auto load( size_t i, size_t j ) const noexcept {
484 BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
485 BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
486 BLAZE_INTERNAL_ASSERT( !SO || ( i % SIMDSIZE == 0UL ), "Invalid row access index" );
487 BLAZE_INTERNAL_ASSERT( SO || ( j % SIMDSIZE == 0UL ), "Invalid column access index" );
488 return op_.load( dm_.load(i,j) );
489 }
490 //**********************************************************************************************
491
492 //**Begin function******************************************************************************
498 inline ConstIterator begin( size_t i ) const {
499 return ConstIterator( dm_.begin(i), op_ );
500 }
501 //**********************************************************************************************
502
503 //**End function********************************************************************************
509 inline ConstIterator end( size_t i ) const {
510 return ConstIterator( dm_.end(i), op_ );
511 }
512 //**********************************************************************************************
513
514 //**Rows function*******************************************************************************
519 inline size_t rows() const noexcept {
520 return dm_.rows();
521 }
522 //**********************************************************************************************
523
524 //**Columns function****************************************************************************
529 inline size_t columns() const noexcept {
530 return dm_.columns();
531 }
532 //**********************************************************************************************
533
534 //**Operand access******************************************************************************
539 inline Operand operand() const noexcept {
540 return dm_;
541 }
542 //**********************************************************************************************
543
544 //**Operation access****************************************************************************
549 inline Operation operation() const {
550 return op_;
551 }
552 //**********************************************************************************************
553
554 //**********************************************************************************************
560 template< typename T >
561 inline bool canAlias( const T* alias ) const noexcept {
562 return IsExpression_v<MT> && dm_.canAlias( alias );
563 }
564 //**********************************************************************************************
565
566 //**********************************************************************************************
572 template< typename T >
573 inline bool isAliased( const T* alias ) const noexcept {
574 return dm_.isAliased( alias );
575 }
576 //**********************************************************************************************
577
578 //**********************************************************************************************
583 inline bool isAligned() const noexcept {
584 return dm_.isAligned();
585 }
586 //**********************************************************************************************
587
588 //**********************************************************************************************
593 inline bool canSMPAssign() const noexcept {
594 return dm_.canSMPAssign();
595 }
596 //**********************************************************************************************
597
598 private:
599 //**Member variables****************************************************************************
602 //**********************************************************************************************
603
604 //**Assignment to dense matrices****************************************************************
619 template< typename MT2 // Type of the target dense matrix
620 , bool SO2 > // Storage order or the target dense matrix
621 friend inline auto assign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
623 IsSame_v< UnderlyingScalar_t<MT>, UnderlyingScalar_t<MT2> > >
624 {
626
627 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
628 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
629
630 assign( *lhs, rhs.dm_ );
631 assign( *lhs, map( *lhs, rhs.op_ ) );
632 }
634 //**********************************************************************************************
635
636 //**Assignment to dense matrices****************************************************************
651 template< typename MT2 // Type of the target dense matrix
652 , bool SO2 > // Storage order or the target dense matrix
653 friend inline auto assign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
655 !IsSame_v< UnderlyingScalar_t<MT>, UnderlyingScalar_t<MT2> > >
656 {
658
662
663 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
664 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
665
666 const RT tmp( serial( rhs.dm_ ) );
667 assign( *lhs, map( tmp, rhs.op_ ) );
668 }
670 //**********************************************************************************************
671
672 //**Assignment to sparse matrices***************************************************************
686 template< typename MT2 // Type of the target sparse matrix
687 , bool SO2 > // Storage order or the target sparse matrix
688 friend inline auto assign( SparseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
689 -> EnableIf_t< UseAssign_v<MT2> >
690 {
692
693 using TmpType = If_t< SO == SO2, RT, OT >;
694
701
702 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
703 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
704
705 const TmpType tmp( serial( rhs.dm_ ) );
706 assign( *lhs, map( tmp, rhs.op_ ) );
707 }
709 //**********************************************************************************************
710
711 //**Addition assignment to dense matrices*******************************************************
725 template< typename MT2 // Type of the target dense matrix
726 , bool SO2 > // Storage order of the target dense matrix
727 friend inline auto addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
728 -> EnableIf_t< UseAssign_v<MT2> >
729 {
731
735
736 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
737 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
738
739 const RT tmp( serial( rhs.dm_ ) );
740 addAssign( *lhs, map( tmp, rhs.op_ ) );
741 }
743 //**********************************************************************************************
744
745 //**Addition assignment to sparse matrices******************************************************
746 // No special implementation for the addition assignment to sparse matrices.
747 //**********************************************************************************************
748
749 //**Subtraction assignment to dense matrices****************************************************
763 template< typename MT2 // Type of the target dense matrix
764 , bool SO2 > // Storage order of the target dense matrix
765 friend inline auto subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
766 -> EnableIf_t< UseAssign_v<MT2> >
767 {
769
773
774 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
775 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
776
777 const RT tmp( serial( rhs.dm_ ) );
778 subAssign( *lhs, map( tmp, rhs.op_ ) );
779 }
781 //**********************************************************************************************
782
783 //**Subtraction assignment to sparse matrices***************************************************
784 // No special implementation for the subtraction assignment to sparse matrices.
785 //**********************************************************************************************
786
787 //**Schur product assignment to dense matrices**************************************************
801 template< typename MT2 // Type of the target dense matrix
802 , bool SO2 > // Storage order of the target dense matrix
803 friend inline auto schurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
804 -> EnableIf_t< UseAssign_v<MT2> >
805 {
807
811
812 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
813 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
814
815 const RT tmp( serial( rhs.dm_ ) );
816 schurAssign( *lhs, map( tmp, rhs.op_ ) );
817 }
819 //**********************************************************************************************
820
821 //**Schur product assignment to sparse matrices*************************************************
822 // No special implementation for the Schur product assignment to sparse matrices.
823 //**********************************************************************************************
824
825 //**Multiplication assignment to dense matrices*************************************************
826 // No special implementation for the multiplication assignment to dense matrices.
827 //**********************************************************************************************
828
829 //**Multiplication assignment to sparse matrices************************************************
830 // No special implementation for the multiplication assignment to sparse matrices.
831 //**********************************************************************************************
832
833 //**SMP assignment to dense matrices************************************************************
848 template< typename MT2 // Type of the target dense matrix
849 , bool SO2 > // Storage order or the target dense matrix
850 friend inline auto smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
851 -> EnableIf_t< UseSMPAssign_v<MT2> &&
852 IsSame_v< UnderlyingScalar_t<MT>, UnderlyingScalar_t<MT2> > >
853 {
855
856 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
857 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
858
859 smpAssign( *lhs, rhs.dm_ );
860 smpAssign( *lhs, map( *lhs, rhs.op_ ) );
861 }
863 //**********************************************************************************************
864
865 //**SMP assignment to dense matrices************************************************************
880 template< typename MT2 // Type of the target dense matrix
881 , bool SO2 > // Storage order or the target dense matrix
882 friend inline auto smpAssign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
883 -> EnableIf_t< UseSMPAssign_v<MT2> &&
884 !IsSame_v< UnderlyingScalar_t<MT>, UnderlyingScalar_t<MT2> > >
885 {
887
891
892 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
893 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
894
895 const RT tmp( rhs.dm_ );
896 smpAssign( *lhs, map( tmp, rhs.op_ ) );
897 }
899 //**********************************************************************************************
900
901 //**SMP assignment to sparse matrices***********************************************************
915 template< typename MT2 // Type of the target sparse matrix
916 , bool SO2 > // Storage order or the target sparse matrix
917 friend inline auto smpAssign( SparseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
918 -> EnableIf_t< UseSMPAssign_v<MT2> >
919 {
921
922 using TmpType = If_t< SO == SO2, RT, OT >;
923
930
931 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
932 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
933
934 const TmpType tmp( rhs.dm_ );
935 smpAssign( *lhs, map( tmp, rhs.op_ ) );
936 }
938 //**********************************************************************************************
939
940 //**SMP addition assignment to dense matrices***************************************************
954 template< typename MT2 // Type of the target dense matrix
955 , bool SO2 > // Storage order of the target dense matrix
956 friend inline auto smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
957 -> EnableIf_t< UseSMPAssign_v<MT2> >
958 {
960
964
965 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
966 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
967
968 const RT tmp( rhs.dm_ );
969 smpAddAssign( *lhs, map( tmp, rhs.op_ ) );
970 }
972 //**********************************************************************************************
973
974 //**SMP addition assignment to sparse matrices**************************************************
975 // No special implementation for the SMP addition assignment to sparse matrices.
976 //**********************************************************************************************
977
978 //**SMP subtraction assignment to dense matrices************************************************
992 template< typename MT2 // Type of the target dense matrix
993 , bool SO2 > // Storage order of the target dense matrix
994 friend inline auto smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
995 -> EnableIf_t< UseSMPAssign_v<MT2> >
996 {
998
1002
1003 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
1004 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
1005
1006 const RT tmp( rhs.dm_ );
1007 smpSubAssign( *lhs, map( tmp, rhs.op_ ) );
1008 }
1010 //**********************************************************************************************
1011
1012 //**SMP subtraction assignment to sparse matrices***********************************************
1013 // No special implementation for the SMP subtraction assignment to sparse matrices.
1014 //**********************************************************************************************
1015
1016 //**SMP Schur product assignment to dense matrices**********************************************
1030 template< typename MT2 // Type of the target dense matrix
1031 , bool SO2 > // Storage order of the target dense matrix
1032 friend inline auto smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatMapExpr& rhs )
1033 -> EnableIf_t< UseSMPAssign_v<MT2> >
1034 {
1036
1040
1041 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
1042 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
1043
1044 const RT tmp( rhs.dm_ );
1045 smpSchurAssign( *lhs, map( tmp, rhs.op_ ) );
1046 }
1048 //**********************************************************************************************
1049
1050 //**SMP Schur product assignment to sparse matrices*********************************************
1051 // No special implementation for the SMP Schur product assignment to sparse matrices.
1052 //**********************************************************************************************
1053
1054 //**SMP multiplication assignment to dense matrices*********************************************
1055 // No special implementation for the SMP multiplication assignment to dense matrices.
1056 //**********************************************************************************************
1057
1058 //**SMP multiplication assignment to sparse matrices********************************************
1059 // No special implementation for the SMP multiplication assignment to sparse matrices.
1060 //**********************************************************************************************
1061
1062 //**Compile time checks*************************************************************************
1067 //**********************************************************************************************
1068};
1069//*************************************************************************************************
1070
1071
1072
1073
1074//=================================================================================================
1075//
1076// GLOBAL FUNCTIONS
1077//
1078//=================================================================================================
1079
1080//*************************************************************************************************
1098template< typename MT // Type of the dense matrix
1099 , bool SO // Storage order
1100 , typename OP > // Type of the custom operation
1101inline decltype(auto) map( const DenseMatrix<MT,SO>& dm, OP op )
1102{
1104
1105 using ReturnType = const DMatMapExpr<MT,OP,SO>;
1106 return ReturnType( *dm, std::move(op) );
1107}
1108//*************************************************************************************************
1109
1110
1111//*************************************************************************************************
1129template< typename MT // Type of the dense matrix
1130 , bool SO // Storage order
1131 , typename OP > // Type of the custom operation
1132inline decltype(auto) forEach( const DenseMatrix<MT,SO>& dm, OP op )
1133{
1135
1136 return map( *dm, std::move(op) );
1137}
1138//*************************************************************************************************
1139
1140
1141//*************************************************************************************************
1160template< typename MT // Type of the dense matrix
1161 , bool SO // Storage order
1162 , typename ST // Type of the scalar exponent
1163 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
1164decltype(auto) min( const DenseMatrix<MT,SO>& dm, ST scalar )
1165{
1167
1168 using ET = ElementType_t<MT>;
1169 using ScalarType = If_t< IsNumeric_v<ET> && IsNumeric_v<ST>, MapTrait_t<ET,ST,Min>, ST >;
1170 return map( *dm, bind2nd( Min(), ScalarType( scalar ) ) );
1171}
1172//*************************************************************************************************
1173
1174
1175//*************************************************************************************************
1194template< typename ST // Type of the scalar exponent
1195 , typename MT // Type of the dense matrix
1196 , bool SO // Storage order
1197 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
1198decltype(auto) min( ST scalar, const DenseMatrix<MT,SO>& dm )
1199{
1201
1202 using ET = ElementType_t<MT>;
1203 using ScalarType = If_t< IsNumeric_v<ST> && IsNumeric_v<ET>, MapTrait_t<ST,ET,Min>, ST >;
1204 return map( *dm, bind1st( Min(), ScalarType( scalar ) ) );
1205}
1206//*************************************************************************************************
1207
1208
1209//*************************************************************************************************
1228template< typename MT // Type of the dense matrix
1229 , bool SO // Storage order
1230 , typename ST // Type of the scalar exponent
1231 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
1232decltype(auto) max( const DenseMatrix<MT,SO>& dm, ST scalar )
1233{
1235
1236 using ET = ElementType_t<MT>;
1237 using ScalarType = If_t< IsNumeric_v<ET> && IsNumeric_v<ST>, MapTrait_t<ET,ST,Max>, ST >;
1238 return map( *dm, bind2nd( Max(), ScalarType( scalar ) ) );
1239}
1240//*************************************************************************************************
1241
1242
1243//*************************************************************************************************
1262template< typename ST // Type of the scalar exponent
1263 , typename MT // Type of the dense matrix
1264 , bool SO // Storage order
1265 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
1266decltype(auto) max( ST scalar, const DenseMatrix<MT,SO>& dm )
1267{
1269
1270 using ET = ElementType_t<MT>;
1271 using ScalarType = If_t< IsNumeric_v<ST> && IsNumeric_v<ET>, MapTrait_t<ST,ET,Max>, ST >;
1272 return map( *dm, bind1st( Max(), ScalarType( scalar ) ) );
1273}
1274//*************************************************************************************************
1275
1276
1277//*************************************************************************************************
1294template< typename MT // Type of the dense matrix
1295 , bool SO > // Storage order
1296inline decltype(auto) abs( const DenseMatrix<MT,SO>& dm )
1297{
1299
1300 return map( *dm, Abs() );
1301}
1302//*************************************************************************************************
1303
1304
1305//*************************************************************************************************
1322template< typename MT // Type of the dense matrix
1323 , bool SO > // Storage order
1324inline decltype(auto) sign( const DenseMatrix<MT,SO>& dm )
1325{
1327
1328 return map( *dm, Sign() );
1329}
1330//*************************************************************************************************
1331
1332
1333//*************************************************************************************************
1350template< typename MT // Type of the dense matrix
1351 , bool SO > // Storage order
1352inline decltype(auto) floor( const DenseMatrix<MT,SO>& dm )
1353{
1355
1356 return map( *dm, Floor() );
1357}
1358//*************************************************************************************************
1359
1360
1361//*************************************************************************************************
1378template< typename MT // Type of the dense matrix
1379 , bool SO > // Storage order
1380inline decltype(auto) ceil( const DenseMatrix<MT,SO>& dm )
1381{
1383
1384 return map( *dm, Ceil() );
1385}
1386//*************************************************************************************************
1387
1388
1389//*************************************************************************************************
1406template< typename MT // Type of the dense matrix
1407 , bool SO > // Storage order
1408inline decltype(auto) trunc( const DenseMatrix<MT,SO>& dm )
1409{
1411
1412 return map( *dm, Trunc() );
1413}
1414//*************************************************************************************************
1415
1416
1417//*************************************************************************************************
1434template< typename MT // Type of the dense matrix
1435 , bool SO > // Storage order
1436inline decltype(auto) round( const DenseMatrix<MT,SO>& dm )
1437{
1439
1440 return map( *dm, Round() );
1441}
1442//*************************************************************************************************
1443
1444
1445//*************************************************************************************************
1462template< typename MT // Type of the dense matrix
1463 , bool SO > // Storage order
1464inline decltype(auto) conj( const DenseMatrix<MT,SO>& dm )
1465{
1467
1468 return map( *dm, Conj() );
1469}
1470//*************************************************************************************************
1471
1472
1473//*************************************************************************************************
1499template< typename MT // Type of the dense matrix
1500 , bool SO > // Storage order
1501inline decltype(auto) ctrans( const DenseMatrix<MT,SO>& dm )
1502{
1504
1505 return trans( conj( *dm ) );
1506}
1507//*************************************************************************************************
1508
1509
1510//*************************************************************************************************
1527template< typename MT // Type of the dense matrix
1528 , bool SO > // Storage order
1529inline decltype(auto) real( const DenseMatrix<MT,SO>& dm )
1530{
1532
1533 return map( *dm, Real() );
1534}
1535//*************************************************************************************************
1536
1537
1538//*************************************************************************************************
1555template< typename MT // Type of the dense matrix
1556 , bool SO > // Storage order
1557inline decltype(auto) imag( const DenseMatrix<MT,SO>& dm )
1558{
1560
1561 return map( *dm, Imag() );
1562}
1563//*************************************************************************************************
1564
1565
1566//*************************************************************************************************
1583template< typename MT // Type of the dense matrix
1584 , bool SO > // Storage order
1585inline decltype(auto) arg( const DenseMatrix<MT,SO>& dm )
1586{
1588
1589 return map( *dm, Arg() );
1590}
1591//*************************************************************************************************
1592
1593
1594//*************************************************************************************************
1614template< typename MT // Type of the dense matrix
1615 , bool SO > // Storage order
1616inline decltype(auto) sqrt( const DenseMatrix<MT,SO>& dm )
1617{
1619
1620 return map( *dm, Sqrt() );
1621}
1622//*************************************************************************************************
1623
1624
1625//*************************************************************************************************
1645template< typename MT // Type of the dense matrix
1646 , bool SO > // Storage order
1647inline decltype(auto) invsqrt( const DenseMatrix<MT,SO>& dm )
1648{
1650
1651 return map( *dm, InvSqrt() );
1652}
1653//*************************************************************************************************
1654
1655
1656//*************************************************************************************************
1676template< typename MT // Type of the dense matrix
1677 , bool SO > // Storage order
1678inline decltype(auto) cbrt( const DenseMatrix<MT,SO>& dm )
1679{
1681
1682 return map( *dm, Cbrt() );
1683}
1684//*************************************************************************************************
1685
1686
1687//*************************************************************************************************
1707template< typename MT // Type of the dense matrix
1708 , bool SO > // Storage order
1709inline decltype(auto) invcbrt( const DenseMatrix<MT,SO>& dm )
1710{
1712
1713 return map( *dm, InvCbrt() );
1714}
1715//*************************************************************************************************
1716
1717
1718//*************************************************************************************************
1737template< typename MT // Type of the dense matrix
1738 , bool SO // Storage order
1739 , typename DT > // Type of the delimiters
1740inline decltype(auto) clamp( const DenseMatrix<MT,SO>& dm, const DT& min, const DT& max )
1741{
1743
1744 return map( *dm, bind2nd( bind3rd( Clamp(), max ), min ) );
1745}
1746//*************************************************************************************************
1747
1748
1749//*************************************************************************************************
1767template< typename MT // Type of the dense matrix
1768 , bool SO // Storage order
1769 , typename ST // Type of the scalar exponent
1770 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
1771inline decltype(auto) pow( const DenseMatrix<MT,SO>& dm, ST exp )
1772{
1774
1775 using ET = ElementType_t<MT>;
1776 using ScalarType = If_t< IsNumeric_v<ET> && IsNumeric_v<ST>, MultTrait_t<ET,ST>, ST >;
1777 return map( *dm, blaze::bind2nd( Pow(), ScalarType( exp ) ) );
1778}
1779//*************************************************************************************************
1780
1781
1782//*************************************************************************************************
1799template< typename MT // Type of the dense matrix
1800 , bool SO > // Storage order
1801inline decltype(auto) exp( const DenseMatrix<MT,SO>& dm )
1802{
1804
1805 return map( *dm, Exp() );
1806}
1807//*************************************************************************************************
1808
1809
1810//*************************************************************************************************
1827template< typename MT // Type of the dense matrix
1828 , bool SO > // Storage order
1829inline decltype(auto) exp2( const DenseMatrix<MT,SO>& dm )
1830{
1832
1833 return map( *dm, Exp2() );
1834}
1835//*************************************************************************************************
1836
1837
1838//*************************************************************************************************
1855template< typename MT // Type of the dense matrix
1856 , bool SO > // Storage order
1857inline decltype(auto) exp10( const DenseMatrix<MT,SO>& dm )
1858{
1860
1861 return map( *dm, Exp10() );
1862}
1863//*************************************************************************************************
1864
1865
1866//*************************************************************************************************
1886template< typename MT // Type of the dense matrix
1887 , bool SO > // Storage order
1888inline decltype(auto) log( const DenseMatrix<MT,SO>& dm )
1889{
1891
1892 return map( *dm, Log() );
1893}
1894//*************************************************************************************************
1895
1896
1897//*************************************************************************************************
1917template< typename MT // Type of the dense matrix
1918 , bool SO > // Storage order
1919inline decltype(auto) log2( const DenseMatrix<MT,SO>& dm )
1920{
1922
1923 return map( *dm, Log2() );
1924}
1925//*************************************************************************************************
1926
1927
1928//*************************************************************************************************
1948template< typename MT // Type of the dense matrix
1949 , bool SO > // Storage order
1950inline decltype(auto) log10( const DenseMatrix<MT,SO>& dm )
1951{
1953
1954 return map( *dm, Log10() );
1955}
1956//*************************************************************************************************
1957
1958
1959//*************************************************************************************************
1981template< typename MT // Type of the dense matrix
1982 , bool SO > // Storage order
1983inline decltype(auto) log1p( const DenseMatrix<MT,SO>& dm )
1984{
1986
1987 return map( *dm, Log1p() );
1988}
1989//*************************************************************************************************
1990
1991
1992//*************************************************************************************************
2014template< typename MT // Type of the dense matrix
2015 , bool SO > // Storage order
2016inline decltype(auto) lgamma( const DenseMatrix<MT,SO>& dm )
2017{
2019
2020 return map( *dm, LGamma() );
2021}
2022//*************************************************************************************************
2023
2024
2025//*************************************************************************************************
2042template< typename MT // Type of the dense matrix
2043 , bool SO > // Storage order
2044inline decltype(auto) sin( const DenseMatrix<MT,SO>& dm )
2045{
2047
2048 return map( *dm, Sin() );
2049}
2050//*************************************************************************************************
2051
2052
2053//*************************************************************************************************
2073template< typename MT // Type of the dense matrix
2074 , bool SO > // Storage order
2075inline decltype(auto) asin( const DenseMatrix<MT,SO>& dm )
2076{
2078
2079 return map( *dm, Asin() );
2080}
2081//*************************************************************************************************
2082
2083
2084//*************************************************************************************************
2101template< typename MT // Type of the dense matrix
2102 , bool SO > // Storage order
2103inline decltype(auto) sinh( const DenseMatrix<MT,SO>& dm )
2104{
2106
2107 return map( *dm, Sinh() );
2108}
2109//*************************************************************************************************
2110
2111
2112//*************************************************************************************************
2129template< typename MT // Type of the dense matrix
2130 , bool SO > // Storage order
2131inline decltype(auto) asinh( const DenseMatrix<MT,SO>& dm )
2132{
2134
2135 return map( *dm, Asinh() );
2136}
2137//*************************************************************************************************
2138
2139
2140//*************************************************************************************************
2157template< typename MT // Type of the dense matrix
2158 , bool SO > // Storage order
2159inline decltype(auto) cos( const DenseMatrix<MT,SO>& dm )
2160{
2162
2163 return map( *dm, Cos() );
2164}
2165//*************************************************************************************************
2166
2167
2168//*************************************************************************************************
2188template< typename MT // Type of the dense matrix
2189 , bool SO > // Storage order
2190inline decltype(auto) acos( const DenseMatrix<MT,SO>& dm )
2191{
2193
2194 return map( *dm, Acos() );
2195}
2196//*************************************************************************************************
2197
2198
2199//*************************************************************************************************
2216template< typename MT // Type of the dense matrix
2217 , bool SO > // Storage order
2218inline decltype(auto) cosh( const DenseMatrix<MT,SO>& dm )
2219{
2221
2222 return map( *dm, Cosh() );
2223}
2224//*************************************************************************************************
2225
2226
2227//*************************************************************************************************
2247template< typename MT // Type of the dense matrix
2248 , bool SO > // Storage order
2249inline decltype(auto) acosh( const DenseMatrix<MT,SO>& dm )
2250{
2252
2253 return map( *dm, Acosh() );
2254}
2255//*************************************************************************************************
2256
2257
2258//*************************************************************************************************
2275template< typename MT // Type of the dense matrix
2276 , bool SO > // Storage order
2277inline decltype(auto) tan( const DenseMatrix<MT,SO>& dm )
2278{
2280
2281 return map( *dm, Tan() );
2282}
2283//*************************************************************************************************
2284
2285
2286//*************************************************************************************************
2303template< typename MT // Type of the dense matrix
2304 , bool SO > // Storage order
2305inline decltype(auto) atan( const DenseMatrix<MT,SO>& dm )
2306{
2308
2309 return map( *dm, Atan() );
2310}
2311//*************************************************************************************************
2312
2313
2314//*************************************************************************************************
2334template< typename MT // Type of the dense matrix
2335 , bool SO > // Storage order
2336inline decltype(auto) tanh( const DenseMatrix<MT,SO>& dm )
2337{
2339
2340 return map( *dm, Tanh() );
2341}
2342//*************************************************************************************************
2343
2344
2345//*************************************************************************************************
2365template< typename MT // Type of the dense matrix
2366 , bool SO > // Storage order
2367inline decltype(auto) atanh( const DenseMatrix<MT,SO>& dm )
2368{
2370
2371 return map( *dm, Atanh() );
2372}
2373//*************************************************************************************************
2374
2375
2376//*************************************************************************************************
2393template< typename MT // Type of the dense matrix
2394 , bool SO > // Storage order
2395inline decltype(auto) erf( const DenseMatrix<MT,SO>& dm )
2396{
2398
2399 return map( *dm, Erf() );
2400}
2401//*************************************************************************************************
2402
2403
2404//*************************************************************************************************
2421template< typename MT // Type of the dense matrix
2422 , bool SO > // Storage order
2423inline decltype(auto) erfc( const DenseMatrix<MT,SO>& dm )
2424{
2426
2427 return map( *dm, Erfc() );
2428}
2429//*************************************************************************************************
2430
2431
2432
2433
2434//=================================================================================================
2435//
2436// GLOBAL RESTRUCTURING FUNCTIONS
2437//
2438//=================================================================================================
2439
2440//*************************************************************************************************
2451template< typename MT // Type of the dense matrix
2452 , bool SO > // Storage order
2453inline decltype(auto) abs( const DMatMapExpr<MT,Abs,SO>& dm )
2454{
2456
2457 return dm;
2458}
2460//*************************************************************************************************
2461
2462
2463//*************************************************************************************************
2474template< typename MT // Type of the dense matrix
2475 , bool SO > // Storage order
2476inline decltype(auto) sign( const DMatMapExpr<MT,Sign,SO>& dm )
2477{
2479
2480 return dm;
2481}
2483//*************************************************************************************************
2484
2485
2486//*************************************************************************************************
2497template< typename MT // Type of the dense matrix
2498 , bool SO > // Storage order
2499inline decltype(auto) floor( const DMatMapExpr<MT,Floor,SO>& dm )
2500{
2502
2503 return dm;
2504}
2506//*************************************************************************************************
2507
2508
2509//*************************************************************************************************
2520template< typename MT // Type of the dense matrix
2521 , bool SO > // Storage order
2522inline decltype(auto) ceil( const DMatMapExpr<MT,Ceil,SO>& dm )
2523{
2525
2526 return dm;
2527}
2529//*************************************************************************************************
2530
2531
2532//*************************************************************************************************
2543template< typename MT // Type of the dense matrix
2544 , bool SO > // Storage order
2545inline decltype(auto) trunc( const DMatMapExpr<MT,Trunc,SO>& dm )
2546{
2548
2549 return dm;
2550}
2552//*************************************************************************************************
2553
2554
2555//*************************************************************************************************
2566template< typename MT // Type of the dense matrix
2567 , bool SO > // Storage order
2568inline decltype(auto) round( const DMatMapExpr<MT,Round,SO>& dm )
2569{
2571
2572 return dm;
2573}
2575//*************************************************************************************************
2576
2577
2578//*************************************************************************************************
2596template< typename MT // Type of the dense matrix
2597 , bool SO > // Storage order
2598inline decltype(auto) conj( const DMatMapExpr<MT,Conj,SO>& dm )
2599{
2601
2602 return dm.operand();
2603}
2605//*************************************************************************************************
2606
2607
2608//*************************************************************************************************
2626template< typename MT // Type of the dense matrix
2627 , bool SO > // Storage order
2628inline decltype(auto) conj( const DMatTransExpr<DMatMapExpr<MT,Conj,SO>,!SO>& dm )
2629{
2631
2632 return trans( dm.operand().operand() );
2633}
2635//*************************************************************************************************
2636
2637
2638//*************************************************************************************************
2649template< typename MT // Type of the dense matrix
2650 , bool SO > // Storage order
2651inline decltype(auto) real( const DMatMapExpr<MT,Real,SO>& dm )
2652{
2654
2655 return dm;
2656}
2658//*************************************************************************************************
2659
2660
2661
2662
2663//=================================================================================================
2664//
2665// GLOBAL ARITHMETIC OPERATORS
2666//
2667//=================================================================================================
2668
2669//*************************************************************************************************
2690template< typename MT // Type of the left-hand side dense matrix
2691 , bool SO // Storage order of the left-hand side dense matrix
2692 , typename ST // Type of the right-hand side scalar
2693 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
2694inline decltype(auto) operator+( const DenseMatrix<MT,SO>& mat, ST scalar )
2695{
2697
2698 using ET = ElementType_t<MT>;
2699 using ScalarType = If_t< IsNumeric_v<ET> && IsNumeric_v<ST>, AddTrait_t<ET,ST>, ST >;
2700 return map( *mat, blaze::bind2nd( Add{}, ScalarType( scalar ) ) );
2701}
2702//*************************************************************************************************
2703
2704
2705//*************************************************************************************************
2726template< typename ST // Type of the left-hand side scalar
2727 , typename MT // Type of the right-hand side dense matrix
2728 , bool SO // Storage order of the right-hand side dense matrix
2729 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
2730inline decltype(auto) operator+( ST scalar, const DenseMatrix<MT,SO>& mat )
2731{
2733
2734 using ET = ElementType_t<MT>;
2735 using ScalarType = If_t< IsNumeric_v<ST> && IsNumeric_v<ET>, AddTrait_t<ST,ET>, ST >;
2736 return map( *mat, blaze::bind1st( Add{}, ScalarType( scalar ) ) );
2737}
2738//*************************************************************************************************
2739
2740
2741//*************************************************************************************************
2763template< typename MT // Type of the left-hand side dense matrix
2764 , bool SO // Storage order of the left-hand side dense matrix
2765 , typename ST // Type of the right-hand side scalar
2766 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
2767inline decltype(auto) operator-( const DenseMatrix<MT,SO>& mat, ST scalar )
2768{
2770
2771 using ET = ElementType_t<MT>;
2772 using ScalarType = If_t< IsNumeric_v<ET> && IsNumeric_v<ST>, SubTrait_t<ET,ST>, ST >;
2773 return map( *mat, blaze::bind2nd( Sub{}, ScalarType( scalar ) ) );
2774}
2775//*************************************************************************************************
2776
2777
2778//*************************************************************************************************
2800template< typename ST // Type of the left-hand side scalar
2801 , typename MT // Type of the right-hand side dense matrix
2802 , bool SO // Storage order of the right-hand side dense matrix
2803 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
2804inline decltype(auto) operator-( ST scalar, const DenseMatrix<MT,SO>& mat )
2805{
2807
2808 using ET = ElementType_t<MT>;
2809 using ScalarType = If_t< IsNumeric_v<ST> && IsNumeric_v<ET>, SubTrait_t<ST,ET>, ST >;
2810 return map( *mat, blaze::bind1st( Sub{}, ScalarType( scalar ) ) );
2811}
2812//*************************************************************************************************
2813
2814
2815//*************************************************************************************************
2836template< typename ST // Type of the left-hand side scalar
2837 , typename MT // Type of the right-hand side dense matrix
2838 , bool SO // Storage order of the right-hand side dense matrix
2839 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
2840inline decltype(auto) operator/( ST scalar, const DenseMatrix<MT,SO>& mat )
2841{
2843
2844 using ET = ElementType_t<MT>;
2845 using ScalarType = If_t< IsNumeric_v<ST> && IsNumeric_v<ET>, DivTrait_t<ST,ET>, ST >;
2846 return map( *mat, blaze::bind1st( Div{}, ScalarType( scalar ) ) );
2847}
2848//*************************************************************************************************
2849
2850
2851//*************************************************************************************************
2867template< typename MT // Type of the dense matrix
2868 , bool SO > // Transpose flag
2869inline decltype(auto) operator<<( const DenseMatrix<MT,SO>& mat, int count )
2870{
2872
2873 return map( *mat, ShiftLI( count ) );
2874}
2875//*************************************************************************************************
2876
2877
2878//*************************************************************************************************
2894template< typename MT // Type of the dense matrix
2895 , bool SO > // Transpose flag
2896inline decltype(auto) operator>>( const DenseMatrix<MT,SO>& mat, int count )
2897{
2899
2900 return map( *mat, ShiftRI( count ) );
2901}
2902//*************************************************************************************************
2903
2904
2905//*************************************************************************************************
2921template< typename MT // Type of the left-hand side dense matrix
2922 , bool SO // Storage order of the left-hand side dense matrix
2923 , typename ST // Type of the right-hand side scalar
2924 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
2925inline decltype(auto) operator&( const DenseMatrix<MT,SO>& mat, ST scalar )
2926{
2928
2929 return map( *mat, blaze::bind2nd( Bitand{}, scalar ) );
2930}
2931//*************************************************************************************************
2932
2933
2934//*************************************************************************************************
2950template< typename MT // Type of the left-hand side dense matrix
2951 , bool SO // Storage order of the left-hand side dense matrix
2952 , typename ST // Type of the right-hand side scalar
2953 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
2954inline decltype(auto) operator|( const DenseMatrix<MT,SO>& mat, ST scalar )
2955{
2957
2958 return map( *mat, blaze::bind2nd( Bitor{}, scalar ) );
2959}
2960//*************************************************************************************************
2961
2962
2963//*************************************************************************************************
2979template< typename MT // Type of the left-hand side dense matrix
2980 , bool SO // Storage order of the left-hand side dense matrix
2981 , typename ST // Type of the right-hand side scalar
2982 , EnableIf_t< IsScalar_v<ST> >* = nullptr >
2983inline decltype(auto) operator^( const DenseMatrix<MT,SO>& mat, ST scalar )
2984{
2986
2987 return map( *mat, blaze::bind2nd( Bitxor{}, scalar ) );
2988}
2989//*************************************************************************************************
2990
2991
2992
2993
2994//=================================================================================================
2995//
2996// GLOBAL LOGICAL OPERATORS
2997//
2998//=================================================================================================
2999
3000//*************************************************************************************************
3015template< typename MT // Type of the dense matrix
3016 , bool SO > // Storage order of the dense matrix
3017inline decltype(auto) operator!( const DenseMatrix<MT,SO>& mat )
3018{
3020
3021 return map( *mat, Not{} );
3022}
3023//*************************************************************************************************
3024
3025
3026
3027
3028//=================================================================================================
3029//
3030// ISALIGNED SPECIALIZATIONS
3031//
3032//=================================================================================================
3033
3034//*************************************************************************************************
3036template< typename MT, typename OP, bool SO >
3037struct IsAligned< DMatMapExpr<MT,OP,SO> >
3038 : public IsAligned<MT>
3039{};
3041//*************************************************************************************************
3042
3043
3044
3045
3046//=================================================================================================
3047//
3048// ISPADDED SPECIALIZATIONS
3049//
3050//=================================================================================================
3051
3052//*************************************************************************************************
3054template< typename MT, typename OP, bool SO >
3055struct IsPadded< DMatMapExpr<MT,OP,SO> >
3056 : public BoolConstant< IsPadded_v<MT> && IsPaddingEnabled_v<OP> >
3057{};
3059//*************************************************************************************************
3060
3061} // namespace blaze
3062
3063#endif
Header file for the addition trait.
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::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 division trait.
Header file for the EnableIf class template.
Header file for the function trace functionality.
Header file for all functors.
Header file for the HasLoad type trait.
Header file for the HasMember type traits.
Macro for CUDA compatibility.
Header file for the If class template.
Header file for the IntegralConstant class template.
Header file for the IsAligned type trait.
Header file for the IsBuiltin type trait.
Header file for the IsComputation type trait class.
Header file for the IsExpression type trait class.
Header file for the IsNumeric type trait.
Header file for the IsPadded type trait.
Header file for the IsPaddingEnabled type trait.
Header file for the IsSIMDEnabled type trait.
Header file for the IsSame and IsStrictlySame type traits.
Header file for the IsScalar type trait.
Header file for the map trait.
Header file for the multiplication trait.
Header file for all SIMD functionality.
Header file for the subtraction trait.
Header file for the UnderlyingScalar type trait.
Iterator over the elements of the dense matrix map expression.
Definition: DMatMapExpr.h:177
BLAZE_DEVICE_CALLABLE const ConstIterator operator++(int)
Post-increment operator.
Definition: DMatMapExpr.h:249
BLAZE_DEVICE_CALLABLE bool operator<=(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatMapExpr.h:345
PointerType pointer
Pointer return type.
Definition: DMatMapExpr.h:189
BLAZE_DEVICE_CALLABLE ConstIterator & operator-=(size_t dec)
Subtraction assignment operator.
Definition: DMatMapExpr.h:227
ConstIterator_t< MT > IteratorType
ConstIterator type of the dense matrix expression.
Definition: DMatMapExpr.h:194
ElementType & ReferenceType
Reference return type.
Definition: DMatMapExpr.h:183
friend BLAZE_DEVICE_CALLABLE const ConstIterator operator+(const ConstIterator &it, size_t inc)
Addition between a ConstIterator and an integral value.
Definition: DMatMapExpr.h:379
auto load() const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatMapExpr.h:290
ElementType ValueType
Type of the underlying elements.
Definition: DMatMapExpr.h:181
BLAZE_DEVICE_CALLABLE ConstIterator & operator++()
Pre-increment operator.
Definition: DMatMapExpr.h:238
BLAZE_DEVICE_CALLABLE bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DMatMapExpr.h:301
BLAZE_DEVICE_CALLABLE bool operator>=(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatMapExpr.h:356
IteratorType it_
Iterator to the current matrix element.
Definition: DMatMapExpr.h:410
DifferenceType difference_type
Difference between two iterators.
Definition: DMatMapExpr.h:191
BLAZE_DEVICE_CALLABLE bool operator>(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatMapExpr.h:334
std::random_access_iterator_tag IteratorCategory
The iterator category.
Definition: DMatMapExpr.h:180
BLAZE_DEVICE_CALLABLE ConstIterator & operator--()
Pre-decrement operator.
Definition: DMatMapExpr.h:259
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DMatMapExpr.h:184
BLAZE_DEVICE_CALLABLE bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DMatMapExpr.h:312
OP op_
The custom unary operation.
Definition: DMatMapExpr.h:411
friend BLAZE_DEVICE_CALLABLE const ConstIterator operator+(size_t inc, const ConstIterator &it)
Addition between an integral value and a ConstIterator.
Definition: DMatMapExpr.h:391
ElementType * PointerType
Pointer return type.
Definition: DMatMapExpr.h:182
ReferenceType reference
Reference return type.
Definition: DMatMapExpr.h:190
BLAZE_DEVICE_CALLABLE ReturnType operator*() const
Direct access to the element at the current iterator position.
Definition: DMatMapExpr.h:280
BLAZE_DEVICE_CALLABLE ConstIterator & operator+=(size_t inc)
Addition assignment operator.
Definition: DMatMapExpr.h:215
ValueType value_type
Type of the underlying elements.
Definition: DMatMapExpr.h:188
IteratorCategory iterator_category
The iterator category.
Definition: DMatMapExpr.h:187
BLAZE_DEVICE_CALLABLE DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two iterators.
Definition: DMatMapExpr.h:367
BLAZE_DEVICE_CALLABLE bool operator<(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatMapExpr.h:323
BLAZE_DEVICE_CALLABLE ConstIterator(IteratorType it, OP op)
Constructor for the ConstIterator class.
Definition: DMatMapExpr.h:203
friend BLAZE_DEVICE_CALLABLE const ConstIterator operator-(const ConstIterator &it, size_t dec)
Subtraction between a ConstIterator and an integral value.
Definition: DMatMapExpr.h:403
BLAZE_DEVICE_CALLABLE const ConstIterator operator--(int)
Post-decrement operator.
Definition: DMatMapExpr.h:270
Expression object for the dense matrix map() function.
Definition: DMatMapExpr.h:107
ElementType_t< ResultType > ElementType
Resulting element type.
Definition: DMatMapExpr.h:158
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatMapExpr.h:498
MapTrait_t< RT, OP > ResultType
Result type for expression template evaluations.
Definition: DMatMapExpr.h:155
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatMapExpr.h:593
ElementType_t< MT > ET
Element type of the dense matrix expression.
Definition: DMatMapExpr.h:112
Operation operation() const
Returns a copy of the custom operation.
Definition: DMatMapExpr.h:549
ReturnType operator()(size_t i, size_t j) const noexcept
2D-access to the matrix elements.
Definition: DMatMapExpr.h:450
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: DMatMapExpr.h:423
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatMapExpr.h:561
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the map expression.
Definition: DMatMapExpr.h:124
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatMapExpr.h:519
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatMapExpr.h:539
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatMapExpr.h:573
decltype(std::declval< OP >()(std::declval< RN >())) ReturnType
Return type for expression template evaluations.
Definition: DMatMapExpr.h:161
OP Operation
Data type of the custom unary operation.
Definition: DMatMapExpr.h:170
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatMapExpr.h:583
OppositeType_t< MT > OT
Opposite type of the dense matrix expression.
Definition: DMatMapExpr.h:111
Operation op_
The custom unary operation.
Definition: DMatMapExpr.h:601
If_t< IsExpression_v< MT >, const MT, const MT & > Operand
Composite data type of the dense matrix expression.
Definition: DMatMapExpr.h:167
OppositeType_t< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatMapExpr.h:156
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatMapExpr.h:509
ReturnType_t< MT > RN
Return type of the dense matrix expression.
Definition: DMatMapExpr.h:113
BLAZE_ALWAYS_INLINE auto load(size_t i, size_t j) const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatMapExpr.h:483
Operand dm_
Dense matrix of the map expression.
Definition: DMatMapExpr.h:600
If_t< useAssign, const ResultType, const DMatMapExpr & > CompositeType
Data type for composite expression templates.
Definition: DMatMapExpr.h:164
TransposeType_t< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatMapExpr.h:157
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: DMatMapExpr.h:418
static constexpr size_t SIMDSIZE
The number of elements packed within a single SIMD element.
Definition: DMatMapExpr.h:428
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatMapExpr.h:529
DMatMapExpr(const MT &dm, OP op) noexcept
Constructor for the DMatMapExpr class.
Definition: DMatMapExpr.h:437
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatMapExpr.h:465
ResultType_t< MT > RT
Result type of the dense matrix expression.
Definition: DMatMapExpr.h:110
Base class for dense matrices.
Definition: DenseMatrix.h:82
SIMD characteristics of data types.
Definition: SIMDTrait.h:297
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 MatMapExpr base class.
decltype(auto) exp(const DenseMatrix< MT, SO > &dm)
Computes for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1801
decltype(auto) trunc(const DenseMatrix< MT, SO > &dm)
Applies the trunc() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1408
decltype(auto) pow(const DenseMatrix< MT, SO > &dm, ST exp)
Computes the exponential value for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1771
decltype(auto) floor(const DenseMatrix< MT, SO > &dm)
Applies the floor() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1352
decltype(auto) exp2(const DenseMatrix< MT, SO > &dm)
Computes for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1829
decltype(auto) sin(const DenseMatrix< MT, SO > &dm)
Computes the sine for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2044
decltype(auto) cbrt(const DenseMatrix< MT, SO > &dm)
Computes the cubic root of each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1678
decltype(auto) log1p(const DenseMatrix< MT, SO > &dm)
Computes the natural logarithm of x+1 for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1983
decltype(auto) invsqrt(const DenseMatrix< MT, SO > &dm)
Computes the inverse square root of each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1647
decltype(auto) asinh(const DenseMatrix< MT, SO > &dm)
Computes the inverse hyperbolic sine for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2131
decltype(auto) acosh(const DenseMatrix< MT, SO > &dm)
Computes the inverse hyperbolic cosine for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2249
decltype(auto) log(const DenseMatrix< MT, SO > &dm)
Computes the natural logarithm for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1888
decltype(auto) invcbrt(const DenseMatrix< MT, SO > &dm)
Computes the inverse cubic root of each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1709
decltype(auto) real(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the real part of each single element of dm.
Definition: DMatMapExpr.h:1529
decltype(auto) conj(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the complex conjugate of each single element of dm.
Definition: DMatMapExpr.h:1464
decltype(auto) sinh(const DenseMatrix< MT, SO > &dm)
Computes the hyperbolic sine for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2103
decltype(auto) acos(const DenseMatrix< MT, SO > &dm)
Computes the inverse cosine for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2190
decltype(auto) exp10(const DenseMatrix< MT, SO > &dm)
Computes for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1857
decltype(auto) ctrans(const DenseMatrix< MT, SO > &dm)
Returns the conjugate transpose matrix of dm.
Definition: DMatMapExpr.h:1501
decltype(auto) max(ST scalar, const DenseMatrix< MT, SO > &dm)
Computes the componentwise maximum of a scalar and a dense matrix dm.
Definition: DMatMapExpr.h:1266
decltype(auto) atan(const DenseMatrix< MT, SO > &dm)
Computes the inverse tangent for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2305
decltype(auto) tanh(const DenseMatrix< MT, SO > &dm)
Computes the hyperbolic tangent for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2336
decltype(auto) cosh(const DenseMatrix< MT, SO > &dm)
Computes the hyperbolic cosine for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2218
decltype(auto) arg(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the phase angle of each single element of dm.
Definition: DMatMapExpr.h:1585
decltype(auto) log2(const DenseMatrix< MT, SO > &dm)
Computes the binary logarithm for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1919
decltype(auto) forEach(const DenseMatrix< MT, SO > &dm, OP op)
Evaluates the given custom operation on each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1132
decltype(auto) abs(const DenseMatrix< MT, SO > &dm)
Applies the abs() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1296
decltype(auto) ceil(const DenseMatrix< MT, SO > &dm)
Applies the ceil() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1380
decltype(auto) clamp(const DenseMatrix< MT, SO > &dm, const DT &min, const DT &max)
Restricts each single element of the dense matrix dm to the range .
Definition: DMatMapExpr.h:1740
decltype(auto) asin(const DenseMatrix< MT, SO > &dm)
Computes the inverse sine for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2075
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:766
decltype(auto) sign(const DenseMatrix< MT, SO > &dm)
Applies the sign() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1324
decltype(auto) erfc(const DenseMatrix< MT, SO > &dm)
Computes the complementary error function for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2423
decltype(auto) log10(const DenseMatrix< MT, SO > &dm)
Computes the common logarithm for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1950
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:812
decltype(auto) map(const DenseMatrix< MT, SO > &dm, OP op)
Evaluates the given custom operation on each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1101
decltype(auto) round(const DenseMatrix< MT, SO > &dm)
Applies the round() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1436
decltype(auto) atanh(const DenseMatrix< MT, SO > &dm)
Computes the inverse hyperbolic tangent for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2367
decltype(auto) cos(const DenseMatrix< MT, SO > &dm)
Computes the cosine for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2159
decltype(auto) erf(const DenseMatrix< MT, SO > &dm)
Computes the error function for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2395
decltype(auto) lgamma(const DenseMatrix< MT, SO > &dm)
Computes the natural logarithm of the absolute value of the gamma function for each single element of...
Definition: DMatMapExpr.h:2016
decltype(auto) imag(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the imaginary part of each single element of dm.
Definition: DMatMapExpr.h:1557
decltype(auto) tan(const DenseMatrix< MT, SO > &dm)
Computes the tangent for each single element of the dense matrix dm.
Definition: DMatMapExpr.h:2277
decltype(auto) sqrt(const DenseMatrix< MT, SO > &dm)
Computes the square root of each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1616
decltype(auto) min(ST scalar, const DenseMatrix< MT, SO > &dm)
Computes the componentwise minimum of a scalar and a dense matrix dm.
Definition: DMatMapExpr.h:1198
constexpr Bind1st< OP, A1 > bind1st(const OP &op, const A1 &a1)
Binds the given object/value to the 1st parameter of the given operation.
Definition: Bind1st.h:153
constexpr Bind3rd< OP, A3 > bind3rd(const OP &op, const A3 &a3)
Binds the given object/value to the 3rd parameter of the given operation.
Definition: Bind3rd.h:157
constexpr Bind2nd< OP, A2 > bind2nd(const OP &op, const A2 &a2)
Binds the given object/value to the 2nd parameter of the given operation.
Definition: Bind2nd.h:155
#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
typename DivTrait< T1, T2 >::Type DivTrait_t
Auxiliary alias declaration for the DivTrait class template.
Definition: DivTrait.h:164
typename MapTrait< Args... >::Type MapTrait_t
Auxiliary alias declaration for the MapTrait class template.
Definition: MapTrait.h:131
typename AddTrait< T1, T2 >::Type AddTrait_t
Auxiliary alias declaration for the AddTrait class template.
Definition: AddTrait.h:163
typename SubTrait< T1, T2 >::Type SubTrait_t
Auxiliary alias declaration for the SubTrait class template.
Definition: SubTrait.h:163
typename MultTrait< T1, T2 >::Type MultTrait_t
Auxiliary alias declaration for the MultTrait class template.
Definition: MultTrait.h:165
typename UnderlyingScalar< T >::Type UnderlyingScalar_t
Auxiliary alias declaration for the UnderlyingScalar type trait.
Definition: UnderlyingScalar.h:116
#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
#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
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.
Definition: IntegralConstant.h:110
#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 the abs() function.
Definition: Abs.h:85
Generic wrapper for the acos() function.
Definition: Acos.h:71
Generic wrapper for the acosh() function.
Definition: Acosh.h:71
Generic wrapper for the addition operator.
Definition: Add.h:85
Generic wrapper for the arg() function.
Definition: Arg.h:77
Generic wrapper for the asin() function.
Definition: Asin.h:81
Generic wrapper for the asinh() function.
Definition: Asinh.h:81
Generic wrapper for the atan() function.
Definition: Atan.h:81
Generic wrapper for the atanh() function.
Definition: Atanh.h:81
Generic wrapper for the bitwise AND ('&') operator.
Definition: Bitand.h:82
Generic wrapper for the bitwise OR ('|') operator.
Definition: Bitor.h:82
Generic wrapper for the bitwise XOR ('^') operator.
Definition: Bitxor.h:68
Generic wrapper for the cbrt() function.
Definition: Cbrt.h:83
Generic wrapper for the ceil() function.
Definition: Ceil.h:83
Generic wrapper for the clamp() function.
Definition: Clamp.h:68
Base class for all compute expression templates.
Definition: Computation.h:68
Generic wrapper for the conj() function.
Definition: Conj.h:85
Generic wrapper for the cos() function.
Definition: Cos.h:71
Generic wrapper for the cosh() function.
Definition: Cosh.h:71
Generic wrapper for the division operator.
Definition: Div.h:81
Generic wrapper for the erf() function.
Definition: Erf.h:79
Generic wrapper for the erfc() function.
Definition: Erfc.h:69
Generic wrapper for the exp10() function.
Definition: Exp10.h:69
Generic wrapper for the exp2() function.
Definition: Exp2.h:69
Generic wrapper for the exp() function.
Definition: Exp.h:71
Generic wrapper for the floor() function.
Definition: Floor.h:83
Generic wrapper for the imag() function.
Definition: Imag.h:76
Generic wrapper for the invcbrt() function.
Definition: InvCbrt.h:69
Generic wrapper for the invsqrt() function.
Definition: InvSqrt.h:71
Generic wrapper for the lgamma() function.
Definition: LGamma.h:71
Generic wrapper for the log10() function.
Definition: Log10.h:71
Generic wrapper for the log1p() function.
Definition: Log1p.h:71
Generic wrapper for the log2() function.
Definition: Log2.h:69
Generic wrapper for the log() function.
Definition: Log.h:71
Base class for all unary matrix map expression templates.
Definition: MatMapExpr.h:68
Generic wrapper for the max() function.
Definition: Max.h:82
Generic wrapper for the min() function.
Definition: Min.h:82
Generic wrapper for the logical NOT operator.
Definition: Not.h:60
Generic wrapper for the pow() function.
Definition: Pow.h:65
Generic wrapper for the real() function.
Definition: Real.h:82
Generic wrapper for the round() function.
Definition: Round.h:83
Generic wrapper for the uniform left-shift operation.
Definition: ShiftLI.h:78
Generic wrapper for the uniform right-shift operation.
Definition: ShiftRI.h:77
Generic wrapper for the sign() function.
Definition: Sign.h:83
Generic wrapper for the sin() function.
Definition: Sin.h:81
Generic wrapper for the sinh() function.
Definition: Sinh.h:81
Generic wrapper for the sqrt() function.
Definition: Sqrt.h:85
Generic wrapper for the subtraction operator.
Definition: Sub.h:85
Generic wrapper for the tan() function.
Definition: Tan.h:81
Generic wrapper for the tanh() function.
Definition: Tanh.h:81
Generic wrapper for the trunc() function.
Definition: Trunc.h:83
System settings for the inline keywords.
Header file for the RequiresEvaluation type trait.
Header file for basic type definitions.