All cuBLAS library function calls return the error status cublasStatus_t.

The application must initialize the handle to the cuBLAS library context by calling the cublasCreate() function. Then, the handle is explicitly passed to every subsequent library function call. Once the application finishes using the library, it must call the function cublasDestroy() to release the resources associated with the cuBLAS library context.

This approach allows the user to explicitly control the library setup when using multiple host threads and multiple GPUs. For example, the application can use cudaSetDevice() to associate different devices with different host threads and in each of those host threads it can initialize a unique handle to the cuBLAS library context, which will use the particular device associated with that host thread. Then, the cuBLAS library function calls made with different handle will automatically dispatch the computation to different devices.

The device associated with a particular cuBLAS context is assumed to remain unchanged between the corresponding cublasCreate() and cublasDestroy() calls. In order for the cuBLAS library to use a different device in the same host thread, the application must set the new device to be used by calling cudaSetDevice() and then create another cuBLAS context, which will be associated with the new device, by calling cublasCreate().

The library is thread safe and its functions can be called from multiple host threads, even with the same handle. When multiple threads share the same handle, extreme care needs to be taken when the handle configuration is changed because that change will affect potentially subsequent cuBLAS calls in all threads. It is even more true for the destruction of the handle. So it is not recommended that multiple thread share the same cuBLAS handle.

By design, all cuBLAS API routines from a given toolkit version, generate the same bit-wise results at every run when executed on GPUs with the same architecture and the same number of SMs. However, bit-wise reproducibility is not guaranteed across toolkit versions because the implementation might differ due to some implementation changes.

This guarantee holds when a single CUDA stream is active only. If multiple concurrent streams are active, the library may optimize total performance by picking different internal implementations.

Note: The non-deterministic behavior of multi-stream execution is due to library optimizations in selecting internal workspace for the routines running in parallel streams. To avoid this effect user can either:

This behavior is expected to change in a future release.

For some routines such as cublas<t>symv and cublas<t>hemv, an alternate significantly faster routine can be chosen using the routine cublasSetAtomicsMode(). In that case, the results are not guaranteed to be bit-wise reproducible because atomics are used for the computation.

There are two categories of the functions that use scalar parameters :

• Functions that take alpha and/or beta parameters by reference on the host or the device as scaling factors, such as gemm.
• Functions that return a scalar result on the host or the device such as amax(), amin, asum(), rotg(), rotmg(), dot() and nrm2().

For the functions of the first category, when the pointer mode is set to CUBLAS_POINTER_MODE_HOST, the scalar parameters alpha and/or beta can be on the stack or allocated on the heap. Underneath, the CUDA kernels related to those functions will be launched with the value of alpha and/or beta. Therefore if they were allocated on the heap, they can be freed just after the return of the call even though the kernel launch is asynchronous. When the pointer mode is set to CUBLAS_POINTER_MODE_DEVICE, alpha and/or beta must be accessible on the device and their values should not be modified until the kernel is done. Note that since cudaFree() does an implicit cudaDeviceSynchronize(), cudaFree() can still be called on alpha and/or beta just after the call but it would defeat the purpose of using this pointer mode in that case.

For the functions of the second category, when the pointer mode is set to CUBLAS_POINTER_MODE_HOST, these functions block the CPU, until the GPU has completed its computation and the results have been copied back to the Host. When the pointer mode is set to CUBLAS_POINTER_MODE_DEVICE, these functions return immediately. In this case, similar to matrix and vector results, the scalar result is ready only when execution of the routine on the GPU has completed. This requires proper synchronization in order to read the result from the host.

In either case, the pointer mode CUBLAS_POINTER_MODE_DEVICE allows the library functions to execute completely asynchronously from the Host even when alpha and/or beta are generated by a previous kernel. For example, this situation can arise when iterative methods for solution of linear systems and eigenvalue problems are implemented using the cuBLAS library.

If the application uses the results computed by multiple independent tasks, CUDA™ streams can be used to overlap the computation performed in these tasks.

The application can conceptually associate each stream with each task. In order to achieve the overlap of computation between the tasks, the user should create CUDA™ streams using the function cudaStreamCreate() and set the stream to be used by each individual cuBLAS library routine by calling cublasSetStream() just before calling the actual cuBLAS routine. Note that cublasSetStream() resets the user-provided workspace to the default workspace pool; see cublasSetWorkspace(). Then, the computation performed in separate streams would be overlapped automatically when possible on the GPU. This approach is especially useful when the computation performed by a single task is relatively small and is not enough to fill the GPU with work.

We recommend using the new cuBLAS API with scalar parameters and results passed by reference in the device memory to achieve maximum overlap of the computation when using streams.

A particular application of streams, batching of multiple small kernels, is described in the following section.

In this section, we explain how to use streams to batch the execution of small kernels. For instance, suppose that we have an application where we need to make many small independent matrix-matrix multiplications with dense matrices.

It is clear that even with millions of small independent matrices we will not be able to achieve the same GFLOPS rate as with a one large matrix. For example, a single $n\times n$ large matrix-matrix multiplication performs $n^3$ operations for $n^2$ input size, while 1024 $\frac{n}{32}\times \frac{n}{32}$ small matrix-matrix multiplications perform $1024{\left(\frac{n}{32}\right)}^3=\frac{n^3}{32}$ operations for the same input size. However, it is also clear that we can achieve a significantly better performance with many small independent matrices compared with a single small matrix.

The architecture family of GPUs allows us to execute multiple kernels simultaneously. Hence, in order to batch the execution of independent kernels, we can run each of them in a separate stream. In particular, in the above example we could create 1024 CUDA™ streams using the function cudaStreamCreate(), then preface each call to cublas<t>gemm() with a call to cublasSetStream() with a different stream for each of the matrix-matrix multiplications (note that cublasSetStream() resets user-provided workspace to the default workspace pool, see cublasSetWorkspace()). This will ensure that when possible the different computations will be executed concurrently. Although the user can create many streams, in practice it is not possible to have more than 32 concurrent kernels executing at the same time.

On some devices, L1 cache and shared memory use the same hardware resources. The cache configuration can be set directly with the CUDA Runtime function cudaDeviceSetCacheConfig. The cache configuration can also be set specifically for some functions using the routine cudaFuncSetCacheConfig. Please refer to the CUDA Runtime API documentation for details about the cache configuration settings.

Because switching from one configuration to another can affect kernels concurrency, the cuBLAS Library does not set any cache configuration preference and relies on the current setting. However, some cuBLAS routines, especially Level-3 routines, rely heavily on shared memory. Thus the cache preference setting might affect adversely their performance.

Starting with release 6.5, the cuBLAS Library is also delivered in a static form as libcublas_static.a on Linux and Mac OSes. The static cuBLAS library and all other static math libraries depend on a common thread abstraction layer library called libculibos.a.

For example, on Linux, to compile a small application using cuBLAS, against the dynamic library, the following command can be used:

    nvcc myCublasApp.c  -lcublas  -o myCublasApp

Whereas to compile against the static cuBLAS library, the following command must be used:

    nvcc myCublasApp.c  -lcublas_static   -lculibos -o myCublasApp

It is also possible to use the native Host C++ compiler. Depending on the Host operating system, some additional libraries like pthread or dl might be needed on the linking line. The following command on Linux is suggested :

    g++ myCublasApp.c  -lcublas_static   -lculibos -lcudart_static -lpthread -ldl -I <cuda-toolkit-path>/include -L <cuda-toolkit-path>/lib64 -o myCublasApp
 

