potrs.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_LAPACK_POTRS_H_
36 #define _BLAZE_MATH_LAPACK_POTRS_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <boost/cast.hpp>
51 #include <blaze/util/Assert.h>
52 #include <blaze/util/Complex.h>
54 #include <blaze/util/Exception.h>
56 
57 
58 namespace blaze {
59 
60 //=================================================================================================
61 //
62 // LAPACK FORWARD DECLARATIONS
63 //
64 //=================================================================================================
65 
66 //*************************************************************************************************
68 extern "C" {
69 
70 void spotrs_( char* uplo, int* n, int* nrhs, float* A, int* lda, float* B, int* ldb, int* info );
71 void dpotrs_( char* uplo, int* n, int* nrhs, double* A, int* lda, double* B, int* ldb, int* info );
72 void cpotrs_( char* uplo, int* n, int* nrhs, float* A, int* lda, float* B, int* ldb, int* info );
73 void zpotrs_( char* uplo, int* n, int* nrhs, double* A, int* lda, double* B, int* ldb, int* info );
74 
75 }
77 //*************************************************************************************************
78 
79 
80 
81 
82 //=================================================================================================
83 //
84 // LAPACK LLH-BASED SUBSTITUTION FUNCTIONS (POTRS)
85 //
86 //=================================================================================================
87 
88 //*************************************************************************************************
91 inline void potrs( char uplo, int n, int nrhs, const float* A, int lda, float* B, int ldb, int* info );
92 
93 inline void potrs( char uplo, int n, int nrhs, const double* A, int lda, double* B, int ldb, int* info );
94 
95 inline void potrs( char uplo, int n, int nrhs, const complex<float>* A, int lda, complex<float>* B, int ldb, int* info );
96 
97 inline void potrs( char uplo, int n, int nrhs, const complex<double>* A, int lda, complex<double>* B, int ldb, int* info );
98 
99 template< typename MT, bool SO, typename VT, bool TF >
100 inline void potrs( const DenseMatrix<MT,SO>& A, DenseVector<VT,TF>& b, char uplo );
101 
102 template< typename MT1, bool SO1, typename MT2, bool SO2 >
103 inline void potrs( const DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B, char uplo );
105 //*************************************************************************************************
106 
107 
108 //*************************************************************************************************
140 inline void potrs( char uplo, int n, int nrhs, const float* A, int lda, float* B, int ldb, int* info )
141 {
142  spotrs_( &uplo, &n, &nrhs, const_cast<float*>( A ), &lda, B, &ldb, info );
143 }
144 //*************************************************************************************************
145 
146 
147 //*************************************************************************************************
179 inline void potrs( char uplo, int n, int nrhs, const double* A, int lda, double* B, int ldb, int* info )
180 {
181  dpotrs_( &uplo, &n, &nrhs, const_cast<double*>( A ), &lda, B, &ldb, info );
182 }
183 //*************************************************************************************************
184 
185 
186 //*************************************************************************************************
218 inline void potrs( char uplo, int n, int nrhs, const complex<float>* A,
219  int lda, complex<float>* B, int ldb, int* info )
220 {
221  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
222 
223  cpotrs_( &uplo, &n, &nrhs, const_cast<float*>( reinterpret_cast<const float*>( A ) ),
224  &lda, reinterpret_cast<float*>( B ), &ldb, info );
225 }
226 //*************************************************************************************************
227 
228 
229 //*************************************************************************************************
261 inline void potrs( char uplo, int n, int nrhs, const complex<double>* A,
262  int lda, complex<double>* B, int ldb, int* info )
263 {
264  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
265 
266  zpotrs_( &uplo, &n, &nrhs, const_cast<double*>( reinterpret_cast<const double*>( A ) ),
267  &lda, reinterpret_cast<double*>( B ), &ldb, info );
268 }
269 //*************************************************************************************************
270 
271 
272 //*************************************************************************************************
352 template< typename MT // Type of the system matrix
353  , bool SO // Storage order of the system matrix
354  , typename VT // Type of the right-hand side vector
355  , bool TF > // Transpose flag of the right-hand side vector
356 inline void potrs( const DenseMatrix<MT,SO>& A, DenseVector<VT,TF>& b, char uplo )
357 {
358  using boost::numeric_cast;
359 
367 
368  typedef typename MT::OppositeType OT;
369  typedef typename MT::ElementType ET;
370 
371  if( !isSquare( ~A ) ) {
372  BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
373  }
374 
375  if( uplo != 'L' && uplo != 'U' ) {
376  BLAZE_THROW_INVALID_ARGUMENT( "Invalid uplo argument provided" );
377  }
378 
379  int n ( numeric_cast<int>( (~A).rows() ) );
380  int nrhs( 1 );
381  int lda ( numeric_cast<int>( (~A).spacing() ) );
382  int ldb ( numeric_cast<int>( (~b).size() ) );
383  int info( 0 );
384 
385  if( n == 0 ) {
386  return;
387  }
388 
390  ( uplo == 'L' )?( uplo = 'U' ):( uplo = 'L' );
391  }
392 
393  potrs( uplo, n, nrhs, (~A).data(), lda, (~b).data(), ldb, &info );
394 
395  BLAZE_INTERNAL_ASSERT( info == 0, "Invalid function argument" );
396 }
397 //*************************************************************************************************
398 
399 
400 //*************************************************************************************************
481 template< typename MT1 // Type of the system matrix
482  , bool SO1 // Storage order of the system matrix
483  , typename MT2 // Type of the right-hand side matrix
484  , bool SO2 > // Storage order of the right-hand side matrix
485 inline void potrs( const DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B, char uplo )
486 {
487  using boost::numeric_cast;
488 
497 
498  typedef typename MT1::OppositeType OT1;
499  typedef typename MT2::OppositeType OT2;
500  typedef typename MT1::ElementType ET1;
501 
502  if( !isSquare( ~A ) ) {
503  BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
504  }
505 
506  if( uplo != 'L' && uplo != 'U' ) {
507  BLAZE_THROW_INVALID_ARGUMENT( "Invalid uplo argument provided" );
508  }
509 
510  int n ( numeric_cast<int>( (~A).rows() ) );
511  int mrhs( numeric_cast<int>( SO2 ? (~B).rows() : (~B).columns() ) );
512  int nrhs( numeric_cast<int>( SO2 ? (~B).columns() : (~B).rows() ) );
513  int lda ( numeric_cast<int>( (~A).spacing() ) );
514  int ldb ( numeric_cast<int>( (~B).spacing() ) );
515  int info( 0 );
516 
517  if( n != mrhs ) {
518  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
519  }
520 
521  if( n == 0 ) {
522  return;
523  }
524 
526  ( uplo == 'L' )?( uplo = 'U' ):( uplo = 'L' );
527  }
528 
529  potrs( uplo, n, nrhs, (~A).data(), lda, (~B).data(), ldb, &info );
530 
531  BLAZE_INTERNAL_ASSERT( info == 0, "Invalid function argument" );
532 }
533 //*************************************************************************************************
534 
535 } // namespace blaze
536 
537 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
Constraint on the data type.
Data type constraint.
Log level for high-level information.
Definition: LogLevel.h:80
#define BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS(T)
Constraint on the data type.In case the given data type T does not provide low-level data access to m...
Definition: MutableDataAccess.h:79
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix)
Checks if the given matrix is a square matrix.
Definition: Matrix.h:603
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:252
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.In case the given data type T is a computational expression (i...
Definition: Computation.h:118
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:308
Header file for the DenseVector base class.
Constraint on the data type.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2584
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ADAPTOR_TYPE(T)
Constraint on the data type.In case the given data type T is an adaptor type (as for instance LowerMa...
Definition: Adaptor.h:118
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
void potrs(char uplo, int n, int nrhs, const float *A, int lda, float *B, int ldb, int *info)
LAPACK kernel for the substitution step of solving a positive definite single precision linear system...
Definition: potrs.h:140
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Compile time assertion.
Compile time check for row-major matrix types.This type trait tests whether or not the given template...
Definition: IsRowMajorMatrix.h:110
Header file for the DenseMatrix base class.
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE(A, B)
Data type constraint.In case the two types A and B are not the same (ignoring all cv-qualifiers of bo...
Definition: SameType.h:89
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2586
Constraint on the data type.
Constraint on the data type.
const bool spacing
Adding an additional spacing line between two log messages.This setting gives the opportunity to add ...
Definition: Logging.h:70
Header file for run time assertion macros.
#define BLAZE_CONSTRAINT_MUST_BE_BLAS_COMPATIBLE_TYPE(T)
Constraint on the data type.In case the given data type T is not a BLAS compatible data type (i...
Definition: BlasCompatible.h:79
Header file for the IsRowMajorMatrix type trait.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:324
Header file for the complex data type.
Header file for exception macros.
#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
#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