35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTRANSPOSER_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTRANSPOSER_H_
105 enum :
bool { simdEnabled = MT::simdEnabled };
111 enum :
bool { smpAssignable = MT::smpAssignable };
145 inline ConstReference
operator()(
size_t i,
size_t j )
const {
160 inline Reference
at(
size_t i,
size_t j ) {
161 if( i >=
dm_.columns() ) {
164 if( j >=
dm_.rows() ) {
179 inline ConstReference
at(
size_t i,
size_t j )
const {
180 if( i >=
dm_.columns() ) {
183 if( j >=
dm_.rows() ) {
195 inline Pointer
data() noexcept {
205 inline ConstPointer
data() const noexcept {
222 return dm_.begin( i );
237 inline ConstIterator
begin(
size_t i )
const {
238 return dm_.cbegin( i );
253 inline ConstIterator
cbegin(
size_t i )
const {
254 return dm_.cbegin( i );
269 inline Iterator
end(
size_t i ) {
285 inline ConstIterator
end(
size_t i )
const {
286 return dm_.cend( i );
301 inline ConstIterator
cend(
size_t i )
const {
302 return dm_.cend( i );
313 template<
typename Other >
330 template<
typename Other >
345 inline size_t rows() const noexcept {
346 return dm_.columns();
366 return dm_.spacing();
397 template<
typename Other >
398 inline bool canAlias(
const Other* alias )
const noexcept
400 return dm_.canAlias( alias );
410 template<
typename Other >
411 inline bool isAliased(
const Other* alias )
const noexcept
413 return dm_.isAliased( alias );
424 return dm_.isAligned();
435 return dm_.canSMPAssign();
452 return dm_.load( j, i );
469 return dm_.loada( j, i );
486 return dm_.loadu( j, i );
504 dm_.store( j, i, value );
522 dm_.storea( j, i, value );
540 dm_.storeu( j, i, value );
558 dm_.stream( j, i, value );
573 template<
typename MT2 >
581 const size_t m(
rows() );
584 const size_t jpos( n &
size_t(-2) );
587 for(
size_t i=0UL; i<m; ++i ) {
588 for(
size_t j=0UL; j<jpos; j+=2UL ) {
589 dm_(j ,i) = (~rhs)(i,j );
590 dm_(j+1UL,i) = (~rhs)(i,j+1UL);
593 dm_(jpos,i) = (~rhs)(i,jpos);
610 template<
typename MT2 >
618 const size_t m(
rows() );
620 const size_t block( BLOCK_SIZE );
622 for(
size_t ii=0UL; ii<m; ii+=block ) {
623 const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
624 for(
size_t jj=0UL; jj<n; jj+=block ) {
625 const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
626 for(
size_t i=ii; i<iend; ++i ) {
627 for(
size_t j=jj; j<jend; ++j ) {
628 dm_(j,i) = (~rhs)(i,j);
647 template<
typename MT2 >
657 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
658 for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).
end(i); ++element )
659 dm_(element->index(),i) = element->value();
674 template<
typename MT2 >
684 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
685 for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).
end(j); ++element )
686 dm_(j,element->index()) = element->value();
701 template<
typename MT2 >
709 const size_t m(
rows() );
712 const size_t jpos( n &
size_t(-2) );
715 for(
size_t i=0UL; i<m; ++i ) {
716 for(
size_t j=0UL; j<jpos; j+=2UL ) {
717 dm_(j ,i) += (~rhs)(i,j );
718 dm_(j+1UL,i) += (~rhs)(i,j+1UL);
722 dm_(jpos,i) += (~rhs)(i,jpos);
739 template<
typename MT2 >
747 const size_t m(
rows() );
749 const size_t block( BLOCK_SIZE );
751 for(
size_t ii=0UL; ii<m; ii+=block ) {
752 const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
753 for(
size_t jj=0UL; jj<n; jj+=block ) {
754 const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
755 for(
size_t i=ii; i<iend; ++i ) {
756 for(
size_t j=jj; j<jend; ++j ) {
757 dm_(j,i) += (~rhs)(i,j);
776 template<
typename MT2 >
786 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
787 for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).
end(i); ++element )
788 dm_(element->index(),i) += element->value();
803 template<
typename MT2 >
813 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
814 for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).
end(j); ++element )
815 dm_(j,element->index()) += element->value();
830 template<
typename MT2 >
838 const size_t m(
rows() );
841 const size_t jpos( n &
size_t(-2) );
844 for(
size_t i=0UL; i<m; ++i ) {
845 for(
size_t j=0UL; j<jpos; j+=2UL ) {
846 dm_(j ,i) -= (~rhs)(i,j );
847 dm_(j+1UL,i) -= (~rhs)(i,j+1UL);
851 dm_(jpos,i) -= (~rhs)(i,jpos);
868 template<
typename MT2 >
876 const size_t m(
rows() );
878 const size_t block( BLOCK_SIZE );
880 for(
size_t ii=0UL; ii<m; ii+=block ) {
881 const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
882 for(
size_t jj=0UL; jj<n; jj+=block ) {
883 const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
884 for(
size_t i=ii; i<iend; ++i ) {
885 for(
size_t j=jj; j<jend; ++j ) {
886 dm_(j,i) -= (~rhs)(i,j);
905 template<
typename MT2 >
915 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
916 for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).
end(i); ++element )
917 dm_(element->index(),i) -= element->value();
932 template<
typename MT2 >
942 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
943 for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).
end(j); ++element )
944 dm_(j,element->index()) -= element->value();
988 template<
typename MT >
1014 enum :
bool { simdEnabled = MT::simdEnabled };
1020 enum :
bool { smpAssignable = MT::smpAssignable };
1040 inline Reference
operator()(
size_t i,
size_t j ) {
1054 inline ConstReference
operator()(
size_t i,
size_t j )
const {
1069 inline Reference
at(
size_t i,
size_t j ) {
1070 if( i >=
dm_.columns() ) {
1073 if( j >=
dm_.rows() ) {
1076 return (*
this)(i,j);
1088 inline ConstReference
at(
size_t i,
size_t j )
const {
1089 if( i >=
dm_.columns() ) {
1092 if( j >=
dm_.rows() ) {
1095 return (*
this)(i,j);
1104 inline Pointer
data() noexcept {
1114 inline ConstPointer
data() const noexcept {
1125 inline Iterator
begin(
size_t j ) {
1126 return dm_.begin(j);
1136 inline ConstIterator
begin(
size_t j )
const {
1137 return dm_.cbegin(j);
1147 inline ConstIterator
cbegin(
size_t j )
const {
1148 return dm_.cbegin(j);
1158 inline Iterator
end(
size_t j ) {
1169 inline ConstIterator
end(
size_t j )
const {
1180 inline ConstIterator
cend(
size_t j )
const {
1192 template<
typename Other >
1209 template<
typename Other >
1224 inline size_t rows() const noexcept {
1225 return dm_.columns();
1234 inline size_t columns() const noexcept {
1244 inline size_t spacing() const noexcept {
1245 return dm_.spacing();
1254 inline void reset() {
1264 inline bool isIntact() const noexcept {
1276 template<
typename Other >
1277 inline bool canAlias(
const Other* alias )
const noexcept
1279 return dm_.canAlias( alias );
1289 template<
typename Other >
1290 inline bool isAliased(
const Other* alias )
const noexcept
1292 return dm_.isAliased( alias );
1303 return dm_.isAligned();
1314 return dm_.canSMPAssign();
1331 return dm_.load( j, i );
1348 return dm_.loada( j, i );
1365 return dm_.loadu( j, i );
1383 dm_.store( j, i, value );
1401 dm_.storea( j, i, value );
1419 dm_.storeu( j, i, value );
1437 dm_.stream( j, i, value );
1452 template<
typename MT2 >
1453 inline void assign(
const DenseMatrix<MT2,true>& rhs )
1460 const size_t m(
rows() );
1463 const size_t ipos( m &
size_t(-2) );
1466 for(
size_t j=0UL; j<n; ++j ) {
1467 for(
size_t i=0UL; i<ipos; i+=2UL ) {
1468 dm_(j,i ) = (~rhs)(i ,j);
1469 dm_(j,i+1UL) = (~rhs)(i+1UL,j);
1472 dm_(j,ipos) = (~rhs)(ipos,j);
1489 template<
typename MT2 >
1490 inline void assign(
const DenseMatrix<MT2,false>& rhs )
1497 const size_t m(
rows() );
1499 const size_t block( BLOCK_SIZE );
1501 for(
size_t jj=0UL; jj<n; jj+=block ) {
1502 const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
1503 for(
size_t ii=0UL; ii<m; ii+=block ) {
1504 const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
1505 for(
size_t j=jj; j<jend; ++j ) {
1506 for(
size_t i=ii; i<iend; ++i ) {
1507 dm_(j,i) = (~rhs)(i,j);
1526 template<
typename MT2 >
1527 inline void assign(
const SparseMatrix<MT2,true>& rhs )
1534 typedef ConstIterator_<MT2> RhsConstIterator;
1536 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
1537 for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).
end(j); ++element )
1538 dm_(j,element->index()) = element->value();
1553 template<
typename MT2 >
1554 inline void assign(
const SparseMatrix<MT2,false>& rhs )
1561 typedef ConstIterator_<MT2> RhsConstIterator;
1563 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
1564 for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).
end(i); ++element )
1565 dm_(element->index(),i) = element->value();
1580 template<
typename MT2 >
1581 inline void addAssign(
const DenseMatrix<MT2,true>& rhs )
1588 const size_t m(
rows() );
1591 const size_t ipos( m &
size_t(-2) );
1594 for(
size_t j=0UL; j<n; ++j ) {
1595 for(
size_t i=0UL; i<ipos; i+=2UL ) {
1596 dm_(j,i ) += (~rhs)(i ,j);
1597 dm_(j,i+1UL) += (~rhs)(i+1UL,j);
1600 dm_(j,ipos) += (~rhs)(ipos,j);
1617 template<
typename MT2 >
1618 inline void addAssign(
const DenseMatrix<MT2,false>& rhs )
1625 const size_t m(
rows() );
1627 const size_t block( BLOCK_SIZE );
1629 for(
size_t jj=0UL; jj<n; jj+=block ) {
1630 const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
1631 for(
size_t ii=0UL; ii<m; ii+=block ) {
1632 const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
1633 for(
size_t j=jj; j<jend; ++j ) {
1634 for(
size_t i=ii; i<iend; ++i ) {
1635 dm_(j,i) += (~rhs)(i,j);
1654 template<
typename MT2 >
1655 inline void addAssign(
const SparseMatrix<MT2,true>& rhs )
1662 typedef ConstIterator_<MT2> RhsConstIterator;
1664 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
1665 for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).
end(j); ++element )
1666 dm_(j,element->index()) += element->value();
1681 template<
typename MT2 >
1682 inline void addAssign(
const SparseMatrix<MT2,false>& rhs )
1689 typedef ConstIterator_<MT2> RhsConstIterator;
1691 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
1692 for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).
end(i); ++element )
1693 dm_(element->index(),i) += element->value();
1708 template<
typename MT2 >
1709 inline void subAssign(
const DenseMatrix<MT2,true>& rhs )
1716 const size_t m(
rows() );
1719 const size_t ipos( m &
size_t(-2) );
1722 for(
size_t j=0UL; j<n; ++j ) {
1723 for(
size_t i=0UL; i<ipos; i+=2UL ) {
1724 dm_(j,i ) -= (~rhs)(i ,j);
1725 dm_(j,i+1UL) -= (~rhs)(i+1UL,j);
1728 dm_(j,ipos) -= (~rhs)(ipos,j);
1745 template<
typename MT2 >
1746 inline void subAssign(
const DenseMatrix<MT2,false>& rhs )
1753 const size_t m(
rows() );
1755 const size_t block( BLOCK_SIZE );
1757 for(
size_t jj=0UL; jj<n; jj+=block ) {
1758 const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
1759 for(
size_t ii=0UL; ii<m; ii+=block ) {
1760 const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
1761 for(
size_t j=jj; j<jend; ++j ) {
1762 for(
size_t i=ii; i<iend; ++i ) {
1763 dm_(j,i) -= (~rhs)(i,j);
1782 template<
typename MT2 >
1783 inline void subAssign(
const SparseMatrix<MT2,true>& rhs )
1790 typedef ConstIterator_<MT2> RhsConstIterator;
1792 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
1793 for( RhsConstIterator element=(~rhs).begin(j); element!=(~rhs).
end(j); ++element )
1794 dm_(j,element->index()) -= element->value();
1809 template<
typename MT2 >
1810 inline void subAssign(
const SparseMatrix<MT2,false>& rhs )
1817 typedef ConstIterator_<MT2> RhsConstIterator;
1819 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
1820 for( RhsConstIterator element=(~rhs).begin(i); element!=(~rhs).
end(i); ++element )
1821 dm_(element->index(),i) -= element->value();
1866 template<
typename MT
1868 inline void reset( DMatTransposer<MT,SO>& m )
1884 template<
typename MT
1886 inline bool isIntact(
const DMatTransposer<MT,SO>& m ) noexcept
1888 return m.isIntact();
1904 template<
typename MT,
bool SO >
1905 struct HasMutableDataAccess< DMatTransposer<MT,SO> >
1906 :
public BoolConstant< HasMutableDataAccess<MT>::value >
1922 template<
typename MT,
bool SO >
1923 struct IsAligned< DMatTransposer<MT,SO> >
1940 template<
typename MT,
bool SO >
1941 struct IsPadded< DMatTransposer<MT,SO> >
1958 template<
typename MT,
bool SO >
1959 struct SubmatrixTrait< DMatTransposer<MT,SO> >
1961 using Type = SubmatrixTrait_< ResultType_< DMatTransposer<MT,SO> > >;
Pointer_< MT > Pointer
Pointer to a non-constant matrix value.
Definition: DMatTransposer.h:94
ConstReference operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTransposer.h:145
Constraint on the data type.
BLAZE_ALWAYS_INLINE void storea(size_t i, size_t j, const SIMDType &value) noexcept
Aligned store of a SIMD element of the matrix.
Definition: DMatTransposer.h:520
Header file for auxiliary alias declarations.
void addAssign(const SparseMatrix< MT2, SO > &rhs)
Implementation of the transpose addition assignment of a row-major sparse matrix. ...
Definition: DMatTransposer.h:777
Header file for kernel specific block sizes.
size_t spacing() const noexcept
Returns the spacing between the beginning of two rows.
Definition: DMatTransposer.h:365
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_USER_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERT flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:117
DMatTransposer< MT, SO > This
Type of this DMatTransposer instance.
Definition: DMatTransposer.h:84
BLAZE_ALWAYS_INLINE void storeu(size_t i, size_t j, const SIMDType &value) noexcept
Unaligned store of a SIMD element of the matrix.
Definition: DMatTransposer.h:538
Header file for basic type definitions.
DMatTransposer(MT &dm) noexcept
Constructor for the DMatTransposer class.
Definition: DMatTransposer.h:119
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatTransposer.h:285
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTransposer.h:86
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.In case the given data type T is a computational expression (i...
Definition: Computation.h:81
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:61
BLAZE_ALWAYS_INLINE SIMDType loada(size_t i, size_t j) const noexcept
Aligned load of a SIMD element of the matrix.
Definition: DMatTransposer.h:467
bool isIntact() const noexcept
Returns whether the invariants of the matrix are intact.
Definition: DMatTransposer.h:385
typename SIMDTrait< T >::Type SIMDTrait_
Auxiliary alias declaration for the SIMDTrait class template.The SIMDTrait_ alias declaration provide...
Definition: SIMDTrait.h:315
void subAssign(const SparseMatrix< MT2,!SO > &rhs)
Implementation of the transpose subtraction assignment of a column-major sparse matrix.
Definition: DMatTransposer.h:933
ConstIterator_< MT > ConstIterator
Iterator over constant elements.
Definition: DMatTransposer.h:97
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
Constraints on the storage order of matrix types.
Reference_< MT > Reference
Reference to a non-constant matrix value.
Definition: DMatTransposer.h:92
ConstReference_< MT > ConstReference
Reference to a constant matrix value.
Definition: DMatTransposer.h:93
void addAssign(const DenseMatrix< MT2, SO > &rhs)
Implementation of the transpose addition assignment of a row-major dense matrix.
Definition: DMatTransposer.h:702
Header file for the SIMD trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
Pointer data() noexcept
Low-level data access to the matrix elements.
Definition: DMatTransposer.h:195
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatTransposer.h:355
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:109
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
bool canAlias(const Other *alias) const noexcept
Returns whether the matrix can alias with the given address alias.
Definition: DMatTransposer.h:398
const This & CompositeType
Data type for composite expression templates.
Definition: DMatTransposer.h:91
Constraint on the data type.
typename T::Pointer Pointer_
Alias declaration for nested Pointer type definitions.The Pointer_ alias declaration provides a conve...
Definition: Aliases.h:263
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
void subAssign(const DenseMatrix< MT2, SO > &rhs)
Implementation of the transpose subtraction assignment of a row-major dense matrix.
Definition: DMatTransposer.h:831
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: ColumnMajorMatrix.h:61
Reference operator()(size_t i, size_t j)
2D-access to the matrix elements.
Definition: DMatTransposer.h:131
ElementType_< MT > ElementType
Type of the matrix elements.
Definition: DMatTransposer.h:88
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
ResultType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatTransposer.h:87
Expression object for the transposition of a dense matrix.The DMatTransposer class is a wrapper objec...
Definition: DMatTransposer.h:80
bool isAligned() const noexcept
Returns whether the matrix is properly aligned in memory.
Definition: DMatTransposer.h:422
MT & dm_
The dense matrix operand.
Definition: DMatTransposer.h:958
Header file for the IsAligned type trait.
Header file for the exception macros of the math module.
EnableIf_< IsNumeric< Other >, DMatTransposer > & operator/=(Other rhs)
Division assignment operator for the division of a matrix by a scalar value ( ).
Definition: DMatTransposer.h:331
void assign(const SparseMatrix< MT2,!SO > &rhs)
Implementation of the transpose assignment of a column-major sparse matrix.
Definition: DMatTransposer.h:675
void reset()
Resets the matrix elements.
Definition: DMatTransposer.h:375
BLAZE_ALWAYS_INLINE void store(size_t i, size_t j, const SIMDType &value) noexcept
Store of a SIMD element of the matrix.
Definition: DMatTransposer.h:502
typename T::Reference Reference_
Alias declaration for nested Reference type definitions.The Reference_ alias declaration provides a c...
Definition: Aliases.h:283
BLAZE_ALWAYS_INLINE void stream(size_t i, size_t j, const SIMDType &value) noexcept
Aligned, non-temporal store of a SIMD element of the matrix.
Definition: DMatTransposer.h:556
Header file for the EnableIf class template.
void assign(const DenseMatrix< MT2,!SO > &rhs)
Implementation of the transpose assignment of a column-major dense matrix.
Definition: DMatTransposer.h:611
Header file for the IsPadded type trait.
SIMDTrait_< ElementType > SIMDType
SIMD type of the matrix elements.
Definition: DMatTransposer.h:89
Iterator_< MT > Iterator
Iterator over non-constant elements.
Definition: DMatTransposer.h:96
void assign(const DenseMatrix< MT2, SO > &rhs)
Implementation of the transpose assignment of a row-major dense matrix.
Definition: DMatTransposer.h:574
Header file for the IsNumeric type trait.
void subAssign(const SparseMatrix< MT2, SO > &rhs)
Implementation of the transpose subtraction assignment of a row-major sparse matrix.
Definition: DMatTransposer.h:906
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: RowMajorMatrix.h:61
Header file for run time assertion macros.
void subAssign(const DenseMatrix< MT2,!SO > &rhs)
Implementation of the transpose subtraction assignment of a column-major dense matrix.
Definition: DMatTransposer.h:869
Header file for the submatrix trait.
ConstPointer_< MT > ConstPointer
Pointer to a constant matrix value.
Definition: DMatTransposer.h:95
ConstIterator cend(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatTransposer.h:301
void addAssign(const DenseMatrix< MT2,!SO > &rhs)
Implementation of the transpose addition assignment of a column-major dense matrix.
Definition: DMatTransposer.h:740
ConstIterator cbegin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatTransposer.h:253
BLAZE_ALWAYS_INLINE SIMDType load(size_t i, size_t j) const noexcept
Load of a SIMD element of the matrix.
Definition: DMatTransposer.h:450
EnableIf_< IsNumeric< Other >, DMatTransposer > & operator*=(Other rhs)
Multiplication assignment operator for the multiplication between a matrix and a scalar value ( )...
Definition: DMatTransposer.h:314
bool canSMPAssign() const noexcept
Returns whether the matrix can be used in SMP assignments.
Definition: DMatTransposer.h:433
ConstReference at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatTransposer.h:179
Constraints on the storage order of matrix types.
TransposeType_< MT > ResultType
Result type for expression template evaluations.
Definition: DMatTransposer.h:85
Header file for the HasMutableDataAccess type trait.
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
typename T::Iterator Iterator_
Alias declaration for nested Iterator type definitions.The Iterator_ alias declaration provides a con...
Definition: Aliases.h:183
typename T::ConstPointer ConstPointer_
Alias declaration for nested ConstPointer type definitions.The ConstPointer_ alias declaration provid...
Definition: Aliases.h:123
typename T::ConstReference ConstReference_
Alias declaration for nested ConstReference type definitions.The ConstReference_ alias declaration pr...
Definition: Aliases.h:143
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
void addAssign(const SparseMatrix< MT2,!SO > &rhs)
Implementation of the transpose addition assignment of a column-major sparse matrix.
Definition: DMatTransposer.h:804
Reference at(size_t i, size_t j)
Checked access to the matrix elements.
Definition: DMatTransposer.h:160
Iterator begin(size_t i)
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatTransposer.h:221
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatTransposer.h:345
ConstPointer data() const noexcept
Low-level data access to the matrix elements.
Definition: DMatTransposer.h:205
void assign(const SparseMatrix< MT2, SO > &rhs)
Implementation of the transpose assignment of a row-major sparse matrix.
Definition: DMatTransposer.h:648
Header file for the IntegralConstant class template.
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:240
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatTransposer.h:90
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
bool isAliased(const Other *alias) const noexcept
Returns whether the matrix is aliased with the given address alias.
Definition: DMatTransposer.h:411
System settings for the inline keywords.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
BLAZE_ALWAYS_INLINE SIMDType loadu(size_t i, size_t j) const noexcept
Unaligned load of a SIMD element of the matrix.
Definition: DMatTransposer.h:484
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatTransposer.h:237
Iterator end(size_t i)
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatTransposer.h:269