35 #ifndef _BLAZE_MATH_ADAPTORS_LOWERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_LOWERMATRIX_DENSE_H_
103 template<
typename MT
105 class LowerMatrix<MT,SO,true>
106 :
public DenseMatrix< LowerMatrix<MT,SO,true>, SO >
113 typedef IntrinsicTrait<ET> IT;
118 typedef LowerMatrix<MT,SO,true>
This;
123 typedef typename MT::IntrinsicType IntrinsicType;
128 typedef typename MT::Pointer Pointer;
129 typedef typename MT::ConstPointer ConstPointer;
136 template<
typename ET >
139 typedef LowerMatrix< typename MT::template Rebind<ET>::Other > Other;
150 typedef std::random_access_iterator_tag IteratorCategory;
152 typedef LowerProxy<MT> PointerType;
153 typedef LowerProxy<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 LowerMatrix();
584 template<
typename A1 >
explicit inline LowerMatrix(
const A1& a1 );
585 explicit inline LowerMatrix(
size_t n,
const ElementType& init );
587 explicit inline LowerMatrix( ElementType* ptr,
size_t n );
588 explicit inline LowerMatrix( ElementType* ptr,
size_t n,
size_t nn );
590 template<
typename Deleter >
591 explicit inline LowerMatrix( ElementType* ptr,
size_t n, Deleter d );
593 template<
typename Deleter >
594 explicit inline LowerMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
596 inline LowerMatrix(
const LowerMatrix& 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 LowerMatrix& operator=(
const ElementType& rhs );
626 inline LowerMatrix& operator=(
const LowerMatrix& rhs );
628 template<
typename MT2,
bool SO2 >
629 inline typename DisableIf< IsComputation<MT2>, LowerMatrix& >::Type
630 operator=(
const Matrix<MT2,SO2>& rhs );
632 template<
typename MT2,
bool SO2 >
633 inline typename EnableIf< IsComputation<MT2>, LowerMatrix& >::Type
634 operator=(
const Matrix<MT2,SO2>& rhs );
636 template<
typename MT2,
bool SO2 >
637 inline typename DisableIf< IsComputation<MT2>, LowerMatrix& >::Type
638 operator+=(
const Matrix<MT2,SO2>& rhs );
640 template<
typename MT2,
bool SO2 >
641 inline typename EnableIf< IsComputation<MT2>, LowerMatrix& >::Type
642 operator+=(
const Matrix<MT2,SO2>& rhs );
644 template<
typename MT2,
bool SO2 >
645 inline typename DisableIf< IsComputation<MT2>, LowerMatrix& >::Type
646 operator-=(
const Matrix<MT2,SO2>& rhs );
648 template<
typename MT2,
bool SO2 >
649 inline typename EnableIf< IsComputation<MT2>, LowerMatrix& >::Type
650 operator-=(
const Matrix<MT2,SO2>& rhs );
652 template<
typename MT2,
bool SO2 >
653 inline LowerMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
655 template<
typename Other >
656 inline typename EnableIf< IsNumeric<Other>, LowerMatrix >::Type&
657 operator*=( Other rhs );
659 template<
typename Other >
660 inline typename EnableIf< IsNumeric<Other>, LowerMatrix >::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 );
681 template<
typename Other >
inline LowerMatrix& scale(
const Other& scalar );
682 inline void swap( LowerMatrix& m ) ;
684 static inline size_t maxNonZeros();
685 static inline size_t maxNonZeros(
size_t n );
699 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
700 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
702 inline bool isAligned ()
const;
703 inline bool canSMPAssign()
const;
715 inline const MT construct(
size_t n ,
TrueType );
716 inline const MT construct(
const ElementType& value,
FalseType );
718 template<
typename MT2,
bool SO2,
typename T >
719 inline const MT construct(
const Matrix<MT2,SO2>& m, T );
731 template<
typename MT2,
bool SO2,
bool DF2 >
732 friend bool isDefault(
const LowerMatrix<MT2,SO2,DF2>& m );
734 template<
typename MT2,
bool SO2,
bool DF2 >
735 friend MT2& derestrict( LowerMatrix<MT2,SO2,DF2>& m );
770 template<
typename MT
772 inline LowerMatrix<MT,SO,true>::LowerMatrix()
800 template<
typename MT
802 template<
typename A1 >
803 inline LowerMatrix<MT,SO,true>::LowerMatrix(
const A1& a1 )
804 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
820 template<
typename MT
822 inline LowerMatrix<MT,SO,true>::LowerMatrix(
size_t n,
const ElementType& init )
823 : matrix_( n, n, ElementType() )
828 for(
size_t j=0UL; j<
columns(); ++j )
829 for(
size_t i=j; i<
rows(); ++i )
833 for(
size_t i=0UL; i<
rows(); ++i )
834 for(
size_t j=0UL; j<=i; ++j )
866 template<
typename MT
868 inline LowerMatrix<MT,SO,true>::LowerMatrix( ElementType* ptr,
size_t n )
869 : matrix_( ptr, n, n )
904 template<
typename MT
906 inline LowerMatrix<MT,SO,true>::LowerMatrix( ElementType* ptr,
size_t n,
size_t nn )
907 : matrix_( ptr, n, n, nn )
940 template<
typename MT
942 template<
typename Deleter >
943 inline LowerMatrix<MT,SO,true>::LowerMatrix( ElementType* ptr,
size_t n, Deleter d )
944 : matrix_( ptr, n, n, d )
978 template<
typename MT
980 template<
typename Deleter >
981 inline LowerMatrix<MT,SO,true>::LowerMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
982 : matrix_( ptr, n, n, nn, d )
1000 template<
typename MT
1002 inline LowerMatrix<MT,SO,true>::LowerMatrix(
const LowerMatrix& m )
1003 : matrix_( m.matrix_ )
1036 template<
typename MT
1039 LowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1066 template<
typename MT
1069 LowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
1074 return matrix_(i,j);
1097 template<
typename MT
1100 LowerMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1108 return (*
this)(i,j);
1131 template<
typename MT
1134 LowerMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const
1142 return (*
this)(i,j);
1161 template<
typename MT
1163 inline typename LowerMatrix<MT,SO,true>::ConstPointer
1164 LowerMatrix<MT,SO,true>::data()
const
1166 return matrix_.data();
1181 template<
typename MT
1183 inline typename LowerMatrix<MT,SO,true>::ConstPointer
1184 LowerMatrix<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 LowerMatrix<MT,SO,true>&
1354 LowerMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1357 for(
size_t j=0UL; j<
columns(); ++j )
1358 for(
size_t i=j; i<
rows(); ++i )
1362 for(
size_t i=0UL; i<
rows(); ++i )
1363 for(
size_t j=0UL; j<=i; ++j )
1383 template<
typename MT
1385 inline LowerMatrix<MT,SO,true>&
1386 LowerMatrix<MT,SO,true>::operator=(
const LowerMatrix& rhs )
1388 matrix_ = rhs.matrix_;
1412 template<
typename MT
1414 template<
typename MT2
1416 inline typename DisableIf< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >::Type
1417 LowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1419 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1447 template<
typename MT
1449 template<
typename MT2
1451 inline typename EnableIf< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >::Type
1452 LowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1454 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1458 if( IsLower<MT2>::value ) {
1468 move( matrix_, tmp );
1493 template<
typename MT
1495 template<
typename MT2
1497 inline typename DisableIf< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >::Type
1498 LowerMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1500 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1528 template<
typename MT
1530 template<
typename MT2
1532 inline typename EnableIf< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >::Type
1533 LowerMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1535 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1539 if( IsLower<MT2>::value ) {
1574 template<
typename MT
1576 template<
typename MT2
1578 inline typename DisableIf< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >::Type
1579 LowerMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1581 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1609 template<
typename MT
1611 template<
typename MT2
1613 inline typename EnableIf< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >::Type
1614 LowerMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1616 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1620 if( IsLower<MT2>::value ) {
1654 template<
typename MT
1656 template<
typename MT2
1658 inline LowerMatrix<MT,SO,true>&
1659 LowerMatrix<MT,SO,true>::operator*=(
const Matrix<MT2,SO2>& rhs )
1661 if( matrix_.rows() != (~rhs).
columns() ) {
1665 MT tmp( matrix_ * ~rhs );
1671 move( matrix_, tmp );
1690 template<
typename MT
1692 template<
typename Other >
1693 inline typename EnableIf< IsNumeric<Other>, LowerMatrix<MT,SO,true> >::Type&
1694 LowerMatrix<MT,SO,true>::operator*=( Other rhs )
1710 template<
typename MT
1712 template<
typename Other >
1713 inline typename EnableIf< IsNumeric<Other>, LowerMatrix<MT,SO,true> >::Type&
1714 LowerMatrix<MT,SO,true>::operator/=( Other rhs )
1739 template<
typename MT
1743 return matrix_.rows();
1755 template<
typename MT
1759 return matrix_.columns();
1776 template<
typename MT
1780 return matrix_.spacing();
1792 template<
typename MT
1796 return matrix_.capacity();
1814 template<
typename MT
1818 return matrix_.capacity(i);
1830 template<
typename MT
1834 return matrix_.nonZeros();
1852 template<
typename MT
1856 return matrix_.nonZeros(i);
1868 template<
typename MT
1875 for(
size_t j=0UL; j<
columns(); ++j )
1876 for(
size_t i=j; i<
rows(); ++i )
1877 clear( matrix_(i,j) );
1880 for(
size_t i=0UL; i<
rows(); ++i )
1881 for(
size_t j=0UL; j<=i; ++j )
1882 clear( matrix_(i,j) );
1902 template<
typename MT
1909 for(
size_t j=i; j<
rows(); ++j )
1910 clear( matrix_(j,i) );
1913 for(
size_t j=0UL; j<=i; ++j )
1914 clear( matrix_(i,j) );
1933 template<
typename MT
1939 if( IsResizable<MT>::value ) {
1986 template<
typename MT
1996 const size_t oldsize( matrix_.rows() );
1998 matrix_.resize( n, n,
true );
2001 const size_t increment( n - oldsize );
2002 submatrix( matrix_, 0UL, oldsize, n-1UL, increment ).reset();
2022 template<
typename MT
2024 inline void LowerMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2045 template<
typename MT
2047 inline void LowerMatrix<MT,SO,true>::reserve(
size_t elements )
2049 matrix_.reserve( elements );
2062 template<
typename MT
2064 template<
typename Other >
2065 inline LowerMatrix<MT,SO,true>& LowerMatrix<MT,SO,true>::scale(
const Other& scalar )
2067 matrix_.scale( scalar );
2082 template<
typename MT
2088 swap( matrix_, m.matrix_ );
2106 template<
typename MT
2108 inline size_t LowerMatrix<MT,SO,true>::maxNonZeros()
2112 return maxNonZeros( Rows<MT>::value );
2128 template<
typename MT
2130 inline size_t LowerMatrix<MT,SO,true>::maxNonZeros(
size_t n )
2132 return ( ( n + 1UL ) * n ) / 2UL;
2156 template<
typename MT
2187 template<
typename MT
2189 template<
typename Other >
2190 inline bool LowerMatrix<MT,SO,true>::canAlias(
const Other* alias )
const
2192 return matrix_.canAlias( alias );
2209 template<
typename MT
2211 template<
typename Other >
2212 inline bool LowerMatrix<MT,SO,true>::isAliased(
const Other* alias )
const
2214 return matrix_.isAliased( alias );
2230 template<
typename MT
2232 inline bool LowerMatrix<MT,SO,true>::isAligned()
const
2234 return matrix_.isAligned();
2251 template<
typename MT
2253 inline bool LowerMatrix<MT,SO,true>::canSMPAssign()
const
2255 return matrix_.canSMPAssign();
2277 template<
typename MT
2280 LowerMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const
2282 return matrix_.load( i, j );
2304 template<
typename MT
2309 return matrix_.loada( i, j );
2331 template<
typename MT
2336 return matrix_.loadu( i, j );
2357 template<
typename MT
2359 inline const MT LowerMatrix<MT,SO,true>::construct(
size_t n,
TrueType )
2376 template<
typename MT
2378 inline const MT LowerMatrix<MT,SO,true>::construct(
const ElementType& init,
FalseType )
2386 for(
size_t j=0UL; j<tmp.columns(); ++j )
2387 for(
size_t i=j; i<tmp.rows(); ++i )
2391 for(
size_t i=0UL; i<tmp.rows(); ++i )
2392 for(
size_t j=0UL; j<=i; ++j )
2413 template<
typename MT
2415 template<
typename MT2
2418 inline const MT LowerMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2422 if( !IsLower<MT2>::value && !
isLower( 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
#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
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
bool isLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower triangular matrix.
Definition: DenseMatrix.h:1044
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:547
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 implementation of the base template of the LowerMatrix.
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 LowerProxy 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
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 IsNumeric type trait.
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.