BLAS Reference

Overview

The vecLib framework contains nine C header files (not counting vecLib.h which merely includes the others).

This document describes the functions declared in the header files cblas.h and vblas.h, which contain the interfaces for Apple’s implementation of the Basic Linear Algebra Subprograms (BLAS) API.

Functions by Task

General Functions

• ATLU_DestroyThreadMemory
• SetBLASParamErrorProc
• cblas_errprn
• cblas_xerbla
• cblas_icamax
• cblas_idamax
• cblas_isamax
• cblas_izamax

CATLAS and CBLAS Vector Functions

• catlas_caxpby
• catlas_cset
• catlas_daxpby
• catlas_dset
• catlas_saxpby
• catlas_sset
• catlas_zaxpby
• catlas_zset
• cblas_sdot
• cblas_sdsdot
• cblas_cdotc_sub
• cblas_cdotu_sub
• cblas_ddot
• cblas_dsdot
• cblas_zdotc_sub
• cblas_zdotu_sub

Single-Precision Float Matrix Functions

• cblas_sasum
• cblas_saxpy
• cblas_scopy
• cblas_sgbmv
• cblas_sgemm
• cblas_sgemv
• cblas_sger
• cblas_snrm2
• cblas_srot
• cblas_srotg
• cblas_srotm
• cblas_srotmg
• cblas_ssbmv
• cblas_sscal
• cblas_sspmv
• cblas_sspr
• cblas_sspr2
• cblas_sswap
• cblas_ssymm
• cblas_ssymv
• cblas_ssyr
• cblas_ssyr2
• cblas_ssyr2k
• cblas_ssyrk
• cblas_stbmv
• cblas_stbsv
• cblas_stpmv
• cblas_stpsv
• cblas_strmm
• cblas_strmv
• cblas_strsm
• cblas_strsv

Single-Precision Complex Matrix Functions

• cblas_caxpy
• cblas_ccopy
• cblas_cgbmv
• cblas_cgemm
• cblas_cgemv
• cblas_cgerc
• cblas_cgeru
• cblas_chbmv
• cblas_chemm
• cblas_chemv
• cblas_cher
• cblas_cher2
• cblas_cher2k
• cblas_cherk
• cblas_chpmv
• cblas_chpr
• cblas_chpr2
• cblas_crotg
• cblas_cscal
• cblas_csrot
• cblas_csscal
• cblas_cswap
• cblas_csymm
• cblas_csyr2k
• cblas_csyrk
• cblas_ctbmv
• cblas_ctbsv
• cblas_ctpmv
• cblas_ctpsv
• cblas_ctrmm
• cblas_ctrmv
• cblas_ctrsm
• cblas_ctrsv
• cblas_scasum
• cblas_scnrm2

Double-Precision Float Matrix Functions

• cblas_dasum
• cblas_daxpy
• cblas_dcopy
• cblas_dgbmv
• cblas_dgemm
• cblas_dgemv
• cblas_dger
• cblas_dnrm2
• cblas_drot
• cblas_drotg
• cblas_drotm
• cblas_drotmg
• cblas_dsbmv
• cblas_dscal
• cblas_dspmv
• cblas_dspr
• cblas_dspr2
• cblas_dswap
• cblas_dsymm
• cblas_dsymv
• cblas_dsyr
• cblas_dsyr2
• cblas_dsyr2k
• cblas_dsyrk
• cblas_dtbmv
• cblas_dtbsv
• cblas_dtpmv
• cblas_dtpsv
• cblas_dtrmm
• cblas_dtrmv
• cblas_dtrsm
• cblas_dtrsv

Double-Precision Complex Matrix Functions

• cblas_dzasum
• cblas_dznrm2
• cblas_zaxpy
• cblas_zcopy
• cblas_zdrot
• cblas_zdscal
• cblas_zgbmv
• cblas_zgemm
• cblas_zgemv
• cblas_zgerc
• cblas_zgeru
• cblas_zhbmv
• cblas_zhemm
• cblas_zhemv
• cblas_zher
• cblas_zher2
• cblas_zher2k
• cblas_zherk
• cblas_zhpmv
• cblas_zhpr
• cblas_zhpr2
• cblas_zrotg
• cblas_zscal
• cblas_zswap
• cblas_zsymm
• cblas_zsyr2k
• cblas_zsyrk
• cblas_ztbmv
• cblas_ztbsv
• cblas_ztpmv
• cblas_ztpsv
• cblas_ztrmm
• cblas_ztrmv
• cblas_ztrsm
• cblas_ztrsv

