35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_DENSE_H_
103 template<
typename MT
105 class StrictlyUpperMatrix<MT,SO,true>
106 :
public DenseMatrix< StrictlyUpperMatrix<MT,SO,true>, SO >
113 typedef IntrinsicTrait<ET> IT;
118 typedef StrictlyUpperMatrix<MT,SO,true>
This;
123 typedef typename MT::IntrinsicType IntrinsicType;
126 typedef StrictlyUpperProxy<MT>
Reference;
128 typedef typename MT::Pointer Pointer;
129 typedef typename MT::ConstPointer ConstPointer;
136 template<
typename ET >
139 typedef StrictlyUpperMatrix< typename MT::template Rebind<ET>::Other > Other;
150 typedef std::random_access_iterator_tag IteratorCategory;
152 typedef StrictlyUpperProxy<MT> PointerType;
153 typedef StrictlyUpperProxy<MT> ReferenceType;
154 typedef ptrdiff_t DifferenceType;
157 typedef IteratorCategory iterator_category;
158 typedef ValueType value_type;
159 typedef PointerType pointer;
160 typedef ReferenceType reference;
161 typedef DifferenceType difference_type;
194 inline Iterator& operator+=(
size_t inc ) {
195 ( SO )?( row_ += inc ):( column_ += inc );
206 inline Iterator& operator-=(
size_t dec ) {
207 ( SO )?( row_ -= dec ):( column_ -= dec );
218 ( SO )?( ++row_ ):( ++column_ );
228 inline const Iterator operator++(
int ) {
241 ( SO )?( --row_ ):( --column_ );
251 inline const Iterator operator--(
int ) {
264 return ReferenceType( *matrix_, row_, column_ );
273 inline PointerType operator->()
const {
274 return PointerType( *matrix_, row_, column_ );
285 return matrix_->begin( column_ ) + row_;
287 return matrix_->begin( row_ ) + column_;
299 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
335 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
371 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
407 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
443 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
479 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
514 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
527 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
529 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
542 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
544 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
557 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
559 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
574 enum { vectorizable = MT::vectorizable };
577 enum { smpAssignable = MT::smpAssignable };
583 explicit inline StrictlyUpperMatrix();
584 template<
typename A1 >
explicit inline StrictlyUpperMatrix(
const A1& a1 );
585 explicit inline StrictlyUpperMatrix(
size_t n,
const ElementType& init );
587 explicit inline StrictlyUpperMatrix( ElementType* ptr,
size_t n );
588 explicit inline StrictlyUpperMatrix( ElementType* ptr,
size_t n,
size_t nn );
590 template<
typename Deleter >
591 explicit inline StrictlyUpperMatrix( ElementType* ptr,
size_t n, Deleter d );
593 template<
typename Deleter >
594 explicit inline StrictlyUpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
596 inline StrictlyUpperMatrix(
const StrictlyUpperMatrix& m );
607 inline Reference operator()(
size_t i,
size_t j );
608 inline ConstReference operator()(
size_t i,
size_t j )
const;
609 inline Reference at(
size_t i,
size_t j );
610 inline ConstReference at(
size_t i,
size_t j )
const;
611 inline ConstPointer data ()
const;
612 inline ConstPointer data (
size_t i )
const;
614 inline ConstIterator
begin (
size_t i )
const;
615 inline ConstIterator
cbegin(
size_t i )
const;
617 inline ConstIterator
end (
size_t i )
const;
618 inline ConstIterator
cend (
size_t i )
const;
625 inline StrictlyUpperMatrix& operator=(
const ElementType& rhs );
626 inline StrictlyUpperMatrix& operator=(
const StrictlyUpperMatrix& rhs );
628 template<
typename MT2,
bool SO2 >
629 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
630 operator=(
const Matrix<MT2,SO2>& rhs );
632 template<
typename MT2,
bool SO2 >
633 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
634 operator=(
const Matrix<MT2,SO2>& rhs );
636 template<
typename MT2,
bool SO2 >
637 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
638 operator+=(
const Matrix<MT2,SO2>& rhs );
640 template<
typename MT2,
bool SO2 >
641 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
642 operator+=(
const Matrix<MT2,SO2>& rhs );
644 template<
typename MT2,
bool SO2 >
645 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
646 operator-=(
const Matrix<MT2,SO2>& rhs );
648 template<
typename MT2,
bool SO2 >
649 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
650 operator-=(
const Matrix<MT2,SO2>& rhs );
652 template<
typename MT2,
bool SO2 >
653 inline StrictlyUpperMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
655 template<
typename Other >
656 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix >::Type&
657 operator*=( Other rhs );
659 template<
typename Other >
660 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix >::Type&
661 operator/=( Other rhs );
668 inline size_t rows()
const;
672 inline size_t capacity(
size_t i )
const;
674 inline size_t nonZeros(
size_t i )
const;
676 inline void reset(
size_t i );
678 void resize (
size_t n,
bool preserve=
true );
679 inline void extend (
size_t n,
bool preserve=
true );
680 inline void reserve(
size_t elements );
682 template<
typename Other >
inline StrictlyUpperMatrix& scale(
const Other& scalar );
684 inline void swap( StrictlyUpperMatrix& m ) ;
686 static inline size_t maxNonZeros();
687 static inline size_t maxNonZeros(
size_t n );
701 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
702 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
704 inline bool isAligned ()
const;
705 inline bool canSMPAssign()
const;
717 inline const MT construct(
size_t n ,
TrueType );
718 inline const MT construct(
const ElementType& value,
FalseType );
720 template<
typename MT2,
bool SO2,
typename T >
721 inline const MT construct(
const Matrix<MT2,SO2>& m, T );
733 template<
typename MT2,
bool SO2,
bool DF2 >
734 friend MT2& derestrict( StrictlyUpperMatrix<MT2,SO2,DF2>& m );
769 template<
typename MT
771 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix()
799 template<
typename MT
801 template<
typename A1 >
802 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix(
const A1& a1 )
803 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
819 template<
typename MT
821 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix(
size_t n,
const ElementType& init )
822 : matrix_( n, n, ElementType() )
827 for(
size_t j=0UL; j<
columns(); ++j ) {
828 for(
size_t i=0UL; i<j; ++i )
833 for(
size_t i=0UL; i<
rows(); ++i ) {
834 for(
size_t j=i+1UL; j<
columns(); ++j )
868 template<
typename MT
870 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix( ElementType* ptr,
size_t n )
871 : matrix_( ptr, n, n )
906 template<
typename MT
908 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix( ElementType* ptr,
size_t n,
size_t nn )
909 : matrix_( ptr, n, n, nn )
942 template<
typename MT
944 template<
typename Deleter >
945 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix( ElementType* ptr,
size_t n, Deleter d )
946 : matrix_( ptr, n, n, d )
980 template<
typename MT
982 template<
typename Deleter >
983 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
984 : matrix_( ptr, n, n, nn, d )
1002 template<
typename MT
1004 inline StrictlyUpperMatrix<MT,SO,true>::StrictlyUpperMatrix(
const StrictlyUpperMatrix& m )
1005 : matrix_( m.matrix_ )
1038 template<
typename MT
1041 StrictlyUpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1068 template<
typename MT
1071 StrictlyUpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
1076 return matrix_(i,j);
1099 template<
typename MT
1102 StrictlyUpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1110 return (*
this)(i,j);
1133 template<
typename MT
1136 StrictlyUpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const
1144 return (*
this)(i,j);
1163 template<
typename MT
1165 inline typename StrictlyUpperMatrix<MT,SO,true>::ConstPointer
1166 StrictlyUpperMatrix<MT,SO,true>::data()
const
1168 return matrix_.data();
1183 template<
typename MT
1185 inline typename StrictlyUpperMatrix<MT,SO,true>::ConstPointer
1186 StrictlyUpperMatrix<MT,SO,true>::data(
size_t i )
const
1188 return matrix_.data(i);
1206 template<
typename MT
1212 return Iterator( matrix_, 0UL, i );
1214 return Iterator( matrix_, i, 0UL );
1232 template<
typename MT
1237 return matrix_.begin(i);
1255 template<
typename MT
1260 return matrix_.cbegin(i);
1278 template<
typename MT
1304 template<
typename MT
1309 return matrix_.end(i);
1327 template<
typename MT
1332 return matrix_.cend(i);
1353 template<
typename MT
1355 inline StrictlyUpperMatrix<MT,SO,true>&
1356 StrictlyUpperMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1359 for(
size_t j=1UL; j<
columns(); ++j )
1360 for(
size_t i=0UL; i<j; ++i )
1364 for(
size_t i=0UL; i<
rows(); ++i )
1365 for(
size_t j=i+1UL; j<
columns(); ++j )
1385 template<
typename MT
1387 inline StrictlyUpperMatrix<MT,SO,true>&
1388 StrictlyUpperMatrix<MT,SO,true>::operator=(
const StrictlyUpperMatrix& rhs )
1390 matrix_ = rhs.matrix_;
1414 template<
typename MT
1416 template<
typename MT2
1418 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1419 StrictlyUpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1421 if( IsUniTriangular<MT2>::value ||
1450 template<
typename MT
1452 template<
typename MT2
1454 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1455 StrictlyUpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1457 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1461 if( IsStrictlyUpper<MT2>::value ) {
1471 move( matrix_, tmp );
1496 template<
typename MT
1498 template<
typename MT2
1500 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1501 StrictlyUpperMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1503 if( IsUniTriangular<MT2>::value ||
1532 template<
typename MT
1534 template<
typename MT2
1536 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1537 StrictlyUpperMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1539 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1543 if( IsStrictlyUpper<MT2>::value ) {
1578 template<
typename MT
1580 template<
typename MT2
1582 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1583 StrictlyUpperMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1613 template<
typename MT
1615 template<
typename MT2
1617 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,true>& >::Type
1618 StrictlyUpperMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1620 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1624 if( IsStrictlyUpper<MT2>::value ) {
1658 template<
typename MT
1660 template<
typename MT2
1662 inline StrictlyUpperMatrix<MT,SO,true>&
1663 StrictlyUpperMatrix<MT,SO,true>::operator*=(
const Matrix<MT2,SO2>& rhs )
1665 if( matrix_.rows() != (~rhs).
columns() ) {
1669 MT tmp( matrix_ * ~rhs );
1675 move( matrix_, tmp );
1694 template<
typename MT
1696 template<
typename Other >
1697 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,true> >::Type&
1698 StrictlyUpperMatrix<MT,SO,true>::operator*=( Other rhs )
1714 template<
typename MT
1716 template<
typename Other >
1717 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,true> >::Type&
1718 StrictlyUpperMatrix<MT,SO,true>::operator/=( Other rhs )
1743 template<
typename MT
1747 return matrix_.rows();
1759 template<
typename MT
1763 return matrix_.columns();
1780 template<
typename MT
1784 return matrix_.spacing();
1796 template<
typename MT
1800 return matrix_.capacity();
1818 template<
typename MT
1822 return matrix_.capacity(i);
1834 template<
typename MT
1838 return matrix_.nonZeros();
1856 template<
typename MT
1860 return matrix_.nonZeros(i);
1872 template<
typename MT
1879 for(
size_t j=1UL; j<
columns(); ++j )
1880 for(
size_t i=0UL; i<j; ++i )
1881 clear( matrix_(i,j) );
1884 for(
size_t i=0UL; i<
rows(); ++i )
1885 for(
size_t j=i+1UL; j<
columns(); ++j )
1886 clear( matrix_(i,j) );
1906 template<
typename MT
1913 for(
size_t j=0UL; j<i; ++j )
1914 clear( matrix_(j,i) );
1917 for(
size_t j=i+1UL; j<
columns(); ++j )
1918 clear( matrix_(i,j) );
1937 template<
typename MT
1943 if( IsResizable<MT>::value ) {
1990 template<
typename MT
2000 const size_t oldsize( matrix_.rows() );
2002 matrix_.resize( n, n,
true );
2006 const size_t increment( n - oldsize );
2007 submatrix( matrix_, oldsize, 0UL, increment, n ).reset();
2027 template<
typename MT
2029 inline void StrictlyUpperMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2050 template<
typename MT
2052 inline void StrictlyUpperMatrix<MT,SO,true>::reserve(
size_t elements )
2054 matrix_.reserve( elements );
2067 template<
typename MT
2069 template<
typename Other >
2070 inline StrictlyUpperMatrix<MT,SO,true>&
2071 StrictlyUpperMatrix<MT,SO,true>::scale(
const Other& scalar )
2073 matrix_.scale( scalar );
2088 template<
typename MT
2094 swap( matrix_, m.matrix_ );
2112 template<
typename MT
2114 inline size_t StrictlyUpperMatrix<MT,SO,true>::maxNonZeros()
2118 return maxNonZeros( Rows<MT>::value );
2134 template<
typename MT
2136 inline size_t StrictlyUpperMatrix<MT,SO,true>::maxNonZeros(
size_t n )
2138 return ( ( n - 1UL ) * n ) / 2UL;
2162 template<
typename MT
2193 template<
typename MT
2195 template<
typename Other >
2196 inline bool StrictlyUpperMatrix<MT,SO,true>::canAlias(
const Other* alias )
const
2198 return matrix_.canAlias( alias );
2215 template<
typename MT
2217 template<
typename Other >
2218 inline bool StrictlyUpperMatrix<MT,SO,true>::isAliased(
const Other* alias )
const
2220 return matrix_.isAliased( alias );
2236 template<
typename MT
2238 inline bool StrictlyUpperMatrix<MT,SO,true>::isAligned()
const
2240 return matrix_.isAligned();
2257 template<
typename MT
2259 inline bool StrictlyUpperMatrix<MT,SO,true>::canSMPAssign()
const
2261 return matrix_.canSMPAssign();
2283 template<
typename MT
2286 StrictlyUpperMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const
2288 return matrix_.load( i, j );
2310 template<
typename MT
2315 return matrix_.loada( i, j );
2337 template<
typename MT
2342 return matrix_.loadu( i, j );
2363 template<
typename MT
2365 inline const MT StrictlyUpperMatrix<MT,SO,true>::construct(
size_t n,
TrueType )
2382 template<
typename MT
2384 inline const MT StrictlyUpperMatrix<MT,SO,true>::construct(
const ElementType& init,
FalseType )
2392 for(
size_t j=0UL; j<
columns(); ++j ) {
2393 for(
size_t i=0UL; i<j; ++i )
2398 for(
size_t i=0UL; i<
rows(); ++i ) {
2399 for(
size_t j=i+1UL; j<
columns(); ++j )
2421 template<
typename MT
2423 template<
typename MT2
2426 inline const MT StrictlyUpperMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2430 if( IsUniTriangular<MT2>::value ||
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_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
#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: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
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.
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.
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 the implementation of the base template of the StrictlyUpperMatrix.
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_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
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.