Note that in the latter case, the library cuda is not needed. The CUDA Runtime will try to open explicitly the cuda library if needed. In the case of a system which does not have the CUDA driver installed, this allows the application to gracefully manage this issue and potentially run if a CPU-only path is available.

Some GEMM algorithms split the computation along the dimension K to increase the GPU occupancy, especially when the dimension K is large compared to dimensions M and N. When this type of algorithm is chosen by the cuBLAS heuristics or explicitly by the user, the results of each split is summed deterministically into the resulting matrix to get the final result.

For the routines cublas<t>gemmEx and cublasGemmEx, when the compute type is greater than the output type, the sum of the split chunks can potentially lead to some intermediate overflows thus producing a final resulting matrix with some overflows. Those overflows might not have occurred if all the dot products had been accumulated in the compute type before being converted at the end in the output type. This computation side-effect can be easily exposed when the computeType is CUDA_R_32F and Atype, Btype and Ctype are in CUDA_R_16F. This behavior can be controlled using the compute precision mode CUBLAS_MATH_DISALLOW_REDUCED_PRECISION_REDUCTION with cublasSetMathMode()

Tensor cores were first introduced with Volta GPUs (compute capability>=sm_70) and significantly accelerate matrix multiplications. Starting with cuBLAS version 11.0.0, the library will automatically make use of Tensor Core capabilities wherever possible, unless they are explicitly disabled by selecting pedantic compute modes in cuBLAS (see cublasSetMathMode(), cublasMath_t, cublasSetMathMode()).

It should be noted that the library will pick a Tensor Core enabled implementation wherever it determines that it would provide the best performance.

cuBLAS routines can be captured in CUDA Graph stream capture without restrictions in most situations.

The exception are routines that output results into host buffers (e.g. cublas<t>dot while pointer mode CUBLAS_POINTER_MODE_HOST is configured), as it enforces synchronization.

NOTE: Every time cuBLAS routines are captured in a new CUDA Graph, cuBLAS will allocate workspace memory on the device. This memory is only freed when the cuBLAS handle used during capture is deleted. To avoid this, use cublasSetWorkspace() function to provide user owned workspace memory.

The cublasHandle_t type is a pointer type to an opaque structure holding the cuBLAS library context. The cuBLAS library context must be initialized using cublasCreate() and the returned handle must be passed to all subsequent library function calls. The context should be destroyed at the end using cublasDestroy().

The type is used for function status returns. All cuBLAS library functions return their status, which can have the following values.

The cublasOperation_t type indicates which operation needs to be performed with the dense matrix. Its values correspond to Fortran characters ‘N’ or ‘n’ (non-transpose), ‘T’ or ‘t’ (transpose) and ‘C’ or ‘c’ (conjugate transpose) that are often used as parameters to legacy BLAS implementations.

The type indicates which part (lower or upper) of the dense matrix was filled and consequently should be used by the function. Its values correspond to Fortran characters ‘L’ or ‘l’ (lower) and ‘U’ or ‘u’ (upper) that are often used as parameters to legacy BLAS implementations.

The type indicates whether the main diagonal of the dense matrix is unity and consequently should not be touched or modified by the function. Its values correspond to Fortran characters ‘N’ or ‘n’ (non-unit) and ‘U’ or ‘u’ (unit) that are often used as parameters to legacy BLAS implementations.

The type indicates whether the dense matrix is on the left or right side in the matrix equation solved by a particular function. Its values correspond to Fortran characters ‘L’ or ‘l’ (left) and ‘R’ or ‘r’ (right) that are often used as parameters to legacy BLAS implementations.

The cublasPointerMode_t type indicates whether the scalar values are passed by reference on the host or device. It is important to point out that if several scalar values are present in the function call, all of them must conform to the same single pointer mode. The pointer mode can be set and retrieved using cublasSetPointerMode() and cublasGetPointerMode() routines, respectively.

The type indicates whether cuBLAS routines which has an alternate implementation using atomics can be used. The atomics mode can be set and queried using cublasSetAtomicsMode() and cublasGetAtomicsMode() and routines, respectively.

cublasGemmAlgo_t type is an enumerant to specify the algorithm for matrix-matrix multiplication on GPU architectures up to sm_75. On sm_80 and newer GPU architectures, this enumarant has no effect. cuBLAS has the following algorithm options:

cublasMath_t enumerate type is used in cublasSetMathMode() to choose compute precision modes as defined below. Since this setting does not directly control the use of Tensor Cores, the mode CUBLAS_TENSOR_OP_MATH is being deprecated and will be removed in a future release.

cublasComputeType_t enumerate type is used in cublasGemmEx and cublasLtMatmul (including all batched and strided batched variants) to choose compute precision modes as defined below.

NOTE: Setting the environment variable NVIDIA_TF32_OVERRIDE = 0 will override any defaults or programmatic configuration of NVIDIA libraries, and consequently, cuBLAS will not accelerate FP32 computations with TF32 tensor cores.

The cudaDataType_t type is an enumerant to specify the data precision. It is used when the data reference does not carry the type itself (e.g void *)

For example, it is used in the routine cublasSgemmEx.

The libraryPropertyType_t is used as a parameter to specify which property is requested when using the routine cublasGetProperty

cublasStatus_t
cublasCreate(cublasHandle_t *handle)

This function initializes the cuBLAS library and creates a handle to an opaque structure holding the cuBLAS library context. It allocates hardware resources on the host and device and must be called prior to making any other cuBLAS library calls. The cuBLAS library context is tied to the current CUDA device. To use the library on multiple devices, one cuBLAS handle needs to be created for each device. Furthermore, for a given device, multiple cuBLAS handles with different configurations can be created. Because cublasCreate() allocates some internal resources and the release of those resources by calling cublasDestroy() will implicitly call cublasDeviceSynchronize(), it is recommended to minimize the number of cublasCreate()/cublasDestroy() occurrences. For multi-threaded applications that use the same device from different threads, the recommended programming model is to create one cuBLAS handle per thread and use that cuBLAS handle for the entire life of the thread.

cublasStatus_t
cublasDestroy(cublasHandle_t handle)

This function releases hardware resources used by the cuBLAS library. This function is usually the last call with a particular handle to the cuBLAS library. Because cublasCreate() allocates some internal resources and the release of those resources by calling cublasDestroy() will implicitly call cublasDeviceSynchronize(), it is recommended to minimize the number of cublasCreate()/cublasDestroy() occurrences.

cublasStatus_t
cublasGetVersion(cublasHandle_t handle, int *version)

This function returns the version number of the cuBLAS library.

cublasStatus_t
cublasGetProperty(libraryPropertyType type, int *value)

This function returns the value of the requested property in memory pointed to by value. Refer to libraryPropertyType for supported types.

cublasStatus_t
cublasSetStream(cublasHandle_t handle, cudaStream_t streamId)

This function sets the cuBLAS library stream, which will be used to execute all subsequent calls to the cuBLAS library functions. If the cuBLAS library stream is not set, all kernels use the defaultNULL stream. In particular, this routine can be used to change the stream between kernel launches and then to reset the cuBLAS library stream back to NULL. Additionally this function unconditionally resets the cuBLAS library workspace back to the default workspace pool (see cublasSetWorkspace()).

