35 #ifndef _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_DENSE_H_
101 class DiagonalMatrix<MT,SO,true>
102 :
public DenseMatrix< DiagonalMatrix<MT,SO,true>, SO >
109 typedef IntrinsicTrait<ET> IT;
114 typedef DiagonalMatrix<MT,SO,true>
This;
119 typedef typename MT::IntrinsicType IntrinsicType;
124 typedef typename MT::Pointer Pointer;
125 typedef typename MT::ConstPointer ConstPointer;
132 template<
typename ET >
135 typedef DiagonalMatrix< typename MT::template Rebind<ET>::Other > Other;
146 typedef std::random_access_iterator_tag IteratorCategory;
148 typedef DiagonalProxy<MT> PointerType;
149 typedef DiagonalProxy<MT> ReferenceType;
150 typedef ptrdiff_t DifferenceType;
153 typedef IteratorCategory iterator_category;
154 typedef ValueType value_type;
155 typedef PointerType pointer;
156 typedef ReferenceType reference;
157 typedef DifferenceType difference_type;
190 inline Iterator& operator+=(
size_t inc ) {
191 ( SO )?( row_ += inc ):( column_ += inc );
202 inline Iterator& operator-=(
size_t dec ) {
203 ( SO )?( row_ -= dec ):( column_ -= dec );
214 ( SO )?( ++row_ ):( ++column_ );
224 inline const Iterator operator++(
int ) {
237 ( SO )?( --row_ ):( --column_ );
247 inline const Iterator operator--(
int ) {
260 return ReferenceType( *matrix_, row_, column_ );
269 inline PointerType operator->()
const {
270 return PointerType( *matrix_, row_, column_ );
281 return matrix_->begin( column_ ) + row_;
283 return matrix_->begin( row_ ) + column_;
295 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
331 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
367 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
403 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
439 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
475 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
510 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
523 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
525 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
538 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
540 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
553 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
555 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
570 enum { vectorizable = MT::vectorizable };
573 enum { smpAssignable = MT::smpAssignable };
579 explicit inline DiagonalMatrix();
580 template<
typename A1 >
explicit inline DiagonalMatrix(
const A1& a1 );
581 explicit inline DiagonalMatrix(
size_t n,
const ElementType& init );
582 inline DiagonalMatrix(
const DiagonalMatrix& m );
593 inline Reference operator()(
size_t i,
size_t j );
594 inline ConstReference operator()(
size_t i,
size_t j )
const;
595 inline ConstPointer data ()
const;
596 inline ConstPointer data (
size_t i )
const;
598 inline ConstIterator
begin (
size_t i )
const;
599 inline ConstIterator
cbegin(
size_t i )
const;
601 inline ConstIterator
end (
size_t i )
const;
602 inline ConstIterator
cend (
size_t i )
const;
609 inline DiagonalMatrix& operator=(
const ElementType& rhs );
610 inline DiagonalMatrix& operator=(
const DiagonalMatrix& rhs );
612 template<
typename MT2,
bool SO2 >
613 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
614 operator=(
const Matrix<MT2,SO2>& rhs );
616 template<
typename MT2,
bool SO2 >
617 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
618 operator=(
const Matrix<MT2,SO2>& rhs );
620 template<
typename MT2,
bool SO2 >
621 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
622 operator+=(
const Matrix<MT2,SO2>& rhs );
624 template<
typename MT2,
bool SO2 >
625 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
626 operator+=(
const Matrix<MT2,SO2>& rhs );
628 template<
typename MT2,
bool SO2 >
629 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
630 operator-=(
const Matrix<MT2,SO2>& rhs );
632 template<
typename MT2,
bool SO2 >
633 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
634 operator-=(
const Matrix<MT2,SO2>& rhs );
636 template<
typename MT2,
bool SO2 >
637 inline DiagonalMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
639 template<
typename Other >
640 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix >::Type&
641 operator*=( Other rhs );
643 template<
typename Other >
644 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix >::Type&
645 operator/=( Other rhs );
652 inline size_t rows()
const;
656 inline size_t capacity(
size_t i )
const;
658 inline size_t nonZeros(
size_t i )
const;
660 inline void reset(
size_t i );
662 void resize (
size_t n,
bool preserve=
true );
663 inline void extend (
size_t n,
bool preserve=
true );
664 inline void reserve(
size_t elements );
665 template<
typename Other >
inline DiagonalMatrix& scale(
const Other& scalar );
666 inline void swap( DiagonalMatrix& m ) ;
673 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
674 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
676 inline bool isAligned ()
const;
677 inline bool canSMPAssign()
const;
688 inline const MT construct(
size_t n ,
TrueType );
689 inline const MT construct(
const ElementType& value,
FalseType );
691 template<
typename MT2,
bool SO2,
typename T >
692 inline const MT construct(
const Matrix<MT2,SO2>& m, T );
704 template<
typename MT2,
bool SO2,
bool DF2 >
705 friend bool isDefault(
const DiagonalMatrix<MT2,SO2,DF2>& m );
707 template<
typename MT2,
bool SO2,
bool DF2 >
708 friend MT2& derestrict( DiagonalMatrix<MT2,SO2,DF2>& m );
742 template<
typename MT
744 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix()
771 template<
typename MT
773 template<
typename A1 >
774 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
const A1& a1 )
775 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
790 template<
typename MT
792 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
size_t n,
const ElementType& init )
793 : matrix_( n, n, ElementType() )
797 for(
size_t i=0UL; i<n; ++i )
812 template<
typename MT
814 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
const DiagonalMatrix& m )
815 : matrix_( m.matrix_ )
844 template<
typename MT
847 DiagonalMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
871 template<
typename MT
874 DiagonalMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
898 template<
typename MT
900 inline typename DiagonalMatrix<MT,SO,true>::ConstPointer
901 DiagonalMatrix<MT,SO,true>::data()
const
903 return matrix_.data();
918 template<
typename MT
920 inline typename DiagonalMatrix<MT,SO,true>::ConstPointer
921 DiagonalMatrix<MT,SO,true>::data(
size_t i )
const
923 return matrix_.data(i);
941 template<
typename MT
967 template<
typename MT
972 return matrix_.begin(i);
990 template<
typename MT
995 return matrix_.cbegin(i);
1013 template<
typename MT
1039 template<
typename MT
1044 return matrix_.end(i);
1062 template<
typename MT
1067 return matrix_.cend(i);
1088 template<
typename MT
1090 inline DiagonalMatrix<MT,SO,true>&
1091 DiagonalMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1094 for(
size_t j=0UL; j<
columns(); ++j )
1098 for(
size_t i=0UL; i<
rows(); ++i )
1118 template<
typename MT
1120 inline DiagonalMatrix<MT,SO,true>&
1121 DiagonalMatrix<MT,SO,true>::operator=(
const DiagonalMatrix& rhs )
1123 matrix_ = rhs.matrix_;
1144 template<
typename MT
1146 template<
typename MT2
1148 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >::Type
1149 DiagonalMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1151 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) )
1152 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1175 template<
typename MT
1177 template<
typename MT2
1179 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >::Type
1180 DiagonalMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1182 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1183 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1185 if( IsDiagonal<MT2>::value ) {
1192 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1194 move( matrix_, tmp );
1216 template<
typename MT
1218 template<
typename MT2
1220 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >::Type
1221 DiagonalMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1223 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) )
1224 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1247 template<
typename MT
1249 template<
typename MT2
1251 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >::Type
1252 DiagonalMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1254 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1255 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1257 if( IsDiagonal<MT2>::value ) {
1264 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1288 template<
typename MT
1290 template<
typename MT2
1292 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >::Type
1293 DiagonalMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1295 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) )
1296 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1319 template<
typename MT
1321 template<
typename MT2
1323 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >::Type
1324 DiagonalMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1326 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1327 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1329 if( IsDiagonal<MT2>::value ) {
1336 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1359 template<
typename MT
1361 template<
typename MT2
1363 inline DiagonalMatrix<MT,SO,true>&
1364 DiagonalMatrix<MT,SO,true>::operator*=(
const Matrix<MT2,SO2>& rhs )
1366 if( matrix_.rows() != (~rhs).
columns() )
1367 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1369 MT tmp( matrix_ * ~rhs );
1372 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
1374 move( matrix_, tmp );
1390 template<
typename MT
1392 template<
typename Other >
1393 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix<MT,SO,true> >::Type&
1394 DiagonalMatrix<MT,SO,true>::operator*=( Other rhs )
1410 template<
typename MT
1412 template<
typename Other >
1413 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix<MT,SO,true> >::Type&
1414 DiagonalMatrix<MT,SO,true>::operator/=( Other rhs )
1439 template<
typename MT
1443 return matrix_.rows();
1455 template<
typename MT
1459 return matrix_.columns();
1476 template<
typename MT
1480 return matrix_.spacing();
1492 template<
typename MT
1496 return matrix_.capacity();
1514 template<
typename MT
1518 return matrix_.capacity(i);
1530 template<
typename MT
1534 return matrix_.nonZeros();
1552 template<
typename MT
1556 return matrix_.nonZeros(i);
1568 template<
typename MT
1591 template<
typename MT
1613 template<
typename MT
1661 template<
typename MT
1671 const size_t oldsize( matrix_.rows() );
1673 matrix_.resize( n, n,
true );
1676 const size_t increment( n - oldsize );
1677 submatrix( matrix_, 0UL, oldsize, n, increment ).reset();
1678 submatrix( matrix_, oldsize, 0UL, increment, increment ).reset();
1698 template<
typename MT
1700 inline void DiagonalMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
1721 template<
typename MT
1723 inline void DiagonalMatrix<MT,SO,true>::reserve(
size_t elements )
1725 matrix_.reserve( elements );
1738 template<
typename MT
1740 template<
typename Other >
1741 inline DiagonalMatrix<MT,SO,true>& DiagonalMatrix<MT,SO,true>::scale(
const Other& scalar )
1743 matrix_.scale( scalar );
1758 template<
typename MT
1764 swap( matrix_, m.matrix_ );
1789 template<
typename MT
1791 template<
typename Other >
1792 inline bool DiagonalMatrix<MT,SO,true>::canAlias(
const Other* alias )
const
1794 return matrix_.canAlias( alias );
1811 template<
typename MT
1813 template<
typename Other >
1814 inline bool DiagonalMatrix<MT,SO,true>::isAliased(
const Other* alias )
const
1816 return matrix_.isAliased( alias );
1832 template<
typename MT
1834 inline bool DiagonalMatrix<MT,SO,true>::isAligned()
const
1836 return matrix_.isAligned();
1853 template<
typename MT
1855 inline bool DiagonalMatrix<MT,SO,true>::canSMPAssign()
const
1857 return matrix_.canSMPAssign();
1879 template<
typename MT
1884 return matrix_.load( i, j );
1906 template<
typename MT
1911 return matrix_.loadu( i, j );
1932 template<
typename MT
1934 inline const MT DiagonalMatrix<MT,SO,true>::construct(
size_t n,
TrueType )
1951 template<
typename MT
1953 inline const MT DiagonalMatrix<MT,SO,true>::construct(
const ElementType& init,
FalseType )
1960 for(
size_t i=0UL; i<tmp.rows(); ++i )
1980 template<
typename MT
1982 template<
typename MT2
1985 inline const MT DiagonalMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
1989 if( !IsDiagonal<MT2>::value && !
isDiagonal( tmp ) )
1990 throw std::invalid_argument(
"Invalid setup of diagonal 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
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:1431
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
Header file for the IsDiagonal type trait.
#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
Header file for the implementation of the base template of the DiagonalMatrix.
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 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 DiagonalProxy class.
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
Constraints on the storage order of matrix types.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a upper triangular matrix type...
Definition: Upper.h:118
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:195
BLAZE_ALWAYS_INLINE void resize(Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true)
Changing the size of the matrix.
Definition: Matrix.h:535
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2509
Header file for the EnableIf class template.
Header file for utility functions for dense matrices.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:841
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.
const bool spacing
Adding an additional spacing line between two log messages.This setting gives the opportunity to add ...
Definition: Logging.h:70
DisableIf< Or< IsComputation< MT >, IsTransExpr< MT > >, typename RowExprTrait< MT >::Type >::Type row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:103
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:116
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2506
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:118
void move(DynamicMatrix< Type, SO > &dst, DynamicMatrix< Type, SO > &src)
Moving the contents of one dynamic matrix to another.
Definition: DynamicMatrix.h:4934
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:116
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2510
Header file for the isDefault shim.
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is resizable, i.e. has a 'resize' member fu...
Definition: Resizable.h:118
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b)
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:200
Header file for all intrinsic functionality.
Header file for the move shim.
SubmatrixExprTrait< MT, unaligned >::Type submatrix(Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n)
Creating a view on a specific submatrix of the given matrix.
Definition: Submatrix.h:143
bool operator<(const NegativeAccuracy< A > &lhs, const T &rhs)
Less-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:328
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is not resizable, i.e. does not have a 'res...
Definition: Resizable.h:79
Header file for the IsComputation type trait class.
boost::false_type FalseType
Type/value traits base class.The FalseType class is used as base class for type traits and value trai...
Definition: FalseType.h:61
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)
Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from ...
Definition: Expression.h:118
bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:249
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2508
boost::true_type TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: TrueType.h:61
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:143
Header file for the IsResizable type trait.
System settings for the inline keywords.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for the TrueType type/value trait base class.