35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_SPARSE_H_
97 class StrictlyUpperMatrix<MT,SO,false>
98 :
public SparseMatrix< StrictlyUpperMatrix<MT,SO,false>, SO >
109 typedef StrictlyUpperMatrix<MT,SO,false>
This;
116 typedef StrictlyUpperProxy<MT>
Reference;
125 template<
typename ET >
128 typedef StrictlyUpperMatrix< typename MT::template Rebind<ET>::Other > Other;
134 enum { smpAssignable = 0 };
140 explicit inline StrictlyUpperMatrix();
141 explicit inline StrictlyUpperMatrix(
size_t n );
142 explicit inline StrictlyUpperMatrix(
size_t n,
size_t nonzeros );
143 explicit inline StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
145 inline StrictlyUpperMatrix(
const StrictlyUpperMatrix& m );
146 template<
typename MT2,
bool SO2 >
inline StrictlyUpperMatrix(
const Matrix<MT2,SO2>& m );
157 inline Reference operator()(
size_t i,
size_t j );
158 inline ConstReference operator()(
size_t i,
size_t j )
const;
159 inline Iterator
begin (
size_t i );
160 inline ConstIterator
begin (
size_t i )
const;
161 inline ConstIterator
cbegin(
size_t i )
const;
162 inline Iterator
end (
size_t i );
163 inline ConstIterator
end (
size_t i )
const;
164 inline ConstIterator
cend (
size_t i )
const;
171 inline StrictlyUpperMatrix& operator=(
const StrictlyUpperMatrix& rhs );
173 template<
typename MT2,
bool SO2 >
174 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
175 operator=(
const Matrix<MT2,SO2>& rhs );
177 template<
typename MT2,
bool SO2 >
178 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
179 operator=(
const Matrix<MT2,SO2>& rhs );
181 template<
typename MT2,
bool SO2 >
182 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
183 operator+=(
const Matrix<MT2,SO2>& rhs );
185 template<
typename MT2,
bool SO2 >
186 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
187 operator+=(
const Matrix<MT2,SO2>& rhs );
189 template<
typename MT2,
bool SO2 >
190 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
191 operator-=(
const Matrix<MT2,SO2>& rhs );
193 template<
typename MT2,
bool SO2 >
194 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
195 operator-=(
const Matrix<MT2,SO2>& rhs );
197 template<
typename MT2,
bool SO2 >
198 inline StrictlyUpperMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
200 template<
typename Other >
201 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix >::Type&
202 operator*=( Other rhs );
204 template<
typename Other >
205 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix >::Type&
206 operator/=( Other rhs );
213 inline size_t rows()
const;
216 inline size_t capacity(
size_t i )
const;
218 inline size_t nonZeros(
size_t i )
const;
220 inline void reset(
size_t i );
222 inline Iterator
set(
size_t i,
size_t j,
const ElementType& value );
223 inline Iterator insert(
size_t i,
size_t j,
const ElementType& value );
224 inline void erase(
size_t i,
size_t j );
225 inline Iterator erase(
size_t i, Iterator pos );
226 inline Iterator erase(
size_t i, Iterator first, Iterator last );
227 inline void resize (
size_t n,
bool preserve=
true );
228 inline void reserve(
size_t nonzeros );
229 inline void reserve(
size_t i,
size_t nonzeros );
231 inline void trim(
size_t i );
233 template<
typename Other >
inline StrictlyUpperMatrix& scale(
const Other& scalar );
234 template<
typename Other >
inline StrictlyUpperMatrix& scaleDiagonal( Other scale );
236 inline void swap( StrictlyUpperMatrix& m ) ;
238 static inline size_t maxNonZeros();
239 static inline size_t maxNonZeros(
size_t n );
246 inline Iterator find (
size_t i,
size_t j );
247 inline ConstIterator find (
size_t i,
size_t j )
const;
248 inline Iterator lowerBound(
size_t i,
size_t j );
249 inline ConstIterator lowerBound(
size_t i,
size_t j )
const;
250 inline Iterator upperBound(
size_t i,
size_t j );
251 inline ConstIterator upperBound(
size_t i,
size_t j )
const;
258 inline void append (
size_t i,
size_t j,
const ElementType& value,
bool check=
false );
259 inline void finalize(
size_t i );
266 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
267 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
269 inline bool canSMPAssign()
const;
277 inline void resetLower();
289 template<
typename MT2,
bool SO2,
bool DF2 >
290 friend MT2& derestrict( StrictlyUpperMatrix<MT2,SO2,DF2>& m );
324 template<
typename MT
326 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix()
343 template<
typename MT
345 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n )
366 template<
typename MT
368 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
size_t nonzeros )
369 : matrix_( n, n,
max( nonzeros, n ) )
393 template<
typename MT
395 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
396 : matrix_( n, n, nonzeros )
412 template<
typename MT
414 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const StrictlyUpperMatrix& m )
415 : matrix_( m.matrix_ )
434 template<
typename MT
436 template<
typename MT2
438 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const Matrix<MT2,SO2>& m )
441 if( IsUniTriangular<MT2>::value ||
443 throw std::invalid_argument(
"Invalid setup of strictly upper matrix" );
445 if( !IsStrictlyUpper<MT2>::value )
474 template<
typename MT
477 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
500 template<
typename MT
503 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
526 template<
typename MT
531 return matrix_.begin(i);
549 template<
typename MT
554 return matrix_.begin(i);
572 template<
typename MT
577 return matrix_.cbegin(i);
595 template<
typename MT
600 return matrix_.end(i);
618 template<
typename MT
623 return matrix_.end(i);
641 template<
typename MT
646 return matrix_.cend(i);
670 template<
typename MT
672 inline StrictlyUpperMatrix<MT,SO,false>&
673 StrictlyUpperMatrix<MT,SO,false>::operator=(
const StrictlyUpperMatrix& rhs )
675 matrix_ = rhs.matrix_;
696 template<
typename MT
698 template<
typename MT2
700 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
701 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
703 if( IsUniTriangular<MT2>::value ||
705 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
709 if( !IsStrictlyUpper<MT2>::value )
731 template<
typename MT
733 template<
typename MT2
735 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
736 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
738 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
739 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
741 if( IsStrictlyUpper<MT2>::value ) {
748 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
750 move( matrix_, tmp );
753 if( !IsStrictlyUpper<MT2>::value )
775 template<
typename MT
777 template<
typename MT2
779 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
780 StrictlyUpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
782 if( IsUniTriangular<MT2>::value ||
784 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
788 if( !IsStrictlyUpper<MT2>::value )
810 template<
typename MT
812 template<
typename MT2
814 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
815 StrictlyUpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
817 if( IsUniTriangular<MT2>::value || ( IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
818 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
820 if( IsStrictlyUpper<MT2>::value ) {
827 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
832 if( !IsStrictlyUpper<MT2>::value )
854 template<
typename MT
856 template<
typename MT2
858 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
859 StrictlyUpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
861 if( IsUniTriangular<MT2>::value ||
863 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
867 if( !IsStrictlyUpper<MT2>::value )
889 template<
typename MT
891 template<
typename MT2
893 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
894 StrictlyUpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
896 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
897 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
899 if( IsStrictlyUpper<MT2>::value ) {
906 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
911 if( !IsStrictlyUpper<MT2>::value )
932 template<
typename MT
934 template<
typename MT2
936 inline StrictlyUpperMatrix<MT,SO,false>&
937 StrictlyUpperMatrix<MT,SO,false>::operator*=(
const Matrix<MT2,SO2>& rhs )
939 if( matrix_.rows() != (~rhs).
columns() )
940 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
942 MT tmp( matrix_ * ~rhs );
945 throw std::invalid_argument(
"Invalid assignment to strictly upper matrix" );
947 move( matrix_, tmp );
949 if( !IsStrictlyUpper<MT2>::value )
966 template<
typename MT
968 template<
typename Other >
969 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,false> >::Type&
970 StrictlyUpperMatrix<MT,SO,false>::operator*=( Other rhs )
986 template<
typename MT
988 template<
typename Other >
989 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,false> >::Type&
990 StrictlyUpperMatrix<MT,SO,false>::operator/=( Other rhs )
1015 template<
typename MT
1019 return matrix_.rows();
1031 template<
typename MT
1035 return matrix_.columns();
1047 template<
typename MT
1051 return matrix_.capacity();
1069 template<
typename MT
1073 return matrix_.capacity(i);
1085 template<
typename MT
1089 return matrix_.nonZeros();
1107 template<
typename MT
1111 return matrix_.nonZeros(i);
1123 template<
typename MT
1128 for(
size_t j=1UL; j<
columns(); ++j ) {
1129 matrix_.erase( j, matrix_.begin(j), matrix_.lowerBound(j,j) );
1133 for(
size_t i=0UL; i<
rows(); ++i ) {
1134 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1155 template<
typename MT
1160 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1163 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1178 template<
typename MT
1184 if( IsResizable<MT>::value ) {
1211 template<
typename MT
1217 throw std::invalid_argument(
"Invalid access to diagonal or lower matrix element" );
1219 return matrix_.set( i, j, value );
1242 template<
typename MT
1245 StrictlyUpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1248 throw std::invalid_argument(
"Invalid access to diagonal or lower matrix element" );
1250 return matrix_.insert( i, j, value );
1266 template<
typename MT
1268 inline void StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1270 matrix_.erase( i, j );
1288 template<
typename MT
1291 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1293 return matrix_.erase( i, pos );
1313 template<
typename MT
1316 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1318 return matrix_.erase( i, first, last );
1339 template<
typename MT
1347 matrix_.resize( n, n, preserve );
1364 template<
typename MT
1366 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1368 matrix_.reserve( nonzeros );
1389 template<
typename MT
1391 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1393 matrix_.reserve( i, nonzeros );
1410 template<
typename MT
1412 inline void StrictlyUpperMatrix<MT,SO,false>::trim()
1432 template<
typename MT
1434 inline void StrictlyUpperMatrix<MT,SO,false>::trim(
size_t i )
1449 template<
typename MT
1451 template<
typename Other >
1452 inline StrictlyUpperMatrix<MT,SO,false>&
1453 StrictlyUpperMatrix<MT,SO,false>::scale(
const Other& scalar )
1455 matrix_.scale( scalar );
1469 template<
typename MT
1471 template<
typename Other >
1472 inline StrictlyUpperMatrix<MT,SO,false>&
1473 StrictlyUpperMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1475 matrix_.scaleDiagonal( scalar );
1490 template<
typename MT
1496 swap( matrix_, m.matrix_ );
1514 template<
typename MT
1516 inline size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros()
1520 return maxNonZeros( Rows<MT>::value );
1536 template<
typename MT
1538 inline size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros(
size_t n )
1540 return ( ( n - 1UL ) * n ) / 2UL;
1552 template<
typename MT
1554 inline void StrictlyUpperMatrix<MT,SO,false>::resetLower()
1557 for(
size_t j=0UL; j<
columns(); ++j )
1558 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1561 for(
size_t i=1UL; i<
rows(); ++i )
1562 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1593 template<
typename MT
1596 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1598 return matrix_.find( i, j );
1620 template<
typename MT
1623 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1625 return matrix_.find( i, j );
1647 template<
typename MT
1650 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1652 return matrix_.lowerBound( i, j );
1674 template<
typename MT
1677 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1679 return matrix_.lowerBound( i, j );
1701 template<
typename MT
1704 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1706 return matrix_.upperBound( i, j );
1728 template<
typename MT
1731 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1733 return matrix_.upperBound( i, j );
1797 template<
typename MT
1799 inline void StrictlyUpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1802 throw std::invalid_argument(
"Invalid access to diagonal or lower matrix element" );
1804 matrix_.append( i, j, value, check );
1824 template<
typename MT
1826 inline void StrictlyUpperMatrix<MT,SO,false>::finalize(
size_t i )
1828 matrix_.finalize( i );
1853 template<
typename MT
1855 template<
typename Other >
1856 inline bool StrictlyUpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const
1858 return matrix_.canAlias( alias );
1875 template<
typename MT
1877 template<
typename Other >
1878 inline bool StrictlyUpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const
1880 return matrix_.isAliased( alias );
1897 template<
typename MT
1899 inline bool StrictlyUpperMatrix<MT,SO,false>::canSMPAssign()
const
1901 return matrix_.canSMPAssign();
Header file for the StrictlyUpperProxy class.
#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
const MT::ElementType max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1649
Header file for mathematical functions.
#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 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
void move(CompressedMatrix< Type, SO > &dst, CompressedMatrix< Type, SO > &src)
Moving the contents of one compressed matrix to another.
Definition: CompressedMatrix.h:4825
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
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
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1354
#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
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
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2501
#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
Constraint on the data type.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2503
Constraint on the data type.
Header file for the SparseMatrix base class.
Header file for utility functions for sparse matrices.
Header file for the IsSquare type trait.
Constraint on the data type.
Header file for the DisableIf class template.
Header file for the IsStrictlyUpper type trait.
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
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
Constraint on the data type.
Header file for the IsUniTriangular type trait.
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.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:841
Header file for the implementation of the base template of the StrictlyUpperMatrix.
Header file for the IsNumeric type trait.
Header file for all adaptor forward declarations.
#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.
#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: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
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, sse_int16_t >::Type set(T value)
Sets all values in the vector to the given 2-byte integral value.
Definition: Set.h:73
Header file for the move shim.
#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.
#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
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
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2508
#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.
#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
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:79