sblas
API
Generated with
sblas/org.ekrich.blas/org.ekrich.blas.unsafe/blas

blas

org.ekrich.blas.unsafe.blas
object blas

Scala Native extern C interface to CBLAS Version 3.8.0

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Self type
blas.type

Members list

Type members

Types

type CblasIndex = CInt

Value members

Concrete methods

def cblas_caxpy(N: CInt, alpha: Ptr[CFloatComplex], X: Ptr[CFloatComplex], incX: CInt, Y: Ptr[CFloatComplex], incY: CInt): Unit

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

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

Attributes

def cblas_ccopy(N: CInt, X: Ptr[CFloatComplex], incX: CInt, Y: Ptr[CFloatComplex], incY: CInt): Unit

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

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

Attributes

def cblas_cdotc_sub(N: CInt, X: Ptr[CFloatComplex], incX: CInt, Y: Ptr[CFloatComplex], incY: CInt, dotc: Ptr[CFloatComplex]): Unit

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

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

Value parameters

dotc

The result vector. Computes conjg(X) * Y.

Attributes

def cblas_cdotu_sub(N: CInt, X: Ptr[CFloatComplex], incX: CInt, Y: Ptr[CFloatComplex], incY: CInt, dotu: Ptr[CFloatComplex]): Unit

Dot product of two single-precision complex vectors.

Dot product of two single-precision complex vectors.

Value parameters

dotu

The result vector.

Attributes

def cblas_cgbmv(order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, M: CInt, N: CInt, KL: CInt, KU: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, X: Ptr[CFloatComplex], incX: CInt, beta: Ptr[CFloatComplex], Y: Ptr[CFloatComplex], incY: CInt): Unit
def cblas_cgemm(Order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, TransB: CBLAS_TRANSPOSE, M: CInt, N: CInt, K: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, B: Ptr[CFloatComplex], ldb: CInt, beta: Ptr[CFloatComplex], C: Ptr[CFloatComplex], ldc: CInt): Unit
def cblas_cgemv(order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, M: CInt, N: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, X: Ptr[CFloatComplex], incX: CInt, beta: Ptr[CFloatComplex], Y: Ptr[CFloatComplex], incY: CInt): Unit
def cblas_cgerc(order: CBLAS_ORDER, M: CInt, N: CInt, alpha: Ptr[CFloatComplex], X: Ptr[CFloatComplex], incX: CInt, Y: Ptr[CFloatComplex], incY: CInt, A: Ptr[CFloatComplex], lda: CInt): Unit
def cblas_cgeru(order: CBLAS_ORDER, M: CInt, N: CInt, alpha: Ptr[CFloatComplex], X: Ptr[CFloatComplex], incX: CInt, Y: Ptr[CFloatComplex], incY: CInt, A: Ptr[CFloatComplex], lda: CInt): Unit
def cblas_chbmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, K: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, X: Ptr[CFloatComplex], incX: CInt, beta: Ptr[CFloatComplex], Y: Ptr[CFloatComplex], incY: CInt): Unit
def cblas_chemm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, M: CInt, N: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, B: Ptr[CFloatComplex], ldb: CInt, beta: Ptr[CFloatComplex], C: Ptr[CFloatComplex], ldc: CInt): Unit
def cblas_chemv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, X: Ptr[CFloatComplex], incX: CInt, beta: Ptr[CFloatComplex], Y: Ptr[CFloatComplex], incY: CInt): Unit
def cblas_cher(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CFloat, X: Ptr[CFloatComplex], incX: CInt, A: Ptr[CFloatComplex], lda: CInt): Unit
def cblas_cher2(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: Ptr[CFloatComplex], X: Ptr[CFloatComplex], incX: CInt, Y: Ptr[CFloatComplex], incY: CInt, A: Ptr[CFloatComplex], lda: CInt): Unit
def cblas_cher2k(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, B: Ptr[CFloatComplex], ldb: CInt, beta: CFloat, C: Ptr[CFloatComplex], ldc: CInt): Unit
def cblas_cherk(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: CFloat, A: Ptr[CFloatComplex], lda: CInt, beta: CFloat, C: Ptr[CFloatComplex], ldc: CInt): Unit
def cblas_chpmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: Ptr[CFloatComplex], Ap: Ptr[CFloatComplex], X: Ptr[CFloatComplex], incX: CInt, beta: Ptr[CFloatComplex], Y: Ptr[CFloatComplex], incY: CInt): Unit
def cblas_chpr(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CFloat, X: Ptr[CFloatComplex], incX: CInt, A: Ptr[CFloatComplex]): Unit
def cblas_chpr2(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: Ptr[CFloatComplex], X: Ptr[CFloatComplex], incX: CInt, Y: Ptr[CFloatComplex], incY: CInt, Ap: Ptr[CFloatComplex]): Unit
def cblas_cscal(N: CInt, alpha: Ptr[CFloatComplex], X: Ptr[CFloatComplex], incX: CInt): Unit

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

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