cublasStatus_t
cublasSetWorkspace(cublasHandle_t handle, void *workspace, size_t workspaceSizeInBytes)

This function sets the cuBLAS library workspace to a user-owned device buffer, which will be used to execute all subsequent calls to the cuBLAS library functions (on the currently set stream). If the cuBLAS library workspace is not set, all kernels will use the default workspace pool allocated during the cuBLAS context creation. In particular, this routine can be used to change the workspace between kernel launches. The workspace pointer should be aligned to at least 256 bytes, otherwise library will not be able to use full buffer size provided. The cublasSetStream() function unconditionally resets the cuBLAS library workspace back to the default workspace pool. Too small workspaceSizeInBytes may cause some routines to fail with CUBLAS_STATUS_ALLOC_FAILED error returned or cause large regressions in performance. Workspace size equal to or larger than 16KiB is enough to prevent CUBLAS_STATUS_ALLOC_FAILED error, while a larger workspace can provide performance benefits for some routines. Recommended size of user-provided workspace is at least 4MiB (to match cuBLAS’ default workspace pool).

This function can't be used together with cudaStreamPerThread. Such combination will result in CUBLAS_STATUS_INVALID_VALUE.

cublasStatus_t
cublasGetStream(cublasHandle_t handle, cudaStream_t *streamId)

This function gets the cuBLAS library stream, which is being used to execute all calls to the cuBLAS library functions. If the cuBLAS library stream is not set, all kernels use the defaultNULL stream.

cublasStatus_t
cublasGetPointerMode(cublasHandle_t handle, cublasPointerMode_t *mode)

This function obtains the pointer mode used by the cuBLAS library. Please see the section on the cublasPointerMode_t type for more details.

cublasStatus_t
cublasSetPointerMode(cublasHandle_t handle, cublasPointerMode_t mode)

This function sets the pointer mode used by the cuBLAS library. The default is for the values to be passed by reference on the host. Please see the section on the cublasPointerMode_t type for more details.

cublasStatus_t
cublasSetVector(int n, int elemSize,
                const void *x, int incx, void *y, int incy)

This function copies n elements from a vector x in host memory space to a vector y in GPU memory space. Elements in both vectors are assumed to have a size of elemSize bytes. The storage spacing between consecutive elements is given by incx for the source vector x and by incy for the destination vector y.

In general, y points to an object, or part of an object, that was allocated via cublasAlloc(). Since column-major format for two-dimensional matrices is assumed, if a vector is part of a matrix, a vector increment equal to 1 accesses a (partial) column of that matrix. Similarly, using an increment equal to the leading dimension of the matrix results in accesses to a (partial) row of that matrix.

cublasStatus_t
cublasGetVector(int n, int elemSize,
                const void *x, int incx, void *y, int incy)

This function copies n elements from a vector x in GPU memory space to a vector y in host memory space. Elements in both vectors are assumed to have a size of elemSize bytes. The storage spacing between consecutive elements is given by incx for the source vector and incy for the destination vector y.

In general, x points to an object, or part of an object, that was allocated via cublasAlloc(). Since column-major format for two-dimensional matrices is assumed, if a vector is part of a matrix, a vector increment equal to 1 accesses a (partial) column of that matrix. Similarly, using an increment equal to the leading dimension of the matrix results in accesses to a (partial) row of that matrix.

cublasStatus_t
cublasSetMatrix(int rows, int cols, int elemSize,
                const void *A, int lda, void *B, int ldb)

This function copies a tile of rows x cols elements from a matrix A in host memory space to a matrix B in GPU memory space. It is assumed that each element requires storage of elemSize bytes and that both matrices are stored in column-major format, with the leading dimension of the source matrix A and destination matrix B given in lda and ldb, respectively. The leading dimension indicates the number of rows of the allocated matrix, even if only a submatrix of it is being used. In general, B is a device pointer that points to an object, or part of an object, that was allocated in GPU memory space via cublasAlloc().

cublasStatus_t
cublasGetMatrix(int rows, int cols, int elemSize,
                const void *A, int lda, void *B, int ldb)

This function copies a tile of rows x cols elements from a matrix A in GPU memory space to a matrix B in host memory space. It is assumed that each element requires storage of elemSize bytes and that both matrices are stored in column-major format, with the leading dimension of the source matrix A and destination matrix B given in lda and ldb, respectively. The leading dimension indicates the number of rows of the allocated matrix, even if only a submatrix of it is being used. In general, A is a device pointer that points to an object, or part of an object, that was allocated in GPU memory space via cublasAlloc().

cublasStatus_t
cublasSetVectorAsync(int n, int elemSize, const void *hostPtr, int incx,
                     void *devicePtr, int incy, cudaStream_t stream)

This function has the same functionality as cublasSetVector(), with the exception that the data transfer is done asynchronously (with respect to the host) using the given CUDA™ stream parameter.

cublasStatus_t
cublasGetVectorAsync(int n, int elemSize, const void *devicePtr, int incx,
                     void *hostPtr, int incy, cudaStream_t stream)

This function has the same functionality as cublasGetVector(), with the exception that the data transfer is done asynchronously (with respect to the host) using the given CUDA™ stream parameter.

cublasStatus_t
cublasSetMatrixAsync(int rows, int cols, int elemSize, const void *A,
                     int lda, void *B, int ldb, cudaStream_t stream)

This function has the same functionality as cublasSetMatrix(), with the exception that the data transfer is done asynchronously (with respect to the host) using the given CUDA™ stream parameter.

cublasStatus_t
cublasGetMatrixAsync(int rows, int cols, int elemSize, const void *A,
                     int lda, void *B, int ldb, cudaStream_t stream)

This function has the same functionality as cublasGetMatrix(), with the exception that the data transfer is done asynchronously (with respect to the host) using the given CUDA™ stream parameter.

cublasStatus_t cublasSetAtomicsMode(cublasHandlet handle, cublasAtomicsMode_t mode)

Some routines like cublas<t>symv and cublas<t>hemv have an alternate implementation that use atomics to cumulate results. This implementation is generally significantly faster but can generate results that are not strictly identical from one run to the others. Mathematically, those different results are not significant but when debugging those differences can be prejudicial.

This function allows or disallows the usage of atomics in the cuBLAS library for all routines which have an alternate implementation. When not explicitly specified in the documentation of any cuBLAS routine, it means that this routine does not have an alternate implementation that use atomics. When atomics mode is disabled, each cuBLAS routine should produce the same results from one run to the other when called with identical parameters on the same Hardware.

The value of the atomics mode is CUBLAS_ATOMICS_NOT_ALLOWED. Please see the section on the type for more details.

cublasStatus_t cublasGetAtomicsMode(cublasHandle_t handle, cublasAtomicsMode_t *mode)

This function queries the atomic mode of a specific cuBLAS context.

The value of the atomics mode is CUBLAS_ATOMICS_NOT_ALLOWED. Please see the section on the type for more details.

cublasStatus_t cublasSetMathMode(cublasHandle_t handle, cublasMath_t mode)

The cublasSetMathMode function enables you to choose whether or not to use Tensor Core operations in the library by setting the math mode to either CUBLAS_TENSOR_OP_MATH or CUBLAS_DEFAULT_MATH. Tensor Core operations perform parallel floating point accumulation of multiple floating point products. Setting the math mode to CUBLAS_TENSOR_OP_MATH indicates that the library will use Tensor Core operations in the functions: cublasHgemm(), cublasGemmEx, cublasSgemmEx(), cublasHgemmBatched() and cublasHgemmStridedBatched(). The math mode default is CUBLAS_DEFAULT_MATH, this default indicates that the Tensor Core operations will be avoided by the library. The default mode is a serialized operation, the Tensor Core operations are parallelized, thus the two might result in slight different numerical results due to the different sequencing of operations. Note: The library falls back to the default math mode when Tensor Core operations are not supported or not permitted.

