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>
70 
71 
72 namespace blaze {
73 
74 //=================================================================================================
75 //
76 // CLASS DVECTRANSEXPR
77 //
78 //=================================================================================================
79 
80 //*************************************************************************************************
87 template< typename VT // Type of the dense vector
88  , bool TF > // Transpose flag
90  : public VecTransExpr< DenseVector< DVecTransExpr<VT,TF>, TF > >
91  , private If< IsComputation<VT>, Computation, Transformation >::Type
92 {
93  private:
94  //**Type definitions****************************************************************************
96  //**********************************************************************************************
97 
98  //**Serial evaluation strategy******************************************************************
100 
106  enum : bool { useAssign = RequiresEvaluation<VT>::value };
107 
109  template< typename VT2 >
111  struct UseAssign {
112  enum : bool { value = useAssign };
113  };
115  //**********************************************************************************************
116 
117  //**Parallel evaluation strategy****************************************************************
119 
124  template< typename VT2 >
125  struct UseSMPAssign {
126  enum : bool { value = VT2::smpAssignable && useAssign };
127  };
129  //**********************************************************************************************
130 
131  //**********************************************************************************************
133 
137  template< typename VT2 >
138  struct GetConstIterator {
140  struct Success { using Type = typename VT2::ConstIterator; };
141  struct Failure { using Type = INVALID_TYPE; };
142  using Type = typename If_< HasConstIterator<VT2>, Success, Failure >::Type;
143  };
145  //**********************************************************************************************
146 
147  public:
148  //**Type definitions****************************************************************************
154 
157 
159  using ConstIterator = typename GetConstIterator<VT>::Type;
160 
162  using Operand = If_< IsExpression<VT>, const VT, const VT& >;
163  //**********************************************************************************************
164 
165  //**Compilation flags***************************************************************************
167  enum : bool { simdEnabled = VT::simdEnabled };
168 
170  enum : bool { smpAssignable = VT::smpAssignable };
171  //**********************************************************************************************
172 
173  //**SIMD properties*****************************************************************************
175  enum : size_t { SIMDSIZE = SIMDTrait<ElementType>::size };
176  //**********************************************************************************************
177 
178  //**Constructor*********************************************************************************
183  explicit inline DVecTransExpr( const VT& dv ) noexcept
184  : dv_( dv ) // Dense vector of the transposition expression
185  {}
186  //**********************************************************************************************
187 
188  //**Subscript operator**************************************************************************
194  inline ReturnType operator[]( size_t index ) const {
195  BLAZE_INTERNAL_ASSERT( index < dv_.size(), "Invalid vector access index" );
196  return dv_[index];
197  }
198  //**********************************************************************************************
199 
200  //**At function*********************************************************************************
207  inline ReturnType at( size_t index ) const {
208  if( index >= dv_.size() ) {
209  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
210  }
211  return (*this)[index];
212  }
213  //**********************************************************************************************
214 
215  //**Load function*******************************************************************************
221  BLAZE_ALWAYS_INLINE auto load( size_t index ) const noexcept {
222  BLAZE_INTERNAL_ASSERT( index < dv_.size() , "Invalid vector access index" );
223  BLAZE_INTERNAL_ASSERT( index % SIMDSIZE == 0UL , "Invalid vector access index" );
224  return dv_.load( index );
225  }
226  //**********************************************************************************************
227 
228  //**Low-level data access***********************************************************************
233  inline const ElementType* data() const noexcept {
234  return dv_.data();
235  }
236  //**********************************************************************************************
237 
238  //**Begin function******************************************************************************
243  inline ConstIterator begin() const {
244  return ConstIterator( dv_.begin() );
245  }
246  //**********************************************************************************************
247 
248  //**End function********************************************************************************
253  inline ConstIterator end() const {
254  return ConstIterator( dv_.end() );
255  }
256  //**********************************************************************************************
257 
258  //**Size function*******************************************************************************
263  inline size_t size() const noexcept {
264  return dv_.size();
265  }
266  //**********************************************************************************************
267 
268  //**Operand access******************************************************************************
273  inline Operand operand() const noexcept {
274  return dv_;
275  }
276  //**********************************************************************************************
277 
278  //**********************************************************************************************
284  template< typename T >
285  inline bool canAlias( const T* alias ) const noexcept {
286  return dv_.canAlias( alias );
287  }
288  //**********************************************************************************************
289 
290  //**********************************************************************************************
296  template< typename T >
297  inline bool isAliased( const T* alias ) const noexcept {
298  return dv_.isAliased( alias );
299  }
300  //**********************************************************************************************
301 
302  //**********************************************************************************************
307  inline bool isAligned() const noexcept {
308  return dv_.isAligned();
309  }
310  //**********************************************************************************************
311 
312  //**********************************************************************************************
317  inline bool canSMPAssign() const noexcept {
318  return dv_.canSMPAssign();
319  }
320  //**********************************************************************************************
321 
322  private:
323  //**Member variables****************************************************************************
325  //**********************************************************************************************
326 
327  //**Assignment to dense vectors*****************************************************************
341  template< typename VT2 > // Type of the target dense vector
342  friend inline EnableIf_< UseAssign<VT2> >
343  assign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
344  {
346 
347  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
348 
349  DVecTransposer<VT2,!TF> tmp( ~lhs );
350  assign( tmp, rhs.dv_ );
351  }
353  //**********************************************************************************************
354 
355  //**Assignment to sparse vectors****************************************************************
369  template< typename VT2 > // Type of the target sparse vector
370  friend inline EnableIf_< UseAssign<VT2> >
371  assign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
372  {
374 
375  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
376 
377  SVecTransposer<VT2,!TF> tmp( ~lhs );
378  assign( tmp, rhs.dv_ );
379  }
381  //**********************************************************************************************
382 
383  //**Addition assignment to dense vectors********************************************************
397  template< typename VT2 > // Type of the target dense vector
398  friend inline EnableIf_< UseAssign<VT2> >
399  addAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
400  {
402 
403  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
404 
405  DVecTransposer<VT2,!TF> tmp( ~lhs );
406  addAssign( tmp, rhs.dv_ );
407  }
409  //**********************************************************************************************
410 
411  //**Addition assignment to sparse vectors*******************************************************
412  // No special implementation for the addition assignment to sparse vectors.
413  //**********************************************************************************************
414 
415  //**Subtraction assignment to dense vectors*****************************************************
429  template< typename VT2 > // Type of the target dense vector
430  friend inline EnableIf_< UseAssign<VT2> >
431  subAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
432  {
434 
435  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
436 
437  DVecTransposer<VT2,!TF> tmp( ~lhs );
438  subAssign( tmp, rhs.dv_ );
439  }
441  //**********************************************************************************************
442 
443  //**Subtraction assignment to sparse vectors****************************************************
444  // No special implementation for the subtraction assignment to sparse vectors.
445  //**********************************************************************************************
446 
447  //**Multiplication assignment to dense vectors**************************************************
461  template< typename VT2 > // Type of the target dense vector
462  friend inline EnableIf_< UseAssign<VT2> >
463  multAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
464  {
466 
467  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
468 
469  DVecTransposer<VT2,!TF> tmp( ~lhs );
470  multAssign( tmp, rhs.dv_ );
471  }
473  //**********************************************************************************************
474 
475  //**Multiplication assignment to sparse vectors*************************************************
476  // No special implementation for the multiplication assignment to sparse vectors.
477  //**********************************************************************************************
478 
479  //**Division assignment to dense vectors********************************************************
493  template< typename VT2 > // Type of the target dense vector
494  friend inline EnableIf_< UseAssign<VT2> >
495  divAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
496  {
498 
499  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
500 
501  DVecTransposer<VT2,!TF> tmp( ~lhs );
502  divAssign( tmp, rhs.dv_ );
503  }
505  //**********************************************************************************************
506 
507  //**Division assignment to sparse vectors*******************************************************
508  // No special implementation for the division assignment to sparse vectors.
509  //**********************************************************************************************
510 
511  //**SMP assignment to dense vectors*************************************************************
525  template< typename VT2 > // Type of the target dense vector
526  friend inline EnableIf_< UseSMPAssign<VT2> >
527  smpAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
528  {
530 
531  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
532 
533  DVecTransposer<VT2,!TF> tmp( ~lhs );
534  smpAssign( tmp, rhs.dv_ );
535  }
537  //**********************************************************************************************
538 
539  //**SMP assignment to sparse vectors************************************************************
553  template< typename VT2 > // Type of the target sparse vector
554  friend inline EnableIf_< UseSMPAssign<VT2> >
555  smpAssign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
556  {
558 
559  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
560 
561  SVecTransposer<VT2,!TF> tmp( ~lhs );
562  smpAssign( tmp, rhs.dv_ );
563  }
565  //**********************************************************************************************
566 
567  //**SMP addition assignment to dense vectors****************************************************
581  template< typename VT2 > // Type of the target dense vector
582  friend inline EnableIf_< UseSMPAssign<VT2> >
584  {
586 
587  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
588 
589  DVecTransposer<VT2,!TF> tmp( ~lhs );
590  smpAddAssign( tmp, rhs.dv_ );
591  }
593  //**********************************************************************************************
594 
595  //**SMP addition assignment to sparse vectors***************************************************
596  // No special implementation for the SMP addition assignment to sparse vectors.
597  //**********************************************************************************************
598 
599  //**SMP subtraction assignment to dense vectors*************************************************
613  template< typename VT2 > // Type of the target dense vector
614  friend inline EnableIf_< UseSMPAssign<VT2> >
616  {
618 
619  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
620 
621  DVecTransposer<VT2,!TF> tmp( ~lhs );
622  smpSubAssign( tmp, rhs.dv_ );
623  }
625  //**********************************************************************************************
626 
627  //**SMP subtraction assignment to sparse vectors************************************************
628  // No special implementation for the SMP subtraction assignment to sparse vectors.
629  //**********************************************************************************************
630 
631  //**SMP multiplication assignment to dense vectors**********************************************
645  template< typename VT2 > // Type of the target dense vector
646  friend inline EnableIf_< UseSMPAssign<VT2> >
648  {
650 
651  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
652 
653  DVecTransposer<VT2,!TF> tmp( ~lhs );
654  smpMultAssign( tmp, rhs.dv_ );
655  }
657  //**********************************************************************************************
658 
659  //**SMP multiplication assignment to sparse vectors*********************************************
660  // No special implementation for the SMP multiplication assignment to sparse vectors.
661  //**********************************************************************************************
662 
663  //**SMP division assignment to dense vectors****************************************************
677  template< typename VT2 > // Type of the target dense vector
678  friend inline EnableIf_< UseSMPAssign<VT2> >
680  {
682 
683  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
684 
685  DVecTransposer<VT2,!TF> tmp( ~lhs );
686  smpDivAssign( tmp, rhs.dv_ );
687  }
689  //**********************************************************************************************
690 
691  //**SMP division assignment to sparse vectors***************************************************
692  // No special implementation for the SMP division assignment to sparse vectors.
693  //**********************************************************************************************
694 
695  //**Compile time checks*************************************************************************
700  //**********************************************************************************************
701 };
702 //*************************************************************************************************
703 
704 
705 
706 
707 //=================================================================================================
708 //
709 // GLOBAL OPERATORS
710 //
711 //=================================================================================================
712 
713 //*************************************************************************************************
732 template< typename VT // Type of the dense vector
733  , bool TF > // Transpose flag
734 inline decltype(auto) trans( const DenseVector<VT,TF>& dv )
735 {
737 
738  using ReturnType = const DVecTransExpr<VT,!TF>;
739  return ReturnType( ~dv );
740 }
741 //*************************************************************************************************
742 
743 
744 
745 
746 //=================================================================================================
747 //
748 // GLOBAL RESTRUCTURING FUNCTIONS
749 //
750 //=================================================================================================
751 
752 //*************************************************************************************************
772 template< typename VT // Type of the dense vector
773  , bool TF > // Transpose flag
774 inline decltype(auto) trans( const DVecTransExpr<VT,TF>& dv )
775 {
777 
778  return dv.operand();
779 }
781 //*************************************************************************************************
782 
783 
784 //*************************************************************************************************
796 template< typename VT // Type of the left-hand side dense vector
797  , typename ST // Type of the right-hand side scalar value
798  , bool TF > // Transpose flag
799 inline decltype(auto) trans( const DVecScalarMultExpr<VT,ST,TF>& dv )
800 {
802 
803  return trans( dv.leftOperand() ) * dv.rightOperand();
804 }
806 //*************************************************************************************************
807 
808 
809 
810 
811 //=================================================================================================
812 //
813 // SIZE SPECIALIZATIONS
814 //
815 //=================================================================================================
816 
817 //*************************************************************************************************
819 template< typename VT, bool TF >
820 struct Size< DVecTransExpr<VT,TF> >
821  : public Size<VT>
822 {};
824 //*************************************************************************************************
825 
826 
827 
828 
829 //=================================================================================================
830 //
831 // ISALIGNED SPECIALIZATIONS
832 //
833 //=================================================================================================
834 
835 //*************************************************************************************************
837 template< typename VT, bool TF >
838 struct IsAligned< DVecTransExpr<VT,TF> >
839  : public BoolConstant< IsAligned<VT>::value >
840 {};
842 //*************************************************************************************************
843 
844 
845 
846 
847 //=================================================================================================
848 //
849 // ISPADDED SPECIALIZATIONS
850 //
851 //=================================================================================================
852 
853 //*************************************************************************************************
855 template< typename VT, bool TF >
856 struct IsPadded< DVecTransExpr<VT,TF> >
857  : public BoolConstant< IsPadded<VT>::value >
858 {};
860 //*************************************************************************************************
861 
862 } // namespace blaze
863 
864 #endif
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DVecTransExpr.h:297
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense vector operand.
Definition: DVecScalarMultExpr.h:531
Header file for auxiliary alias declarations.
const ElementType * data() const noexcept
Low-level data access to the vector elements.
Definition: DVecTransExpr.h:233
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 alias declaration selects one of the two given types T2 and T3 dep...
Definition: If.h:132
Header file for basic type definitions.
ResultType_< VT > TransposeType
Transpose type for expression template evaluations.
Definition: DVecTransExpr.h:151
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: DVecScalarMultExpr.h:541
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:164
DVecTransExpr(const VT &dv) noexcept
Constructor for the DVecTransExpr class.
Definition: DVecTransExpr.h:183
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecTransExpr.h:194
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
EnableIf_< IsDenseVector< VT1 > > smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:193
IfTrue_< useAssign, const ResultType, const DVecTransExpr &> CompositeType
Data type for composite expression templates.
Definition: DVecTransExpr.h:156
Header file for the DenseVector base class.
#define BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT(TYPE_TRAIT_NAME, MEMBER_NAME)
Macro for the creation of a type trait for compile time checks for member types.This macro creates th...
Definition: HasMember.h:182
If_< IsExpression< VT >, const VT, const VT &> Operand
Composite data type of the dense vector expression.
Definition: DVecTransExpr.h:162
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
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:133
Operand operand() const noexcept
Returns the dense vector operand.
Definition: DVecTransExpr.h:273
Expression object for the transposition of a dense vector.The DVecTransposer class is a wrapper objec...
Definition: DVecTransposer.h:77
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
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:363
Operand dv_
Dense vector of the transposition expression.
Definition: DVecTransExpr.h:324
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
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
TransposeType_< VT > ResultType
Result type for expression template evaluations.
Definition: DVecTransExpr.h:150
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DVecTransExpr.h:285
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 the If class template.
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: DVecTransExpr.h:207
Header file for the dense vector transposer.
Header file for the Transformation base class.
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:102
ReturnType_< VT > ReturnType
Return type for expression template evaluations.
Definition: DVecTransExpr.h:153
#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
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3087
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Expression object for the transposition of a sparse vector.The SVecTransposer class is a wrapper obje...
Definition: Forward.h:147
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:221
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
typename GetConstIterator< VT >::Type ConstIterator
Iterator over the elements of the dense vector.
Definition: DVecTransExpr.h:159
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: DVecTransExpr.h:263
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:253
Constraint on the data type.
Constraint on the data type.
Header file for the exception macros of the math module.
ElementType_< VT > ElementType
Resulting element type.
Definition: DVecTransExpr.h:152
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:317
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:243
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:307
Header file for run time assertion macros.
Utility type for generic codes.
CompositeType_< VT > CT
Composite type of the dense vector expression.
Definition: DVecTransExpr.h:95
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:154
EnableIf_< IsDenseVector< VT1 > > smpDivAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP division assignment of a vector to a dense vector.
Definition: DenseVector.h:222
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:94
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:224
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3082
#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:790
Header file for the sparse vector transposer.
Header file for the IsComputation type trait class.
Expression object for dense vector-scalar multiplications.The DVecScalarMultExpr class represents the...
Definition: DVecScalarMultExpr.h:106
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:130
Header file for the IntegralConstant class template.
Expression object for dense vector transpositions.The DVecTransExpr class represents the compile time...
Definition: DVecTransExpr.h:89
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
System settings for the inline keywords.
Header file for the Size type trait.
#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
Header file for the IsExpression type trait class.
Header file for the function trace functionality.