Attributes

def cblas_csscal(N: CInt, alpha: CFloat, X: Ptr[CFloatComplex], incX: CInt): Unit

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

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

Attributes

def cblas_cswap(N: CInt, X: Ptr[CFloatComplex], incX: CInt, Y: Ptr[CFloatComplex], incY: CInt): Unit

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

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

Attributes

def cblas_csymm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, M: CInt, N: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, B: Ptr[CFloatComplex], ldb: CInt, beta: Ptr[CFloatComplex], C: Ptr[CFloatComplex], ldc: CInt): Unit
def cblas_csyr2k(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, B: Ptr[CFloatComplex], ldb: CInt, beta: Ptr[CFloatComplex], C: Ptr[CFloatComplex], ldc: CInt): Unit
def cblas_csyrk(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, beta: Ptr[CFloatComplex], C: Ptr[CFloatComplex], ldc: CInt): Unit
def cblas_ctbmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, K: CInt, A: Ptr[CFloatComplex], lda: CInt, X: Ptr[CFloatComplex], incX: CInt): Unit
def cblas_ctbsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, K: CInt, A: Ptr[CFloatComplex], lda: CInt, X: Ptr[CFloatComplex], incX: CInt): Unit
def cblas_ctpmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, Ap: Ptr[CFloatComplex], X: Ptr[CFloatComplex], incX: CInt): Unit
def cblas_ctpsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, Ap: Ptr[CFloatComplex], X: Ptr[CFloatComplex], incX: CInt): Unit
def cblas_ctrmm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, M: CInt, N: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, B: Ptr[CFloatComplex], ldb: CInt): Unit
def cblas_ctrmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, A: Ptr[CFloatComplex], lda: CInt, X: Ptr[CFloatComplex], incX: CInt): Unit
def cblas_ctrsm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, M: CInt, N: CInt, alpha: Ptr[CFloatComplex], A: Ptr[CFloatComplex], lda: CInt, B: Ptr[CFloatComplex], ldb: CInt): Unit
def cblas_ctrsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, A: Ptr[CFloatComplex], lda: CInt, X: Ptr[CFloatComplex], incX: CInt): Unit
def cblas_dasum(N: CInt, X: Ptr[CDouble], incX: CInt): CDouble

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

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

Attributes

def cblas_daxpy(N: CInt, alpha: CDouble, X: Ptr[CDouble], incX: CInt, Y: Ptr[CDouble], incY: CInt): Unit

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

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

Attributes

def cblas_dcopy(N: CInt, X: Ptr[CDouble], incX: CInt, Y: Ptr[CDouble], incY: CInt): Unit

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

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

Attributes

def cblas_ddot(N: CInt, X: Ptr[CDouble], incX: CInt, Y: Ptr[CDouble], incY: CInt): CDouble

