Matrix Solver Runtime Library APIs

This section describes the Fortran interfaces to the CUDA cuSOLVER library. The cuSOLVER functions are only accessible from host code. All of the runtime API routines are integer functions that return an error code; they return a value of CUSOLVER_STATUS_SUCCESS if the call was successful, or another cuSOLVER status return value if there was an error.

Currently we provide Fortran interfaces to the cuSolverDN, the dense LAPACK functions.

Chapter 10 contains examples of accessing the cuSOLVER library routines from OpenACC and CUDA Fortran. In both cases, the interfaces to the library can be exposed by adding the line

use cusolverDn

to your program unit.

Unless a specific kind is provided, the plain integer type used in the interfaces implies integer(4) and the plain real type implies real(4).

CUSOLVER Definitions and Helper Functions

This section contains definitions and data types used in the cuSOLVER library and interfaces to the cuSOLVER helper functions.

The cuSOLVER module contains the following derived type definitions:

! Definitions from cusolver_common.h
integer, parameter :: CUSOLVER_VER_MAJOR = 11
integer, parameter :: CUSOLVER_VER_MINOR = 6
integer, parameter :: CUSOLVER_VER_PATCH = 4

The cuSOLVER module contains the following enumerations:

enum, bind(c)
    enumerator :: CUSOLVER_STATUS_SUCCESS                   = 0
    enumerator :: CUSOLVER_STATUS_NOT_INITIALIZED           = 1
    enumerator :: CUSOLVER_STATUS_ALLOC_FAILED              = 2
    enumerator :: CUSOLVER_STATUS_INVALID_VALUE             = 3
    enumerator :: CUSOLVER_STATUS_ARCH_MISMATCH             = 4
    enumerator :: CUSOLVER_STATUS_MAPPING_ERROR             = 5
    enumerator :: CUSOLVER_STATUS_EXECUTION_FAILED          = 6
    enumerator :: CUSOLVER_STATUS_INTERNAL_ERROR            = 7
    enumerator :: CUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED = 8
    enumerator :: CUSOLVER_STATUS_NOT_SUPPORTED             = 9
    enumerator :: CUSOLVER_STATUS_ZERO_PIVOT                = 10
    enumerator :: CUSOLVER_STATUS_INVALID_LICENSE           = 11
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_NOT_INITIALIZED= 12
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_INVALID        = 13
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_INVALID_PREC   = 14
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_INVALID_REFINE = 15
    enumerator :: CUSOLVER_STATUS_IRS_PARAMS_INVALID_MAXITER= 16
    enumerator :: CUSOLVER_STATUS_IRS_INTERNAL_ERROR        = 20
    enumerator :: CUSOLVER_STATUS_IRS_NOT_SUPPORTED         = 21
    enumerator :: CUSOLVER_STATUS_IRS_OUT_OF_RANGE          = 22
    enumerator :: CUSOLVER_STATUS_IRS_NRHS_NOT_SUPPORTED_FOR_REFINE_GMRES=23
    enumerator :: CUSOLVER_STATUS_IRS_INFOS_NOT_INITIALIZED = 25
    enumerator :: CUSOLVER_STATUS_IRS_INFOS_NOT_DESTROYED   = 26
    enumerator :: CUSOLVER_STATUS_IRS_MATRIX_SINGULAR       = 30
    enumerator :: CUSOLVER_STATUS_INVALID_WORKSPACE         = 31
end enum

enum, bind(c)
    enumerator :: CUSOLVER_EIG_TYPE_1 = 1
    enumerator :: CUSOLVER_EIG_TYPE_2 = 2
    enumerator :: CUSOLVER_EIG_TYPE_3 = 3
end enum

enum, bind(c)
    enumerator :: CUSOLVER_EIG_MODE_NOVECTOR = 0
    enumerator :: CUSOLVER_EIG_MODE_VECTOR   = 1
end enum

enum, bind(c)
    enumerator :: CUSOLVER_EIG_RANGE_ALL = 1001
    enumerator :: CUSOLVER_EIG_RANGE_I   = 1002
    enumerator :: CUSOLVER_EIG_RANGE_V   = 1003
end enum

enum, bind(c)
    enumerator :: CUSOLVER_INF_NORM = 104
    enumerator :: CUSOLVER_MAX_NORM = 105
    enumerator :: CUSOLVER_ONE_NORM = 106
    enumerator :: CUSOLVER_FRO_NORM = 107
end enum

enum, bind(c)
    enumerator :: CUSOLVER_IRS_REFINE_NOT_SET          = 1100
    enumerator :: CUSOLVER_IRS_REFINE_NONE             = 1101
    enumerator :: CUSOLVER_IRS_REFINE_CLASSICAL        = 1102
    enumerator :: CUSOLVER_IRS_REFINE_CLASSICAL_GMRES  = 1103
    enumerator :: CUSOLVER_IRS_REFINE_GMRES            = 1104
    enumerator :: CUSOLVER_IRS_REFINE_GMRES_GMRES      = 1105
    enumerator :: CUSOLVER_IRS_REFINE_GMRES_NOPCOND    = 1106

    enumerator :: CUSOLVER_PREC_DD           = 1150
    enumerator :: CUSOLVER_PREC_SS           = 1151
    enumerator :: CUSOLVER_PREC_SHT          = 1152
end enum

enum, bind(c)
    enumerator :: CUSOLVER_R_8I  = 1201
    enumerator :: CUSOLVER_R_8U  = 1202
    enumerator :: CUSOLVER_R_64F = 1203
    enumerator :: CUSOLVER_R_32F = 1204
    enumerator :: CUSOLVER_R_16F = 1205
    enumerator :: CUSOLVER_R_16BF  = 1206
    enumerator :: CUSOLVER_R_TF32  = 1207
    enumerator :: CUSOLVER_R_AP  = 1208
    enumerator :: CUSOLVER_C_8I  = 1211
    enumerator :: CUSOLVER_C_8U  = 1212
    enumerator :: CUSOLVER_C_64F = 1213
    enumerator :: CUSOLVER_C_32F = 1214
    enumerator :: CUSOLVER_C_16F = 1215
    enumerator :: CUSOLVER_C_16BF  = 1216
    enumerator :: CUSOLVER_C_TF32  = 1217
    enumerator :: CUSOLVER_C_AP  = 1218
end enum

enum, bind(c)
    enumerator :: CUSOLVER_ALG_0 = 0
    enumerator :: CUSOLVER_ALG_1 = 1
end enum

enum, bind(c)
    enumerator :: CUBLAS_STOREV_COLUMNWISE = 0
    enumerator :: CUBLAS_STOREV_ROWWISE    = 1
end enum

enum, bind(c)
    enumerator :: CUBLAS_DIRECT_FORWARD    = 0
    enumerator :: CUBLAS_DIRECT_BACKWARD   = 1
end enum

The cuSOLVERDN module contains the following enumerations and type definitions:

type cusolverDnHandle
  type(c_ptr) :: handle
end type

type cusolverDnParams
  type(c_ptr) :: params
end type

type cusolverDnSyevjInfo
  type(c_ptr) :: info
end type

enum, bind(c)
    enumerator :: CUSOLVERDN_GETRF = 0
end enum

cusolverDnCreate

This function initializes the cusolverDn library and creates a handle on the cusolverDn context. It must be called before any other cuSolverDn API function is invoked. It allocates hardware resources necessary for accessing the GPU.

integer(4) function cusolverDnCreate(handle)
  type(cusolverDnHandle) :: handle

cusolverDnDestroy

This function releases CPU-side resources used by the cuSolverDn library.

integer(4) function cusolverDnDestroy(handle)
  type(cusolverDnHandle) :: handle

cusolverDnCreateParams

This function creates and initializes the 64-bit API structure to default values.

integer(4) function cusolverDnCreateParams(params)
  type(cusolverDnParams) :: params

cusolverDnDestroyParams

This function releases any resources used by the 64-bit API structure.

integer(4) function cusolverDnDestroyParams(params)
  type(cusolverDnParams) :: params

cusolverDnCreateSyevjInfo

This function creates and initializes the Syevj API structure to default values.

integer(4) function cusolverDnCreateSyevjInfo(info)
  type(cusolverDnSyevjInfo) :: info

cusolverDnDestroySyevjInfo

This function releases any resources used by the Syevj API structure.

integer(4) function cusolverDnDestroySyevjInfo(info)
  type(cusolverDnSyevjInfo) :: info

cusolverDnSetAdvOptions

This function configures the algorithm used in the 64-bit API.

integer(4) function cusolverDnSetAdvOptions(params, function, algo)
   type(cusolverDnParams) :: params
   integer(4) :: function, algo

cusolverDnGetStream

This function gets the stream used by the cuSolverDn library to execute its routines.

integer(4) function cusolverDnGetStream(handle, stream)
  type(cusolverDnHandle) :: handle
  integer(cuda_stream_kind) :: stream

cusolverDnSetStream

This function sets the stream to be used by the cuSolverDn library to execute its routines.

integer(4) function cusolverDnSetStream(handle, stream)
  type(cusolverDnHandle) :: handle
  integer(cuda_stream_kind) :: stream

cusolverDnXsyevjSetTolerance

This function configures the tolerance value used in the Xsyevj functions.

integer(4) function cusolverDnXsyevjSetTolerance(info, tolerance)
   type(cusolverSyevjInfo) :: info
   real(8) :: tolerance

cusolverDnXsyevjSetMaxSweeps

This function sets the maximum number of sweeps used in the Xsyevj functions.

integer(4) function cusolverDnXsyevjSetMaxSweeps(info, sweeps)
   type(cusolverSyevjInfo) :: info
   integer(4) :: sweeps

cusolverDnXsyevjSetSortEig

This function sets the sorting behavior used in the Xsyevj functions.

integer(4) function cusolverDnXsyevjSetSortEig(info, sort_eig)
   type(cusolverSyevjInfo) :: info
   integer(4) :: sort_eig

cusolverDnXsyevjGetResidual

This function provides the residual after the execution of the Xsyevj functions.

integer(4) function cusolverDnXsyevjGetResidual(handle, info, residual)
   type(cusolverDnHandle)  :: handle
   type(cusolverSyevjInfo) :: info
   real(8) :: residual

cusolverDnXsyevjGetSweeps

This function provides the number of sweeps used after the execution of the Xsyevj functions.

integer(4) function cusolverDnXsyevjGetSweeps(handle, info, sweeps)
   type(cusolverDnHandle)  :: handle
   type(cusolverSyevjInfo) :: info
   integer(4) :: sweeps

cusolverDn Legacy API

This section describes the linear solver legacy API of cusolverDn, including Cholesky factorization, LU with partial pivoting, QR factorization, and Bunch-Kaufman (LDLT) factorization.

cusolverDnSpotrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSpotrf

integer function cusolverDnSpotrf_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnDpotrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDpotrf

integer function cusolverDnDpotrf_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnCpotrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCpotrf

integer function cusolverDnCpotrf_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnZpotrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZpotrf

integer function cusolverDnZpotrf_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnSpotrf

This function computes the Cholesky factorization of a Hermitian positive-definite matrix

