Blaze 3.9
SVecTransExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_SVECTRANSEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_SVECTRANSEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Aliases.h>
57#include <blaze/util/Assert.h>
58#include <blaze/util/EnableIf.h>
62#include <blaze/util/mpl/If.h>
63#include <blaze/util/Types.h>
65
66
67namespace blaze {
68
69//=================================================================================================
70//
71// CLASS SVECTRANSEXPR
72//
73//=================================================================================================
74
75//*************************************************************************************************
82template< typename VT // Type of the sparse vector
83 , bool TF > // Transpose flag
85 : public VecTransExpr< SparseVector< SVecTransExpr<VT,TF>, TF > >
86 , private If_t< IsComputation_v<VT>, Computation, Transformation >
87{
88 private:
89 //**Type definitions****************************************************************************
91 BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT( GetConstIterator, ConstIterator, INVALID_TYPE );
92 //**********************************************************************************************
93
94 //**Serial evaluation strategy******************************************************************
96
102 static constexpr bool useAssign = RequiresEvaluation_v<VT>;
103
106 template< typename VT2 >
107 static constexpr bool UseAssign_v = useAssign;
109 //**********************************************************************************************
110
111 //**Parallel evaluation strategy****************************************************************
113
119 template< typename VT2 >
120 static constexpr bool UseSMPAssign_v = ( VT2::smpAssignable && useAssign );
122 //**********************************************************************************************
123
124 public:
125 //**Type definitions****************************************************************************
128
131
136
139
141 using ConstIterator = GetConstIterator_t<VT>;
142
144 using Operand = If_t< IsExpression_v<VT>, const VT, const VT& >;
145 //**********************************************************************************************
146
147 //**Compilation flags***************************************************************************
149 static constexpr bool smpAssignable = VT::smpAssignable;
150 //**********************************************************************************************
151
152 //**Constructor*********************************************************************************
157 explicit inline SVecTransExpr( const VT& sv ) noexcept
158 : sv_( sv ) // Sparse vector of the transposition expression
159 {}
160 //**********************************************************************************************
161
162 //**Subscript operator**************************************************************************
168 inline ReturnType operator[]( size_t index ) const {
169 BLAZE_INTERNAL_ASSERT( index < sv_.size(), "Invalid vector access index" );
170 return sv_[index];
171 }
172 //**********************************************************************************************
173
174 //**At function*********************************************************************************
181 inline ReturnType at( size_t index ) const {
182 if( index >= sv_.size() ) {
183 BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
184 }
185 return (*this)[index];
186 }
187 //**********************************************************************************************
188
189 //**Begin function******************************************************************************
194 inline ConstIterator begin() const {
195 return ConstIterator( sv_.begin() );
196 }
197 //**********************************************************************************************
198
199 //**End function********************************************************************************
204 inline ConstIterator end() const {
205 return ConstIterator( sv_.end() );
206 }
207 //**********************************************************************************************
208
209 //**Size function*******************************************************************************
214 inline size_t size() const noexcept {
215 return sv_.size();
216 }
217 //**********************************************************************************************
218
219 //**NonZeros function***************************************************************************
224 inline size_t nonZeros() const {
225 return sv_.nonZeros();
226 }
227 //**********************************************************************************************
228
229 //**Find function*******************************************************************************
235 inline ConstIterator find( size_t index ) const {
237 return ConstIterator( sv_.find( index ) );
238 }
239 //**********************************************************************************************
240
241 //**LowerBound function*************************************************************************
247 inline ConstIterator lowerBound( size_t index ) const {
249 return ConstIterator( sv_.lowerBound( index ) );
250 }
251 //**********************************************************************************************
252
253 //**UpperBound function*************************************************************************
259 inline ConstIterator upperBound( size_t index ) const {
261 return ConstIterator( sv_.upperBound( index ) );
262 }
263 //**********************************************************************************************
264
265 //**Operand access******************************************************************************
270 inline Operand operand() const noexcept {
271 return sv_;
272 }
273 //**********************************************************************************************
274
275 //**********************************************************************************************
281 template< typename T >
282 inline bool canAlias( const T* alias ) const noexcept {
283 return sv_.canAlias( alias );
284 }
285 //**********************************************************************************************
286
287 //**********************************************************************************************
293 template< typename T >
294 inline bool isAliased( const T* alias ) const noexcept {
295 return sv_.isAliased( alias );
296 }
297 //**********************************************************************************************
298
299 //**********************************************************************************************
304 inline bool canSMPAssign() const noexcept {
305 return sv_.canSMPAssign();
306 }
307 //**********************************************************************************************
308
309 private:
310 //**Member variables****************************************************************************
312 //**********************************************************************************************
313
314 //**Assignment to dense vectors*****************************************************************
328 template< typename VT2 > // Type of the target dense vector
329 friend inline auto assign( DenseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
331 {
333
334 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
335
336 DVecTransposer<VT2,!TF> tmp( *lhs );
337 assign( tmp, rhs.sv_ );
338 }
340 //**********************************************************************************************
341
342 //**Assignment to sparse vectors****************************************************************
356 template< typename VT2 > // Type of the target sparse vector
357 friend inline auto assign( SparseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
359 {
361
362 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
363
364 SVecTransposer<VT2,!TF> tmp( *lhs );
365 assign( tmp, rhs.sv_ );
366 }
368 //**********************************************************************************************
369
370 //**Addition assignment to dense vectors********************************************************
384 template< typename VT2 > // Type of the target dense vector
385 friend inline auto addAssign( DenseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
386 -> EnableIf_t< UseAssign_v<VT2> >
387 {
389
390 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
391
392 DVecTransposer<VT2,!TF> tmp( *lhs );
393 addAssign( tmp, rhs.sv_ );
394 }
396 //**********************************************************************************************
397
398 //**Addition assignment to sparse vectors*******************************************************
399 // No special implementation for the addition assignment to sparse vectors.
400 //**********************************************************************************************
401
402 //**Subtraction assignment to dense vectors*****************************************************
416 template< typename VT2 > // Type of the target dense vector
417 friend inline auto subAssign( DenseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
418 -> EnableIf_t< UseAssign_v<VT2> >
419 {
421
422 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
423
424 DVecTransposer<VT2,!TF> tmp( *lhs );
425 subAssign( tmp, rhs.sv_ );
426 }
428 //**********************************************************************************************
429
430 //**Subtraction assignment to sparse vectors****************************************************
431 // No special implementation for the subtraction assignment to sparse vectors.
432 //**********************************************************************************************
433
434 //**Multiplication assignment to dense vectors**************************************************
448 template< typename VT2 > // Type of the target dense vector
449 friend inline auto multAssign( DenseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
450 -> EnableIf_t< UseAssign_v<VT2> >
451 {
453
454 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
455
456 DVecTransposer<VT2,!TF> tmp( *lhs );
457 multAssign( tmp, rhs.sv_ );
458 }
460 //**********************************************************************************************
461
462 //**Multiplication assignment to sparse vectors*************************************************
463 // No special implementation for the multiplication assignment to sparse vectors.
464 //**********************************************************************************************
465
466 //**SMP assignment to dense vectors*************************************************************
480 template< typename VT2 > // Type of the target dense vector
481 friend inline auto smpAssign( DenseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
482 -> EnableIf_t< UseSMPAssign_v<VT2> >
483 {
485
486 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
487
488 DVecTransposer<VT2,!TF> tmp( *lhs );
489 smpAssign( tmp, rhs.sv_ );
490 }
492 //**********************************************************************************************
493
494 //**SMP assignment to sparse vectors************************************************************
508 template< typename VT2 > // Type of the target sparse vector
509 friend inline auto smpAssign( SparseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
510 -> EnableIf_t< UseSMPAssign_v<VT2> >
511 {
513
514 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
515
516 SVecTransposer<VT2,!TF> tmp( *lhs );
517 smpAssign( tmp, rhs.sv_ );
518 }
520 //**********************************************************************************************
521
522 //**SMP addition assignment to dense vectors****************************************************
536 template< typename VT2 > // Type of the target dense vector
537 friend inline auto smpAddAssign( DenseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
538 -> EnableIf_t< UseSMPAssign_v<VT2> >
539 {
541
542 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
543
544 DVecTransposer<VT2,!TF> tmp( *lhs );
545 smpAddAssign( tmp, rhs.sv_ );
546 }
548 //**********************************************************************************************
549
550 //**SMP addition assignment to sparse vectors***************************************************
551 // No special implementation for the SMP addition assignment to sparse vectors.
552 //**********************************************************************************************
553
554 //**SMP subtraction assignment to dense vectors*************************************************
568 template< typename VT2 > // Type of the target dense vector
569 friend inline auto smpSubAssign( DenseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
570 -> EnableIf_t< UseSMPAssign_v<VT2> >
571 {
573
574 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
575
576 DVecTransposer<VT2,!TF> tmp( *lhs );
577 smpSubAssign( tmp, rhs.sv_ );
578 }
580 //**********************************************************************************************
581
582 //**SMP subtraction assignment to sparse vectors************************************************
583 // No special implementation for the SMP subtraction assignment to sparse vectors.
584 //**********************************************************************************************
585
586 //**SMP multiplication assignment to dense vectors**********************************************
601 template< typename VT2 > // Type of the target dense vector
602 friend inline auto smpMultAssign( DenseVector<VT2,TF>& lhs, const SVecTransExpr& rhs )
603 -> EnableIf_t< UseSMPAssign_v<VT2> >
604 {
606
607 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
608
609 DVecTransposer<VT2,!TF> tmp( *lhs );
610 smpMultAssign( tmp, rhs.sv_ );
611 }
613 //**********************************************************************************************
614
615 //**SMP multiplication assignment to sparse vectors*********************************************
616 // No special implementation for the SMP multiplication assignment to sparse vectors.
617 //**********************************************************************************************
618
619 //**Compile time checks*************************************************************************
623 //**********************************************************************************************
624};
625//*************************************************************************************************
626
627
628
629
630//=================================================================================================
631//
632// GLOBAL OPERATORS
633//
634//=================================================================================================
635
636//*************************************************************************************************
655template< typename VT // Type of the sparse vector
656 , bool TF > // Transpose flag
657inline decltype(auto) trans( const SparseVector<VT,TF>& sv )
658{
660
661 using ReturnType = const SVecTransExpr<VT,!TF>;
662 return ReturnType( *sv );
663}
664//*************************************************************************************************
665
666
667//*************************************************************************************************
675template< typename VT // Type of the sparse vector
676 , bool TF > // Transpose flag
677inline decltype(auto) transTo_backend( const SparseVector<VT,TF>& sv, FalseType )
678{
679 return trans( *sv );
680}
682//*************************************************************************************************
683
684
685//*************************************************************************************************
693template< typename VT // Type of the sparse vector
694 , bool TF > // Transpose flag
695inline const VT& transTo_backend( const SparseVector<VT,TF>& sv, TrueType )
696{
697 return *sv;
698}
700//*************************************************************************************************
701
702
703//*************************************************************************************************
715template< bool TTF // Target transpose flag
716 , typename VT // Type of the sparse vector
717 , bool TF > // Current transpose flag of the sparse vector
718inline decltype(auto) transTo( const SparseVector<VT,TF>& sv )
719{
720 return transTo_backend( *sv, BoolConstant<TTF == TF>() );
721}
722//*************************************************************************************************
723
724} // namespace blaze
725
726#endif
Header file for auxiliary alias declarations.
typename T::ReturnType ReturnType_t
Alias declaration for nested ReturnType type definitions.
Definition: Aliases.h:470
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.
Definition: Aliases.h:450
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.
Definition: Aliases.h:190
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.
Definition: Aliases.h:550
Header file for run time assertion macros.
Header file for the dense vector transposer.
Header file for the EnableIf class template.
Header file for the function trace functionality.
Header file for the GetMemberType type trait.
Header file for the If class template.
Header file for the IntegralConstant class template.
Utility type for generic codes.
Header file for the IsExpression type trait class.
Deactivation of problematic macros.
Header file for the sparse vector transposer.
Expression object for the transposition of a dense vector.
Definition: DVecTransposer.h:81
Base class for N-dimensional dense vectors.
Definition: DenseVector.h:77
Expression object for sparse vector transpositions.
Definition: SVecTransExpr.h:87
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SVecTransExpr.h:294
If_t< IsExpression_v< VT >, const VT, const VT & > Operand
Composite data type of the sparse vector expression.
Definition: SVecTransExpr.h:144
BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT(GetConstIterator, ConstIterator, INVALID_TYPE)
Definition of the GetConstIterator type trait.
ConstIterator end() const
Returns an iterator just past the last non-zero element of the sparse vector.
Definition: SVecTransExpr.h:204
ReturnType_t< VT > ReturnType
Return type for expression template evaluations.
Definition: SVecTransExpr.h:135
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: SVecTransExpr.h:181
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: SVecTransExpr.h:168
TransposeType_t< VT > ResultType
Result type for expression template evaluations.
Definition: SVecTransExpr.h:132
ResultType_t< VT > TransposeType
Transpose type for expression template evaluations.
Definition: SVecTransExpr.h:133
Operand sv_
Sparse vector of the transposition expression.
Definition: SVecTransExpr.h:311
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SVecTransExpr.h:304
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the transposition expression.
Definition: SVecTransExpr.h:102
size_t nonZeros() const
Returns the number of non-zero elements in the sparse vector.
Definition: SVecTransExpr.h:224
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: SVecTransExpr.h:214
SVecTransExpr(const VT &sv) noexcept
Constructor for the SVecTransExpr class.
Definition: SVecTransExpr.h:157
GetConstIterator_t< VT > ConstIterator
Iterator over the elements of the dense vector.
Definition: SVecTransExpr.h:141
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: SVecTransExpr.h:149
ConstIterator begin() const
Returns an iterator to the first non-zero element of the sparse vector.
Definition: SVecTransExpr.h:194
ConstIterator find(size_t index) const
Searches for a specific vector element.
Definition: SVecTransExpr.h:235
ConstIterator lowerBound(size_t index) const
Returns an iterator to the first index not less then the given index.
Definition: SVecTransExpr.h:247
If_t< useAssign, const ResultType, const SVecTransExpr & > CompositeType
Data type for composite expression templates.
Definition: SVecTransExpr.h:138
ConstIterator upperBound(size_t index) const
Returns an iterator to the first index greater then the given index.
Definition: SVecTransExpr.h:259
Operand operand() const noexcept
Returns the sparse vector operand.
Definition: SVecTransExpr.h:270
ElementType_t< VT > ElementType
Resulting element type.
Definition: SVecTransExpr.h:134
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SVecTransExpr.h:282
Expression object for the transposition of a sparse vector.
Definition: SVecTransposer.h:77
Base class for sparse vectors.
Definition: SparseVector.h:72
Constraint on the data type.
Constraint on the data type.
Header file for the Computation base class.
Header file for the SparseVector base class.
Header file for the Transformation base class.
Header file for the VecTransExpr base class.
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:766
decltype(auto) transTo(const DenseVector< VT, TF > &dv)
Conditional calculation of the transpose of the given dense vector.
Definition: DVecTransExpr.h:783
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.
Definition: RequiresEvaluation.h:81
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.
Definition: SparseVector.h:61
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
auto smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:162
auto smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:100
auto smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP multiplication assignment of a vector to a dense vector.
Definition: DenseVector.h:192
auto smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:131
BoolConstant< true > TrueType
Type traits base class.
Definition: IntegralConstant.h:132
BoolConstant< false > FalseType
Type/value traits base class.
Definition: IntegralConstant.h:121
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.
Definition: EnableIf.h:138
typename If< Condition >::template Type< T1, T2 > If_t
Auxiliary alias template for the If class template.
Definition: If.h:108
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.
Definition: Exception.h:331
#define BLAZE_FUNCTION_TRACE
Function trace macro.
Definition: FunctionTrace.h:94
Header file for the exception macros of the math module.
Header file for all forward declarations for expression class templates.
Generic wrapper for a compile time constant integral value.
Definition: IntegralConstant.h:74
Base class for all vector transposition expression templates.
Definition: VecTransExpr.h:69
Header file for the RequiresEvaluation type trait.
Header file for basic type definitions.