Dot product of two vectors (double-precision).

Dot product of two vectors (double-precision).

Attributes

def cblas_dgbmv(order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, M: CInt, N: CInt, KL: CInt, KU: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, X: Ptr[CDouble], incX: CInt, beta: CDouble, Y: Ptr[CDouble], incY: CInt): Unit
def cblas_dgemm(Order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, TransB: CBLAS_TRANSPOSE, M: CInt, N: CInt, K: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, B: Ptr[CDouble], ldb: CInt, beta: CDouble, C: Ptr[CDouble], ldc: CInt): Unit
def cblas_dgemv(order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, M: CInt, N: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, X: Ptr[CDouble], incX: CInt, beta: CDouble, Y: Ptr[CDouble], incY: CInt): Unit
def cblas_dger(order: CBLAS_ORDER, M: CInt, N: CInt, alpha: CDouble, X: Ptr[CDouble], incX: CInt, Y: Ptr[CDouble], incY: CInt, A: Ptr[CDouble], lda: CInt): Unit
def cblas_dnrm2(N: CInt, X: Ptr[CDouble], incX: CInt): CDouble

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

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

Attributes

def cblas_drot(N: CInt, X: Ptr[CDouble], incX: CInt, Y: Ptr[CDouble], incY: CInt, c: CDouble, s: CDouble): Unit

Applies a Givens rotation matrix to a pair of vectors.

Applies a Givens rotation matrix to a pair of vectors.

Attributes

def cblas_drotg(a: Ptr[CDouble], b: Ptr[CDouble], c: Ptr[CDouble], s: Ptr[CDouble]): Unit

Constructs a Givens rotation matrix.

Constructs a Givens rotation matrix.

Attributes

def cblas_drotm(N: CInt, X: Ptr[CDouble], incX: CInt, Y: Ptr[CDouble], incY: CInt, P: Ptr[CDouble]): Unit

Applies a modified Givens transformation (single precision).

Applies a modified Givens transformation (single precision).

Attributes

def cblas_drotmg(d1: Ptr[CDouble], d2: Ptr[CDouble], b1: Ptr[CDouble], b2: CDouble, P: Ptr[CDouble]): Unit

Generates a modified Givens rotation matrix.

Generates a modified Givens rotation matrix.

Attributes

def cblas_dsbmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, K: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, X: Ptr[CDouble], incX: CInt, beta: CDouble, Y: Ptr[CDouble], incY: CInt): Unit
def cblas_dscal(N: CInt, alpha: CDouble, X: Ptr[CDouble], incX: CInt): Unit

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

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

Attributes

def cblas_dsdot(N: CInt, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt): CDouble

Double-precision dot product of a pair of single-precision vectors.

Double-precision dot product of a pair of single-precision vectors.

Attributes

def cblas_dspmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CDouble, Ap: Ptr[CDouble], X: Ptr[CDouble], incX: CInt, beta: CDouble, Y: Ptr[CDouble], incY: CInt): Unit
def cblas_dspr(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CDouble, X: Ptr[CDouble], incX: CInt, Ap: Ptr[CDouble]): Unit
def cblas_dspr2(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CDouble, X: Ptr[CDouble], incX: CInt, Y: Ptr[CDouble], incY: CInt, A: Ptr[CDouble]): Unit
def cblas_dswap(N: CInt, X: Ptr[CDouble], incX: CInt, Y: Ptr[CDouble], incY: CInt): Unit

Exchanges the elements of two vectors (double precision).

Exchanges the elements of two vectors (double precision).

Attributes

