DMatInvExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATINVEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATINVEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
47 #include <blaze/math/Exception.h>
63 #include <blaze/util/Assert.h>
66 #include <blaze/util/InvalidType.h>
67 #include <blaze/util/mpl/If.h>
68 #include <blaze/util/Types.h>
69 
70 
71 namespace blaze {
72 
73 //=================================================================================================
74 //
75 // CLASS DMATINVEXPR
76 //
77 //=================================================================================================
78 
79 //*************************************************************************************************
85 template< typename MT // Type of the dense matrix
86  , bool SO > // Storage order
88  : public MatInvExpr< DenseMatrix< DMatInvExpr<MT,SO>, SO > >
89  , private Computation
90 {
91  private:
92  //**Type definitions****************************************************************************
93  using RT = ResultType_<MT>;
95  //**********************************************************************************************
96 
97  public:
98  //**Type definitions****************************************************************************
105 
107  using CompositeType = const ResultType;
108 
110  using Operand = If_< IsExpression<MT>, const MT, const MT& >;
111  //**********************************************************************************************
112 
113  //**Compilation flags***************************************************************************
115  enum : bool { simdEnabled = false };
116 
118  enum : bool { smpAssignable = false };
119  //**********************************************************************************************
120 
121  //**Constructor*********************************************************************************
126  explicit inline DMatInvExpr( const MT& dm ) noexcept
127  : dm_( dm ) // Dense matrix of the inversion expression
128  {}
129  //**********************************************************************************************
130 
131  //**Rows function*******************************************************************************
136  inline size_t rows() const noexcept {
137  return dm_.columns();
138  }
139  //**********************************************************************************************
140 
141  //**Columns function****************************************************************************
146  inline size_t columns() const noexcept {
147  return dm_.rows();
148  }
149  //**********************************************************************************************
150 
151  //**Operand access******************************************************************************
156  inline Operand operand() const noexcept {
157  return dm_;
158  }
159  //**********************************************************************************************
160 
161  //**********************************************************************************************
167  template< typename T >
168  inline bool canAlias( const T* alias ) const noexcept {
169  return dm_.isAliased( alias );
170  }
171  //**********************************************************************************************
172 
173  //**********************************************************************************************
179  template< typename T >
180  inline bool isAliased( const T* alias ) const noexcept {
181  return dm_.isAliased( alias );
182  }
183  //**********************************************************************************************
184 
185  private:
186  //**Member variables****************************************************************************
188  //**********************************************************************************************
189 
190  //**********************************************************************************************
196  static constexpr InversionFlag getInversionFlag() noexcept {
204  : asGeneral );
205  }
207  //**********************************************************************************************
208 
209  //**Assignment to dense matrices****************************************************************
221  template< typename MT2 // Type of the target dense matrix
222  , bool SO2 > // Storage order of the target dense matrix
223  friend inline void assign( DenseMatrix<MT2,SO2>& lhs, const DMatInvExpr& rhs )
224  {
226 
227  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
228  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
229 
230  if( !isSame( ~lhs, rhs.dm_ ) ) {
231  assign( ~lhs, rhs.dm_ );
232  }
233 
234  invert< DMatInvExpr::getInversionFlag() >( ~lhs );
235  }
237  //**********************************************************************************************
238 
239  //**Assignment to sparse matrices***************************************************************
251  template< typename MT2 // Type of the target sparse matrix
252  , bool SO2 > // Storage order of the target sparse matrix
253  friend inline void assign( SparseMatrix<MT2,SO2>& lhs, const DMatInvExpr& rhs )
254  {
256 
258 
265 
266  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
267  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
268 
269  const TmpType tmp( serial( rhs ) );
270  assign( ~lhs, tmp );
271  }
273  //**********************************************************************************************
274 
275  //**Addition assignment to dense matrices*******************************************************
287  template< typename MT2 // Type of the target dense matrix
288  , bool SO2 > // Storage order of the target dense matrix
289  friend inline void addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatInvExpr& rhs )
290  {
292 
293  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
294  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
295 
296  const ResultType tmp( serial( rhs ) );
297  addAssign( ~lhs, tmp );
298  }
300  //**********************************************************************************************
301 
302  //**Addition assignment to sparse matrices******************************************************
303  // No special implementation for the addition assignment to sparse matrices.
304  //**********************************************************************************************
305 
306  //**Subtraction assignment to dense matrices****************************************************
318  template< typename MT2 // Type of the target dense matrix
319  , bool SO2 > // Storage order of the target dense matrix
320  friend inline void subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatInvExpr& rhs )
321  {
323 
324  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
325  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
326 
327  const ResultType tmp( serial( rhs ) );
328  subAssign( ~lhs, tmp );
329  }
331  //**********************************************************************************************
332 
333  //**Subtraction assignment to sparse matrices***************************************************
334  // No special implementation for the subtraction assignment to sparse matrices.
335  //**********************************************************************************************
336 
337  //**Schur product assignment to dense matrices**************************************************
349  template< typename MT2 // Type of the target dense matrix
350  , bool SO2 > // Storage order of the target dense matrix
351  friend inline void schurAssign( DenseMatrix<MT2,SO2>& lhs, const DMatInvExpr& rhs )
352  {
354 
355  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
356  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
357 
358  const ResultType tmp( serial( rhs ) );
359  schurAssign( ~lhs, tmp );
360  }
362  //**********************************************************************************************
363 
364  //**Schur product assignment to sparse matrices*************************************************
365  // No special implementation for the Schur product assignment to sparse matrices.
366  //**********************************************************************************************
367 
368  //**Multiplication assignment to dense matrices*************************************************
369  // No special implementation for the multiplication assignment to dense matrices.
370  //**********************************************************************************************
371 
372  //**Multiplication assignment to sparse matrices************************************************
373  // No special implementation for the multiplication assignment to sparse matrices.
374  //**********************************************************************************************
375 
376  //**Compile time checks*************************************************************************
381  //**********************************************************************************************
382 };
383 //*************************************************************************************************
384 
385 
386 
387 
388 //=================================================================================================
389 //
390 // GLOBAL OPERATORS
391 //
392 //=================================================================================================
393 
394 //*************************************************************************************************
424 template< typename MT // Type of the dense matrix
425  , bool SO > // Storage order
426 inline decltype(auto) inv( const DenseMatrix<MT,SO>& dm )
427 {
429 
430  if( !isSquare( ~dm ) ) {
431  BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
432  }
433 
434  using ReturnType = const DMatInvExpr<MT,SO>;
435  return ReturnType( ~dm );
436 }
437 //*************************************************************************************************
438 
439 
440 
441 
442 //=================================================================================================
443 //
444 // GLOBAL RESTRUCTURING FUNCTIONS
445 //
446 //=================================================================================================
447 
448 //*************************************************************************************************
468 template< typename MT // Type of the dense matrix
469  , bool SO > // Storage order
470 inline decltype(auto) inv( const DMatInvExpr<MT,SO>& dm )
471 {
473 
474  return dm.operand();
475 }
477 //*************************************************************************************************
478 
479 
480 
481 
482 //=================================================================================================
483 //
484 // ROWS SPECIALIZATIONS
485 //
486 //=================================================================================================
487 
488 //*************************************************************************************************
490 template< typename MT, bool SO >
491 struct Rows< DMatInvExpr<MT,SO> >
492  : public Rows<MT>
493 {};
495 //*************************************************************************************************
496 
497 
498 
499 
500 //=================================================================================================
501 //
502 // COLUMNS SPECIALIZATIONS
503 //
504 //=================================================================================================
505 
506 //*************************************************************************************************
508 template< typename MT, bool SO >
509 struct Columns< DMatInvExpr<MT,SO> >
510  : public Columns<MT>
511 {};
513 //*************************************************************************************************
514 
515 
516 
517 
518 //=================================================================================================
519 //
520 // ISSYMMETRIC SPECIALIZATIONS
521 //
522 //=================================================================================================
523 
524 //*************************************************************************************************
526 template< typename MT, bool SO >
527 struct IsSymmetric< DMatInvExpr<MT,SO> >
528  : public BoolConstant< IsSymmetric<MT>::value >
529 {};
531 //*************************************************************************************************
532 
533 
534 
535 
536 //=================================================================================================
537 //
538 // ISHERMITIAN SPECIALIZATIONS
539 //
540 //=================================================================================================
541 
542 //*************************************************************************************************
544 template< typename MT, bool SO >
545 struct IsHermitian< DMatInvExpr<MT,SO> >
546  : public BoolConstant< IsHermitian<MT>::value >
547 {};
549 //*************************************************************************************************
550 
551 
552 
553 
554 //=================================================================================================
555 //
556 // ISLOWER SPECIALIZATIONS
557 //
558 //=================================================================================================
559 
560 //*************************************************************************************************
562 template< typename MT, bool SO >
563 struct IsLower< DMatInvExpr<MT,SO> >
564  : public BoolConstant< IsLower<MT>::value >
565 {};
567 //*************************************************************************************************
568 
569 
570 
571 
572 //=================================================================================================
573 //
574 // ISUNILOWER SPECIALIZATIONS
575 //
576 //=================================================================================================
577 
578 //*************************************************************************************************
580 template< typename MT, bool SO >
581 struct IsUniLower< DMatInvExpr<MT,SO> >
582  : public BoolConstant< IsUniLower<MT>::value >
583 {};
585 //*************************************************************************************************
586 
587 
588 
589 
590 //=================================================================================================
591 //
592 // ISUPPER SPECIALIZATIONS
593 //
594 //=================================================================================================
595 
596 //*************************************************************************************************
598 template< typename MT, bool SO >
599 struct IsUpper< DMatInvExpr<MT,SO> >
600  : public BoolConstant< IsUpper<MT>::value >
601 {};
603 //*************************************************************************************************
604 
605 
606 
607 
608 //=================================================================================================
609 //
610 // ISUNIUPPER SPECIALIZATIONS
611 //
612 //=================================================================================================
613 
614 //*************************************************************************************************
616 template< typename MT, bool SO >
617 struct IsUniUpper< DMatInvExpr<MT,SO> >
618  : public BoolConstant< IsUniUpper<MT>::value >
619 {};
621 //*************************************************************************************************
622 
623 } // namespace blaze
624 
625 #endif
#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.
Operand dm_
Dense matrix of the inversion expression.
Definition: DMatInvExpr.h:187
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
Flag for the inversion of a diagonal matrix.
Definition: InversionFlag.h:115
BLAZE_ALWAYS_INLINE bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:786
Header file for basic type definitions.
Flag for the inversion of a general matrix (same as byLU).
Definition: InversionFlag.h:108
Flag for the inversion of a upper unitriangular matrix.
Definition: InversionFlag.h:114
Flag for the inversion of a lower unitriangular matrix.
Definition: InversionFlag.h:112
Header file for the serial shim.
#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:63
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
#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:61
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
Header file for the Computation base class.
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Header file for the MatInvExpr base class.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatInvExpr.h:168
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
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:78
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatInvExpr.h:136
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:363
DMatInvExpr(const MT &dm) noexcept
Constructor for the DMatInvExpr class.
Definition: DMatInvExpr.h:126
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
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatInvExpr.h:180
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
Flag for the inversion of a upper triangular matrix.
Definition: InversionFlag.h:113
Flag for the inversion of a lower triangular matrix.
Definition: InversionFlag.h:111
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatInvExpr.h:104
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatInvExpr.h:101
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
decltype(auto) inv(const DenseMatrix< MT, SO > &dm)
Calculation of the inverse of the given dense matrix.
Definition: DMatInvExpr.h:426
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Flag for the inversion of a Hermitian matrix (same as byLDLH).
Definition: InversionFlag.h:110
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:90
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: DMatInvExpr.h:100
Constraints on the storage order of matrix types.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
Header file for the exception macros of the math module.
Constraint on the data type.
Header file for all forward declarations for expression class templates.
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatInvExpr.h:102
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
CompositeType_< MT > CT
Composite type of the dense matrix expression.
Definition: DMatInvExpr.h:94
Flag for the inversion of a symmetric matrix (same as byLDLT).
Definition: InversionFlag.h:109
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatInvExpr.h:156
Header file for run time assertion macros.
Utility type for generic codes.
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
ResultType_< MT > RT
Result type of the dense matrix expression.
Definition: DMatInvExpr.h:93
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Base class for all matrix inversion expression templates.The MatInvExpr class serves as a tag for all...
Definition: MatInvExpr.h:66
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:819
#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
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:84
Expression object for dense matrix inversions.The DMatInvExpr class represents the compile time expre...
Definition: DMatInvExpr.h:87
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3082
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatInvExpr.h:107
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:66
ElementType_< MT > ElementType
Resulting element type.
Definition: DMatInvExpr.h:103
Header file for the IntegralConstant class template.
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Header file for the IsUpper type trait.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatInvExpr.h:146
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:742
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatInvExpr.h:110
InversionFlag
Inversion flag.The InversionFlag type enumeration represents the different types of matrix inversion ...
Definition: InversionFlag.h:101
#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 IsExpression type trait class.
Header file for the function trace functionality.