Blaze 3.9
hesv.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_LAPACK_HESV_H_
36#define _BLAZE_MATH_LAPACK_HESV_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <memory>
44#include <blaze/math/Aliases.h>
54#include <blaze/util/Assert.h>
57
58
59namespace blaze {
60
61//=================================================================================================
62//
63// LAPACK HERMITIAN INDEFINITE LINEAR SYSTEM FUNCTIONS (HESV)
64//
65//=================================================================================================
66
67//*************************************************************************************************
70template< typename MT, bool SO, typename VT, bool TF >
71void hesv( DenseMatrix<MT,SO>& A, DenseVector<VT,TF>& b, char uplo, blas_int_t* ipiv );
72
73template< typename MT1, bool SO1, typename MT2, bool SO2 >
74void hesv( DenseMatrix<MT1,SO1>& A, DenseMatrix<MT2,SO2>& B, char uplo, blas_int_t* ipiv );
76//*************************************************************************************************
77
78
79//*************************************************************************************************
138template< typename MT // Type of the system matrix
139 , bool SO // Storage order of the system matrix
140 , typename VT // Type of the right-hand side vector
141 , bool TF > // Transpose flag of the right-hand side vector
142inline void hesv( DenseMatrix<MT,SO>& A, DenseVector<VT,TF>& b, char uplo, blas_int_t* ipiv )
143{
149
154
155 using ET = ElementType_t<MT>;
156
157 if( !isSquare( *A ) ) {
158 BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
159 }
160
161 if( (*b).size() != (*A).rows() ) {
162 BLAZE_THROW_INVALID_ARGUMENT( "Invalid right-hand side vector provided" );
163 }
164
165 if( uplo != 'L' && uplo != 'U' ) {
166 BLAZE_THROW_INVALID_ARGUMENT( "Invalid uplo argument provided" );
167 }
168
169 blas_int_t n ( numeric_cast<blas_int_t>( (*A).rows() ) );
170 blas_int_t nrhs( 1 );
171 blas_int_t lda ( numeric_cast<blas_int_t>( (*A).spacing() ) );
172 blas_int_t ldb ( numeric_cast<blas_int_t>( (*b).size() ) );
173 blas_int_t info( 0 );
174
175 if( n == 0 ) {
176 return;
177 }
178
179 if( IsRowMajorMatrix_v<MT> ) {
180 ( uplo == 'L' )?( uplo = 'U' ):( uplo = 'L' );
181 }
182
183 blas_int_t lwork( n*lda );
184 const std::unique_ptr<ET[]> work( new ET[lwork] );
185
186 hesv( uplo, n, nrhs, (*A).data(), lda, ipiv, (*b).data(), ldb, work.get(), lwork, &info );
187
188 BLAZE_INTERNAL_ASSERT( info >= 0, "Invalid function argument" );
189
190 if( info > 0 ) {
191 BLAZE_THROW_LAPACK_ERROR( "Inversion of singular matrix failed" );
192 }
193}
194//*************************************************************************************************
195
196
197//*************************************************************************************************
260template< typename MT1 // Type of the system matrix
261 , bool SO1 // Storage order of the system matrix
262 , typename MT2 // Type of the right-hand side matrix
263 , bool SO2 > // Storage order of the right-hand side matrix
265 char uplo, blas_int_t* ipiv )
266{
272
278
279 using ET = ElementType_t<MT1>;
280
281 if( !isSquare( *A ) ) {
282 BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
283 }
284
285 if( uplo != 'L' && uplo != 'U' ) {
286 BLAZE_THROW_INVALID_ARGUMENT( "Invalid uplo argument provided" );
287 }
288
289 blas_int_t n ( numeric_cast<blas_int_t>( (*A).rows() ) );
290 blas_int_t mrhs( numeric_cast<blas_int_t>( SO2 ? (*B).rows() : (*B).columns() ) );
291 blas_int_t nrhs( numeric_cast<blas_int_t>( SO2 ? (*B).columns() : (*B).rows() ) );
292 blas_int_t lda ( numeric_cast<blas_int_t>( (*A).spacing() ) );
293 blas_int_t ldb ( numeric_cast<blas_int_t>( (*B).spacing() ) );
294 blas_int_t info( 0 );
295
296 if( n != mrhs ) {
297 BLAZE_THROW_INVALID_ARGUMENT( "Invalid right-hand side matrix provided" );
298 }
299
300 if( n == 0 ) {
301 return;
302 }
303
304 if( IsRowMajorMatrix_v<MT1> ) {
305 ( uplo == 'L' )?( uplo = 'U' ):( uplo = 'L' );
306 }
307
308 blas_int_t lwork( n*lda );
309 const std::unique_ptr<ET[]> work( new ET[lwork] );
310
311 hesv( uplo, n, nrhs, (*A).data(), lda, ipiv, (*B).data(), ldb, work.get(), lwork, &info );
312
313 BLAZE_INTERNAL_ASSERT( info >= 0, "Invalid function argument" );
314
315 if( info > 0 ) {
316 BLAZE_THROW_LAPACK_ERROR( "Inversion of singular matrix failed" );
317 }
318}
319//*************************************************************************************************
320
321} // namespace blaze
322
323#endif
Constraint on the data type.
Header file for auxiliary alias declarations.
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.
Definition: Aliases.h:190
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
Header file for the IsRowMajorMatrix type trait.
Constraint on the data type.
Cast operators for numeric types.
Data type constraint.
Header file for the CLAPACK hesv wrapper functions.
Base class for dense matrices.
Definition: DenseMatrix.h:82
Base class for N-dimensional dense vectors.
Definition: DenseVector.h:77
Constraint on the data type.
Header file for the DenseMatrix base class.
#define BLAZE_CONSTRAINT_MUST_BE_SAME_TYPE(A, B)
Data type constraint.
Definition: SameType.h:71
void hesv(DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, char uplo, blas_int_t *ipiv)
LAPACK kernel for solving a Hermitian indefinite linear system of equations ( ).
Definition: hesv.h:264
#define BLAZE_CONSTRAINT_MUST_BE_BLAS_COMPATIBLE_TYPE(T)
Constraint on the data type.
Definition: BLASCompatible.h:61
#define BLAZE_CONSTRAINT_MUST_BE_CONTIGUOUS_TYPE(T)
Constraint on the data type.
Definition: Contiguous.h:61
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.
Definition: Computation.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ADAPTOR_TYPE(T)
Constraint on the data type.
Definition: Adaptor.h:81
#define BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS(T)
Constraint on the data type.
Definition: MutableDataAccess.h:61
int32_t blas_int_t
Signed integer type used in the BLAS/LAPACK wrapper functions.
Definition: Types.h:64
#define BLAZE_THROW_LAPACK_ERROR(MESSAGE)
Macro for the emission of an exception on detection of a LAPACK error.
Definition: Exception.h:146
bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:1383
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition: Exception.h:235
Header file for the exception macros of the math module.