DVecTransposer.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DVECTRANSPOSER_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DVECTRANSPOSER_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
47 #include <blaze/math/Exception.h>
53 #include <blaze/system/Inline.h>
54 #include <blaze/util/Assert.h>
55 #include <blaze/util/EnableIf.h>
57 #include <blaze/util/Types.h>
59 
60 
61 namespace blaze {
62 
63 //=================================================================================================
64 //
65 // CLASS DVECTRANSPOSER
66 //
67 //=================================================================================================
68 
69 //*************************************************************************************************
75 template< typename VT // Type of the dense vector
76  , bool TF > // Transpose flag
77 class DVecTransposer : public DenseVector< DVecTransposer<VT,TF>, TF >
78 {
79  public:
80  //**Type definitions****************************************************************************
87  typedef const This& CompositeType;
94  //**********************************************************************************************
95 
96  //**Compilation flags***************************************************************************
98 
101  enum : bool { simdEnabled = VT::simdEnabled };
102 
104 
107  enum : bool { smpAssignable = VT::smpAssignable };
108  //**********************************************************************************************
109 
110  //**Constructor*********************************************************************************
115  explicit inline DVecTransposer( VT& dv ) noexcept
116  : dv_( dv ) // The dense vector operand
117  {}
118  //**********************************************************************************************
119 
120  //**Subscript operator**************************************************************************
126  inline Reference operator[]( size_t index ) {
127  BLAZE_USER_ASSERT( index < dv_.size(), "Invalid vector access index" );
128  return dv_[index];
129  }
130  //**********************************************************************************************
131 
132  //**Subscript operator**************************************************************************
138  inline ConstReference operator[]( size_t index ) const {
139  BLAZE_USER_ASSERT( index < dv_.size(), "Invalid vector access index" );
140  return dv_[index];
141  }
142  //**********************************************************************************************
143 
144  //**At function*********************************************************************************
151  inline Reference at( size_t index ) {
152  if( index >= dv_.size() ) {
153  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
154  }
155  return (*this)[index];
156  }
157  //**********************************************************************************************
158 
159  //**At function*********************************************************************************
166  inline ConstReference at( size_t index ) const {
167  if( index >= dv_.size() ) {
168  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
169  }
170  return (*this)[index];
171  }
172  //**********************************************************************************************
173 
174  //**Low-level data access***********************************************************************
179  inline Pointer data() noexcept {
180  return dv_.data();
181  }
182  //**********************************************************************************************
183 
184  //**Low-level data access***********************************************************************
189  inline ConstPointer data() const noexcept {
190  return dv_.data();
191  }
192  //**********************************************************************************************
193 
194  //**Begin function******************************************************************************
199  inline Iterator begin() {
200  return dv_.begin();
201  }
202  //**********************************************************************************************
203 
204  //**Begin function******************************************************************************
209  inline ConstIterator begin() const {
210  return dv_.cbegin();
211  }
212  //**********************************************************************************************
213 
214  //**Cbegin function*****************************************************************************
219  inline ConstIterator cbegin() const {
220  return dv_.cbegin();
221  }
222  //**********************************************************************************************
223 
224  //**End function********************************************************************************
229  inline Iterator end() {
230  return dv_.end();
231  }
232  //**********************************************************************************************
233 
234  //**End function********************************************************************************
239  inline ConstIterator end() const {
240  return dv_.cend();
241  }
242  //**********************************************************************************************
243 
244  //**Cend function*******************************************************************************
249  inline ConstIterator cend() const {
250  return dv_.cend();
251  }
252  //**********************************************************************************************
253 
254  //**Multiplication assignment operator**********************************************************
261  template< typename Other > // Data type of the right-hand side scalar
263  {
264  (~dv_) *= rhs;
265  return *this;
266  }
267  //**********************************************************************************************
268 
269  //**Division assignment operator****************************************************************
278  template< typename Other > // Data type of the right-hand side scalar
280  {
281  BLAZE_USER_ASSERT( rhs != Other(0), "Division by zero detected" );
282 
283  (~dv_) /= rhs;
284  return *this;
285  }
286  //**********************************************************************************************
287 
288  //**Size function*******************************************************************************
293  inline size_t size() const noexcept {
294  return dv_.size();
295  }
296  //**********************************************************************************************
297 
298  //**Reset function******************************************************************************
303  inline void reset() {
304  return dv_.reset();
305  }
306  //**********************************************************************************************
307 
308  //**CanAliased function*************************************************************************
314  template< typename Other > // Data type of the foreign expression
315  inline bool canAlias( const Other* alias ) const noexcept
316  {
317  return dv_.canAlias( alias );
318  }
319  //**********************************************************************************************
320 
321  //**IsAliased function**************************************************************************
327  template< typename Other > // Data type of the foreign expression
328  inline bool isAliased( const Other* alias ) const noexcept
329  {
330  return dv_.isAliased( alias );
331  }
332  //**********************************************************************************************
333 
334  //**IsAligned function**************************************************************************
339  inline bool isAligned() const noexcept
340  {
341  return dv_.isAligned();
342  }
343  //**********************************************************************************************
344 
345  //**CanSMPAssign function***********************************************************************
350  inline bool canSMPAssign() const noexcept
351  {
352  return dv_.canSMPAssign();
353  }
354  //**********************************************************************************************
355 
356  //**Load function*******************************************************************************
366  BLAZE_ALWAYS_INLINE SIMDType load( size_t index ) const noexcept
367  {
368  return dv_.load( index );
369  }
370  //**********************************************************************************************
371 
372  //**Loada function******************************************************************************
382  BLAZE_ALWAYS_INLINE SIMDType loada( size_t index ) const noexcept
383  {
384  return dv_.loada( index );
385  }
386  //**********************************************************************************************
387 
388  //**Loadu function******************************************************************************
398  BLAZE_ALWAYS_INLINE SIMDType loadu( size_t index ) const noexcept
399  {
400  return dv_.loadu( index );
401  }
402  //**********************************************************************************************
403 
404  //**Store function******************************************************************************
415  BLAZE_ALWAYS_INLINE void store( size_t index, const SIMDType& value ) noexcept
416  {
417  dv_.store( index, value );
418  }
419  //**********************************************************************************************
420 
421  //**Storea function******************************************************************************
432  BLAZE_ALWAYS_INLINE void storea( size_t index, const SIMDType& value ) noexcept
433  {
434  dv_.storea( index, value );
435  }
436  //**********************************************************************************************
437 
438  //**Storeu function*****************************************************************************
449  BLAZE_ALWAYS_INLINE void storeu( size_t index, const SIMDType& value ) noexcept
450  {
451  dv_.storeu( index, value );
452  }
453  //**********************************************************************************************
454 
455  //**Stream function*****************************************************************************
466  BLAZE_ALWAYS_INLINE void stream( size_t index, const SIMDType& value ) noexcept
467  {
468  dv_.stream( index, value );
469  }
470  //**********************************************************************************************
471 
472  //**Transpose assignment of dense vectors*******************************************************
483  template< typename VT2 > // Type of the right-hand side dense vector
484  inline void assign( const DenseVector<VT2,TF>& rhs )
485  {
487 
488  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
489 
490  const size_t n( size() );
491 
492  const size_t ipos( n & size_t(-2) );
493  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ipos, "Invalid end calculation" );
494 
495  for( size_t i=0UL; i<ipos; i+=2UL ) {
496  dv_[i ] = (~rhs)[i ];
497  dv_[i+1UL] = (~rhs)[i+1UL];
498  }
499  if( ipos < n )
500  dv_[ipos] = (~rhs)[ipos];
501  }
502  //**********************************************************************************************
503 
504  //**Transpose assignment of sparse vectors******************************************************
515  template< typename VT2 > // Type of the right-hand side sparse vector
516  inline void assign( const SparseVector<VT2,TF>& rhs )
517  {
519 
520  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
521 
522  typedef ConstIterator_<VT2> RhsConstIterator;
523 
524  for( RhsConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
525  dv_[element->index()] = element->value();
526  }
527  //**********************************************************************************************
528 
529  //**Transpose addition assignment of dense vectors**********************************************
540  template< typename VT2 > // Type of the right-hand side dense vector
541  inline void addAssign( const DenseVector<VT2,TF>& rhs )
542  {
544 
545  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
546 
547  const size_t n( size() );
548 
549  const size_t ipos( n & size_t(-2) );
550  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ipos, "Invalid end calculation" );
551 
552  for( size_t i=0UL; i<ipos; i+=2UL ) {
553  dv_[i ] += (~rhs)[i ];
554  dv_[i+1UL] += (~rhs)[i+1UL];
555  }
556  if( ipos < n )
557  dv_[ipos] += (~rhs)[ipos];
558  }
559  //**********************************************************************************************
560 
561  //**Transpose addition assignment of sparse vectors*********************************************
572  template< typename VT2 > // Type of the right-hand side sparse vector
573  inline void addAssign( const SparseVector<VT2,TF>& rhs )
574  {
576 
577  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
578 
579  typedef ConstIterator_<VT2> RhsConstIterator;
580 
581  for( RhsConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
582  dv_[element->index()] += element->value();
583  }
584  //**********************************************************************************************
585 
586  //**Transpose subtraction assignment of dense vectors*******************************************
597  template< typename VT2 > // Type of the right-hand side dense vector
598  inline void subAssign( const DenseVector<VT2,TF>& rhs )
599  {
601 
602  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
603 
604  const size_t n( size() );
605 
606  const size_t ipos( n & size_t(-2) );
607  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ipos, "Invalid end calculation" );
608 
609  for( size_t i=0UL; i<ipos; i+=2UL ) {
610  dv_[i ] -= (~rhs)[i ];
611  dv_[i+1UL] -= (~rhs)[i+1UL];
612  }
613  if( ipos < n )
614  dv_[ipos] -= (~rhs)[ipos];
615  }
616  //**********************************************************************************************
617 
618  //**Transpose subtraction assignment of sparse vectors******************************************
629  template< typename VT2 > // Type of the right-hand side sparse vector
630  inline void subAssign( const SparseVector<VT2,TF>& rhs )
631  {
633 
634  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
635 
636  typedef ConstIterator_<VT2> RhsConstIterator;
637 
638  for( RhsConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
639  dv_[element->index()] -= element->value();
640  }
641  //**********************************************************************************************
642 
643  //**Transpose multiplication assignment of dense vectors****************************************
654  template< typename VT2 > // Type of the right-hand side dense vector
655  inline void multAssign( const DenseVector<VT2,TF>& rhs )
656  {
658 
659  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
660 
661  const size_t n( size() );
662 
663  const size_t ipos( n & size_t(-2) );
664  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ipos, "Invalid end calculation" );
665 
666  for( size_t i=0UL; i<ipos; i+=2UL ) {
667  dv_[i ] *= (~rhs)[i ];
668  dv_[i+1UL] *= (~rhs)[i+1UL];
669  }
670  if( ipos < n )
671  dv_[ipos] *= (~rhs)[ipos];
672  }
673  //**********************************************************************************************
674 
675  //**Transpose multiplication assignment of sparse vectors***************************************
686  template< typename VT2 > // Type of the right-hand side dense vector
687  inline void multAssign( const SparseVector<VT2,TF>& rhs )
688  {
690 
691  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
692 
693  typedef ConstIterator_<VT2> RhsConstIterator;
694 
695  const VT tmp( dv_ );
696  dv_.reset();
697 
698  for( RhsConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
699  dv_[element->index()] = tmp[element->index()] * element->value();
700  }
701  //**********************************************************************************************
702 
703  //**Transpose division assignment of dense vectors**********************************************
714  template< typename VT2 > // Type of the right-hand side dense vector
715  inline void divAssign( const DenseVector<VT2,TF>& rhs )
716  {
718 
719  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
720 
721  const size_t n( size() );
722 
723  const size_t ipos( n & size_t(-2) );
724  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ipos, "Invalid end calculation" );
725 
726  for( size_t i=0UL; i<ipos; i+=2UL ) {
727  dv_[i ] /= (~rhs)[i ];
728  dv_[i+1UL] /= (~rhs)[i+1UL];
729  }
730  if( ipos < n )
731  dv_[ipos] /= (~rhs)[ipos];
732  }
733  //**********************************************************************************************
734 
735  private:
736  //**Member variables****************************************************************************
737  VT& dv_;
738  //**********************************************************************************************
739 
740  //**Compile time checks*************************************************************************
746  //**********************************************************************************************
747 };
748 //*************************************************************************************************
749 
750 
751 
752 
753 //=================================================================================================
754 //
755 // GLOBAL OPERATORS
756 //
757 //=================================================================================================
758 
759 //*************************************************************************************************
767 template< typename VT // Type of the dense vector
768  , bool TF > // Transpose flag
769 inline void reset( DVecTransposer<VT,TF>& v )
770 {
771  v.reset();
772 }
774 //*************************************************************************************************
775 
776 
777 
778 
779 //=================================================================================================
780 //
781 // ISALIGNED SPECIALIZATIONS
782 //
783 //=================================================================================================
784 
785 //*************************************************************************************************
787 template< typename VT, bool TF >
788 struct IsAligned< DVecTransposer<VT,TF> >
789  : public BoolConstant< IsAligned<VT>::value >
790 {};
792 //*************************************************************************************************
793 
794 
795 
796 
797 //=================================================================================================
798 //
799 // ISPADDED SPECIALIZATIONS
800 //
801 //=================================================================================================
802 
803 //*************************************************************************************************
805 template< typename VT, bool TF >
806 struct IsPadded< DVecTransposer<VT,TF> >
807  : public BoolConstant< IsPadded<VT>::value >
808 {};
810 //*************************************************************************************************
811 
812 
813 
814 
815 //=================================================================================================
816 //
817 // SUBVECTORTRAIT SPECIALIZATIONS
818 //
819 //=================================================================================================
820 
821 //*************************************************************************************************
823 template< typename VT, bool TF >
824 struct SubvectorTrait< DVecTransposer<VT,TF> >
825 {
826  using Type = SubvectorTrait_< ResultType_< DVecTransposer<VT,TF> > >;
827 };
829 //*************************************************************************************************
830 
831 } // namespace blaze
832 
833 #endif
Reference operator[](size_t index)
Subscript operator for the direct access to the vector elements.
Definition: DVecTransposer.h:126
Constraint on the data type.
Iterator begin()
Returns an iterator to the first element of the dense vector.
Definition: DVecTransposer.h:199
Header file for auxiliary alias declarations.
BLAZE_ALWAYS_INLINE SIMDType loada(size_t index) const noexcept
Aligned load of a SIMD element of the vector.
Definition: DVecTransposer.h:382
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_USER_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERT flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:117
Header file for basic type definitions.
ConstReference at(size_t index) const
Checked access to the vector elements.
Definition: DVecTransposer.h:166
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.In case the given data type T is a computational expression (i...
Definition: Computation.h:81
void subAssign(const DenseVector< VT2, TF > &rhs)
Implementation of the transpose subtraction assignment of a dense vector.
Definition: DVecTransposer.h:598
typename SIMDTrait< T >::Type SIMDTrait_
Auxiliary alias declaration for the SIMDTrait class template.The SIMDTrait_ alias declaration provide...
Definition: SIMDTrait.h:315
BLAZE_ALWAYS_INLINE SIMDType loadu(size_t index) const noexcept
Unaligned load of a SIMD element of the vector.
Definition: DVecTransposer.h:398
EnableIf_< IsNumeric< Other >, DVecTransposer > & operator*=(Other rhs)
Multiplication assignment operator for the multiplication between a vector and a scalar value ( )...
Definition: DVecTransposer.h:262
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
SIMDTrait_< ElementType > SIMDType
SIMD type of the vector elements.
Definition: DVecTransposer.h:85
ConstIterator cend() const
Returns an iterator just past the last element of the dense vector.
Definition: DVecTransposer.h:249
void multAssign(const SparseVector< VT2, TF > &rhs)
Implementation of the transpose multiplication assignment of a sparse vector.
Definition: DVecTransposer.h:687
Header file for the DenseVector base class.
ConstReference operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecTransposer.h:138
ConstReference_< VT > ConstReference
Reference to a constant vector value.
Definition: DVecTransposer.h:89
ConstIterator begin() const
Returns an iterator to the first element of the dense vector.
Definition: DVecTransposer.h:209
Header file for the SIMD trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
Expression object for the transposition of a dense vector.The DVecTransposer class is a wrapper objec...
Definition: DVecTransposer.h:77
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
BLAZE_ALWAYS_INLINE void store(size_t index, const SIMDType &value) noexcept
Store of a SIMD element of the vector.
Definition: DVecTransposer.h:415
bool canAlias(const Other *alias) const noexcept
Returns whether the vector can alias with the given address alias.
Definition: DVecTransposer.h:315
typename T::Pointer Pointer_
Alias declaration for nested Pointer type definitions.The Pointer_ alias declaration provides a conve...
Definition: Aliases.h:263
Iterator_< VT > Iterator
Iterator over non-constant elements.
Definition: DVecTransposer.h:92
EnableIf_< IsNumeric< Other >, DVecTransposer > & operator/=(Other rhs)
Division assignment operator for the division of a vector by a scalar value ( ).
Definition: DVecTransposer.h:279
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
DVecTransposer(VT &dv) noexcept
Constructor for the DVecTransposer class.
Definition: DVecTransposer.h:115
Pointer_< VT > Pointer
Pointer to a non-constant vector value.
Definition: DVecTransposer.h:90
bool isAligned() const noexcept
Returns whether the vector is properly aligned in memory.
Definition: DVecTransposer.h:339
bool isAliased(const Other *alias) const noexcept
Returns whether the vector is aliased with the given address alias.
Definition: DVecTransposer.h:328
BLAZE_ALWAYS_INLINE SIMDType load(size_t index) const noexcept
Load of a SIMD element of the vector.
Definition: DVecTransposer.h:366
#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
ConstPointer_< VT > ConstPointer
Pointer to a constant vector value.
Definition: DVecTransposer.h:91
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: DVecTransposer.h:293
bool canSMPAssign() const noexcept
Returns whether the vector can be used in SMP assignments.
Definition: DVecTransposer.h:350
Header file for the subvector trait.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Reference at(size_t index)
Checked access to the vector elements.
Definition: DVecTransposer.h:151
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
TransposeType_< VT > ResultType
Result type for expression template evaluations.
Definition: DVecTransposer.h:82
Header file for the IsAligned type trait.
BLAZE_ALWAYS_INLINE void storeu(size_t index, const SIMDType &value) noexcept
Unaligned store of a SIMD element of the vector.
Definition: DVecTransposer.h:449
Constraint on the data type.
Constraint on the data type.
Header file for the exception macros of the math module.
BLAZE_ALWAYS_INLINE void storea(size_t index, const SIMDType &value) noexcept
Aligned store of a SIMD element of the vector.
Definition: DVecTransposer.h:432
typename T::Reference Reference_
Alias declaration for nested Reference type definitions.The Reference_ alias declaration provides a c...
Definition: Aliases.h:283
Header file for the EnableIf class template.
Header file for the IsPadded type trait.
void reset()
Resets the vector elements.
Definition: DVecTransposer.h:303
Header file for the IsNumeric type trait.
DVecTransposer< VT, TF > This
Type of this DVecTransposer instance.
Definition: DVecTransposer.h:81
Header file for run time assertion macros.
const This & CompositeType
Data type for composite expression templates.
Definition: DVecTransposer.h:87
Iterator end()
Returns an iterator just past the last element of the dense vector.
Definition: DVecTransposer.h:229
void addAssign(const SparseVector< VT2, TF > &rhs)
Implementation of the transpose addition assignment of a sparse vector.
Definition: DVecTransposer.h:573
BLAZE_ALWAYS_INLINE void stream(size_t index, const SIMDType &value) noexcept
Aligned, non-temporal store of a SIMD element of the vector.
Definition: DVecTransposer.h:466
void addAssign(const DenseVector< VT2, TF > &rhs)
Implementation of the transpose addition assignment of a dense vector.
Definition: DVecTransposer.h:541
ResultType_< VT > TransposeType
Transpose type for expression template evaluations.
Definition: DVecTransposer.h:83
ConstIterator end() const
Returns an iterator just past the last element of the dense vector.
Definition: DVecTransposer.h:239
Pointer data() noexcept
Low-level data access to the vector elements.
Definition: DVecTransposer.h:179
void subAssign(const SparseVector< VT2, TF > &rhs)
Implementation of the transpose subtraction assignment of a sparse vector.
Definition: DVecTransposer.h:630
void divAssign(const DenseVector< VT2, TF > &rhs)
Implementation of the transpose division assignment of a dense vector.
Definition: DVecTransposer.h:715
void assign(const SparseVector< VT2, TF > &rhs)
Implementation of the transpose assignment of a sparse vector.
Definition: DVecTransposer.h:516
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
typename T::Iterator Iterator_
Alias declaration for nested Iterator type definitions.The Iterator_ alias declaration provides a con...
Definition: Aliases.h:183
Reference_< VT > Reference
Reference to a non-constant vector value.
Definition: DVecTransposer.h:88
typename T::ConstPointer ConstPointer_
Alias declaration for nested ConstPointer type definitions.The ConstPointer_ alias declaration provid...
Definition: Aliases.h:123
typename T::ConstReference ConstReference_
Alias declaration for nested ConstReference type definitions.The ConstReference_ alias declaration pr...
Definition: Aliases.h:143
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
#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
void assign(const DenseVector< VT2, TF > &rhs)
Implementation of the transpose assignment of a dense vector.
Definition: DVecTransposer.h:484
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:110
Header file for the IntegralConstant class template.
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
ConstIterator_< VT > ConstIterator
Iterator over constant elements.
Definition: DVecTransposer.h:93
ReturnType_< VT > ReturnType
Return type for expression template evaluations.
Definition: DVecTransposer.h:86
ConstPointer data() const noexcept
Low-level data access to the vector elements.
Definition: DVecTransposer.h:189
System settings for the inline keywords.
void multAssign(const DenseVector< VT2, TF > &rhs)
Implementation of the transpose multiplication assignment of a dense vector.
Definition: DVecTransposer.h:655
#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
ConstIterator cbegin() const
Returns an iterator to the first element of the dense vector.
Definition: DVecTransposer.h:219
VT & dv_
The dense vector operand.
Definition: DVecTransposer.h:737
ElementType_< VT > ElementType
Type of the vector elements.
Definition: DVecTransposer.h:84