Functions

ATLU_DestroyThreadMemory

Releases per-thread storage associated with BLAS.

void ATLU_DestroyThreadMemory (
   void
);

catlas_caxpby

Computes the product of two vectors, scaling each one separately (single-precision complex).

void catlas_caxpby (
   const int N,
   const void *alpha,
   const void *X,
   const int incX,
   const void *beta,
   void *Y,
   const int incY
);

catlas_cset

Modifies a vector (single-precision complex) in place, setting each element to a given value.

void catlas_cset (
   const int N,
   const void *alpha,
   void *X,
   const int incX
);

catlas_daxpby

Computes the product of two vectors, scaling each one separately (double-precision).

void catlas_daxpby (
   const int N,
   const double alpha,
   const double *X,
   const int incX,
   const double beta,
   double *Y,
   const int incY
);

catlas_dset

Modifies a vector (double-precision) in place, setting each element to a given value.

void catlas_dset (
   const int N,
   const double alpha,
   double *X,
   const int incX
);

catlas_saxpby

Scales the two input vectors separately, then adds the input vectors (single-precision).

void catlas_saxpby (
   const int N,
   const float alpha,
   const float *X,
   const int incX,
   const float beta,
   float *Y,
   const int incY
);

Y = (alpha * X) + (beta * Y)

catlas_sset

Modifies a vector (single-precision) in place, setting each element to a given value.

void catlas_sset (
   const int N,
   const float alpha,
   float *X,
   const int incX
);

catlas_zaxpby

Computes the product of two vectors, scaling each one separately (double-precision complex).

void catlas_zaxpby (
   const int N,
   const void *alpha,
   const void *X,
   const int incX,
   const void *beta,
   void *Y,
   const int incY
);

catlas_zset

Modifies a vector (double-precision complex) in place, setting each element to a given value.

void catlas_zset (
   const int N,
   const void *alpha,
   void *X,
   const int incX
);

cblas_caxpy

Computes a constant times a vector plus a vector (single-precision complex).

void cblas_caxpy (
   const int N,
   const void *alpha,
   const void *X,
   const int incX,
   void *Y,
   const int incY
);

cblas_ccopy

Copies a vector to another vector (single-precision complex).

void cblas_ccopy (
   const int N,
   const void *X,
   const int incX,
   void *Y,
   const int incY
);

cblas_cdotc_sub

Calculates the dot product of the complex conjugate of a single-precision complex vector with a second single-precision complex vector.

void cblas_cdotc_sub (
   const int N,
   const void *X,
   const int incX,
   const void *Y,
   const int incY,
   void *dotc
);

cblas_cdotu_sub

Computes the dot product of two single-precision complex vectors.

void cblas_cdotu_sub (
   const int N,
   const void *X,
   const int incX,
   const void *Y,
   const int incY,
   void *dotu
);

cblas_cgbmv

Scales a general band matrix, then multiplies by a vector, then adds a vector (single-precision complex).

void cblas_cgbmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_TRANSPOSE TransA,
   const int M,
   const int N,
   const int KL,
   const int KU,
   const void *alpha,
   const void *A,
   const int lda,
   const void *X,
   const int incX,
   const void *beta,
   void *Y,
   const int incY
);

cblas_cgemm

Multiplies two matrices (single-precision complex).

void cblas_cgemm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_TRANSPOSE TransB,
   const int M,
   const int N,
   const int K,
   const void *alpha,
   const void *A,
   const int lda,
   const void *B,
   const int ldb,
   const void *beta,
   void *C,
   const int ldc
);

cblas_cgemv

Multiplies a matrix by a vector (single-precision complex).

void cblas_cgemv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_TRANSPOSE TransA,
   const int M,
   const int N,
   const void *alpha,
   const void *A,
   const int lda,
   const void *X,
   const int incX,
   const void *beta,
   void *Y,
   const int incY
);

cblas_cgerc

Multiplies vector X by the conjugate transform of vector Y, then adds matrix A (single-precision complex).

void cblas_cgerc (
   const enum CBLAS_ORDER Order,
   const int M,
   const int N,
   const void *alpha,
   const void *X,
   const int incX,
   const void *Y,
   const int incY,
   void *A,
   const int lda
);

