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>
65 #include <blaze/util/FalseType.h>
68 #include <blaze/util/InvalidType.h>
69 #include <blaze/util/mpl/If.h>
70 #include <blaze/util/TrueType.h>
71 #include <blaze/util/Types.h>
73 
74 
75 namespace blaze {
76 
77 //=================================================================================================
78 //
79 // CLASS DVECTRANSEXPR
80 //
81 //=================================================================================================
82 
83 //*************************************************************************************************
90 template< typename VT // Type of the dense vector
91  , bool TF > // Transpose flag
93  : public VecTransExpr< DenseVector< DVecTransExpr<VT,TF>, TF > >
94  , private If< IsComputation_v<VT>, Computation, Transformation >::Type
95 {
96  private:
97  //**Type definitions****************************************************************************
99 
101  BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT( GetConstIterator, ConstIterator, INVALID_TYPE );
102  //**********************************************************************************************
103 
104  //**Serial evaluation strategy******************************************************************
106 
112  static constexpr bool useAssign = RequiresEvaluation_v<VT>;
113 
115  template< typename VT2 >
117  static constexpr bool UseAssign_v = useAssign;
119  //**********************************************************************************************
120 
121  //**Parallel evaluation strategy****************************************************************
123 
129  template< typename VT2 >
130  static constexpr bool UseSMPAssign_v = ( VT2::smpAssignable && useAssign );
132  //**********************************************************************************************
133 
134  public:
135  //**Type definitions****************************************************************************
142 
145 
147  using ConstIterator = GetConstIterator_t<VT>;
148 
150  using Operand = If_t< IsExpression_v<VT>, const VT, const VT& >;
151  //**********************************************************************************************
152 
153  //**Compilation flags***************************************************************************
155  static constexpr bool simdEnabled = VT::simdEnabled;
156 
158  static constexpr bool smpAssignable = VT::smpAssignable;
159  //**********************************************************************************************
160 
161  //**SIMD properties*****************************************************************************
163  static constexpr size_t SIMDSIZE = SIMDTrait<ElementType>::size;
164  //**********************************************************************************************
165 
166  //**Constructor*********************************************************************************
171  explicit inline DVecTransExpr( const VT& dv ) noexcept
172  : dv_( dv ) // Dense vector of the transposition expression
173  {}
174  //**********************************************************************************************
175 
176  //**Subscript operator**************************************************************************
182  inline ReturnType operator[]( size_t index ) const {
183  BLAZE_INTERNAL_ASSERT( index < dv_.size(), "Invalid vector access index" );
184  return dv_[index];
185  }
186  //**********************************************************************************************
187 
188  //**At function*********************************************************************************
195  inline ReturnType at( size_t index ) const {
196  if( index >= dv_.size() ) {
197  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
198  }
199  return (*this)[index];
200  }
201  //**********************************************************************************************
202 
203  //**Load function*******************************************************************************
209  BLAZE_ALWAYS_INLINE auto load( size_t index ) const noexcept {
210  BLAZE_INTERNAL_ASSERT( index < dv_.size() , "Invalid vector access index" );
211  BLAZE_INTERNAL_ASSERT( index % SIMDSIZE == 0UL , "Invalid vector access index" );
212  return dv_.load( index );
213  }
214  //**********************************************************************************************
215 
216  //**Low-level data access***********************************************************************
221  inline const ElementType* data() const noexcept {
222  return dv_.data();
223  }
224  //**********************************************************************************************
225 
226  //**Begin function******************************************************************************
231  inline ConstIterator begin() const {
232  return ConstIterator( dv_.begin() );
233  }
234  //**********************************************************************************************
235 
236  //**End function********************************************************************************
241  inline ConstIterator end() const {
242  return ConstIterator( dv_.end() );
243  }
244  //**********************************************************************************************
245 
246  //**Size function*******************************************************************************
251  inline size_t size() const noexcept {
252  return dv_.size();
253  }
254  //**********************************************************************************************
255 
256  //**Operand access******************************************************************************
261  inline Operand operand() const noexcept {
262  return dv_;
263  }
264  //**********************************************************************************************
265 
266  //**********************************************************************************************
272  template< typename T >
273  inline bool canAlias( const T* alias ) const noexcept {
274  return dv_.canAlias( alias );
275  }
276  //**********************************************************************************************
277 
278  //**********************************************************************************************
284  template< typename T >
285  inline bool isAliased( const T* alias ) const noexcept {
286  return dv_.isAliased( alias );
287  }
288  //**********************************************************************************************
289 
290  //**********************************************************************************************
295  inline bool isAligned() const noexcept {
296  return dv_.isAligned();
297  }
298  //**********************************************************************************************
299 
300  //**********************************************************************************************
305  inline bool canSMPAssign() const noexcept {
306  return dv_.canSMPAssign();
307  }
308  //**********************************************************************************************
309 
310  private:
311  //**Member variables****************************************************************************
313  //**********************************************************************************************
314 
315  //**Assignment to dense vectors*****************************************************************
329  template< typename VT2 > // Type of the target dense vector
330  friend inline auto assign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
332  {
334 
335  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
336 
337  DVecTransposer<VT2,!TF> tmp( ~lhs );
338  assign( tmp, rhs.dv_ );
339  }
341  //**********************************************************************************************
342 
343  //**Assignment to sparse vectors****************************************************************
357  template< typename VT2 > // Type of the target sparse vector
358  friend inline auto assign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
360  {
362 
363  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
364 
365  SVecTransposer<VT2,!TF> tmp( ~lhs );
366  assign( tmp, rhs.dv_ );
367  }
369  //**********************************************************************************************
370 
371  //**Addition assignment to dense vectors********************************************************
385  template< typename VT2 > // Type of the target dense vector
386  friend inline auto addAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
387  -> EnableIf_t< UseAssign_v<VT2> >
388  {
390 
391  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
392 
393  DVecTransposer<VT2,!TF> tmp( ~lhs );
394  addAssign( tmp, rhs.dv_ );
395  }
397  //**********************************************************************************************
398 
399  //**Addition assignment to sparse vectors*******************************************************
400  // No special implementation for the addition assignment to sparse vectors.
401  //**********************************************************************************************
402 
403  //**Subtraction assignment to dense vectors*****************************************************
417  template< typename VT2 > // Type of the target dense vector
418  friend inline auto subAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
419  -> EnableIf_t< UseAssign_v<VT2> >
420  {
422 
423  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
424 
425  DVecTransposer<VT2,!TF> tmp( ~lhs );
426  subAssign( tmp, rhs.dv_ );
427  }
429  //**********************************************************************************************
430 
431  //**Subtraction assignment to sparse vectors****************************************************
432  // No special implementation for the subtraction assignment to sparse vectors.
433  //**********************************************************************************************
434 
435  //**Multiplication assignment to dense vectors**************************************************
449  template< typename VT2 > // Type of the target dense vector
450  friend inline auto multAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
451  -> EnableIf_t< UseAssign_v<VT2> >
452  {
454 
455  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
456 
457  DVecTransposer<VT2,!TF> tmp( ~lhs );
458  multAssign( tmp, rhs.dv_ );
459  }
461  //**********************************************************************************************
462 
463  //**Multiplication assignment to sparse vectors*************************************************
464  // No special implementation for the multiplication assignment to sparse vectors.
465  //**********************************************************************************************
466 
467  //**Division assignment to dense vectors********************************************************
481  template< typename VT2 > // Type of the target dense vector
482  friend inline auto divAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
483  -> EnableIf_t< UseAssign_v<VT2> >
484  {
486 
487  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
488 
489  DVecTransposer<VT2,!TF> tmp( ~lhs );
490  divAssign( tmp, rhs.dv_ );
491  }
493  //**********************************************************************************************
494 
495  //**Division assignment to sparse vectors*******************************************************
496  // No special implementation for the division assignment to sparse vectors.
497  //**********************************************************************************************
498 
499  //**SMP assignment to dense vectors*************************************************************
513  template< typename VT2 > // Type of the target dense vector
514  friend inline auto smpAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
515  -> EnableIf_t< UseSMPAssign_v<VT2> >
516  {
518 
519  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
520 
521  DVecTransposer<VT2,!TF> tmp( ~lhs );
522  smpAssign( tmp, rhs.dv_ );
523  }
525  //**********************************************************************************************
526 
527  //**SMP assignment to sparse vectors************************************************************
541  template< typename VT2 > // Type of the target sparse vector
542  friend inline auto smpAssign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
543  -> EnableIf_t< UseSMPAssign_v<VT2> >
544  {
546 
547  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
548 
549  SVecTransposer<VT2,!TF> tmp( ~lhs );
550  smpAssign( tmp, rhs.dv_ );
551  }
553  //**********************************************************************************************
554 
555  //**SMP addition assignment to dense vectors****************************************************
569  template< typename VT2 > // Type of the target dense vector
570  friend inline auto smpAddAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
571  -> EnableIf_t< UseSMPAssign_v<VT2> >
572  {
574 
575  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
576 
577  DVecTransposer<VT2,!TF> tmp( ~lhs );
578  smpAddAssign( tmp, rhs.dv_ );
579  }
581  //**********************************************************************************************
582 
583  //**SMP addition assignment to sparse vectors***************************************************
584  // No special implementation for the SMP addition assignment to sparse vectors.
585  //**********************************************************************************************
586 
587  //**SMP subtraction assignment to dense vectors*************************************************
601  template< typename VT2 > // Type of the target dense vector
602  friend inline auto smpSubAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
603  -> EnableIf_t< UseSMPAssign_v<VT2> >
604  {
606 
607  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
608 
609  DVecTransposer<VT2,!TF> tmp( ~lhs );
610  smpSubAssign( tmp, rhs.dv_ );
611  }
613  //**********************************************************************************************
614 
615  //**SMP subtraction assignment to sparse vectors************************************************
616  // No special implementation for the SMP subtraction assignment to sparse vectors.
617  //**********************************************************************************************
618 
619  //**SMP multiplication assignment to dense vectors**********************************************
633  template< typename VT2 > // Type of the target dense vector
634  friend inline auto smpMultAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
635  -> EnableIf_t< UseSMPAssign_v<VT2> >
636  {
638 
639  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
640 
641  DVecTransposer<VT2,!TF> tmp( ~lhs );
642  smpMultAssign( tmp, rhs.dv_ );
643  }
645  //**********************************************************************************************
646 
647  //**SMP multiplication assignment to sparse vectors*********************************************
648  // No special implementation for the SMP multiplication assignment to sparse vectors.
649  //**********************************************************************************************
650 
651  //**SMP division assignment to dense vectors****************************************************
665  template< typename VT2 > // Type of the target dense vector
666  friend inline auto smpDivAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
667  -> EnableIf_t< UseSMPAssign_v<VT2> >
668  {
670 
671  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
672 
673  DVecTransposer<VT2,!TF> tmp( ~lhs );
674  smpDivAssign( tmp, rhs.dv_ );
675  }
677  //**********************************************************************************************
678 
679  //**SMP division assignment to sparse vectors***************************************************
680  // No special implementation for the SMP division assignment to sparse vectors.
681  //**********************************************************************************************
682 
683  //**Compile time checks*************************************************************************
688  //**********************************************************************************************
689 };
690 //*************************************************************************************************
691 
692 
693 
694 
695 //=================================================================================================
696 //
697 // GLOBAL OPERATORS
698 //
699 //=================================================================================================
700 
701 //*************************************************************************************************
720 template< typename VT // Type of the dense vector
721  , bool TF > // Transpose flag
722 inline decltype(auto) trans( const DenseVector<VT,TF>& dv )
723 {
725 
726  using ReturnType = const DVecTransExpr<VT,!TF>;
727  return ReturnType( ~dv );
728 }
729 //*************************************************************************************************
730 
731 
732 //*************************************************************************************************
740 template< typename VT // Type of the dense vector
741  , bool TF > // Transpose flag
742 inline decltype(auto) transTo_backend( const DenseVector<VT,TF>& dv, FalseType )
743 {
744  return trans( ~dv );
745 }
747 //*************************************************************************************************
748 
749 
750 //*************************************************************************************************
758 template< typename VT // Type of the dense vector
759  , bool TF > // Transpose flag
760 inline const VT& transTo_backend( const DenseVector<VT,TF>& dv, TrueType )
761 {
762  return ~dv;
763 }
765 //*************************************************************************************************
766 
767 
768 //*************************************************************************************************
780 template< bool TTF // Target transpose flag
781  , typename VT // Type of the dense vector
782  , bool TF > // Current transpose flag of the dense vector
783 inline decltype(auto) transTo( const DenseVector<VT,TF>& dv )
784 {
785  return transTo_backend( ~dv, BoolConstant<TTF == TF>() );
786 }
787 //*************************************************************************************************
788 
789 
790 
791 
792 //=================================================================================================
793 //
794 // GLOBAL RESTRUCTURING FUNCTIONS
795 //
796 //=================================================================================================
797 
798 //*************************************************************************************************
818 template< typename VT // Type of the dense vector
819  , bool TF > // Transpose flag
820 inline decltype(auto) trans( const DVecTransExpr<VT,TF>& dv )
821 {
823 
824  return dv.operand();
825 }
827 //*************************************************************************************************
828 
829 
830 //*************************************************************************************************
842 template< typename VT // Type of the left-hand side dense vector
843  , typename ST // Type of the right-hand side scalar value
844  , bool TF > // Transpose flag
845 inline decltype(auto) trans( const DVecScalarMultExpr<VT,ST,TF>& dv )
846 {
848 
849  return trans( dv.leftOperand() ) * dv.rightOperand();
850 }
852 //*************************************************************************************************
853 
854 
855 
856 
857 //=================================================================================================
858 //
859 // ISALIGNED SPECIALIZATIONS
860 //
861 //=================================================================================================
862 
863 //*************************************************************************************************
865 template< typename VT, bool TF >
866 struct HasConstDataAccess< DVecTransExpr<VT,TF> >
867  : public HasConstDataAccess<VT>
868 {};
870 //*************************************************************************************************
871 
872 
873 
874 
875 //=================================================================================================
876 //
877 // ISALIGNED SPECIALIZATIONS
878 //
879 //=================================================================================================
880 
881 //*************************************************************************************************
883 template< typename VT, bool TF >
884 struct IsAligned< DVecTransExpr<VT,TF> >
885  : public IsAligned<VT>
886 {};
888 //*************************************************************************************************
889 
890 
891 
892 
893 //=================================================================================================
894 //
895 // ISPADDED SPECIALIZATIONS
896 //
897 //=================================================================================================
898 
899 //*************************************************************************************************
901 template< typename VT, bool TF >
902 struct IsPadded< DVecTransExpr<VT,TF> >
903  : public IsPadded<VT>
904 {};
906 //*************************************************************************************************
907 
908 } // namespace blaze
909 
910 #endif
BoolConstant< false > FalseType
Type/value traits base class.The FalseType class is used as base class for type traits and value trai...
Definition: FalseType.h:61
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DVecTransExpr.h:285
Header file for auxiliary alias declarations.
const ElementType * data() const noexcept
Low-level data access to the vector elements.
Definition: DVecTransExpr.h:221
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:98
Header file for basic type definitions.
typename If< Condition, T1, T2 >::Type If_t
Auxiliary alias declaration for the If class template.The If_t alias declaration provides a convenien...
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
Header file for the FalseType type/value trait base class.
DVecTransExpr(const VT &dv) noexcept
Constructor for the DVecTransExpr class.
Definition: DVecTransExpr.h:171
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecTransExpr.h:182
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
static constexpr bool smpAssignable
Compilation flag for SMP assignments.
Definition: CompressedMatrix.h:3113
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the transposition expression.
Definition: DVecTransExpr.h:112
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: TrueType.h:61
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:261
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:77
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: DVecTransExpr.h:155
Operand dv_
Dense vector of the transposition expression.
Definition: DVecTransExpr.h:312
If_t< useAssign, const ResultType, const DVecTransExpr &> CompositeType
Data type for composite expression templates.
Definition: DVecTransExpr.h:144
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:158
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DVecTransExpr.h:273
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:195
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:163
TransposeType_t< VT > ResultType
Result type for expression template evaluations.
Definition: DVecTransExpr.h:138
Expression object for the transposition of a sparse vector.The SVecTransposer class is a wrapper obje...
Definition: Forward.h:156
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:209
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:251
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:241
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:783
Constraint on the data type.
Header file for the exception macros of the math module.
Header file for all forward declarations for expression class templates.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DVecTransExpr.h:305
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:231
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:295
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:147
If_t< IsExpression_v< VT >, const VT, const VT &> Operand
Composite data type of the dense vector expression.
Definition: DVecTransExpr.h:150
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
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:141
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3081
#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:138
Header file for the IntegralConstant class template.
ResultType_t< VT > TransposeType
Transpose type for expression template evaluations.
Definition: DVecTransExpr.h:139
Expression object for dense vector transpositions.The DVecTransExpr class represents the compile time...
Definition: DVecTransExpr.h:92
ElementType_t< VT > ElementType
Resulting element type.
Definition: DVecTransExpr.h:140
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, 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
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 TrueType type/value trait base class.
Header file for the IsExpression type trait class.
Header file for the function trace functionality.