35 #ifndef _BLAZE_MATH_DENSE_DENSEMATRIX_H_ 36 #define _BLAZE_MATH_DENSE_DENSEMATRIX_H_ 97 template<
typename T1,
typename T2 >
98 inline bool operator==(
const DenseMatrix<T1,false>& lhs,
const DenseMatrix<T2,false>& rhs );
100 template<
typename T1,
typename T2 >
101 inline bool operator==(
const DenseMatrix<T1,true>& lhs,
const DenseMatrix<T2,true>& rhs );
103 template<
typename T1,
typename T2,
bool SO >
104 inline bool operator==(
const DenseMatrix<T1,SO>& lhs,
const DenseMatrix<T2,!SO>& rhs );
106 template<
typename T1,
typename T2,
bool SO >
107 inline bool operator==(
const DenseMatrix<T1,SO>& lhs,
const SparseMatrix<T2,false>& rhs );
109 template<
typename T1,
typename T2,
bool SO >
110 inline bool operator==(
const DenseMatrix<T1,SO>& lhs,
const SparseMatrix<T2,true>& rhs );
112 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
113 inline bool operator==(
const SparseMatrix<T1,SO1>& lhs,
const DenseMatrix<T2,SO2>& rhs );
115 template<
typename T1,
typename T2 >
116 inline EnableIf_< IsNumeric<T2>,
bool >
operator==(
const DenseMatrix<T1,false>& mat, T2 scalar );
118 template<
typename T1,
typename T2 >
119 inline EnableIf_< IsNumeric<T2>,
bool >
operator==(
const DenseMatrix<T1,true>& mat, T2 scalar );
121 template<
typename T1,
typename T2,
bool SO >
122 inline EnableIf_< IsNumeric<T2>,
bool >
operator==( T1 scalar,
const DenseMatrix<T2,SO>& mat );
124 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
125 inline bool operator!=(
const DenseMatrix<T1,SO1>& lhs,
const DenseMatrix<T2,SO2>& rhs );
127 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
128 inline bool operator!=(
const DenseMatrix<T1,SO1>& lhs,
const SparseMatrix<T2,SO2>& rhs );
130 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
131 inline bool operator!=(
const SparseMatrix<T1,SO1>& lhs,
const DenseMatrix<T2,SO2>& rhs );
133 template<
typename T1,
typename T2,
bool SO >
134 inline EnableIf_< IsNumeric<T2>,
bool >
operator!=(
const DenseMatrix<T1,SO>& mat, T2 scalar );
136 template<
typename T1,
typename T2,
bool SO >
137 inline EnableIf_< IsNumeric<T2>,
bool >
operator!=( T1 scalar,
const DenseMatrix<T2,SO>& mat );
139 template<
typename MT,
bool SO,
typename ST >
140 inline EnableIf_< IsNumeric<ST>, MT& >
operator*=( DenseMatrix<MT,SO>& mat, ST scalar );
142 template<
typename MT,
bool SO,
typename ST >
143 inline EnableIf_< IsNumeric<ST>, MT& >
operator*=( DenseMatrix<MT,SO>&& mat, ST scalar );
145 template<
typename MT,
bool SO,
typename ST >
146 inline EnableIf_< IsNumeric<ST>, MT& >
operator/=( DenseMatrix<MT,SO>& mat, ST scalar );
148 template<
typename MT,
bool SO,
typename ST >
149 inline EnableIf_< IsNumeric<ST>, MT& >
operator/=( DenseMatrix<MT,SO>&& mat, ST scalar );
162 template<
typename T1
179 for(
size_t i=0; i<A.rows(); ++i ) {
180 for(
size_t j=0; j<A.columns(); ++j ) {
181 if( !
equal( A(i,j), B(i,j) ) )
return false;
198 template<
typename T1
215 for(
size_t j=0; j<A.columns(); ++j ) {
216 for(
size_t i=0; i<A.rows(); ++i ) {
217 if( !
equal( A(i,j), B(i,j) ) )
return false;
234 template<
typename T1
252 const size_t rows ( A.rows() );
253 const size_t columns( A.columns() );
254 const size_t block ( 16 );
256 for(
size_t ii=0; ii<
rows; ii+=block ) {
257 const size_t iend( ( rows < ii+block )?( rows ):( ii+block ) );
258 for(
size_t jj=0; jj<
columns; jj+=block ) {
259 const size_t jend( ( columns < jj+block )?( columns ):( jj+block ) );
260 for(
size_t i=ii; i<iend; ++i ) {
261 for(
size_t j=jj; j<jend; ++j ) {
262 if( !
equal( A(i,j), B(i,j) ) )
return false;
281 template<
typename T1
302 for(
size_t i=0; i<B.rows(); ++i ) {
304 for(
ConstIterator element=B.begin(i); element!=B.end(i); ++element, ++j ) {
305 for( ; j<element->index(); ++j ) {
308 if( !
equal( element->value(), A(i,j) ) )
return false;
310 for( ; j<A.columns(); ++j ) {
328 template<
typename T1
349 for(
size_t j=0; j<B.columns(); ++j ) {
351 for(
ConstIterator element=B.begin(j); element!=B.end(j); ++element, ++i ) {
352 for( ; i<element->index(); ++i ) {
355 if( !
equal( element->value(), A(i,j) ) )
return false;
357 for( ; i<A.rows(); ++i ) {
375 template<
typename T1
381 return ( rhs == lhs );
398 template<
typename T1
409 for(
size_t i=0; i<A.rows(); ++i ) {
410 for(
size_t j=0; j<A.columns(); ++j ) {
411 if( !
equal( A(i,j), scalar ) )
return false;
432 template<
typename T1
443 for(
size_t j=0; j<A.columns(); ++j ) {
444 for(
size_t i=0; i<A.rows(); ++i ) {
445 if( !
equal( A(i,j), scalar ) )
return false;
466 template<
typename T1
471 return ( mat == scalar );
484 template<
typename T1
490 return !( lhs == rhs );
503 template<
typename T1
509 return !( lhs == rhs );
522 template<
typename T1
528 return !( rhs == lhs );
545 template<
typename T1
550 return !( mat == scalar );
567 template<
typename T1
572 return !( mat == scalar );
590 template<
typename MT
598 if( !tryMult( ~mat, 0UL, 0UL, (~mat).
rows(), (~mat).
columns(), scalar ) ) {
603 BLAZE_DECLTYPE_AUTO( left, derestrict( ~mat ) );
627 template<
typename MT
652 template<
typename MT
662 if( !tryDiv( ~mat, 0UL, 0UL, (~mat).
rows(), (~mat).
columns(), scalar ) ) {
667 BLAZE_DECLTYPE_AUTO( left, derestrict( ~mat ) );
693 template<
typename MT
714 template<
typename MT,
bool SO >
717 template<
bool RF,
typename MT,
bool SO >
720 template<
bool RF,
typename MT,
bool SO >
723 template<
bool RF,
typename MT,
bool SO >
726 template<
bool RF,
typename MT,
bool SO >
729 template<
bool RF,
typename MT,
bool SO >
732 template<
bool RF,
typename MT,
bool SO >
735 template<
bool RF,
typename MT,
bool SO >
738 template<
bool RF,
typename MT,
bool SO >
741 template<
bool RF,
typename MT,
bool SO >
744 template<
bool RF,
typename MT,
bool SO >
747 template<
bool RF,
typename MT,
bool SO >
750 template<
typename MT,
bool SO >
753 template<
typename MT,
bool SO >
779 template<
typename MT
788 for(
size_t i=0UL; i<A.rows(); ++i ) {
789 for(
size_t j=0UL; j<A.columns(); ++j )
790 if(
isnan( A(i,j) ) )
return true;
794 for(
size_t j=0UL; j<A.columns(); ++j ) {
795 for(
size_t i=0UL; i<A.rows(); ++i )
796 if(
isnan( A(i,j) ) )
return true;
860 for(
size_t i=1UL; i<A.rows(); ++i ) {
861 for(
size_t j=0UL; j<i; ++j ) {
862 if( !equal<RF>( A(i,j), A(j,i) ) )
868 for(
size_t j=1UL; j<A.columns(); ++j ) {
869 for(
size_t i=0UL; i<j; ++i ) {
870 if( !equal<RF>( A(i,j), A(j,i) ) )
936 for(
size_t i=0UL; i<A.rows(); ++i ) {
937 for(
size_t j=0UL; j<i; ++j ) {
938 if( !equal<RF>( A(i,j),
conj( A(j,i) ) ) )
941 if( !isReal<RF>( A(i,i) ) )
946 for(
size_t j=0UL; j<A.columns(); ++j ) {
947 for(
size_t i=0UL; i<j; ++i ) {
948 if( !equal<RF>( A(i,j),
conj( A(j,i) ) ) )
951 if( !isReal<RF>( A(j,j) ) )
982 for(
size_t i=ibegin; i<iend; ++i ) {
984 for(
size_t j=0UL; j<i; ++j ) {
985 if( !isDefault<RF>( (~dm)(i,j) ) )
989 if( !isDefault<RF>( (~dm)(i,i) ) )
992 for(
size_t j=i+1UL; j<(~dm).
columns(); ++j ) {
993 if( !isDefault<RF>( (~dm)(i,j) ) )
1026 for(
size_t j=jbegin; j<jend; ++j ) {
1028 for(
size_t i=0UL; i<j; ++i ) {
1029 if( !isDefault<RF>( (~dm)(i,j) ) )
1033 if( !isDefault<RF>( (~dm)(j,j) ) )
1036 for(
size_t i=j+1UL; i<(~dm).
rows(); ++i ) {
1037 if( !isDefault<RF>( (~dm)(i,j) ) )
1069 for(
size_t i=0UL; i<(~dm).
rows(); ++i ) {
1070 for(
size_t j=0UL; j<(~dm).
columns(); ++j ) {
1071 if( (~dm)(i,j) != cmp )
1102 for(
size_t j=0UL; j<(~dm).
columns(); ++j ) {
1103 for(
size_t i=0UL; i<(~dm).
rows(); ++i ) {
1104 if( (~dm)(i,j) != cmp )
1158 ( (~dm).
rows() == 1UL && (~dm).
columns() == 1UL ) )
1227 if( (~dm).
rows() < 2UL )
1233 for(
size_t i=0UL; i<A.rows()-1UL; ++i ) {
1234 for(
size_t j=i+1UL; j<A.columns(); ++j ) {
1235 if( !isDefault<RF>( A(i,j) ) )
1241 for(
size_t j=1UL; j<A.columns(); ++j ) {
1242 for(
size_t i=0UL; i<j; ++i ) {
1243 if( !isDefault<RF>( A(i,j) ) )
1315 for(
size_t i=0UL; i<A.rows(); ++i ) {
1316 if( !isOne<RF>( A(i,i) ) )
1318 for(
size_t j=i+1UL; j<A.columns(); ++j ) {
1319 if( !isZero<RF>( A(i,j) ) )
1325 for(
size_t j=0UL; j<A.columns(); ++j ) {
1326 for(
size_t i=0UL; i<j; ++i ) {
1327 if( !isZero<RF>( A(i,j) ) )
1330 if( !isOne<RF>( A(j,j) ) )
1402 for(
size_t i=0UL; i<A.rows(); ++i ) {
1403 for(
size_t j=i; j<A.columns(); ++j ) {
1404 if( !isDefault<RF>( A(i,j) ) )
1410 for(
size_t j=0UL; j<A.columns(); ++j ) {
1411 for(
size_t i=0UL; i<=j; ++i ) {
1412 if( !isDefault<RF>( A(i,j) ) )
1482 if( (~dm).
rows() < 2UL )
1488 for(
size_t i=1UL; i<A.rows(); ++i ) {
1489 for(
size_t j=0UL; j<i; ++j ) {
1490 if( !isDefault<RF>( A(i,j) ) )
1496 for(
size_t j=0UL; j<A.columns()-1UL; ++j ) {
1497 for(
size_t i=j+1UL; i<A.rows(); ++i ) {
1498 if( !isDefault<RF>( A(i,j) ) )
1570 for(
size_t i=0UL; i<A.rows(); ++i ) {
1571 for(
size_t j=0UL; j<i; ++j ) {
1572 if( !isZero<RF>( A(i,j) ) )
1575 if( !isOne<RF>( A(i,i) ) )
1580 for(
size_t j=0UL; j<A.columns(); ++j ) {
1581 if( !isOne<RF>( A(j,j) ) )
1583 for(
size_t i=j+1UL; i<A.rows(); ++i ) {
1584 if( !isZero<RF>( A(i,j) ) )
1657 for(
size_t i=0UL; i<A.rows(); ++i ) {
1658 for(
size_t j=0UL; j<=i; ++j ) {
1659 if( !isDefault<RF>( A(i,j) ) )
1665 for(
size_t j=0UL; j<A.columns(); ++j ) {
1666 for(
size_t i=j; i<A.rows(); ++i ) {
1667 if( !isDefault<RF>( A(i,j) ) )
1738 if( (~dm).
rows() < 2UL )
1744 for(
size_t i=0UL; i<A.rows(); ++i ) {
1746 for(
size_t j=0UL; j<i; ++j ) {
1747 if( !isDefault<RF>( A(i,j) ) )
1752 for(
size_t j=i+1UL; j<A.columns(); ++j ) {
1753 if( !isDefault<RF>( A(i,j) ) )
1760 for(
size_t j=0UL; j<A.columns(); ++j ) {
1762 for(
size_t i=0UL; i<j; ++i ) {
1763 if( !isDefault<RF>( A(i,j) ) )
1768 for(
size_t i=j+1UL; i<A.rows(); ++i ) {
1769 if( !isDefault<RF>( A(i,j) ) )
1840 if( (~dm).
rows() == 0UL )
1846 for(
size_t i=0UL; i<A.rows(); ++i ) {
1848 for(
size_t j=0UL; j<i; ++j ) {
1849 if( !isZero<RF>( A(i,j) ) )
1857 for(
size_t j=i+1UL; j<A.columns(); ++j ) {
1858 if( !isZero<RF>( A(i,j) ) )
1865 for(
size_t j=0UL; j<A.columns(); ++j ) {
1867 for(
size_t i=0UL; i<j; ++i ) {
1868 if( !isZero<RF>( A(i,j) ) )
1876 for(
size_t i=j+1UL; i<A.rows(); ++i ) {
1877 if( !isZero<RF>( A(i,j) ) )
1901 template<
typename MT
1912 if( A.rows() == 0UL || A.columns() == 0UL )
return ET();
1914 ET minimum( A(0,0) );
1917 for(
size_t j=1UL; j<A.columns(); ++j )
1918 minimum =
min( minimum, A(0UL,j) );
1919 for(
size_t i=1UL; i<A.rows(); ++i )
1920 for(
size_t j=0UL; j<A.columns(); ++j )
1921 minimum =
min( minimum, A(i,j) );
1924 for(
size_t i=1UL; i<A.rows(); ++i )
1925 minimum =
min( minimum, A(i,0UL) );
1926 for(
size_t j=1UL; j<A.columns(); ++j )
1927 for(
size_t i=0UL; i<A.rows(); ++i )
1928 minimum =
min( minimum, A(i,j) );
1948 template<
typename MT
1959 if( A.rows() == 0UL || A.columns() == 0UL )
return ET();
1961 ET maximum( A(0,0) );
1964 for(
size_t j=1UL; j<A.columns(); ++j )
1965 maximum =
max( maximum, A(0UL,j) );
1966 for(
size_t i=1UL; i<A.rows(); ++i )
1967 for(
size_t j=0UL; j<A.columns(); ++j )
1968 maximum =
max( maximum, A(i,j) );
1971 for(
size_t i=1UL; i<A.rows(); ++i )
1972 maximum =
max( maximum, A(i,0UL) );
1973 for(
size_t j=1UL; j<A.columns(); ++j )
1974 for(
size_t i=0UL; i<A.rows(); ++i )
1975 maximum =
max( maximum, A(i,j) );
#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.
#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
bool isUniLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower unitriangular matrix.
Definition: DenseMatrix.h:1299
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.
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:1725
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 dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:80
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.
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.
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:102
Header file for the DenseMatrix base class.
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
bool isUniform(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a uniform matrix.
Definition: DenseMatrix.h:1151
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
Header file for the conjugate shim.
Constraint on the data type.
Header file for the IsNumeric type trait.
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.
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
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.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:224
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
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 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.