DMatForEachExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATFOREACHEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATFOREACHEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <iterator>
44 #include <utility>
45 #include <blaze/math/Aliases.h>
48 #include <blaze/math/Exception.h>
53 #include <blaze/math/Functors.h>
55 #include <blaze/math/SIMD.h>
78 #include <blaze/system/Inline.h>
79 #include <blaze/util/Assert.h>
82 #include <blaze/util/EnableIf.h>
85 #include <blaze/util/mpl/And.h>
86 #include <blaze/util/mpl/If.h>
87 #include <blaze/util/mpl/Not.h>
88 #include <blaze/util/Template.h>
89 #include <blaze/util/Types.h>
93 
94 
95 namespace blaze {
96 
97 //=================================================================================================
98 //
99 // CLASS DMATFOREACHEXPR
100 //
101 //=================================================================================================
102 
103 //*************************************************************************************************
110 template< typename MT // Type of the dense matrix
111  , typename OP // Type of the custom operation
112  , bool SO > // Storage order
113 class DMatForEachExpr : public DenseMatrix< DMatForEachExpr<MT,OP,SO>, SO >
114  , private MatForEachExpr
115  , private Computation
116 {
117  private:
118  //**Type definitions****************************************************************************
119  typedef ResultType_<MT> RT;
122  typedef ReturnType_<MT> RN;
123 
125  BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT( HasSIMDEnabled, simdEnabled );
126 
129  //**********************************************************************************************
130 
131  //**Serial evaluation strategy******************************************************************
133 
139  enum : bool { useAssign = RequiresEvaluation<MT>::value };
140 
142  template< typename MT2 >
144  struct UseAssign {
145  enum : bool { value = useAssign };
146  };
148  //**********************************************************************************************
149 
150  //**Parallel evaluation strategy****************************************************************
152 
158  template< typename MT2 >
159  struct UseSMPAssign {
160  enum : bool { value = ( !MT2::smpAssignable || !MT::smpAssignable ) && useAssign };
161  };
163  //**********************************************************************************************
164 
165  //**SIMD support detection**********************************************************************
167  struct UseSIMDEnabledFlag {
169  enum : bool { value = OP::BLAZE_TEMPLATE simdEnabled<ET>() };
170  };
172  //**********************************************************************************************
173 
174  public:
175  //**Type definitions****************************************************************************
181 
183  typedef decltype( std::declval<OP>()( std::declval<RN>() ) ) ReturnType;
184 
186  typedef IfTrue_< useAssign, const ResultType, const DMatForEachExpr& > CompositeType;
187 
189  typedef If_< IsExpression<MT>, const MT, const MT& > Operand;
190 
192  typedef OP Operation;
193  //**********************************************************************************************
194 
195  //**ConstIterator class definition**************************************************************
199  {
200  public:
201  //**Type definitions*************************************************************************
202  typedef std::random_access_iterator_tag IteratorCategory;
203  typedef ElementType ValueType;
204  typedef ElementType* PointerType;
205  typedef ElementType& ReferenceType;
207 
208  // STL iterator requirements
209  typedef IteratorCategory iterator_category;
210  typedef ValueType value_type;
211  typedef PointerType pointer;
212  typedef ReferenceType reference;
213  typedef DifferenceType difference_type;
214 
217  //*******************************************************************************************
218 
219  //**Constructor******************************************************************************
225  explicit inline ConstIterator( IteratorType it, OP op )
226  : it_( it ) // Iterator to the current matrix element
227  , op_( op ) // The custom unary operation
228  {}
229  //*******************************************************************************************
230 
231  //**Addition assignment operator*************************************************************
237  inline ConstIterator& operator+=( size_t inc ) {
238  it_ += inc;
239  return *this;
240  }
241  //*******************************************************************************************
242 
243  //**Subtraction assignment operator**********************************************************
249  inline ConstIterator& operator-=( size_t dec ) {
250  it_ -= dec;
251  return *this;
252  }
253  //*******************************************************************************************
254 
255  //**Prefix increment operator****************************************************************
260  inline ConstIterator& operator++() {
261  ++it_;
262  return *this;
263  }
264  //*******************************************************************************************
265 
266  //**Postfix increment operator***************************************************************
271  inline const ConstIterator operator++( int ) {
272  return ConstIterator( it_++, op_ );
273  }
274  //*******************************************************************************************
275 
276  //**Prefix decrement operator****************************************************************
281  inline ConstIterator& operator--() {
282  --it_;
283  return *this;
284  }
285  //*******************************************************************************************
286 
287  //**Postfix decrement operator***************************************************************
292  inline const ConstIterator operator--( int ) {
293  return ConstIterator( it_--, op_ );
294  }
295  //*******************************************************************************************
296 
297  //**Element access operator******************************************************************
302  inline ReturnType operator*() const {
303  return op_( *it_ );
304  }
305  //*******************************************************************************************
306 
307  //**Load function****************************************************************************
312  inline auto load() const noexcept {
313  return op_.load( it_.load() );
314  }
315  //*******************************************************************************************
316 
317  //**Equality operator************************************************************************
323  inline bool operator==( const ConstIterator& rhs ) const {
324  return it_ == rhs.it_;
325  }
326  //*******************************************************************************************
327 
328  //**Inequality operator**********************************************************************
334  inline bool operator!=( const ConstIterator& rhs ) const {
335  return it_ != rhs.it_;
336  }
337  //*******************************************************************************************
338 
339  //**Less-than operator***********************************************************************
345  inline bool operator<( const ConstIterator& rhs ) const {
346  return it_ < rhs.it_;
347  }
348  //*******************************************************************************************
349 
350  //**Greater-than operator********************************************************************
356  inline bool operator>( const ConstIterator& rhs ) const {
357  return it_ > rhs.it_;
358  }
359  //*******************************************************************************************
360 
361  //**Less-or-equal-than operator**************************************************************
367  inline bool operator<=( const ConstIterator& rhs ) const {
368  return it_ <= rhs.it_;
369  }
370  //*******************************************************************************************
371 
372  //**Greater-or-equal-than operator***********************************************************
378  inline bool operator>=( const ConstIterator& rhs ) const {
379  return it_ >= rhs.it_;
380  }
381  //*******************************************************************************************
382 
383  //**Subtraction operator*********************************************************************
389  inline DifferenceType operator-( const ConstIterator& rhs ) const {
390  return it_ - rhs.it_;
391  }
392  //*******************************************************************************************
393 
394  //**Addition operator************************************************************************
401  friend inline const ConstIterator operator+( const ConstIterator& it, size_t inc ) {
402  return ConstIterator( it.it_ + inc, it.op_ );
403  }
404  //*******************************************************************************************
405 
406  //**Addition operator************************************************************************
413  friend inline const ConstIterator operator+( size_t inc, const ConstIterator& it ) {
414  return ConstIterator( it.it_ + inc, it.op_ );
415  }
416  //*******************************************************************************************
417 
418  //**Subtraction operator*********************************************************************
425  friend inline const ConstIterator operator-( const ConstIterator& it, size_t dec ) {
426  return ConstIterator( it.it_ - dec, it.op_ );
427  }
428  //*******************************************************************************************
429 
430  private:
431  //**Member variables*************************************************************************
432  IteratorType it_;
433  OP op_;
434  //*******************************************************************************************
435  };
436  //**********************************************************************************************
437 
438  //**Compilation flags***************************************************************************
440  enum : bool { simdEnabled = MT::simdEnabled &&
441  If_< HasSIMDEnabled<OP>, UseSIMDEnabledFlag, HasLoad<OP> >::value };
442 
444  enum : bool { smpAssignable = MT::smpAssignable };
445  //**********************************************************************************************
446 
447  //**SIMD properties*****************************************************************************
449  enum : size_t { SIMDSIZE = SIMDTrait<ElementType>::size };
450  //**********************************************************************************************
451 
452  //**Constructor*********************************************************************************
458  explicit inline DMatForEachExpr( const MT& dm, OP op ) noexcept
459  : dm_( dm ) // Dense matrix of the for-each expression
460  , op_( op ) // The custom unary operation
461  {}
462  //**********************************************************************************************
463 
464  //**Access operator*****************************************************************************
471  inline ReturnType operator()( size_t i, size_t j ) const noexcept {
472  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
473  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
474  return op_( dm_(i,j) );
475  }
476  //**********************************************************************************************
477 
478  //**At function*********************************************************************************
486  inline ReturnType at( size_t i, size_t j ) const {
487  if( i >= dm_.rows() ) {
488  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
489  }
490  if( j >= dm_.columns() ) {
491  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
492  }
493  return (*this)(i,j);
494  }
495  //**********************************************************************************************
496 
497  //**Load function*******************************************************************************
504  BLAZE_ALWAYS_INLINE auto load( size_t i, size_t j ) const noexcept {
505  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
506  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
507  BLAZE_INTERNAL_ASSERT( !SO || ( i % SIMDSIZE == 0UL ), "Invalid row access index" );
508  BLAZE_INTERNAL_ASSERT( SO || ( j % SIMDSIZE == 0UL ), "Invalid column access index" );
509  return op_.load( dm_.load(i,j) );
510  }
511  //**********************************************************************************************
512 
513  //**Begin function******************************************************************************
519  inline ConstIterator begin( size_t i ) const {
520  return ConstIterator( dm_.begin(i), op_ );
521  }
522  //**********************************************************************************************
523 
524  //**End function********************************************************************************
530  inline ConstIterator end( size_t i ) const {
531  return ConstIterator( dm_.end(i), op_ );
532  }
533  //**********************************************************************************************
534 
535  //**Rows function*******************************************************************************
540  inline size_t rows() const noexcept {
541  return dm_.rows();
542  }
543  //**********************************************************************************************
544 
545  //**Columns function****************************************************************************
550  inline size_t columns() const noexcept {
551  return dm_.columns();
552  }
553  //**********************************************************************************************
554 
555  //**Operand access******************************************************************************
560  inline Operand operand() const noexcept {
561  return dm_;
562  }
563  //**********************************************************************************************
564 
565  //**Operation access****************************************************************************
570  inline Operation operation() const {
571  return op_;
572  }
573  //**********************************************************************************************
574 
575  //**********************************************************************************************
581  template< typename T >
582  inline bool canAlias( const T* alias ) const noexcept {
583  return IsComputation<MT>::value && dm_.canAlias( alias );
584  }
585  //**********************************************************************************************
586 
587  //**********************************************************************************************
593  template< typename T >
594  inline bool isAliased( const T* alias ) const noexcept {
595  return dm_.isAliased( alias );
596  }
597  //**********************************************************************************************
598 
599  //**********************************************************************************************
604  inline bool isAligned() const noexcept {
605  return dm_.isAligned();
606  }
607  //**********************************************************************************************
608 
609  //**********************************************************************************************
614  inline bool canSMPAssign() const noexcept {
615  return dm_.canSMPAssign();
616  }
617  //**********************************************************************************************
618 
619  private:
620  //**Member variables****************************************************************************
623  //**********************************************************************************************
624 
625  //**Assignment to dense matrices****************************************************************
640  template< typename MT2 // Type of the target dense matrix
641  , bool SO2 > // Storage order or the target dense matrix
642  friend inline EnableIf_< And< UseAssign<MT2>
644  assign( DenseMatrix<MT2,SO2>& lhs, const DMatForEachExpr& rhs )
645  {
647 
648  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
649  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
650 
651  assign( ~lhs, rhs.dm_ );
652  assign( ~lhs, rhs.op_( ~lhs ) );
653  }
655  //**********************************************************************************************
656 
657  //**Assignment to dense matrices****************************************************************
672  template< typename MT2 // Type of the target dense matrix
673  , bool SO2 > // Storage order or the target dense matrix
674  friend inline EnableIf_< And< UseAssign<MT2>
676  assign( DenseMatrix<MT2,SO2>& lhs, const DMatForEachExpr& rhs )
677  {
679 
683 
684  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
685  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
686 
687  const RT tmp( serial( rhs.dm_ ) );
688  assign( ~lhs, forEach( tmp, rhs.op_ ) );
689  }
691  //**********************************************************************************************
692 
693  //**Assignment to sparse matrices***************************************************************
707  template< typename MT2 // Type of the target sparse matrix
708  , bool SO2 > // Storage order or the target sparse matrix
709  friend inline EnableIf_< UseAssign<MT2> >
710  assign( SparseMatrix<MT2,SO2>& lhs, const DMatForEachExpr& rhs )
711  {
713 
714  typedef IfTrue_< SO == SO2, RT, OT > TmpType;
715 
722 
723  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
724  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
725 
726  const TmpType tmp( serial( rhs.dm_ ) );
727  assign( ~lhs, rhs.op_( tmp ) );
728  }
730  //**********************************************************************************************
731 
732  //**Addition assignment to dense matrices*******************************************************
746  template< typename MT2 // Type of the target dense matrix
747  , bool SO2 > // Storage order of the target dense matrix
748  friend inline EnableIf_< UseAssign<MT2> >
749  addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatForEachExpr& rhs )
750  {
752 
756 
757  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
758  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
759 
760  const RT tmp( serial( rhs.dm_ ) );
761  addAssign( ~lhs, forEach( tmp, rhs.op_ ) );
762  }
764  //**********************************************************************************************
765 
766  //**Addition assignment to sparse matrices******************************************************
767  // No special implementation for the addition assignment to sparse matrices.
768  //**********************************************************************************************
769 
770  //**Subtraction assignment to dense matrices****************************************************
784  template< typename MT2 // Type of the target dense matrix
785  , bool SO2 > // Storage order of the target dense matrix
786  friend inline EnableIf_< UseAssign<MT2> >
787  subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatForEachExpr& rhs )
788  {
790 
794 
795  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
796  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
797 
798  const RT tmp( serial( rhs.dm_ ) );
799  subAssign( ~lhs, forEach( tmp, rhs.op_ ) );
800  }
802  //**********************************************************************************************
803 
804  //**Subtraction assignment to sparse matrices***************************************************
805  // No special implementation for the subtraction assignment to sparse matrices.
806  //**********************************************************************************************
807 
808  //**Multiplication assignment to dense matrices*************************************************
809  // No special implementation for the multiplication assignment to dense matrices.
810  //**********************************************************************************************
811 
812  //**Multiplication assignment to sparse matrices************************************************
813  // No special implementation for the multiplication assignment to sparse matrices.
814  //**********************************************************************************************
815 
816  //**SMP assignment to dense matrices************************************************************
831  template< typename MT2 // Type of the target dense matrix
832  , bool SO2 > // Storage order or the target dense matrix
834  , IsSame< UnderlyingNumeric<MT>, UnderlyingNumeric<MT2> > > >
836  {
838 
839  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
840  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
841 
842  smpAssign( ~lhs, rhs.dm_ );
843  smpAssign( ~lhs, rhs.op_( ~lhs ) );
844  }
846  //**********************************************************************************************
847 
848  //**SMP assignment to dense matrices************************************************************
863  template< typename MT2 // Type of the target dense matrix
864  , bool SO2 > // Storage order or the target dense matrix
865  friend inline EnableIf_< And< UseSMPAssign<MT2>
866  , Not< IsSame< UnderlyingNumeric<MT>, UnderlyingNumeric<MT2> > > > >
868  {
870 
874 
875  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
876  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
877 
878  const RT tmp( rhs.dm_ );
879  smpAssign( ~lhs, forEach( tmp, rhs.op_ ) );
880  }
882  //**********************************************************************************************
883 
884  //**SMP assignment to sparse matrices***********************************************************
898  template< typename MT2 // Type of the target sparse matrix
899  , bool SO2 > // Storage order or the target sparse matrix
900  friend inline EnableIf_< UseSMPAssign<MT2> >
902  {
904 
905  typedef IfTrue_< SO == SO2, RT, OT > TmpType;
906 
913 
914  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
915  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
916 
917  const TmpType tmp( rhs.dm_ );
918  smpAssign( ~lhs, rhs.op_( tmp ) );
919  }
921  //**********************************************************************************************
922 
923  //**SMP addition assignment to dense matrices***************************************************
937  template< typename MT2 // Type of the target dense matrix
938  , bool SO2 > // Storage order of the target dense matrix
939  friend inline EnableIf_< UseSMPAssign<MT2> >
941  {
943 
947 
948  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
949  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
950 
951  const RT tmp( rhs.dm_ );
952  smpAddAssign( ~lhs, forEach( tmp, rhs.op_ ) );
953  }
955  //**********************************************************************************************
956 
957  //**SMP addition assignment to sparse matrices**************************************************
958  // No special implementation for the SMP addition assignment to sparse matrices.
959  //**********************************************************************************************
960 
961  //**SMP subtraction assignment to dense matrices************************************************
975  template< typename MT2 // Type of the target dense matrix
976  , bool SO2 > // Storage order of the target dense matrix
977  friend inline EnableIf_< UseSMPAssign<MT2> >
979  {
981 
985 
986  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
987  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
988 
989  const RT tmp( rhs.dm_ );
990  smpSubAssign( ~lhs, forEach( tmp, rhs.op_ ) );
991  }
993  //**********************************************************************************************
994 
995  //**SMP subtraction assignment to sparse matrices***********************************************
996  // No special implementation for the SMP subtraction assignment to sparse matrices.
997  //**********************************************************************************************
998 
999  //**SMP multiplication assignment to dense matrices*********************************************
1000  // No special implementation for the SMP multiplication assignment to dense matrices.
1001  //**********************************************************************************************
1002 
1003  //**SMP multiplication assignment to sparse matrices********************************************
1004  // No special implementation for the SMP multiplication assignment to sparse matrices.
1005  //**********************************************************************************************
1006 
1007  //**Compile time checks*************************************************************************
1012  //**********************************************************************************************
1013 };
1014 //*************************************************************************************************
1015 
1016 
1017 
1018 
1019 //=================================================================================================
1020 //
1021 // GLOBAL FUNCTIONS
1022 //
1023 //=================================================================================================
1024 
1025 //*************************************************************************************************
1043 template< typename MT // Type of the dense matrix
1044  , bool SO // Storage order
1045  , typename OP > // Type of the custom operation
1046 inline const DMatForEachExpr<MT,OP,SO> forEach( const DenseMatrix<MT,SO>& dm, OP op )
1047 {
1049 
1050  return DMatForEachExpr<MT,OP,SO>( ~dm, op );
1051 }
1052 //*************************************************************************************************
1053 
1054 
1055 //*************************************************************************************************
1072 template< typename MT // Type of the dense matrix
1073  , bool SO > // Storage order
1075 {
1077 
1078  return DMatForEachExpr<MT,Abs,SO>( ~dm, Abs() );
1079 }
1080 //*************************************************************************************************
1081 
1082 
1083 //*************************************************************************************************
1100 template< typename MT // Type of the dense matrix
1101  , bool SO > // Storage order
1103 {
1105 
1106  return DMatForEachExpr<MT,Floor,SO>( ~dm, Floor() );
1107 }
1108 //*************************************************************************************************
1109 
1110 
1111 //*************************************************************************************************
1128 template< typename MT // Type of the dense matrix
1129  , bool SO > // Storage order
1131 {
1133 
1134  return DMatForEachExpr<MT,Ceil,SO>( ~dm, Ceil() );
1135 }
1136 //*************************************************************************************************
1137 
1138 
1139 //*************************************************************************************************
1156 template< typename MT // Type of the dense matrix
1157  , bool SO > // Storage order
1159 {
1161 
1162  return DMatForEachExpr<MT,Trunc,SO>( ~dm, Trunc() );
1163 }
1164 //*************************************************************************************************
1165 
1166 
1167 //*************************************************************************************************
1184 template< typename MT // Type of the dense matrix
1185  , bool SO > // Storage order
1187 {
1189 
1190  return DMatForEachExpr<MT,Round,SO>( ~dm, Round() );
1191 }
1192 //*************************************************************************************************
1193 
1194 
1195 //*************************************************************************************************
1212 template< typename MT // Type of the dense matrix
1213  , bool SO > // Storage order
1215 {
1217 
1218  return DMatForEachExpr<MT,Conj,SO>( ~dm, Conj() );
1219 }
1220 //*************************************************************************************************
1221 
1222 
1223 //*************************************************************************************************
1249 template< typename MT // Type of the dense matrix
1250  , bool SO > // Storage order
1252 {
1254 
1255  return trans( conj( ~dm ) );
1256 }
1257 //*************************************************************************************************
1258 
1259 
1260 //*************************************************************************************************
1277 template< typename MT // Type of the dense matrix
1278  , bool SO > // Storage order
1280 {
1282 
1283  return DMatForEachExpr<MT,Real,SO>( ~dm, Real() );
1284 }
1285 //*************************************************************************************************
1286 
1287 
1288 //*************************************************************************************************
1305 template< typename MT // Type of the dense matrix
1306  , bool SO > // Storage order
1308 {
1310 
1311  return DMatForEachExpr<MT,Imag,SO>( ~dm, Imag() );
1312 }
1313 //*************************************************************************************************
1314 
1315 
1316 //*************************************************************************************************
1336 template< typename MT // Type of the dense matrix
1337  , bool SO > // Storage order
1339 {
1341 
1342  return DMatForEachExpr<MT,Sqrt,SO>( ~dm, Sqrt() );
1343 }
1344 //*************************************************************************************************
1345 
1346 
1347 //*************************************************************************************************
1367 template< typename MT // Type of the dense matrix
1368  , bool SO > // Storage order
1370 {
1372 
1373  return DMatForEachExpr<MT,InvSqrt,SO>( ~dm, InvSqrt() );
1374 }
1375 //*************************************************************************************************
1376 
1377 
1378 //*************************************************************************************************
1398 template< typename MT // Type of the dense matrix
1399  , bool SO > // Storage order
1401 {
1403 
1404  return DMatForEachExpr<MT,Cbrt,SO>( ~dm, Cbrt() );
1405 }
1406 //*************************************************************************************************
1407 
1408 
1409 //*************************************************************************************************
1429 template< typename MT // Type of the dense matrix
1430  , bool SO > // Storage order
1432 {
1434 
1435  return DMatForEachExpr<MT,InvCbrt,SO>( ~dm, InvCbrt() );
1436 }
1437 //*************************************************************************************************
1438 
1439 
1440 //*************************************************************************************************
1459 template< typename MT // Type of the dense matrix
1460  , bool SO // Storage order
1461  , typename DT > // Type of the delimiters
1462 inline const DMatForEachExpr<MT,Clamp<DT>,SO>
1463  clamp( const DenseMatrix<MT,SO>& dm, const DT& min, const DT& max )
1464 {
1466 
1467  return DMatForEachExpr<MT,Clamp<DT>,SO>( ~dm, Clamp<DT>( min, max ) );
1468 }
1469 //*************************************************************************************************
1470 
1471 
1472 //*************************************************************************************************
1490 template< typename MT // Type of the dense matrix
1491  , bool SO // Storage order
1492  , typename ET > // Type of the exponent
1493 inline const DMatForEachExpr<MT,Pow<ET>,SO> pow( const DenseMatrix<MT,SO>& dm, ET exp )
1494 {
1496 
1498 
1499  return DMatForEachExpr<MT,Pow<ET>,SO>( ~dm, Pow<ET>( exp ) );
1500 }
1501 //*************************************************************************************************
1502 
1503 
1504 //*************************************************************************************************
1521 template< typename MT // Type of the dense matrix
1522  , bool SO > // Storage order
1524 {
1526 
1527  return DMatForEachExpr<MT,Exp,SO>( ~dm, Exp() );
1528 }
1529 //*************************************************************************************************
1530 
1531 
1532 //*************************************************************************************************
1549 template< typename MT // Type of the dense matrix
1550  , bool SO > // Storage order
1552 {
1554 
1555  return DMatForEachExpr<MT,Exp2,SO>( ~dm, Exp2() );
1556 }
1557 //*************************************************************************************************
1558 
1559 
1560 //*************************************************************************************************
1577 template< typename MT // Type of the dense matrix
1578  , bool SO > // Storage order
1580 {
1582 
1583  return DMatForEachExpr<MT,Exp10,SO>( ~dm, Exp10() );
1584 }
1585 //*************************************************************************************************
1586 
1587 
1588 //*************************************************************************************************
1608 template< typename MT // Type of the dense matrix
1609  , bool SO > // Storage order
1611 {
1613 
1614  return DMatForEachExpr<MT,Log,SO>( ~dm, Log() );
1615 }
1616 //*************************************************************************************************
1617 
1618 
1619 //*************************************************************************************************
1639 template< typename MT // Type of the dense matrix
1640  , bool SO > // Storage order
1642 {
1644 
1645  return DMatForEachExpr<MT,Log2,SO>( ~dm, Log2() );
1646 }
1647 //*************************************************************************************************
1648 
1649 
1650 //*************************************************************************************************
1670 template< typename MT // Type of the dense matrix
1671  , bool SO > // Storage order
1673 {
1675 
1676  return DMatForEachExpr<MT,Log10,SO>( ~dm, Log10() );
1677 }
1678 //*************************************************************************************************
1679 
1680 
1681 //*************************************************************************************************
1698 template< typename MT // Type of the dense matrix
1699  , bool SO > // Storage order
1701 {
1703 
1704  return DMatForEachExpr<MT,Sin,SO>( ~dm, Sin() );
1705 }
1706 //*************************************************************************************************
1707 
1708 
1709 //*************************************************************************************************
1729 template< typename MT // Type of the dense matrix
1730  , bool SO > // Storage order
1732 {
1734 
1735  return DMatForEachExpr<MT,Asin,SO>( ~dm, Asin() );
1736 }
1737 //*************************************************************************************************
1738 
1739 
1740 //*************************************************************************************************
1757 template< typename MT // Type of the dense matrix
1758  , bool SO > // Storage order
1760 {
1762 
1763  return DMatForEachExpr<MT,Sinh,SO>( ~dm, Sinh() );
1764 }
1765 //*************************************************************************************************
1766 
1767 
1768 //*************************************************************************************************
1785 template< typename MT // Type of the dense matrix
1786  , bool SO > // Storage order
1788 {
1790 
1791  return DMatForEachExpr<MT,Asinh,SO>( ~dm, Asinh() );
1792 }
1793 //*************************************************************************************************
1794 
1795 
1796 //*************************************************************************************************
1813 template< typename MT // Type of the dense matrix
1814  , bool SO > // Storage order
1816 {
1818 
1819  return DMatForEachExpr<MT,Cos,SO>( ~dm, Cos() );
1820 }
1821 //*************************************************************************************************
1822 
1823 
1824 //*************************************************************************************************
1844 template< typename MT // Type of the dense matrix
1845  , bool SO > // Storage order
1847 {
1849 
1850  return DMatForEachExpr<MT,Acos,SO>( ~dm, Acos() );
1851 }
1852 //*************************************************************************************************
1853 
1854 
1855 //*************************************************************************************************
1872 template< typename MT // Type of the dense matrix
1873  , bool SO > // Storage order
1875 {
1877 
1878  return DMatForEachExpr<MT,Cosh,SO>( ~dm, Cosh() );
1879 }
1880 //*************************************************************************************************
1881 
1882 
1883 //*************************************************************************************************
1903 template< typename MT // Type of the dense matrix
1904  , bool SO > // Storage order
1906 {
1908 
1909  return DMatForEachExpr<MT,Acosh,SO>( ~dm, Acosh() );
1910 }
1911 //*************************************************************************************************
1912 
1913 
1914 //*************************************************************************************************
1931 template< typename MT // Type of the dense matrix
1932  , bool SO > // Storage order
1934 {
1936 
1937  return DMatForEachExpr<MT,Tan,SO>( ~dm, Tan() );
1938 }
1939 //*************************************************************************************************
1940 
1941 
1942 //*************************************************************************************************
1959 template< typename MT // Type of the dense matrix
1960  , bool SO > // Storage order
1962 {
1964 
1965  return DMatForEachExpr<MT,Atan,SO>( ~dm, Atan() );
1966 }
1967 //*************************************************************************************************
1968 
1969 
1970 //*************************************************************************************************
1990 template< typename MT // Type of the dense matrix
1991  , bool SO > // Storage order
1993 {
1995 
1996  return DMatForEachExpr<MT,Tanh,SO>( ~dm, Tanh() );
1997 }
1998 //*************************************************************************************************
1999 
2000 
2001 //*************************************************************************************************
2021 template< typename MT // Type of the dense matrix
2022  , bool SO > // Storage order
2024 {
2026 
2027  return DMatForEachExpr<MT,Atanh,SO>( ~dm, Atanh() );
2028 }
2029 //*************************************************************************************************
2030 
2031 
2032 //*************************************************************************************************
2049 template< typename MT // Type of the dense matrix
2050  , bool SO > // Storage order
2052 {
2054 
2055  return DMatForEachExpr<MT,Erf,SO>( ~dm, Erf() );
2056 }
2057 //*************************************************************************************************
2058 
2059 
2060 //*************************************************************************************************
2077 template< typename MT // Type of the dense matrix
2078  , bool SO > // Storage order
2080 {
2082 
2083  return DMatForEachExpr<MT,Erfc,SO>( ~dm, Erfc() );
2084 }
2085 //*************************************************************************************************
2086 
2087 
2088 
2089 
2090 //=================================================================================================
2091 //
2092 // GLOBAL RESTRUCTURING FUNCTIONS
2093 //
2094 //=================================================================================================
2095 
2096 //*************************************************************************************************
2107 template< typename MT // Type of the dense matrix
2108  , bool SO > // Storage order
2110 {
2112 
2113  return dm;
2114 }
2116 //*************************************************************************************************
2117 
2118 
2119 //*************************************************************************************************
2130 template< typename MT // Type of the dense matrix
2131  , bool SO > // Storage order
2133 {
2135 
2136  return dm;
2137 }
2139 //*************************************************************************************************
2140 
2141 
2142 //*************************************************************************************************
2153 template< typename MT // Type of the dense matrix
2154  , bool SO > // Storage order
2156 {
2158 
2159  return dm;
2160 }
2162 //*************************************************************************************************
2163 
2164 
2165 //*************************************************************************************************
2176 template< typename MT // Type of the dense matrix
2177  , bool SO > // Storage order
2179 {
2181 
2182  return dm;
2183 }
2185 //*************************************************************************************************
2186 
2187 
2188 //*************************************************************************************************
2199 template< typename MT // Type of the dense matrix
2200  , bool SO > // Storage order
2202 {
2204 
2205  return dm;
2206 }
2208 //*************************************************************************************************
2209 
2210 
2211 //*************************************************************************************************
2229 template< typename MT // Type of the dense matrix
2230  , bool SO > // Storage order
2232 {
2234 
2235  return dm.operand();
2236 }
2238 //*************************************************************************************************
2239 
2240 
2241 //*************************************************************************************************
2259 template< typename MT // Type of the dense matrix
2260  , bool SO > // Storage order
2262 {
2264 
2265  return DMatTransExpr<MT,!SO>( dm.operand().operand() );
2266 }
2268 //*************************************************************************************************
2269 
2270 
2271 //*************************************************************************************************
2282 template< typename MT // Type of the dense matrix
2283  , bool SO > // Storage order
2285 {
2287 
2288  return dm;
2289 }
2291 //*************************************************************************************************
2292 
2293 
2294 
2295 
2296 //=================================================================================================
2297 //
2298 // ROWS SPECIALIZATIONS
2299 //
2300 //=================================================================================================
2301 
2302 //*************************************************************************************************
2304 template< typename MT, typename OP, bool SO >
2305 struct Rows< DMatForEachExpr<MT,OP,SO> > : public Rows<MT>
2306 {};
2308 //*************************************************************************************************
2309 
2310 
2311 
2312 
2313 //=================================================================================================
2314 //
2315 // COLUMNS SPECIALIZATIONS
2316 //
2317 //=================================================================================================
2318 
2319 //*************************************************************************************************
2321 template< typename MT, typename OP, bool SO >
2322 struct Columns< DMatForEachExpr<MT,OP,SO> > : public Columns<MT>
2323 {};
2325 //*************************************************************************************************
2326 
2327 
2328 
2329 
2330 //=================================================================================================
2331 //
2332 // ISALIGNED SPECIALIZATIONS
2333 //
2334 //=================================================================================================
2335 
2336 //*************************************************************************************************
2338 template< typename MT, typename OP, bool SO >
2339 struct IsAligned< DMatForEachExpr<MT,OP,SO> >
2340  : public BoolConstant< IsAligned<MT>::value >
2341 {};
2343 //*************************************************************************************************
2344 
2345 
2346 
2347 
2348 //=================================================================================================
2349 //
2350 // ISPADDED SPECIALIZATIONS
2351 //
2352 //=================================================================================================
2353 
2354 //*************************************************************************************************
2356 template< typename MT, typename OP, bool SO >
2357 struct IsPadded< DMatForEachExpr<MT,OP,SO> >
2358  : public BoolConstant< IsPadded<MT>::value >
2359 {};
2361 //*************************************************************************************************
2362 
2363 
2364 
2365 
2366 //=================================================================================================
2367 //
2368 // ISSYMMETRIC SPECIALIZATIONS
2369 //
2370 //=================================================================================================
2371 
2372 //*************************************************************************************************
2374 template< typename MT, bool SO >
2375 struct IsSymmetric< DMatForEachExpr<MT,Abs,SO> >
2376  : public BoolConstant< IsSymmetric<MT>::value >
2377 {};
2378 
2379 template< typename MT, bool SO >
2380 struct IsSymmetric< DMatForEachExpr<MT,Floor,SO> >
2381  : public BoolConstant< IsSymmetric<MT>::value >
2382 {};
2383 
2384 template< typename MT, bool SO >
2385 struct IsSymmetric< DMatForEachExpr<MT,Ceil,SO> >
2386  : public BoolConstant< IsSymmetric<MT>::value >
2387 {};
2388 
2389 template< typename MT, bool SO >
2390 struct IsSymmetric< DMatForEachExpr<MT,Trunc,SO> >
2391  : public BoolConstant< IsSymmetric<MT>::value >
2392 {};
2393 
2394 template< typename MT, bool SO >
2395 struct IsSymmetric< DMatForEachExpr<MT,Round,SO> >
2396  : public BoolConstant< IsSymmetric<MT>::value >
2397 {};
2398 
2399 template< typename MT, bool SO >
2400 struct IsSymmetric< DMatForEachExpr<MT,Conj,SO> >
2401  : public BoolConstant< IsSymmetric<MT>::value >
2402 {};
2403 
2404 template< typename MT, bool SO >
2405 struct IsSymmetric< DMatForEachExpr<MT,Real,SO> >
2406  : public BoolConstant< IsSymmetric<MT>::value >
2407 {};
2408 
2409 template< typename MT, bool SO >
2410 struct IsSymmetric< DMatForEachExpr<MT,Imag,SO> >
2411  : public BoolConstant< IsSymmetric<MT>::value >
2412 {};
2413 
2414 template< typename MT, bool SO >
2415 struct IsSymmetric< DMatForEachExpr<MT,Sqrt,SO> >
2416  : public BoolConstant< IsSymmetric<MT>::value >
2417 {};
2418 
2419 template< typename MT, bool SO >
2420 struct IsSymmetric< DMatForEachExpr<MT,InvSqrt,SO> >
2421  : public BoolConstant< IsSymmetric<MT>::value >
2422 {};
2423 
2424 template< typename MT, bool SO >
2425 struct IsSymmetric< DMatForEachExpr<MT,Cbrt,SO> >
2426  : public BoolConstant< IsSymmetric<MT>::value >
2427 {};
2428 
2429 template< typename MT, bool SO >
2430 struct IsSymmetric< DMatForEachExpr<MT,InvCbrt,SO> >
2431  : public BoolConstant< IsSymmetric<MT>::value >
2432 {};
2433 
2434 template< typename MT, typename ET, bool SO >
2435 struct IsSymmetric< DMatForEachExpr<MT,Pow<ET>,SO> >
2436  : public BoolConstant< IsSymmetric<MT>::value >
2437 {};
2438 
2439 template< typename MT, bool SO >
2440 struct IsSymmetric< DMatForEachExpr<MT,Exp,SO> >
2441  : public BoolConstant< IsSymmetric<MT>::value >
2442 {};
2443 
2444 template< typename MT, bool SO >
2445 struct IsSymmetric< DMatForEachExpr<MT,Exp2,SO> >
2446  : public BoolConstant< IsSymmetric<MT>::value >
2447 {};
2448 
2449 template< typename MT, bool SO >
2450 struct IsSymmetric< DMatForEachExpr<MT,Exp10,SO> >
2451  : public BoolConstant< IsSymmetric<MT>::value >
2452 {};
2453 
2454 template< typename MT, bool SO >
2455 struct IsSymmetric< DMatForEachExpr<MT,Log,SO> >
2456  : public BoolConstant< IsSymmetric<MT>::value >
2457 {};
2458 
2459 template< typename MT, bool SO >
2460 struct IsSymmetric< DMatForEachExpr<MT,Log2,SO> >
2461  : public BoolConstant< IsSymmetric<MT>::value >
2462 {};
2463 
2464 template< typename MT, bool SO >
2465 struct IsSymmetric< DMatForEachExpr<MT,Log10,SO> >
2466  : public BoolConstant< IsSymmetric<MT>::value >
2467 {};
2468 
2469 template< typename MT, bool SO >
2470 struct IsSymmetric< DMatForEachExpr<MT,Sin,SO> >
2471  : public BoolConstant< IsSymmetric<MT>::value >
2472 {};
2473 
2474 template< typename MT, bool SO >
2475 struct IsSymmetric< DMatForEachExpr<MT,Asin,SO> >
2476  : public BoolConstant< IsSymmetric<MT>::value >
2477 {};
2478 
2479 template< typename MT, bool SO >
2480 struct IsSymmetric< DMatForEachExpr<MT,Sinh,SO> >
2481  : public BoolConstant< IsSymmetric<MT>::value >
2482 {};
2483 
2484 template< typename MT, bool SO >
2485 struct IsSymmetric< DMatForEachExpr<MT,Asinh,SO> >
2486  : public BoolConstant< IsSymmetric<MT>::value >
2487 {};
2488 
2489 template< typename MT, bool SO >
2490 struct IsSymmetric< DMatForEachExpr<MT,Cos,SO> >
2491  : public BoolConstant< IsSymmetric<MT>::value >
2492 {};
2493 
2494 template< typename MT, bool SO >
2495 struct IsSymmetric< DMatForEachExpr<MT,Acos,SO> >
2496  : public BoolConstant< IsSymmetric<MT>::value >
2497 {};
2498 
2499 template< typename MT, bool SO >
2500 struct IsSymmetric< DMatForEachExpr<MT,Cosh,SO> >
2501  : public BoolConstant< IsSymmetric<MT>::value >
2502 {};
2503 
2504 template< typename MT, bool SO >
2505 struct IsSymmetric< DMatForEachExpr<MT,Acosh,SO> >
2506  : public BoolConstant< IsSymmetric<MT>::value >
2507 {};
2508 
2509 template< typename MT, bool SO >
2510 struct IsSymmetric< DMatForEachExpr<MT,Tan,SO> >
2511  : public BoolConstant< IsSymmetric<MT>::value >
2512 {};
2513 
2514 template< typename MT, bool SO >
2515 struct IsSymmetric< DMatForEachExpr<MT,Atan,SO> >
2516  : public BoolConstant< IsSymmetric<MT>::value >
2517 {};
2518 
2519 template< typename MT, bool SO >
2520 struct IsSymmetric< DMatForEachExpr<MT,Tanh,SO> >
2521  : public BoolConstant< IsSymmetric<MT>::value >
2522 {};
2523 
2524 template< typename MT, bool SO >
2525 struct IsSymmetric< DMatForEachExpr<MT,Atanh,SO> >
2526  : public BoolConstant< IsSymmetric<MT>::value >
2527 {};
2528 
2529 template< typename MT, bool SO >
2530 struct IsSymmetric< DMatForEachExpr<MT,Erf,SO> >
2531  : public BoolConstant< IsSymmetric<MT>::value >
2532 {};
2533 
2534 template< typename MT, bool SO >
2535 struct IsSymmetric< DMatForEachExpr<MT,Erfc,SO> >
2536  : public BoolConstant< IsSymmetric<MT>::value >
2537 {};
2539 //*************************************************************************************************
2540 
2541 
2542 
2543 
2544 //=================================================================================================
2545 //
2546 // ISHERMITIAN SPECIALIZATIONS
2547 //
2548 //=================================================================================================
2549 
2550 //*************************************************************************************************
2552 template< typename MT, bool SO >
2553 struct IsHermitian< DMatForEachExpr<MT,Abs,SO> >
2554  : public BoolConstant< IsHermitian<MT>::value >
2555 {};
2556 
2557 template< typename MT, bool SO >
2558 struct IsHermitian< DMatForEachExpr<MT,Floor,SO> >
2559  : public BoolConstant< IsHermitian<MT>::value >
2560 {};
2561 
2562 template< typename MT, bool SO >
2563 struct IsHermitian< DMatForEachExpr<MT,Ceil,SO> >
2564  : public BoolConstant< IsHermitian<MT>::value >
2565 {};
2566 
2567 template< typename MT, bool SO >
2568 struct IsHermitian< DMatForEachExpr<MT,Trunc,SO> >
2569  : public BoolConstant< IsHermitian<MT>::value >
2570 {};
2571 
2572 template< typename MT, bool SO >
2573 struct IsHermitian< DMatForEachExpr<MT,Round,SO> >
2574  : public BoolConstant< IsHermitian<MT>::value >
2575 {};
2576 
2577 template< typename MT, bool SO >
2578 struct IsHermitian< DMatForEachExpr<MT,Conj,SO> >
2579  : public BoolConstant< IsHermitian<MT>::value >
2580 {};
2581 
2582 template< typename MT, bool SO >
2583 struct IsHermitian< DMatForEachExpr<MT,Real,SO> >
2584  : public BoolConstant< IsHermitian<MT>::value >
2585 {};
2586 
2587 template< typename MT, bool SO >
2588 struct IsHermitian< DMatForEachExpr<MT,Imag,SO> >
2589  : public BoolConstant< IsBuiltin< ElementType_<MT> >::value >
2590 {};
2591 
2592 template< typename MT, bool SO >
2593 struct IsHermitian< DMatForEachExpr<MT,Sqrt,SO> >
2594  : public BoolConstant< IsHermitian<MT>::value >
2595 {};
2596 
2597 template< typename MT, bool SO >
2598 struct IsHermitian< DMatForEachExpr<MT,InvSqrt,SO> >
2599  : public BoolConstant< IsHermitian<MT>::value >
2600 {};
2601 
2602 template< typename MT, bool SO >
2603 struct IsHermitian< DMatForEachExpr<MT,Cbrt,SO> >
2604  : public BoolConstant< IsHermitian<MT>::value >
2605 {};
2606 
2607 template< typename MT, bool SO >
2608 struct IsHermitian< DMatForEachExpr<MT,InvCbrt,SO> >
2609  : public BoolConstant< IsHermitian<MT>::value >
2610 {};
2611 
2612 template< typename MT, typename ET, bool SO >
2613 struct IsHermitian< DMatForEachExpr<MT,Pow<ET>,SO> >
2614  : public BoolConstant< IsHermitian<MT>::value >
2615 {};
2616 
2617 template< typename MT, bool SO >
2618 struct IsHermitian< DMatForEachExpr<MT,Exp,SO> >
2619  : public BoolConstant< IsHermitian<MT>::value >
2620 {};
2621 
2622 template< typename MT, bool SO >
2623 struct IsHermitian< DMatForEachExpr<MT,Exp2,SO> >
2624  : public BoolConstant< IsHermitian<MT>::value >
2625 {};
2626 
2627 template< typename MT, bool SO >
2628 struct IsHermitian< DMatForEachExpr<MT,Exp10,SO> >
2629  : public BoolConstant< IsHermitian<MT>::value >
2630 {};
2631 
2632 template< typename MT, bool SO >
2633 struct IsHermitian< DMatForEachExpr<MT,Log,SO> >
2634  : public BoolConstant< IsHermitian<MT>::value >
2635 {};
2636 
2637 template< typename MT, bool SO >
2638 struct IsHermitian< DMatForEachExpr<MT,Log2,SO> >
2639  : public BoolConstant< IsHermitian<MT>::value >
2640 {};
2641 
2642 template< typename MT, bool SO >
2643 struct IsHermitian< DMatForEachExpr<MT,Log10,SO> >
2644  : public BoolConstant< IsHermitian<MT>::value >
2645 {};
2646 
2647 template< typename MT, bool SO >
2648 struct IsHermitian< DMatForEachExpr<MT,Sin,SO> >
2649  : public BoolConstant< IsHermitian<MT>::value >
2650 {};
2651 
2652 template< typename MT, bool SO >
2653 struct IsHermitian< DMatForEachExpr<MT,Asin,SO> >
2654  : public BoolConstant< IsHermitian<MT>::value >
2655 {};
2656 
2657 template< typename MT, bool SO >
2658 struct IsHermitian< DMatForEachExpr<MT,Sinh,SO> >
2659  : public BoolConstant< IsHermitian<MT>::value >
2660 {};
2661 
2662 template< typename MT, bool SO >
2663 struct IsHermitian< DMatForEachExpr<MT,Asinh,SO> >
2664  : public BoolConstant< IsHermitian<MT>::value >
2665 {};
2666 
2667 template< typename MT, bool SO >
2668 struct IsHermitian< DMatForEachExpr<MT,Cos,SO> >
2669  : public BoolConstant< IsHermitian<MT>::value >
2670 {};
2671 
2672 template< typename MT, bool SO >
2673 struct IsHermitian< DMatForEachExpr<MT,Acos,SO> >
2674  : public BoolConstant< IsHermitian<MT>::value >
2675 {};
2676 
2677 template< typename MT, bool SO >
2678 struct IsHermitian< DMatForEachExpr<MT,Cosh,SO> >
2679  : public BoolConstant< IsHermitian<MT>::value >
2680 {};
2681 
2682 template< typename MT, bool SO >
2683 struct IsHermitian< DMatForEachExpr<MT,Acosh,SO> >
2684  : public BoolConstant< IsHermitian<MT>::value >
2685 {};
2686 
2687 template< typename MT, bool SO >
2688 struct IsHermitian< DMatForEachExpr<MT,Tan,SO> >
2689  : public BoolConstant< IsHermitian<MT>::value >
2690 {};
2691 
2692 template< typename MT, bool SO >
2693 struct IsHermitian< DMatForEachExpr<MT,Atan,SO> >
2694  : public BoolConstant< IsHermitian<MT>::value >
2695 {};
2696 
2697 template< typename MT, bool SO >
2698 struct IsHermitian< DMatForEachExpr<MT,Tanh,SO> >
2699  : public BoolConstant< IsHermitian<MT>::value >
2700 {};
2701 
2702 template< typename MT, bool SO >
2703 struct IsHermitian< DMatForEachExpr<MT,Atanh,SO> >
2704  : public BoolConstant< IsHermitian<MT>::value >
2705 {};
2706 
2707 template< typename MT, bool SO >
2708 struct IsHermitian< DMatForEachExpr<MT,Erf,SO> >
2709  : public BoolConstant< IsHermitian<MT>::value >
2710 {};
2711 
2712 template< typename MT, bool SO >
2713 struct IsHermitian< DMatForEachExpr<MT,Erfc,SO> >
2714  : public BoolConstant< IsHermitian<MT>::value >
2715 {};
2717 //*************************************************************************************************
2718 
2719 
2720 
2721 
2722 //=================================================================================================
2723 //
2724 // ISLOWER SPECIALIZATIONS
2725 //
2726 //=================================================================================================
2727 
2728 //*************************************************************************************************
2730 template< typename MT, bool SO >
2731 struct IsLower< DMatForEachExpr<MT,Abs,SO> >
2732  : public BoolConstant< IsLower<MT>::value >
2733 {};
2734 
2735 template< typename MT, bool SO >
2736 struct IsLower< DMatForEachExpr<MT,Floor,SO> >
2737  : public BoolConstant< IsLower<MT>::value >
2738 {};
2739 
2740 template< typename MT, bool SO >
2741 struct IsLower< DMatForEachExpr<MT,Ceil,SO> >
2742  : public BoolConstant< IsLower<MT>::value >
2743 {};
2744 
2745 template< typename MT, bool SO >
2746 struct IsLower< DMatForEachExpr<MT,Trunc,SO> >
2747  : public BoolConstant< IsLower<MT>::value >
2748 {};
2749 
2750 template< typename MT, bool SO >
2751 struct IsLower< DMatForEachExpr<MT,Round,SO> >
2752  : public BoolConstant< IsLower<MT>::value >
2753 {};
2754 
2755 template< typename MT, bool SO >
2756 struct IsLower< DMatForEachExpr<MT,Conj,SO> >
2757  : public BoolConstant< IsLower<MT>::value >
2758 {};
2759 
2760 template< typename MT, bool SO >
2761 struct IsLower< DMatForEachExpr<MT,Real,SO> >
2762  : public BoolConstant< IsLower<MT>::value >
2763 {};
2764 
2765 template< typename MT, bool SO >
2766 struct IsLower< DMatForEachExpr<MT,Imag,SO> >
2767  : public BoolConstant< IsLower<MT>::value >
2768 {};
2769 
2770 template< typename MT, bool SO >
2771 struct IsLower< DMatForEachExpr<MT,Sin,SO> >
2772  : public BoolConstant< IsLower<MT>::value >
2773 {};
2774 
2775 template< typename MT, bool SO >
2776 struct IsLower< DMatForEachExpr<MT,Asin,SO> >
2777  : public BoolConstant< IsLower<MT>::value >
2778 {};
2779 
2780 template< typename MT, bool SO >
2781 struct IsLower< DMatForEachExpr<MT,Sinh,SO> >
2782  : public BoolConstant< IsLower<MT>::value >
2783 {};
2784 
2785 template< typename MT, bool SO >
2786 struct IsLower< DMatForEachExpr<MT,Asinh,SO> >
2787  : public BoolConstant< IsLower<MT>::value >
2788 {};
2789 
2790 template< typename MT, bool SO >
2791 struct IsLower< DMatForEachExpr<MT,Tan,SO> >
2792  : public BoolConstant< IsLower<MT>::value >
2793 {};
2794 
2795 template< typename MT, bool SO >
2796 struct IsLower< DMatForEachExpr<MT,Atan,SO> >
2797  : public BoolConstant< IsLower<MT>::value >
2798 {};
2799 
2800 template< typename MT, bool SO >
2801 struct IsLower< DMatForEachExpr<MT,Tanh,SO> >
2802  : public BoolConstant< IsLower<MT>::value >
2803 {};
2804 
2805 template< typename MT, bool SO >
2806 struct IsLower< DMatForEachExpr<MT,Atanh,SO> >
2807  : public BoolConstant< IsLower<MT>::value >
2808 {};
2809 
2810 template< typename MT, bool SO >
2811 struct IsLower< DMatForEachExpr<MT,Erf,SO> >
2812  : public BoolConstant< IsLower<MT>::value >
2813 {};
2815 //*************************************************************************************************
2816 
2817 
2818 
2819 
2820 //=================================================================================================
2821 //
2822 // ISUNILOWER SPECIALIZATIONS
2823 //
2824 //=================================================================================================
2825 
2826 //*************************************************************************************************
2828 template< typename MT, bool SO >
2829 struct IsUniLower< DMatForEachExpr<MT,Abs,SO> >
2830  : public BoolConstant< IsUniLower<MT>::value >
2831 {};
2832 
2833 template< typename MT, bool SO >
2834 struct IsUniLower< DMatForEachExpr<MT,Floor,SO> >
2835  : public BoolConstant< IsUniLower<MT>::value >
2836 {};
2837 
2838 template< typename MT, bool SO >
2839 struct IsUniLower< DMatForEachExpr<MT,Ceil,SO> >
2840  : public BoolConstant< IsUniLower<MT>::value >
2841 {};
2842 
2843 template< typename MT, bool SO >
2844 struct IsUniLower< DMatForEachExpr<MT,Trunc,SO> >
2845  : public BoolConstant< IsUniLower<MT>::value >
2846 {};
2847 
2848 template< typename MT, bool SO >
2849 struct IsUniLower< DMatForEachExpr<MT,Round,SO> >
2850  : public BoolConstant< IsUniLower<MT>::value >
2851 {};
2852 
2853 template< typename MT, typename ET, bool SO >
2854 struct IsUniLower< DMatForEachExpr<MT,Pow<ET>,SO> >
2855  : public BoolConstant< IsUniLower<MT>::value >
2856 {};
2858 //*************************************************************************************************
2859 
2860 
2861 
2862 
2863 //=================================================================================================
2864 //
2865 // ISSTRICTLYLOWER SPECIALIZATIONS
2866 //
2867 //=================================================================================================
2868 
2869 //*************************************************************************************************
2871 template< typename MT, bool SO >
2872 struct IsStrictlyLower< DMatForEachExpr<MT,Abs,SO> >
2873  : public BoolConstant< IsStrictlyLower<MT>::value >
2874 {};
2875 
2876 template< typename MT, bool SO >
2877 struct IsStrictlyLower< DMatForEachExpr<MT,Floor,SO> >
2878  : public BoolConstant< IsStrictlyLower<MT>::value >
2879 {};
2880 
2881 template< typename MT, bool SO >
2882 struct IsStrictlyLower< DMatForEachExpr<MT,Ceil,SO> >
2883  : public BoolConstant< IsStrictlyLower<MT>::value >
2884 {};
2885 
2886 template< typename MT, bool SO >
2887 struct IsStrictlyLower< DMatForEachExpr<MT,Trunc,SO> >
2888  : public BoolConstant< IsStrictlyLower<MT>::value >
2889 {};
2890 
2891 template< typename MT, bool SO >
2892 struct IsStrictlyLower< DMatForEachExpr<MT,Round,SO> >
2893  : public BoolConstant< IsStrictlyLower<MT>::value >
2894 {};
2895 
2896 template< typename MT, bool SO >
2897 struct IsStrictlyLower< DMatForEachExpr<MT,Conj,SO> >
2898  : public BoolConstant< IsStrictlyLower<MT>::value >
2899 {};
2900 
2901 template< typename MT, bool SO >
2902 struct IsStrictlyLower< DMatForEachExpr<MT,Real,SO> >
2903  : public BoolConstant< IsStrictlyLower<MT>::value >
2904 {};
2905 
2906 template< typename MT, bool SO >
2907 struct IsStrictlyLower< DMatForEachExpr<MT,Imag,SO> >
2908  : public BoolConstant< IsStrictlyLower<MT>::value >
2909 {};
2910 
2911 template< typename MT, bool SO >
2912 struct IsStrictlyLower< DMatForEachExpr<MT,Sin,SO> >
2913  : public BoolConstant< IsStrictlyLower<MT>::value >
2914 {};
2915 
2916 template< typename MT, bool SO >
2917 struct IsStrictlyLower< DMatForEachExpr<MT,Asin,SO> >
2918  : public BoolConstant< IsStrictlyLower<MT>::value >
2919 {};
2920 
2921 template< typename MT, bool SO >
2922 struct IsStrictlyLower< DMatForEachExpr<MT,Sinh,SO> >
2923  : public BoolConstant< IsStrictlyLower<MT>::value >
2924 {};
2925 
2926 template< typename MT, bool SO >
2927 struct IsStrictlyLower< DMatForEachExpr<MT,Asinh,SO> >
2928  : public BoolConstant< IsStrictlyLower<MT>::value >
2929 {};
2930 
2931 template< typename MT, bool SO >
2932 struct IsStrictlyLower< DMatForEachExpr<MT,Tan,SO> >
2933  : public BoolConstant< IsStrictlyLower<MT>::value >
2934 {};
2935 
2936 template< typename MT, bool SO >
2937 struct IsStrictlyLower< DMatForEachExpr<MT,Atan,SO> >
2938  : public BoolConstant< IsStrictlyLower<MT>::value >
2939 {};
2940 
2941 template< typename MT, bool SO >
2942 struct IsStrictlyLower< DMatForEachExpr<MT,Tanh,SO> >
2943  : public BoolConstant< IsStrictlyLower<MT>::value >
2944 {};
2945 
2946 template< typename MT, bool SO >
2947 struct IsStrictlyLower< DMatForEachExpr<MT,Atanh,SO> >
2948  : public BoolConstant< IsStrictlyLower<MT>::value >
2949 {};
2950 
2951 template< typename MT, bool SO >
2952 struct IsStrictlyLower< DMatForEachExpr<MT,Erf,SO> >
2953  : public BoolConstant< IsStrictlyLower<MT>::value >
2954 {};
2956 //*************************************************************************************************
2957 
2958 
2959 
2960 
2961 //=================================================================================================
2962 //
2963 // ISUPPER SPECIALIZATIONS
2964 //
2965 //=================================================================================================
2966 
2967 //*************************************************************************************************
2969 template< typename MT, bool SO >
2970 struct IsUpper< DMatForEachExpr<MT,Abs,SO> >
2971  : public BoolConstant< IsUpper<MT>::value >
2972 {};
2973 
2974 template< typename MT, bool SO >
2975 struct IsUpper< DMatForEachExpr<MT,Floor,SO> >
2976  : public BoolConstant< IsUpper<MT>::value >
2977 {};
2978 
2979 template< typename MT, bool SO >
2980 struct IsUpper< DMatForEachExpr<MT,Ceil,SO> >
2981  : public BoolConstant< IsUpper<MT>::value >
2982 {};
2983 
2984 template< typename MT, bool SO >
2985 struct IsUpper< DMatForEachExpr<MT,Trunc,SO> >
2986  : public BoolConstant< IsUpper<MT>::value >
2987 {};
2988 
2989 template< typename MT, bool SO >
2990 struct IsUpper< DMatForEachExpr<MT,Round,SO> >
2991  : public BoolConstant< IsUpper<MT>::value >
2992 {};
2993 
2994 template< typename MT, bool SO >
2995 struct IsUpper< DMatForEachExpr<MT,Conj,SO> >
2996  : public BoolConstant< IsUpper<MT>::value >
2997 {};
2998 
2999 template< typename MT, bool SO >
3000 struct IsUpper< DMatForEachExpr<MT,Real,SO> >
3001  : public BoolConstant< IsUpper<MT>::value >
3002 {};
3003 
3004 template< typename MT, bool SO >
3005 struct IsUpper< DMatForEachExpr<MT,Imag,SO> >
3006  : public BoolConstant< IsUpper<MT>::value >
3007 {};
3008 
3009 template< typename MT, bool SO >
3010 struct IsUpper< DMatForEachExpr<MT,Sin,SO> >
3011  : public BoolConstant< IsUpper<MT>::value >
3012 {};
3013 
3014 template< typename MT, bool SO >
3015 struct IsUpper< DMatForEachExpr<MT,Asin,SO> >
3016  : public BoolConstant< IsUpper<MT>::value >
3017 {};
3018 
3019 template< typename MT, bool SO >
3020 struct IsUpper< DMatForEachExpr<MT,Sinh,SO> >
3021  : public BoolConstant< IsUpper<MT>::value >
3022 {};
3023 
3024 template< typename MT, bool SO >
3025 struct IsUpper< DMatForEachExpr<MT,Asinh,SO> >
3026  : public BoolConstant< IsUpper<MT>::value >
3027 {};
3028 
3029 template< typename MT, bool SO >
3030 struct IsUpper< DMatForEachExpr<MT,Tan,SO> >
3031  : public BoolConstant< IsUpper<MT>::value >
3032 {};
3033 
3034 template< typename MT, bool SO >
3035 struct IsUpper< DMatForEachExpr<MT,Atan,SO> >
3036  : public BoolConstant< IsUpper<MT>::value >
3037 {};
3038 
3039 template< typename MT, bool SO >
3040 struct IsUpper< DMatForEachExpr<MT,Tanh,SO> >
3041  : public BoolConstant< IsUpper<MT>::value >
3042 {};
3043 
3044 template< typename MT, bool SO >
3045 struct IsUpper< DMatForEachExpr<MT,Atanh,SO> >
3046  : public BoolConstant< IsUpper<MT>::value >
3047 {};
3048 
3049 template< typename MT, bool SO >
3050 struct IsUpper< DMatForEachExpr<MT,Erf,SO> >
3051  : public BoolConstant< IsUpper<MT>::value >
3052 {};
3054 //*************************************************************************************************
3055 
3056 
3057 
3058 
3059 //=================================================================================================
3060 //
3061 // ISUNIUPPER SPECIALIZATIONS
3062 //
3063 //=================================================================================================
3064 
3065 //*************************************************************************************************
3067 template< typename MT, bool SO >
3068 struct IsUniUpper< DMatForEachExpr<MT,Abs,SO> >
3069  : public BoolConstant< IsUniUpper<MT>::value >
3070 {};
3071 
3072 template< typename MT, bool SO >
3073 struct IsUniUpper< DMatForEachExpr<MT,Floor,SO> >
3074  : public BoolConstant< IsUniUpper<MT>::value >
3075 {};
3076 
3077 template< typename MT, bool SO >
3078 struct IsUniUpper< DMatForEachExpr<MT,Ceil,SO> >
3079  : public BoolConstant< IsUniUpper<MT>::value >
3080 {};
3081 
3082 template< typename MT, bool SO >
3083 struct IsUniUpper< DMatForEachExpr<MT,Trunc,SO> >
3084  : public BoolConstant< IsUniUpper<MT>::value >
3085 {};
3086 
3087 template< typename MT, bool SO >
3088 struct IsUniUpper< DMatForEachExpr<MT,Round,SO> >
3089  : public BoolConstant< IsUniUpper<MT>::value >
3090 {};
3091 
3092 template< typename MT, typename ET, bool SO >
3093 struct IsUniUpper< DMatForEachExpr<MT,Pow<ET>,SO> >
3094  : public BoolConstant< IsUniUpper<MT>::value >
3095 {};
3097 //*************************************************************************************************
3098 
3099 
3100 
3101 
3102 //=================================================================================================
3103 //
3104 // ISSTRICTLYUPPER SPECIALIZATIONS
3105 //
3106 //=================================================================================================
3107 
3108 //*************************************************************************************************
3110 template< typename MT, bool SO >
3111 struct IsStrictlyUpper< DMatForEachExpr<MT,Abs,SO> >
3112  : public BoolConstant< IsStrictlyUpper<MT>::value >
3113 {};
3114 
3115 template< typename MT, bool SO >
3116 struct IsStrictlyUpper< DMatForEachExpr<MT,Floor,SO> >
3117  : public BoolConstant< IsStrictlyUpper<MT>::value >
3118 {};
3119 
3120 template< typename MT, bool SO >
3121 struct IsStrictlyUpper< DMatForEachExpr<MT,Ceil,SO> >
3122  : public BoolConstant< IsStrictlyUpper<MT>::value >
3123 {};
3124 
3125 template< typename MT, bool SO >
3126 struct IsStrictlyUpper< DMatForEachExpr<MT,Trunc,SO> >
3127  : public BoolConstant< IsStrictlyUpper<MT>::value >
3128 {};
3129 
3130 template< typename MT, bool SO >
3131 struct IsStrictlyUpper< DMatForEachExpr<MT,Round,SO> >
3132  : public BoolConstant< IsStrictlyUpper<MT>::value >
3133 {};
3134 
3135 template< typename MT, bool SO >
3136 struct IsStrictlyUpper< DMatForEachExpr<MT,Conj,SO> >
3137  : public BoolConstant< IsStrictlyUpper<MT>::value >
3138 {};
3139 
3140 template< typename MT, bool SO >
3141 struct IsStrictlyUpper< DMatForEachExpr<MT,Real,SO> >
3142  : public BoolConstant< IsStrictlyUpper<MT>::value >
3143 {};
3144 
3145 template< typename MT, bool SO >
3146 struct IsStrictlyUpper< DMatForEachExpr<MT,Imag,SO> >
3147  : public BoolConstant< IsStrictlyUpper<MT>::value >
3148 {};
3149 
3150 template< typename MT, bool SO >
3151 struct IsStrictlyUpper< DMatForEachExpr<MT,Sin,SO> >
3152  : public BoolConstant< IsStrictlyUpper<MT>::value >
3153 {};
3154 
3155 template< typename MT, bool SO >
3156 struct IsStrictlyUpper< DMatForEachExpr<MT,Asin,SO> >
3157  : public BoolConstant< IsStrictlyUpper<MT>::value >
3158 {};
3159 
3160 template< typename MT, bool SO >
3161 struct IsStrictlyUpper< DMatForEachExpr<MT,Sinh,SO> >
3162  : public BoolConstant< IsStrictlyUpper<MT>::value >
3163 {};
3164 
3165 template< typename MT, bool SO >
3166 struct IsStrictlyUpper< DMatForEachExpr<MT,Asinh,SO> >
3167  : public BoolConstant< IsStrictlyUpper<MT>::value >
3168 {};
3169 
3170 template< typename MT, bool SO >
3171 struct IsStrictlyUpper< DMatForEachExpr<MT,Tan,SO> >
3172  : public BoolConstant< IsStrictlyUpper<MT>::value >
3173 {};
3174 
3175 template< typename MT, bool SO >
3176 struct IsStrictlyUpper< DMatForEachExpr<MT,Atan,SO> >
3177  : public BoolConstant< IsStrictlyUpper<MT>::value >
3178 {};
3179 
3180 template< typename MT, bool SO >
3181 struct IsStrictlyUpper< DMatForEachExpr<MT,Tanh,SO> >
3182  : public BoolConstant< IsStrictlyUpper<MT>::value >
3183 {};
3184 
3185 template< typename MT, bool SO >
3186 struct IsStrictlyUpper< DMatForEachExpr<MT,Atanh,SO> >
3187  : public BoolConstant< IsStrictlyUpper<MT>::value >
3188 {};
3189 
3190 template< typename MT, bool SO >
3191 struct IsStrictlyUpper< DMatForEachExpr<MT,Erf,SO> >
3192  : public BoolConstant< IsStrictlyUpper<MT>::value >
3193 {};
3195 //*************************************************************************************************
3196 
3197 
3198 
3199 
3200 //=================================================================================================
3201 //
3202 // EXPRESSION TRAIT SPECIALIZATIONS
3203 //
3204 //=================================================================================================
3205 
3206 //*************************************************************************************************
3208 template< typename MT >
3209 struct DMatForEachExprTrait< DMatForEachExpr<MT,Abs,false>, Abs >
3210 {
3211  public:
3212  //**********************************************************************************************
3215  , INVALID_TYPE >;
3216  //**********************************************************************************************
3217 };
3219 //*************************************************************************************************
3220 
3221 
3222 //*************************************************************************************************
3224 template< typename MT >
3225 struct TDMatForEachExprTrait< DMatForEachExpr<MT,Abs,true>, Abs >
3226 {
3227  public:
3228  //**********************************************************************************************
3231  , INVALID_TYPE >;
3232  //**********************************************************************************************
3233 };
3235 //*************************************************************************************************
3236 
3237 
3238 //*************************************************************************************************
3240 template< typename MT >
3241 struct DMatForEachExprTrait< DMatForEachExpr<MT,Floor,false>, Floor >
3242 {
3243  public:
3244  //**********************************************************************************************
3247  , INVALID_TYPE >;
3248  //**********************************************************************************************
3249 };
3251 //*************************************************************************************************
3252 
3253 
3254 //*************************************************************************************************
3256 template< typename MT >
3257 struct TDMatForEachExprTrait< DMatForEachExpr<MT,Floor,true>, Floor >
3258 {
3259  public:
3260  //**********************************************************************************************
3263  , INVALID_TYPE >;
3264  //**********************************************************************************************
3265 };
3267 //*************************************************************************************************
3268 
3269 
3270 //*************************************************************************************************
3272 template< typename MT >
3273 struct DMatForEachExprTrait< DMatForEachExpr<MT,Ceil,false>, Ceil >
3274 {
3275  public:
3276  //**********************************************************************************************
3279  , INVALID_TYPE >;
3280  //**********************************************************************************************
3281 };
3283 //*************************************************************************************************
3284 
3285 
3286 //*************************************************************************************************
3288 template< typename MT >
3289 struct TDMatForEachExprTrait< DMatForEachExpr<MT,Ceil,true>, Ceil >
3290 {
3291  public:
3292  //**********************************************************************************************
3295  , INVALID_TYPE >;
3296  //**********************************************************************************************
3297 };
3299 //*************************************************************************************************
3300 
3301 
3302 //*************************************************************************************************
3304 template< typename MT >
3305 struct DMatForEachExprTrait< DMatForEachExpr<MT,Trunc,false>, Trunc >
3306 {
3307  public:
3308  //**********************************************************************************************
3311  , INVALID_TYPE >;
3312  //**********************************************************************************************
3313 };
3315 //*************************************************************************************************
3316 
3317 
3318 //*************************************************************************************************
3320 template< typename MT >
3321 struct TDMatForEachExprTrait< DMatForEachExpr<MT,Trunc,true>, Trunc >
3322 {
3323  public:
3324  //**********************************************************************************************
3327  , INVALID_TYPE >;
3328  //**********************************************************************************************
3329 };
3331 //*************************************************************************************************
3332 
3333 
3334 //*************************************************************************************************
3336 template< typename MT >
3337 struct DMatForEachExprTrait< DMatForEachExpr<MT,Round,false>, Round >
3338 {
3339  public:
3340  //**********************************************************************************************
3343  , INVALID_TYPE >;
3344  //**********************************************************************************************
3345 };
3347 //*************************************************************************************************
3348 
3349 
3350 //*************************************************************************************************
3352 template< typename MT >
3353 struct TDMatForEachExprTrait< DMatForEachExpr<MT,Round,true>, Round >
3354 {
3355  public:
3356  //**********************************************************************************************
3359  , INVALID_TYPE >;
3360  //**********************************************************************************************
3361 };
3363 //*************************************************************************************************
3364 
3365 
3366 //*************************************************************************************************
3368 template< typename MT >
3369 struct DMatForEachExprTrait< DMatForEachExpr<MT,Conj,false>, Conj >
3370 {
3371  public:
3372  //**********************************************************************************************
3375  , INVALID_TYPE >;
3376  //**********************************************************************************************
3377 };
3379 //*************************************************************************************************
3380 
3381 
3382 //*************************************************************************************************
3384 template< typename MT >
3385 struct TDMatForEachExprTrait< DMatForEachExpr<MT,Conj,true>, Conj >
3386 {
3387  public:
3388  //**********************************************************************************************
3391  , INVALID_TYPE >;
3392  //**********************************************************************************************
3393 };
3395 //*************************************************************************************************
3396 
3397 
3398 //*************************************************************************************************
3400 template< typename MT >
3401 struct DMatForEachExprTrait< DMatTransExpr< DMatForEachExpr<MT,Conj,true>, false >, Conj >
3402 {
3403  public:
3404  //**********************************************************************************************
3407  , INVALID_TYPE >;
3408  //**********************************************************************************************
3409 };
3411 //*************************************************************************************************
3412 
3413 
3414 //*************************************************************************************************
3416 template< typename MT >
3417 struct TDMatForEachExprTrait< DMatTransExpr< DMatForEachExpr<MT,Conj,false>, true >, Conj >
3418 {
3419  public:
3420  //**********************************************************************************************
3423  , INVALID_TYPE >;
3424  //**********************************************************************************************
3425 };
3427 //*************************************************************************************************
3428 
3429 
3430 //*************************************************************************************************
3432 template< typename MT >
3433 struct DMatForEachExprTrait< DMatForEachExpr<MT,Real,false>, Real >
3434 {
3435  public:
3436  //**********************************************************************************************
3439  , INVALID_TYPE >;
3440  //**********************************************************************************************
3441 };
3443 //*************************************************************************************************
3444 
3445 
3446 //*************************************************************************************************
3448 template< typename MT >
3449 struct TDMatForEachExprTrait< DMatForEachExpr<MT,Real,true>, Real >
3450 {
3451  public:
3452  //**********************************************************************************************
3455  , INVALID_TYPE >;
3456  //**********************************************************************************************
3457 };
3459 //*************************************************************************************************
3460 
3461 
3462 //*************************************************************************************************
3464 template< typename MT, typename OP, bool SO, bool AF >
3465 struct SubmatrixExprTrait< DMatForEachExpr<MT,OP,SO>, AF >
3466 {
3467  public:
3468  //**********************************************************************************************
3470  //**********************************************************************************************
3471 };
3473 //*************************************************************************************************
3474 
3475 
3476 //*************************************************************************************************
3478 template< typename MT, typename OP, bool SO >
3479 struct RowExprTrait< DMatForEachExpr<MT,OP,SO> >
3480 {
3481  public:
3482  //**********************************************************************************************
3483  using Type = ForEachExprTrait_< RowExprTrait_<const MT>, OP >;
3484  //**********************************************************************************************
3485 };
3487 //*************************************************************************************************
3488 
3489 
3490 //*************************************************************************************************
3492 template< typename MT, typename OP, bool SO >
3493 struct ColumnExprTrait< DMatForEachExpr<MT,OP,SO> >
3494 {
3495  public:
3496  //**********************************************************************************************
3498  //**********************************************************************************************
3499 };
3501 //*************************************************************************************************
3502 
3503 } // namespace blaze
3504 
3505 #endif
Header file for the UnderlyingNumeric type trait.
Generic wrapper for the trunc() function.
Definition: Trunc.h:62
Pointer difference type of the Blaze library.
ConstIterator & operator--()
Pre-decrement operator.
Definition: DMatForEachExpr.h:281
bool operator>(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatForEachExpr.h:356
const DMatForEachExpr< MT, Conj, SO > conj(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the complex conjugate of each single element of dm.
Definition: DMatForEachExpr.h:1214
Header file for auxiliary alias declarations.
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:72
Constraint on the data type.
Generic wrapper for the ceil() function.
Definition: Ceil.h:62
Operand dm_
Dense matrix of the for-each expression.
Definition: DMatForEachExpr.h:621
friend const ConstIterator operator+(size_t inc, const ConstIterator &it)
Addition between an integral value and a ConstIterator.
Definition: DMatForEachExpr.h:413
const DMatForEachExpr< MT, Log, SO > log(const DenseMatrix< MT, SO > &dm)
Computes the natural logarithm for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1610
const DMatForEachExpr< MT, Sin, SO > sin(const DenseMatrix< MT, SO > &dm)
Computes the sine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1700
Generic wrapper for the cbrt() function.
Definition: Cbrt.h:62
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
ReturnType operator()(size_t i, size_t j) const noexcept
2D-access to the matrix elements.
Definition: DMatForEachExpr.h:471
BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT(HasSIMDEnabled, simdEnabled)
Definition of the HasSIMDEnabled type trait.
Header file for basic type definitions.
const DMatForEachExpr< MT, Log10, SO > log10(const DenseMatrix< MT, SO > &dm)
Computes the common logarithm for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1672
Generic wrapper for the sin() function.
Definition: Sin.h:62
Generic wrapper for the conj() function.
Definition: Conj.h:62
Generic wrapper for the invsqrt() function.
Definition: InvSqrt.h:62
EnableIf_< IsDenseMatrix< MT1 > > smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
Header file for the serial shim.
Expression object for dense matrix transpositions.The DMatTransExpr class represents the compile time...
Definition: DMatTransExpr.h:112
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:63
const DMatForEachExpr< MT, Tanh, SO > tanh(const DenseMatrix< MT, SO > &dm)
Computes the hyperbolic tangent for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1992
DifferenceType difference_type
Difference between two iterators.
Definition: DMatForEachExpr.h:213
const CTransExprTrait_< MT > ctrans(const DenseMatrix< MT, SO > &dm)
Returns the conjugate transpose matrix of dm.
Definition: DMatForEachExpr.h:1251
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:61
Operation op_
The custom unary operation.
Definition: DMatForEachExpr.h:622
Header file for the ColumnExprTrait class template.
Header file for the IsSame and IsStrictlySame type traits.
Header file for the ForEachExprTrait class template.
const DMatForEachExpr< MT, Cos, SO > cos(const DenseMatrix< MT, SO > &dm)
Computes the cosine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1815
Generic wrapper for the clamp() function.
Definition: Clamp.h:60
const DMatForEachExpr< MT, Atan, SO > atan(const DenseMatrix< MT, SO > &dm)
Computes the inverse tangent for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1961
Generic wrapper for the acosh() function.
Definition: Acosh.h:62
const DMatForEachExpr< MT, Imag, SO > imag(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the imaginary part of each single element of dm.
Definition: DMatForEachExpr.h:1307
Header file for the And class template.
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1755
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
friend const ConstIterator operator-(const ConstIterator &it, size_t dec)
Subtraction between a ConstIterator and an integral value.
Definition: DMatForEachExpr.h:425
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
const DMatForEachExpr< MT, Sinh, SO > sinh(const DenseMatrix< MT, SO > &dm)
Computes the hyperbolic sine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1759
Header file for the Computation base class.
Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType.
Definition: IsSame.h:138
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Header file for the RequiresEvaluation type trait.
Header file for the MatForEachExpr base class.
const DMatForEachExpr< MT, Exp10, SO > exp10(const DenseMatrix< MT, SO > &dm)
Computes for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1579
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1802
EnableIf_< IsDenseMatrix< MT1 > > smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
const ConstIterator operator--(int)
Post-decrement operator.
Definition: DMatForEachExpr.h:292
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two iterators.
Definition: DMatForEachExpr.h:389
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:71
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:119
const DMatForEachExpr< MT, Exp, SO > exp(const DenseMatrix< MT, SO > &dm)
Computes for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1523
Constraint on the data type.
const DMatForEachExpr< MT, Trunc, SO > trunc(const DenseMatrix< MT, SO > &dm)
Applies the trunc() function to each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1158
bool operator>=(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatForEachExpr.h:378
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatForEachExpr.h:582
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
Constraint on the data type.
Generic wrapper for the abs() function.
Definition: Abs.h:62
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
typename ForEachTrait< T, OP >::Type ForEachTrait_
Auxiliary alias declaration for the ForEachTrait class template.The ForEachTrait_ alias declaration p...
Definition: ForEachTrait.h:146
const DMatForEachExpr< MT, Acosh, SO > acosh(const DenseMatrix< MT, SO > &dm)
Computes the inverse hyperbolic cosine for each single element of the dense matrix dm...
Definition: DMatForEachExpr.h:1905
Generic wrapper for the sqrt() function.
Definition: Sqrt.h:62
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: DMatForEachExpr.h:519
ConstIterator & operator++()
Pre-increment operator.
Definition: DMatForEachExpr.h:260
Header file for the IsStrictlyUpper type trait.
ConstIterator(IteratorType it, OP op)
Constructor for the ConstIterator class.
Definition: DMatForEachExpr.h:225
Header file for the IsSymmetric type trait.
typename CTransExprTrait< T >::Type CTransExprTrait_
Auxiliary alias declaration for the CTransExprTrait class template.The CTransExprTrait_ alias declara...
Definition: CTransExprTrait.h:143
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Header file for nested template disabiguation.
Header file for the If class template.
Generic wrapper for the imag() function.
Definition: Imag.h:59
Generic wrapper for the exp10() function.
Definition: Exp10.h:62
Compile time check for row-major matrix types.This type trait tests whether or not the given template...
Definition: IsRowMajorMatrix.h:83
const DMatForEachExpr< MT, Abs, SO > abs(const DenseMatrix< MT, SO > &dm)
Applies the abs() function to each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1074
IteratorType it_
Iterator to the current matrix element.
Definition: DMatForEachExpr.h:432
ConstIterator_< MT > IteratorType
ConstIterator type of the dense matrix expression.
Definition: DMatForEachExpr.h:216
friend const ConstIterator operator+(const ConstIterator &it, size_t inc)
Addition between a ConstIterator and an integral value.
Definition: DMatForEachExpr.h:401
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatForEachExpr.h:604
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2939
Compile time check for data types with padding.This type trait tests whether the given data type empl...
Definition: IsPadded.h:76
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatForEachExpr.h:178
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
const DMatForEachExpr< MT, OP, SO > forEach(const DenseMatrix< MT, SO > &dm, OP op)
Evaluates the given custom operation on each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1046
Generic wrapper for the log10() function.
Definition: Log10.h:62
Header file for the Not class template.
Header file for all functors.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Header file for all SIMD functionality.
ResultType_< MT > RT
Result type of the dense matrix expression.
Definition: DMatForEachExpr.h:119
const DMatForEachExpr< MT, InvCbrt, SO > invcbrt(const DenseMatrix< MT, SO > &dm)
Computes the inverse cubic root of each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1431
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatForEachExpr.h:614
Iterator over the elements of the dense matrix.
Definition: DMatForEachExpr.h:198
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatForEachExpr.h:560
Evaluation of the expression type type of a submatrix operation.Via this type trait it is possible to...
Definition: SubmatrixExprTrait.h:80
Header file for the IsLower type trait.
Evaluation of the expression type of a dense matrix custom operation.Via this type trait it is possib...
Definition: TDMatForEachExprTrait.h:75
Header file for the IsAligned type trait.
Generic wrapper for the exp2() function.
Definition: Exp2.h:62
ElementType ValueType
Type of the underlying elements.
Definition: DMatForEachExpr.h:203
Generic wrapper for the asin() function.
Definition: Asin.h:62
const DMatForEachExpr< MT, Floor, SO > floor(const DenseMatrix< MT, SO > &dm)
Applies the floor() function to each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1102
ElementType * PointerType
Pointer return type.
Definition: DMatForEachExpr.h:204
ConstIterator & operator+=(size_t inc)
Addition assignment operator.
Definition: DMatForEachExpr.h:237
bool operator<(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatForEachExpr.h:345
const ConstIterator operator++(int)
Post-increment operator.
Definition: DMatForEachExpr.h:271
const DMatForEachExpr< MT, Erf, SO > erf(const DenseMatrix< MT, SO > &dm)
Computes the error function for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:2051
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:60
const DMatForEachExpr< MT, Tan, SO > tan(const DenseMatrix< MT, SO > &dm)
Computes the tangent for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1933
Generic wrapper for the erf() function.
Definition: Erf.h:62
PointerType pointer
Pointer return type.
Definition: DMatForEachExpr.h:211
const DMatForEachExpr< MT, Round, SO > round(const DenseMatrix< MT, SO > &dm)
Applies the round() function to each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1186
Constraints on the storage order of matrix types.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
const DMatForEachExpr< MT, Pow< ET >, SO > pow(const DenseMatrix< MT, SO > &dm, ET exp)
Computes the exponential value for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1493
ReturnType operator*() const
Direct access to the element at the current iterator position.
Definition: DMatForEachExpr.h:302
Header file for the exception macros of the math module.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatForEachExpr.h:540
Expression object for the dense matrix forEach() function.The DMatForEachExpr class represents the co...
Definition: DMatForEachExpr.h:113
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Evaluation of the expression type type of a row operation.Via this type trait it is possible to evalu...
Definition: RowExprTrait.h:79
auto load() const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatForEachExpr.h:312
Evaluation of the underlying numeric element type of a given data type.Via this type trait it is poss...
Definition: UnderlyingNumeric.h:81
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Generic wrapper for the floor() function.
Definition: Floor.h:62
ValueType value_type
Type of the underlying elements.
Definition: DMatForEachExpr.h:210
const DMatForEachExpr< MT, Cosh, SO > cosh(const DenseMatrix< MT, SO > &dm)
Computes the hyperbolic cosine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1874
const DMatForEachExpr< MT, Exp2, SO > exp2(const DenseMatrix< MT, SO > &dm)
Computes for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1551
const DMatForEachExpr< MT, Sqrt, SO > sqrt(const DenseMatrix< MT, SO > &dm)
Computes the square root of each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1338
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatForEachExpr.h:594
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatForEachExpr.h:189
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
const DMatForEachExpr< MT, Real, SO > real(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the real part of each single element of dm.
Definition: DMatForEachExpr.h:1279
Header file for the IsPadded type trait.
const DMatForEachExpr< MT, Atanh, SO > atanh(const DenseMatrix< MT, SO > &dm)
Computes the inverse hyperbolic tangent for each single element of the dense matrix dm...
Definition: DMatForEachExpr.h:2023
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
const DMatForEachExpr< MT, Acos, SO > acos(const DenseMatrix< MT, SO > &dm)
Computes the inverse cosine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1846
IteratorCategory iterator_category
The iterator category.
Definition: DMatForEachExpr.h:209
OP Operation
Data type of the custom unary operation.
Definition: DMatForEachExpr.h:192
bool operator<=(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatForEachExpr.h:367
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2934
bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DMatForEachExpr.h:323
ConstIterator & operator-=(size_t dec)
Subtraction assignment operator.
Definition: DMatForEachExpr.h:249
Header file for run time assertion macros.
Compile time check for column-major matrix types.This type trait tests whether or not the given templ...
Definition: IsColumnMajorMatrix.h:83
const DMatForEachExpr< MT, InvSqrt, SO > invsqrt(const DenseMatrix< MT, SO > &dm)
Computes the inverse square root of each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1369
Base class for all matrix for-each expression templates.The MatForEachExpr class serves as a tag for ...
Definition: MatForEachExpr.h:65
Generic wrapper for the pow() function.
Definition: Forward.h:80
const DMatForEachExpr< MT, Cbrt, SO > cbrt(const DenseMatrix< MT, SO > &dm)
Computes the cubic root of each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1400
Generic wrapper for the atanh() function.
Definition: Atanh.h:62
Generic wrapper for the invcbrt() function.
Definition: InvCbrt.h:62
Generic wrapper for the real() function.
Definition: Real.h:59
OP op_
The custom unary operation.
Definition: DMatForEachExpr.h:433
Generic wrapper for the asinh() function.
Definition: Asinh.h:62
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatForEachExpr.h:486
const DMatForEachExpr< MT, Asin, SO > asin(const DenseMatrix< MT, SO > &dm)
Computes the inverse sine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1731
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: DMatForEachExpr.h:530
ElementType_< MT > ET
Element type of the dense matrix expression.
Definition: DMatForEachExpr.h:121
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE(T)
Constraint on the data type.In case the given data type T is not a numeric (integral or floating poin...
Definition: Numeric.h:61
Generic wrapper for the tan() function.
Definition: Tan.h:62
Generic wrapper for the log() function.
Definition: Log.h:62
SIMD characteristics of data types.The SIMDTrait class template provides the SIMD characteristics of ...
Definition: SIMDTrait.h:296
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:93
ReferenceType reference
Reference return type.
Definition: DMatForEachExpr.h:212
Compile time type negation.The Not class template negates the given compile time condition. In case the given condition would evaluate to true, the nested member enumeration is set to false and vice versa:
Definition: Not.h:70
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Operation operation() const
Returns a copy of the custom operation.
Definition: DMatForEachExpr.h:570
IfTrue_< useAssign, const ResultType, const DMatForEachExpr &> CompositeType
Data type for composite expression templates.
Definition: DMatForEachExpr.h:186
const DMatForEachExpr< MT, Clamp< DT >, SO > 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: DMatForEachExpr.h:1463
Generic wrapper for the erfc() function.
Definition: Erfc.h:62
Header file for the HasMember type traits.
Generic wrapper for the cos() function.
Definition: Cos.h:62
OppositeType_< MT > OT
Opposite type of the dense matrix expression.
Definition: DMatForEachExpr.h:120
ElementType_< ResultType > ElementType
Resulting element type.
Definition: DMatForEachExpr.h:180
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:84
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatForEachExpr.h:179
const DMatForEachExpr< MT, Erfc, SO > erfc(const DenseMatrix< MT, SO > &dm)
Computes the complementary error function for each single element of the dense matrix dm...
Definition: DMatForEachExpr.h:2079
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
const DMatForEachExpr< MT, Log2, SO > log2(const DenseMatrix< MT, SO > &dm)
Computes the binary logarithm for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1641
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatForEachExpr.h:550
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:733
Header file for the IsComputation type trait class.
DMatForEachExpr< MT, OP, SO > This
Type of this DMatForEachExpr instance.
Definition: DMatForEachExpr.h:176
Header file for the IsBuiltin type trait.
Generic wrapper for the acos() function.
Definition: Acos.h:62
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
ElementType & ReferenceType
Reference return type.
Definition: DMatForEachExpr.h:205
Header file for the for-each trait.
Generic wrapper for the atan() function.
Definition: Atan.h:62
Generic wrapper for the round() function.
Definition: Round.h:62
const DMatForEachExpr< MT, Asinh, SO > asinh(const DenseMatrix< MT, SO > &dm)
Computes the inverse hyperbolic sine for each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1787
Generic wrapper for the sinh() function.
Definition: Sinh.h:62
Header file for the IntegralConstant class template.
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
ForEachTrait_< MT, OP > ResultType
Result type for expression template evaluations.
Definition: DMatForEachExpr.h:177
std::random_access_iterator_tag IteratorCategory
The iterator category.
Definition: DMatForEachExpr.h:202
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Generic wrapper for the log2() function.
Definition: Log2.h:62
Evaluation of the expression type of a dense matrix custom operation.Via this type trait it is possib...
Definition: DMatForEachExprTrait.h:75
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
Header file for the IsUpper type trait.
Header file for the CTransExprTrait class template.
Generic wrapper for the cosh() function.
Definition: Cosh.h:62
typename ForEachExprTrait< T, OP >::Type ForEachExprTrait_
Auxiliary alias declaration for the ForEachExprTrait class template.The ForEachExprTrait_ alias decla...
Definition: ForEachExprTrait.h:144
ReturnType_< MT > RN
Return type of the dense matrix expression.
Definition: DMatForEachExpr.h:122
Generic wrapper for the tanh() function.
Definition: Tanh.h:62
Header file for the IsHermitian type trait.
Generic wrapper for the exp() function.
Definition: Exp.h:62
System settings for the inline keywords.
Evaluation of the expression type type of a column operation.Via this type trait it is possible to ev...
Definition: ColumnExprTrait.h:78
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
typename T::Operand Operand_
Alias declaration for nested Operand type definitions.The Operand_ alias declaration provides a conve...
Definition: Aliases.h:223
Compile time check whether the given type is an expression template.This type trait class tests wheth...
Definition: IsExpression.h:71
const DMatForEachExpr< MT, Ceil, SO > ceil(const DenseMatrix< MT, SO > &dm)
Applies the ceil() function to each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1130
Header file for the IsExpression type trait class.
Header file for the function trace functionality.
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DMatForEachExpr.h:334
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DMatForEachExpr.h:206
DMatForEachExpr(const MT &dm, OP op) noexcept
Constructor for the DMatForEachExpr class.
Definition: DMatForEachExpr.h:458
BLAZE_ALWAYS_INLINE auto load(size_t i, size_t j) const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatForEachExpr.h:504