def cblas_dsymm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, M: CInt, N: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, B: Ptr[CDouble], ldb: CInt, beta: CDouble, C: Ptr[CDouble], ldc: CInt): Unit
def cblas_dsymv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, X: Ptr[CDouble], incX: CInt, beta: CDouble, Y: Ptr[CDouble], incY: CInt): Unit
def cblas_dsyr(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CDouble, X: Ptr[CDouble], incX: CInt, A: Ptr[CDouble], lda: CInt): Unit
def cblas_dsyr2(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CDouble, X: Ptr[CDouble], incX: CInt, Y: Ptr[CDouble], incY: CInt, A: Ptr[CDouble], lda: CInt): Unit
def cblas_dsyr2k(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, B: Ptr[CDouble], ldb: CInt, beta: CDouble, C: Ptr[CDouble], ldc: CInt): Unit
def cblas_dsyrk(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, beta: CDouble, C: Ptr[CDouble], ldc: CInt): Unit
def cblas_dtbmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, K: CInt, A: Ptr[CDouble], lda: CInt, X: Ptr[CDouble], incX: CInt): Unit
def cblas_dtbsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, K: CInt, A: Ptr[CDouble], lda: CInt, X: Ptr[CDouble], incX: CInt): Unit
def cblas_dtpmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, Ap: Ptr[CDouble], X: Ptr[CDouble], incX: CInt): Unit
def cblas_dtpsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, Ap: Ptr[CDouble], X: Ptr[CDouble], incX: CInt): Unit
def cblas_dtrmm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, M: CInt, N: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, B: Ptr[CDouble], ldb: CInt): Unit
def cblas_dtrmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, A: Ptr[CDouble], lda: CInt, X: Ptr[CDouble], incX: CInt): Unit
def cblas_dtrsm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, M: CInt, N: CInt, alpha: CDouble, A: Ptr[CDouble], lda: CInt, B: Ptr[CDouble], ldb: CInt): Unit
def cblas_dtrsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, A: Ptr[CDouble], lda: CInt, X: Ptr[CDouble], incX: CInt): Unit
def cblas_dzasum(N: CInt, X: Ptr[CDoubleComplex], incX: CInt): CDouble

Sum of the absolute values of real and imaginary parts of elements in a vector (double-precision complex).

Sum of the absolute values of real and imaginary parts of elements in a vector (double-precision complex).

Attributes

def cblas_dznrm2(N: CInt, X: Ptr[CDoubleComplex], incX: CInt): CDouble

Unitary norm of a vector (double-precision complex).

Unitary norm of a vector (double-precision complex).

Attributes

def cblas_icamax(N: CInt, X: Ptr[CFloatComplex], incX: CInt): CblasIndex

Attributes

Returns

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

def cblas_idamax(N: CInt, X: Ptr[CDouble], incX: CInt): CblasIndex

Attributes

Returns

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

def cblas_isamax(N: CInt, X: Ptr[CFloat], incX: CInt): CblasIndex

Attributes

Returns

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

def cblas_izamax(N: CInt, X: Ptr[CDoubleComplex], incX: CInt): CblasIndex

Attributes

Returns

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

def cblas_sasum(N: CInt, X: Ptr[CFloat], incX: CInt): CFloat

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

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

Attributes

def cblas_saxpy(N: CInt, alpha: CFloat, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt): Unit

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

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

Value parameters

alpha

The initial value to add to the dot product.

Attributes

def cblas_scasum(N: CInt, X: Ptr[CFloatComplex], incX: CInt): CFloat

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

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

Attributes

def cblas_scnrm2(N: CInt, X: Ptr[CFloatComplex], incX: CInt): CFloat

Unitary norm of a vector (single-precision complex).

Unitary norm of a vector (single-precision complex).

Attributes

def cblas_scopy(N: CInt, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt): Unit

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

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

Attributes

def cblas_sdot(N: CInt, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt): CFloat

Dot product of two vectors (single-precision).

Dot product of two vectors (single-precision).

Attributes

def cblas_sdsdot(N: CInt, alpha: CFloat, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt): CFloat

Dot product of two single-precision vectors plus an initial single-precision value.

Dot product of two single-precision vectors plus an initial single-precision value.

