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>
63 #include <blaze/system/Inline.h>
64 #include <blaze/util/Assert.h>
65 #include <blaze/util/EnableIf.h>
66 #include <blaze/util/FalseType.h>
69 #include <blaze/util/InvalidType.h>
70 #include <blaze/util/mpl/If.h>
71 #include <blaze/util/TrueType.h>
72 #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<VT>, Computation, Transformation >::Type
95 {
96  private:
97  //**Type definitions****************************************************************************
99  //**********************************************************************************************
100 
101  //**Serial evaluation strategy******************************************************************
103 
109  enum : bool { useAssign = RequiresEvaluation<VT>::value };
110 
112  template< typename VT2 >
114  struct UseAssign {
115  enum : bool { value = useAssign };
116  };
118  //**********************************************************************************************
119 
120  //**Parallel evaluation strategy****************************************************************
122 
127  template< typename VT2 >
128  struct UseSMPAssign {
129  enum : bool { value = VT2::smpAssignable && useAssign };
130  };
132  //**********************************************************************************************
133 
134  //**********************************************************************************************
136 
140  template< typename VT2 >
141  struct GetConstIterator {
143  struct Success { using Type = typename VT2::ConstIterator; };
144  struct Failure { using Type = INVALID_TYPE; };
145  using Type = typename If_< HasConstIterator<VT2>, Success, Failure >::Type;
146  };
148  //**********************************************************************************************
149 
150  public:
151  //**Type definitions****************************************************************************
157 
160 
162  using ConstIterator = typename GetConstIterator<VT>::Type;
163 
165  using Operand = If_< IsExpression<VT>, const VT, const VT& >;
166  //**********************************************************************************************
167 
168  //**Compilation flags***************************************************************************
170  enum : bool { simdEnabled = VT::simdEnabled };
171 
173  enum : bool { smpAssignable = VT::smpAssignable };
174  //**********************************************************************************************
175 
176  //**SIMD properties*****************************************************************************
178  enum : size_t { SIMDSIZE = SIMDTrait<ElementType>::size };
179  //**********************************************************************************************
180 
181  //**Constructor*********************************************************************************
186  explicit inline DVecTransExpr( const VT& dv ) noexcept
187  : dv_( dv ) // Dense vector of the transposition expression
188  {}
189  //**********************************************************************************************
190 
191  //**Subscript operator**************************************************************************
197  inline ReturnType operator[]( size_t index ) const {
198  BLAZE_INTERNAL_ASSERT( index < dv_.size(), "Invalid vector access index" );
199  return dv_[index];
200  }
201  //**********************************************************************************************
202 
203  //**At function*********************************************************************************
210  inline ReturnType at( size_t index ) const {
211  if( index >= dv_.size() ) {
212  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
213  }
214  return (*this)[index];
215  }
216  //**********************************************************************************************
217 
218  //**Load function*******************************************************************************
224  BLAZE_ALWAYS_INLINE auto load( size_t index ) const noexcept {
225  BLAZE_INTERNAL_ASSERT( index < dv_.size() , "Invalid vector access index" );
226  BLAZE_INTERNAL_ASSERT( index % SIMDSIZE == 0UL , "Invalid vector access index" );
227  return dv_.load( index );
228  }
229  //**********************************************************************************************
230 
231  //**Low-level data access***********************************************************************
236  inline const ElementType* data() const noexcept {
237  return dv_.data();
238  }
239  //**********************************************************************************************
240 
241  //**Begin function******************************************************************************
246  inline ConstIterator begin() const {
247  return ConstIterator( dv_.begin() );
248  }
249  //**********************************************************************************************
250 
251  //**End function********************************************************************************
256  inline ConstIterator end() const {
257  return ConstIterator( dv_.end() );
258  }
259  //**********************************************************************************************
260 
261  //**Size function*******************************************************************************
266  inline size_t size() const noexcept {
267  return dv_.size();
268  }
269  //**********************************************************************************************
270 
271  //**Operand access******************************************************************************
276  inline Operand operand() const noexcept {
277  return dv_;
278  }
279  //**********************************************************************************************
280 
281  //**********************************************************************************************
287  template< typename T >
288  inline bool canAlias( const T* alias ) const noexcept {
289  return dv_.canAlias( alias );
290  }
291  //**********************************************************************************************
292 
293  //**********************************************************************************************
299  template< typename T >
300  inline bool isAliased( const T* alias ) const noexcept {
301  return dv_.isAliased( alias );
302  }
303  //**********************************************************************************************
304 
305  //**********************************************************************************************
310  inline bool isAligned() const noexcept {
311  return dv_.isAligned();
312  }
313  //**********************************************************************************************
314 
315  //**********************************************************************************************
320  inline bool canSMPAssign() const noexcept {
321  return dv_.canSMPAssign();
322  }
323  //**********************************************************************************************
324 
325  private:
326  //**Member variables****************************************************************************
328  //**********************************************************************************************
329 
330  //**Assignment to dense vectors*****************************************************************
344  template< typename VT2 > // Type of the target dense vector
345  friend inline EnableIf_< UseAssign<VT2> >
346  assign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
347  {
349 
350  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
351 
352  DVecTransposer<VT2,!TF> tmp( ~lhs );
353  assign( tmp, rhs.dv_ );
354  }
356  //**********************************************************************************************
357 
358  //**Assignment to sparse vectors****************************************************************
372  template< typename VT2 > // Type of the target sparse vector
373  friend inline EnableIf_< UseAssign<VT2> >
374  assign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
375  {
377 
378  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
379 
380  SVecTransposer<VT2,!TF> tmp( ~lhs );
381  assign( tmp, rhs.dv_ );
382  }
384  //**********************************************************************************************
385 
386  //**Addition assignment to dense vectors********************************************************
400  template< typename VT2 > // Type of the target dense vector
401  friend inline EnableIf_< UseAssign<VT2> >
402  addAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
403  {
405 
406  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
407 
408  DVecTransposer<VT2,!TF> tmp( ~lhs );
409  addAssign( tmp, rhs.dv_ );
410  }
412  //**********************************************************************************************
413 
414  //**Addition assignment to sparse vectors*******************************************************
415  // No special implementation for the addition assignment to sparse vectors.
416  //**********************************************************************************************
417 
418  //**Subtraction assignment to dense vectors*****************************************************
432  template< typename VT2 > // Type of the target dense vector
433  friend inline EnableIf_< UseAssign<VT2> >
434  subAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
435  {
437 
438  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
439 
440  DVecTransposer<VT2,!TF> tmp( ~lhs );
441  subAssign( tmp, rhs.dv_ );
442  }
444  //**********************************************************************************************
445 
446  //**Subtraction assignment to sparse vectors****************************************************
447  // No special implementation for the subtraction assignment to sparse vectors.
448  //**********************************************************************************************
449 
450  //**Multiplication assignment to dense vectors**************************************************
464  template< typename VT2 > // Type of the target dense vector
465  friend inline EnableIf_< UseAssign<VT2> >
466  multAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
467  {
469 
470  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
471 
472  DVecTransposer<VT2,!TF> tmp( ~lhs );
473  multAssign( tmp, rhs.dv_ );
474  }
476  //**********************************************************************************************
477 
478  //**Multiplication assignment to sparse vectors*************************************************
479  // No special implementation for the multiplication assignment to sparse vectors.
480  //**********************************************************************************************
481 
482  //**Division assignment to dense vectors********************************************************
496  template< typename VT2 > // Type of the target dense vector
497  friend inline EnableIf_< UseAssign<VT2> >
498  divAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
499  {
501 
502  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
503 
504  DVecTransposer<VT2,!TF> tmp( ~lhs );
505  divAssign( tmp, rhs.dv_ );
506  }
508  //**********************************************************************************************
509 
510  //**Division assignment to sparse vectors*******************************************************
511  // No special implementation for the division assignment to sparse vectors.
512  //**********************************************************************************************
513 
514  //**SMP assignment to dense vectors*************************************************************
528  template< typename VT2 > // Type of the target dense vector
529  friend inline EnableIf_< UseSMPAssign<VT2> >
530  smpAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
531  {
533 
534  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
535 
536  DVecTransposer<VT2,!TF> tmp( ~lhs );
537  smpAssign( tmp, rhs.dv_ );
538  }
540  //**********************************************************************************************
541 
542  //**SMP assignment to sparse vectors************************************************************
556  template< typename VT2 > // Type of the target sparse vector
557  friend inline EnableIf_< UseSMPAssign<VT2> >
558  smpAssign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
559  {
561 
562  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
563 
564  SVecTransposer<VT2,!TF> tmp( ~lhs );
565  smpAssign( tmp, rhs.dv_ );
566  }
568  //**********************************************************************************************
569 
570  //**SMP addition assignment to dense vectors****************************************************
584  template< typename VT2 > // Type of the target dense vector
585  friend inline EnableIf_< UseSMPAssign<VT2> >
587  {
589 
590  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
591 
592  DVecTransposer<VT2,!TF> tmp( ~lhs );
593  smpAddAssign( tmp, rhs.dv_ );
594  }
596  //**********************************************************************************************
597 
598  //**SMP addition assignment to sparse vectors***************************************************
599  // No special implementation for the SMP addition assignment to sparse vectors.
600  //**********************************************************************************************
601 
602  //**SMP subtraction assignment to dense vectors*************************************************
616  template< typename VT2 > // Type of the target dense vector
617  friend inline EnableIf_< UseSMPAssign<VT2> >
619  {
621 
622  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
623 
624  DVecTransposer<VT2,!TF> tmp( ~lhs );
625  smpSubAssign( tmp, rhs.dv_ );
626  }
628  //**********************************************************************************************
629 
630  //**SMP subtraction assignment to sparse vectors************************************************
631  // No special implementation for the SMP subtraction assignment to sparse vectors.
632  //**********************************************************************************************
633 
634  //**SMP multiplication assignment to dense vectors**********************************************
648  template< typename VT2 > // Type of the target dense vector
649  friend inline EnableIf_< UseSMPAssign<VT2> >
651  {
653 
654  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
655 
656  DVecTransposer<VT2,!TF> tmp( ~lhs );
657  smpMultAssign( tmp, rhs.dv_ );
658  }
660  //**********************************************************************************************
661 
662  //**SMP multiplication assignment to sparse vectors*********************************************
663  // No special implementation for the SMP multiplication assignment to sparse vectors.
664  //**********************************************************************************************
665 
666  //**SMP division assignment to dense vectors****************************************************
680  template< typename VT2 > // Type of the target dense vector
681  friend inline EnableIf_< UseSMPAssign<VT2> >
683  {
685 
686  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
687 
688  DVecTransposer<VT2,!TF> tmp( ~lhs );
689  smpDivAssign( tmp, rhs.dv_ );
690  }
692  //**********************************************************************************************
693 
694  //**SMP division assignment to sparse vectors***************************************************
695  // No special implementation for the SMP division assignment to sparse vectors.
696  //**********************************************************************************************
697 
698  //**Compile time checks*************************************************************************
703  //**********************************************************************************************
704 };
705 //*************************************************************************************************
706 
707 
708 
709 
710 //=================================================================================================
711 //
712 // GLOBAL OPERATORS
713 //
714 //=================================================================================================
715 
716 //*************************************************************************************************
735 template< typename VT // Type of the dense vector
736  , bool TF > // Transpose flag
737 inline decltype(auto) trans( const DenseVector<VT,TF>& dv )
738 {
740 
741  using ReturnType = const DVecTransExpr<VT,!TF>;
742  return ReturnType( ~dv );
743 }
744 //*************************************************************************************************
745 
746 
747 //*************************************************************************************************
755 template< typename VT // Type of the dense vector
756  , bool TF > // Transpose flag
757 inline decltype(auto) transTo_backend( const DenseVector<VT,TF>& dv, FalseType )
758 {
759  return trans( ~dv );
760 }
762 //*************************************************************************************************
763 
764 
765 //*************************************************************************************************
773 template< typename VT // Type of the dense vector
774  , bool TF > // Transpose flag
775 inline const VT& transTo_backend( const DenseVector<VT,TF>& dv, TrueType )
776 {
777  return ~dv;
778 }
780 //*************************************************************************************************
781 
782 
783 //*************************************************************************************************
795 template< bool TTF // Target transpose flag
796  , typename VT // Type of the dense vector
797  , bool TF > // Current transpose flag of the dense vector
798 inline decltype(auto) transTo( const DenseVector<VT,TF>& dv )
799 {
800  return transTo_backend( ~dv, BoolConstant<TTF == TF>() );
801 }
802 //*************************************************************************************************
803 
804 
805 
806 
807 //=================================================================================================
808 //
809 // GLOBAL RESTRUCTURING FUNCTIONS
810 //
811 //=================================================================================================
812 
813 //*************************************************************************************************
833 template< typename VT // Type of the dense vector
834  , bool TF > // Transpose flag
835 inline decltype(auto) trans( const DVecTransExpr<VT,TF>& dv )
836 {
838 
839  return dv.operand();
840 }
842 //*************************************************************************************************
843 
844 
845 //*************************************************************************************************
857 template< typename VT // Type of the left-hand side dense vector
858  , typename ST // Type of the right-hand side scalar value
859  , bool TF > // Transpose flag
860 inline decltype(auto) trans( const DVecScalarMultExpr<VT,ST,TF>& dv )
861 {
863 
864  return trans( dv.leftOperand() ) * dv.rightOperand();
865 }
867 //*************************************************************************************************
868 
869 
870 
871 
872 //=================================================================================================
873 //
874 // SIZE SPECIALIZATIONS
875 //
876 //=================================================================================================
877 
878 //*************************************************************************************************
880 template< typename VT, bool TF >
881 struct Size< DVecTransExpr<VT,TF>, 0UL >
882  : public Size<VT,0UL>
883 {};
885 //*************************************************************************************************
886 
887 
888 
889 
890 //=================================================================================================
891 //
892 // ISALIGNED SPECIALIZATIONS
893 //
894 //=================================================================================================
895 
896 //*************************************************************************************************
898 template< typename VT, bool TF >
899 struct HasConstDataAccess< DVecTransExpr<VT,TF> >
900  : public HasConstDataAccess<VT>
901 {};
903 //*************************************************************************************************
904 
905 
906 
907 
908 //=================================================================================================
909 //
910 // ISALIGNED SPECIALIZATIONS
911 //
912 //=================================================================================================
913 
914 //*************************************************************************************************
916 template< typename VT, bool TF >
917 struct IsAligned< DVecTransExpr<VT,TF> >
918  : public IsAligned<VT>
919 {};
921 //*************************************************************************************************
922 
923 
924 
925 
926 //=================================================================================================
927 //
928 // ISPADDED SPECIALIZATIONS
929 //
930 //=================================================================================================
931 
932 //*************************************************************************************************
934 template< typename VT, bool TF >
935 struct IsPadded< DVecTransExpr<VT,TF> >
936  : public IsPadded<VT>
937 {};
939 //*************************************************************************************************
940 
941 } // namespace blaze
942 
943 #endif
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DVecTransExpr.h:300
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense vector operand.
Definition: DVecScalarMultExpr.h:529
Header file for auxiliary alias declarations.
const ElementType * data() const noexcept
Low-level data access to the vector elements.
Definition: DVecTransExpr.h:236
Compile time check for low-level access to constant data.This type trait tests whether the given data...
Definition: HasConstDataAccess.h:75
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:154
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: DVecScalarMultExpr.h:539
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
Header file for the FalseType type/value trait base class.
DVecTransExpr(const VT &dv) noexcept
Constructor for the DVecTransExpr class.
Definition: DVecTransExpr.h:186
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecTransExpr.h:197
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:159
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:165
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:276
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:327
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:71
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:153
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DVecTransExpr.h:288
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:210
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:156
#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:3085
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:224
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:76
typename GetConstIterator< VT >::Type ConstIterator
Iterator over the elements of the dense vector.
Definition: DVecTransExpr.h:162
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: DVecTransExpr.h:266
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:256
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:798
Constraint on the data type.
Header file for the exception macros of the math module.
ElementType_< VT > ElementType
Resulting element type.
Definition: DVecTransExpr.h:155
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:320
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:246
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:310
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:98
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:3080
#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:789
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:104
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of...
Definition: Size.h:80
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:92
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 TrueType type/value trait base class.
Header file for the IsExpression type trait class.
Header file for the function trace functionality.