Blaze 3.9
Loading...
Searching...
No Matches
SMatTransExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_SMATTRANSEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_SMATTRANSEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Aliases.h>
58#include <blaze/util/Assert.h>
59#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 SMATTRANSEXPR
72//
73//=================================================================================================
74
75//*************************************************************************************************
82template< typename MT // Type of the sparse matrix
83 , bool SO > // Storage order
85 : public MatTransExpr< SparseMatrix< SMatTransExpr<MT,SO>, SO > >
86 , private If_t< IsComputation_v<MT>, 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<MT>;
103
106 template< typename MT2 >
107 static constexpr bool UseAssign_v = useAssign;
109 //**********************************************************************************************
110
111 //**Parallel evaluation strategy****************************************************************
114
119 template< typename MT2 >
120 static constexpr bool UseSMPAssign_v = ( MT2::smpAssignable && useAssign );
122 //**********************************************************************************************
123
124 public:
125 //**Type definitions****************************************************************************
128
131
137
140
142 using ConstIterator = GetConstIterator_t<MT>;
143
145 using Operand = If_t< IsExpression_v<MT>, const MT, const MT& >;
146 //**********************************************************************************************
147
148 //**Compilation flags***************************************************************************
150 static constexpr bool smpAssignable = MT::smpAssignable;
151 //**********************************************************************************************
152
153 //**Constructor*********************************************************************************
158 explicit inline SMatTransExpr( const MT& sm ) noexcept
159 : sm_( sm )
160 {}
161 //**********************************************************************************************
162
163 //**Access operator*****************************************************************************
170 inline ReturnType operator()( size_t i, size_t j ) const {
171 BLAZE_INTERNAL_ASSERT( i < sm_.columns(), "Invalid row access index" );
172 BLAZE_INTERNAL_ASSERT( j < sm_.rows() , "Invalid column access index" );
173 return sm_(j,i);
174 }
175 //**********************************************************************************************
176
177 //**At function*********************************************************************************
185 inline ReturnType at( size_t i, size_t j ) const {
186 if( i >= sm_.columns() ) {
187 BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
188 }
189 if( j >= sm_.rows() ) {
190 BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
191 }
192 return (*this)(i,j);
193 }
194 //**********************************************************************************************
195
196 //**Begin function******************************************************************************
202 inline ConstIterator begin( size_t i ) const {
203 return sm_.begin(i);
204 }
205 //**********************************************************************************************
206
207 //**End function********************************************************************************
213 inline ConstIterator end( size_t i ) const {
214 return sm_.end(i);
215 }
216 //**********************************************************************************************
217
218 //**Rows function*******************************************************************************
223 inline size_t rows() const noexcept {
224 return sm_.columns();
225 }
226 //**********************************************************************************************
227
228 //**Columns function****************************************************************************
233 inline size_t columns() const noexcept {
234 return sm_.rows();
235 }
236 //**********************************************************************************************
237
238 //**NonZeros function***************************************************************************
243 inline size_t nonZeros() const {
244 return sm_.nonZeros();
245 }
246 //**********************************************************************************************
247
248 //**NonZeros function***************************************************************************
254 inline size_t nonZeros( size_t i ) const {
255 return sm_.nonZeros( i );
256 }
257 //**********************************************************************************************
258
259 //**Find function*******************************************************************************
266 inline ConstIterator find( size_t i, size_t j ) const {
268 return sm_.find( j, i );
269 }
270 //**********************************************************************************************
271
272 //**LowerBound function*************************************************************************
279 inline ConstIterator lowerBound( size_t i, size_t j ) const {
281 return sm_.lowerBound( j, i );
282 }
283 //**********************************************************************************************
284
285 //**UpperBound function*************************************************************************
292 inline ConstIterator upperBound( size_t i, size_t j ) const {
294 return sm_.upperBound( j, i );
295 }
296 //**********************************************************************************************
297
298 //**Operand access******************************************************************************
303 inline Operand operand() const noexcept {
304 return sm_;
305 }
306 //**********************************************************************************************
307
308 //**********************************************************************************************
314 template< typename T >
315 inline bool canAlias( const T* alias ) const noexcept {
316 return sm_.isAliased( alias );
317 }
318 //**********************************************************************************************
319
320 //**********************************************************************************************
326 template< typename T >
327 inline bool isAliased( const T* alias ) const noexcept {
328 return sm_.isAliased( alias );
329 }
330 //**********************************************************************************************
331
332 //**********************************************************************************************
337 inline bool canSMPAssign() const noexcept {
338 return sm_.canSMPAssign();
339 }
340 //**********************************************************************************************
341
342 private:
343 //**Member variables****************************************************************************
345 //**********************************************************************************************
346
347 //**Assignment to dense matrices****************************************************************
361 template< typename MT2 // Type of the target dense matrix
362 , bool SO2 > // Storage order of the target dense matrix
363 friend inline auto assign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
365 {
367
368 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
369 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
370
371 DMatTransposer<MT2,!SO2> tmp( *lhs );
372 assign( tmp, rhs.sm_ );
373 }
375 //**********************************************************************************************
376
377 //**Assignment to sparse matrices***************************************************************
391 template< typename MT2 // Type of the target sparse matrix
392 , bool SO2 > // Storage order of the target sparse matrix
393 friend inline auto assign( SparseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
395 {
397
398 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
399 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
400
401 SMatTransposer<MT2,!SO2> tmp( *lhs );
402 assign( tmp, rhs.sm_ );
403 }
405 //**********************************************************************************************
406
407 //**Addition assignment to dense matrices*******************************************************
421 template< typename MT2 // Type of the target dense matrix
422 , bool SO2 > // Storage order of the target dense matrix
423 friend inline auto addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
425 {
427
428 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
429 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
430
431 DMatTransposer<MT2,!SO2> tmp( *lhs );
432 addAssign( tmp, rhs.sm_ );
433 }
435 //**********************************************************************************************
436
437 //**Addition assignment to sparse matrices******************************************************
438 // No special implementation for the addition assignment to sparse matrices.
439 //**********************************************************************************************
440
441 //**Subtraction assignment to dense matrices****************************************************
455 template< typename MT2 // Type of the target dense matrix
456 , bool SO2 > // Storage order of the target dense matrix
457 friend inline auto subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
459 {
461
462 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
463 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
464
465 DMatTransposer<MT2,!SO2> tmp( *lhs );
466 subAssign( tmp, rhs.sm_ );
467 }
469 //**********************************************************************************************
470
471 //**Subtraction assignment to sparse matrices***************************************************
472 // No special implementation for the subtraction assignment to sparse matrices.
473 //**********************************************************************************************
474
475 //**Schur product assignment to dense matrices**************************************************
489 template< typename MT2 // Type of the target dense matrix
490 , bool SO2 > // Storage order of the target dense matrix
491 friend inline auto schurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
493 {
495
496 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
497 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
498
499 DMatTransposer<MT2,!SO2> tmp( *lhs );
500 schurAssign( tmp, rhs.sm_ );
501 }
503 //**********************************************************************************************
504
505 //**Schur product assignment to sparse matrices*************************************************
506 // No special implementation for the Schur product assignment to sparse matrices.
507 //**********************************************************************************************
508
509 //**Multiplication assignment to dense matrices*************************************************
510 // No special implementation for the multiplication assignment to dense matrices.
511 //**********************************************************************************************
512
513 //**Multiplication assignment to sparse matrices************************************************
514 // No special implementation for the multiplication assignment to sparse matrices.
515 //**********************************************************************************************
516
517 //**SMP assignment to dense matrices************************************************************
531 template< typename MT2 // Type of the target dense matrix
532 , bool SO2 > // Storage order of the target dense matrix
533 friend inline auto smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
535 {
537
538 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
539 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
540
541 DMatTransposer<MT2,!SO2> tmp( *lhs );
542 smpAssign( tmp, rhs.sm_ );
543 }
545 //**********************************************************************************************
546
547 //**SMP assignment to sparse matrices***********************************************************
561 template< typename MT2 // Type of the target sparse matrix
562 , bool SO2 > // Storage order of the target sparse matrix
563 friend inline auto smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
565 {
567
568 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
569 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
570
571 SMatTransposer<MT2,!SO2> tmp( *lhs );
572 smpAssign( tmp, rhs.sm_ );
573 }
575 //**********************************************************************************************
576
577 //**SMP addition assignment to dense matrices***************************************************
591 template< typename MT2 // Type of the target dense matrix
592 , bool SO2 > // Storage order of the target dense matrix
593 friend inline auto smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
595 {
597
598 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
599 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
600
601 DMatTransposer<MT2,!SO2> tmp( *lhs );
602 smpAddAssign( tmp, rhs.sm_ );
603 }
605 //**********************************************************************************************
606
607 //**SMP addition assignment to sparse matrices**************************************************
608 // No special implementation for the SMP addition assignment to sparse matrices.
609 //**********************************************************************************************
610
611 //**SMP subtraction assignment to dense matrices************************************************
626 template< typename MT2 // Type of the target dense matrix
627 , bool SO2 > // Storage order of the target dense matrix
628 friend inline auto smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
630 {
632
633 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
634 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
635
636 DMatTransposer<MT2,!SO2> tmp( *lhs );
637 smpSubAssign( tmp, rhs.sm_ );
638 }
640 //**********************************************************************************************
641
642 //**SMP subtraction assignment to sparse matrices***********************************************
643 // No special implementation for the SMP subtraction assignment to sparse matrices.
644 //**********************************************************************************************
645
646 //**SMP Schur product assignment to dense matrices**********************************************
661 template< typename MT2 // Type of the target dense matrix
662 , bool SO2 > // Storage order of the target dense matrix
663 friend inline auto smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatTransExpr& rhs )
665 {
667
668 BLAZE_INTERNAL_ASSERT( (*lhs).rows() == rhs.rows() , "Invalid number of rows" );
669 BLAZE_INTERNAL_ASSERT( (*lhs).columns() == rhs.columns(), "Invalid number of columns" );
670
671 DMatTransposer<MT2,!SO2> tmp( *lhs );
672 smpSchurAssign( tmp, rhs.sm_ );
673 }
675 //**********************************************************************************************
676
677 //**SMP Schur product assignment to sparse matrices*********************************************
678 // No special implementation for the SMP Schur product assignment to sparse matrices.
679 //**********************************************************************************************
680
681 //**SMP multiplication assignment to dense matrices*********************************************
682 // No special implementation for the SMP multiplication assignment to dense matrices.
683 //**********************************************************************************************
684
685 //**SMP multiplication assignment to sparse matrices********************************************
686 // No special implementation for the SMP multiplication assignment to sparse matrices.
687 //**********************************************************************************************
688
689 //**Compile time checks*************************************************************************
694 //**********************************************************************************************
695};
696//*************************************************************************************************
697
698
699
700
701//=================================================================================================
702//
703// GLOBAL OPERATORS
704//
705//=================================================================================================
706
707//*************************************************************************************************
726template< typename MT // Type of the sparse matrix
727 , bool SO > // Storage order
728inline decltype(auto) trans( const SparseMatrix<MT,SO>& sm )
729{
731
732 using ReturnType = const SMatTransExpr<MT,!SO>;
733 return ReturnType( *sm );
734}
735//*************************************************************************************************
736
737
738//*************************************************************************************************
749template< typename MT // Type of the sparse matrix
750 , bool SO > // Storage order
751inline decltype(auto) transIf( FalseType, const SparseMatrix<MT,SO>& sm )
752{
753 return *sm;
754}
756//*************************************************************************************************
757
758
759//*************************************************************************************************
770template< typename MT // Type of the sparse matrix
771 , bool SO > // Storage order
772inline decltype(auto) transIf( TrueType, const SparseMatrix<MT,SO>& sm )
773{
774 return trans( *sm );
775}
777//*************************************************************************************************
778
779
780//*************************************************************************************************
791template< bool B // Compile time condition
792 , typename MT // Type of the sparse matrix
793 , bool SO > // Storage order
794inline decltype(auto) transIf( const SparseMatrix<MT,SO>& sm )
795{
796 return transIf( BoolConstant<B>(), *sm );
797}
798//*************************************************************************************************
799
800} // namespace blaze
801
802#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::OppositeType OppositeType_t
Alias declaration for nested OppositeType type definitions.
Definition Aliases.h:310
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.
Definition Aliases.h:550
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.
Definition Aliases.h:190
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.
Definition Aliases.h:450
Header file for run time assertion macros.
Header file for the dense matrix 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.
Utility type for generic codes.
Header file for the IsComputation type trait class.
Header file for the IsExpression type trait class.
Header file for the sparse matrix transposer.
Expression object for the transposition of a dense matrix.
Definition DMatTransposer.h:79
Base class for dense matrices.
Definition DenseMatrix.h:82
Expression object for sparse matrix transpositions.
Definition SMatTransExpr.h:87
SMatTransExpr(const MT &sm) noexcept
Constructor for the SMatTransExpr class.
Definition SMatTransExpr.h:158
ElementType_t< MT > ElementType
Resulting element type.
Definition SMatTransExpr.h:135
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition SMatTransExpr.h:233
ReturnType_t< MT > ReturnType
Return type for expression template evaluations.
Definition SMatTransExpr.h:136
static constexpr bool useAssign
Compilation switch for the serial evaluation strategy of the transposition expression.
Definition SMatTransExpr.h:102
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition SMatTransExpr.h:170
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition SMatTransExpr.h:303
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition SMatTransExpr.h:243
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition SMatTransExpr.h:213
ResultType_t< MT > TransposeType
Transpose type for expression template evaluations.
Definition SMatTransExpr.h:134
static constexpr bool smpAssignable
Compilation switch for the expression template assignment strategy.
Definition SMatTransExpr.h:150
GetConstIterator_t< MT > ConstIterator
Iterator over the elements of the sparse matrix.
Definition SMatTransExpr.h:142
If_t< IsExpression_v< MT >, const MT, const MT & > Operand
Composite data type of the sparse matrix expression.
Definition SMatTransExpr.h:145
TransposeType_t< MT > ResultType
Result type for expression template evaluations.
Definition SMatTransExpr.h:132
ConstIterator upperBound(size_t i, size_t j) const
Returns an iterator to the first index greater then the given index.
Definition SMatTransExpr.h:292
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row/column.
Definition SMatTransExpr.h:254
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition SMatTransExpr.h:327
SMatTransExpr< MT, SO > This
Type of this SMatTransExpr instance.
Definition SMatTransExpr.h:127
Operand sm_
Sparse matrix of the transposition expression.
Definition SMatTransExpr.h:344
BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT(GetConstIterator, ConstIterator, INVALID_TYPE)
Definition of the GetConstIterator type trait.
OppositeType_t< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition SMatTransExpr.h:133
ConstIterator find(size_t i, size_t j) const
Searches for a specific matrix element.
Definition SMatTransExpr.h:266
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition SMatTransExpr.h:315
If_t< useAssign, const ResultType, const SMatTransExpr & > CompositeType
Data type for composite expression templates.
Definition SMatTransExpr.h:139
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition SMatTransExpr.h:185
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition SMatTransExpr.h:337
MatTransExpr< SparseMatrix< This, SO > > BaseType
Base type of this SMatTransExpr instance.
Definition SMatTransExpr.h:130
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition SMatTransExpr.h:202
ConstIterator lowerBound(size_t i, size_t j) const
Returns an iterator to the first index not less then the given index.
Definition SMatTransExpr.h:279
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition SMatTransExpr.h:223
Expression object for the transposition of a sparse matrix.
Definition SMatTransposer.h:72
Base class for sparse matrices.
Definition SparseMatrix.h:77
Constraint on the data type.
Constraint on the data type.
Header file for the Computation base class.
Header file for the MatTransExpr base class.
Header file for the SparseMatrix base class.
Header file for the Transformation base class.
decltype(auto) transIf(const DenseMatrix< MT, SO > &dm)
Conditional calculation of the transpose of the given dense matrix.
Definition DMatTransExpr.h:832
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition DMatTransExpr.h:766
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.
Definition RequiresEvaluation.h:81
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.
Definition SparseMatrix.h:61
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.
Definition StorageOrder.h:63
constexpr bool RequiresEvaluation_v
Auxiliary variable template for the RequiresEvaluation type trait.
Definition RequiresEvaluation.h:91
#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 smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > >
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition DenseMatrix.h:194
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< 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
BoolConstant< true > TrueType
Type traits base class.
Definition IntegralConstant.h:132
#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
typename If< Condition >::template Type< T1, T2 > If_t
Auxiliary alias template for the If class template.
Definition If.h:108
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.
Definition IntegralConstant.h:110
Header file for the exception macros of the math module.
Constraints on the storage order of matrix types.
Header file for all forward declarations for expression class templates.
Base class for all matrix transposition expression templates.
Definition MatTransExpr.h:69
Header file for the RequiresEvaluation type trait.
Header file for basic type definitions.