Value parameters

N

The number of elements in the vectors.

X

Vector X.

Y

Vector Y.

alpha

The initial value to add to the dot product.

incX

Stride within X. For example, if incX is 7, every 7th element is used.

incY

Stride within Y. For example, if incY is 7, every 7th element is used.

Attributes

Returns

See description above.

def cblas_sgbmv(order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, M: CInt, N: CInt, KL: CInt, KU: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, X: Ptr[CFloat], incX: CInt, beta: CFloat, Y: Ptr[CFloat], incY: CInt): Unit
def cblas_sgemm(Order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, TransB: CBLAS_TRANSPOSE, M: CInt, N: CInt, K: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, B: Ptr[CFloat], ldb: CInt, beta: CFloat, C: Ptr[CFloat], ldc: CInt): Unit

Multiplies two matrices (single-precision)

Multiplies two matrices (single-precision)

Value parameters

A

Matrix A

B

Matrix B

C

Matrix C

K

Number of columns in matrix A; number of rows in matrix B

M

Number of rows in matrices A and C

N

Number of columns in matrices B and C

Order

Specifies row-major (C) or column-major (Fortran) data ordering

TransA

Specifies whether to transpose matrix A

TransB

Specifies whether to transpose matrix B

alpha

Scaling factor for the product of matrices A and B

beta

Scaling factor for matrix C

lda

The size of the first dimension of matrix A; if you are passing a matrix A[m][n], the value should be m

ldb

The size of the first dimension of matrix B; if you are passing a matrix B[m][n], the value should be m

ldc

The size of the first dimension of matrix C; if you are passing a matrix C[m][n], the value should be m

Attributes

def cblas_sgemv(order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, M: CInt, N: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, X: Ptr[CFloat], incX: CInt, beta: CFloat, Y: Ptr[CFloat], incY: CInt): Unit
def cblas_sger(order: CBLAS_ORDER, M: CInt, N: CInt, alpha: CFloat, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt, A: Ptr[CFloat], lda: CInt): Unit
def cblas_snrm2(N: CInt, X: Ptr[CFloat], incX: CInt): CFloat

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

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

Attributes

def cblas_srot(N: CInt, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt, c: CFloat, s: CFloat): Unit

Applies a Givens rotation matrix to a pair of vectors.

Applies a Givens rotation matrix to a pair of vectors.

Attributes

def cblas_srotg(a: Ptr[CFloat], b: Ptr[CFloat], c: Ptr[CFloat], s: Ptr[CFloat]): Unit

Constructs a Givens rotation matrix.

Constructs a Givens rotation matrix.

Value parameters

a

Single-precision value a. Overwritten on return with result r.

b

Single-precision value b. Overwritten on return with result z (zero).

c

Unused on entry. Overwritten on return with the value cos(θ).

s

Unused on entry. Overwritten on return with the value sin(θ).

Attributes

def cblas_srotm(N: CInt, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt, P: Ptr[CFloat]): Unit

Applies a modified Givens transformation (single precision).

Applies a modified Givens transformation (single precision).

Attributes

def cblas_srotmg(d1: Ptr[CFloat], d2: Ptr[CFloat], b1: Ptr[CFloat], b2: CFloat, P: Ptr[CFloat]): Unit

Generates a modified Givens rotation matrix.

Generates a modified Givens rotation matrix.

Value parameters

P 
 A 5-element vector:
  P[0] Flag value that defines the form of matrix H.
 -2.0: matrix H contains the identity matrix.
 -1.0: matrix H is identical to matrix SH (defined by the remaining values in the vector).
  0.0: H[1,2] and H[2,1] are obtained from matrix SH. The remaining values are both 1.0.
  1.0: H[1,1] and H[2,2] are obtained from matrix SH. H[1,2] is 1.0. H[2,1] is -1.0.
  P[1] Contains SH[1,1].
  P[2] Contains SH[2,1].
  P[3] Contains SH[1,2].
  P[4] Contains SH[2,2].