cblas_cgeru

Multiplies vector X by the transform of vector Y, then adds matrix A (single-precision complex).

void cblas_cgeru (
   const enum CBLAS_ORDER Order,
   const int M,
   const int N,
   const void *alpha,
   const void *X,
   const int incX,
   const void *Y,
   const int incY,
   void *A,
   const int lda
);

cblas_chbmv

Scales a Hermitian band matrix, then multiplies by a vector, then adds a vector (single-precision complex).

void cblas_chbmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const int K,
   const void *alpha,
   const void *A,
   const int lda,
   const void *X,
   const int incX,
   const void *beta,
   void *Y,
   const int incY
);

cblas_chemm

Multiplies two Hermitian matrices (single-precision complex), then adds a third (with scaling).

void cblas_chemm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_SIDE Side,
   const enum CBLAS_UPLO Uplo,
   const int M,
   const int N,
   const void *alpha,
   const void *A,
   const int lda,
   const void *B,
   const int ldb,
   const void *beta,
   void *C,
   const int ldc
);

cblas_chemv

Scales and multiplies a Hermitian matrix by a vector, then adds a second (scaled) vector.

void cblas_chemv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const void *alpha,
   const void *A,
   const int lda,
   const void *X,
   const int incX,
   const void *beta,
   void *Y,
   const int incY
);

cblas_cher

Hermitian rank 1 update: adds the product of a scaling factor, vector X, and the conjugate transpose of X to matrix A.

void cblas_cher (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const float alpha,
   const void *X,
   const int incX,
   void *A,
   const int lda
);

cblas_cher2

Hermitian rank 2 update: adds the product of a scaling factor, vector X, and the conjugate transpose of vector Y to the product of the conjugate of the scaling factor, vector Y, and the conjugate transpose of vector X, and adds the result to matrix A.

void cblas_cher2 (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const void *alpha,
   const void *X,
   const int incX,
   const void *Y,
   const int incY,
   void *A,
   const int lda
);

cblas_cher2k

Performs a rank-2k update of a complex Hermitian matrix (single-precision complex).

void cblas_cher2k (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE Trans,
   const int N,
   const int K,
   const void *alpha,
   const void *A,
   const int lda,
   const void *B,
   const int ldb,
   const float beta,
   void *C,
   const int ldc
);

cblas_cherk

Rank-k update—multiplies a Hermitian matrix by its transpose and adds a second matrix (single precision).

void cblas_cherk (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE Trans,
   const int N,
   const int K,
   const float alpha,
   const void *A,
   const int lda,
   const float beta,
   void *C,
   const int ldc
);

cblas_chpmv

Scales a packed hermitian matrix, multiplies it by a vector, and adds a scaled vector.

void cblas_chpmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const void *alpha,
   const void *Ap,
   const void *X,
   const int incX,
   const void *beta,
   void *Y,
   const int incY
);

cblas_chpr

Scales and multiplies a vector times its conjugate transpose, then adds a matrix.

void cblas_chpr (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const float alpha,
   const void *X,
   const int incX,
   void *A
);

cblas_chpr2

Multiplies a vector times the conjugate transpose of a second vector and vice-versa, sums the results, and adds a matrix.

void cblas_chpr2 (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const void *alpha,
   const void *X,
   const int incX,
   const void *Y,
   const int incY,
   void *Ap
);

cblas_crotg

Constructs a complex Givens rotation.

void cblas_crotg (
   void *a,
   void *b,
   void *c,
   void *s
);

cblas_cscal

Multiplies each element of a vector by a constant (single-precision complex).

void cblas_cscal (
   const int N,
   const void *alpha,
   void *X,
   const int incX
);

cblas_csrot

Applies a Givens rotation matrix to a pair of complex vectors.

void cblas_csrot (
   const int N,
   void *X,
   const int incX,
   void *Y,
   const int incY,
   const float c,
   const float s
);

cblas_csscal

Multiplies each element of a vector by a constant (single-precision complex).

void cblas_csscal (
   const int N,
   const float alpha,
   void *X,
   const int incX
);

cblas_cswap

Exchanges the elements of two vectors (single-precision complex).

void cblas_cswap (
   const int N,
   void *X,
   const int incX,
   void *Y,
   const int incY
);

cblas_csymm