cublasStatus_t cublasGetMathMode(cublasHandle_t handle, cublasMath_t *mode)

This function returns the math mode used by the library routines.

cublasStatus_t cublasLoggerConfigure(
    int             logIsOn,
    int             logToStdOut,
    int             logToStdErr,
    const char*     logFileName)

This function configures logging during runtime. Besides this type of configuration, it is possible to configure logging with special environment variables which will be checked by libcublas:

• CUBLAS_LOGINFO_DBG - Setup env. variable to "1" means turn on logging (by default logging is off).
• CUBLAS_LOGDEST_DBG - Setup env. variable encodes how to log. "stdout", "stderr" means to output log messages to stdout or stderr, respectively. In the other case, its specifies "filename" of file.

Parameters

logIsOn

Input. Turn on/off logging completely. By default is off, but is turned on by calling cublasSetLoggerCallback to user defined callback function.

logToStdOut

Input. Turn on/off logging to standard error I/O stream. By default is off.

logToStdErr

Input. Turn on/off logging to standard error I/O stream. By default is off.

logFileName

Input. Turn on/off logging to file in filesystem specified by it's name. cublasLoggerConfigure copy content of logFileName. You should provide null pointer if you're not interested in this type of logging.

Returns

CUBLAS_STATUS_SUCCESS

Success.

cublasStatus_t cublasGetLoggerCallback(
    cublasLogCallback* userCallback)

This function retrieves function pointer to previously installed custom user defined callback function via cublasSetLoggerCallback or zero otherwise.

Parameters

userCallback

Output. Pointer to user defined callback function.

Returns

CUBLAS_STATUS_SUCCESS

Success.

cublasStatus_t cublasSetLoggerCallback(
    cublasLogCallback   userCallback)

This function installs a custom user defined callback function via cublas C public API.

Parameters

userCallback

Input. Pointer to user defined callback function.

Returns

CUBLAS_STATUS_SUCCESS

Success.

cublasStatus_t cublasIsamax(cublasHandle_t handle, int n,
                            const float *x, int incx, int *result)
cublasStatus_t cublasIdamax(cublasHandle_t handle, int n,
                            const double *x, int incx, int *result)
cublasStatus_t cublasIcamax(cublasHandle_t handle, int n,
                            const cuComplex *x, int incx, int *result)
cublasStatus_t cublasIzamax(cublasHandle_t handle, int n,
                            const cuDoubleComplex *x, int incx, int *result)

This function finds the (smallest) index of the element of the maximum magnitude. Hence, the result is the first $i$ such that $\left|Im\left(x\left[j\right]\right)\right|+\left|Re\left(x\left[j\right]\right)\right|$ is maximum for $i=1,\dots ,n$ and $j=1+\left(i-1\right)*\text{ incx}$ . Notice that the last equation reflects 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

isamax, idamax, icamax, izamax

cublasStatus_t cublasIsamin(cublasHandle_t handle, int n,
                            const float *x, int incx, int *result)
cublasStatus_t cublasIdamin(cublasHandle_t handle, int n,
                            const double *x, int incx, int *result)
cublasStatus_t cublasIcamin(cublasHandle_t handle, int n,
                            const cuComplex *x, int incx, int *result)
cublasStatus_t cublasIzamin(cublasHandle_t handle, int n,
                            const cuDoubleComplex *x, int incx, int *result)

This function finds the (smallest) index of the element of the minimum magnitude. Hence, the result is the first $i$ such that $\left|Im\left(x\left[j\right]\right)\right|+\left|Re\left(x\left[j\right]\right)\right|$ is minimum for $i=1,\dots ,n$ and $j=1+\left(i-1\right)*\text{ incx}$ Notice that the last equation reflects 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

isamin

cublasStatus_t  cublasSasum(cublasHandle_t handle, int n,
                            const float           *x, int incx, float  *result)
cublasStatus_t  cublasDasum(cublasHandle_t handle, int n,
                            const double          *x, int incx, double *result)
cublasStatus_t cublasScasum(cublasHandle_t handle, int n,
                            const cuComplex       *x, int incx, float  *result)
cublasStatus_t cublasDzasum(cublasHandle_t handle, int n,
                            const cuDoubleComplex *x, int incx, double *result)

This function computes the sum of the absolute values of the elements of vector x. Hence, the result is ${\sum }_{i=1}^n\left|Im\left(x\left[j\right]\right)\right|+\left|Re\left(x\left[j\right]\right)\right|$ where $j=1+\left(i-1\right)*\text{ incx}$ . Notice that the last equation reflects 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sasum, dasum, scasum, dzasum

cublasStatus_t cublasSaxpy(cublasHandle_t handle, int n,
                           const float           *alpha,
                           const float           *x, int incx,
                           float                 *y, int incy)
cublasStatus_t cublasDaxpy(cublasHandle_t handle, int n,
                           const double          *alpha,
                           const double          *x, int incx,
                           double                *y, int incy)
cublasStatus_t cublasCaxpy(cublasHandle_t handle, int n,
                           const cuComplex       *alpha,
                           const cuComplex       *x, int incx,
                           cuComplex             *y, int incy)
cublasStatus_t cublasZaxpy(cublasHandle_t handle, int n,
                           const cuDoubleComplex *alpha,
                           const cuDoubleComplex *x, int incx,
                           cuDoubleComplex       *y, int incy)

This function multiplies the vector x by the scalar $\alpha$ and adds it to the vector y overwriting the latest vector with the result. Hence, the performed operation is $y\left[j\right]=\alpha \times x\left[k\right]+y\left[j\right]$ for $i=1,\dots ,n$ , $k=1+\left(i-1\right)*\text{ incx}$ and $j=1+\left(i-1\right)*\text{ incy}$ . Notice that the last two equations reflect 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

saxpy, daxpy, caxpy, zaxpy

cublasStatus_t cublasScopy(cublasHandle_t handle, int n,
                           const float           *x, int incx,
                           float                 *y, int incy)
cublasStatus_t cublasDcopy(cublasHandle_t handle, int n,
                           const double          *x, int incx,
                           double                *y, int incy)
cublasStatus_t cublasCcopy(cublasHandle_t handle, int n,
                           const cuComplex       *x, int incx,
                           cuComplex             *y, int incy)
cublasStatus_t cublasZcopy(cublasHandle_t handle, int n,
                           const cuDoubleComplex *x, int incx,
                           cuDoubleComplex       *y, int incy)

This function copies the vector x into the vector y. Hence, the performed operation is $y\left[j\right]=x\left[k\right]$ for $i=1,\dots ,n$ , $k=1+\left(i-1\right)*\text{ incx}$ and $j=1+\left(i-1\right)*\text{ incy}$ . Notice that the last two equations reflect 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

scopy, dcopy, ccopy, zcopy

cublasStatus_t cublasSdot (cublasHandle_t handle, int n,
                           const float           *x, int incx,
                           const float           *y, int incy,
                           float           *result)
