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 
51 #include <blaze/system/Inline.h>
52 #include <blaze/util/Assert.h>
53 #include <blaze/util/EnableIf.h>
54 #include <blaze/util/Exception.h>
55 #include <blaze/util/Types.h>
58 
59 
60 namespace blaze {
61 
62 //=================================================================================================
63 //
64 // CLASS DVECTRANSPOSER
65 //
66 //=================================================================================================
67 
68 //*************************************************************************************************
74 template< typename VT // Type of the dense vector
75  , bool TF > // Transpose flag
76 class DVecTransposer : public DenseVector< DVecTransposer<VT,TF>, TF >
77 {
78  private:
79  //**Type definitions****************************************************************************
81  //**********************************************************************************************
82 
83  public:
84  //**Type definitions****************************************************************************
86  typedef typename VT::TransposeType ResultType;
87  typedef typename VT::ResultType TransposeType;
88  typedef typename VT::ElementType ElementType;
89  typedef typename IT::Type IntrinsicType;
90  typedef typename VT::ReturnType ReturnType;
91  typedef const This& CompositeType;
92  typedef typename VT::Reference Reference;
94  typedef typename VT::Pointer Pointer;
95  typedef typename VT::ConstPointer ConstPointer;
96  typedef typename VT::Iterator Iterator;
97  typedef typename VT::ConstIterator ConstIterator;
98  //**********************************************************************************************
99 
100  //**Compilation flags***************************************************************************
102 
105  enum { vectorizable = VT::vectorizable };
106 
108 
111  enum { smpAssignable = VT::smpAssignable };
112  //**********************************************************************************************
113 
114  //**Constructor*********************************************************************************
119  explicit inline DVecTransposer( VT& dv )
120  : dv_( dv ) // The dense vector operand
121  {}
122  //**********************************************************************************************
123 
124  //**Subscript operator**************************************************************************
130  inline Reference operator[]( size_t index ) {
131  BLAZE_USER_ASSERT( index < dv_.size(), "Invalid vector access index" );
132  return dv_[index];
133  }
134  //**********************************************************************************************
135 
136  //**Subscript operator**************************************************************************
142  inline ConstReference operator[]( size_t index ) const {
143  BLAZE_USER_ASSERT( index < dv_.size(), "Invalid vector access index" );
144  return dv_[index];
145  }
146  //**********************************************************************************************
147 
148  //**At function*********************************************************************************
155  inline Reference at( size_t index ) {
156  if( index >= dv_.size() ) {
157  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
158  }
159  return (*this)[index];
160  }
161  //**********************************************************************************************
162 
163  //**At function*********************************************************************************
170  inline ConstReference at( size_t index ) const {
171  if( index >= dv_.size() ) {
172  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
173  }
174  return (*this)[index];
175  }
176  //**********************************************************************************************
177 
178  //**Low-level data access***********************************************************************
183  inline Pointer data() {
184  return dv_.data();
185  }
186  //**********************************************************************************************
187 
188  //**Low-level data access***********************************************************************
193  inline ConstPointer data() const {
194  return dv_.data();
195  }
196  //**********************************************************************************************
197 
198  //**Begin function******************************************************************************
203  inline Iterator begin() {
204  return dv_.begin();
205  }
206  //**********************************************************************************************
207 
208  //**Begin function******************************************************************************
213  inline ConstIterator begin() const {
214  return dv_.cbegin();
215  }
216  //**********************************************************************************************
217 
218  //**Cbegin function*****************************************************************************
223  inline ConstIterator cbegin() const {
224  return dv_.cbegin();
225  }
226  //**********************************************************************************************
227 
228  //**End function********************************************************************************
233  inline Iterator end() {
234  return dv_.end();
235  }
236  //**********************************************************************************************
237 
238  //**End function********************************************************************************
243  inline ConstIterator end() const {
244  return dv_.cend();
245  }
246  //**********************************************************************************************
247 
248  //**Cend function*******************************************************************************
253  inline ConstIterator cend() const {
254  return dv_.cend();
255  }
256  //**********************************************************************************************
257 
258  //**Multiplication assignment operator**********************************************************
265  template< typename Other > // Data type of the right-hand side scalar
266  inline typename EnableIf< IsNumeric<Other>, DVecTransposer >::Type& operator*=( Other rhs )
267  {
268  (~dv_) *= rhs;
269  return *this;
270  }
271  //**********************************************************************************************
272 
273  //**Division assignment operator****************************************************************
282  template< typename Other > // Data type of the right-hand side scalar
283  inline typename EnableIf< IsNumeric<Other>, DVecTransposer >::Type& operator/=( Other rhs )
284  {
285  BLAZE_USER_ASSERT( rhs != Other(0), "Division by zero detected" );
286 
287  (~dv_) /= rhs;
288  return *this;
289  }
290  //**********************************************************************************************
291 
292  //**Size function*******************************************************************************
297  inline size_t size() const {
298  return dv_.size();
299  }
300  //**********************************************************************************************
301 
302  //**Reset function******************************************************************************
307  inline void reset() {
308  return dv_.reset();
309  }
310  //**********************************************************************************************
311 
312  //**CanAliased function*************************************************************************
318  template< typename Other > // Data type of the foreign expression
319  inline bool canAlias( const Other* alias ) const
320  {
321  return dv_.canAlias( alias );
322  }
323  //**********************************************************************************************
324 
325  //**IsAliased function**************************************************************************
331  template< typename Other > // Data type of the foreign expression
332  inline bool isAliased( const Other* alias ) const
333  {
334  return dv_.isAliased( alias );
335  }
336  //**********************************************************************************************
337 
338  //**IsAligned function**************************************************************************
343  inline bool isAligned() const
344  {
345  return dv_.isAligned();
346  }
347  //**********************************************************************************************
348 
349  //**CanSMPAssign function***********************************************************************
354  inline bool canSMPAssign() const
355  {
356  return dv_.canSMPAssign();
357  }
358  //**********************************************************************************************
359 
360  //**Load function*******************************************************************************
370  BLAZE_ALWAYS_INLINE IntrinsicType load( size_t index ) const
371  {
372  return dv_.load( index );
373  }
374  //**********************************************************************************************
375 
376  //**Loada function******************************************************************************
386  BLAZE_ALWAYS_INLINE IntrinsicType loada( size_t index ) const
387  {
388  return dv_.loada( index );
389  }
390  //**********************************************************************************************
391 
392  //**Loadu function******************************************************************************
402  BLAZE_ALWAYS_INLINE IntrinsicType loadu( size_t index ) const
403  {
404  return dv_.loadu( index );
405  }
406  //**********************************************************************************************
407 
408  //**Store function******************************************************************************
419  BLAZE_ALWAYS_INLINE void store( size_t index, const IntrinsicType& value )
420  {
421  dv_.store( index, value );
422  }
423  //**********************************************************************************************
424 
425  //**Storea function******************************************************************************
436  BLAZE_ALWAYS_INLINE void storea( size_t index, const IntrinsicType& value )
437  {
438  dv_.storea( index, value );
439  }
440  //**********************************************************************************************
441 
442  //**Storeu function*****************************************************************************
453  BLAZE_ALWAYS_INLINE void storeu( size_t index, const IntrinsicType& value )
454  {
455  dv_.storeu( index, value );
456  }
457  //**********************************************************************************************
458 
459  //**Stream function*****************************************************************************
470  BLAZE_ALWAYS_INLINE void stream( size_t index, const IntrinsicType& value )
471  {
472  dv_.stream( index, value );
473  }
474  //**********************************************************************************************
475 
476  //**Transpose assignment of dense vectors*******************************************************
487  template< typename VT2 > // Type of the right-hand side dense vector
488  inline void assign( const DenseVector<VT2,TF>& rhs )
489  {
491 
492  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
493 
494  const size_t n( size() );
495 
496  const size_t ipos( n & size_t(-2) );
497  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ipos, "Invalid end calculation" );
498 
499  for( size_t i=0UL; i<ipos; i+=2UL ) {
500  dv_[i ] = (~rhs)[i ];
501  dv_[i+1UL] = (~rhs)[i+1UL];
502  }
503  if( ipos < n )
504  dv_[ipos] = (~rhs)[ipos];
505  }
506  //**********************************************************************************************
507 
508  //**Transpose assignment of sparse vectors******************************************************
519  template< typename VT2 > // Type of the right-hand side sparse vector
520  inline void assign( const SparseVector<VT2,TF>& rhs )
521  {
523 
524  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
525 
526  typedef typename VT2::ConstIterator RhsConstIterator;
527 
528  for( RhsConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
529  dv_[element->index()] = element->value();
530  }
531  //**********************************************************************************************
532 
533  //**Transpose addition assignment of dense vectors**********************************************
544  template< typename VT2 > // Type of the right-hand side dense vector
545  inline void addAssign( const DenseVector<VT2,TF>& rhs )
546  {
548 
549  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
550 
551  const size_t n( size() );
552 
553  const size_t ipos( n & size_t(-2) );
554  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ipos, "Invalid end calculation" );
555 
556  for( size_t i=0UL; i<ipos; i+=2UL ) {
557  dv_[i ] += (~rhs)[i ];
558  dv_[i+1UL] += (~rhs)[i+1UL];
559  }
560  if( ipos < n )
561  dv_[ipos] += (~rhs)[ipos];
562  }
563  //**********************************************************************************************
564 
565  //**Transpose addition assignment of sparse vectors*********************************************
576  template< typename VT2 > // Type of the right-hand side sparse vector
577  inline void addAssign( const SparseVector<VT2,TF>& rhs )
578  {
580 
581  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
582 
583  typedef typename VT2::ConstIterator RhsConstIterator;
584 
585  for( RhsConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
586  dv_[element->index()] += element->value();
587  }
588  //**********************************************************************************************
589 
590  //**Transpose subtraction assignment of dense vectors*******************************************
601  template< typename VT2 > // Type of the right-hand side dense vector
602  inline void subAssign( const DenseVector<VT2,TF>& rhs )
603  {
605 
606  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
607 
608  const size_t n( size() );
609 
610  const size_t ipos( n & size_t(-2) );
611  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ipos, "Invalid end calculation" );
612 
613  for( size_t i=0UL; i<ipos; i+=2UL ) {
614  dv_[i ] -= (~rhs)[i ];
615  dv_[i+1UL] -= (~rhs)[i+1UL];
616  }
617  if( ipos < n )
618  dv_[ipos] -= (~rhs)[ipos];
619  }
620  //**********************************************************************************************
621 
622  //**Transpose subtraction assignment of sparse vectors******************************************
633  template< typename VT2 > // Type of the right-hand side sparse vector
634  inline void subAssign( const SparseVector<VT2,TF>& rhs )
635  {
637 
638  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
639 
640  typedef typename VT2::ConstIterator RhsConstIterator;
641 
642  for( RhsConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
643  dv_[element->index()] -= element->value();
644  }
645  //**********************************************************************************************
646 
647  //**Transpose multiplication assignment of dense vectors****************************************
658  template< typename VT2 > // Type of the right-hand side dense vector
659  inline void multAssign( const DenseVector<VT2,TF>& rhs )
660  {
662 
663  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
664 
665  const size_t n( size() );
666 
667  const size_t ipos( n & size_t(-2) );
668  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ipos, "Invalid end calculation" );
669 
670  for( size_t i=0UL; i<ipos; i+=2UL ) {
671  dv_[i ] *= (~rhs)[i ];
672  dv_[i+1UL] *= (~rhs)[i+1UL];
673  }
674  if( ipos < n )
675  dv_[ipos] *= (~rhs)[ipos];
676  }
677  //**********************************************************************************************
678 
679  //**Transpose multiplication assignment of sparse vectors***************************************
690  template< typename VT2 > // Type of the right-hand side dense vector
691  inline void multAssign( const SparseVector<VT2,TF>& rhs )
692  {
694 
695  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
696 
697  typedef typename VT2::ConstIterator RhsConstIterator;
698 
699  const VT tmp( dv_ );
700  dv_.reset();
701 
702  for( RhsConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
703  dv_[element->index()] = tmp[element->index()] * element->value();
704  }
705  //**********************************************************************************************
706 
707  private:
708  //**Member variables****************************************************************************
709  VT& dv_;
710  //**********************************************************************************************
711 
712  //**Compile time checks*************************************************************************
718  //**********************************************************************************************
719 };
720 //*************************************************************************************************
721 
722 
723 
724 
725 //=================================================================================================
726 //
727 // GLOBAL OPERATORS
728 //
729 //=================================================================================================
730 
731 //*************************************************************************************************
739 template< typename VT // Type of the dense vector
740  , bool TF > // Transpose flag
741 inline void reset( DVecTransposer<VT,TF>& v )
742 {
743  v.reset();
744 }
746 //*************************************************************************************************
747 
748 
749 
750 
751 //=================================================================================================
752 //
753 // ISALIGNED SPECIALIZATIONS
754 //
755 //=================================================================================================
756 
757 //*************************************************************************************************
759 template< typename VT, bool TF >
760 struct IsAligned< DVecTransposer<VT,TF> > : public IsTrue< IsAligned<VT>::value >
761 {};
763 //*************************************************************************************************
764 
765 
766 
767 
768 //=================================================================================================
769 //
770 // ISPADDED SPECIALIZATIONS
771 //
772 //=================================================================================================
773 
774 //*************************************************************************************************
776 template< typename VT, bool TF >
777 struct IsPadded< DVecTransposer<VT,TF> > : public IsTrue< IsPadded<VT>::value >
778 {};
780 //*************************************************************************************************
781 
782 
783 
784 
785 //=================================================================================================
786 //
787 // SUBVECTORTRAIT SPECIALIZATIONS
788 //
789 //=================================================================================================
790 
791 //*************************************************************************************************
793 template< typename VT, bool TF >
794 struct SubvectorTrait< DVecTransposer<VT,TF> >
795 {
797 };
799 //*************************************************************************************************
800 
801 } // namespace blaze
802 
803 #endif
Reference operator[](size_t index)
Subscript operator for the direct access to the vector elements.
Definition: DVecTransposer.h:130
Constraint on the data type.
Iterator begin()
Returns an iterator to the first element of the dense vector.
Definition: DVecTransposer.h:203
bool isAliased(const Other *alias) const
Returns whether the vector is aliased with the given address alias.
Definition: DVecTransposer.h:332
VT::ConstIterator ConstIterator
Iterator over constant elements.
Definition: DVecTransposer.h:97
#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
size_t size() const
Returns the current size/dimension of the vector.
Definition: DVecTransposer.h:297
Header file for basic type definitions.
VT::Iterator Iterator
Iterator over non-constant elements.
Definition: DVecTransposer.h:96
ConstReference at(size_t index) const
Checked access to the vector elements.
Definition: DVecTransposer.h:170
#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:118
bool canSMPAssign() const
Returns whether the vector can be used in SMP assignments.
Definition: DVecTransposer.h:354
void subAssign(const DenseVector< VT2, TF > &rhs)
Implementation of the transpose subtraction assignment of a dense vector.
Definition: DVecTransposer.h:602
BLAZE_ALWAYS_INLINE IntrinsicType load(size_t index) const
Load of an intrinsic element of the vector.
Definition: DVecTransposer.h:370
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:507
VT::ConstReference ConstReference
Reference to a constant vector value.
Definition: DVecTransposer.h:93
ConstIterator cend() const
Returns an iterator just past the last element of the dense vector.
Definition: DVecTransposer.h:253
void multAssign(const SparseVector< VT2, TF > &rhs)
Implementation of the transpose multiplication assignment of a sparse vector.
Definition: DVecTransposer.h:691
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:142
bool canAlias(const Other *alias) const
Returns whether the vector can alias with the given address alias.
Definition: DVecTransposer.h:319
VT::ConstPointer ConstPointer
Pointer to a constant vector value.
Definition: DVecTransposer.h:95
ConstIterator begin() const
Returns an iterator to the first element of the dense vector.
Definition: DVecTransposer.h:213
VT::ElementType ElementType
Type of the vector elements.
Definition: DVecTransposer.h:88
Header file for the intrinsic trait.
BLAZE_ALWAYS_INLINE void stream(size_t index, const IntrinsicType &value)
Aligned, non-temporal store of an intrinsic element of the vector.
Definition: DVecTransposer.h:470
Expression object for the transposition of a dense vector.The DVecTransposer class is a wrapper objec...
Definition: DVecTransposer.h:76
VT::ResultType TransposeType
Transpose type for expression template evaluations.
Definition: DVecTransposer.h:87
bool isAligned() const
Returns whether the vector is properly aligned in memory.
Definition: DVecTransposer.h:343
VT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: DVecTransposer.h:90
IntrinsicTrait< typename VT::ElementType > IT
Intrinsic trait for the vector element type.
Definition: DVecTransposer.h:80
DVecTransposer(VT &dv)
Constructor for the DVecTransposer class.
Definition: DVecTransposer.h:119
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
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
BLAZE_ALWAYS_INLINE IntrinsicType loada(size_t index) const
Aligned load of an intrinsic element of the vector.
Definition: DVecTransposer.h:386
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
Pointer data()
Low-level data access to the vector elements.
Definition: DVecTransposer.h:183
Header file for the subvector trait.
Reference at(size_t index)
Checked access to the vector elements.
Definition: DVecTransposer.h:155
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
Header file for the IsAligned type trait.
Constraint on the data type.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2585
Constraint on the data type.
VT::Reference Reference
Reference to a non-constant vector value.
Definition: DVecTransposer.h:92
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2586
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2590
BLAZE_ALWAYS_INLINE IntrinsicType loadu(size_t index) const
Unaligned load of an intrinsic element of the vector.
Definition: DVecTransposer.h:402
Header file for the EnableIf class template.
Header file for the IsPadded type trait.
void reset()
Resets the vector elements.
Definition: DVecTransposer.h:307
Header file for the IsNumeric type trait.
DVecTransposer< VT, TF > This
Type of this DVecTransposer instance.
Definition: DVecTransposer.h:85
BLAZE_ALWAYS_INLINE void storeu(size_t index, const IntrinsicType &value)
Unaligned store of an intrinsic element of the vector.
Definition: DVecTransposer.h:453
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2587
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:1232
Header file for run time assertion macros.
const This & CompositeType
Data type for composite expression templates.
Definition: DVecTransposer.h:91
Iterator end()
Returns an iterator just past the last element of the dense vector.
Definition: DVecTransposer.h:233
void addAssign(const SparseVector< VT2, TF > &rhs)
Implementation of the transpose addition assignment of a sparse vector.
Definition: DVecTransposer.h:577
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
void addAssign(const DenseVector< VT2, TF > &rhs)
Implementation of the transpose addition assignment of a dense vector.
Definition: DVecTransposer.h:545
ConstIterator end() const
Returns an iterator just past the last element of the dense vector.
Definition: DVecTransposer.h:243
BLAZE_ALWAYS_INLINE void storea(size_t index, const IntrinsicType &value)
Aligned store of an intrinsic element of the vector.
Definition: DVecTransposer.h:436
IT::Type IntrinsicType
Intrinsic type of the vector elements.
Definition: DVecTransposer.h:89
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2591
void subAssign(const SparseVector< VT2, TF > &rhs)
Implementation of the transpose subtraction assignment of a sparse vector.
Definition: DVecTransposer.h:634
VT::Pointer Pointer
Pointer to a non-constant vector value.
Definition: DVecTransposer.h:94
void assign(const SparseVector< VT2, TF > &rhs)
Implementation of the transpose assignment of a sparse vector.
Definition: DVecTransposer.h:520
#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:79
VT::TransposeType ResultType
Result type for expression template evaluations.
Definition: DVecTransposer.h:86
void assign(const DenseVector< VT2, TF > &rhs)
Implementation of the transpose assignment of a dense vector.
Definition: DVecTransposer.h:488
EnableIf< IsNumeric< Other >, DVecTransposer >::Type & operator/=(Other rhs)
Division assignment operator for the division of a vector by a scalar value ( ).
Definition: DVecTransposer.h:283
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:118
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
Header file for the IsTrue value trait.
EnableIf< IsNumeric< Other >, DVecTransposer >::Type & operator*=(Other rhs)
Multiplication assignment operator for the multiplication between a vector and a scalar value ( )...
Definition: DVecTransposer.h:266
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2589
Header file for exception macros.
BLAZE_ALWAYS_INLINE void store(size_t index, const IntrinsicType &value)
Store of an intrinsic element of the vector.
Definition: DVecTransposer.h:419
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:659
#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:81
#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:223
VT & dv_
The dense vector operand.
Definition: DVecTransposer.h:709
ConstPointer data() const
Low-level data access to the vector elements.
Definition: DVecTransposer.h:193