Multiplies a matrix by a symmetric matrix (single-precision complex).

void cblas_csymm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_SIDE Side,
   const enum CBLAS_UPLO Uplo,
   const int M,
   const int N,
   const void *alpha,
   const void *A,
   const int lda,
   const void *B,
   const int ldb,
   const void *beta,
   void *C,
   const int ldc
);

cblas_csyr2k

Performs a rank-2k update of a symmetric matrix (single-precision complex).

void cblas_csyr2k (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE Trans,
   const int N,
   const int K,
   const void *alpha,
   const void *A,
   const int lda,
   const void *B,
   const int ldb,
   const void *beta,
   void *C,
   const int ldc
);

cblas_csyrk

Rank-k update—multiplies a symmetric matrix by its transpose and adds a second matrix (single-precision complex).

void cblas_csyrk (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE Trans,
   const int N,
   const int K,
   const void *alpha,
   const void *A,
   const int lda,
   const void *beta,
   void *C,
   const int ldc
);

cblas_ctbmv

Scales a triangular band matrix, then multiplies by a vector (single-precision compex).

void cblas_ctbmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const int K,
   const void *A,
   const int lda,
   void *X,
   const int incX
);

cblas_ctbsv

Solves a triangular banded system of equations.

void cblas_ctbsv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const int K,
   const void *A,
   const int lda,
   void *X,
   const int incX
);

cblas_ctpmv

Multiplies a triangular matrix by a vector, then adds a vector (single-precision complex).

void cblas_ctpmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const void *Ap,
   void *X,
   const int incX
);

cblas_ctpsv

Solves a packed triangular system of equations.

void cblas_ctpsv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const void *Ap,
   void *X,
   const int incX
);

cblas_ctrmm

Scales a triangular matrix and multiplies it by a matrix.

void cblas_ctrmm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_SIDE Side,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int M,
   const int N,
   const void *alpha,
   const void *A,
   const int lda,
   void *B,
   const int ldb
);

cblas_ctrmv

Multiplies a triangular matrix by a vector.

void cblas_ctrmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const void *A,
   const int lda,
   void *X,
   const int incX
);

cblas_ctrsm

Solves a triangular system of equations with multiple values for the right side.

void cblas_ctrsm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_SIDE Side,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int M,
   const int N,
   const void *alpha,
   const void *A,
   const int lda,
   void *B,
   const int ldb
);

cblas_ctrsv

Solves a triangular system of equations with a single value for the right side.

void cblas_ctrsv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const void *A,
   const int lda,
   void *X,
   const int incX
);

cblas_dasum

Computes the sum of the absolute values of elements in a vector (double-precision).

double cblas_dasum (
   const int N,
   const double *X,
   const int incX
);

cblas_daxpy

Computes a constant times a vector plus a vector (double-precision).

void cblas_daxpy (
   const int N,
   const double alpha,
   const double *X,
   const int incX,
   double *Y,
   const int incY
);

cblas_dcopy

Copies a vector to another vector (double-precision).

void cblas_dcopy (
   const int N,
   const double *X,
   const int incX,
   double *Y,
   const int incY
);

cblas_ddot

Computes the dot product of two vectors (double-precision).

double cblas_ddot (
   const int N,
   const double *X,
   const int incX,
   const double *Y,
   const int incY
);

cblas_dgbmv

Scales a general band matrix, then multiplies by a vector, then adds a vector (double precision).

void cblas_dgbmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_TRANSPOSE TransA,
   const int M,
   const int N,
   const int KL,
   const int KU,
   const double alpha,
   const double *A,
   const int lda,
   const double *X,
   const int incX,
   const double beta,
   double *Y,
   const int incY
);

cblas_dgemm

Multiplies two matrices (double-precision).

void cblas_dgemm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_TRANSPOSE TransB,
   const int M,
   const int N,
   const int K,
   const double alpha,
   const double *A,
   const int lda,
   const double *B,
   const int ldb,
   const double beta,
   double *C,
   const int ldc
);

cblas_dgemv

Multiplies a matrix by a vector (double precision).

void cblas_dgemv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_TRANSPOSE TransA,
   const int M,
   const int N,
   const double alpha,
   const double *A,
   const int lda,
   const double *X,
   const int incX,
   const double beta,
   double *Y,
   const int incY
);

cblas_dger

Multiplies vector X by the transform of vector Y, then adds matrix A (double precison).