cublasStatus_t cublasDdot (cublasHandle_t handle, int n,
                           const double          *x, int incx,
                           const double          *y, int incy,
                           double          *result)
cublasStatus_t cublasCdotu(cublasHandle_t handle, int n,
                           const cuComplex       *x, int incx,
                           const cuComplex       *y, int incy,
                           cuComplex       *result)
cublasStatus_t cublasCdotc(cublasHandle_t handle, int n,
                           const cuComplex       *x, int incx,
                           const cuComplex       *y, int incy,
                           cuComplex       *result)
cublasStatus_t cublasZdotu(cublasHandle_t handle, int n,
                           const cuDoubleComplex *x, int incx,
                           const cuDoubleComplex *y, int incy,
                           cuDoubleComplex *result)
cublasStatus_t cublasZdotc(cublasHandle_t handle, int n,
                           const cuDoubleComplex *x, int incx,
                           const cuDoubleComplex *y, int incy,
                           cuDoubleComplex       *result)

This function computes the dot product of vectors x and y. Hence, the result is ${\sum }_{i=1}^n\left(x\left[k\right]\times y\left[j\right]\right)$ where $k=1+\left(i-1\right)*\text{ incx}$ and $j=1+\left(i-1\right)*\text{ incy}$ . Notice that in the first equation the conjugate of the element of vector should be used if the function name ends in character ‘c’ and that the last two equations reflect 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sdot, ddot, cdotu, cdotc, zdotu, zdotc

cublasStatus_t  cublasSnrm2(cublasHandle_t handle, int n,
                            const float           *x, int incx, float  *result)
cublasStatus_t  cublasDnrm2(cublasHandle_t handle, int n,
                            const double          *x, int incx, double *result)
cublasStatus_t cublasScnrm2(cublasHandle_t handle, int n,
                            const cuComplex       *x, int incx, float  *result)
cublasStatus_t cublasDznrm2(cublasHandle_t handle, int n,
                            const cuDoubleComplex *x, int incx, double *result)

This function computes the Euclidean norm of the vector x. The code uses a multiphase model of accumulation to avoid intermediate underflow and overflow, with the result being equivalent to $\sqrt{{\sum }_{i=1}^n\left(x\left[j\right]\times x\left[j\right]\right)}$ where $j=1+\left(i-1\right)*\text{ incx}$ in exact arithmetic. Notice that the last equation reflects 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

snrm2, snrm2, dnrm2, dnrm2, scnrm2, scnrm2, dznrm2

cublasStatus_t  cublasSrot(cublasHandle_t handle, int n,
                           float           *x, int incx,
                           float           *y, int incy,
                           const float  *c, const float           *s)
cublasStatus_t  cublasDrot(cublasHandle_t handle, int n,
                           double          *x, int incx,
                           double          *y, int incy,
                           const double *c, const double          *s)
cublasStatus_t  cublasCrot(cublasHandle_t handle, int n,
                           cuComplex       *x, int incx,
                           cuComplex       *y, int incy,
                           const float  *c, const cuComplex       *s)
cublasStatus_t cublasCsrot(cublasHandle_t handle, int n,
                           cuComplex       *x, int incx,
                           cuComplex       *y, int incy,
                           const float  *c, const float           *s)
cublasStatus_t  cublasZrot(cublasHandle_t handle, int n,
                           cuDoubleComplex *x, int incx,
                           cuDoubleComplex *y, int incy,
                           const double *c, const cuDoubleComplex *s)
cublasStatus_t cublasZdrot(cublasHandle_t handle, int n,
                           cuDoubleComplex *x, int incx,
                           cuDoubleComplex *y, int incy,
                           const double *c, const double          *s)

This function applies Givens rotation matrix (i.e., rotation in the x,y plane counter-clockwise by angle defined by cos(alpha)=c, sin(alpha)=s):

$G=\left(\begin{array}{cc}\hfill c\hfill & \hfill s\hfill \\ \hfill -s\hfill & \hfill c\hfill \end{array}\right)$

to vectors x and y.

Hence, the result is $x\left[k\right]=c\times x\left[k\right]+s\times y\left[j\right]$ and $y\left[j\right]=-s\times x\left[k\right]+c\times y\left[j\right]$ where $k=1+\left(i-1\right)*\text{ incx}$ and $j=1+\left(i-1\right)*\text{ incy}$ . Notice that the last two equations reflect 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

srot, drot, crot, csrot, zrot, zdrot

cublasStatus_t cublasSrotg(cublasHandle_t handle,
                           float           *a, float           *b,
                           float  *c, float           *s)
cublasStatus_t cublasDrotg(cublasHandle_t handle,
                           double          *a, double          *b,
                           double *c, double          *s)
cublasStatus_t cublasCrotg(cublasHandle_t handle,
                           cuComplex       *a, cuComplex       *b,
                           float  *c, cuComplex       *s)
cublasStatus_t cublasZrotg(cublasHandle_t handle,
                           cuDoubleComplex *a, cuDoubleComplex *b,
                           double *c, cuDoubleComplex *s)

This function constructs the Givens rotation matrix

$G=\left(\begin{array}{cc}\hfill c\hfill & \hfill s\hfill \\ \hfill -s\hfill & \hfill c\hfill \end{array}\right)$

that zeros out the second entry of a $2\times 1$ vector ${\left(a,b\right)}^T$ .

Then, for real numbers we can write

$\left(\begin{array}{cc}\hfill c\hfill & \hfill s\hfill \\ \hfill -s\hfill & \hfill c\hfill \end{array}\right)\left(\begin{array}{c}\hfill a\hfill \\ \hfill b\hfill \end{array}\right)=\left(\begin{array}{c}\hfill r\hfill \\ \hfill 0\hfill \end{array}\right)$

where $c^2+s^2=1$ and $r=a^2+b^2$ . The parameters $a$ and $b$ are overwritten with $r$ and $z$ , respectively. The value of $z$ is such that $c$ and $s$ may be recovered using the following rules:

