Loading...
Searching...
No Matches
potrf: Cholesky factorization
Batched LA » Linear system solvers » Symmetric/Hermitian positive definite: Cholesky

## Functions

magma_int_t | magma_cpotrf_batched (magma_uplo_t uplo, magma_int_t n, magmaFloatComplex **dA_array, magma_int_t ldda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
| CPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix dA.
magma_int_t | magma_cpotrf_vbatched (magma_uplo_t uplo, magma_int_t *n, magmaFloatComplex **dA_array, magma_int_t *ldda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
| CPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix dA.
magma_int_t | magma_dpotrf_batched (magma_uplo_t uplo, magma_int_t n, double **dA_array, magma_int_t ldda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
| DPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix dA.
magma_int_t | magma_dpotrf_vbatched (magma_uplo_t uplo, magma_int_t *n, double **dA_array, magma_int_t *ldda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
| DPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix dA.
magma_int_t | magma_spotrf_batched (magma_uplo_t uplo, magma_int_t n, float **dA_array, magma_int_t ldda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
| SPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix dA.
magma_int_t | magma_spotrf_vbatched (magma_uplo_t uplo, magma_int_t *n, float **dA_array, magma_int_t *ldda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
| SPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix dA.
magma_int_t | magma_zpotrf_batched (magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex **dA_array, magma_int_t ldda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
| ZPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix dA.
magma_int_t | magma_zpotrf_vbatched (magma_uplo_t uplo, magma_int_t *n, magmaDoubleComplex **dA_array, magma_int_t *ldda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
| ZPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix dA.

## Detailed Description

## Function Documentation

## magma_cpotrf_batched()

magma_int_t magma_cpotrf_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaFloatComplex ** | dA_array,
|  | magma_int_t | ldda,
|  | magma_int_t * | info_array,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix dA.

The factorization has the form dA = U**H * U, if UPLO = MagmaUpper, or dA = L * L**H, if UPLO = MagmaLower, where U is an upper triangular matrix and L is lower triangular.

This is the block version of the algorithm, calling Level 3 BLAS. This is the fixed size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of dA is stored;
  - = MagmaLower: Lower triangle of dA is stored. Only MagmaLower is supported.

  [in] | n | INTEGER The order of the matrix dA. N >= 0.

  [in,out]

  dA_array

  Array of pointers, dimension (batchCount). Each is a COMPLEX array on the GPU, dimension (LDDA,N) On entry, each pointer is a Hermitian matrix dA.
  If UPLO = MagmaUpper, the leading N-by-N upper triangular part of dA contains the upper triangular part of the matrix dA, and the strictly lower triangular part of dA is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of dA contains the lower triangular part of the matrix dA, and the strictly upper triangular part of dA is not referenced.
  On exit, if corresponding entry in info_array = 0, each pointer is the factor U or L from the Cholesky factorization dA = U**H * U or dA = L * L**H.

  [in] | ldda | INTEGER The leading dimension of each array dA. LDDA >= max(1,N). To benefit from coalescent memory accesses LDDA must be divisible by 16.

  [out]

  info_array

  Array of INTEGERs, dimension (batchCount), for corresponding matrices.
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value
  - > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.

  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_cpotrf_vbatched()

magma_int_t magma_cpotrf_vbatched | ( | magma_uplo_t | uplo,
|  | magma_int_t * | n,
|  | magmaFloatComplex ** | dA_array,
|  | magma_int_t * | ldda,
|  | magma_int_t * | info_array,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

CPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix dA.

The factorization has the form dA = U**H * U, if UPLO = MagmaUpper, or dA = L * L**H, if UPLO = MagmaLower, where U is an upper triangular matrix and L is lower triangular.

This is the block version of the algorithm, calling Level 3 BLAS. This is the variable size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of dA is stored;
  - = MagmaLower: Lower triangle of dA is stored. Only MagmaLower is supported.

  [in] | n | INTEGER array, dimension(batchCount + 1). Each element N specifies the order of each matrix A. N >= 0.

  [in,out]

  dA_array

  Array of pointers, dimension (batchCount). Each is a COMPLEX array A on the GPU, dimension (LDDA,N) On entry, each pointer is a Hermitian matrix A.
  If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if corresponding entry in info_array = 0, each pointer is the factor U or L from the Cholesky factorization dA = U**H * U or dA = L * L**H.

  [in] | ldda | INTEGER array, dimension(batchCount + 1). Each element LDDA specifies the leading dimension of each array A. LDDA >= max(1,N). To benefit from coalescent memory accesses LDDA must be divisible by 16.

  [out]

  info_array

  Array of INTEGERs, dimension (batchCount), for corresponding matrices.
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value
  - > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.

  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_dpotrf_batched()

magma_int_t magma_dpotrf_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | double ** | dA_array,
|  | magma_int_t | ldda,
|  | magma_int_t * | info_array,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix dA.

The factorization has the form dA = U**H * U, if UPLO = MagmaUpper, or dA = L * L**H, if UPLO = MagmaLower, where U is an upper triangular matrix and L is lower triangular.

This is the block version of the algorithm, calling Level 3 BLAS. This is the fixed size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of dA is stored;
  - = MagmaLower: Lower triangle of dA is stored. Only MagmaLower is supported.

  [in] | n | INTEGER The order of the matrix dA. N >= 0.

  [in,out]

  dA_array

  Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array on the GPU, dimension (LDDA,N) On entry, each pointer is a symmetric matrix dA.
  If UPLO = MagmaUpper, the leading N-by-N upper triangular part of dA contains the upper triangular part of the matrix dA, and the strictly lower triangular part of dA is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of dA contains the lower triangular part of the matrix dA, and the strictly upper triangular part of dA is not referenced.
  On exit, if corresponding entry in info_array = 0, each pointer is the factor U or L from the Cholesky factorization dA = U**H * U or dA = L * L**H.

  [in] | ldda | INTEGER The leading dimension of each array dA. LDDA >= max(1,N). To benefit from coalescent memory accesses LDDA must be divisible by 16.

  [out]

  info_array

  Array of INTEGERs, dimension (batchCount), for corresponding matrices.
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value
  - > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.

  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_dpotrf_vbatched()

magma_int_t magma_dpotrf_vbatched | ( | magma_uplo_t | uplo,
|  | magma_int_t * | n,
|  | double ** | dA_array,
|  | magma_int_t * | ldda,
|  | magma_int_t * | info_array,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

DPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix dA.

The factorization has the form dA = U**H * U, if UPLO = MagmaUpper, or dA = L * L**H, if UPLO = MagmaLower, where U is an upper triangular matrix and L is lower triangular.

This is the block version of the algorithm, calling Level 3 BLAS. This is the variable size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of dA is stored;
  - = MagmaLower: Lower triangle of dA is stored. Only MagmaLower is supported.

  [in] | n | INTEGER array, dimension(batchCount + 1). Each element N specifies the order of each matrix A. N >= 0.

  [in,out]

  dA_array

  Array of pointers, dimension (batchCount). Each is a DOUBLE PRECISION array A on the GPU, dimension (LDDA,N) On entry, each pointer is a symmetric matrix A.
  If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if corresponding entry in info_array = 0, each pointer is the factor U or L from the Cholesky factorization dA = U**H * U or dA = L * L**H.

  [in] | ldda | INTEGER array, dimension(batchCount + 1). Each element LDDA specifies the leading dimension of each array A. LDDA >= max(1,N). To benefit from coalescent memory accesses LDDA must be divisible by 16.

  [out]

  info_array

  Array of INTEGERs, dimension (batchCount), for corresponding matrices.
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value
  - > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.

  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_spotrf_batched()

magma_int_t magma_spotrf_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | float ** | dA_array,
|  | magma_int_t | ldda,
|  | magma_int_t * | info_array,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix dA.

The factorization has the form dA = U**H * U, if UPLO = MagmaUpper, or dA = L * L**H, if UPLO = MagmaLower, where U is an upper triangular matrix and L is lower triangular.

This is the block version of the algorithm, calling Level 3 BLAS. This is the fixed size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of dA is stored;
  - = MagmaLower: Lower triangle of dA is stored. Only MagmaLower is supported.

  [in] | n | INTEGER The order of the matrix dA. N >= 0.

  [in,out]

  dA_array

  Array of pointers, dimension (batchCount). Each is a REAL array on the GPU, dimension (LDDA,N) On entry, each pointer is a symmetric matrix dA.
  If UPLO = MagmaUpper, the leading N-by-N upper triangular part of dA contains the upper triangular part of the matrix dA, and the strictly lower triangular part of dA is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of dA contains the lower triangular part of the matrix dA, and the strictly upper triangular part of dA is not referenced.
  On exit, if corresponding entry in info_array = 0, each pointer is the factor U or L from the Cholesky factorization dA = U**H * U or dA = L * L**H.

  [in] | ldda | INTEGER The leading dimension of each array dA. LDDA >= max(1,N). To benefit from coalescent memory accesses LDDA must be divisible by 16.

  [out]

  info_array

  Array of INTEGERs, dimension (batchCount), for corresponding matrices.
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value
  - > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.

  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_spotrf_vbatched()

magma_int_t magma_spotrf_vbatched | ( | magma_uplo_t | uplo,
|  | magma_int_t * | n,
|  | float ** | dA_array,
|  | magma_int_t * | ldda,
|  | magma_int_t * | info_array,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

SPOTRF computes the Cholesky factorization of a real symmetric positive definite matrix dA.

The factorization has the form dA = U**H * U, if UPLO = MagmaUpper, or dA = L * L**H, if UPLO = MagmaLower, where U is an upper triangular matrix and L is lower triangular.

This is the block version of the algorithm, calling Level 3 BLAS. This is the variable size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of dA is stored;
  - = MagmaLower: Lower triangle of dA is stored. Only MagmaLower is supported.

  [in] | n | INTEGER array, dimension(batchCount + 1). Each element N specifies the order of each matrix A. N >= 0.

  [in,out]

  dA_array

  Array of pointers, dimension (batchCount). Each is a REAL array A on the GPU, dimension (LDDA,N) On entry, each pointer is a symmetric matrix A.
  If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if corresponding entry in info_array = 0, each pointer is the factor U or L from the Cholesky factorization dA = U**H * U or dA = L * L**H.

  [in] | ldda | INTEGER array, dimension(batchCount + 1). Each element LDDA specifies the leading dimension of each array A. LDDA >= max(1,N). To benefit from coalescent memory accesses LDDA must be divisible by 16.

  [out]

  info_array

  Array of INTEGERs, dimension (batchCount), for corresponding matrices.
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value
  - > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.

  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_zpotrf_batched()

magma_int_t magma_zpotrf_batched | ( | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaDoubleComplex ** | dA_array,
|  | magma_int_t | ldda,
|  | magma_int_t * | info_array,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix dA.

The factorization has the form dA = U**H * U, if UPLO = MagmaUpper, or dA = L * L**H, if UPLO = MagmaLower, where U is an upper triangular matrix and L is lower triangular.

This is the block version of the algorithm, calling Level 3 BLAS. This is the fixed size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of dA is stored;
  - = MagmaLower: Lower triangle of dA is stored. Only MagmaLower is supported.

  [in] | n | INTEGER The order of the matrix dA. N >= 0.

  [in,out]

  dA_array

  Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array on the GPU, dimension (LDDA,N) On entry, each pointer is a Hermitian matrix dA.
  If UPLO = MagmaUpper, the leading N-by-N upper triangular part of dA contains the upper triangular part of the matrix dA, and the strictly lower triangular part of dA is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of dA contains the lower triangular part of the matrix dA, and the strictly upper triangular part of dA is not referenced.
  On exit, if corresponding entry in info_array = 0, each pointer is the factor U or L from the Cholesky factorization dA = U**H * U or dA = L * L**H.

  [in] | ldda | INTEGER The leading dimension of each array dA. LDDA >= max(1,N). To benefit from coalescent memory accesses LDDA must be divisible by 16.

  [out]

  info_array

  Array of INTEGERs, dimension (batchCount), for corresponding matrices.
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value
  - > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.

  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_zpotrf_vbatched()

magma_int_t magma_zpotrf_vbatched | ( | magma_uplo_t | uplo,
|  | magma_int_t * | n,
|  | magmaDoubleComplex ** | dA_array,
|  | magma_int_t * | ldda,
|  | magma_int_t * | info_array,
|  | magma_int_t | batchCount,
|  | magma_queue_t | queue )

ZPOTRF computes the Cholesky factorization of a complex Hermitian positive definite matrix dA.

The factorization has the form dA = U**H * U, if UPLO = MagmaUpper, or dA = L * L**H, if UPLO = MagmaLower, where U is an upper triangular matrix and L is lower triangular.

This is the block version of the algorithm, calling Level 3 BLAS. This is the variable size batched version of the operation.

Parameters

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of dA is stored;
  - = MagmaLower: Lower triangle of dA is stored. Only MagmaLower is supported.

  [in] | n | INTEGER array, dimension(batchCount + 1). Each element N specifies the order of each matrix A. N >= 0.

  [in,out]

  dA_array

  Array of pointers, dimension (batchCount). Each is a COMPLEX_16 array A on the GPU, dimension (LDDA,N) On entry, each pointer is a Hermitian matrix A.
  If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if corresponding entry in info_array = 0, each pointer is the factor U or L from the Cholesky factorization dA = U**H * U or dA = L * L**H.

  [in] | ldda | INTEGER array, dimension(batchCount + 1). Each element LDDA specifies the leading dimension of each array A. LDDA >= max(1,N). To benefit from coalescent memory accesses LDDA must be divisible by 16.

  [out]

  info_array

  Array of INTEGERs, dimension (batchCount), for corresponding matrices.
  - = 0: successful exit
  - < 0: if INFO = -i, the i-th argument had an illegal value
  - > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.

  [in] | batchCount | INTEGER The number of matrices to operate on.
  [in] | queue | magma_queue_t Queue to execute in.