void cblas_dger (
   const enum CBLAS_ORDER Order,
   const int M,
   const int N,
   const double alpha,
   const double *X,
   const int incX,
   const double *Y,
   const int incY,
   double *A,
   const int lda
);

cblas_dnrm2

Computes the L2 norm (Euclidian length) of a vector (double precision).

double cblas_dnrm2 (
   const int N,
   const double *X,
   const int incX
);

cblas_drot

Applies a Givens rotation matrix to a pair of vectors.

void cblas_drot (
   const int N,
   double *X,
   const int incX,
   double *Y,
   const int incY,
   const double c,
   const double s
);

cblas_drotg

Constructs a Givens rotation matrix.

void cblas_drotg (
   double *a,
   double *b,
   double *c,
   double *s
);

cblas_drotm

Applies a modified Givens transformation (single precision).

void cblas_drotm (
   const int N,
   double *X,
   const int incX,
   double *Y,
   const int incY,
   const double *P
);

cblas_drotmg

Generates a modified Givens rotation matrix.

void cblas_drotmg (
   double *d1,
   double *d2,
   double *b1,
   const double b2,
   double *P
);

cblas_dsbmv

Scales a symmetric band matrix, then multiplies by a vector, then adds a vector (double precision).

void cblas_dsbmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const int K,
   const double alpha,
   const double *A,
   const int lda,
   const double *X,
   const int incX,
   const double beta,
   double *Y,
   const int incY
);

cblas_dscal

Multiplies each element of a vector by a constant (double-precision).

void cblas_dscal (
   const int N,
   const double alpha,
   double *X,
   const int incX
);

cblas_dsdot

Computes the double-precision dot product of a pair of single-precision vectors.

double cblas_dsdot (
   const int N,
   const float *X,
   const int incX,
   const float *Y,
   const int incY
);

cblas_dspmv

Scales a packed symmetric matrix, then multiplies by a vector, then scales and adds another vector (double precision).

void cblas_dspmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const double alpha,
   const double *Ap,
   const double *X,
   const int incX,
   const double beta,
   double *Y,
   const int incY
);

cblas_dspr

Rank one update: adds a packed symmetric matrix to the product of a scaling factor, a vector, and its transpose (double precision).

void cblas_dspr (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const double alpha,
   const double *X,
   const int incX,
   double *Ap
);

cblas_dspr2

Rank two update of a packed symmetric matrix using two vectors (single precision).

void cblas_dspr2 (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const double alpha,
   const double *X,
   const int incX,
   const double *Y,
   const int incY,
   double *A
);

cblas_dswap

Exchanges the elements of two vectors (double precision).

void cblas_dswap (
   const int N,
   double *X,
   const int incX,
   double *Y,
   const int incY
);

cblas_dsymm

Multiplies a matrix by a symmetric matrix (double-precision).

void cblas_dsymm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_SIDE Side,
   const enum CBLAS_UPLO Uplo,
   const int M,
   const int N,
   const double alpha,
   const double *A,
   const int lda,
   const double *B,
   const int ldb,
   const double beta,
   double *C,
   const int ldc
);

cblas_dsymv

Scales a symmetric matrix, multiplies by a vector, then scales and adds another vector (single precision).

void cblas_dsymv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const double alpha,
   const double *A,
   const int lda,
   const double *X,
   const int incX,
   const double beta,
   double *Y,
   const int incY
);

cblas_dsyr

Rank one update: adds a symmetric matrix to the product of a scaling factor, a vector, and its transpose (double precision).

void cblas_dsyr (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const double alpha,
   const double *X,
   const int incX,
   double *A,
   const int lda
);

cblas_dsyr2

Rank two update of a symmetric matrix using two vectors (single precision).

void cblas_dsyr2 (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const double alpha,
   const double *X,
   const int incX,
   const double *Y,
   const int incY,
   double *A,
   const int lda
);

cblas_dsyr2k

Performs a rank-2k update of a symmetric matrix (double precision).

void cblas_dsyr2k (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE Trans,
   const int N,
   const int K,
   const double alpha,
   const double *A,
   const int lda,
   const double *B,
   const int ldb,
   const double beta,
   double *C,
   const int ldc
);

cblas_dsyrk

Rank-k update—multiplies a symmetric matrix by its transpose and adds a second matrix (double precision).

