35 #ifndef _BLAZE_MATH_ADAPTORS_UNIUPPERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_UNIUPPERMATRIX_DENSE_H_
107 template<
typename MT
109 class UniUpperMatrix<MT,SO,true>
110 :
public DenseMatrix< UniUpperMatrix<MT,SO,true>, SO >
117 typedef IntrinsicTrait<ET> IT;
122 typedef UniUpperMatrix<MT,SO,true>
This;
127 typedef typename MT::IntrinsicType IntrinsicType;
132 typedef typename MT::Pointer Pointer;
133 typedef typename MT::ConstPointer ConstPointer;
140 template<
typename ET >
143 typedef UniUpperMatrix< typename MT::template Rebind<ET>::Other > Other;
154 typedef std::random_access_iterator_tag IteratorCategory;
156 typedef UniUpperProxy<MT> PointerType;
157 typedef UniUpperProxy<MT> ReferenceType;
158 typedef ptrdiff_t DifferenceType;
161 typedef IteratorCategory iterator_category;
162 typedef ValueType value_type;
163 typedef PointerType pointer;
164 typedef ReferenceType reference;
165 typedef DifferenceType difference_type;
198 inline Iterator& operator+=(
size_t inc ) {
199 ( SO )?( row_ += inc ):( column_ += inc );
210 inline Iterator& operator-=(
size_t dec ) {
211 ( SO )?( row_ -= dec ):( column_ -= dec );
222 ( SO )?( ++row_ ):( ++column_ );
232 inline const Iterator operator++(
int ) {
245 ( SO )?( --row_ ):( --column_ );
255 inline const Iterator operator--(
int ) {
268 return ReferenceType( *matrix_, row_, column_ );
277 inline PointerType operator->()
const {
278 return PointerType( *matrix_, row_, column_ );
289 return matrix_->begin( column_ ) + row_;
291 return matrix_->begin( row_ ) + column_;
303 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
339 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
375 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
411 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
447 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
483 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
518 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
531 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
533 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
546 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
548 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
561 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
563 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
578 enum { vectorizable = MT::vectorizable };
581 enum { smpAssignable = MT::smpAssignable };
587 explicit inline UniUpperMatrix();
588 template<
typename A1 >
explicit inline UniUpperMatrix(
const A1& a1 );
589 explicit inline UniUpperMatrix(
size_t n,
const ElementType& init );
591 explicit inline UniUpperMatrix( ElementType* ptr,
size_t n );
592 explicit inline UniUpperMatrix( ElementType* ptr,
size_t n,
size_t nn );
594 template<
typename Deleter >
595 explicit inline UniUpperMatrix( ElementType* ptr,
size_t n, Deleter d );
597 template<
typename Deleter >
598 explicit inline UniUpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
600 inline UniUpperMatrix(
const UniUpperMatrix& m );
611 inline Reference operator()(
size_t i,
size_t j );
612 inline ConstReference operator()(
size_t i,
size_t j )
const;
613 inline Reference at(
size_t i,
size_t j );
614 inline ConstReference at(
size_t i,
size_t j )
const;
615 inline ConstPointer data ()
const;
616 inline ConstPointer data (
size_t i )
const;
618 inline ConstIterator
begin (
size_t i )
const;
619 inline ConstIterator
cbegin(
size_t i )
const;
621 inline ConstIterator
end (
size_t i )
const;
622 inline ConstIterator
cend (
size_t i )
const;
629 inline UniUpperMatrix& operator=(
const ElementType& rhs );
630 inline UniUpperMatrix& operator=(
const UniUpperMatrix& rhs );
632 template<
typename MT2,
bool SO2 >
633 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
634 operator=(
const Matrix<MT2,SO2>& rhs );
636 template<
typename MT2,
bool SO2 >
637 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
638 operator=(
const Matrix<MT2,SO2>& rhs );
640 template<
typename MT2,
bool SO2 >
641 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
642 operator+=(
const Matrix<MT2,SO2>& rhs );
644 template<
typename MT2,
bool SO2 >
645 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
646 operator+=(
const Matrix<MT2,SO2>& rhs );
648 template<
typename MT2,
bool SO2 >
649 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
650 operator-=(
const Matrix<MT2,SO2>& rhs );
652 template<
typename MT2,
bool SO2 >
653 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
654 operator-=(
const Matrix<MT2,SO2>& rhs );
656 template<
typename MT2,
bool SO2 >
657 inline UniUpperMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
664 inline size_t rows()
const;
668 inline size_t capacity(
size_t i )
const;
670 inline size_t nonZeros(
size_t i )
const;
672 inline void reset(
size_t i );
674 void resize (
size_t n,
bool preserve=
true );
675 inline void extend (
size_t n,
bool preserve=
true );
676 inline void reserve(
size_t elements );
677 inline void swap( UniUpperMatrix& m ) ;
679 static inline size_t maxNonZeros();
680 static inline size_t maxNonZeros(
size_t n );
694 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
695 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
697 inline bool isAligned ()
const;
698 inline bool canSMPAssign()
const;
710 inline const MT construct(
size_t n ,
TrueType );
711 inline const MT construct(
const ElementType& value,
FalseType );
713 template<
typename MT2,
bool SO2,
typename T >
714 inline const MT construct(
const Matrix<MT2,SO2>& m, T );
726 template<
typename MT2,
bool SO2,
bool DF2 >
727 friend MT2& derestrict( UniUpperMatrix<MT2,SO2,DF2>& m );
763 template<
typename MT
765 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix()
768 for(
size_t i=0UL; i<Rows<MT>::value; ++i )
796 template<
typename MT
798 template<
typename A1 >
799 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix(
const A1& a1 )
800 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
816 template<
typename MT
818 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix(
size_t n,
const ElementType& init )
819 : matrix_( n, n, ElementType() )
824 for(
size_t j=0UL; j<
columns(); ++j ) {
825 for(
size_t i=0UL; i<j; ++i )
831 for(
size_t i=0UL; i<
rows(); ++i ) {
833 for(
size_t j=i+1UL; j<
columns(); ++j )
866 template<
typename MT
868 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( ElementType* ptr,
size_t n )
869 : matrix_( ptr, n, n )
904 template<
typename MT
906 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( ElementType* ptr,
size_t n,
size_t nn )
907 : matrix_( ptr, n, n, nn )
940 template<
typename MT
942 template<
typename Deleter >
943 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( ElementType* ptr,
size_t n, Deleter d )
944 : matrix_( ptr, n, n, d )
978 template<
typename MT
980 template<
typename Deleter >
981 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
982 : matrix_( ptr, n, n, nn, d )
1000 template<
typename MT
1002 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix(
const UniUpperMatrix& m )
1003 : matrix_( m.matrix_ )
1036 template<
typename MT
1039 UniUpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1066 template<
typename MT
1069 UniUpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
1074 return matrix_(i,j);
1097 template<
typename MT
1100 UniUpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1108 return (*
this)(i,j);
1131 template<
typename MT
1134 UniUpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const
1142 return (*
this)(i,j);
1161 template<
typename MT
1163 inline typename UniUpperMatrix<MT,SO,true>::ConstPointer
1164 UniUpperMatrix<MT,SO,true>::data()
const
1166 return matrix_.data();
1181 template<
typename MT
1183 inline typename UniUpperMatrix<MT,SO,true>::ConstPointer
1184 UniUpperMatrix<MT,SO,true>::data(
size_t i )
const
1186 return matrix_.data(i);
1204 template<
typename MT
1210 return Iterator( matrix_, 0UL, i );
1212 return Iterator( matrix_, i, 0UL );
1230 template<
typename MT
1235 return matrix_.begin(i);
1253 template<
typename MT
1258 return matrix_.cbegin(i);
1276 template<
typename MT
1302 template<
typename MT
1307 return matrix_.end(i);
1325 template<
typename MT
1330 return matrix_.cend(i);
1351 template<
typename MT
1353 inline UniUpperMatrix<MT,SO,true>&
1354 UniUpperMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1357 for(
size_t j=1UL; j<
columns(); ++j )
1358 for(
size_t i=0UL; i<j; ++i )
1362 for(
size_t i=0UL; i<
rows(); ++i )
1363 for(
size_t j=i+1UL; j<
columns(); ++j )
1383 template<
typename MT
1385 inline UniUpperMatrix<MT,SO,true>&
1386 UniUpperMatrix<MT,SO,true>::operator=(
const UniUpperMatrix& rhs )
1388 matrix_ = rhs.matrix_;
1412 template<
typename MT
1414 template<
typename MT2
1416 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >::Type
1417 UniUpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1419 if( IsStrictlyTriangular<MT2>::value || ( !IsUniUpper<MT2>::value && !
isUniUpper( ~rhs ) ) ) {
1447 template<
typename MT
1449 template<
typename MT2
1451 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >::Type
1452 UniUpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1454 if( IsStrictlyTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1458 if( IsUniUpper<MT2>::value ) {
1468 move( matrix_, tmp );
1493 template<
typename MT
1495 template<
typename MT2
1497 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >::Type
1498 UniUpperMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1500 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1529 template<
typename MT
1531 template<
typename MT2
1533 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >::Type
1534 UniUpperMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1536 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1537 ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1541 if( IsStrictlyUpper<MT2>::value ) {
1576 template<
typename MT
1578 template<
typename MT2
1580 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >::Type
1581 UniUpperMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1583 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1612 template<
typename MT
1614 template<
typename MT2
1616 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >::Type
1617 UniUpperMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1619 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1620 ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1624 if( IsStrictlyUpper<MT2>::value ) {
1658 template<
typename MT
1660 template<
typename MT2
1662 inline UniUpperMatrix<MT,SO,true>&
1663 UniUpperMatrix<MT,SO,true>::operator*=(
const Matrix<MT2,SO2>& rhs )
1665 if( matrix_.rows() != (~rhs).
columns() ) {
1669 MT tmp( matrix_ * ~rhs );
1675 move( matrix_, tmp );
1700 template<
typename MT
1704 return matrix_.rows();
1716 template<
typename MT
1720 return matrix_.columns();
1737 template<
typename MT
1741 return matrix_.spacing();
1753 template<
typename MT
1757 return matrix_.capacity();
1775 template<
typename MT
1779 return matrix_.capacity(i);
1791 template<
typename MT
1795 return matrix_.nonZeros();
1813 template<
typename MT
1817 return matrix_.nonZeros(i);
1829 template<
typename MT
1836 for(
size_t j=1UL; j<
columns(); ++j )
1837 for(
size_t i=0UL; i<j; ++i )
1838 clear( matrix_(i,j) );
1841 for(
size_t i=0UL; i<
rows(); ++i )
1842 for(
size_t j=i+1UL; j<
columns(); ++j )
1843 clear( matrix_(i,j) );
1863 template<
typename MT
1870 for(
size_t j=0UL; j<i; ++j )
1871 clear( matrix_(j,i) );
1874 for(
size_t j=i+1UL; j<
columns(); ++j )
1875 clear( matrix_(i,j) );
1894 template<
typename MT
1900 if( IsResizable<MT>::value ) {
1947 template<
typename MT
1957 const size_t oldsize( matrix_.rows() );
1959 matrix_.resize( n, n,
true );
1963 const size_t increment( n - oldsize );
1964 submatrix( matrix_, oldsize, 0UL, increment, n-1UL ).reset();
1966 for(
size_t i=oldsize; i<n; ++i )
1987 template<
typename MT
1989 inline void UniUpperMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2010 template<
typename MT
2012 inline void UniUpperMatrix<MT,SO,true>::reserve(
size_t elements )
2014 matrix_.reserve( elements );
2028 template<
typename MT
2034 swap( matrix_, m.matrix_ );
2052 template<
typename MT
2054 inline size_t UniUpperMatrix<MT,SO,true>::maxNonZeros()
2058 return maxNonZeros( Rows<MT>::value );
2074 template<
typename MT
2076 inline size_t UniUpperMatrix<MT,SO,true>::maxNonZeros(
size_t n )
2078 return ( ( n + 1UL ) * n ) / 2UL;
2102 template<
typename MT
2133 template<
typename MT
2135 template<
typename Other >
2136 inline bool UniUpperMatrix<MT,SO,true>::canAlias(
const Other* alias )
const
2138 return matrix_.canAlias( alias );
2155 template<
typename MT
2157 template<
typename Other >
2158 inline bool UniUpperMatrix<MT,SO,true>::isAliased(
const Other* alias )
const
2160 return matrix_.isAliased( alias );
2176 template<
typename MT
2178 inline bool UniUpperMatrix<MT,SO,true>::isAligned()
const
2180 return matrix_.isAligned();
2197 template<
typename MT
2199 inline bool UniUpperMatrix<MT,SO,true>::canSMPAssign()
const
2201 return matrix_.canSMPAssign();
2223 template<
typename MT
2226 UniUpperMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const
2228 return matrix_.load( i, j );
2250 template<
typename MT
2255 return matrix_.loada( i, j );
2277 template<
typename MT
2282 return matrix_.loadu( i, j );
2303 template<
typename MT
2305 inline const MT UniUpperMatrix<MT,SO,true>::construct(
size_t n,
TrueType )
2311 for(
size_t i=0UL; i<n; ++i )
2327 template<
typename MT
2329 inline const MT UniUpperMatrix<MT,SO,true>::construct(
const ElementType& init,
FalseType )
2337 for(
size_t j=0UL; j<
columns(); ++j ) {
2338 for(
size_t i=0UL; i<j; ++i )
2344 for(
size_t i=0UL; i<
rows(); ++i ) {
2346 for(
size_t j=i+1UL; j<
columns(); ++j )
2368 template<
typename MT
2370 template<
typename MT2
2373 inline const MT UniUpperMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2377 if( IsStrictlyTriangular<MT2>::value || ( !IsUniUpper<MT2>::value && !
isUniUpper( tmp ) ) ) {
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_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
Constraint on the data type.
#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.
Header file for the IsUniUpper type trait.
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:7820
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:603
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:229
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:292
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:250
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1434
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: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: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:507
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix)
Returns the maximum capacity of the matrix.
Definition: Matrix.h:340
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:308
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:4926
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:107
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:2582
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
Header file for the implementation of the base template of the UniUpperMatrix.
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:378
#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
void move(CustomMatrix< Type, AF, PF, SO > &dst, CustomMatrix< Type, AF, PF, SO > &src)
Moving the contents of one custom matrix to another.
Definition: CustomMatrix.h:6085
Constraint on the data type.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2584
Constraint on the data type.
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.
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_int16_t >::Type loadu(const T *address)
Loads a vector of 2-byte integral values.
Definition: Loadu.h:74
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
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b)
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:4998
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:4980
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
#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
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:610
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
Constraint on the data type.
Header file for the IsLower type trait.
Header file for the UniUpperProxy class.
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:642
Header file for the IsUniTriangular type trait.
Header file for the IsStrictlyTriangular type trait.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2585
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:187
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:532
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2586
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2590
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:527
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:107
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_int16_t >::Type loada(const T *address)
Loads a vector of 2-byte integral values.
Definition: Loada.h:77
#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:2587
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE(T)
Constraint on the data type.In case the given data type T is not a numeric (integral or floating poin...
Definition: Numeric.h:79
#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
#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:2591
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:256
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:146
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:2583
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:324
bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:237
bool isUniUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper unitriangular matrix.
Definition: DenseMatrix.h:1354
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2589
#define BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is an Hermitian matrix type, a compilation error is created.
Definition: Hermitian.h:116
Header file for exception macros.
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.