35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_DENSE_H_
101 template<
typename MT
103 class StrictlyUpperMatrix<MT,SO,true>
104 :
public DenseMatrix< StrictlyUpperMatrix<MT,SO,true>, SO >
111 typedef IntrinsicTrait<ET> IT;
116 typedef StrictlyUpperMatrix<MT,SO,true>
This;
121 typedef typename MT::IntrinsicType IntrinsicType;
124 typedef StrictlyUpperProxy<MT>
Reference;
126 typedef typename MT::Pointer Pointer;
127 typedef typename MT::ConstPointer ConstPointer;
134 template<
typename ET >
137 typedef StrictlyUpperMatrix< typename MT::template Rebind<ET>::Other > Other;
148 typedef std::random_access_iterator_tag IteratorCategory;
150 typedef StrictlyUpperProxy<MT> PointerType;
151 typedef StrictlyUpperProxy<MT> ReferenceType;
152 typedef ptrdiff_t DifferenceType;
155 typedef IteratorCategory iterator_category;
156 typedef ValueType value_type;
157 typedef PointerType pointer;
158 typedef ReferenceType reference;
159 typedef DifferenceType difference_type;
192 inline Iterator& operator+=(
size_t inc ) {
193 ( SO )?( row_ += inc ):( column_ += inc );
204 inline Iterator& operator-=(
size_t dec ) {
205 ( SO )?( row_ -= dec ):( column_ -= dec );
216 ( SO )?( ++row_ ):( ++column_ );
226 inline const Iterator operator++(
int ) {
239 ( SO )?( --row_ ):( --column_ );
249 inline const Iterator operator--(
int ) {
262 return ReferenceType( *matrix_, row_, column_ );
271 inline PointerType operator->()
const {
272 return PointerType( *matrix_, row_, column_ );
283 return matrix_->begin( column_ ) + row_;
285 return matrix_->begin( row_ ) + column_;
297 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
333 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
369 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
405 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
441 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
477 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
512 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
525 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
527 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
540 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
542 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
555 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
557 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
572 enum { vectorizable = MT::vectorizable };
575 enum { smpAssignable = MT::smpAssignable };
581 explicit inline StrictlyUpperMatrix();
582 template<
typename A1 >
explicit inline StrictlyUpperMatrix(
const A1& a1 );
583 explicit inline StrictlyUpperMatrix(
size_t n,
const ElementType& init );
584 inline StrictlyUpperMatrix(
const StrictlyUpperMatrix& m );
595 inline Reference operator()(
size_t i,
size_t j );
596 inline ConstReference operator()(
size_t i,
size_t j )
const;
597 inline ConstPointer data ()
const;
598 inline ConstPointer data (
size_t i )
const;
600 inline ConstIterator
begin (
size_t i )
const;
601 inline ConstIterator
cbegin(
size_t i )
const;
603 inline ConstIterator
end (
size_t i )
const;
604 inline ConstIterator
cend (
size_t i )
const;
611 inline StrictlyUpperMatrix& operator=(
const ElementType& rhs );
612 inline StrictlyUpperMatrix& operator=(
const StrictlyUpperMatrix& rhs );
614 template<
typename MT2,
bool SO2 >
615 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
616 operator=(
const Matrix<MT2,SO2>& rhs );
618 template<
typename MT2,
bool SO2 >
619 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
620 operator=(
const Matrix<MT2,SO2>& rhs );
622 template<
typename MT2,
bool SO2 >
623 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
624 operator+=(
const Matrix<MT2,SO2>& rhs );
626 template<
typename MT2,
bool SO2 >
627 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
628 operator+=(
const Matrix<MT2,SO2>& rhs );
630 template<
typename MT2,
bool SO2 >
631 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
632 operator-=(
const Matrix<MT2,SO2>& rhs );
634 template<
typename MT2,
bool SO2 >
635 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
636 operator-=(
const Matrix<MT2,SO2>& rhs );
638 template<
typename MT2,
bool SO2 >
639 inline StrictlyUpperMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
641 template<
typename Other >
642 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix >::Type&
643 operator*=( Other rhs );
645 template<
typename Other >
646 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix >::Type&
647 operator/=( Other rhs );
654 inline size_t rows()
const;
658 inline size_t capacity(
size_t i )
const;
660 inline size_t nonZeros(
size_t i )
const;
662 inline void reset(
size_t i );
664 void resize (
size_t n,
bool preserve=
true );
665 inline void extend (
size_t n,
bool preserve=
true );
666 inline void reserve(
size_t elements );
668 template<
typename Other >
inline StrictlyUpperMatrix& scale(
const Other& scalar );
670 inline void swap( StrictlyUpperMatrix& m ) ;
672 static inline size_t maxNonZeros();
673 static inline size_t maxNonZeros(
size_t n );
680 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
681 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
683 inline bool isAligned ()
const;
684 inline bool canSMPAssign()
const;
695 inline const MT construct(
size_t n ,
TrueType );
696 inline const MT construct(
const ElementType& value,
FalseType );
698 template<
typename MT2,
bool SO2,
typename T >
699 inline const MT construct(
const Matrix<MT2,SO2>& m, T );
711 template<
typename MT2,
bool SO2,
bool DF2 >
712 friend MT2& derestrict( StrictlyUpperMatrix<MT2,SO2,DF2>& m );
746 template<
typename MT
748 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix()
775 template<
typename MT
777 template<
typename A1 >
778 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix(
const A1& a1 )
779 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
794 template<
typename MT
796 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix(
size_t n,
const ElementType& init )
797 : matrix_( n, n, ElementType() )
802 for(
size_t j=0UL; j<
columns(); ++j ) {
803 for(
size_t i=0UL; i<j; ++i )
808 for(
size_t i=0UL; i<
rows(); ++i ) {
809 for(
size_t j=i+1UL; j<
columns(); ++j )
826 template<
typename MT
828 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix(
const StrictlyUpperMatrix& m )
829 : matrix_( m.matrix_ )
858 template<
typename MT
861 StrictlyUpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
885 template<
typename MT
888 StrictlyUpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
912 template<
typename MT
914 inline typename StrictlyUpperMatrix<MT,SO,true>::ConstPointer
915 StrictlyUpperMatrix<MT,SO,true>::data()
const
917 return matrix_.data();
932 template<
typename MT
934 inline typename StrictlyUpperMatrix<MT,SO,true>::ConstPointer
935 StrictlyUpperMatrix<MT,SO,true>::data(
size_t i )
const
937 return matrix_.data(i);
955 template<
typename MT
981 template<
typename MT
986 return matrix_.begin(i);
1004 template<
typename MT
1009 return matrix_.cbegin(i);
1027 template<
typename MT
1053 template<
typename MT
1058 return matrix_.end(i);
1076 template<
typename MT
1081 return matrix_.cend(i);
1102 template<
typename MT
1104 inline StrictlyUpperMatrix<MT,SO,true>&
1105 StrictlyUpperMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1108 for(
size_t j=1UL; j<
columns(); ++j )
1109 for(
size_t i=0UL; i<j; ++i )
1113 for(
size_t i=0UL; i<
rows(); ++i )
1114 for(
size_t j=i+1UL; j<
columns(); ++j )
1134 template<
typename MT
1136 inline StrictlyUpperMatrix<MT,SO,true>&
1137 StrictlyUpperMatrix<MT,SO,true>::operator=(
const StrictlyUpperMatrix& rhs )
1139 matrix_ = rhs.matrix_;
1160 template<
typename MT
1162 template<
typename MT2
1164 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1165 StrictlyUpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1167 if( IsUniTriangular<MT2>::value ||
1169 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1192 template<
typename MT
1194 template<
typename MT2
1196 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1197 StrictlyUpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1199 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
1200 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1202 if( IsStrictlyUpper<MT2>::value ) {
1209 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1211 move( matrix_, tmp );
1233 template<
typename MT
1235 template<
typename MT2
1237 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1238 StrictlyUpperMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1240 if( IsUniTriangular<MT2>::value ||
1242 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1265 template<
typename MT
1267 template<
typename MT2
1269 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1270 StrictlyUpperMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1272 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
1273 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1275 if( IsStrictlyUpper<MT2>::value ) {
1282 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1306 template<
typename MT
1308 template<
typename MT2
1310 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1311 StrictlyUpperMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1314 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1337 template<
typename MT
1339 template<
typename MT2
1341 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1342 StrictlyUpperMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1344 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1345 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1347 if( IsStrictlyUpper<MT2>::value ) {
1354 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1377 template<
typename MT
1379 template<
typename MT2
1381 inline StrictlyUpperMatrix<MT,SO,true>&
1382 StrictlyUpperMatrix<MT,SO,true>::operator*=(
const Matrix<MT2,SO2>& rhs )
1384 if( matrix_.rows() != (~rhs).
columns() )
1385 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1387 MT tmp( matrix_ * ~rhs );
1390 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
1392 move( matrix_, tmp );
1408 template<
typename MT
1410 template<
typename Other >
1411 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,true> >::Type&
1412 StrictlyUpperMatrix<MT,SO,true>::operator*=( Other rhs )
1428 template<
typename MT
1430 template<
typename Other >
1431 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,true> >::Type&
1432 StrictlyUpperMatrix<MT,SO,true>::operator/=( Other rhs )
1457 template<
typename MT
1461 return matrix_.rows();
1473 template<
typename MT
1477 return matrix_.columns();
1494 template<
typename MT
1498 return matrix_.spacing();
1510 template<
typename MT
1514 return matrix_.capacity();
1532 template<
typename MT
1536 return matrix_.capacity(i);
1548 template<
typename MT
1552 return matrix_.nonZeros();
1570 template<
typename MT
1574 return matrix_.nonZeros(i);
1586 template<
typename MT
1593 for(
size_t j=1UL; j<
columns(); ++j )
1594 for(
size_t i=0UL; i<j; ++i )
1595 clear( matrix_(i,j) );
1598 for(
size_t i=0UL; i<
rows(); ++i )
1599 for(
size_t j=i+1UL; j<
columns(); ++j )
1600 clear( matrix_(i,j) );
1620 template<
typename MT
1627 for(
size_t j=0UL; j<i; ++j )
1628 clear( matrix_(j,i) );
1631 for(
size_t j=i+1UL; j<
columns(); ++j )
1632 clear( matrix_(i,j) );
1651 template<
typename MT
1657 if( IsResizable<MT>::value ) {
1704 template<
typename MT
1714 const size_t oldsize( matrix_.rows() );
1716 matrix_.resize( n, n,
true );
1720 const size_t increment( n - oldsize );
1721 submatrix( matrix_, oldsize, 0UL, increment, n ).reset();
1741 template<
typename MT
1743 inline void StrictlyUpperMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
1764 template<
typename MT
1766 inline void StrictlyUpperMatrix<MT,SO,true>::reserve(
size_t elements )
1768 matrix_.reserve( elements );
1781 template<
typename MT
1783 template<
typename Other >
1784 inline StrictlyUpperMatrix<MT,SO,true>&
1785 StrictlyUpperMatrix<MT,SO,true>::scale(
const Other& scalar )
1787 matrix_.scale( scalar );
1802 template<
typename MT
1808 swap( matrix_, m.matrix_ );
1826 template<
typename MT
1828 inline size_t StrictlyUpperMatrix<MT,SO,true>::maxNonZeros()
1832 return maxNonZeros( Rows<MT>::value );
1848 template<
typename MT
1850 inline size_t StrictlyUpperMatrix<MT,SO,true>::maxNonZeros(
size_t n )
1852 return ( ( n - 1UL ) * n ) / 2UL;
1877 template<
typename MT
1879 template<
typename Other >
1880 inline bool StrictlyUpperMatrix<MT,SO,true>::canAlias(
const Other* alias )
const
1882 return matrix_.canAlias( alias );
1899 template<
typename MT
1901 template<
typename Other >
1902 inline bool StrictlyUpperMatrix<MT,SO,true>::isAliased(
const Other* alias )
const
1904 return matrix_.isAliased( alias );
1920 template<
typename MT
1922 inline bool StrictlyUpperMatrix<MT,SO,true>::isAligned()
const
1924 return matrix_.isAligned();
1941 template<
typename MT
1943 inline bool StrictlyUpperMatrix<MT,SO,true>::canSMPAssign()
const
1945 return matrix_.canSMPAssign();
1967 template<
typename MT
1972 return matrix_.load( i, j );
1994 template<
typename MT
1999 return matrix_.loadu( i, j );
2020 template<
typename MT
2022 inline const MT StrictlyUpperMatrix<MT,SO,true>::construct(
size_t n,
TrueType )
2039 template<
typename MT
2041 inline const MT StrictlyUpperMatrix<MT,SO,true>::construct(
const ElementType& init,
FalseType )
2049 for(
size_t j=0UL; j<
columns(); ++j ) {
2050 for(
size_t i=0UL; i<j; ++i )
2055 for(
size_t i=0UL; i<
rows(); ++i ) {
2056 for(
size_t j=i+1UL; j<
columns(); ++j )
2078 template<
typename MT
2080 template<
typename MT2
2083 inline const MT StrictlyUpperMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2087 if( IsUniTriangular<MT2>::value ||
2089 throw std::invalid_argument(
"Invalid setup of strictly upper matrix" );
Header file for the StrictlyUpperProxy class.
Constraint on the data type.
Header file for all restructuring submatrix functions.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created.
Definition: Const.h:116
#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
Header file for the Rows type trait.
Header file for the UNUSED_PARAMETER function template.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:8247
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix)
Checks if the given matrix is a square matrix.
Definition: Matrix.h:902
BLAZE_ALWAYS_INLINE MT::ConstIterator cbegin(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:237
BLAZE_ALWAYS_INLINE MT::ConstIterator cend(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:300
bool operator<=(const NegativeAccuracy< A > &, const T &rhs)
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:404
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:258
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1354
Header file for the FalseType type/value trait base class.
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:242
#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:79
Constraint on the data type.
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:821
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix)
Returns the maximum capacity of the matrix.
Definition: Matrix.h:348
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:316
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:4762
DisableIf< Or< IsComputation< MT >, IsTransExpr< MT > >, typename ColumnExprTrait< MT >::Type >::Type column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:103
void UNUSED_PARAMETER(const T1 &)
Suppression of unused parameter warnings.
Definition: Unused.h:81
bool operator>(const NegativeAccuracy< A > &lhs, const T &rhs)
Greater-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:366
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2501
bool operator>=(const NegativeAccuracy< A > &, const T &rhs)
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:442
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created.
Definition: Volatile.h:116
BLAZE_ALWAYS_INLINE size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:386
#define BLAZE_CONSTRAINT_MUST_BE_SQUARE(T)
Constraint on the data type.In case the given data type T is not a square matrix type, a compilation error is created.
Definition: Square.h:78
Constraint on the data type.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2503
Constraint on the data type.
Header file for the IsSquare type trait.
Constraint on the data type.
Constraint on the data type.
Header file for the DenseSubmatrix class template.
Header file for the DisableIf class template.
Header file for the IsStrictlyUpper type trait.
Header file for the clear shim.
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
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, sse_int16_t >::Type loadu(const T *address)
Loads a vector of 2-byte integral values.
Definition: Loadu.h:76
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b)
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:4807
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:116
Header file for the DenseMatrix base class.
Constraint on the data type.
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
Header file for the IsUniTriangular type trait.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2504
Constraints on the storage order of matrix types.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a upper triangular matrix type...
Definition: Upper.h:118
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:195
BLAZE_ALWAYS_INLINE void resize(Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true)
Changing the size of the matrix.
Definition: Matrix.h:535
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2509
Header file for the EnableIf class template.
Header file for utility functions for dense matrices.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:841
Header file for the implementation of the base template of the StrictlyUpperMatrix.
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, sse_int16_t >::Type load(const T *address)
Loads a vector of 2-byte integral values.
Definition: Load.h:79
Header file for all adaptor forward declarations.
const bool spacing
Adding an additional spacing line between two log messages.This setting gives the opportunity to add ...
Definition: Logging.h:70
DisableIf< Or< IsComputation< MT >, IsTransExpr< MT > >, typename RowExprTrait< MT >::Type >::Type row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:103
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:116
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2506
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:118
void move(DynamicMatrix< Type, SO > &dst, DynamicMatrix< Type, SO > &src)
Moving the contents of one dynamic matrix to another.
Definition: DynamicMatrix.h:4934
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:116
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2510
Header file for the isDefault shim.
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is resizable, i.e. has a 'resize' member fu...
Definition: Resizable.h:118
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b)
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:200
Header file for all intrinsic functionality.
Header file for the move shim.
SubmatrixExprTrait< MT, unaligned >::Type submatrix(Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n)
Creating a view on a specific submatrix of the given matrix.
Definition: Submatrix.h:143
bool operator<(const NegativeAccuracy< A > &lhs, const T &rhs)
Less-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:328
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is not resizable, i.e. does not have a 'res...
Definition: Resizable.h:79
Header file for the IsComputation type trait class.
boost::false_type FalseType
Type/value traits base class.The FalseType class is used as base class for type traits and value trai...
Definition: FalseType.h:61
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)
Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from ...
Definition: Expression.h:118
bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:249
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2508
boost::true_type TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: TrueType.h:61
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:143
Header file for the IsResizable type trait.
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
Header file for the TrueType type/value trait base class.