35 #ifndef _BLAZE_MATH_SPARSE_SPARSEMATRIX_H_ 36 #define _BLAZE_MATH_SPARSE_SPARSEMATRIX_H_ 106 template<
typename T1,
typename T2,
bool SO >
107 inline bool operator==(
const SparseMatrix<T1,false>& lhs,
const SparseMatrix<T2,false>& rhs );
109 template<
typename T1,
typename T2,
bool SO >
110 inline bool operator==(
const SparseMatrix<T1,true>& lhs,
const SparseMatrix<T2,true>& rhs );
112 template<
typename T1,
typename T2,
bool SO >
113 inline bool operator==(
const SparseMatrix<T1,SO>& lhs,
const SparseMatrix<T2,!SO>& rhs );
115 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
116 inline bool operator!=(
const SparseMatrix<T1,SO1>& lhs,
const SparseMatrix<T2,SO2>& rhs );
118 template<
typename MT,
bool SO,
typename ST >
119 inline EnableIf_< IsNumeric<ST>, MT& >
operator*=( SparseMatrix<MT,SO>& mat, ST scalar );
121 template<
typename MT,
bool SO,
typename ST >
122 inline EnableIf_< IsNumeric<ST>, MT& >
operator*=( SparseMatrix<MT,SO>&& mat, ST scalar );
124 template<
typename MT,
bool SO,
typename ST >
125 inline EnableIf_< IsNumeric<ST>, MT& >
operator/=( SparseMatrix<MT,SO>& mat, ST scalar );
127 template<
typename MT,
bool SO,
typename ST >
128 inline EnableIf_< IsNumeric<ST>, MT& >
operator/=( SparseMatrix<MT,SO>&& mat, ST scalar );
141 template<
typename T1
160 for(
size_t i=0UL; i<A.rows(); ++i )
162 const LhsConstIterator lend( A.end(i) );
163 const RhsConstIterator rend( B.end(i) );
165 LhsConstIterator lelem( A.begin(i) );
166 RhsConstIterator relem( B.begin(i) );
168 while( lelem != lend && relem != rend )
170 if( lelem->index() < relem->index() ) {
175 else if( lelem->index() > relem->index() ) {
180 else if( !
equal( lelem->value(), relem->value() ) ) {
189 while( lelem != lend ) {
195 while( relem != rend ) {
215 template<
typename T1
234 for(
size_t j=0UL; j<A.columns(); ++j )
236 const LhsConstIterator lend( A.end(j) );
237 const RhsConstIterator rend( B.end(j) );
239 LhsConstIterator lelem( A.begin(j) );
240 RhsConstIterator relem( B.begin(j) );
242 while( lelem != lend && relem != rend )
244 if( lelem->index() < relem->index() ) {
249 else if( lelem->index() > relem->index() ) {
254 else if( !
equal( lelem->value(), relem->value() ) ) {
263 while( lelem != lend ) {
269 while( relem != rend ) {
289 template<
typename T1
295 return ( ~lhs == tmp );
308 template<
typename T1
314 return !( lhs == rhs );
332 template<
typename MT
340 if( !tryMult( ~mat, 0UL, 0UL, (~mat).
rows(), (~mat).
columns(), scalar ) ) {
351 BLAZE_DECLTYPE_AUTO( left, derestrict( ~mat ) );
354 for(
size_t i=0UL; i<iend; ++i ) {
355 const auto last( left.end(i) );
356 for(
auto element=left.begin(i); element!=last; ++element ) {
357 element->value() *= scalar;
382 template<
typename MT
407 template<
typename MT
417 if( !tryDiv( ~mat, 0UL, 0UL, (~mat).
rows(), (~mat).
columns(), scalar ) ) {
430 BLAZE_DECLTYPE_AUTO( left, derestrict( ~mat ) );
433 const ScalarType tmp( ScalarType(1)/static_cast<ScalarType>( scalar ) );
435 for(
size_t i=0UL; i<iend; ++i ) {
436 const auto last( left.end(i) );
437 for(
auto element=left.begin(i); element!=last; ++element ) {
438 element->value() *= tmp;
444 for(
size_t i=0UL; i<iend; ++i ) {
445 const auto last( left.end(i) );
446 for(
auto element=left.begin(i); element!=last; ++element ) {
447 element->value() /= scalar;
474 template<
typename MT
495 template<
typename MT,
bool SO >
498 template<
bool RF,
typename MT,
bool SO >
501 template<
bool RF,
typename MT,
bool SO >
504 template<
bool RF,
typename MT,
bool SO >
507 template<
bool RF,
typename MT,
bool SO >
510 template<
bool RF,
typename MT,
bool SO >
513 template<
bool RF,
typename MT,
bool SO >
516 template<
bool RF,
typename MT,
bool SO >
519 template<
bool RF,
typename MT,
bool SO >
522 template<
bool RF,
typename MT,
bool SO >
525 template<
bool RF,
typename MT,
bool SO >
528 template<
bool RF,
typename MT,
bool SO >
531 template<
typename MT,
bool SO >
534 template<
typename MT,
bool SO >
560 template<
typename MT
570 for(
size_t i=0UL; i<A.rows(); ++i ) {
571 for(
ConstIterator element=A.begin(i); element!=A.end(i); ++element )
572 if(
isnan( element->value() ) )
return true;
576 for(
size_t j=0UL; j<A.columns(); ++j ) {
577 for(
ConstIterator element=A.begin(j); element!=A.end(j); ++element )
578 if(
isnan( element->value() ) )
return true;
643 for(
size_t i=0UL; i<A.rows(); ++i ) {
644 for(
ConstIterator element=A.begin(i); element!=A.end(i); ++element )
646 const size_t j( element->index() );
648 if( i == j || isDefault<RF>( element->value() ) )
652 if( pos == A.end(j) || !equal<RF>( pos->value(), element->value() ) )
658 for(
size_t j=0UL; j<A.columns(); ++j ) {
659 for(
ConstIterator element=A.begin(j); element!=A.end(j); ++element )
661 const size_t i( element->index() );
663 if( j == i || isDefault<RF>( element->value() ) )
667 if( pos == A.end(i) || !equal<RF>( pos->value(), element->value() ) )
737 for(
size_t i=0UL; i<A.rows(); ++i ) {
738 for(
ConstIterator element=A.begin(i); element!=A.end(i); ++element )
740 const size_t j( element->index() );
742 if( isDefault<RF>( element->value() ) )
745 if( i == j && !isReal<RF>( element->value() ) )
749 if( pos == A.end(j) || !equal<RF>( pos->value(),
conj( element->value() ) ) )
755 for(
size_t j=0UL; j<A.columns(); ++j ) {
756 for(
ConstIterator element=A.begin(j); element!=A.end(j); ++element )
758 const size_t i( element->index() );
760 if( isDefault<RF>( element->value() ) )
763 if( j == i && !isReal<RF>( element->value() ) )
767 if( pos == A.end(i) || !equal<RF>( pos->value(),
conj( element->value() ) ) )
801 for(
size_t i=ibegin; i<iend; ++i ) {
803 if( !isDefault<RF>( element->value() ) )
837 for(
size_t j=jbegin; j<jend; ++j ) {
839 if( !isDefault<RF>( element->value() ) )
871 const size_t maxElements( (~sm).
rows() * (~sm).
columns() );
873 if( (~sm).
nonZeros() != maxElements )
875 for(
size_t i=0UL; i<(~sm).
rows(); ++i ) {
876 for(
ConstIterator element=(~sm).begin(i); element!=(~sm).
end(i); ++element ) {
877 if( !isDefault<RF>( element->value() ) )
888 for(
size_t i=0UL; i<(~sm).
rows(); ++i ) {
889 for(
ConstIterator element=(~sm).begin(i); element!=(~sm).
end(i); ++element ) {
890 if( element->value() != cmp )
923 const size_t maxElements( (~sm).
rows() * (~sm).
columns() );
925 if( (~sm).
nonZeros() != maxElements )
927 for(
size_t j=0UL; j<(~sm).
columns(); ++j ) {
928 for(
ConstIterator element=(~sm).begin(j); element!=(~sm).
end(j); ++element ) {
929 if( !isDefault<RF>( element->value() ) )
940 for(
size_t j=0UL; j<(~sm).
columns(); ++j ) {
941 for(
ConstIterator element=(~sm).begin(j); element!=(~sm).
end(j); ++element ) {
942 if( element->value() != cmp )
997 ( (~sm).
rows() == 1UL && (~sm).
columns() == 1UL ) )
1067 if( (~sm).
rows() < 2UL )
1073 for(
size_t i=0UL; i<A.rows()-1UL; ++i ) {
1074 for(
ConstIterator element=A.lowerBound(i,i+1UL); element!=A.end(i); ++element )
1076 if( !isDefault<RF>( element->value() ) )
1082 for(
size_t j=1UL; j<A.columns(); ++j ) {
1083 for(
ConstIterator element=A.begin(j); element!=A.end(j); ++element )
1085 if( element->index() >= j )
1088 if( !isDefault<RF>( element->value() ) )
1161 for(
size_t i=0UL; i<A.rows(); ++i )
1165 if( element == A.end(i) || element->index() != i || !isOne<RF>( element->value() ) )
1170 for( ; element!=A.end(i); ++element ) {
1171 if( !isZero<RF>( element->value() ) )
1177 for(
size_t j=0UL; j<A.columns(); ++j )
1179 bool hasDiagonalElement(
false );
1181 for(
ConstIterator element=A.begin(j); element!=A.end(j); ++element )
1183 if( element->index() >= j ) {
1184 if( element->index() != j || !isOne<RF>( element->value() ) )
1186 hasDiagonalElement =
true;
1190 if( !isZero<RF>( element->value() ) )
1194 if( !hasDiagonalElement ) {
1268 for(
size_t i=0UL; i<A.rows(); ++i ) {
1269 for(
ConstIterator element=A.lowerBound(i,i); element!=A.end(i); ++element )
1271 if( !isDefault<RF>( element->value() ) )
1277 for(
size_t j=0UL; j<A.columns(); ++j ) {
1278 for(
ConstIterator element=A.begin(j); element!=A.end(j); ++element )
1280 if( element->index() > j )
1283 if( !isDefault<RF>( element->value() ) )
1354 if( (~sm).
rows() < 2UL )
1360 for(
size_t i=1UL; i<A.rows(); ++i ) {
1361 for(
ConstIterator element=A.begin(i); element!=A.end(i); ++element )
1363 if( element->index() >= i )
1366 if( !isDefault<RF>( element->value() ) )
1372 for(
size_t j=0UL; j<A.columns()-1UL; ++j ) {
1373 for(
ConstIterator element=A.lowerBound(j+1UL,j); element!=A.end(j); ++element )
1375 if( !isDefault<RF>( element->value() ) )
1448 for(
size_t i=0UL; i<A.rows(); ++i )
1450 bool hasDiagonalElement(
false );
1452 for(
ConstIterator element=A.begin(i); element!=A.end(i); ++element )
1454 if( element->index() >= i ) {
1455 if( element->index() != i || !isOne<RF>( element->value() ) )
1457 hasDiagonalElement =
true;
1460 else if( !isZero<RF>( element->value() ) ) {
1465 if( !hasDiagonalElement ) {
1471 for(
size_t j=0UL; j<A.columns(); ++j )
1475 if( element == A.end(j) || element->index() != j || !isOne<RF>( element->value() ) )
1480 for( ; element!=A.end(j); ++element ) {
1481 if( !isZero<RF>( element->value() ) )
1555 for(
size_t i=0UL; i<A.rows(); ++i ) {
1556 for(
ConstIterator element=A.begin(i); element!=A.end(i); ++element )
1558 if( element->index() > i )
1561 if( !isDefault<RF>( element->value() ) )
1567 for(
size_t j=0UL; j<A.columns(); ++j ) {
1568 for(
ConstIterator element=A.lowerBound(j,j); element!=A.end(j); ++element )
1570 if( !isDefault<RF>( element->value() ) )
1641 if( (~sm).
rows() < 2UL )
1647 for(
size_t i=0UL; i<A.rows(); ++i ) {
1648 for(
ConstIterator element=A.begin(i); element!=A.end(i); ++element )
1649 if( element->index() != i && !isDefault<RF>( element->value() ) )
1654 for(
size_t j=0UL; j<A.columns(); ++j ) {
1655 for(
ConstIterator element=A.begin(j); element!=A.end(j); ++element )
1656 if( element->index() != j && !isDefault<RF>( element->value() ) )
1729 for(
size_t i=0UL; i<A.rows(); ++i )
1731 bool hasDiagonalElement(
false );
1733 for(
ConstIterator element=A.begin(i); element!=A.end(i); ++element )
1735 if( element->index() == i ) {
1736 if( !isOne<RF>( element->value() ) )
1738 hasDiagonalElement =
true;
1740 else if( !isZero<RF>( element->value() ) ) {
1745 if( !hasDiagonalElement ) {
1751 for(
size_t j=0UL; j<A.columns(); ++j )
1753 bool hasDiagonalElement(
false );
1755 for(
ConstIterator element=A.begin(j); element!=A.end(j); ++element )
1757 if( element->index() == j ) {
1758 if( !isOne<RF>( element->value() ) )
1760 hasDiagonalElement =
true;
1762 else if( !isZero<RF>( element->value() ) ) {
1767 if( !hasDiagonalElement ) {
1790 template<
typename MT
1802 const size_t nonzeros( A.nonZeros() );
1804 if( nonzeros == 0UL ) {
1809 if( nonzeros == A.rows() * A.columns() ) {
1810 minimum = A.begin( 0UL )->value();
1813 const size_t index( ( SO ==
rowMajor )?( A.rows() ):( A.columns() ) );
1815 for(
size_t i=0UL; i<index; ++i ) {
1818 for( ; element!=
end; ++element )
1819 minimum =
min( minimum, element->value() );
1839 template<
typename MT
1851 const size_t nonzeros( A.nonZeros() );
1853 if( nonzeros == 0UL ) {
1858 if( nonzeros == A.rows() * A.columns() ) {
1859 maximum = A.begin( 0UL )->value();
1862 const size_t index( ( SO ==
rowMajor )?( A.rows() ):( A.columns() ) );
1864 for(
size_t i=0UL; i<index; ++i ) {
1867 for( ; element!=
end; ++element )
1868 maximum =
max( maximum, element->value() );
#define BLAZE_CONSTRAINT_MUST_BE_TRIANGULAR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a lower or upper triangular matrix t...
Definition: Triangular.h:61
Header file for the isnan shim.
Header file for the UnderlyingNumeric type trait.
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
Headerfile for the generic min algorithm.
Compile time check for numeric types.This type trait tests whether or not the given template paramete...
Definition: IsNumeric.h:79
bool isLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower triangular matrix.
Definition: DenseMatrix.h:1214
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1469
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1386
#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 IsUniUpper type trait.
Compile time check for triangular matrix types.This type trait tests whether or not the given templat...
Definition: IsTriangular.h:86
Header file for basic type definitions.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRIANGULAR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower or upper triangular matrix type...
Definition: Triangular.h:81
constexpr bool equal(const T1 &a, const T2 &b)
Generic equality check.
Definition: Equal.h:76
Header file for the FalseType type/value trait base class.
Header file for the IsDiagonal type trait.
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
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:364
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:588
bool isUniLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower unitriangular matrix.
Definition: DenseMatrix.h:1299
Header file for the And class template.
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1903
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:87
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNITRIANGULAR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower or upper unitriangular matrix ty...
Definition: UniTriangular.h:81
Header file for the IsIdentity type trait.
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:3083
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:1725
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:560
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:87
Header file for the decltype(auto) workaround.
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1950
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
bool isIdentity(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is an identity matrix.
Definition: DenseMatrix.h:1827
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:363
Compile time check for data types with restricted data access.This type trait tests whether the given...
Definition: IsRestricted.h:82
Header file for the SparseMatrix base class.
Header file for the IsSquare type trait.
bool isZero(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is 0.
Definition: DiagonalProxy.h:670
Header file for the matrix storage order types.
Constraint on the data type.
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
Headerfile for the generic max algorithm.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Header file for the If class template.
Header file for the IsFloatingPoint type trait.
Header file for the UnderlyingBuiltin type trait.
Header file for the Or class template.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3085
Header file for the isZero shim.
constexpr bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:250
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Header file for the IsLower type trait.
Compile time check for diagonal matrices.This type trait tests whether or not the given template para...
Definition: IsDiagonal.h:89
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:506
Header file for the equal shim.
Header file for the IsUniTriangular type trait.
Header file for the IsTriangular type trait.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
bool isnan(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is not a number.
Definition: DiagonalProxy.h:710
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Compile time check for floating point data types.This type trait tests whether or not the given templ...
Definition: IsFloatingPoint.h:75
bool isUniform(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a uniform matrix.
Definition: DenseMatrix.h:1151
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:430
constexpr bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:290
Constraint on the data type.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the isOne shim.
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
typename DivTrait< T1, T2 >::Type DivTrait_
Auxiliary alias declaration for the DivTrait class template.The DivTrait_ alias declaration provides ...
Definition: DivTrait.h:292
Header file for the conjugate shim.
Constraint on the data type.
Header file for the IsNumeric type trait.
Compile time check for resizable data types.This type trait tests whether the given data type is a re...
Definition: IsResizable.h:75
Compile time check for identity matrices.This type trait tests whether or not the given template para...
Definition: IsIdentity.h:89
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1641
Header file for run time assertion macros.
Header file for the division trait.
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:154
bool isHermitian(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is Hermitian.
Definition: DenseMatrix.h:919
Header file for the isDefault shim.
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Compile time check for built-in data types.This type trait tests whether or not the given template pa...
Definition: IsBuiltin.h:75
Compile time check for data types.This type trait tests whether or not the given template parameter i...
Definition: IsInvertible.h:82
bool isSymmetric(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is symmetric.
Definition: DenseMatrix.h:841
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
Header file for the RemoveReference type trait.
Header file for the IsInvertible type trait.
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
typename T::ConstReference ConstReference_
Alias declaration for nested ConstReference type definitions.The ConstReference_ alias declaration pr...
Definition: Aliases.h:143
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:490
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
EnableIf_< IsNumeric< ST >, MT &> operator/=(DenseMatrix< MT, SO > &mat, ST scalar)
Division assignment operator for the division of a dense matrix by a scalar value ( )...
Definition: DenseMatrix.h:655
const bool rowMajor
Storage order flag for row-major matrices.
Definition: StorageOrder.h:71
Header file for the IsBuiltin type trait.
bool isUniUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper unitriangular matrix.
Definition: DenseMatrix.h:1554
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:254
Header file for the IsComplex type trait.
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:628
Header file for the IsUpper type trait.
decltype(auto) conj(const DenseMatrix< MT, SO > &dm)
Returns a matrix containing the complex conjugate of each single element of dm.
Definition: DMatMapExpr.h:1321
EnableIf_< IsNumeric< ST >, MT &> operator*=(DenseMatrix< MT, SO > &mat, ST scalar)
Multiplication assignment operator for the multiplication of a dense matrix and a scalar value ( )...
Definition: DenseMatrix.h:593
Header file for the IsHermitian type trait.
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:908
Header file for the IsResizable type trait.
Header file for the IsRestricted type trait.
Header file for the isReal shim.
#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.
Compile time check for unitriangular matrix types.This type trait tests whether or not the given temp...
Definition: IsUniTriangular.h:86
Header file for the IsExpression type trait class.