integer function cusolverDnSpotrf(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDpotrf

This function computes the Cholesky factorization of a Hermitian positive-definite matrix

integer function cusolverDnDpotrf(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCpotrf

This function computes the Cholesky factorization of a Hermitian positive-definite matrix

integer function cusolverDnCpotrf(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZpotrf

This function computes the Cholesky factorization of a Hermitian positive-definite matrix

integer function cusolverDnZpotrf(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSpotrs

This function solves the system of linear equations resulting from the Cholesky factorization of a Hermitian positive-definite matrix using cusolverDnSpotrf

integer function cusolverDnSpotrs(handle, &
    uplo, n, nrhs, A, lda, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnDpotrs

This function solves the system of linear equations resulting from the Cholesky factorization of a Hermitian positive-definite matrix using cusolverDnDpotrf

integer function cusolverDnDpotrs(handle, &
    uplo, n, nrhs, A, lda, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnCpotrs

This function solves the system of linear equations resulting from the Cholesky factorization of a Hermitian positive-definite matrix using cusolverDnCpotrf

integer function cusolverDnCpotrs(handle, &
    uplo, n, nrhs, A, lda, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnZpotrs

This function solves the system of linear equations resulting from the Cholesky factorization of a Hermitian positive-definite matrix using cusolverDnZpotrf

integer function cusolverDnZpotrs(handle, &
    uplo, n, nrhs, A, lda, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnSpotrfBatched

This function computes the Cholesky factorization of a sequence of Hermitian positive-definite matrices

integer function cusolverDnSpotrfBatched(handle, &
    uplo, n, Aarray, lda, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, batchCount
    type(c_devptr), device :: Aarray(*)
    integer(4), device, intent(out) :: devinfo

cusolverDnDpotrfBatched

This function computes the Cholesky factorization of a sequence of Hermitian positive-definite matrices

integer function cusolverDnDpotrfBatched(handle, &
    uplo, n, Aarray, lda, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, batchCount
    type(c_devptr), device :: Aarray(*)
    integer(4), device, intent(out) :: devinfo

cusolverDnCpotrfBatched

This function computes the Cholesky factorization of a sequence of Hermitian positive-definite matrices

integer function cusolverDnCpotrfBatched(handle, &
    uplo, n, Aarray, lda, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, batchCount
    type(c_devptr), device :: Aarray(*)
    integer(4), device, intent(out) :: devinfo

cusolverDnZpotrfBatched

This function computes the Cholesky factorization of a sequence of Hermitian positive-definite matrices

integer function cusolverDnZpotrfBatched(handle, &
    uplo, n, Aarray, lda, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, batchCount
    type(c_devptr), device :: Aarray(*)
    integer(4), device, intent(out) :: devinfo

cusolverDnSpotrsBatched

This function solves a sequence of linear systems resulting from the Cholesky factorization of a sequence of Hermitian positive-definite matrices using cusolverDnSpotrfBatched

integer function cusolverDnSpotrsBatched(handle, &
    uplo, n, nrhs, Aarray, lda, Barray, ldb, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, batchCount
    type(c_devptr), device :: Aarray(*)
    type(c_devptr), device :: Barray(*)
    integer(4), device, intent(out) :: devinfo

cusolverDnDpotrsBatched

This function solves a sequence of linear systems resulting from the Cholesky factorization of a sequence of Hermitian positive-definite matrices using cusolverDnDpotrfBatched

integer function cusolverDnDpotrsBatched(handle, &
    uplo, n, nrhs, Aarray, lda, Barray, ldb, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, batchCount
    type(c_devptr), device :: Aarray(*)
    type(c_devptr), device :: Barray(*)
    integer(4), device, intent(out) :: devinfo

cusolverDnCpotrsBatched

This function solves a sequence of linear systems resulting from the Cholesky factorization of a sequence of Hermitian positive-definite matrices using cusolverDnCpotrfBatched

integer function cusolverDnCpotrsBatched(handle, &
    uplo, n, nrhs, Aarray, lda, Barray, ldb, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, batchCount
    type(c_devptr), device :: Aarray(*)
    type(c_devptr), device :: Barray(*)
    integer(4), device, intent(out) :: devinfo

cusolverDnZpotrsBatched

This function solves a sequence of linear systems resulting from the Cholesky factorization of a sequence of Hermitian positive-definite matrices using cusolverDnZpotrfBatched

integer function cusolverDnZpotrsBatched(handle, &
    uplo, n, nrhs, Aarray, lda, Barray, ldb, devinfo, batchCount)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, batchCount
    type(c_devptr), device :: Aarray(*)
    type(c_devptr), device :: Barray(*)
    integer(4), device, intent(out) :: devinfo

cusolverDnSpotri_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSpotri

integer function cusolverDnSpotri_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnDpotri_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDpotri

integer function cusolverDnDpotri_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnCpotri_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCpotri

integer function cusolverDnCpotri_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnZpotri_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZpotri

integer function cusolverDnZpotri_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnSpotri

This function computes the inverse of a positive-definite matrix using the Cholesky factorization computed by cusolverDnSpotrf.

integer function cusolverDnSpotri(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDpotri

This function computes the inverse of a positive-definite matrix using the Cholesky factorization computed by cusolverDnDpotrf.

integer function cusolverDnDpotri(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCpotri

This function computes the inverse of a positive-definite matrix using the Cholesky factorization computed by cusolverDnCpotrf.

integer function cusolverDnCpotri(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZpotri

This function computes the inverse of a positive-definite matrix using the Cholesky factorization computed by cusolverDnZpotrf.

integer function cusolverDnZpotri(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnStrtri_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnStrtri

integer function cusolverDnStrtri_buffersize(handle, &
    uplo, diag, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnDtrtri_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDtrtri

integer function cusolverDnDtrtri_buffersize(handle, &
    uplo, diag, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnCtrtri_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCtrtri

integer function cusolverDnCtrtri_buffersize(handle, &
    uplo, diag, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnZtrtri_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZtrtri

integer function cusolverDnZtrtri_buffersize(handle, &
    uplo, diag, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnStrtri

This function computes the inverse of an upper or lower triangular matrix A. It is typically called by cusolverDnSpotri.

integer function cusolverDnStrtri(handle, &
    uplo, diag, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDtrtri

This function computes the inverse of an upper or lower triangular matrix A. It is typically called by cusolverDnDpotri.

integer function cusolverDnDtrtri(handle, &
    uplo, diag, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCtrtri

This function computes the inverse of an upper or lower triangular matrix A. It is typically called by cusolverDnCpotri.

integer function cusolverDnCtrtri(handle, &
    uplo, diag, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZtrtri

This function computes the inverse of an upper or lower triangular matrix A. It is typically called by cusolverDnZpotri.

integer function cusolverDnZtrtri(handle, &
    uplo, diag, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSlauum_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSlauum

integer function cusolverDnSlauum_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnDlauum_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDlauum

integer function cusolverDnDlauum_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnClauum_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnClauum

integer function cusolverDnClauum_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnZlauum_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZlauum

integer function cusolverDnZlauum_buffersize(handle, &
    uplo, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnSlauum

This function computes the product U * U**T or L**T * L. It is typically called by cusolverDnSpotri.

integer function cusolverDnSlauum(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDlauum

This function computes the product U * U**T or L**T * L. It is typically called by cusolverDnDpotri.

integer function cusolverDnDlauum(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnClauum

This function computes the product U * U**T or L**T * L. It is typically called by cusolverDnCpotri.

integer function cusolverDnClauum(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZlauum

This function computes the product U * U**T or L**T * L. It is typically called by cusolverDnZpotri.

integer function cusolverDnZlauum(handle, &
    uplo, n, A, lda, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSgetrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSgetrf

integer function cusolverDnSgetrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnDgetrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDgetrf

integer function cusolverDnDgetrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnCgetrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCgetrf

integer function cusolverDnCgetrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnZgetrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZgetrf

integer function cusolverDnZgetrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnSgetrf

This function computes the LU factorization of a general mxn matrix

integer function cusolverDnSgetrf(handle, &
    m, n, A, lda, workspace, devipiv, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: workspace
    integer(4), device, dimension(*) :: devipiv
    integer(4), device, intent(out) :: devinfo

cusolverDnDgetrf

This function computes the LU factorization of a general mxn matrix

integer function cusolverDnDgetrf(handle, &
    m, n, A, lda, workspace, devipiv, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: workspace
    integer(4), device, dimension(*) :: devipiv
    integer(4), device, intent(out) :: devinfo

cusolverDnCgetrf

This function computes the LU factorization of a general mxn matrix

integer function cusolverDnCgetrf(handle, &
    m, n, A, lda, workspace, devipiv, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: workspace
    integer(4), device, dimension(*) :: devipiv
    integer(4), device, intent(out) :: devinfo

cusolverDnZgetrf

This function computes the LU factorization of a general mxn matrix

integer function cusolverDnZgetrf(handle, &
    m, n, A, lda, workspace, devipiv, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: workspace
    integer(4), device, dimension(*) :: devipiv
    integer(4), device, intent(out) :: devinfo

cusolverDnSgetrs

This function solves the system of linear equations resulting from the LU factorization of a matrix using cusolverDnSgetrf

integer function cusolverDnSgetrs(handle, &
    trans, n, nrhs, A, lda, devipiv, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: trans
    integer(4) :: n, nrhs, lda, ldb
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnDgetrs

This function solves the system of linear equations resulting from the LU factorization of a matrix using cusolverDnDgetrf

integer function cusolverDnDgetrs(handle, &
    trans, n, nrhs, A, lda, devipiv, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: trans
    integer(4) :: n, nrhs, lda, ldb
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnCgetrs

This function solves the system of linear equations resulting from the LU factorization of a matrix using cusolverDnCgetrf

integer function cusolverDnCgetrs(handle, &
    trans, n, nrhs, A, lda, devipiv, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: trans
    integer(4) :: n, nrhs, lda, ldb
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnZgetrs

This function solves the system of linear equations resulting from the LU factorization of a matrix using cusolverDnZgetrf

integer function cusolverDnZgetrs(handle, &
    trans, n, nrhs, A, lda, devipiv, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: trans
    integer(4) :: n, nrhs, lda, ldb
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnSlaswp

This function performs row pivoting. It is typically called by cusolverDnSgetrf.

integer function cusolverDnSlaswp(handle, &
    n, A, lda, k1, k2, devipiv, incx)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda, k1, k2, incx
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv

cusolverDnDlaswp

This function performs row pivoting. It is typically called by cusolverDnDgetrf.

integer function cusolverDnDlaswp(handle, &
    n, A, lda, k1, k2, devipiv, incx)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda, k1, k2, incx
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv

cusolverDnClaswp

This function performs row pivoting. It is typically called by cusolverDnCgetrf.

integer function cusolverDnClaswp(handle, &
    n, A, lda, k1, k2, devipiv, incx)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda, k1, k2, incx
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv

cusolverDnZlaswp

This function performs row pivoting. It is typically called by cusolverDnZgetrf.

integer function cusolverDnZlaswp(handle, &
    n, A, lda, k1, k2, devipiv, incx)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda, k1, k2, incx
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv

cusolverDnSgeqrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSgeqrf

integer function cusolverDnSgeqrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnDgeqrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDgeqrf

integer function cusolverDnDgeqrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnCgeqrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCgeqrf

integer function cusolverDnCgeqrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnZgeqrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZgeqrf

integer function cusolverDnZgeqrf_buffersize(handle, &
    m, n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnSgeqrf

This function computes the QR factorization of an mxn matrix

integer function cusolverDnSgeqrf(handle, &
    m, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDgeqrf

This function computes the QR factorization of an mxn matrix

integer function cusolverDnDgeqrf(handle, &
    m, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCgeqrf

This function computes the QR factorization of an mxn matrix

integer function cusolverDnCgeqrf(handle, &
    m, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZgeqrf

This function computes the QR factorization of an mxn matrix

integer function cusolverDnZgeqrf(handle, &
    m, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSorgqr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSorgqr

integer function cusolverDnSorgqr_buffersize(handle, &
    m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnDorgqr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDorgqr

integer function cusolverDnDorgqr_buffersize(handle, &
    m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnCorgqr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCorgqr

integer function cusolverDnCorgqr_buffersize(handle, &
    m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnZorgqr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZorgqr

integer function cusolverDnZorgqr_buffersize(handle, &
    m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnSorgqr

This function generates the unitary matrix Q from the QR factorization of an mxn matrix

integer function cusolverDnSorgqr(handle, &
    m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDorgqr

This function generates the unitary matrix Q from the QR factorization of an mxn matrix

integer function cusolverDnDorgqr(handle, &
    m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCorgqr

This function generates the unitary matrix Q from the QR factorization of an mxn matrix

integer function cusolverDnCorgqr(handle, &
    m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZorgqr

This function generates the unitary matrix Q from the QR factorization of an mxn matrix

integer function cusolverDnZorgqr(handle, &
    m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, k, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSormqr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSormqr

integer function cusolverDnSormqr_buffersize(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(ldc,*) :: C
    integer(4) :: lwork

cusolverDnDormqr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDormqr

integer function cusolverDnDormqr_buffersize(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(ldc,*) :: C
    integer(4) :: lwork

cusolverDnCormqr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCormqr

integer function cusolverDnCormqr_buffersize(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(ldc,*) :: C
    integer(4) :: lwork

cusolverDnZormqr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZormqr

integer function cusolverDnZormqr_buffersize(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(ldc,*) :: C
    integer(4) :: lwork

cusolverDnSormqr

This function generates the unitary matrix Q from the QR factorization of an mxn matrix and overwrites the array C, based on the side and trans arguments.

integer function cusolverDnSormqr(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(ldc,*) :: C
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDormqr

This function generates the unitary matrix Q from the QR factorization of an mxn matrix and overwrites the array C, based on the side and trans arguments.

integer function cusolverDnDormqr(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(ldc,*) :: C
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCormqr

This function generates the unitary matrix Q from the QR factorization of an mxn matrix and overwrites the array C, based on the side and trans arguments.

integer function cusolverDnCormqr(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(ldc,*) :: C
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZormqr

This function generates the unitary matrix Q from the QR factorization of an mxn matrix and overwrites the array C, based on the side and trans arguments.

integer function cusolverDnZormqr(handle, &
    side, trans, m, n, k, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, trans
    integer(4) :: m, n, k, lda, ldc, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(ldc,*) :: C
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSsytrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSsytrf

integer function cusolverDnSsytrf_buffersize(handle, &
    n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnDsytrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDsytrf

integer function cusolverDnDsytrf_buffersize(handle, &
    n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnCsytrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCsytrf

integer function cusolverDnCsytrf_buffersize(handle, &
    n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnZsytrf_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZsytrf

integer function cusolverDnZsytrf_buffersize(handle, &
    n, A, lda, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4) :: lwork

cusolverDnSsytrf

This function computes the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix

integer function cusolverDnSsytrf(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDsytrf

This function computes the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix

integer function cusolverDnDsytrf(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCsytrf

This function computes the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix

integer function cusolverDnCsytrf(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZsytrf

This function computes the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix

integer function cusolverDnZsytrf(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSsytrs_bufferSize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSsytrs

integer function cusolverDnSsytrs_bufferSize(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: lwork

cusolverDnDsytrs_bufferSize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDsytrs

integer function cusolverDnDsytrs_bufferSize(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: lwork

cusolverDnCsytrs_bufferSize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCsytrs

integer function cusolverDnCsytrs_bufferSize(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: lwork

cusolverDnZsytrs_bufferSize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZsytrs

integer function cusolverDnZsytrs_bufferSize(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: lwork

cusolverDnSsytrs

This function solves the system of linear equations resulting from the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix using cusolverDnSsytrf

integer function cusolverDnSsytrs(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, lwork
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDsytrs

This function solves the system of linear equations resulting from the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix using cusolverDnDsytrf

integer function cusolverDnDsytrs(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, lwork
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCsytrs

This function solves the system of linear equations resulting from the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix using cusolverDnCsytrf

integer function cusolverDnCsytrs(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, lwork
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(ldb,*) :: B
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZsytrs

This function solves the system of linear equations resulting from the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix using cusolverDnZsytrf

integer function cusolverDnZsytrs(handle, &
    uplo, n, nrhs, A, lda, devipiv, B, ldb, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, nrhs, lda, ldb, lwork
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(ldb,*) :: B
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSsytri_bufferSize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSsytri

integer function cusolverDnSsytri_bufferSize(handle, &
    uplo, n, A, lda, devipiv, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    integer(4), intent(out) :: lwork

cusolverDnDsytri_bufferSize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDsytri

integer function cusolverDnDsytri_bufferSize(handle, &
    uplo, n, A, lda, devipiv, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    integer(4), intent(out) :: lwork

cusolverDnCsytri_bufferSize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCsytri

integer function cusolverDnCsytri_bufferSize(handle, &
    uplo, n, A, lda, devipiv, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    integer(4), intent(out) :: lwork

cusolverDnZsytri_bufferSize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZsytri

integer function cusolverDnZsytri_bufferSize(handle, &
    uplo, n, A, lda, devipiv, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    integer(4), intent(out) :: lwork

cusolverDnSsytri

This function inverts the matrix resulting from the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix using cusolverDnSsytrf

integer function cusolverDnSsytri(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDsytri

This function inverts the matrix resulting from the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix using cusolverDnDsytrf

integer function cusolverDnDsytri(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCsytri

This function inverts the matrix resulting from the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix using cusolverDnCsytrf

integer function cusolverDnCsytri(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZsytri

This function inverts the matrix resulting from the Bunch-Kaufman factorization of an nxn symmetric indefinite matrix using cusolverDnZsytrf

integer function cusolverDnZsytri(handle, &
    uplo, n, A, lda, devipiv, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    integer(4), device, dimension(*) :: devipiv
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDn Legacy Eigenvalue Solver API

This section describes the eigenvalue solver legacy API of cusolverDn, including bidiagonalization and SVD.

cusolverDnSgebrd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSgebrd

integer function cusolverDnSgebrd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

cusolverDnDgebrd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDgebrd

integer function cusolverDnDgebrd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

cusolverDnCgebrd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCgebrd

integer function cusolverDnCgebrd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

cusolverDnZgebrd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZgebrd

integer function cusolverDnZgebrd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

cusolverDnSgebrd

This function reduces a general mxn matrix A to an upper or lower bidiagonal form B by an orthogonal transformation QH * A * P = B

integer function cusolverDnSgebrd(handle, &
    m, n, A, lda, D, E, TauQ, TauP, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: D
    real(4), device, dimension(*) :: E
    real(4), device, dimension(*) :: TauQ
    real(4), device, dimension(*) :: TauP
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDgebrd

This function reduces a general mxn matrix A to an upper or lower bidiagonal form B by an orthogonal transformation QH * A * P = B

integer function cusolverDnDgebrd(handle, &
    m, n, A, lda, D, E, TauQ, TauP, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: D
    real(8), device, dimension(*) :: E
    real(8), device, dimension(*) :: TauQ
    real(8), device, dimension(*) :: TauP
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCgebrd

This function reduces a general mxn matrix A to an upper or lower bidiagonal form B by an orthogonal transformation QH * A * P = B

integer function cusolverDnCgebrd(handle, &
    m, n, A, lda, D, E, TauQ, TauP, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: D
    complex(4), device, dimension(*) :: E
    complex(4), device, dimension(*) :: TauQ
    complex(4), device, dimension(*) :: TauP
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZgebrd

This function reduces a general mxn matrix A to an upper or lower bidiagonal form B by an orthogonal transformation QH * A * P = B

integer function cusolverDnZgebrd(handle, &
    m, n, A, lda, D, E, TauQ, TauP, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: D
    complex(8), device, dimension(*) :: E
    complex(8), device, dimension(*) :: TauQ
    complex(8), device, dimension(*) :: TauP
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSorgbr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSorgbr

integer function cusolverDnSorgbr_buffersize(handle, &
    side, m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnDorgbr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDorgbr

integer function cusolverDnDorgbr_buffersize(handle, &
    side, m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnCungbr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCungbr

integer function cusolverDnCungbr_buffersize(handle, &
    side, m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnZungbr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZungbr

integer function cusolverDnZungbr_buffersize(handle, &
    side, m, n, k, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnSorgbr

This function generates one of the unitary matrices Q or P**H determined by cusolverDnSgebrd.

integer function cusolverDnSorgbr(handle, &
    side, m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDorgbr

This function generates one of the unitary matrices Q or P**H determined by cusolverDnDgebrd.

integer function cusolverDnDorgbr(handle, &
    side, m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCungbr

This function generates one of the unitary matrices Q or P**H determined by cusolverDnCgebrd.

integer function cusolverDnCungbr(handle, &
    side, m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZungbr

This function generates one of the unitary matrices Q or P**H determined by cusolverDnZgebrd.

integer function cusolverDnZungbr(handle, &
    side, m, n, k, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: m, n, k, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSsytrd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSsytrd

integer function cusolverDnSsytrd_buffersize(handle, &
    uplo, n, A, lda, D, E, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: D
    real(4), device, dimension(*) :: E
    real(4), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnDsytrd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDsytrd

integer function cusolverDnDsytrd_buffersize(handle, &
    uplo, n, A, lda, D, E, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: D
    real(8), device, dimension(*) :: E
    real(8), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnChetrd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnChetrd

integer function cusolverDnChetrd_buffersize(handle, &
    uplo, n, A, lda, D, E, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: D
    complex(4), device, dimension(*) :: E
    complex(4), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnZhetrd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZhetrd

integer function cusolverDnZhetrd_buffersize(handle, &
    uplo, n, A, lda, D, E, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: D
    complex(8), device, dimension(*) :: E
    complex(8), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnSsytrd

This function reduces a general symmetric or Hermitian nxn matrix to real symmetric tridiagonal form.

integer function cusolverDnSsytrd(handle, &
    uplo, n, A, lda, D, E, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: D
    real(4), device, dimension(*) :: E
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDsytrd

This function reduces a general symmetric or Hermitian nxn matrix to real symmetric tridiagonal form.

integer function cusolverDnDsytrd(handle, &
    uplo, n, A, lda, D, E, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: D
    real(8), device, dimension(*) :: E
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnChetrd

This function reduces a general symmetric or Hermitian nxn matrix to real symmetric tridiagonal form.

integer function cusolverDnChetrd(handle, &
    uplo, n, A, lda, D, E, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: D
    complex(4), device, dimension(*) :: E
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZhetrd

This function reduces a general symmetric or Hermitian nxn matrix to real symmetric tridiagonal form.

integer function cusolverDnZhetrd(handle, &
    uplo, n, A, lda, D, E, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: D
    complex(8), device, dimension(*) :: E
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSormtr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSormtr

integer function cusolverDnSormtr_buffersize(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(ldc,*) :: C
    integer(4) :: lwork

cusolverDnDormtr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDormtr

integer function cusolverDnDormtr_buffersize(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(ldc,*) :: C
    integer(4) :: lwork

cusolverDnCunmtr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCunmtr

integer function cusolverDnCunmtr_buffersize(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(ldc,*) :: C
    integer(4) :: lwork

cusolverDnZunmtr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZunmtr

integer function cusolverDnZunmtr_buffersize(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(ldc,*) :: C
    integer(4) :: lwork

cusolverDnSormtr

This function generates the unitary matrix Q formed by a sequence of elementary reflection vectors and overwrites the array C, based on the side and trans arguments.

integer function cusolverDnSormtr(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(ldc,*) :: C
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDormtr

This function generates the unitary matrix Q formed by a sequence of elementary reflection vectors and overwrites the array C, based on the side and trans arguments.

integer function cusolverDnDormtr(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(ldc,*) :: C
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCunmtr

This function generates the unitary matrix Q formed by a sequence of elementary reflection vectors and overwrites the array C, based on the side and trans arguments.

integer function cusolverDnCunmtr(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(ldc,*) :: C
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZunmtr

This function generates the unitary matrix Q formed by a sequence of elementary reflection vectors and overwrites the array C, based on the side and trans arguments.

integer function cusolverDnZunmtr(handle, &
    side, uplo, trans, m, n, A, lda, tau, C, ldc, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(4) :: m, n, lda, ldc, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(ldc,*) :: C
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSorgtr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSorgtr

integer function cusolverDnSorgtr_buffersize(handle, &
    uplo, n, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnDorgtr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDorgtr

integer function cusolverDnDorgtr_buffersize(handle, &
    uplo, n, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnCungtr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCungtr

integer function cusolverDnCungtr_buffersize(handle, &
    uplo, n, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnZungtr_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZungtr

integer function cusolverDnZungtr_buffersize(handle, &
    uplo, n, A, lda, tau, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    integer(4) :: lwork

cusolverDnSorgtr

This function generates a unitary matrix Q defined as the product of n-1 elementary reflectors of order n, produced by cusolverDnSsytrd.

integer function cusolverDnSorgtr(handle, &
    uplo, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: tau
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDorgtr

This function generates a unitary matrix Q defined as the product of n-1 elementary reflectors of order n, produced by cusolverDnDsytrd.

integer function cusolverDnDorgtr(handle, &
    uplo, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: tau
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCungtr

This function generates a unitary matrix Q defined as the product of n-1 elementary reflectors of order n, produced by cusolverDnCsytrd.

integer function cusolverDnCungtr(handle, &
    uplo, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: tau
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZungtr

This function generates a unitary matrix Q defined as the product of n-1 elementary reflectors of order n, produced by cusolverDnZsytrd.

integer function cusolverDnZungtr(handle, &
    uplo, n, A, lda, tau, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: tau
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSgesvd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSgesvd

integer function cusolverDnSgesvd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

cusolverDnDgesvd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDgesvd

integer function cusolverDnDgesvd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

cusolverDnCgesvd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCgesvd

integer function cusolverDnCgesvd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

cusolverDnZgesvd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZgesvd

integer function cusolverDnZgesvd_buffersize(handle, &
    m, n, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n
    integer(4) :: lwork

cusolverDnSgesvd

This function computes the singular value decomposition (SVD) of an mxn matrix A and the corresponding left and/or right singular vectors. CusolverDnSgesvd only supports m >= n.

integer function cusolverDnSgesvd(handle, &
    jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, workspace, lwork, rwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, ldu, ldvt, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: S
    real(4), device, dimension(ldu,*) :: U
    real(4), device, dimension(ldvt,*) :: VT
    real(4), device, dimension(lwork) :: workspace
    real(4), device, dimension(lwork) :: rwork
    integer(4), device, intent(out) :: devinfo

cusolverDnDgesvd

This function computes the singular value decomposition (SVD) of an mxn matrix A and the corresponding left and/or right singular vectors. CusolverDnDgesvd only supports m >= n.

integer function cusolverDnDgesvd(handle, &
    jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, workspace, lwork, rwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, ldu, ldvt, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: S
    real(8), device, dimension(ldu,*) :: U
    real(4), device, dimension(ldvt,*) :: VT
    real(8), device, dimension(lwork) :: workspace
    real(8), device, dimension(lwork) :: rwork
    integer(4), device, intent(out) :: devinfo

cusolverDnCgesvd

This function computes the singular value decomposition (SVD) of an mxn matrix A and the corresponding left and/or right singular vectors. CusolverDnCgesvd only supports m >= n.

integer function cusolverDnCgesvd(handle, &
    jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, workspace, lwork, rwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, ldu, ldvt, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: S
    complex(4), device, dimension(ldu,*) :: U
    complex(4), device, dimension(ldvt,*) :: VT
    complex(4), device, dimension(lwork) :: workspace
    real(4), device, dimension(lwork) :: rwork
    integer(4), device, intent(out) :: devinfo

cusolverDnZgesvd

This function computes the singular value decomposition (SVD) of an mxn matrix A and the corresponding left and/or right singular vectors. CusolverDnZgesvd only supports m >= n.

integer function cusolverDnZgesvd(handle, &
    jobu, jobvt, m, n, A, lda, S, U, ldu, VT, ldvt, workspace, lwork, rwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: m, n, lda, ldu, ldvt, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: S
    complex(8), device, dimension(ldu,*) :: U
    complex(8), device, dimension(ldvt,*) :: VT
    complex(8), device, dimension(lwork) :: workspace
    real(8), device, dimension(lwork) :: rwork
    integer(4), device, intent(out) :: devinfo

cusolverDnSsyevd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSsyevd

integer function cusolverDnSsyevd_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: W
    integer(4) :: lwork

cusolverDnDsyevd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDsyevd

integer function cusolverDnDsyevd_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: W
    integer(4) :: lwork

cusolverDnCheevd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCheevd

integer function cusolverDnCheevd_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(*) :: W
    integer(4) :: lwork

cusolverDnZheevd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZheevd

integer function cusolverDnZheevd_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(*) :: W
    integer(4) :: lwork

cusolverDnSsyevd

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnSsyevd(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDsyevd

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnDsyevd(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCheevd

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnCheevd(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZheevd

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnZheevd(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSsyevdx_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSsyevdx

integer function cusolverDnSsyevdx_buffersize(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu
    real(4) :: vl, vu
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    integer(4) :: meig, lwork

cusolverDnDsyevdx_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDsyevdx

integer function cusolverDnDsyevdx_buffersize(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu
    real(8) :: vl, vu
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    integer(4) :: meig, lwork

cusolverDnCheevdx_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCheevdx

integer function cusolverDnCheevdx_buffersize(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu
    real(4) :: vl, vu
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    integer(4) :: meig, lwork

cusolverDnZheevdx_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZheevdx

integer function cusolverDnZheevdx_buffersize(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu
    real(8) :: vl, vu
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    integer(4) :: meig, lwork

cusolverDnSsyevdx

This function computes all or a selection of eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnSsyevdx(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu, lwork
    real(4) :: vl, vu
    real(4), device, dimension(lda,*) :: A
    integer(4), intent(out) :: meig
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDsyevdx

This function computes all or a selection of eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnDsyevdx(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu, lwork
    real(8) :: vl, vu
    real(8), device, dimension(lda,*) :: A
    integer(4), intent(out) :: meig
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnCheevdx

This function computes all or a selection of eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnCheevdx(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu, lwork
    real(4) :: vl, vu
    complex(4), device, dimension(lda,*) :: A
    integer(4), intent(out) :: meig
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZheevdx

This function computes all or a selection of eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnZheevdx(handle, &
    jobz, range, uplo, n, A, lda, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, range, uplo
    integer(4) :: n, lda, il, iu, lwork
    real(8) :: vl, vu
    complex(8), device, dimension(lda,*) :: A
    integer(4), intent(out) :: meig
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSsyevj_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSsyevj

integer function cusolverDnSsyevj_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params

cusolverDnDsyevj_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDsyevj

integer function cusolverDnDsyevj_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params

cusolverDnCheevj_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnCheevj

integer function cusolverDnCheevj_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(*) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params

cusolverDnZheevj_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZheevj

integer function cusolverDnZheevj_buffersize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(*) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params

cusolverDnSsyevj

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnSsyevj(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
 type(cusolverDnSyevjInfo) :: params

cusolverDnDsyevj

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnDsyevj(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params

cusolverDnCheevj

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnCheevj(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params

cusolverDnZheevj

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix A.

integer function cusolverDnZheevj(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params

cusolverDnSsyevjBatched_bufferSize

This function calculates the buffer size needed for the device workspace passed into cusolverDnSsyevjBatched.

integer function cusolverDnSsyevjBatched_bufferSize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

cusolverDnDsyevjBatched_bufferSize

This function calculates the buffer size needed for the device workspace passed into cusolverDnDsyevjBatched.

integer function cusolverDnDsyevjBatched_bufferSize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

cusolverDnCheevjBatched_bufferSize

This function calculates the buffer size needed for the device workspace passed into cusolverDnCheevjBatched.

integer function cusolverDnCheevjBatched_bufferSize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

cusolverDnZheevjBatched_bufferSize

This function calculates the buffer size needed for the device workspace passed into cusolverDnZheevjBatched.

integer function cusolverDnZheevjBatched_bufferSize(handle, &
    jobz, uplo, n, A, lda, W, lwork, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    integer(4), intent(out) :: lwork
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

cusolverDnSsyevjBatched

This function computes the eigenvalues and eigenvectors of symmetric or Hermitian nxn matrices.

integer function cusolverDnSsyevjBatched(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

cusolverDnDsyevjBatched

This function computes the eigenvalues and eigenvectors of symmetric or Hermitian nxn matrices.

integer function cusolverDnDsyevjBatched(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

cusolverDnCheevjBatched

This function computes the eigenvalues and eigenvectors of symmetric or Hermitian nxn matrices.

integer function cusolverDnCheevjBatched(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(4), device, dimension(lda,*) :: A
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

cusolverDnZheevjBatched

This function computes the eigenvalues and eigenvectors of symmetric or Hermitian nxn matrices.

integer function cusolverDnZheevjBatched(handle, &
    jobz, uplo, n, A, lda, W, workspace, lwork, devinfo, params, batchSize)
    type(cusolverDnHandle) :: handle
    integer(4) :: jobz, uplo
    integer(4) :: n, lda, lwork
    complex(8), device, dimension(lda,*) :: A
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo
    type(cusolverDnSyevjInfo) :: params
    integer(4) :: batchSize

cusolverDnSsygvd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSsygvd

integer function cusolverDnSsygvd_buffersize(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    integer(4) :: lwork

cusolverDnDsygvd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDsygvd

integer function cusolverDnDsygvd_buffersize(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    integer(4) :: lwork

cusolverDnChegvd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnChegvd

integer function cusolverDnChegvd_buffersize(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    integer(4) :: lwork

cusolverDnZhegvd_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZhegvd

integer function cusolverDnZhegvd_buffersize(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    integer(4) :: lwork

cusolverDnSsygvd

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix pair (A,B).

integer function cusolverDnSsygvd(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb, lwork
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDsygvd

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix pair (A,B).

integer function cusolverDnDsygvd(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb, lwork
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnChegvd

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix pair (A,B).

integer function cusolverDnChegvd(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb, lwork
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZhegvd

This function computes eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix pair (A,B).

integer function cusolverDnZhegvd(handle, &
    itype, jobz, uplo, n, A, lda, B, ldb, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, uplo
    integer(4) :: n, lda, ldb, lwork
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnSsygvdx_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnSsygvdx

integer function cusolverDnSsygvdx_buffersize(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu
    real(4) :: vl, vu
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    integer(4) :: meig, lwork

cusolverDnDsygvdx_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnDsygvdx

integer function cusolverDnDsygvdx_buffersize(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu
    real(8) :: vl, vu
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    integer(4) :: meig, lwork

cusolverDnChegvdx_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnChegvdx

integer function cusolverDnChegvdx_buffersize(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu
    real(4) :: vl, vu
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    real(4), device, dimension(n) :: W
    integer(4) :: meig, lwork

cusolverDnZhegvdx_buffersize

This function calculates the buffer sizes needed for the device workspace passed into cusolverDnZhegvdx

integer function cusolverDnZhegvdx_buffersize(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, lwork)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu
    real(8) :: vl, vu
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    real(8), device, dimension(n) :: W
    integer(4) :: meig, lwork

cusolverDnSsygvdx

This function computes all or a selection of the eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix pair (A,B).

integer function cusolverDnSsygvdx(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu, lwork
    real(4) :: vl, vu
    real(4), device, dimension(lda,*) :: A
    real(4), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: meig
    real(4), device, dimension(n) :: W
    real(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnDsygvdx

This function computes all or a selection of the eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix pair (A,B).

integer function cusolverDnDsygvdx(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu, lwork
    real(8) :: vl, vu
    real(8), device, dimension(lda,*) :: A
    real(8), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: meig
    real(8), device, dimension(n) :: W
    real(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnChegvdx

This function computes all or a selection of the eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix pair (A,B).

integer function cusolverDnChegvdx(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu, lwork
    real(4) :: vl, vu
    complex(4), device, dimension(lda,*) :: A
    complex(4), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: meig
    real(4), device, dimension(n) :: W
    complex(4), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDnZhegvdx

This function computes all or a selection of the eigenvalues and eigenvectors of a symmetric or Hermitian nxn matrix pair (A,B).

integer function cusolverDnZhegvdx(handle, &
    itype, jobz, range, uplo, n, A, lda, B, ldb, vl, vu, il, iu, meig, W, workspace, lwork, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: itype, jobz, range, uplo
    integer(4) :: n, lda, ldb, il, iu, lwork
    real(8) :: vl, vu
    complex(8), device, dimension(lda,*) :: A
    complex(8), device, dimension(ldb,*) :: B
    integer(4), intent(out) :: meig
    real(8), device, dimension(n) :: W
    complex(8), device, dimension(lwork) :: workspace
    integer(4), device, intent(out) :: devinfo

cusolverDn 64-bit API

This section describes the linear solver 64-bit API of cusolverDn, including Cholesky factorization, LU with partial pivoting, and QR factorization.

cusolverDnXpotrf_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverDnXpotrf

The type and kind of the A matrix is determined by the dataTypeA argument. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXpotrf_buffersize(handle, &
    params, uplo, n, dataTypeA, A, lda, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: uplo
    integer(8) :: n, lda
    type(cudaDataType) :: dataTypeA, computeType
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXpotrf

This function computes the Cholesky factorization of a Hermitian positive-definite matrix

The type and kind of the A matrix is determined by the dataTypeA argument. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used. The workspaces can be any type and kind so long as the adequate amount of space in bytes is available.

integer function cusolverDnXpotrf(handle, &
    params, uplo, n, dataTypeA, A, lda, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: uplo
    integer(8) :: n, lda
    type(cudaDataType) :: dataTypeA, computeType
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverDnXpotrs

This function solves the system of linear equations resulting from the Cholesky factorization of a Hermitian positive-definite matrix using cusolverDnXpotrf

The type and kind of the A, B matrices are determined by the dataTypeA and dataTypeB arguments, respectively. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXpotrs(handle, &
    params, uplo, n, nrhs, dataTypeA, A, lda, &
    dataTypeB, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: uplo
    integer(8) :: n, nrhs, lda, ldb
    type(cudaDataType) :: dataTypeA, dataTypeB
    real, device, dimension(lda,*) :: A
    real, device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnXgeqrf_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverDnXgeqrf

The type and kind of the A matrix and tau vector is determined by the dataTypeA and dataTypeTau arguments, respectively. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXgeqrf_buffersize(handle, &
    params, m, n, dataTypeA, A, lda, dataTypeTau, tau, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(8) :: m, n, lda
    type(cudaDataType) :: dataTypeA, dataTypeTau, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: tau
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXgeqrf

This function computes the QR factorization of a general mxn matrix

The type and kind of the A matrix and tau vector is determined by the dataTypeA and dataTypeTau arguments, respectively. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used. The workspaces can be any type and kind so long as the adequate amount of space in bytes is available.

integer function cusolverDnXgeqrf(handle, &
    params, m, n, dataTypeA, A, lda, dataTypeTau, tau, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(8) :: m, n, lda
    type(cudaDataType) :: dataTypeA, dataTypeTau, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: tau
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverDnXgetrf_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverDnXgetrf

The type and kind of the A matrix is determined by the dataTypeA argument. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXgetrf_buffersize(handle, &
    params, m, n, dataTypeA, A, lda, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(8) :: m, n, lda
    type(cudaDataType) :: dataTypeA, computeType
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXgetrf

This function computes the LU factorization of a general mxn matrix

The type and kind of the A matrix is determined by the dataTypeA argument. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used. The workspaces can be any type and kind so long as the adequate amount of space in bytes is available.

integer function cusolverDnXgetrf(handle, &
    params, m, n, dataTypeA, A, lda, devipiv, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(8) :: n, m, lda
    type(cudaDataType) :: dataTypeA, computeType
    real, device, dimension(lda,*) :: A
    integer(8), device, dimension(*), intent(out) :: devipiv
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverDnXgetrs

This function solves the linear system of multiple right-hand sides applying a general nxn matrix which was LU-factored using cusolverDnXgetrf

The type and kind of the A, B matrices are determined by the dataTypeA and dataTypeB arguments, respectively. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXpotrs(handle, &
    params, trans, n, nrhs, dataTypeA, A, lda, devipiv, &
    dataTypeB, B, ldb, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: trans
    integer(8) :: n, nrhs, lda, ldb
    type(cudaDataType) :: dataTypeA, dataTypeB
    real, device, dimension(lda,*) :: A
    integer(8), device, dimension(*), intent(in) :: devipiv
    real, device, dimension(ldb,*) :: B
    integer(4), device, intent(out) :: devinfo

cusolverDnXsyevd_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverDnXsyevd

The type and kind of the A matrix and W array is determined by the dataTypeA and dataTypeW arguments, respectively. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXsyevd_buffersize(handle, &
    params, jobz, uplo, n, dataTypeA, A, lda, &
    dataTypeW, W, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, uplo
    integer(8) :: n, lda
    type(cudaDataType) :: dataTypeA, dataTypeW, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: W
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXsyevd

This function computes the eigenvalues and eigenvectors of a symmetric (Hermitian) nxn matrix

The type and kind of the A matrix and W array is determined by the dataTypeA and dataTypeW arguments, respectively. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used. The workspaces can be any type and kind so long as the adequate amount of space in bytes is available.

integer function cusolverDnXsyevd(handle, &
    params, jobz, uplo, n, dataTypeA, A, lda, &
    dataTypeW, W, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, uplo
    integer(8) :: n, lda
    type(cudaDataType) :: dataTypeA, dataTypeW, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: W
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverDnXsyevdx_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverDnXsyevdx

The type and kind of the A matrix and W array is determined by the dataTypeA and dataTypeW arguments, respectively. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXsyevdx_buffersize(handle, &
    params, jobz, range, uplo, n, dataTypeA, A, lda, &
    vl, vu, il, iu, meig, &
    dataTypeW, W, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, range, uplo
    integer(8) :: n, lda, il, iu
    type(cudaDataType) :: dataTypeA, dataTypeW, computeType
    real, device, dimension(lda,*) :: A
    real :: vl, vu
    integer(8) :: meig
    real, device, dimension(*)     :: W
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXsyevdx

This function computes all or some of the eigenvalues and optionally the eigenvectors of a symmetric (Hermitian) nxn matrix

The type and kind of the A matrix and W array is determined by the dataTypeA and dataTypeW arguments, respectively. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used. The workspaces can be any type and kind so long as the adequate amount of space in bytes is available.

integer function cusolverDnXsyevdx(handle, &
    params, jobz, range, uplo, n, dataTypeA, A, lda, &
    vl, vu, il, iu, meig, &
    dataTypeW, W, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, range, uplo
    integer(8) :: n, lda, il, iu
    type(cudaDataType) :: dataTypeA, dataTypeW, computeType
    real, device, dimension(lda,*) :: A
    real :: vl, vu
    integer(8) :: meig
    real, device, dimension(*)     :: W
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverDnXsytrs_bufferSize

This function calculates the buffer sizes needed to solve a system of linear equations using the generic API cusolverDnXsytrs function.

integer function cusolverDnXsytrs_bufferSize(handle, &
    uplo, n, nrhs, datatypeA, A, lda, &
    devipiv, datatypeB, B, ldb, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    type(cudaDataType) :: dataTypeA, dataTypeB
    integer(8) :: n, nrhs, lda, ldb
    real, device, dimension(lda,*) :: A
    integer(8), device :: devipiv(*)
    real, device, dimension(ldb,*) :: B
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXsytrs

This function solves a system of linear equations using the generic API.

integer function cusolverDnXsytrs(handle, &
    uplo, n, nrhs, datatypeA, A, lda, &
    devipiv, datatypeB, B, ldb, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo
    type(cudaDataType) :: dataTypeA, dataTypeB
    integer(8) :: n, nrhs, lda, ldb
    real, device, dimension(lda,*) :: A
    integer(8), device :: devipiv(*)
    real, device, dimension(ldb,*) :: B
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverDnXtrtri_bufferSize

This function calculates the buffer sizes needed to compute the inverse of an upper or lower triangular matrix A using the generic API cusolverDnXtrtri function.

integer function cusolverDnXtrtri_bufferSize(handle, &
    uplo, diag, n, datatypeA, A, lda, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    type(cudaDataType) :: dataTypeA
    integer(8) :: n, lda
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXtrtri

This function computes the inverse of an upper or lower triangular matrix A using the generic API interface.

integer function cusolverDnXtrtri(handle, &
    uplo, diag, n, datatypeA, A, lda, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    integer(4) :: uplo, diag
    type(cudaDataType) :: dataTypeA
    integer(8) :: n, lda
    real, device, dimension(lda,*) :: A
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverDnXgesvd_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverDnXgesvd

The type and kind of the A, U, and VT matrices and the S array is determined by the associated dataType arguments. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXgesvd_buffersize(handle, &
    params, jobu, jobvt, m, n, dataTypeA, A, lda, &
    dataTypeS, S, dataTypeU, U, ldu, &
    dataTypeVT, VT, ldvt, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    character*1 :: jobu, jobvt
    integer(8) :: m, n, lda, ldu, ldvt
    type(cudaDataType) :: dataTypeA, dataTypeS, dataTypeU, dataTypeVT, &
    computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: S
    real, device, dimension(ldu,*) :: U
    real, device, dimension(ldvt,*) :: VT
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXgesvd

This function computes the singular value decomposition (SVD) of an mxn matrix

The type and kind of the A, U, and VT matrices and the S array is determined by the associated dataType arguments. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used. The workspaces can be any type and kind so long as the adequate amount of space in bytes is available.

integer function cusolverDnXgesvd(handle, &
    params, jobu, jobvt, m, n, dataTypeA, A, lda, &
    dataTypeS, S, dataTypeU, U, ldu, &
    dataTypeVT, VT, ldvt, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    character*1 :: jobu, jobvt
    integer(8) :: m, n, lda, ldu, ldvt
    type(cudaDataType) :: dataTypeA, dataTypeS, dataTypeU, dataTypeVT, &
    computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: S
    real, device, dimension(ldu,*) :: U
    real, device, dimension(ldvt,*) :: VT
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverDnXgesvdp_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverDnXgesvdp

The type and kind of the A, U, and V matrices and the S array is determined by the associated dataType arguments. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXgesvdp_buffersize(handle, &
    params, jobz, econ, m, n, dataTypeA, A, lda, &
    dataTypeS, S, dataTypeU, U, ldu, &
    dataTypeV, V, ldv, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, econ
    integer(8) :: m, n, lda, ldu, ldv
    type(cudaDataType) :: dataTypeA, dataTypeS, dataTypeU, dataTypeV, &
    computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: S
    real, device, dimension(ldu,*) :: U
    real, device, dimension(ldv,*) :: V
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXgesvdp

This function computes the singular value decomposition (SVD) of an mxn matrix. This variation combines polar decompostion and cusolverDnXsyevd to compute the SVD.

The type and kind of the A, U, and V matrices and the S array is determined by the associated dataType arguments. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used. The workspaces can be any type and kind so long as the adequate amount of space in bytes is available.

integer function cusolverDnXgesvdp(handle, &
    params, jobz, econ, m, n, dataTypeA, A, lda, &
    dataTypeS, S, dataTypeU, U, ldu, &
    dataTypeV, V, ldv, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    integer(4) :: jobz, econ
    integer(8) :: m, n, lda, ldu, ldv
    type(cudaDataType) :: dataTypeA, dataTypeS, dataTypeU, dataTypeVT, &
    computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: S
    real, device, dimension(ldu,*) :: U
    real, device, dimension(ldv,*) :: V
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverDnXgesvdr_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverDnXgesvdr

The type and kind of the A, Urand, and Vrand matrices and the Srand array is determined by the associated dataType arguments. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverDnXgesvdr_buffersize(handle, &
    params, jobu, jobvt, m, n, k, p, niters, dataTypeA, A, lda, &
    dataTypeSrand, Srand, dataTypeUrand, Urand, ldurand, &
    dataTypeVrand, Vrand, ldvrand, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    character*1 :: jobu, jobvt
    integer(8) :: m, n, k, p, niters, lda, ldurand, ldvrand
    type(cudaDataType) :: dataTypeA, dataTypeSrand, dataTypeUrand, &
      dataTypeVrand, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: Srand
    real, device, dimension(ldurand,*) :: Urand
    real, device, dimension(ldvrand,*) :: Vrand
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverDnXgesvdr

This function computes the approximated rank-k singular value decomposition (SVD) of an mxn matrix.

The type and kind of the A, Urand, and Vrand matrices and the Srand array is determined by the associated dataType arguments. The computeType is typically set to the same. Array sizes and dimensions, such as n, m, lda will be promoted to integer(8) by the compiler, so other integer kinds may be used. The workspaces can be any type and kind so long as the adequate amount of space in bytes is available.

integer function cusolverDnXgesvdr(handle, &
    params, jobu, jobv, m, n, k, p, niters, dataTypeA, A, lda, &
    dataTypeSrand, Srand, dataTypeUrand, Urand, ldurand, &
    dataTypeVrand, Vrand, ldvrand, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverDnHandle) :: handle
    type(cusolverDnParams) :: params
    character*1 :: jobu, jobv
    integer(8) :: m, n, k, p, niters, lda, ldurand, ldvrand
    type(cudaDataType) :: dataTypeA, dataTypeSrand, dataTypeUrand, &
      dataTypeVrand, computeType
    real, device, dimension(lda,*) :: A
    real, device, dimension(*)     :: Srand
    real, device, dimension(ldurand,*) :: Urand
    real, device, dimension(ldvrand,*) :: Vrand
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverMp API

This section describes the distributed, multi-processor linear solvers supported in cusolverMp, along with supporting functions to set up and initialize the library.

The cusolverMp module contains the following derived type definitions:

! Definitions from cusolverMp.h
integer, parameter :: CUSOLVERMP_VER_MAJOR = 0
integer, parameter :: CUSOLVERMP_VER_MINOR = 4
integer, parameter :: CUSOLVERMP_VER_PATCH = 3
integer, parameter :: CUSOLVERMP_VER_BUILD = 0
integer, parameter :: CUSOLVERMP_VERSION = &
        (CUSOLVERMP_VER_MAJOR * 1000 + CUSOLVERMP_VER_MINOR * 100 + CUSOLVERMP_VER_PATCH)

! Types from cusolverMp.h
    TYPE cusolverMpHandle
      TYPE(C_PTR) :: handle
    END TYPE cusolverMpHandle

    TYPE cusolverMpGrid
      TYPE(C_PTR) :: handle
    END TYPE cusolverMpGrid

    TYPE cusolverMpMatrixDescriptor
      TYPE(C_PTR) :: handle
    END TYPE cusolverMpMatrixDescriptor

enum, bind(c)
    enumerator :: CUDALIBMP_GRID_MAPPING_COL_MAJOR = 0
    enumerator :: CUDALIBMP_GRID_MAPPING_ROW_MAJOR = 1
end enum

cusolverMpCreate

This function initializes the cusolverMp library and creates a handle on the cusolverDn context. It must be called before other cuSolverMp API functions are invoked, but after a CUDA context and stream are created.

integer(4) function cusolverMpCreate(handle, deviceId, stream)
  type(cusolverMpHandle) :: handle
  integer(4) :: deviceId
  integer(cuda_stream_kind) :: stream

cusolverMpDestroy

This function releases CPU-side resources used by the cuSolverMp library.

integer(4) function cusolverMpDestroy(handle)
  type(cusolverMpHandle) :: handle

cusolverMpGetStream

This function gets the stream used by the cuSolverMp library to execute its routines.

integer(4) function cusolverMpGetStream(handle, stream)
  type(cusolverMpHandle) :: handle
  integer(cuda_stream_kind) :: stream

cusolverMpGetVersion

This function gets the version of the cuSolverMp library at runtime. It has the value (CUSOLVERMP_VER_MAJOR * 1000 + CUSOLVERMP_VER_MINOR * 100 + CUSOLVERMP_VER_PATCH)

integer(4) function cusolverMpGetVersion(handle, version)
  type(cusolverMpHandle) :: handle
  integer(4) :: version

cusolverMpCreateDeviceGrid

This function initializes the grid data structure used in the cusolverMp library. It takes a handle, a communicator, and other information related to the data layout as inputs.

integer(4) function cusolverMpCreateDeviceGrid(handle, &
          grid, comm, numRowDevices, numColDevices, mapping)
  type(cusolverMpHandle) :: handle
  type(cusolverMpGrid) :: grid
  type(cal_comm) :: comm
  integer(4) :: numRowDevices, numColDevices
  integer(4) :: mapping ! enum above, usually column major in Fortran

cusolverMpDestroyGrid

This function destroys the grid data structure and frees the resources used in the cusolverMp library.

integer(4) function cusolverMpDestroyGrid(grid)
   type(cusolverMpGrid) :: grid

cusolverMpCreateMatrixDesc

This function initializes the matrix descriptor object used in the cusolverMp library. It takes the number of rows (M_A) and the number of columns (N_A) in the global array, along with the blocking factor over each dimension. RSRC_A and CSRC_A must currently be 0. LLD_A is the leading dimension of the local matrix, after blocking and distributing the matrix.

integer(4) function cusolverMpCreateMatrixDesc(descr, grid, &
          dataType, M_A, N_A, MB_A, NB_A, RSRC_A, CSRC_A, LLD_A)
  type(cusolverMpMatrixDescriptor)  :: descr
  type(cusolverMpGrid) :: grid
  type(cudaDataType)  :: dataType
  integer(8) :: M_A, N_A, MB_A, NB_A
  integer(4) :: RSRC_A, CSRC_A
  integer(8) :: LLD_A

cusolverMpDestroyMatrixDesc

This function destroys the matrix descriptor data structure and frees the resources used in the cusolverMp library.

integer(4) function cusolverMpDestroyMatrixDesc(descr)
   type(cusolverMpMatrixDescriptor) :: descr

cusolverMpNumROC

This utility function returns the number of rows or columns in the distributed matrix owned by the iproc process.

integer(4) function cusolverMpNumROC(N, NB, iproc, isrcproc, nprocs)
  integer(8), intent(in) :: N, NB
  integer(4), intent(in) :: iproc, isrcproc, nprocs

cusolverMpGetrf_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpGetrf

The type, kind, and rank of the A matrix is ignored and has already been set by the descrA argument. The computeType is typically set to the same type. Array sizes and dimensions, such as M, N will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpGetrf_buffersize(handle, &
    M, N, A, IA, JA, descrA, devipiv, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(8) :: M, N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    integer(8), device, dimension(*) :: devipiv
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpGetrf

This function computes the LU factorization of a general mxn matrix

The type, kind, and rank of the A matrix is ignored and has already been set by the descrA argument. The computeType is typically set to the same type. Array sizes and dimensions, such as M, N will be promoted to integer(8) by the compiler, so other integer kinds may be used. The workspaces can be any type and kind so long as the adequate amount of space in bytes is available.

integer function cusolverMpGetrf(handle, &
    M, N, A, IA, JA, descrA, devipiv, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(8) :: M, N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    integer(8), device, dimension(*) :: devipiv
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpGetrs_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpGetrs

The type, kind, and rank of the A, B matrices are ignored and are set by the descrA, descrB arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as N, NRHS will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpGetrs_buffersize(handle, trans, &
    N, NRHS, A, IA, JA, descrA, devipiv, B, IB, JB, descrB, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: trans
    integer(8) :: N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    integer(8), device, dimension(*) :: devipiv
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpGetrs

This function solves the linear system of multiple right-hand sides applying a general nxn matrix which was LU-factored using cusolverMpGetrf

The type, kind, and rank of the A, B matrices are ignored and are set by the descrA, descrB arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as N, NRHS will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpGetrs(handle, trans, &
    N, NRHS, A, IA, JA, descrA, devipiv, B, IB, JB, descrB, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverMpHandle) :: handle
    integer(4) :: trans
    integer(8) :: N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    integer(8), device, dimension(*) :: devipiv
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverMpPotrf_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpPotrf

The type, kind, and rank of the A matrix is ignored and has already been set by the descrA argument. The computeType is typically set to the same type. Array sizes and dimensions, such as N will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpPotrf_buffersize(handle, &
    uplo, N, A, IA, JA, descrA, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpPotrf

This function computes the Cholesky factorization of a Hermitian positive-definite matrix

The type, kind, and rank of the A matrix is ignored and has already been set by the descrA argument. The computeType is typically set to the same type. Array sizes and dimensions, such as N will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpPotrf(handle, &
    uplo, N, A, IA, JA, descrA, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpPotrs_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpPotrs

The type, kind, and rank of the A, B matrices are ignored and are set by the descrA, descrB arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as N, NRHS will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpPotrs_buffersize(handle, uplo, &
    N, NRHS, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpPotrs

This function solves the system of linear equations resulting from the Cholesky factorization of a Hermitian positive-definite matrix using cusolverMpPotrf

The type, kind, and rank of the A, B matrices are ignored and are set by the descrA, descrB arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as N, NRHS will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpPotrs(handle, uplo, &
    N, NRHS, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpOrmqr_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpOrmqr

The type, kind, and rank of the A, C matrices is ignored and has already been set by the descrA, descrC arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as M, N, K will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpOrmqr_buffersize(handle, side, trans, &
    M, N, K, A, IA, JA, descrA, tau, C, IC, JC, descrC, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: side, trans
    integer(8) :: M, N, K, IA, JA, IC, JC
    real, device, dimension(*) :: A, tau, C
    type(cusolverMpMatrixDescriptor) :: descrA, descrC
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpOrmqr

This function generates the unitary matrix Q from the QR factorization of an mxn matrix and overwrites the array C, based on the side and trans arguments.

The type, kind, and rank of the A, C matrices is ignored and has already been set by the descrA, descrC arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as M, N, K will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpOrmqr(handle, side, trans, &
    M, N, K, A, IA, JA, descrA, tau, C, IC, JC, descrC, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: side, trans
    integer(8) :: M, N, K, IA, JA, IC, JC
    real, device, dimension(*) :: A, tau, C
    type(cusolverMpMatrixDescriptor) :: descrA, descrC
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpOrmtr_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpOrmtr

The type, kind, and rank of the A, tau, C matrices is ignored and has already been set by the descrA, descrC arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as M, N, K will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpOrmtr_buffersize(handle, side, uplo, trans, &
    M, N, A, IA, JA, descrA, tau, C, IC, JC, descrC, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(8) :: M, N, IA, JA, IC, JC
    real, device, dimension(*) :: A, tau, C
    type(cusolverMpMatrixDescriptor) :: descrA, descrC
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpOrmtr

This function generates the unitary matrix Q formed by a sequence of elementary reflection vectors and overwrites the array C, based on the side and trans arguments.

The type, kind, and rank of the A, C matrices is ignored and has already been set by the descrA, descrC arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as M, N, K will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpOrmtr(handle, side, uplo, trans, &
    M, N, A, IA, JA, descrA, tau, C, IC, JC, descrC, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: side, uplo, trans
    integer(8) :: M, N, IA, JA, IC, JC
    real, device, dimension(*) :: A, tau, C
    type(cusolverMpMatrixDescriptor) :: descrA, descrC
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpGels_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpGels

The type, kind, and rank of the A, B matrices are ignored and are set by the descrA, descrB arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as N, NRHS will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpGels_buffersize(handle, trans, &
    M, N, NRHS, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: trans
    integer(8) :: M, N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpGels

This function solves overdetermined or underdetermined linear systems of the MxN matrix A, or its transpose, using QR or LQ factorization.

The type, kind, and rank of the A, B matrices are ignored and are set by the descrA, descrB arguments. The computeType is typically set to the same type. Array sizes and dimensions, such as N, NRHS will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpGels(handle, trans, &
    M, N, NRHS, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: trans
    integer(8) :: M, N, NRHS, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpStedc_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpStedc

The type, kind, and rank of the D, E, Q matrices are ignored and are already set by the descrQ argument. The computeType is typically set to the same type. Array offsets and dimensions, such as N, IQ, JQ will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpStedc_buffersize(handle, compz, &
    N, D, E, Q, IQ, JQ, descrQ, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    character :: compz
    integer(8) :: N, IQ, JQ
    real, device, dimension(*) :: D, E, Q
    type(cusolverMpMatrixDescriptor) :: descrQ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(4) :: iwork(*)

cusolverMpStedc

This function computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.

The type, kind, and rank of the D, E, Q matrices are ignored and are already set by the descrQ argument. The computeType is typically set to the same type. Array offsets and dimensions, such as N, IQ, JQ will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpStedc(handle, compz, &
    N, D, E, Q, IQ, JQ, descrQ, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    character :: compz
    integer(8) :: N, IQ, JQ
    real, device, dimension(*) :: D, E, Q
    type(cusolverMpMatrixDescriptor) :: descrQ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpGeqrf_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpGeqrf

The type, kind, and rank of the A matrix is ignored and has already been set by the descrA argument. The computeType is typically set to the same type. Array sizes and dimensions, such as M, N will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpGeqrf_buffersize(handle, &
    M, N, A, IA, JA, descrA, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(8) :: M, N, IA, JA
    real, device, dimension(*) :: A
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpGeqrf

This function computes a QR factorization of an MxN matrix.

The type, kind, and rank of the A matrix is ignored and has already been set by the descrA argument. The computeType is typically set to the same type. Array sizes and dimensions, such as M, N, K will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpGeqrf(handle, &
    M, N, A, IA, JA, descrA, tau, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(8) :: M, N, IA, JA
    real, device, dimension(*) :: A, tau
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpSytrd_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpSytrd

The type, kind, and rank of the A, D, E matrix and vectors are ignored and are already set by the descrA argument. The computeType is typically set to the same type. Array offsets and dimensions, such as N, IA, JA will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpSytrd_buffersize(handle, uplo, &
    N, A, IA, JA, descrA, D, E, tau, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, IA, JA
    real, device, dimension(*) :: A, D, E, tau
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpSytrd

This function reduces a symmetric (Hermitian) NxN matrix to symmetric tridiagonal form.

The type, kind, and rank of the A, D, E matrix and vectors are ignored and are already set by the descrA argument. The computeType is typically set to the same type. Array offsets and dimensions, such as N, IA, JA will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpSytrd(handle, uplo, &
    N, A, IA, JA, descrA, D, E, tau, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: uplo
    integer(8) :: N, IA, JA
    real, device, dimension(*) :: A, D, E, tau
    type(cusolverMpMatrixDescriptor) :: descrA
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpSyevd_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpSyevd

The type, kind, and rank of the A, D, Q matrices are ignored and are already set by the descrA, descrQ argument. The computeType is typically set to the same type. Array offsets and dimensions, such as N, IA, JA will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpSyevd_buffersize(handle, compz, &
    uplo, N, A, IA, JA, descrA, D, Q, IQ, JQ, descrQ, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    character :: compz
    integer(4) :: uplo
    integer(8) :: N, IA, JA, IQ, JQ
    real, device, dimension(*) :: A, D, Q
    type(cusolverMpMatrixDescriptor) :: descrA, descrQ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpSyevd

This function computes the eigenvalues and eigenvectors of a symmetric (Hermitian) nxn matrix

The type, kind, and rank of the A, D, Q matrices are ignored and are already set by the descrA, descrQ argument. The computeType is typically set to the same type. Array offsets and dimensions, such as N, IA, JA will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpSyevd(handle, compz, &
    uplo, N, A, IA, JA, descrA, D, Q, IQ, JQ, descrQ, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, devinfo)
    type(cusolverMpHandle) :: handle
    character :: compz
    integer(4) :: uplo
    integer(8) :: N, IA, JA, IQ, JQ
    real, device, dimension(*) :: A, D, Q
    type(cusolverMpMatrixDescriptor) :: descrA, descrQ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: devinfo

cusolverMpSygst_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpSygst

The types for the A, B matrices are set by the descrA, descrB arguments and not passed in to compute the buffer requirements. The computeType is typically set to the same type. Array offsets and dimensions, such as M, IA, JA will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpSygst_buffersize(handle, ibtype, uplo, &
    M, IA, JA, descrA, IB, JB, descrB, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: ibtype, uplo
    integer(8) :: M, IA, JA, IB, JB
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpSygst

This function reduces a symmetric-definite generalized eigenproblem to standard form.

The type, kind, and rank of the A, B matrices are ignored and are already set by the descrA, descrB argument. The computeType is typically set to the same type. Array offsets and dimensions, such as M, IA, JA will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpSygst(handle, ibtype, uplo, &
    M, A, IA, JA, descrA, B, IB, JB, descrB, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: ibtype, uplo
    integer(8) :: M, IA, JA, IB, JB
    real, device, dimension(*) :: A, B
    type(cusolverMpMatrixDescriptor) :: descrA, descrB
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpSygvd_buffersize

This function calculates the buffer sizes needed for the host and device workspaces passed into cusolverMpSygvd

The types for the A, B, Z matrices are set by the descrA, descrB, descrZ arguments and not passed in to compute the buffer requirements. The computeType is typically set to the same type. Array offsets and dimensions, such as M, IA, JA will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpSygvd_buffersize(handle, ibtype, jobz, &
    uplo, M, IA, JA, descrA, IB, JB, descrB, IZ, JZ, descrZ, computeType, &
    workspaceInBytesOnDevice, workspaceInBytesOnHost)
    type(cusolverMpHandle) :: handle
    integer(4) :: ibtype, jobz, uplo
    integer(8) :: M, IA, JA, IB, JB, IZ, JZ
    type(cusolverMpMatrixDescriptor) :: descrA, descrB, descrZ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost

cusolverMpSygvd

This function computes all eigenvalues and eigenvectors of a symmetric (Hermitian) generalized eigen problem.

The type, kind, and rank of the A, B, Z matrices are ignored and are already set by the descrA, descrB, descrZ argument. The computeType is typically set to the same type. Array offsets and dimensions, such as M, IA, JA will be promoted to integer(8) by the compiler, so other integer kinds may be used.

integer function cusolverMpSygvd(handle, ibtype, jobz, &
    uplo, M, A, IA, JA, descrA, B, IB, JB, descrB, &
    W, Z, IZ, JZ, descrZ, computeType, &
    bufferOnDevice, workspaceInBytesOnDevice, &
    bufferOnHost, workspaceInBytesOnHost, info)
    type(cusolverMpHandle) :: handle
    integer(4) :: ibtype, jobz, uplo
    integer(8) :: M, IA, JA, IB, JB,
    real, device, dimension(*) :: A, B, W, Z
    type(cusolverMpMatrixDescriptor) :: descrA, descrB, descrZ
    type(cudaDataType) :: computeType
    integer(8) :: workspaceInBytesOnDevice, workspaceInBytesOnHost
    integer(1), device :: bufferOnDevice(workspaceInBytesOnDevice)
    integer(1)         :: bufferOnHost(workspaceInBytesOnHost)
    integer(4), device, intent(out) :: info

cusolverMpLoggerSetFile

This function specifies the Fortran unit to be used as the cusolverMp logfile.

integer(4) function cusolverMpLoggerSetFile(unit)
  integer :: unit

cusolverMpLoggerOpenFile

This function specifies a Fortran character string to be opened and used as the cusolverMp logfile.

integer(4) function cusolverMpLoggerOpenFile(logFile)
  character*(*) :: logFile

cusolverMpLoggerSetLevel

This function specifies the cusolverMp logging level.

integer(4) function cusolverMpLoggerSetLevel(level)
  integer :: level

cusolverMpLoggerSetMask

This function specifies the cusolverMp logging mask.

integer(4) function cusolverMpLoggerSetMask(mask)
  integer :: mask

cusolverMpLoggerForceDisable

This function disables cusolverMp logging.

integer(4) function cusolverMpLoggerForceDisable()

NVLAMATH Runtime Library

This section describes the NVLAmath runtime library, which enables offloading calls to standard LAPACK subroutines to the GPU by redirecting them to a wrapper around cuSOLVER functions.

Functionality and performance wise, this library provides no additions to what is documented in the previous sections of this chapter. The most common use cases for NVLAmath we see are:

• Drop-in acceleration. When running in a unified memory environment, NVLAmath allows recompile-and-run to offload LAPACK solvers to the GPU.

• Quick-porting functionality which may or may not be performance critical, but where the data already resides on the GPU from other sections of the application, via CUDA, OpenACC, or OpenMP. Access to a GPU-enabled function avoids costly data movement back and forth between the GPU and CPU.

• Keeping traditional code integrity. NVLAmath enables porting to the GPU with minimal code changes, for instance enabling 32-bit and 64-bit integers in the same source, and calling solver library entry points which are available on all targets.

The NVLAmath wrappers are enabled through the Fortran nvlamath module, which overloads the LAPACK subroutine names. There are two ways users can insert the module into their Fortran subprogram units. The first is non-invasive: add the compiler option -gpu=nvlamath to the compile lines on the files containing LAPACK calls you wish to move to the GPU. The second way is more traditional, just add the use nvlamath statement to the subroutines or functions that contain those LAPACK calls. If you use neither of these methods, the LAPACK calls will likely be resolved by the CPU LAPACK library, either the one we ship or the one you decide to use on your link line. In some cases, the NVLAmath wrappers might even call into that CPU library as well. In other words, there is no tampering with the CPU LAPACK symbol (library entry point) names.

To link the NVLAmath wrapper library, add -cudalib=nvlamath to your link line. To use the 64-bit integer version of the library, either compile and link with the -i8 option, or add -cudalib=nvlamath_ilp64 to your link line.

NVLAMATH Automatic Drop-In Acceleration

In unified memory environments, the simplest method to move standard LAPACK calls to run on the GPU is through what we call automatic drop-in acceleration. This currently requires a GPU and OS which supports CUDA managed memory, and that the arrays that are passed to the library functions are dynamically allocated.

Here is an example test program which calls dgetrf() and dgetrs():

program testdgetrf
integer, parameter :: M = 1000, N = M, NRHS=2
real(8), allocatable :: A(:,:), B(:,:)
integer, allocatable :: IPIV(:)
real(8), parameter :: eps = 1.0d-10
!
allocate(A(M,N),B(M,NRHS),IPIV(M))
call random_number(A)
do i = 1, M
    A(i,i) = A(i,i) * 10.0d0
    B(i,1) = sum(A(i,:))
    B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!
if ((info1.ne.0) .or. (info2.ne.0)) then
    print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0) .gt. eps) .or. &
         any(abs(B(:,2)-2.0d0) .gt. eps)) then
    print *,"test FAILED"
else
    print *,"test PASSED"
end if
end

To compile and link this program for CPU execution using nvfortran, the simplest option would be nvfortran testdgetrf.f90 -llapack -lblas. To enable acceleration on the GPU, the simplest option would be nvfortran -stdpar -gpu=nvlamath testdgetrf.f90 -cudalib=nvlamath. Here, -stdpar is one of the available methods to instruct the compiler and runtime to treat allocatable arrays as CUDA managed data. The -gpu=nvlamath option instructs the compiler to insert the statement use nvhpc_nvlamath into the program unit and then the two LAPACK calls are redirected to the wrappers. Finally, the -cudalib=nvlamath linker option pulls in the NVLAmath wrapper runtime library.

NVLAMATH Usage From CUDA Fortran

From CUDA Fortran, usage of NVLAmath is very straight-forward. The interfaces in the nvhpc_nvlamath module are similar in nature to all the other Fortran modules in this document. The library function device dummy arguments can be matched to device or managed actual arguments, or a combination of both, as used here.

This example code is written in CUDA Fortran. Note that all CUDA Fortran additions are behind the !@cuf sentinel, or within a CUF kernel, which still allows this file to be compiled with any Fortran compiler.

program testdgetrf
!@cuf use nvhpc_nvlamath
!@cuf use cutensorex
integer, parameter :: M = 1000, N = M, NRHS=2
real(8), allocatable :: A(:,:), B(:,:)
integer, allocatable :: IPIV(:)
!@cuf attributes(device) :: A, IPIV
!@cuf attributes(managed) :: B
real(8), parameter :: eps = 1.0d-10
!
allocate(A(M,N),B(M,NRHS),IPIV(M))
call random_number(A)
!$cuf kernel do(1)<<<*,*>>>
do i = 1, M
    A(i,i) = A(i,i) * 10.0d0
    B(i,1) = sum(A(i,:))
    B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!
if ((info1.ne.0) .or. (info2.ne.0)) then
    print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0) .gt. eps) .or. &
         any(abs(B(:,2)-2.0d0) .gt. eps)) then
    print *,"test FAILED"
else
    print *,"test PASSED"
end if
end

Here we use the nvhpc_nvlamath module explicitly, and we also use the cutensorex module, discussed elsewhere in this document, to generate random numbers on the GPU. Assuming this file has a .cuf extension, the simplest compile and link line to use with this file is nvfortran testdgetrf.cuf -cudalib=curand,nvlamath.

NVLAMATH Usage From OpenACC

From OpenACC, the LAPACK functions are treated just like CUBLAS or CUSOLVER functions. Use the host_data use_device directive to pass device pointers to the functions.

program testdgetrf
integer, parameter :: M = 1000, N = M, NRHS=2
real(8) :: A(M,N), B(M,NRHS)
integer :: IPIV(M)
real(8), parameter :: eps = 1.0d-10
!
call random_number(A)
!$acc data copyin(A), copyout(B), create(IPIV)
!$acc parallel loop
do i = 1, M
  A(i,i) = A(i,i) * 10.0d0
  B(i,1) = sum(A(i,:))
  B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
!$acc host_data use_device(A, IPIV, B)
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!$acc end host_data
!$acc end data
!
if ((info1.ne.0) .or. (info2.ne.0)) then
  print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0).gt.eps).or.any(abs(B(:,2)-2.0d0).gt.eps)) then
  print *,"test FAILED"
else
  print *,"test PASSED"
end if
end

Here we show static arrays rather than dynamic arrays, so we use OpenACC data directives to control the data movement. The simplest compile and link line to use with this file is nvfortran -acc=gpu -gpu=nvlamath testdgetrf.f90 -cudalib=nvlamath.

NVLAMATH Usage From OpenMP

Usage of the NVLAmath functions from OpenMP are basically the same as from OpenACC. Use the target data use_device_ptr directive to pass device pointers to the functions.

program testdgetrf
integer, parameter :: M = 1000, N = M, NRHS=2
real(8) :: A(M,N), B(M,NRHS)
integer :: IPIV(M)
real(8), parameter :: eps = 1.0d-10
!
call random_number(A)
!$omp target enter data map(to:A) map(alloc:B,IPIV)
!$omp target teams loop
do i = 1, M
  A(i,i) = A(i,i) * 10.0d0
  B(i,1) = sum(A(i,:))
  B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
!$omp target data use_device_ptr(A, IPIV, B)
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!$omp end target data
!$omp target exit data map(from:B) map(delete:A,IPIV)
!
if ((info1.ne.0) .or. (info2.ne.0)) then
  print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0).gt.eps).or.any(abs(B(:,2)-2.0d0).gt.eps)) then
  print *,"test FAILED"
else
  print *,"test PASSED"
end if
end

Again we show static arrays rather than dynamic arrays, so we use OpenMP data directives to control the data movement. The simplest compile and link line to use with this file is nvfortran -mp=gpu -gpu=nvlamath testdgetrf.f90 -cudalib=nvlamath.

NVLAMATH List of Current Subroutines

Out of the thousands of LAPACK subroutines and functions, 31 of the most commonly used and requested subroutines are currently wrapped in this library.

Table 1. NVLAMATH List of Subroutines

		S	C	D	Z
Linear Solvers	LU	sgetrf	cgetrf	dgetrf	zgetrf
		sgetrs	cgetrs	dgetrs	zgetrs
		sgesv
	Cholesky			dpotrf	zpotrf
				dpotrs
Eigen Solvers	Eigen Solver	ssyev		dsyev	zheev
		ssyevd	cheevd	dsyevd	zheevd
	Partial Eigen Solver	ssyevx	cheevx	dsyevx	zheevx
		ssyevr		dsyevr
	Eigen Solver for Generalized Problems			dsygv	zhegv
				dsygvd	zhegvd
	Partial Eigen Solver for Generalized Problems				zhegvx
	SVD			dgesvd

NVLAMATH Argument Checks and CPU Fallback

In large, complicated applications, the compiler (and developers) can lose track of the attributes of data arrays: whether they are host arrays, managed, or device. Note that the compilers auto-conversion of allocatable arrays to managed require that they be allocatable. Consider the example from the drop-in case, but where the pivot array is declared statically.

program testdgetrf
integer, parameter :: M = 1000, N = M, NRHS=2
real(8), allocatable :: A(:,:), B(:,:)
integer :: IPIV(M)
real(8), parameter :: eps = 1.0d-10
!
allocate(A(M,N),B(M,NRHS))
call random_number(A)
do i = 1, M
    A(i,i) = A(i,i) * 10.0d0
    B(i,1) = sum(A(i,:))
    B(i,2) = B(i,1) * 2.0d0
end do
!
lda = M; ldb = M
call dgetrf(M,N,A,lda,IPIV,info1)
call dgetrs('n',n,NRHS,A,lda,IPIV,B,ldb,info2)
!
if ((info1.ne.0) .or. (info2.ne.0)) then
    print *,"test FAILED"
else if (any(abs(B(:,1)-1.0d0) .gt. eps) .or. &
         any(abs(B(:,2)-2.0d0) .gt. eps)) then
    print *,"test FAILED"
else
    print *,"test PASSED"
end if
end

Now, we compile this as before, nvfortran -stdpar -gpu=nvlamath testdgetrf.f90 -cudalib=nvlamath. To review, -stdpar instructs the compiler and runtime to treat allocatable arrays as CUDA managed data. However, this time when the program is run:

** On entry to dgetrf parameter number 5 failed the pointer check
3: Accessible on GPU = T; Accessible on CPU = T
5: Accessible on GPU = F; Accessible on CPU = T
 Fallback to CPU compute disabled.
 Please (1) make sure that input arrays are accessible on the GPU; or (2) set
 environment variable NVCOMPILER_LAMATH_FALLBACK=1 to fallback to CPU execution.
 Terminate the application

Except when every array in the call is accessible only on the CPU, we assume that if the developer is using NVLAMATH, they intend to run the library function on the GPU, thus a mismatch in the GPU-accessibility of the subroutine arguments should be reported. As the error message states, you can continue through this error by setting the NVCOMPILER_LAMATH_FALLBACK environment variable to 1.

** On entry to dgetrf parameter number 5 failed the pointer check
3: Accessible on GPU = T; Accessible on CPU = T
5: Accessible on GPU = F; Accessible on CPU = T
 Fallback to CPU compute
** On entry to dgetrs parameter number 6 failed the pointer check
4: Accessible on GPU = T; Accessible on CPU = T
6: Accessible on GPU = F; Accessible on CPU = T
7: Accessible on GPU = T; Accessible on CPU = T
 Fallback to CPU compute
 test PASSED

Finally, we assume the developer would rather fix the issue by making the pivot array accessible on the GPU, either via CUDA Fortran device or managed attributes, OpenACC or OpenMP data directives, or changing it from statically declared to allocatable.