All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DVecTransposer.h
Go to the documentation of this file.
1 //=================================================================================================
20 //=================================================================================================
21 
22 #ifndef _BLAZE_MATH_EXPRESSIONS_DVECTRANSPOSER_H_
23 #define _BLAZE_MATH_EXPRESSIONS_DVECTRANSPOSER_H_
24 
25 
26 //*************************************************************************************************
27 // Includes
28 //*************************************************************************************************
29 
34 #include <blaze/util/Assert.h>
35 #include <blaze/util/Types.h>
36 
37 
38 namespace blaze {
39 
40 //=================================================================================================
41 //
42 // CLASS DVECTRANSPOSER
43 //
44 //=================================================================================================
45 
46 //*************************************************************************************************
52 template< typename VT // Type of the dense vector
53  , bool TF > // Transpose flag
54 class DVecTransposer : public DenseVector< DVecTransposer<VT,TF>, TF >
55 {
56  public:
57  //**Type definitions****************************************************************************
59  typedef typename VT::TransposeType ResultType;
60  typedef typename VT::ResultType TransposeType;
61  typedef typename VT::ElementType ElementType;
62  typedef typename VT::ReturnType ReturnType;
63  typedef const This& CompositeType;
64  typedef typename VT::Reference Reference;
65  typedef typename VT::ConstReference ConstReference;
66  //**********************************************************************************************
67 
68  //**Compilation flags***************************************************************************
70 
73  enum { vectorizable = VT::vectorizable };
74  //**********************************************************************************************
75 
76  //**Constructor*********************************************************************************
81  explicit inline DVecTransposer( VT& dv )
82  : dv_( dv ) // The dense vector operand
83  {}
84  //**********************************************************************************************
85 
86  //**Subscript operator**************************************************************************
92  inline Reference operator[]( size_t index ) {
93  BLAZE_USER_ASSERT( index < dv_.size(), "Invalid vector access index" );
94  return dv_[index];
95  }
96  //**********************************************************************************************
97 
98  //**Low-level data access***********************************************************************
103  inline ElementType* data() {
104  return dv_.data();
105  }
106  //**********************************************************************************************
107 
108  //**Size function*******************************************************************************
113  inline size_t size() const {
114  return dv_.size();
115  }
116  //**********************************************************************************************
117 
118  //**Reset function******************************************************************************
123  inline void reset() {
124  return dv_.reset();
125  }
126  //**********************************************************************************************
127 
128  //**IsAliased function**************************************************************************
134  template< typename Other > // Data type of the foreign expression
135  inline bool isAliased( const Other* alias ) const
136  {
137  return dv_.isAliased( alias );
138  }
139  //**********************************************************************************************
140 
141  //**Transpose assignment of dense vectors*******************************************************
152  template< typename VT2 > // Type of the right-hand side dense vector
153  inline void assign( const DenseVector<VT2,TF>& rhs )
154  {
156 
157  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
158 
159  const size_t n( size() );
160 
161  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
162  const size_t end( n & size_t(-2) );
163 
164  for( size_t i=0UL; i<end; i+=2UL ) {
165  dv_[i ] = (~rhs)[i ];
166  dv_[i+1UL] = (~rhs)[i+1UL];
167  }
168  if( end < n )
169  dv_[end] = (~rhs)[end];
170  }
171  //**********************************************************************************************
172 
173  //**Transpose assignment of sparse vectors******************************************************
184  template< typename VT2 > // Type of the right-hand side sparse vector
185  inline void assign( const SparseVector<VT2,TF>& rhs )
186  {
188 
189  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
190 
191  typedef typename VT2::ConstIterator ConstIterator;
192 
193  for( ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
194  dv_[element->index()] = element->value();
195  }
196  //**********************************************************************************************
197 
198  //**Transpose addition assignment of dense vectors**********************************************
209  template< typename VT2 > // Type of the right-hand side dense vector
210  inline void addAssign( const DenseVector<VT2,TF>& rhs )
211  {
213 
214  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
215 
216  const size_t n( size() );
217 
218  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
219  const size_t end( n & size_t(-2) );
220 
221  for( size_t i=0UL; i<end; i+=2UL ) {
222  dv_[i ] += (~rhs)[i ];
223  dv_[i+1UL] += (~rhs)[i+1UL];
224  }
225  if( end < n )
226  dv_[end] += (~rhs)[end];
227  }
228  //**********************************************************************************************
229 
230  //**Transpose addition assignment of sparse vectors*********************************************
241  template< typename VT2 > // Type of the right-hand side sparse vector
242  inline void addAssign( const SparseVector<VT2,TF>& rhs )
243  {
245 
246  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
247 
248  typedef typename VT2::ConstIterator ConstIterator;
249 
250  for( ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
251  dv_[element->index()] += element->value();
252  }
253  //**********************************************************************************************
254 
255  //**Transpose subtraction assignment of dense vectors*******************************************
266  template< typename VT2 > // Type of the right-hand side dense vector
267  inline void subAssign( const DenseVector<VT2,TF>& rhs )
268  {
270 
271  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
272 
273  const size_t n( size() );
274 
275  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
276  const size_t end( n & size_t(-2) );
277 
278  for( size_t i=0UL; i<end; i+=2UL ) {
279  dv_[i ] -= (~rhs)[i ];
280  dv_[i+1UL] -= (~rhs)[i+1UL];
281  }
282  if( end < n )
283  dv_[end] -= (~rhs)[end];
284  }
285  //**********************************************************************************************
286 
287  //**Transpose subtraction assignment of sparse vectors******************************************
298  template< typename VT2 > // Type of the right-hand side sparse vector
299  inline void subAssign( const SparseVector<VT2,TF>& rhs )
300  {
302 
303  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
304 
305  typedef typename VT2::ConstIterator ConstIterator;
306 
307  for( ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
308  dv_[element->index()] -= element->value();
309  }
310  //**********************************************************************************************
311 
312  //**Transpose multiplication assignment of dense vectors****************************************
323  template< typename VT2 > // Type of the right-hand side dense vector
324  inline void multAssign( const DenseVector<VT2,TF>& rhs )
325  {
327 
328  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
329 
330  const size_t n( size() );
331 
332  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
333  const size_t end( n & size_t(-2) );
334 
335  for( size_t i=0UL; i<end; i+=2UL ) {
336  dv_[i ] *= (~rhs)[i ];
337  dv_[i+1UL] *= (~rhs)[i+1UL];
338  }
339  if( end < n )
340  dv_[end] *= (~rhs)[end];
341  }
342  //**********************************************************************************************
343 
344  //**Transpose multiplication assignment of sparse vectors***************************************
355  template< typename VT2 > // Type of the right-hand side dense vector
356  inline void multAssign( const SparseVector<VT2,TF>& rhs )
357  {
359 
360  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
361 
362  typedef typename VT2::ConstIterator ConstIterator;
363 
364  const VT tmp( dv_ );
365  const ConstIterator end( (~rhs).end() );
366 
367  dv_.reset();
368 
369  for( ConstIterator element=(~rhs).begin(); element!=end; ++element )
370  dv_[element->index()] = tmp[element->index()] * element->value();
371  }
372  //**********************************************************************************************
373 
374  private:
375  //**Member variables****************************************************************************
376  VT& dv_;
377  //**********************************************************************************************
378 
379  //**Compile time checks*************************************************************************
385  //**********************************************************************************************
386 };
387 //*************************************************************************************************
388 
389 
390 
391 
392 //=================================================================================================
393 //
394 // GLOBAL OPERATORS
395 //
396 //=================================================================================================
397 
398 //*************************************************************************************************
406 template< typename VT // Type of the dense vector
407  , bool TF > // Transpose flag
408 inline void reset( DVecTransposer<VT,TF>& v )
409 {
410  v.reset();
411 }
413 //*************************************************************************************************
414 
415 } // namespace blaze
416 
417 #endif