void cblas_dsyrk (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE Trans,
   const int N,
   const int K,
   const double alpha,
   const double *A,
   const int lda,
   const double beta,
   double *C,
   const int ldc
);

cblas_dtbmv

Scales a triangular band matrix, then multiplies by a vector (double precision).

void cblas_dtbmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const int K,
   const double *A,
   const int lda,
   double *X,
   const int incX
);

cblas_dtbsv

Solves a triangular banded system of equations.

void cblas_dtbsv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const int K,
   const double *A,
   const int lda,
   double *X,
   const int incX
);

cblas_dtpmv

Multiplies a triangular matrix by a vector, then adds a vector (double precision).

void cblas_dtpmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const double *Ap,
   double *X,
   const int incX
);

cblas_dtpsv

Solves a packed triangular system of equations.

void cblas_dtpsv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const double *Ap,
   double *X,
   const int incX
);

cblas_dtrmm

Scales a triangular matrix and multiplies it by a matrix.

void cblas_dtrmm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_SIDE Side,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int M,
   const int N,
   const double alpha,
   const double *A,
   const int lda,
   double *B,
   const int ldb
);

cblas_dtrmv

Multiplies a triangular matrix by a vector.

void cblas_dtrmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const double *A,
   const int lda,
   double *X,
   const int incX
);

cblas_dtrsm

Solves a triangular system of equations with multiple values for the right side.

void cblas_dtrsm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_SIDE Side,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int M,
   const int N,
   const double alpha,
   const double *A,
   const int lda,
   double *B,
   const int ldb
);

cblas_dtrsv

Solves a triangular system of equations with a single value for the right side.

void cblas_dtrsv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_DIAG Diag,
   const int N,
   const double *A,
   const int lda,
   double *X,
   const int incX
);

cblas_dzasum

Computes the sum of the absolute values of real and imaginary parts of elements in a vector (single-precision complex).

double cblas_dzasum (
   const int N,
   const void *X,
   const int incX
);

cblas_dznrm2

Computes the unitary norm of a vector (double-precision complex).

double cblas_dznrm2 (
   const int N,
   const void *X,
   const int incX
);

cblas_errprn

Prints an error message.

int cblas_errprn (
   int ierr,
   int info,
   char *form,
   ...
);

cblas_icamax

Returns the index of the element with the largest absolute value in a vector (single-precision complex).

int cblas_icamax (
   const int N,
   const void *X,
   const int incX
);

cblas_idamax

Returns the index of the element with the largest absolute value in a vector (double-precision).

int cblas_idamax (
   const int N,
   const double *X,
   const int incX
);

cblas_isamax

Returns the index of the element with the largest absolute value in a vector (single-precision).

int cblas_isamax (
   const int N,
   const float *X,
   const int incX
);

cblas_izamax

Returns the index of the element with the largest absolute value in a vector (double-precision complex).

int cblas_izamax (
   const int N,
   const void *X,
   const int incX
);

cblas_sasum

Computes the sum of the absolute values of elements in a vector (single-precision).

float cblas_sasum (
   const int N,
   const float *X,
   const int incX
);

cblas_saxpy

Computes a constant times a vector plus a vector (single-precision).

void cblas_saxpy (
   const int N,
   const float alpha,
   const float *X,
   const int incX,
   float *Y,
   const int incY
);

cblas_scasum

Computes the sum of the absolute values of real and imaginary parts of elements in a vector (single-precision complex).

float cblas_scasum (
   const int N,
   const void *X,
   const int incX
);

cblas_scnrm2

Computes the unitary norm of a vector (single-precision complex).

float cblas_scnrm2 (
   const int N,
   const void *X,
   const int incX
);

cblas_scopy

Copies a vector to another vector (single-precision).

void cblas_scopy (
   const int N,
   const float *X,
   const int incX,
   float *Y,
   const int incY
);

cblas_sdot

Computes the dot product of two vectors (single-precision).

float cblas_sdot (
   const int N,
   const float *X,
   const int incX,
   const float *Y,
   const int incY
);

cblas_sdsdot

Computes the dot product of two single-precision vectors plus an initial single-precision value.

float cblas_sdsdot (
   const int N,
   const float alpha,
   const float *X,
   const int incX,
   const float *Y,
   const int incY
);

cblas_sgbmv

Scales a general band matrix, then multiplies by a vector, then adds a vector (single precision).