b1

Scaling factor B1.

b2

Scaling factor B2.

d1

Scaling factor D1.

d2

Scaling factor D2.

Attributes

def cblas_ssbmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, K: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, X: Ptr[CFloat], incX: CInt, beta: CFloat, Y: Ptr[CFloat], incY: CInt): Unit
def cblas_sscal(N: CInt, alpha: CFloat, X: Ptr[CFloat], incX: CInt): Unit

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

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

Attributes

def cblas_sspmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CFloat, Ap: Ptr[CFloat], X: Ptr[CFloat], incX: CInt, beta: CFloat, Y: Ptr[CFloat], incY: CInt): Unit
def cblas_sspr(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CFloat, X: Ptr[CFloat], incX: CInt, Ap: Ptr[CFloat]): Unit
def cblas_sspr2(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CFloat, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt, A: Ptr[CFloat]): Unit
def cblas_sswap(N: CInt, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt): Unit

Exchanges the elements of two vectors (single precision).

Exchanges the elements of two vectors (single precision).

Parameters for the following functions:

Value parameters

N

The number of elements in the vectors.

X

Vector X.

Y

Vector Y.

incX

Stride within X. For example, if incX is 7, every 7th element is used.

incY

Stride within Y. For example, if incY is 7, every 7th element is used.

Attributes

Returns

See description above.

def cblas_ssymm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, M: CInt, N: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, B: Ptr[CFloat], ldb: CInt, beta: CFloat, C: Ptr[CFloat], ldc: CInt): Unit
def cblas_ssymv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, X: Ptr[CFloat], incX: CInt, beta: CFloat, Y: Ptr[CFloat], incY: CInt): Unit
def cblas_ssyr(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CFloat, X: Ptr[CFloat], incX: CInt, A: Ptr[CFloat], lda: CInt): Unit
def cblas_ssyr2(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CFloat, X: Ptr[CFloat], incX: CInt, Y: Ptr[CFloat], incY: CInt, A: Ptr[CFloat], lda: CInt): Unit
def cblas_ssyr2k(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, B: Ptr[CFloat], ldb: CInt, beta: CFloat, C: Ptr[CFloat], ldc: CInt): Unit
def cblas_ssyrk(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, beta: CFloat, C: Ptr[CFloat], ldc: CInt): Unit
def cblas_stbmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, K: CInt, A: Ptr[CFloat], lda: CInt, X: Ptr[CFloat], incX: CInt): Unit
def cblas_stbsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, K: CInt, A: Ptr[CFloat], lda: CInt, X: Ptr[CFloat], incX: CInt): Unit
def cblas_stpmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, Ap: Ptr[CFloat], X: Ptr[CFloat], incX: CInt): Unit
def cblas_stpsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, Ap: Ptr[CFloat], X: Ptr[CFloat], incX: CInt): Unit
def cblas_strmm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, M: CInt, N: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, B: Ptr[CFloat], ldb: CInt): Unit
def cblas_strmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, A: Ptr[CFloat], lda: CInt, X: Ptr[CFloat], incX: CInt): Unit
def cblas_strsm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, M: CInt, N: CInt, alpha: CFloat, A: Ptr[CFloat], lda: CInt, B: Ptr[CFloat], ldb: CInt): Unit
def cblas_strsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, A: Ptr[CFloat], lda: CInt, X: Ptr[CFloat], incX: CInt): Unit
def cblas_xerbla(p: CInt, rout: CString, form: CString, varArgs: CVarArg*): Unit

The error handler for the LAPACK routines. It is called by an LAPACK routine if an input parameter has an invalid value. A message is printed and execution stops.

The error handler for the LAPACK routines. It is called by an LAPACK routine if an input parameter has an invalid value. A message is printed and execution stops.

Attributes

