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 canAlias( const Other* alias ) const
136  {
137  return dv_.canAlias( alias );
138  }
139  //**********************************************************************************************
140 
141  //**IsAliased function**************************************************************************
147  template< typename Other > // Data type of the foreign expression
148  inline bool isAliased( const Other* alias ) const
149  {
150  return dv_.isAliased( alias );
151  }
152  //**********************************************************************************************
153 
154  //**Transpose assignment of dense vectors*******************************************************
165  template< typename VT2 > // Type of the right-hand side dense vector
166  inline void assign( const DenseVector<VT2,TF>& rhs )
167  {
169 
170  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
171 
172  const size_t n( size() );
173 
174  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
175  const size_t end( n & size_t(-2) );
176 
177  for( size_t i=0UL; i<end; i+=2UL ) {
178  dv_[i ] = (~rhs)[i ];
179  dv_[i+1UL] = (~rhs)[i+1UL];
180  }
181  if( end < n )
182  dv_[end] = (~rhs)[end];
183  }
184  //**********************************************************************************************
185 
186  //**Transpose assignment of sparse vectors******************************************************
197  template< typename VT2 > // Type of the right-hand side sparse vector
198  inline void assign( const SparseVector<VT2,TF>& rhs )
199  {
201 
202  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
203 
204  typedef typename VT2::ConstIterator ConstIterator;
205 
206  for( ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
207  dv_[element->index()] = element->value();
208  }
209  //**********************************************************************************************
210 
211  //**Transpose addition assignment of dense vectors**********************************************
222  template< typename VT2 > // Type of the right-hand side dense vector
223  inline void addAssign( const DenseVector<VT2,TF>& rhs )
224  {
226 
227  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
228 
229  const size_t n( size() );
230 
231  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
232  const size_t end( n & size_t(-2) );
233 
234  for( size_t i=0UL; i<end; i+=2UL ) {
235  dv_[i ] += (~rhs)[i ];
236  dv_[i+1UL] += (~rhs)[i+1UL];
237  }
238  if( end < n )
239  dv_[end] += (~rhs)[end];
240  }
241  //**********************************************************************************************
242 
243  //**Transpose addition assignment of sparse vectors*********************************************
254  template< typename VT2 > // Type of the right-hand side sparse vector
255  inline void addAssign( const SparseVector<VT2,TF>& rhs )
256  {
258 
259  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
260 
261  typedef typename VT2::ConstIterator ConstIterator;
262 
263  for( ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
264  dv_[element->index()] += element->value();
265  }
266  //**********************************************************************************************
267 
268  //**Transpose subtraction assignment of dense vectors*******************************************
279  template< typename VT2 > // Type of the right-hand side dense vector
280  inline void subAssign( const DenseVector<VT2,TF>& rhs )
281  {
283 
284  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
285 
286  const size_t n( size() );
287 
288  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
289  const size_t end( n & size_t(-2) );
290 
291  for( size_t i=0UL; i<end; i+=2UL ) {
292  dv_[i ] -= (~rhs)[i ];
293  dv_[i+1UL] -= (~rhs)[i+1UL];
294  }
295  if( end < n )
296  dv_[end] -= (~rhs)[end];
297  }
298  //**********************************************************************************************
299 
300  //**Transpose subtraction assignment of sparse vectors******************************************
311  template< typename VT2 > // Type of the right-hand side sparse vector
312  inline void subAssign( const SparseVector<VT2,TF>& rhs )
313  {
315 
316  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
317 
318  typedef typename VT2::ConstIterator ConstIterator;
319 
320  for( ConstIterator element=(~rhs).begin(); element!=(~rhs).end(); ++element )
321  dv_[element->index()] -= element->value();
322  }
323  //**********************************************************************************************
324 
325  //**Transpose multiplication assignment of dense vectors****************************************
336  template< typename VT2 > // Type of the right-hand side dense vector
337  inline void multAssign( const DenseVector<VT2,TF>& rhs )
338  {
340 
341  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
342 
343  const size_t n( size() );
344 
345  BLAZE_INTERNAL_ASSERT( ( n - ( n % 2UL ) ) == ( n & size_t(-2) ), "Invalid end calculation" );
346  const size_t end( n & size_t(-2) );
347 
348  for( size_t i=0UL; i<end; i+=2UL ) {
349  dv_[i ] *= (~rhs)[i ];
350  dv_[i+1UL] *= (~rhs)[i+1UL];
351  }
352  if( end < n )
353  dv_[end] *= (~rhs)[end];
354  }
355  //**********************************************************************************************
356 
357  //**Transpose multiplication assignment of sparse vectors***************************************
368  template< typename VT2 > // Type of the right-hand side dense vector
369  inline void multAssign( const SparseVector<VT2,TF>& rhs )
370  {
372 
373  BLAZE_INTERNAL_ASSERT( dv_.size() == (~rhs).size(), "Invalid vector sizes" );
374 
375  typedef typename VT2::ConstIterator ConstIterator;
376 
377  const VT tmp( dv_ );
378  const ConstIterator end( (~rhs).end() );
379 
380  dv_.reset();
381 
382  for( ConstIterator element=(~rhs).begin(); element!=end; ++element )
383  dv_[element->index()] = tmp[element->index()] * element->value();
384  }
385  //**********************************************************************************************
386 
387  private:
388  //**Member variables****************************************************************************
389  VT& dv_;
390  //**********************************************************************************************
391 
392  //**Compile time checks*************************************************************************
398  //**********************************************************************************************
399 };
400 //*************************************************************************************************
401 
402 
403 
404 
405 //=================================================================================================
406 //
407 // GLOBAL OPERATORS
408 //
409 //=================================================================================================
410 
411 //*************************************************************************************************
419 template< typename VT // Type of the dense vector
420  , bool TF > // Transpose flag
421 inline void reset( DVecTransposer<VT,TF>& v )
422 {
423  v.reset();
424 }
426 //*************************************************************************************************
427 
428 } // namespace blaze
429 
430 #endif