$\left(c,s\right)=\left\{\begin{array}{cc}\left(\sqrt{1-z^2},z\right)\hfill & \text{ if }\left|z\right|<1\hfill \\ \left(0.0,1.0\right)\hfill & \text{ if }\left|z\right|=1\hfill \\ \left(1∕z,\sqrt{1-z^2}\right)\hfill & \text{ if }\left|z\right|>1\hfill \end{array}\right.$

For complex numbers we can write

$\left(\begin{array}{cc}\hfill c\hfill & \hfill s\hfill \\ \hfill -\bar{s}\hfill & \hfill c\hfill \end{array}\right)\left(\begin{array}{c}\hfill a\hfill \\ \hfill b\hfill \end{array}\right)=\left(\begin{array}{c}\hfill r\hfill \\ \hfill 0\hfill \end{array}\right)$

where $c^2+\left(\bar{s}\times s\right)=1$ and $r=\frac{a}{\left|a\right|}\times \parallel {\left(a,b\right)}^T{\parallel }_2$ with $\parallel {\left(a,b\right)}^T{\parallel }_2=\sqrt{|a{|}^2+|b{|}^2}$ for $a\ne 0$ and $r=b$ for $a=0$ . Finally, the parameter $a$ is overwritten with $r$ on exit.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

srotg, drotg, crotg, zrotg

cublasStatus_t cublasSrotm(cublasHandle_t handle, int n, float  *x, int incx,
                           float  *y, int incy, const float*  param)
cublasStatus_t cublasDrotm(cublasHandle_t handle, int n, double *x, int incx,
                           double *y, int incy, const double* param)

This function applies the modified Givens transformation

$H=\left(\begin{array}{cc}\hfill h_{11}\hfill & \hfill h_{12}\hfill \\ \hfill h_{21}\hfill & \hfill h_{22}\hfill \end{array}\right)$

to vectors x and y.

Hence, the result is $x\left[k\right]=h_{11}\times x\left[k\right]+h_{12}\times y\left[j\right]$ and $y\left[j\right]=h_{21}\times x\left[k\right]+h_{22}\times y\left[j\right]$ where $k=1+\left(i-1\right)*\text{ incx}$ and $j=1+\left(i-1\right)*\text{ incy}$ . Notice that the last two equations reflect 1-based indexing used for compatibility with Fortran.

The elements , , and of matrix $H$ are stored in param[1], param[2], param[3] and param[4], respectively. The flag=param[0] defines the following predefined values for the matrix $H$ entries

Notice that the values -1.0, 0.0 and 1.0 implied by the flag are not stored in param.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

srotm, drotm

cublasStatus_t cublasSrotmg(cublasHandle_t handle, float  *d1, float  *d2,
                            float  *x1, const float  *y1, float  *param)
cublasStatus_t cublasDrotmg(cublasHandle_t handle, double *d1, double *d2,
                            double *x1, const double *y1, double *param)

This function constructs the modified Givens transformation

$H=\left(\begin{array}{cc}\hfill h_{11}\hfill & \hfill h_{12}\hfill \\ \hfill h_{21}\hfill & \hfill h_{22}\hfill \end{array}\right)$

that zeros out the second entry of a $2\times 1$ vector ${\left(\sqrt{d1}*x1,\sqrt{d2}*y1\right)}^T$ .

The flag=param[0] defines the following predefined values for the matrix $H$ entries

Notice that the values -1.0, 0.0 and 1.0 implied by the flag are not stored in param.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

srotmg, drotmg

cublasStatus_t  cublasSscal(cublasHandle_t handle, int n,
                            const float           *alpha,
                            float           *x, int incx)
cublasStatus_t  cublasDscal(cublasHandle_t handle, int n,
                            const double          *alpha,
                            double          *x, int incx)
cublasStatus_t  cublasCscal(cublasHandle_t handle, int n,
                            const cuComplex       *alpha,
                            cuComplex       *x, int incx)
cublasStatus_t cublasCsscal(cublasHandle_t handle, int n,
                            const float           *alpha,
                            cuComplex       *x, int incx)
cublasStatus_t  cublasZscal(cublasHandle_t handle, int n,
                            const cuDoubleComplex *alpha,
                            cuDoubleComplex *x, int incx)
cublasStatus_t cublasZdscal(cublasHandle_t handle, int n,
                            const double          *alpha,
                            cuDoubleComplex *x, int incx)

This function scales the vector x by the scalar $\alpha$ and overwrites it with the result. Hence, the performed operation is $x\left[j\right]=\alpha \times x\left[j\right]$ for $i=1,\dots ,n$ and $j=1+\left(i-1\right)*\text{ incx}$ . Notice that the last two equations reflect 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sscal, dscal, csscal, cscal, zdscal, zscal

cublasStatus_t cublasSswap(cublasHandle_t handle, int n, float           *x,
                           int incx, float           *y, int incy)
cublasStatus_t cublasDswap(cublasHandle_t handle, int n, double          *x,
                           int incx, double          *y, int incy)
cublasStatus_t cublasCswap(cublasHandle_t handle, int n, cuComplex       *x,
                           int incx, cuComplex       *y, int incy)
cublasStatus_t cublasZswap(cublasHandle_t handle, int n, cuDoubleComplex *x,
                           int incx, cuDoubleComplex *y, int incy)

This function interchanges the elements of vector x and y. Hence, the performed operation is $y\left[j\right]\iff x\left[k\right]$ for $i=1,\dots ,n$ , $k=1+\left(i-1\right)*\text{ incx}$ and $j=1+\left(i-1\right)*\text{ incy}$ . Notice that the last two equations reflect 1-based indexing used for compatibility with Fortran.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sswap, dswap, cswap, zswap

cublasStatus_t cublasSgbmv(cublasHandle_t handle, cublasOperation_t trans,
                           int m, int n, int kl, int ku,
                           const float           *alpha,
                           const float           *A, int lda,
                           const float           *x, int incx,
                           const float           *beta,
                           float           *y, int incy)
cublasStatus_t cublasDgbmv(cublasHandle_t handle, cublasOperation_t trans,
                           int m, int n, int kl, int ku,
                           const double          *alpha,
                           const double          *A, int lda,
                           const double          *x, int incx,
                           const double          *beta,
                           double          *y, int incy)
cublasStatus_t cublasCgbmv(cublasHandle_t handle, cublasOperation_t trans,
                           int m, int n, int kl, int ku,
                           const cuComplex       *alpha,
                           const cuComplex       *A, int lda,
                           const cuComplex       *x, int incx,
                           const cuComplex       *beta,
                           cuComplex       *y, int incy)
cublasStatus_t cublasZgbmv(cublasHandle_t handle, cublasOperation_t trans,
                           int m, int n, int kl, int ku,
                           const cuDoubleComplex *alpha,
                           const cuDoubleComplex *A, int lda,
                           const cuDoubleComplex *x, int incx,
                           const cuDoubleComplex *beta,
                           cuDoubleComplex *y, int incy)

This function performs the banded matrix-vector multiplication

$y=\alpha \text{ op}\left(A\right)x+\beta y$

where $A$ is a banded matrix with $kl$ subdiagonals and $ku$ superdiagonals, $x$ and $y$ are vectors, and $\alpha$ and $\beta$ are scalars. Also, for matrix $A$

$\text{ op}\left(A\right)=\left\{\begin{array}{cc}A\hfill & \text{ if transa == CUBLAS\_OP\_N}\hfill \\ A^T\hfill & \text{ if transa == CUBLAS\_OP\_T}\hfill \\ A^H\hfill & \text{ if transa == CUBLAS\_OP\_H}\hfill \end{array}\right.$

The banded matrix $A$ is stored column by column, with the main diagonal stored in row $ku+1$ (starting in first position), the first superdiagonal stored in row $ku$ (starting in second position), the first subdiagonal stored in row $ku+2$ (starting in first position), etc. So that in general, the element $A\left(i,j\right)$ is stored in the memory location A(ku+1+i-j,j) for $j=1,\dots ,n$ and $i\in \left[max\left(1,j-ku\right),min\left(m,j+kl\right)\right]$ . Also, the elements in the array $A$ that do not conceptually correspond to the elements in the banded matrix (the top left $ku\times ku$ and bottom right $kl\times kl$ triangles) are not referenced.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sgbmv, dgbmv, cgbmv, zgbmv

cublasStatus_t cublasSgemv(cublasHandle_t handle, cublasOperation_t trans,
                           int m, int n,
                           const float           *alpha,
                           const float           *A, int lda,
                           const float           *x, int incx,
                           const float           *beta,
                           float           *y, int incy)
cublasStatus_t cublasDgemv(cublasHandle_t handle, cublasOperation_t trans,
                           int m, int n,
                           const double          *alpha,
                           const double          *A, int lda,
                           const double          *x, int incx,
                           const double          *beta,
                           double          *y, int incy)
cublasStatus_t cublasCgemv(cublasHandle_t handle, cublasOperation_t trans,
                           int m, int n,
                           const cuComplex       *alpha,
                           const cuComplex       *A, int lda,
                           const cuComplex       *x, int incx,
                           const cuComplex       *beta,
                           cuComplex       *y, int incy)
cublasStatus_t cublasZgemv(cublasHandle_t handle, cublasOperation_t trans,
                           int m, int n,
                           const cuDoubleComplex *alpha,
                           const cuDoubleComplex *A, int lda,
                           const cuDoubleComplex *x, int incx,
                           const cuDoubleComplex *beta,
                           cuDoubleComplex *y, int incy)

This function performs the matrix-vector multiplication

$\mathbf{\text{y}}=\alpha \text{op}(A)\mathbf{\text{x}}+\beta \mathbf{\text{y}}$

where $A$ is a $m\times n$ matrix stored in column-major format, $\mathbf{x}$ and $\mathbf{y}$ are vectors, and $\alpha$ and $\beta$ are scalars. Also, for matrix $A$

$\text{ op}\left(A\right)=\left\{\begin{array}{cc}A\hfill & \text{ if transa == CUBLAS\_OP\_N}\hfill \\ A^T\hfill & \text{ if transa == CUBLAS\_OP\_T}\hfill \\ A^H\hfill & \text{ if transa == CUBLAS\_OP\_H}\hfill \end{array}\right.$

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sgemv, dgemv, cgemv, zgemv

cublasStatus_t  cublasSger(cublasHandle_t handle, int m, int n,
                           const float           *alpha,
                           const float           *x, int incx,
                           const float           *y, int incy,
                           float           *A, int lda)
cublasStatus_t  cublasDger(cublasHandle_t handle, int m, int n,
                           const double          *alpha,
                           const double          *x, int incx,
                           const double          *y, int incy,
                           double          *A, int lda)
cublasStatus_t cublasCgeru(cublasHandle_t handle, int m, int n,
                           const cuComplex       *alpha,
                           const cuComplex       *x, int incx,
                           const cuComplex       *y, int incy,
                           cuComplex       *A, int lda)
cublasStatus_t cublasCgerc(cublasHandle_t handle, int m, int n,
                           const cuComplex       *alpha,
                           const cuComplex       *x, int incx,
                           const cuComplex       *y, int incy,
                           cuComplex       *A, int lda)
cublasStatus_t cublasZgeru(cublasHandle_t handle, int m, int n,
                           const cuDoubleComplex *alpha,
                           const cuDoubleComplex *x, int incx,
                           const cuDoubleComplex *y, int incy,
                           cuDoubleComplex *A, int lda)
cublasStatus_t cublasZgerc(cublasHandle_t handle, int m, int n,
                           const cuDoubleComplex *alpha,
                           const cuDoubleComplex *x, int incx,
                           const cuDoubleComplex *y, int incy,
                           cuDoubleComplex *A, int lda)

This function performs the rank-1 update

$A=\left\{\begin{array}{cc}\alpha {xy}^T+A\hfill & \text{if ger(),geru() is called}\hfill \\ \alpha {xy}^H+A\hfill & \text{if gerc() is called}\hfill \end{array}\right.$

where $A$ is a $m\times n$ matrix stored in column-major format, $\mathbf{x}$ and $\mathbf{y}$ are vectors, and $\alpha$ is a scalar.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sger, dger, cgeru, cgerc, zgeru, zgerc

cublasStatus_t cublasSsbmv(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, int k, const float  *alpha,
                           const float  *A, int lda,
                           const float  *x, int incx,
                           const float  *beta, float *y, int incy)
cublasStatus_t cublasDsbmv(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, int k, const double *alpha,
                           const double *A, int lda,
                           const double *x, int incx,
                           const double *beta, double *y, int incy)

This function performs the symmetric banded matrix-vector multiplication

$\mathbf{\text{y}}=\alpha A\mathbf{\text{x}}+\beta \mathbf{\text{y}}$

where $A$ is a $n\times n$ symmetric banded matrix with $k$ subdiagonals and superdiagonals, $\mathbf{x}$ and $\mathbf{y}$ are vectors, and $\alpha$ and $\beta$ are scalars.

If uplo == CUBLAS_FILL_MODE_LOWER then the symmetric banded matrix $A$ is stored column by column, with the main diagonal of the matrix stored in row 1, the first subdiagonal in row 2 (starting at first position), the second subdiagonal in row 3 (starting at first position), etc. So that in general, the element $A(i,j)$ is stored in the memory location A(1+i-j,j) for $j=1,\dots ,n$ and $i\in [j,min(m,j+k)]$ . Also, the elements in the array A that do not conceptually correspond to the elements in the banded matrix (the bottom right $k\times k$ triangle) are not referenced.

If uplo == CUBLAS_FILL_MODE_UPPER then the symmetric banded matrix $A$ is stored column by column, with the main diagonal of the matrix stored in row k+1, the first superdiagonal in row k (starting at second position), the second superdiagonal in row k-1 (starting at third position), etc. So that in general, the element $A(i,j)$ is stored in the memory location A(1+k+i-j,j) for $j=1,\dots ,n$ and $i\in [max(1,j-k),j]$ . Also, the elements in the array A that do not conceptually correspond to the elements in the banded matrix (the top left $k\times k$ triangle) are not referenced.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

ssbmv, dsbmv

cublasStatus_t cublasSspmv(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, const float  *alpha, const float  *AP,
                           const float  *x, int incx, const float  *beta,
                           float  *y, int incy)
cublasStatus_t cublasDspmv(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, const double *alpha, const double *AP,
                           const double *x, int incx, const double *beta,
                           double *y, int incy)

This function performs the symmetric packed matrix-vector multiplication

$\mathbf{\text{y}}=\alpha A\mathbf{\text{x}}+\beta \mathbf{\text{y}}$

where $A$ is a $n\times n$ symmetric matrix stored in packed format, $\mathbf{x}$ and $\mathbf{y}$ are vectors, and $\alpha$ and $\beta$ are scalars.

If uplo == CUBLAS_FILL_MODE_LOWER then the elements in the lower triangular part of the symmetric matrix $A$ are packed together column by column without gaps, so that the element $A(i,j)$ is stored in the memory location AP[i+((2*n-j+1)*j)/2] for $j=1,\dots ,n$ and $i\ge j$ . Consequently, the packed format requires only $\frac{n(n+1)}{2}$ elements for storage.

If uplo == CUBLAS_FILL_MODE_UPPER then the elements in the upper triangular part of the symmetric matrix $A$ are packed together column by column without gaps, so that the element $A(i,j)$ is stored in the memory location AP[i+(j*(j+1))/2] for $j=1,\dots ,n$ and $i\le j$ . Consequently, the packed format requires only $\frac{n(n+1)}{2}$ elements for storage.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sspmv, dspmv

cublasStatus_t cublasSspr(cublasHandle_t handle, cublasFillMode_t uplo,
                          int n, const float  *alpha,
                          const float  *x, int incx, float  *AP)
cublasStatus_t cublasDspr(cublasHandle_t handle, cublasFillMode_t uplo,
                          int n, const double *alpha,
                          const double *x, int incx, double *AP)

This function performs the packed symmetric rank-1 update

$A=\alpha \mathbf{\text{x}}{\mathbf{\text{x}}}^T+A$

where $A$ is a $n\times n$ symmetric matrix stored in packed format, $\mathbf{x}$ is a vector, and $\alpha$ is a scalar.

If uplo == CUBLAS_FILL_MODE_LOWER then the elements in the lower triangular part of the symmetric matrix $A$ are packed together column by column without gaps, so that the element $A(i,j)$ is stored in the memory location AP[i+((2*n-j+1)*j)/2] for $j=1,\dots ,n$ and $i\ge j$ . Consequently, the packed format requires only $\frac{n(n+1)}{2}$ elements for storage.

If uplo == CUBLAS_FILL_MODE_UPPER then the elements in the upper triangular part of the symmetric matrix $A$ are packed together column by column without gaps, so that the element $A(i,j)$ is stored in the memory location AP[i+(j*(j+1))/2] for $j=1,\dots ,n$ and $i\le j$ . Consequently, the packed format requires only $\frac{n(n+1)}{2}$ elements for storage.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sspr, dspr

cublasStatus_t cublasSspr2(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, const float  *alpha,
                           const float  *x, int incx,
                           const float  *y, int incy, float  *AP)
cublasStatus_t cublasDspr2(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, const double *alpha,
                           const double *x, int incx,
                           const double *y, int incy, double *AP)

This function performs the packed symmetric rank-2 update

$A=\alpha \left(\mathbf{\text{x}}{\mathbf{\text{y}}}^T+\mathbf{\text{y}}{\mathbf{\text{x}}}^T\right)+A$

where $A$ is a $n\times n$ symmetric matrix stored in packed format, $\mathbf{x}$ is a vector, and $\alpha$ is a scalar.

If uplo == CUBLAS_FILL_MODE_LOWER then the elements in the lower triangular part of the symmetric matrix $A$ are packed together column by column without gaps, so that the element $A(i,j)$ is stored in the memory location AP[i+((2*n-j+1)*j)/2] for $j=1,\dots ,n$ and $i\ge j$ . Consequently, the packed format requires only $\frac{n(n+1)}{2}$ elements for storage.

If uplo == CUBLAS_FILL_MODE_UPPER then the elements in the upper triangular part of the symmetric matrix $A$ are packed together column by column without gaps, so that the element $A(i,j)$ is stored in the memory location AP[i+(j*(j+1))/2] for $j=1,\dots ,n$ and $i\le j$ . Consequently, the packed format requires only $\frac{n(n+1)}{2}$ elements for storage.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

sspr2, dspr2

cublasStatus_t cublasSsymv(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, const float           *alpha,
                           const float           *A, int lda,
                           const float           *x, int incx, const float           *beta,
                           float           *y, int incy)
cublasStatus_t cublasDsymv(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, const double          *alpha,
                           const double          *A, int lda,
                           const double          *x, int incx, const double          *beta,
                           double          *y, int incy)
cublasStatus_t cublasCsymv(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, const cuComplex       *alpha, /* host or device pointer */
                           const cuComplex       *A, int lda,
                           const cuComplex       *x, int incx, const cuComplex       *beta,
                           cuComplex       *y, int incy)
cublasStatus_t cublasZsymv(cublasHandle_t handle, cublasFillMode_t uplo,
                           int n, const cuDoubleComplex *alpha,
                           const cuDoubleComplex *A, int lda,
                           const cuDoubleComplex *x, int incx, const cuDoubleComplex *beta,
                           cuDoubleComplex *y, int incy)

This function performs the symmetric matrix-vector multiplication.

where $A$ is a $n\times n$ symmetric matrix stored in lower or upper mode, $\mathbf{x}$ and $\mathbf{y}$ are vectors, and $\alpha$ and $\beta$ are scalars.

This function has an alternate faster implementation using atomics that can be enabled with cublasSetAtomicsMode().

Please see the section on the function cublasSetAtomicsMode() for more details about the usage of atomics.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

ssymv, dsymv

cublasStatus_t cublasSsyr(cublasHandle_t handle, cublasFillMode_t uplo,
                          int n, const float           *alpha,
                          const float           *x, int incx, float           *A, int lda)
cublasStatus_t cublasDsyr(cublasHandle_t handle, cublasFillMode_t uplo,
                          int n, const double          *alpha,
                          const double          *x, int incx, double          *A, int lda)
cublasStatus_t cublasCsyr(cublasHandle_t handle, cublasFillMode_t uplo,
                          int n, const cuComplex       *alpha,
                          const cuComplex       *x, int incx, cuComplex       *A, int lda)
cublasStatus_t cublasZsyr(cublasHandle_t handle, cublasFillMode_t uplo,
                          int n, const cuDoubleComplex *alpha,
                          const cuDoubleComplex *x, int incx, cuDoubleComplex *A, int lda)

This function performs the symmetric rank-1 update

$A=\alpha \mathbf{\text{x}}{\mathbf{\text{x}}}^T+A$

where $A$ is a $n\times n$ symmetric matrix stored in column-major format, $\mathbf{x}$ is a vector, and $\alpha$ is a scalar.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

ssyr, dsyr

cublasStatus_t cublasSsyr2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
                           const float           *alpha, const float           *x, int incx,
                           const float           *y, int incy, float           *A, int lda
cublasStatus_t cublasDsyr2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
                           const double          *alpha, const double          *x, int incx,
                           const double          *y, int incy, double          *A, int lda
cublasStatus_t cublasCsyr2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
                           const cuComplex       *alpha, const cuComplex       *x, int incx,
                           const cuComplex       *y, int incy, cuComplex       *A, int lda
cublasStatus_t cublasZsyr2(cublasHandle_t handle, cublasFillMode_t uplo, int n,
                           const cuDoubleComplex *alpha, const cuDoubleComplex *x, int incx,
                           const cuDoubleComplex *y, int incy, cuDoubleComplex *A, int lda

This function performs the symmetric rank-2 update

$A=\alpha \left(\mathbf{\text{x}}{\mathbf{\text{y}}}^T+\mathbf{\text{y}}{\mathbf{\text{x}}}^T\right)+A$

where $A$ is a $n\times n$ symmetric matrix stored in column-major format, $\mathbf{x}$ and $\mathbf{y}$ are vectors, and $\alpha$ is a scalar.

The possible error values returned by this function and their meanings are listed below.

For references please refer to:

ssyr2, dsyr2

cublasStatus_t cublasStbmv(cublasHandle_t handle, cublasFillMode_t uplo,
                           cublasOperation_t trans, cublasDiagType_t diag,
                           int n, int k, const float           *A, int lda,
                           float           *x, int incx)
cublasStatus_t cublasDtbmv(cublasHandle_t handle, cublasFillMode_t uplo,
                           cublasOperation_t trans, cublasDiagType_t diag,
                           int n, int k, const double          *A, int lda,
                           double          *x, int incx)
cublasStatus_t cublasCtbmv(cublasHandle_t handle, cublasFillMode_t uplo,
                           cublasOperation_t trans, cublasDiagType_t diag,
                           int n, int k, const cuComplex       *A, int lda,
                           cuComplex       *x, int incx)
cublasStatus_t cublasZtbmv(cublasHandle_t handle, cublasFillMode_t uplo,
                           cublasOperation_t trans, cublasDiagType_t diag,
                           int n, int k, const cuDoubleComplex *A, int lda,
                           cuDoubleComplex *x, int incx)

This function performs the triangular banded matrix-vector multiplication