def cblas_zaxpy(N: CInt, alpha: Ptr[CDoubleComplex], X: Ptr[CDoubleComplex], incX: CInt, Y: Ptr[CDoubleComplex], incY: CInt): Unit

A constant times a vector plus a vector (double-precision complex).

A constant times a vector plus a vector (double-precision complex).

Attributes

def cblas_zcopy(N: CInt, X: Ptr[CDoubleComplex], incX: CInt, Y: Ptr[CDoubleComplex], incY: CInt): Unit

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

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

Attributes

def cblas_zdotc_sub(N: CInt, X: Ptr[CDoubleComplex], incX: CInt, Y: Ptr[CDoubleComplex], incY: CInt, dotc: Ptr[CDoubleComplex]): Unit

Dot product of the complex conjugate of a double-precision complex vector with a second double-precision complex vector.

Dot product of the complex conjugate of a double-precision complex vector with a second double-precision complex vector.

Value parameters

dotc

The result vector. Computes conjg(X) * Y.

Attributes

def cblas_zdotu_sub(N: CInt, X: Ptr[CDoubleComplex], incX: CInt, Y: Ptr[CDoubleComplex], incY: CInt, dotu: Ptr[CDoubleComplex]): Unit

Dot product of two double-precision complex vectors.

Dot product of two double-precision complex vectors.

Value parameters

dotu

The result vector.

Attributes

def cblas_zdscal(N: CInt, alpha: CDouble, X: Ptr[CDoubleComplex], incX: CInt): Unit

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

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

Attributes

def cblas_zgbmv(order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, M: CInt, N: CInt, KL: CInt, KU: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, X: Ptr[CDoubleComplex], incX: CInt, beta: Ptr[CDoubleComplex], Y: Ptr[CDoubleComplex], incY: CInt): Unit
def cblas_zgemm(Order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, TransB: CBLAS_TRANSPOSE, M: CInt, N: CInt, K: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, B: Ptr[CDoubleComplex], ldb: CInt, beta: Ptr[CDoubleComplex], C: Ptr[CDoubleComplex], ldc: CInt): Unit
def cblas_zgemv(order: CBLAS_ORDER, TransA: CBLAS_TRANSPOSE, M: CInt, N: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, X: Ptr[CDoubleComplex], incX: CInt, beta: Ptr[CDoubleComplex], Y: Ptr[CDoubleComplex], incY: CInt): Unit
def cblas_zgerc(order: CBLAS_ORDER, M: CInt, N: CInt, alpha: Ptr[CDoubleComplex], X: Ptr[CDoubleComplex], incX: CInt, Y: Ptr[CDoubleComplex], incY: CInt, A: Ptr[CDoubleComplex], lda: CInt): Unit
def cblas_zgeru(order: CBLAS_ORDER, M: CInt, N: CInt, alpha: Ptr[CDoubleComplex], X: Ptr[CDoubleComplex], incX: CInt, Y: Ptr[CDoubleComplex], incY: CInt, A: Ptr[CDoubleComplex], lda: CInt): Unit
def cblas_zhbmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, K: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, X: Ptr[CDoubleComplex], incX: CInt, beta: Ptr[CDoubleComplex], Y: Ptr[CDoubleComplex], incY: CInt): Unit
def cblas_zhemm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, M: CInt, N: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, B: Ptr[CDoubleComplex], ldb: CInt, beta: Ptr[CDoubleComplex], C: Ptr[CDoubleComplex], ldc: CInt): Unit
def cblas_zhemv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, X: Ptr[CDoubleComplex], incX: CInt, beta: Ptr[CDoubleComplex], Y: Ptr[CDoubleComplex], incY: CInt): Unit
def cblas_zher(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CDouble, X: Ptr[CDoubleComplex], incX: CInt, A: Ptr[CDoubleComplex], lda: CInt): Unit
def cblas_zher2(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: Ptr[CDoubleComplex], X: Ptr[CDoubleComplex], incX: CInt, Y: Ptr[CDoubleComplex], incY: CInt, A: Ptr[CDoubleComplex], lda: CInt): Unit
def cblas_zher2k(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, B: Ptr[CDoubleComplex], ldb: CInt, beta: CDouble, C: Ptr[CDoubleComplex], ldc: CInt): Unit
def cblas_zherk(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: CDouble, A: Ptr[CDoubleComplex], lda: CInt, beta: CDouble, C: Ptr[CDoubleComplex], ldc: CInt): Unit
def cblas_zhpmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: Ptr[CDoubleComplex], Ap: Ptr[CDoubleComplex], X: Ptr[CDoubleComplex], incX: CInt, beta: Ptr[CDoubleComplex], Y: Ptr[CDoubleComplex], incY: CInt): Unit
def cblas_zhpr(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: CDouble, X: Ptr[CDoubleComplex], incX: CInt, A: Ptr[CDoubleComplex]): Unit
def cblas_zhpr2(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, N: CInt, alpha: Ptr[CDoubleComplex], X: Ptr[CDoubleComplex], incX: CInt, Y: Ptr[CDoubleComplex], incY: CInt, Ap: Ptr[CDoubleComplex]): Unit
def cblas_zscal(N: CInt, alpha: Ptr[CDoubleComplex], X: Ptr[CDoubleComplex], incX: CInt): Unit

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

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

