Blaze  3.6
DVecTransExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DVECTRANSEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DVECTRANSEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <iterator>
44 #include <blaze/math/Aliases.h>
47 #include <blaze/math/Exception.h>
55 #include <blaze/math/SIMD.h>
62 #include <blaze/system/Inline.h>
63 #include <blaze/util/Assert.h>
64 #include <blaze/util/EnableIf.h>
67 #include <blaze/util/InvalidType.h>
68 #include <blaze/util/mpl/If.h>
69 #include <blaze/util/Types.h>
71 
72 
73 namespace blaze {
74 
75 //=================================================================================================
76 //
77 // CLASS DVECTRANSEXPR
78 //
79 //=================================================================================================
80 
81 //*************************************************************************************************
88 template< typename VT // Type of the dense vector
89  , bool TF > // Transpose flag
91  : public VecTransExpr< DenseVector< DVecTransExpr<VT,TF>, TF > >
92  , private If< IsComputation_v<VT>, Computation, Transformation >::Type
93 {
94  private:
95  //**Type definitions****************************************************************************
97 
99  BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT( GetConstIterator, ConstIterator, INVALID_TYPE );
100  //**********************************************************************************************
101 
102  //**Serial evaluation strategy******************************************************************
104 
110  static constexpr bool useAssign = RequiresEvaluation_v<VT>;
111 
113  template< typename VT2 >
115  static constexpr bool UseAssign_v = useAssign;
117  //**********************************************************************************************
118 
119  //**Parallel evaluation strategy****************************************************************
121 
127  template< typename VT2 >
128  static constexpr bool UseSMPAssign_v = ( VT2::smpAssignable && useAssign );
130  //**********************************************************************************************
131 
132  public:
133  //**Type definitions****************************************************************************
140 
143 
145  using ConstIterator = GetConstIterator_t<VT>;
146 
148  using Operand = If_t< IsExpression_v<VT>, const VT, const VT& >;
149  //**********************************************************************************************
150 
151  //**Compilation flags***************************************************************************
153  static constexpr bool simdEnabled = VT::simdEnabled;
154 
156  static constexpr bool smpAssignable = VT::smpAssignable;
157  //**********************************************************************************************
158 
159  //**SIMD properties*****************************************************************************
161  static constexpr size_t SIMDSIZE = SIMDTrait<ElementType>::size;
162  //**********************************************************************************************
163 
164  //**Constructor*********************************************************************************
169  explicit inline DVecTransExpr( const VT& dv ) noexcept
170  : dv_( dv ) // Dense vector of the transposition expression
171  {}
172  //**********************************************************************************************
173 
174  //**Subscript operator**************************************************************************
180  inline ReturnType operator[]( size_t index ) const {
181  BLAZE_INTERNAL_ASSERT( index < dv_.size(), "Invalid vector access index" );
182  return dv_[index];
183  }
184  //**********************************************************************************************
185 
186  //**At function*********************************************************************************
193  inline ReturnType at( size_t index ) const {
194  if( index >= dv_.size() ) {
195  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
196  }
197  return (*this)[index];
198  }
199  //**********************************************************************************************
200 
201  //**Load function*******************************************************************************
207  BLAZE_ALWAYS_INLINE auto load( size_t index ) const noexcept {
208  BLAZE_INTERNAL_ASSERT( index < dv_.size() , "Invalid vector access index" );
209  BLAZE_INTERNAL_ASSERT( index % SIMDSIZE == 0UL , "Invalid vector access index" );
210  return dv_.load( index );
211  }
212  //**********************************************************************************************
213 
214  //**Low-level data access***********************************************************************
219  inline const ElementType* data() const noexcept {
220  return dv_.data();
221  }
222  //**********************************************************************************************
223 
224  //**Begin function******************************************************************************
229  inline ConstIterator begin() const {
230  return ConstIterator( dv_.begin() );
231  }
232  //**********************************************************************************************
233 
234  //**End function********************************************************************************
239  inline ConstIterator end() const {
240  return ConstIterator( dv_.end() );
241  }
242  //**********************************************************************************************
243 
244  //**Size function*******************************************************************************
249  inline size_t size() const noexcept {
250  return dv_.size();
251  }
252  //**********************************************************************************************
253 
254  //**Operand access******************************************************************************
259  inline Operand operand() const noexcept {
260  return dv_;
261  }
262  //**********************************************************************************************
263 
264  //**********************************************************************************************
270  template< typename T >
271  inline bool canAlias( const T* alias ) const noexcept {
272  return dv_.canAlias( alias );
273  }
274  //**********************************************************************************************
275 
276  //**********************************************************************************************
282  template< typename T >
283  inline bool isAliased( const T* alias ) const noexcept {
284  return dv_.isAliased( alias );
285  }
286  //**********************************************************************************************
287 
288  //**********************************************************************************************
293  inline bool isAligned() const noexcept {
294  return dv_.isAligned();
295  }
296  //**********************************************************************************************
297 
298  //**********************************************************************************************
303  inline bool canSMPAssign() const noexcept {
304  return dv_.canSMPAssign();
305  }
306  //**********************************************************************************************
307 
308  private:
309  //**Member variables****************************************************************************
311  //**********************************************************************************************
312 
313  //**Assignment to dense vectors*****************************************************************
327  template< typename VT2 > // Type of the target dense vector
328  friend inline auto assign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
330  {
332 
333  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
334 
335  DVecTransposer<VT2,!TF> tmp( ~lhs );
336  assign( tmp, rhs.dv_ );
337  }
339  //**********************************************************************************************
340 
341  //**Assignment to sparse vectors****************************************************************
355  template< typename VT2 > // Type of the target sparse vector
356  friend inline auto assign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
358  {
360 
361  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
362 
363  SVecTransposer<VT2,!TF> tmp( ~lhs );
364  assign( tmp, rhs.dv_ );
365  }
367  //**********************************************************************************************
368 
369  //**Addition assignment to dense vectors********************************************************
383  template< typename VT2 > // Type of the target dense vector
384  friend inline auto addAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
385  -> EnableIf_t< UseAssign_v<VT2> >
386  {
388 
389  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
390 
391  DVecTransposer<VT2,!TF> tmp( ~lhs );
392  addAssign( tmp, rhs.dv_ );
393  }
395  //**********************************************************************************************
396 
397  //**Addition assignment to sparse vectors*******************************************************
398  // No special implementation for the addition assignment to sparse vectors.
399  //**********************************************************************************************
400 
401  //**Subtraction assignment to dense vectors*****************************************************
415  template< typename VT2 > // Type of the target dense vector
416  friend inline auto subAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
417  -> EnableIf_t< UseAssign_v<VT2> >
418  {
420 
421  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
422 
423  DVecTransposer<VT2,!TF> tmp( ~lhs );
424  subAssign( tmp, rhs.dv_ );
425  }
427  //**********************************************************************************************
428 
429  //**Subtraction assignment to sparse vectors****************************************************
430  // No special implementation for the subtraction assignment to sparse vectors.
431  //**********************************************************************************************
432 
433  //**Multiplication assignment to dense vectors**************************************************
447  template< typename VT2 > // Type of the target dense vector
448  friend inline auto multAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
449  -> EnableIf_t< UseAssign_v<VT2> >
450  {
452 
453  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
454 
455  DVecTransposer<VT2,!TF> tmp( ~lhs );
456  multAssign( tmp, rhs.dv_ );
457  }
459  //**********************************************************************************************
460 
461  //**Multiplication assignment to sparse vectors*************************************************
462  // No special implementation for the multiplication assignment to sparse vectors.
463  //**********************************************************************************************
464 
465  //**Division assignment to dense vectors********************************************************
479  template< typename VT2 > // Type of the target dense vector
480  friend inline auto divAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
481  -> EnableIf_t< UseAssign_v<VT2> >
482  {
484 
485  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
486 
487  DVecTransposer<VT2,!TF> tmp( ~lhs );
488  divAssign( tmp, rhs.dv_ );
489  }
491  //**********************************************************************************************
492 
493  //**Division assignment to sparse vectors*******************************************************
494  // No special implementation for the division assignment to sparse vectors.
495  //**********************************************************************************************
496 
497  //**SMP assignment to dense vectors*************************************************************
511  template< typename VT2 > // Type of the target dense vector
512  friend inline auto smpAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
513  -> EnableIf_t< UseSMPAssign_v<VT2> >
514  {
516 
517  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
518 
519  DVecTransposer<VT2,!TF> tmp( ~lhs );
520  smpAssign( tmp, rhs.dv_ );
521  }
523  //**********************************************************************************************
524 
525  //**SMP assignment to sparse vectors************************************************************
539  template< typename VT2 > // Type of the target sparse vector
540  friend inline auto smpAssign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
541  -> EnableIf_t< UseSMPAssign_v<VT2> >
542  {
544 
545  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
546 
547  SVecTransposer<VT2,!TF> tmp( ~lhs );
548  smpAssign( tmp, rhs.dv_ );
549  }
551  //**********************************************************************************************
552 
553  //**SMP addition assignment to dense vectors****************************************************
567  template< typename VT2 > // Type of the target dense vector
568  friend inline auto smpAddAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
569  -> EnableIf_t< UseSMPAssign_v<VT2> >
570  {
572 
573  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
574 
575  DVecTransposer<VT2,!TF> tmp( ~lhs );
576  smpAddAssign( tmp, rhs.dv_ );
577  }
579  //**********************************************************************************************
580 
581  //**SMP addition assignment to sparse vectors***************************************************
582  // No special implementation for the SMP addition assignment to sparse vectors.
583  //**********************************************************************************************
584 
585  //**SMP subtraction assignment to dense vectors*************************************************
599  template< typename VT2 > // Type of the target dense vector
600  friend inline auto smpSubAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
601  -> EnableIf_t< UseSMPAssign_v<VT2> >
602  {
604 
605  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
606 
607  DVecTransposer<VT2,!TF> tmp( ~lhs );
608  smpSubAssign( tmp, rhs.dv_ );
609  }
611  //**********************************************************************************************
612 
613  //**SMP subtraction assignment to sparse vectors************************************************
614  // No special implementation for the SMP subtraction assignment to sparse vectors.
615  //**********************************************************************************************
616 
617  //**SMP multiplication assignment to dense vectors**********************************************
631  template< typename VT2 > // Type of the target dense vector
632  friend inline auto smpMultAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
633  -> EnableIf_t< UseSMPAssign_v<VT2> >
634  {
636 
637  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
638 
639  DVecTransposer<VT2,!TF> tmp( ~lhs );
640  smpMultAssign( tmp, rhs.dv_ );
641  }
643  //**********************************************************************************************
644 
645  //**SMP multiplication assignment to sparse vectors*********************************************
646  // No special implementation for the SMP multiplication assignment to sparse vectors.
647  //**********************************************************************************************
648 
649  //**SMP division assignment to dense vectors****************************************************
663  template< typename VT2 > // Type of the target dense vector
664  friend inline auto smpDivAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
665  -> EnableIf_t< UseSMPAssign_v<VT2> >
666  {
668 
669  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
670 
671  DVecTransposer<VT2,!TF> tmp( ~lhs );
672  smpDivAssign( tmp, rhs.dv_ );
673  }
675  //**********************************************************************************************
676 
677  //**SMP division assignment to sparse vectors***************************************************
678  // No special implementation for the SMP division assignment to sparse vectors.
679  //**********************************************************************************************
680 
681  //**Compile time checks*************************************************************************
686  //**********************************************************************************************
687 };
688 //*************************************************************************************************
689 
690 
691 
692 
693 //=================================================================================================
694 //
695 // GLOBAL OPERATORS
696 //
697 //=================================================================================================
698 
699 //*************************************************************************************************
718 template< typename VT // Type of the dense vector
719  , bool TF > // Transpose flag
720 inline decltype(auto) trans( const DenseVector<VT,TF>& dv )
721 {
723 
724  using ReturnType = const DVecTransExpr<VT,!TF>;
725  return ReturnType( ~dv );
726 }
727 //*************************************************************************************************
728 
729 
730 //*************************************************************************************************
738 template< typename VT // Type of the dense vector
739  , bool TF > // Transpose flag
740 inline decltype(auto) transTo_backend( const DenseVector<VT,TF>& dv, FalseType )
741 {
742  return trans( ~dv );
743 }
745 //*************************************************************************************************
746 
747 
748 //*************************************************************************************************
756 template< typename VT // Type of the dense vector
757  , bool TF > // Transpose flag
758 inline const VT& transTo_backend( const DenseVector<VT,TF>& dv, TrueType )
759 {
760  return ~dv;
761 }
763 //*************************************************************************************************
764 
765 
766 //*************************************************************************************************
778 template< bool TTF // Target transpose flag
779  , typename VT // Type of the dense vector
780  , bool TF > // Current transpose flag of the dense vector
781 inline decltype(auto) transTo( const DenseVector<VT,TF>& dv )
782 {
783  return transTo_backend( ~dv, BoolConstant<TTF == TF>() );
784 }
785 //*************************************************************************************************
786 
787 
788 
789 
790 //=================================================================================================
791 //
792 // GLOBAL RESTRUCTURING FUNCTIONS
793 //
794 //=================================================================================================
795 
796 //*************************************************************************************************
816 template< typename VT // Type of the dense vector
817  , bool TF > // Transpose flag
818 inline decltype(auto) trans( const DVecTransExpr<VT,TF>& dv )
819 {
821 
822  return dv.operand();
823 }
825 //*************************************************************************************************
826 
827 
828 //*************************************************************************************************
840 template< typename VT // Type of the left-hand side dense vector
841  , typename ST // Type of the right-hand side scalar value
842  , bool TF > // Transpose flag
843 inline decltype(auto) trans( const DVecScalarMultExpr<VT,ST,TF>& dv )
844 {
846 
847  return trans( dv.leftOperand() ) * dv.rightOperand();
848 }
850 //*************************************************************************************************
851 
852 
853 
854 
855 //=================================================================================================
856 //
857 // ISALIGNED SPECIALIZATIONS
858 //
859 //=================================================================================================
860 
861 //*************************************************************************************************
863 template< typename VT, bool TF >
864 struct HasConstDataAccess< DVecTransExpr<VT,TF> >
865  : public HasConstDataAccess<VT>
866 {};
868 //*************************************************************************************************
869 
870 
871 
872 
873 //=================================================================================================
874 //
875 // ISALIGNED SPECIALIZATIONS
876 //
877 //=================================================================================================
878 
879 //*************************************************************************************************
881 template< typename VT, bool TF >
882 struct IsAligned< DVecTransExpr<VT,TF> >
883  : public IsAligned<VT>
884 {};
886 //*************************************************************************************************
887 
888 
889 
890 
891 //=================================================================================================
892 //
893 // ISPADDED SPECIALIZATIONS
894 //
895 //=================================================================================================
896 
897 //*************************************************************************************************
899 template< typename VT, bool TF >
900 struct IsPadded< DVecTransExpr<VT,TF> >
901  : public IsPadded<VT>
902 {};
904 //*************************************************************************************************
905 
906 } // namespace blaze
907 
908 #endif
BoolConstant< false > FalseType
Type/value traits base class.The FalseType class is used as base class for type traits and value trai...
Definition: IntegralConstant.h:121
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DVecTransExpr.h:283
Header file for auxiliary alias declarations.
const ElementType * data() const noexcept
Low-level data access to the vector elements.
Definition: DVecTransExpr.h:219
Base class for all vector transposition expression templates.The VecTransExpr class serves as a tag f...
Definition: VecTransExpr.h:66
Compile time type selection.The If class template selects one of the two given types T1 and T2 depend...
Definition: If.h:59
CompositeType_t< VT > CT
Composite type of the dense vector expression.
Definition: DVecTransExpr.h:96
Header file for basic type definitions.
typename If< Condition, T1, T2 >::Type If_t
Auxiliary alias template for the If class template.The If_t alias template provides a convenient shor...
Definition: If.h:109
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.The ResultType_t alias declaration provides ...
Definition: Aliases.h:390
DVecTransExpr(const VT &dv) noexcept
Constructor for the DVecTransExpr class.
Definition: DVecTransExpr.h:169
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecTransExpr.h:180
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:72
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the transposition expression.
Definition: DVecTransExpr.h:110
Header file for the DenseVector base class.
Header file for the Computation base class.
BoolConstant< true > TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: IntegralConstant.h:132
Header file for the RequiresEvaluation type trait.
BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT(GetConstIterator, ConstIterator, INVALID_TYPE)
Definition of the GetConstIterator type trait.
typename T::ReturnType ReturnType_t
Alias declaration for nested ReturnType type definitions.The ReturnType_t alias declaration provides ...
Definition: Aliases.h:410
Operand operand() const noexcept
Returns the dense vector operand.
Definition: DVecTransExpr.h:259
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.The ElementType_t alias declaration provide...
Definition: Aliases.h:170
auto smpDivAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP division assignment of a vector to a dense vector.
Definition: DenseVector.h:220
Expression object for the transposition of a dense vector.The DVecTransposer class is a wrapper objec...
Definition: DVecTransposer.h:78
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: DVecTransExpr.h:153
Operand dv_
Dense vector of the transposition expression.
Definition: DVecTransExpr.h:310
If_t< useAssign, const ResultType, const DVecTransExpr & > CompositeType
Data type for composite expression templates.
Definition: DVecTransExpr.h:142
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.The EnableIf_t alias declaration provides a convenient...
Definition: EnableIf.h:138
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: DVecTransExpr.h:156
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DVecTransExpr.h:271
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Header file for the If class template.
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: DVecTransExpr.h:193
Header file for the dense vector transposer.
Header file for the Transformation base class.
#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
static constexpr size_t SIMDSIZE
The number of elements packed within a single SIMD element.
Definition: DVecTransExpr.h:161
TransposeType_t< VT > ResultType
Result type for expression template evaluations.
Definition: DVecTransExpr.h:136
Expression object for the transposition of a sparse vector.The SVecTransposer class is a wrapper obje...
Definition: Forward.h:166
Header file for all SIMD functionality.
BLAZE_ALWAYS_INLINE auto load(size_t index) const noexcept
Access to the SIMD elements of the vector.
Definition: DVecTransExpr.h:207
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:76
Header file for the GetMemberType type trait.
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: DVecTransExpr.h:249
Header file for the IsAligned type trait.
ConstIterator end() const
Returns an iterator just past the last non-zero element of the dense vector.
Definition: DVecTransExpr.h:239
Constraint on the data type.
decltype(auto) transTo(const DenseVector< VT, TF > &dv)
Conditional calculation of the transpose of the given dense vector.
Definition: DVecTransExpr.h:781
Constraint on the data type.
Header file for the exception macros of the math module.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DVecTransExpr.h:303
Header file for the EnableIf class template.
Header file for the IsPadded type trait.
ConstIterator begin() const
Returns an iterator to the first non-zero element of the dense vector.
Definition: DVecTransExpr.h:229
Header file for the HasConstDataAccess type trait.
Header file for the VecTransExpr base class.
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DVecTransExpr.h:293
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.The TransposeType_t alias declaration pro...
Definition: Aliases.h:470
Header file for run time assertion macros.
typename T::CompositeType CompositeType_t
Alias declaration for nested CompositeType type definitions.The CompositeType_t alias declaration pro...
Definition: Aliases.h:90
Utility type for generic codes.
auto smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:131
GetConstIterator_t< VT > ConstIterator
Iterator over the elements of the dense vector.
Definition: DVecTransExpr.h:145
If_t< IsExpression_v< VT >, const VT, const VT & > Operand
Composite data type of the dense vector expression.
Definition: DVecTransExpr.h:148
SIMD characteristics of data types.The SIMDTrait class template provides the SIMD characteristics of ...
Definition: SIMDTrait.h:295
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Header file for all forward declarations for expression class templates.
auto smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:100
ReturnType_t< VT > ReturnType
Return type for expression template evaluations.
Definition: DVecTransExpr.h:139
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional vector type,...
Definition: DenseVector.h:61
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:765
Header file for the sparse vector transposer.
Header file for the IsComputation type trait class.
auto smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:162
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:146
Header file for the IntegralConstant class template.
ResultType_t< VT > TransposeType
Transpose type for expression template evaluations.
Definition: DVecTransExpr.h:137
Expression object for dense vector transpositions.The DVecTransExpr class represents the compile time...
Definition: DVecTransExpr.h:90
ElementType_t< VT > ElementType
Resulting element type.
Definition: DVecTransExpr.h:138
System settings for the inline keywords.
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF)
Constraint on the data type.In case the given data type T is not a dense or sparse vector type and in...
Definition: TransposeFlag.h:63
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression,...
Definition: Assert.h:101
auto smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP multiplication assignment of a vector to a dense vector.
Definition: DenseVector.h:191
Header file for the IsExpression type trait class.
Header file for the function trace functionality.