Blaze 3.9
DVecTransExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_DVECTRANSEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_DVECTRANSEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Aliases.h>
54#include <blaze/math/SIMD.h>
61#include <blaze/system/Inline.h>
63#include <blaze/util/Assert.h>
64#include <blaze/util/EnableIf.h>
68#include <blaze/util/mpl/If.h>
69#include <blaze/util/Types.h>
71
72
73namespace blaze {
74
75//=================================================================================================
76//
77// CLASS DVECTRANSEXPR
78//
79//=================================================================================================
80
81//*************************************************************************************************
88template< typename VT // Type of the dense vector
89 , bool TF > // Transpose flag
91 : public VecTransExpr< DenseVector< DVecTransExpr<VT,TF>, TF > >
92 , private If_t< IsComputation_v<VT>, Computation, Transformation >
93{
94 private:
95 //**Type definitions****************************************************************************
97 BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT( GetConstIterator, ConstIterator, INVALID_TYPE );
98 //**********************************************************************************************
99
100 //**Serial evaluation strategy******************************************************************
102
108 static constexpr bool useAssign = RequiresEvaluation_v<VT>;
109
112 template< typename VT2 >
113 static constexpr bool UseAssign_v = useAssign;
115 //**********************************************************************************************
116
117 //**Parallel evaluation strategy****************************************************************
119
125 template< typename VT2 >
126 static constexpr bool UseSMPAssign_v = ( VT2::smpAssignable && useAssign );
128 //**********************************************************************************************
129
130 public:
131 //**Type definitions****************************************************************************
134
137
142
145
147 using ConstIterator = GetConstIterator_t<VT>;
148
150 using Operand = If_t< IsExpression_v<VT>, const VT, const VT& >;
151 //**********************************************************************************************
152
153 //**Compilation flags***************************************************************************
155 static constexpr bool simdEnabled = VT::simdEnabled;
156
158 static constexpr bool smpAssignable = VT::smpAssignable;
159 //**********************************************************************************************
160
161 //**SIMD properties*****************************************************************************
163 static constexpr size_t SIMDSIZE = SIMDTrait<ElementType>::size;
164 //**********************************************************************************************
165
166 //**Constructor*********************************************************************************
171 explicit inline DVecTransExpr( const VT& dv ) noexcept
172 : dv_( dv ) // Dense vector of the transposition expression
173 {}
174 //**********************************************************************************************
175
176 //**Subscript operator**************************************************************************
182 inline ReturnType operator[]( size_t index ) const {
183 BLAZE_INTERNAL_ASSERT( index < dv_.size(), "Invalid vector access index" );
184 return dv_[index];
185 }
186 //**********************************************************************************************
187
188 //**At function*********************************************************************************
195 inline ReturnType at( size_t index ) const {
196 if( index >= dv_.size() ) {
197 BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
198 }
199 return (*this)[index];
200 }
201 //**********************************************************************************************
202
203 //**Load function*******************************************************************************
209 BLAZE_ALWAYS_INLINE auto load( size_t index ) const noexcept {
210 BLAZE_INTERNAL_ASSERT( index < dv_.size() , "Invalid vector access index" );
211 BLAZE_INTERNAL_ASSERT( index % SIMDSIZE == 0UL , "Invalid vector access index" );
212 return dv_.load( index );
213 }
214 //**********************************************************************************************
215
216 //**Low-level data access***********************************************************************
221 inline const ElementType* data() const noexcept {
222 return dv_.data();
223 }
224 //**********************************************************************************************
225
226 //**Begin function******************************************************************************
231 inline ConstIterator begin() const {
232 return ConstIterator( dv_.begin() );
233 }
234 //**********************************************************************************************
235
236 //**End function********************************************************************************
241 inline ConstIterator end() const {
242 return ConstIterator( dv_.end() );
243 }
244 //**********************************************************************************************
245
246 //**Size function*******************************************************************************
251 inline size_t size() const noexcept {
252 return dv_.size();
253 }
254 //**********************************************************************************************
255
256 //**Operand access******************************************************************************
261 inline Operand operand() const noexcept {
262 return dv_;
263 }
264 //**********************************************************************************************
265
266 //**********************************************************************************************
272 template< typename T >
273 inline bool canAlias( const T* alias ) const noexcept {
274 return dv_.canAlias( alias );
275 }
276 //**********************************************************************************************
277
278 //**********************************************************************************************
284 template< typename T >
285 inline bool isAliased( const T* alias ) const noexcept {
286 return dv_.isAliased( alias );
287 }
288 //**********************************************************************************************
289
290 //**********************************************************************************************
295 inline bool isAligned() const noexcept {
296 return dv_.isAligned();
297 }
298 //**********************************************************************************************
299
300 //**********************************************************************************************
305 inline bool canSMPAssign() const noexcept {
306 return dv_.canSMPAssign();
307 }
308 //**********************************************************************************************
309
310 private:
311 //**Member variables****************************************************************************
313 //**********************************************************************************************
314
315 //**Assignment to dense vectors*****************************************************************
329 template< typename VT2 > // Type of the target dense vector
330 friend inline auto assign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
332 {
334
335 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
336
337 DVecTransposer<VT2,!TF> tmp( *lhs );
338 assign( tmp, rhs.dv_ );
339 }
341 //**********************************************************************************************
342
343 //**Assignment to sparse vectors****************************************************************
357 template< typename VT2 > // Type of the target sparse vector
358 friend inline auto assign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
360 {
362
363 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
364
365 SVecTransposer<VT2,!TF> tmp( *lhs );
366 assign( tmp, rhs.dv_ );
367 }
369 //**********************************************************************************************
370
371 //**Addition assignment to dense vectors********************************************************
385 template< typename VT2 > // Type of the target dense vector
386 friend inline auto addAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
387 -> EnableIf_t< UseAssign_v<VT2> >
388 {
390
391 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
392
393 DVecTransposer<VT2,!TF> tmp( *lhs );
394 addAssign( tmp, rhs.dv_ );
395 }
397 //**********************************************************************************************
398
399 //**Addition assignment to sparse vectors*******************************************************
400 // No special implementation for the addition assignment to sparse vectors.
401 //**********************************************************************************************
402
403 //**Subtraction assignment to dense vectors*****************************************************
417 template< typename VT2 > // Type of the target dense vector
418 friend inline auto subAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
419 -> EnableIf_t< UseAssign_v<VT2> >
420 {
422
423 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
424
425 DVecTransposer<VT2,!TF> tmp( *lhs );
426 subAssign( tmp, rhs.dv_ );
427 }
429 //**********************************************************************************************
430
431 //**Subtraction assignment to sparse vectors****************************************************
432 // No special implementation for the subtraction assignment to sparse vectors.
433 //**********************************************************************************************
434
435 //**Multiplication assignment to dense vectors**************************************************
449 template< typename VT2 > // Type of the target dense vector
450 friend inline auto multAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
451 -> EnableIf_t< UseAssign_v<VT2> >
452 {
454
455 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
456
457 DVecTransposer<VT2,!TF> tmp( *lhs );
458 multAssign( tmp, rhs.dv_ );
459 }
461 //**********************************************************************************************
462
463 //**Multiplication assignment to sparse vectors*************************************************
464 // No special implementation for the multiplication assignment to sparse vectors.
465 //**********************************************************************************************
466
467 //**Division assignment to dense vectors********************************************************
481 template< typename VT2 > // Type of the target dense vector
482 friend inline auto divAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
483 -> EnableIf_t< UseAssign_v<VT2> >
484 {
486
487 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
488
489 DVecTransposer<VT2,!TF> tmp( *lhs );
490 divAssign( tmp, rhs.dv_ );
491 }
493 //**********************************************************************************************
494
495 //**Division assignment to sparse vectors*******************************************************
496 // No special implementation for the division assignment to sparse vectors.
497 //**********************************************************************************************
498
499 //**SMP assignment to dense vectors*************************************************************
513 template< typename VT2 > // Type of the target dense vector
514 friend inline auto smpAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
515 -> EnableIf_t< UseSMPAssign_v<VT2> >
516 {
518
519 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
520
521 DVecTransposer<VT2,!TF> tmp( *lhs );
522 smpAssign( tmp, rhs.dv_ );
523 }
525 //**********************************************************************************************
526
527 //**SMP assignment to sparse vectors************************************************************
541 template< typename VT2 > // Type of the target sparse vector
542 friend inline auto smpAssign( SparseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
543 -> EnableIf_t< UseSMPAssign_v<VT2> >
544 {
546
547 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
548
549 SVecTransposer<VT2,!TF> tmp( *lhs );
550 smpAssign( tmp, rhs.dv_ );
551 }
553 //**********************************************************************************************
554
555 //**SMP addition assignment to dense vectors****************************************************
569 template< typename VT2 > // Type of the target dense vector
570 friend inline auto smpAddAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
571 -> EnableIf_t< UseSMPAssign_v<VT2> >
572 {
574
575 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
576
577 DVecTransposer<VT2,!TF> tmp( *lhs );
578 smpAddAssign( tmp, rhs.dv_ );
579 }
581 //**********************************************************************************************
582
583 //**SMP addition assignment to sparse vectors***************************************************
584 // No special implementation for the SMP addition assignment to sparse vectors.
585 //**********************************************************************************************
586
587 //**SMP subtraction assignment to dense vectors*************************************************
601 template< typename VT2 > // Type of the target dense vector
602 friend inline auto smpSubAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& 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 smpSubAssign( tmp, rhs.dv_ );
611 }
613 //**********************************************************************************************
614
615 //**SMP subtraction assignment to sparse vectors************************************************
616 // No special implementation for the SMP subtraction assignment to sparse vectors.
617 //**********************************************************************************************
618
619 //**SMP multiplication assignment to dense vectors**********************************************
633 template< typename VT2 > // Type of the target dense vector
634 friend inline auto smpMultAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
635 -> EnableIf_t< UseSMPAssign_v<VT2> >
636 {
638
639 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
640
641 DVecTransposer<VT2,!TF> tmp( *lhs );
642 smpMultAssign( tmp, rhs.dv_ );
643 }
645 //**********************************************************************************************
646
647 //**SMP multiplication assignment to sparse vectors*********************************************
648 // No special implementation for the SMP multiplication assignment to sparse vectors.
649 //**********************************************************************************************
650
651 //**SMP division assignment to dense vectors****************************************************
665 template< typename VT2 > // Type of the target dense vector
666 friend inline auto smpDivAssign( DenseVector<VT2,TF>& lhs, const DVecTransExpr& rhs )
667 -> EnableIf_t< UseSMPAssign_v<VT2> >
668 {
670
671 BLAZE_INTERNAL_ASSERT( (*lhs).size() == rhs.size(), "Invalid vector sizes" );
672
673 DVecTransposer<VT2,!TF> tmp( *lhs );
674 smpDivAssign( tmp, rhs.dv_ );
675 }
677 //**********************************************************************************************
678
679 //**SMP division assignment to sparse vectors***************************************************
680 // No special implementation for the SMP division assignment to sparse vectors.
681 //**********************************************************************************************
682
683 //**Compile time checks*************************************************************************
688 //**********************************************************************************************
689};
690//*************************************************************************************************
691
692
693
694
695//=================================================================================================
696//
697// GLOBAL OPERATORS
698//
699//=================================================================================================
700
701//*************************************************************************************************
720template< typename VT // Type of the dense vector
721 , bool TF > // Transpose flag
722inline decltype(auto) trans( const DenseVector<VT,TF>& dv )
723{
725
726 using ReturnType = const DVecTransExpr<VT,!TF>;
727 return ReturnType( *dv );
728}
729//*************************************************************************************************
730
731
732//*************************************************************************************************
740template< typename VT // Type of the dense vector
741 , bool TF > // Transpose flag
742inline decltype(auto) transTo_backend( const DenseVector<VT,TF>& dv, FalseType )
743{
744 return trans( *dv );
745}
747//*************************************************************************************************
748
749
750//*************************************************************************************************
758template< typename VT // Type of the dense vector
759 , bool TF > // Transpose flag
760inline const VT& transTo_backend( const DenseVector<VT,TF>& dv, TrueType )
761{
762 return *dv;
763}
765//*************************************************************************************************
766
767
768//*************************************************************************************************
780template< bool TTF // Target transpose flag
781 , typename VT // Type of the dense vector
782 , bool TF > // Current transpose flag of the dense vector
783inline decltype(auto) transTo( const DenseVector<VT,TF>& dv )
784{
785 return transTo_backend( *dv, BoolConstant<TTF == TF>() );
786}
787//*************************************************************************************************
788
789
790
791
792//=================================================================================================
793//
794// ISALIGNED SPECIALIZATIONS
795//
796//=================================================================================================
797
798//*************************************************************************************************
800template< typename VT, bool TF >
801struct HasConstDataAccess< DVecTransExpr<VT,TF> >
802 : public HasConstDataAccess<VT>
803{};
805//*************************************************************************************************
806
807
808
809
810//=================================================================================================
811//
812// ISALIGNED SPECIALIZATIONS
813//
814//=================================================================================================
815
816//*************************************************************************************************
818template< typename VT, bool TF >
819struct IsAligned< DVecTransExpr<VT,TF> >
820 : public IsAligned<VT>
821{};
823//*************************************************************************************************
824
825
826
827
828//=================================================================================================
829//
830// ISPADDED SPECIALIZATIONS
831//
832//=================================================================================================
833
834//*************************************************************************************************
836template< typename VT, bool TF >
837struct IsPadded< DVecTransExpr<VT,TF> >
838 : public IsPadded<VT>
839{};
841//*************************************************************************************************
842
843} // namespace blaze
844
845#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 HasConstDataAccess 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 IsAligned type trait.
Header file for the IsComputation type trait class.
Header file for the IsExpression type trait class.
Header file for the IsPadded type trait.
Deactivation of problematic macros.
Header file for all SIMD functionality.
Header file for the sparse vector transposer.
Expression object for dense vector transpositions.
Definition: DVecTransExpr.h:93
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DVecTransExpr.h:285
const ElementType * data() const noexcept
Low-level data access to the vector elements.
Definition: DVecTransExpr.h:221
ReturnType_t< VT > ReturnType
Return type for expression template evaluations.
Definition: DVecTransExpr.h:141
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DVecTransExpr.h:305
Operand dv_
Dense vector of the transposition expression.
Definition: DVecTransExpr.h:312
static constexpr bool simdEnabled
Compilation switch for the expression template evaluation strategy.
Definition: DVecTransExpr.h:155
static constexpr size_t SIMDSIZE
The number of elements packed within a single SIMD element.
Definition: DVecTransExpr.h:163
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DVecTransExpr.h:273
ResultType_t< VT > TransposeType
Transpose type for expression template evaluations.
Definition: DVecTransExpr.h:139
DVecTransExpr(const VT &dv) noexcept
Constructor for the DVecTransExpr class.
Definition: DVecTransExpr.h:171
ElementType_t< VT > ElementType
Resulting element type.
Definition: DVecTransExpr.h:140
TransposeType_t< VT > ResultType
Result type for expression template evaluations.
Definition: DVecTransExpr.h:138
Operand operand() const noexcept
Returns the dense vector operand.
Definition: DVecTransExpr.h:261
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: DVecTransExpr.h:251
If_t< useAssign, const ResultType, const DVecTransExpr & > CompositeType
Data type for composite expression templates.
Definition: DVecTransExpr.h:144
If_t< IsExpression_v< VT >, const VT, const VT & > Operand
Composite data type of the dense vector expression.
Definition: DVecTransExpr.h:150
BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT(GetConstIterator, ConstIterator, INVALID_TYPE)
Definition of the GetConstIterator type trait.
GetConstIterator_t< VT > ConstIterator
Iterator over the elements of the dense vector.
Definition: DVecTransExpr.h:147
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the transposition expression.
Definition: DVecTransExpr.h:108
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition: DVecTransExpr.h:158
BLAZE_ALWAYS_INLINE auto load(size_t index) const noexcept
Access to the SIMD elements of the vector.
Definition: DVecTransExpr.h:209
ConstIterator end() const
Returns an iterator just past the last non-zero element of the dense vector.
Definition: DVecTransExpr.h:241
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: DVecTransExpr.h:195
ConstIterator begin() const
Returns an iterator to the first non-zero element of the dense vector.
Definition: DVecTransExpr.h:231
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecTransExpr.h:182
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DVecTransExpr.h:295
Expression object for the transposition of a dense vector.
Definition: DVecTransposer.h:81
VT & dv_
The dense vector operand.
Definition: DVecTransposer.h:556
Base class for N-dimensional dense vectors.
Definition: DenseVector.h:77
SIMD characteristics of data types.
Definition: SIMDTrait.h:297
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.
Header file for the Computation base class.
Header file for the DenseVector base class.
Header file for the Transformation base class.
Header file for the VecTransExpr base class.
decltype(auto) trans(const DenseVector< VT, TF > &dv)
Calculation of the transpose of the given dense vector.
Definition: DVecTransExpr.h:722
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_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF)
Constraint on the data type.
Definition: TransposeFlag.h:63
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.
Definition: DenseVector.h:61
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
auto smpDivAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > >
Default implementation of the SMP division assignment of a vector to a dense vector.
Definition: DenseVector.h:221
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
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
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.
Constraint on the data type.
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
System settings for the inline keywords.
Header file for the RequiresEvaluation type trait.
Header file for basic type definitions.