void cblas_sgbmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_TRANSPOSE TransA,
   const int M,
   const int N,
   const int KL,
   const int KU,
   const float alpha,
   const float *A,
   const int lda,
   const float *X,
   const int incX,
   const float beta,
   float *Y,
   const int incY
);

cblas_sgemm

Multiplies two matrices (single-precision).

void cblas_sgemm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_TRANSPOSE TransA,
   const enum CBLAS_TRANSPOSE TransB,
   const int M,
   const int N,
   const int K,
   const float alpha,
   const float *A,
   const int lda,
   const float *B,
   const int ldb,
   const float beta,
   float *C,
   const int ldc
);

cblas_sgemv

Multiplies a matrix by a vector (single precision).

void cblas_sgemv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_TRANSPOSE TransA,
   const int M,
   const int N,
   const float alpha,
   const float *A,
   const int lda,
   const float *X,
   const int incX,
   const float beta,
   float *Y,
   const int incY
);

cblas_sger

Multiplies vector X by the transform of vector Y, then adds matrix A (single precison).

void cblas_sger (
   const enum CBLAS_ORDER Order,
   const int M,
   const int N,
   const float alpha,
   const float *X,
   const int incX,
   const float *Y,
   const int incY,
   float *A,
   const int lda
);

cblas_snrm2

Computes the L2 norm (Euclidian length) of a vector (single precision).

float cblas_snrm2 (
   const int N,
   const float *X,
   const int incX
);

cblas_srot

Applies a Givens rotation matrix to a pair of vectors.

void cblas_srot (
   const int N,
   float *X,
   const int incX,
   float *Y,
   const int incY,
   const float c,
   const float s
);

cblas_srotg

Constructs a Givens rotation matrix.

void cblas_srotg (
   float *a,
   float *b,
   float *c,
   float *s
);

cblas_srotm

Applies a modified Givens transformation (single precision).

void cblas_srotm (
   const int N,
   float *X,
   const int incX,
   float *Y,
   const int incY,
   const float *P
);

cblas_srotmg

Generates a modified Givens rotation matrix.

void cblas_srotmg (
   float *d1,
   float *d2,
   float *b1,
   const float b2,
   float *P
);

cblas_ssbmv

Scales a symmetric band matrix, then multiplies by a vector, then adds a vector (single-precision).

void cblas_ssbmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const int K,
   const float alpha,
   const float *A,
   const int lda,
   const float *X,
   const int incX,
   const float beta,
   float *Y,
   const int incY
);

cblas_sscal

Multiplies each element of a vector by a constant (single-precision).

void cblas_sscal (
   const int N,
   const float alpha,
   float *X,
   const int incX
);

cblas_sspmv

Scales a packed symmetric matrix, then multiplies by a vector, then scales and adds another vector (single precision).

void cblas_sspmv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const float alpha,
   const float *Ap,
   const float *X,
   const int incX,
   const float beta,
   float *Y,
   const int incY
);

cblas_sspr

Rank one update: adds a packed symmetric matrix to the product of a scaling factor, a vector, and its transpose (single precision).

void cblas_sspr (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const float alpha,
   const float *X,
   const int incX,
   float *Ap
);

cblas_sspr2

Rank two update of a packed symmetric matrix using two vectors (single precision).

void cblas_sspr2 (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const float alpha,
   const float *X,
   const int incX,
   const float *Y,
   const int incY,
   float *A
);

cblas_sswap

Exchanges the elements of two vectors (single precision).

void cblas_sswap (
   const int N,
   float *X,
   const int incX,
   float *Y,
   const int incY
);

cblas_ssymm

Multiplies a matrix by a symmetric matrix (single-precision).

void cblas_ssymm (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_SIDE Side,
   const enum CBLAS_UPLO Uplo,
   const int M,
   const int N,
   const float alpha,
   const float *A,
   const int lda,
   const float *B,
   const int ldb,
   const float beta,
   float *C,
   const int ldc
);

cblas_ssymv

Scales a symmetric matrix, multiplies by a vector, then scales and adds another vector (single precision).

void cblas_ssymv (
   const enum CBLAS_ORDER Order,
   const enum CBLAS_UPLO Uplo,
   const int N,
   const float alpha,
   const float *A,
   const int lda,
   const float *X,
   const int incX,
   const float beta,
   float *Y,
   const int incY
);