35 #ifndef _BLAZE_MATH_ADAPTORS_UPPERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_UPPERMATRIX_DENSE_H_
101 template<
typename MT
103 class UpperMatrix<MT,SO,true>
104 :
public DenseMatrix< UpperMatrix<MT,SO,true>, SO >
111 typedef IntrinsicTrait<ET> IT;
116 typedef UpperMatrix<MT,SO,true>
This;
121 typedef typename MT::IntrinsicType IntrinsicType;
126 typedef typename MT::Pointer Pointer;
127 typedef typename MT::ConstPointer ConstPointer;
134 template<
typename ET >
137 typedef UpperMatrix< typename MT::template Rebind<ET>::Other > Other;
148 typedef std::random_access_iterator_tag IteratorCategory;
150 typedef UpperProxy<MT> PointerType;
151 typedef UpperProxy<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 UpperMatrix();
582 template<
typename A1 >
explicit inline UpperMatrix(
const A1& a1 );
583 explicit inline UpperMatrix(
size_t n,
const ElementType& init );
584 inline UpperMatrix(
const UpperMatrix& 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 UpperMatrix& operator=(
const ElementType& rhs );
612 inline UpperMatrix& operator=(
const UpperMatrix& rhs );
614 template<
typename MT2,
bool SO2 >
615 inline typename DisableIf< IsComputation<MT2>, UpperMatrix& >::Type
616 operator=(
const Matrix<MT2,SO2>& rhs );
618 template<
typename MT2,
bool SO2 >
619 inline typename EnableIf< IsComputation<MT2>, UpperMatrix& >::Type
620 operator=(
const Matrix<MT2,SO2>& rhs );
622 template<
typename MT2,
bool SO2 >
623 inline typename DisableIf< IsComputation<MT2>, UpperMatrix& >::Type
624 operator+=(
const Matrix<MT2,SO2>& rhs );
626 template<
typename MT2,
bool SO2 >
627 inline typename EnableIf< IsComputation<MT2>, UpperMatrix& >::Type
628 operator+=(
const Matrix<MT2,SO2>& rhs );
630 template<
typename MT2,
bool SO2 >
631 inline typename DisableIf< IsComputation<MT2>, UpperMatrix& >::Type
632 operator-=(
const Matrix<MT2,SO2>& rhs );
634 template<
typename MT2,
bool SO2 >
635 inline typename EnableIf< IsComputation<MT2>, UpperMatrix& >::Type
636 operator-=(
const Matrix<MT2,SO2>& rhs );
638 template<
typename MT2,
bool SO2 >
639 inline UpperMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
641 template<
typename Other >
642 inline typename EnableIf< IsNumeric<Other>, UpperMatrix >::Type&
643 operator*=( Other rhs );
645 template<
typename Other >
646 inline typename EnableIf< IsNumeric<Other>, UpperMatrix >::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 );
667 template<
typename Other >
inline UpperMatrix& scale(
const Other& scalar );
668 inline void swap( UpperMatrix& m ) ;
670 static inline size_t maxNonZeros();
671 static inline size_t maxNonZeros(
size_t n );
678 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
679 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
681 inline bool isAligned ()
const;
682 inline bool canSMPAssign()
const;
693 inline const MT construct(
size_t n ,
TrueType );
694 inline const MT construct(
const ElementType& value,
FalseType );
696 template<
typename MT2,
bool SO2,
typename T >
697 inline const MT construct(
const Matrix<MT2,SO2>& m, T );
709 template<
typename MT2,
bool SO2,
bool DF2 >
710 friend bool isDefault(
const UpperMatrix<MT2,SO2,DF2>& m );
712 template<
typename MT2,
bool SO2,
bool DF2 >
713 friend MT2& derestrict( UpperMatrix<MT2,SO2,DF2>& m );
747 template<
typename MT
749 inline UpperMatrix<MT,SO,true>::UpperMatrix()
776 template<
typename MT
778 template<
typename A1 >
779 inline UpperMatrix<MT,SO,true>::UpperMatrix(
const A1& a1 )
780 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
795 template<
typename MT
797 inline UpperMatrix<MT,SO,true>::UpperMatrix(
size_t n,
const ElementType& init )
798 : matrix_( n, n, ElementType() )
803 for(
size_t j=0UL; j<
columns(); ++j )
804 for(
size_t i=0UL; i<=j; ++i )
808 for(
size_t i=0UL; i<
rows(); ++i )
809 for(
size_t j=i; j<
columns(); ++j )
825 template<
typename MT
827 inline UpperMatrix<MT,SO,true>::UpperMatrix(
const UpperMatrix& m )
828 : matrix_( m.matrix_ )
857 template<
typename MT
860 UpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
884 template<
typename MT
887 UpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
911 template<
typename MT
913 inline typename UpperMatrix<MT,SO,true>::ConstPointer
914 UpperMatrix<MT,SO,true>::data()
const
916 return matrix_.data();
931 template<
typename MT
933 inline typename UpperMatrix<MT,SO,true>::ConstPointer
934 UpperMatrix<MT,SO,true>::data(
size_t i )
const
936 return matrix_.data(i);
954 template<
typename MT
980 template<
typename MT
985 return matrix_.begin(i);
1003 template<
typename MT
1008 return matrix_.cbegin(i);
1026 template<
typename MT
1052 template<
typename MT
1057 return matrix_.end(i);
1075 template<
typename MT
1080 return matrix_.cend(i);
1101 template<
typename MT
1103 inline UpperMatrix<MT,SO,true>&
1104 UpperMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1107 for(
size_t j=0UL; j<
columns(); ++j )
1108 for(
size_t i=0UL; i<=j; ++i )
1112 for(
size_t i=0UL; i<
rows(); ++i )
1113 for(
size_t j=i; j<
columns(); ++j )
1133 template<
typename MT
1135 inline UpperMatrix<MT,SO,true>&
1136 UpperMatrix<MT,SO,true>::operator=(
const UpperMatrix& rhs )
1138 matrix_ = rhs.matrix_;
1159 template<
typename MT
1161 template<
typename MT2
1163 inline typename DisableIf< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >::Type
1164 UpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1166 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) )
1167 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1190 template<
typename MT
1192 template<
typename MT2
1194 inline typename EnableIf< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >::Type
1195 UpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1197 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1198 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1200 if( IsUpper<MT2>::value ) {
1207 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1209 move( matrix_, tmp );
1231 template<
typename MT
1233 template<
typename MT2
1235 inline typename DisableIf< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >::Type
1236 UpperMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1238 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) )
1239 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1262 template<
typename MT
1264 template<
typename MT2
1266 inline typename EnableIf< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >::Type
1267 UpperMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1269 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1270 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1272 if( IsUpper<MT2>::value ) {
1279 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1303 template<
typename MT
1305 template<
typename MT2
1307 inline typename DisableIf< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >::Type
1308 UpperMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1310 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) )
1311 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1334 template<
typename MT
1336 template<
typename MT2
1338 inline typename EnableIf< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >::Type
1339 UpperMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1341 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1342 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1344 if( IsUpper<MT2>::value ) {
1351 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1374 template<
typename MT
1376 template<
typename MT2
1378 inline UpperMatrix<MT,SO,true>&
1379 UpperMatrix<MT,SO,true>::operator*=(
const Matrix<MT2,SO2>& rhs )
1381 if( matrix_.rows() != (~rhs).
columns() )
1382 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1384 MT tmp( matrix_ * ~rhs );
1387 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
1389 move( matrix_, tmp );
1405 template<
typename MT
1407 template<
typename Other >
1408 inline typename EnableIf< IsNumeric<Other>, UpperMatrix<MT,SO,true> >::Type&
1409 UpperMatrix<MT,SO,true>::operator*=( Other rhs )
1425 template<
typename MT
1427 template<
typename Other >
1428 inline typename EnableIf< IsNumeric<Other>, UpperMatrix<MT,SO,true> >::Type&
1429 UpperMatrix<MT,SO,true>::operator/=( Other rhs )
1454 template<
typename MT
1458 return matrix_.rows();
1470 template<
typename MT
1474 return matrix_.columns();
1491 template<
typename MT
1495 return matrix_.spacing();
1507 template<
typename MT
1511 return matrix_.capacity();
1529 template<
typename MT
1533 return matrix_.capacity(i);
1545 template<
typename MT
1549 return matrix_.nonZeros();
1567 template<
typename MT
1571 return matrix_.nonZeros(i);
1583 template<
typename MT
1590 for(
size_t j=0UL; j<
columns(); ++j )
1591 for(
size_t i=0UL; i<=j; ++i )
1592 clear( matrix_(i,j) );
1595 for(
size_t i=0UL; i<
rows(); ++i )
1596 for(
size_t j=i; j<
columns(); ++j )
1597 clear( matrix_(i,j) );
1617 template<
typename MT
1624 for(
size_t j=0UL; j<=i; ++j )
1625 clear( matrix_(j,i) );
1628 for(
size_t j=i; j<
columns(); ++j )
1629 clear( matrix_(i,j) );
1648 template<
typename MT
1654 if( IsResizable<MT>::value ) {
1701 template<
typename MT
1711 const size_t oldsize( matrix_.rows() );
1713 matrix_.resize( n, n,
true );
1716 const size_t increment( n - oldsize );
1717 submatrix( matrix_, oldsize, 0UL, increment, n-1 ).reset();
1737 template<
typename MT
1739 inline void UpperMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
1760 template<
typename MT
1762 inline void UpperMatrix<MT,SO,true>::reserve(
size_t elements )
1764 matrix_.reserve( elements );
1777 template<
typename MT
1779 template<
typename Other >
1780 inline UpperMatrix<MT,SO,true>& UpperMatrix<MT,SO,true>::scale(
const Other& scalar )
1782 matrix_.scale( scalar );
1797 template<
typename MT
1803 swap( matrix_, m.matrix_ );
1821 template<
typename MT
1823 inline size_t UpperMatrix<MT,SO,true>::maxNonZeros()
1827 return maxNonZeros( Rows<MT>::value );
1843 template<
typename MT
1845 inline size_t UpperMatrix<MT,SO,true>::maxNonZeros(
size_t n )
1847 return ( ( n + 1UL ) * n ) / 2UL;
1872 template<
typename MT
1874 template<
typename Other >
1875 inline bool UpperMatrix<MT,SO,true>::canAlias(
const Other* alias )
const
1877 return matrix_.canAlias( alias );
1894 template<
typename MT
1896 template<
typename Other >
1897 inline bool UpperMatrix<MT,SO,true>::isAliased(
const Other* alias )
const
1899 return matrix_.isAliased( alias );
1915 template<
typename MT
1917 inline bool UpperMatrix<MT,SO,true>::isAligned()
const
1919 return matrix_.isAligned();
1936 template<
typename MT
1938 inline bool UpperMatrix<MT,SO,true>::canSMPAssign()
const
1940 return matrix_.canSMPAssign();
1962 template<
typename MT
1967 return matrix_.load( i, j );
1989 template<
typename MT
1994 return matrix_.loadu( i, j );
2015 template<
typename MT
2017 inline const MT UpperMatrix<MT,SO,true>::construct(
size_t n,
TrueType )
2034 template<
typename MT
2036 inline const MT UpperMatrix<MT,SO,true>::construct(
const ElementType& init,
FalseType )
2044 for(
size_t j=0UL; j<
columns(); ++j )
2045 for(
size_t i=0UL; i<=j; ++i )
2049 for(
size_t i=0UL; i<
rows(); ++i )
2050 for(
size_t j=i; j<
columns(); ++j )
2071 template<
typename MT
2073 template<
typename MT2
2076 inline const MT UpperMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2080 if( !IsUpper<MT2>::value && !
isUpper( tmp ) )
2081 throw std::invalid_argument(
"Invalid setup of upper matrix" );
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
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
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:861
Constraint on the data type.
Header file for the implementation of the base template of the UpperMatrix.
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 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
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2504
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1197
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
Header file for the UpperProxy class.
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
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 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: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
Header file for the IsUpper type trait.
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.