Attributes

def cblas_zswap(N: CInt, X: Ptr[CDoubleComplex], incX: CInt, Y: Ptr[CDoubleComplex], incY: CInt): Unit

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

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

Attributes

def cblas_zsymm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, M: CInt, N: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, B: Ptr[CDoubleComplex], ldb: CInt, beta: Ptr[CDoubleComplex], C: Ptr[CDoubleComplex], ldc: CInt): Unit
def cblas_zsyr2k(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, B: Ptr[CDoubleComplex], ldb: CInt, beta: Ptr[CDoubleComplex], C: Ptr[CDoubleComplex], ldc: CInt): Unit
def cblas_zsyrk(Order: CBLAS_ORDER, Uplo: CBLAS_UPLO, Trans: CBLAS_TRANSPOSE, N: CInt, K: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, beta: Ptr[CDoubleComplex], C: Ptr[CDoubleComplex], ldc: CInt): Unit
def cblas_ztbmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, K: CInt, A: Ptr[CDoubleComplex], lda: CInt, X: Ptr[CDoubleComplex], incX: CInt): Unit
def cblas_ztbsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, K: CInt, A: Ptr[CDoubleComplex], lda: CInt, X: Ptr[CDoubleComplex], incX: CInt): Unit
def cblas_ztpmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, Ap: Ptr[CDoubleComplex], X: Ptr[CDoubleComplex], incX: CInt): Unit
def cblas_ztpsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, Ap: Ptr[CDoubleComplex], X: Ptr[CDoubleComplex], incX: CInt): Unit
def cblas_ztrmm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, M: CInt, N: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, B: Ptr[CDoubleComplex], ldb: CInt): Unit
def cblas_ztrmv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, A: Ptr[CDoubleComplex], lda: CInt, X: Ptr[CDoubleComplex], incX: CInt): Unit
def cblas_ztrsm(Order: CBLAS_ORDER, Side: CBLAS_SIDE, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, M: CInt, N: CInt, alpha: Ptr[CDoubleComplex], A: Ptr[CDoubleComplex], lda: CInt, B: Ptr[CDoubleComplex], ldb: CInt): Unit
def cblas_ztrsv(order: CBLAS_ORDER, Uplo: CBLAS_UPLO, TransA: CBLAS_TRANSPOSE, Diag: CBLAS_DIAG, N: CInt, A: Ptr[CDoubleComplex], lda: CInt, X: Ptr[CDoubleComplex], incX: CInt): Unit
Generated with