package nuod:cblas
Source

⌘K
Ctrl+K
or
/

    Overview

    This file has been provided by kalsprite from the OpenBLAS bindings:

    https://github.com/kalsprite/odin-command

    Index

    Variables (0)

    This section is empty.

    Procedures (220)
    Procedure Groups (0)

    This section is empty.

    Types

    CBLAS_DIAG ¶
    Source

    CBLAS_DIAG :: enum u32 {
	NonUnit = 131, 
	Unit    = 132, 
}
    Related Procedures With Parameters

    CBLAS_INDEX ¶
    Source

    CBLAS_INDEX :: uint
    Related Procedures With Returns

    CBLAS_ORDER ¶
    Source

    CBLAS_ORDER :: enum u32 {
	RowMajor = 101, 
	ColMajor = 102, 
}
    Related Procedures With Parameters

    CBLAS_SIDE ¶
    Source

    CBLAS_SIDE :: enum u32 {
	Left  = 141, 
	Right = 142, 
}
    Related Procedures With Parameters

    CBLAS_TRANSPOSE ¶
    Source

    CBLAS_TRANSPOSE :: enum u32 {
	NoTrans     = 111, 
	Trans       = 112, 
	ConjTrans   = 113, 
	ConjNoTrans = 114, 
}
    Related Procedures With Parameters

    CBLAS_UPLO ¶
    Source

    CBLAS_UPLO :: enum u32 {
	Upper = 121, 
	Lower = 122, 
}
    Related Procedures With Parameters

    bfloat16 ¶
    Source

    bfloat16 :: u16
    Related Procedures With Parameters

    blasint ¶
    Source

    blasint :: i64
    Related Procedures With Parameters

    openblas_dojob_callback ¶
    Source

    openblas_dojob_callback :: proc "c" (job_id: i32, job_data: rawptr, thread_id: i32)
     

    Set the threading backend to a custom callback.

    openblas_threads_callback ¶
    Source

    openblas_threads_callback :: proc "c" (num_threads: i32, dojob: openblas_dojob_callback, jobdata_elsize: i32, jobdata_stride: uint, jobdata: rawptr, num_jobs: i32)
    Related Procedures With Parameters

    Constants

    OPENBLAS_SUPPORTED ¶
    Source

    OPENBLAS_SUPPORTED: bool : true

    OPENMP ¶
    Source

    OPENMP :: 2
     

    OpenBLAS is compiled using OpenMP threading model

    SEQUENTIAL ¶
    Source

    SEQUENTIAL :: 0
     

    OpenBLAS is compiled for sequential use

    THREAD ¶
    Source

    THREAD :: 1
     

    OpenBLAS is compiled using normal threading model

    Variables

    This section is empty.

    Procedures

    caxpby ¶
    Source

    caxpby :: proc "c" (
	n:     i64, 
	alpha: ^complex64, 
	x:     [^]complex64, 
	incx:  i64, 
	beta:  ^complex64, 
	y:     [^]complex64, 
	incy:  i64, 
) ---

    caxpy ¶
    Source

    caxpy :: proc "c" (
	n:     i64, 
	alpha: ^complex64, 
	x:     [^]complex64, 
	incx:  i64, 
	y:     [^]complex64, 
	incy:  i64, 
) ---

    caxpyc ¶
    Source

    caxpyc :: proc "c" (
	n:     i64, 
	alpha: ^complex64, 
	x:     [^]complex64, 
	incx:  i64, 
	y:     [^]complex64, 
	incy:  i64, 
) ---

    ccopy ¶
    Source

    ccopy :: proc "c" (n: i64, x: [^]complex64, incx: i64, y: [^]complex64, incy: i64) ---

    cdotc ¶
    Source

    cdotc :: proc "c" (n: i64, x: [^]complex64, incx: i64, y: [^]complex64, incy: i64) -> complex64 ---

    cdotc_sub ¶
    Source

    cdotc_sub :: proc "c" (
	n:    i64, 
	x:    [^]complex64, 
	incx: i64, 
	y:    [^]complex64, 
	incy: i64, 
	ret:  ^complex64, 
) ---

    cdotu ¶
    Source

    cdotu :: proc "c" (n: i64, x: [^]complex64, incx: i64, y: [^]complex64, incy: i64) -> complex64 ---

    cdotu_sub ¶
    Source

    cdotu_sub :: proc "c" (
	n:    i64, 
	x:    [^]complex64, 
	incx: i64, 
	y:    [^]complex64, 
	incy: i64, 
	ret:  ^complex64, 
) ---

    cgbmv ¶
    Source

    cgbmv :: proc "c" (
	order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	KL:     i64, 
	KU:     i64, 
	alpha:  ^complex64, 
	A:      [^]complex64, 
	lda:    i64, 
	X:      [^]complex64, 
	incX:   i64, 
	beta:   ^complex64, 
	Y:      [^]complex64, 
	incY:   i64, 
) ---

    cgeadd ¶
    Source

    cgeadd :: proc "c" (
	CORDER: CBLAS_ORDER, 
	crows:  i64, 
	ccols:  i64, 
	calpha: ^complex64, 
	a:      [^]complex64, 
	clda:   i64, 
	cbeta:  ^complex64, 
	_c:     [^]complex64, 
	cldc:   i64, 
) ---

    cgemm ¶
    Source

    cgemm :: proc "c" (
	Order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	K:      i64, 
	alpha:  ^complex64, 
	A:      [^]complex64, 
	lda:    i64, 
	B:      [^]complex64, 
	ldb:    i64, 
	beta:   ^complex64, 
	C:      [^]complex64, 
	ldc:    i64, 
) ---

    cgemm3m ¶
    Source

    cgemm3m :: proc "c" (
	Order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	K:      i64, 
	alpha:  ^complex64, 
	A:      [^]complex64, 
	lda:    i64, 
	B:      [^]complex64, 
	ldb:    i64, 
	beta:   ^complex64, 
	C:      [^]complex64, 
	ldc:    i64, 
) ---

    cgemm_batch ¶
    Source

    cgemm_batch :: proc "c" (
	Order:        CBLAS_ORDER, 
	TransA_array: [^]CBLAS_TRANSPOSE, 
	TransB_array: [^]CBLAS_TRANSPOSE, 
	M_array:      [^]i64, 
	N_array:      [^]i64, 
	K_array:      [^]i64, 
	alpha_array:  [^]complex64, 
	A_array:      [^][^]complex64, 
	lda_array:    [^]i64, 
	B_array:      [^][^]complex64, 
	ldb_array:    [^]i64, 
	beta_array:   [^]complex64, 
	C_array:      [^][^]complex64, 
	ldc_array:    [^]i64, 
	group_count:  i64, 
	group_size:   [^]i64, 
) ---

    cgemmt ¶
    Source

    cgemmt :: proc "c" (
	Order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	K:      i64, 
	alpha:  ^complex64, 
	A:      [^]complex64, 
	lda:    i64, 
	B:      [^]complex64, 
	ldb:    i64, 
	beta:   ^complex64, 
	C:      [^]complex64, 
	ldc:    i64, 
) ---

    cgemv ¶
    Source

    cgemv :: proc "c" (
	order: CBLAS_ORDER, 
	trans: CBLAS_TRANSPOSE, 
	m:     i64, 
	n:     i64, 
	alpha: ^complex64, 
	a:     [^]complex64, 
	lda:   i64, 
	x:     [^]complex64, 
	incx:  i64, 
	beta:  ^complex64, 
	y:     [^]complex64, 
	incy:  i64, 
) ---

    cgerc ¶
    Source

    cgerc :: proc "c" (
	order: CBLAS_ORDER, 
	M:     i64, 
	N:     i64, 
	alpha: ^complex64, 
	X:     [^]complex64, 
	incX:  i64, 
	Y:     [^]complex64, 
	incY:  i64, 
	A:     [^]complex64, 
	lda:   i64, 
) ---

    cgeru ¶
    Source

    cgeru :: proc "c" (
	order: CBLAS_ORDER, 
	M:     i64, 
	N:     i64, 
	alpha: ^complex64, 
	X:     [^]complex64, 
	incX:  i64, 
	Y:     [^]complex64, 
	incY:  i64, 
	A:     [^]complex64, 
	lda:   i64, 
) ---

    chbmv ¶
    Source

    chbmv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	K:     i64, 
	alpha: ^complex64, 
	A:     [^]complex64, 
	lda:   i64, 
	X:     [^]complex64, 
	incX:  i64, 
	beta:  ^complex64, 
	Y:     [^]complex64, 
	incY:  i64, 
) ---

    chemm ¶
    Source

    chemm :: proc "c" (
	Order: CBLAS_ORDER, 
	Side:  CBLAS_SIDE, 
	Uplo:  CBLAS_UPLO, 
	M:     i64, 
	N:     i64, 
	alpha: ^complex64, 
	A:     [^]complex64, 
	lda:   i64, 
	B:     [^]complex64, 
	ldb:   i64, 
	beta:  ^complex64, 
	C:     [^]complex64, 
	ldc:   i64, 
) ---

    chemv ¶
    Source

    chemv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: ^complex64, 
	A:     [^]complex64, 
	lda:   i64, 
	X:     [^]complex64, 
	incX:  i64, 
	beta:  ^complex64, 
	Y:     [^]complex64, 
	incY:  i64, 
) ---

    cher ¶
    Source

    cher :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f32, 
	X:     [^]complex64, 
	incX:  i64, 
	A:     [^]complex64, 
	lda:   i64, 
) ---

    cher2 ¶
    Source

    cher2 :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: ^complex64, 
	X:     [^]complex64, 
	incX:  i64, 
	Y:     [^]complex64, 
	incY:  i64, 
	A:     [^]complex64, 
	lda:   i64, 
) ---

    cher2k ¶
    Source

    cher2k :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: ^complex64, 
	A:     [^]complex64, 
	lda:   i64, 
	B:     [^]complex64, 
	ldb:   i64, 
	beta:  f32, 
	C:     [^]complex64, 
	ldc:   i64, 
) ---

    cherk ¶
    Source

    cherk :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: f32, 
	A:     [^]complex64, 
	lda:   i64, 
	beta:  f32, 
	C:     [^]complex64, 
	ldc:   i64, 
) ---

    chpmv ¶
    Source

    chpmv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: ^complex64, 
	Ap:    [^]complex64, 
	X:     [^]complex64, 
	incX:  i64, 
	beta:  ^complex64, 
	Y:     [^]complex64, 
	incY:  i64, 
) ---

    chpr ¶
    Source

    chpr :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f32, 
	X:     [^]complex64, 
	incX:  i64, 
	A:     [^]complex64, 
) ---

    chpr2 ¶
    Source

    chpr2 :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: ^complex64, 
	X:     [^]complex64, 
	incX:  i64, 
	Y:     [^]complex64, 
	incY:  i64, 
	Ap:    [^]complex64, 
) ---

    cimatcopy ¶
    Source

    cimatcopy :: proc "c" (
	CORDER: CBLAS_ORDER, 
	CTRANS: CBLAS_TRANSPOSE, 
	crows:  i64, 
	ccols:  i64, 
	calpha: ^complex64, 
	a:      [^]complex64, 
	clda:   i64, 
	cldb:   i64, 
) ---

    comatcopy ¶
    Source

    comatcopy :: proc "c" (
	CORDER: CBLAS_ORDER, 
	CTRANS: CBLAS_TRANSPOSE, 
	crows:  i64, 
	ccols:  i64, 
	calpha: ^complex64, 
	a:      [^]complex64, 
	clda:   i64, 
	b:      [^]complex64, 
	cldb:   i64, 
) ---

    crotg ¶
    Source

    crotg :: proc "c" (a: ^complex64, b: ^complex64, _c: ^f32, s: ^complex64) ---

    cscal ¶
    Source

    cscal :: proc "c" (N: i64, alpha: ^complex64, X: [^]complex64, incX: i64) ---

    csrot ¶
    Source

    csrot :: proc "c" (
	n:    i64, 
	x:    [^]complex64, 
	incx: i64, 
	y:    [^]complex64, 
	incY: i64, 
	_c:   f32, 
	s:    f32, 
) ---

    csscal ¶
    Source

    csscal :: proc "c" (N: i64, alpha: f32, X: [^]complex64, incX: i64) ---

    cswap ¶
    Source

    cswap :: proc "c" (n: i64, x: [^]complex64, incx: i64, y: [^]complex64, incy: i64) ---

    csymm ¶
    Source

    csymm :: proc "c" (
	Order: CBLAS_ORDER, 
	Side:  CBLAS_SIDE, 
	Uplo:  CBLAS_UPLO, 
	M:     i64, 
	N:     i64, 
	alpha: ^complex64, 
	A:     [^]complex64, 
	lda:   i64, 
	B:     [^]complex64, 
	ldb:   i64, 
	beta:  ^complex64, 
	C:     [^]complex64, 
	ldc:   i64, 
) ---

    csyr2k ¶
    Source

    csyr2k :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: ^complex64, 
	A:     [^]complex64, 
	lda:   i64, 
	B:     [^]complex64, 
	ldb:   i64, 
	beta:  ^complex64, 
	C:     [^]complex64, 
	ldc:   i64, 
) ---

    csyrk ¶
    Source

    csyrk :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: ^complex64, 
	A:     [^]complex64, 
	lda:   i64, 
	beta:  ^complex64, 
	C:     [^]complex64, 
	ldc:   i64, 
) ---

    ctbmv ¶
    Source

    ctbmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	K:      i64, 
	A:      [^]complex64, 
	lda:    i64, 
	X:      [^]complex64, 
	incX:   i64, 
) ---

    ctbsv ¶
    Source

    ctbsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	K:      i64, 
	A:      [^]complex64, 
	lda:    i64, 
	X:      [^]complex64, 
	incX:   i64, 
) ---

    ctpmv ¶
    Source

    ctpmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	Ap:     [^]complex64, 
	X:      [^]complex64, 
	incX:   i64, 
) ---

    ctpsv ¶
    Source

    ctpsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	Ap:     [^]complex64, 
	X:      [^]complex64, 
	incX:   i64, 
) ---

    ctrmm ¶
    Source

    ctrmm :: proc "c" (
	Order:  CBLAS_ORDER, 
	Side:   CBLAS_SIDE, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	M:      i64, 
	N:      i64, 
	alpha:  ^complex64, 
	A:      [^]complex64, 
	lda:    i64, 
	B:      [^]complex64, 
	ldb:    i64, 
) ---

    ctrmv ¶
    Source

    ctrmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	A:      [^]complex64, 
	lda:    i64, 
	X:      [^]complex64, 
	incX:   i64, 
) ---

    ctrsm ¶
    Source

    ctrsm :: proc "c" (
	Order:  CBLAS_ORDER, 
	Side:   CBLAS_SIDE, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	M:      i64, 
	N:      i64, 
	alpha:  ^complex64, 
	A:      [^]complex64, 
	lda:    i64, 
	B:      [^]complex64, 
	ldb:    i64, 
) ---

    ctrsv ¶
    Source

    ctrsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	A:      [^]complex64, 
	lda:    i64, 
	X:      [^]complex64, 
	incX:   i64, 
) ---

    damax ¶
    Source

    damax :: proc "c" (n: i64, x: [^]f64, incx: i64) -> f64 ---

    damin ¶
    Source

    damin :: proc "c" (n: i64, x: [^]f64, incx: i64) -> f64 ---

    dasum ¶
    Source

    dasum :: proc "c" (n: i64, x: [^]f64, incx: i64) -> f64 ---

    daxpby ¶
    Source

    daxpby :: proc "c" (
	n:     i64, 
	alpha: f64, 
	x:     [^]f64, 
	incx:  i64, 
	beta:  f64, 
	y:     [^]f64, 
	incy:  i64, 
) ---

    daxpy ¶
    Source

    daxpy :: proc "c" (
	n:     i64, 
	alpha: f64, 
	x:     [^]f64, 
	incx:  i64, 
	y:     [^]f64, 
	incy:  i64, 
) ---

    dbf16tod ¶
    Source

    dbf16tod :: proc "c" (n: i64, _in: [^]u16, incin: i64, out: [^]f64, incout: i64) ---
     

    convert BFLOAT16 array to double array

    dcopy ¶
    Source

    dcopy :: proc "c" (n: i64, x: [^]f64, incx: i64, y: [^]f64, incy: i64) ---

    ddot ¶
    Source

    ddot :: proc "c" (n: i64, x: [^]f64, incx: i64, y: [^]f64, incy: i64) -> f64 ---

    dgbmv ¶
    Source

    dgbmv :: proc "c" (
	order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	KL:     i64, 
	KU:     i64, 
	alpha:  f64, 
	A:      [^]f64, 
	lda:    i64, 
	X:      [^]f64, 
	incX:   i64, 
	beta:   f64, 
	Y:      [^]f64, 
	incY:   i64, 
) ---

    dgeadd ¶
    Source

    dgeadd :: proc "c" (
	CORDER: CBLAS_ORDER, 
	crows:  i64, 
	ccols:  i64, 
	calpha: f64, 
	a:      [^]f64, 
	clda:   i64, 
	cbeta:  f64, 
	_c:     [^]f64, 
	cldc:   i64, 
) ---

    dgemm ¶
    Source

    dgemm :: proc "c" (
	Order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	K:      i64, 
	alpha:  f64, 
	A:      [^]f64, 
	lda:    i64, 
	B:      [^]f64, 
	ldb:    i64, 
	beta:   f64, 
	C:      [^]f64, 
	ldc:    i64, 
) ---

    dgemm_batch ¶
    Source

    dgemm_batch :: proc "c" (
	Order:        CBLAS_ORDER, 
	TransA_array: [^]CBLAS_TRANSPOSE, 
	TransB_array: [^]CBLAS_TRANSPOSE, 
	M_array:      [^]i64, 
	N_array:      [^]i64, 
	K_array:      [^]i64, 
	alpha_array:  [^]f64, 
	A_array:      [^]^f64, 
	lda_array:    [^]i64, 
	B_array:      [^]^f64, 
	ldb_array:    [^]i64, 
	beta_array:   [^]f64, 
	C_array:      [^]^f64, 
	ldc_array:    [^]i64, 
	group_count:  i64, 
	group_size:   [^]i64, 
) ---

    dgemmt ¶
    Source

    dgemmt :: proc "c" (
	Order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	K:      i64, 
	alpha:  f64, 
	A:      [^]f64, 
	lda:    i64, 
	B:      [^]f64, 
	ldb:    i64, 
	beta:   f64, 
	C:      [^]f64, 
	ldc:    i64, 
) ---

    dgemv ¶
    Source

    dgemv :: proc "c" (
	order: CBLAS_ORDER, 
	trans: CBLAS_TRANSPOSE, 
	m:     i64, 
	n:     i64, 
	alpha: f64, 
	a:     [^]f64, 
	lda:   i64, 
	x:     [^]f64, 
	incx:  i64, 
	beta:  f64, 
	y:     [^]f64, 
	incy:  i64, 
) ---

    dger ¶
    Source

    dger :: proc "c" (
	order: CBLAS_ORDER, 
	M:     i64, 
	N:     i64, 
	alpha: f64, 
	X:     [^]f64, 
	incX:  i64, 
	Y:     [^]f64, 
	incY:  i64, 
	A:     [^]f64, 
	lda:   i64, 
) ---

    dimatcopy ¶
    Source

    dimatcopy :: proc "c" (
	CORDER: CBLAS_ORDER, 
	CTRANS: CBLAS_TRANSPOSE, 
	crows:  i64, 
	ccols:  i64, 
	calpha: f64, 
	a:      [^]f64, 
	clda:   i64, 
	cldb:   i64, 
) ---

    dnrm2 ¶
    Source

    dnrm2 :: proc "c" (N: i64, X: [^]f64, incX: i64) -> f64 ---

    domatcopy ¶
    Source

    domatcopy :: proc "c" (
	CORDER: CBLAS_ORDER, 
	CTRANS: CBLAS_TRANSPOSE, 
	crows:  i64, 
	ccols:  i64, 
	calpha: f64, 
	a:      [^]f64, 
	clda:   i64, 
	b:      [^]f64, 
	cldb:   i64, 
) ---

    drot ¶
    Source

    drot :: proc "c" (
	N:    i64, 
	X:    [^]f64, 
	incX: i64, 
	Y:    [^]f64, 
	incY: i64, 
	_c:   f64, 
	s:    f64, 
) ---

    drotg ¶
    Source

    drotg :: proc "c" (a: ^f64, b: ^f64, _c: ^f64, s: ^f64) ---

    drotm ¶
    Source

    drotm :: proc "c" (
	N:    i64, 
	X:    [^]f64, 
	incX: i64, 
	Y:    [^]f64, 
	incY: i64, 
	P:    [^]f64, 
) ---

    drotmg ¶
    Source

    drotmg :: proc "c" (d1: ^f64, d2: ^f64, b1: ^f64, b2: f64, P: [^]f64) ---

    dsbmv ¶
    Source

    dsbmv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	K:     i64, 
	alpha: f64, 
	A:     [^]f64, 
	lda:   i64, 
	X:     [^]f64, 
	incX:  i64, 
	beta:  f64, 
	Y:     [^]f64, 
	incY:  i64, 
) ---

    dscal ¶
    Source

    dscal :: proc "c" (N: i64, alpha: f64, X: [^]f64, incX: i64) ---

    dsdot ¶
    Source

    dsdot :: proc "c" (n: i64, x: [^]f32, incx: i64, y: [^]f32, incy: i64) -> f64 ---

    dspmv ¶
    Source

    dspmv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f64, 
	Ap:    [^]f64, 
	X:     [^]f64, 
	incX:  i64, 
	beta:  f64, 
	Y:     [^]f64, 
	incY:  i64, 
) ---

    dspr ¶
    Source

    dspr :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f64, 
	X:     [^]f64, 
	incX:  i64, 
	Ap:    [^]f64, 
) ---

    dspr2 ¶
    Source

    dspr2 :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f64, 
	X:     [^]f64, 
	incX:  i64, 
	Y:     [^]f64, 
	incY:  i64, 
	A:     [^]f64, 
) ---

    dsum ¶
    Source

    dsum :: proc "c" (n: i64, x: [^]f64, incx: i64) -> f64 ---

    dswap ¶
    Source

    dswap :: proc "c" (n: i64, x: [^]f64, incx: i64, y: [^]f64, incy: i64) ---

    dsymm ¶
    Source

    dsymm :: proc "c" (
	Order: CBLAS_ORDER, 
	Side:  CBLAS_SIDE, 
	Uplo:  CBLAS_UPLO, 
	M:     i64, 
	N:     i64, 
	alpha: f64, 
	A:     [^]f64, 
	lda:   i64, 
	B:     [^]f64, 
	ldb:   i64, 
	beta:  f64, 
	C:     [^]f64, 
	ldc:   i64, 
) ---

    dsymv ¶
    Source

    dsymv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f64, 
	A:     [^]f64, 
	lda:   i64, 
	X:     [^]f64, 
	incX:  i64, 
	beta:  f64, 
	Y:     [^]f64, 
	incY:  i64, 
) ---

    dsyr ¶
    Source

    dsyr :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f64, 
	X:     [^]f64, 
	incX:  i64, 
	A:     [^]f64, 
	lda:   i64, 
) ---

    dsyr2 ¶
    Source

    dsyr2 :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f64, 
	X:     [^]f64, 
	incX:  i64, 
	Y:     [^]f64, 
	incY:  i64, 
	A:     [^]f64, 
	lda:   i64, 
) ---

    dsyr2k ¶
    Source

    dsyr2k :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: f64, 
	A:     [^]f64, 
	lda:   i64, 
	B:     [^]f64, 
	ldb:   i64, 
	beta:  f64, 
	C:     [^]f64, 
	ldc:   i64, 
) ---

    dsyrk ¶
    Source

    dsyrk :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: f64, 
	A:     [^]f64, 
	lda:   i64, 
	beta:  f64, 
	C:     [^]f64, 
	ldc:   i64, 
) ---

    dtbmv ¶
    Source

    dtbmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	K:      i64, 
	A:      [^]f64, 
	lda:    i64, 
	X:      [^]f64, 
	incX:   i64, 
) ---

    dtbsv ¶
    Source

    dtbsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	K:      i64, 
	A:      [^]f64, 
	lda:    i64, 
	X:      [^]f64, 
	incX:   i64, 
) ---

    dtpmv ¶
    Source

    dtpmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	Ap:     [^]f64, 
	X:      [^]f64, 
	incX:   i64, 
) ---

    dtpsv ¶
    Source

    dtpsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	Ap:     [^]f64, 
	X:      [^]f64, 
	incX:   i64, 
) ---

    dtrmm ¶
    Source

    dtrmm :: proc "c" (
	Order:  CBLAS_ORDER, 
	Side:   CBLAS_SIDE, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	M:      i64, 
	N:      i64, 
	alpha:  f64, 
	A:      [^]f64, 
	lda:    i64, 
	B:      [^]f64, 
	ldb:    i64, 
) ---

    dtrmv ¶
    Source

    dtrmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	A:      [^]f64, 
	lda:    i64, 
	X:      [^]f64, 
	incX:   i64, 
) ---

    dtrsm ¶
    Source

    dtrsm :: proc "c" (
	Order:  CBLAS_ORDER, 
	Side:   CBLAS_SIDE, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	M:      i64, 
	N:      i64, 
	alpha:  f64, 
	A:      [^]f64, 
	lda:    i64, 
	B:      [^]f64, 
	ldb:    i64, 
) ---

    dtrsv ¶
    Source

    dtrsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	A:      [^]f64, 
	lda:    i64, 
	X:      [^]f64, 
	incX:   i64, 
) ---

    dzamax ¶
    Source

    dzamax :: proc "c" (n: i64, x: [^]complex128, incx: i64) -> f64 ---

    dzamin ¶
    Source

    dzamin :: proc "c" (n: i64, x: [^]complex128, incx: i64) -> f64 ---

    dzasum ¶
    Source

    dzasum :: proc "c" (n: i64, x: [^]complex128, incx: i64) -> f64 ---

    dznrm2 ¶
    Source

    dznrm2 :: proc "c" (N: i64, X: [^]complex128, incX: i64) -> f64 ---

    dzsum ¶
    Source

    dzsum :: proc "c" (n: i64, x: [^]complex128, incx: i64) -> f64 ---

    goto_set_num_threads ¶
    Source

    goto_set_num_threads :: proc "c" (num_threads: i32) ---

    icamax ¶
    Source

    icamax :: proc "c" (n: i64, x: [^]complex64, incx: i64) -> uint ---

    icamin ¶
    Source

    icamin :: proc "c" (n: i64, x: [^]complex64, incx: i64) -> uint ---

    icmax ¶
    Source

    icmax :: proc "c" (n: i64, x: [^]complex64, incx: i64) -> uint ---

    icmin ¶
    Source

    icmin :: proc "c" (n: i64, x: [^]complex64, incx: i64) -> uint ---

    idamax ¶
    Source

    idamax :: proc "c" (n: i64, x: [^]f64, incx: i64) -> uint ---

    idamin ¶
    Source

    idamin :: proc "c" (n: i64, x: [^]f64, incx: i64) -> uint ---

    idmax ¶
    Source

    idmax :: proc "c" (n: i64, x: [^]f64, incx: i64) -> uint ---

    idmin ¶
    Source

    idmin :: proc "c" (n: i64, x: [^]f64, incx: i64) -> uint ---

    isamax ¶
    Source

    isamax :: proc "c" (n: i64, x: [^]f32, incx: i64) -> uint ---

    isamin ¶
    Source

    isamin :: proc "c" (n: i64, x: [^]f32, incx: i64) -> uint ---

    ismax ¶
    Source

    ismax :: proc "c" (n: i64, x: [^]f32, incx: i64) -> uint ---

    ismin ¶
    Source

    ismin :: proc "c" (n: i64, x: [^]f32, incx: i64) -> uint ---

    izamax ¶
    Source

    izamax :: proc "c" (n: i64, x: [^]complex128, incx: i64) -> uint ---

    izamin ¶
    Source

    izamin :: proc "c" (n: i64, x: [^]complex128, incx: i64) -> uint ---

    izmax ¶
    Source

    izmax :: proc "c" (n: i64, x: [^]complex128, incx: i64) -> uint ---

    izmin ¶
    Source

    izmin :: proc "c" (n: i64, x: [^]complex128, incx: i64) -> uint ---

    openblas_get_config ¶
    Source

    openblas_get_config :: proc "c" () -> cstring ---
     

    Get the build configure on runtime.

    openblas_get_corename ¶
    Source

    openblas_get_corename :: proc "c" () -> cstring ---
     

    Get the CPU corename on runtime.

    openblas_get_num_procs ¶
    Source

    openblas_get_num_procs :: proc "c" () -> i32 ---
     

    Get the number of physical processors (cores).

    openblas_get_num_threads ¶
    Source

    openblas_get_num_threads :: proc "c" () -> i32 ---
     

    Get the number of threads on runtime.

    openblas_get_parallel ¶
    Source

    openblas_get_parallel :: proc "c" () -> i32 ---
     

    Get the parallelization type which is used by OpenBLAS

    openblas_set_num_threads ¶
    Source

    openblas_set_num_threads :: proc "c" (num_threads: i32) ---
     

    Set the number of threads on runtime.

    openblas_set_num_threads_local ¶
    Source

    openblas_set_num_threads_local :: proc "c" (num_threads: i32) -> i32 ---

    openblas_set_threads_callback_function ¶
    Source

    openblas_set_threads_callback_function :: proc "c" (callback: openblas_threads_callback) ---

    samax ¶
    Source

    samax :: proc "c" (n: i64, x: [^]f32, incx: i64) -> f32 ---

    samin ¶
    Source

    samin :: proc "c" (n: i64, x: [^]f32, incx: i64) -> f32 ---

    sasum ¶
    Source

    sasum :: proc "c" (n: i64, x: [^]f32, incx: i64) -> f32 ---

    saxpby ¶
    Source

    saxpby :: proc "c" (
	n:     i64, 
	alpha: f32, 
	x:     [^]f32, 
	incx:  i64, 
	beta:  f32, 
	y:     [^]f32, 
	incy:  i64, 
) ---
     

    BLAS extensions

    saxpy ¶
    Source

    saxpy :: proc "c" (
	n:     i64, 
	alpha: f32, 
	x:     [^]f32, 
	incx:  i64, 
	y:     [^]f32, 
	incy:  i64, 
) ---

    sbdot ¶
    Source

    sbdot :: proc "c" (n: i64, x: [^]u16, incx: i64, y: [^]u16, incy: i64) -> f32 ---
     

    dot production of BFLOAT16 input arrays, and output as float

    sbdtobf16 ¶
    Source

    sbdtobf16 :: proc "c" (n: i64, _in: [^]f64, incin: i64, out: [^]u16, incout: i64) ---
     

    convert double array to BFLOAT16 array by rounding

    sbf16tos ¶
    Source

    sbf16tos :: proc "c" (n: i64, _in: [^]u16, incin: i64, out: [^]f32, incout: i64) ---
     

    convert BFLOAT16 array to float array

    sbgemm ¶
    Source

    sbgemm :: proc "c" (
	Order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	K:      i64, 
	alpha:  f32, 
	A:      [^]u16, 
	lda:    i64, 
	B:      [^]u16, 
	ldb:    i64, 
	beta:   f32, 
	C:      [^]f32, 
	ldc:    i64, 
) ---

    sbgemm_batch ¶
    Source

    sbgemm_batch :: proc "c" (
	Order:        CBLAS_ORDER, 
	TransA_array: [^]CBLAS_TRANSPOSE, 
	TransB_array: [^]CBLAS_TRANSPOSE, 
	M_array:      [^]i64, 
	N_array:      [^]i64, 
	K_array:      [^]i64, 
	alpha_array:  [^]f32, 
	A_array:      [^]^u16, 
	lda_array:    [^]i64, 
	B_array:      [^]^u16, 
	ldb_array:    [^]i64, 
	beta_array:   [^]f32, 
	C_array:      [^]^f32, 
	ldc_array:    [^]i64, 
	group_count:  i64, 
	group_size:   [^]i64, 
) ---

    sbgemv ¶
    Source

    sbgemv :: proc "c" (
	order: CBLAS_ORDER, 
	trans: CBLAS_TRANSPOSE, 
	m:     i64, 
	n:     i64, 
	alpha: f32, 
	a:     [^]u16, 
	lda:   i64, 
	x:     [^]u16, 
	incx:  i64, 
	beta:  f32, 
	y:     [^]f32, 
	incy:  i64, 
) ---

    sbstobf16 ¶
    Source

    sbstobf16 :: proc "c" (n: i64, _in: [^]f32, incin: i64, out: [^]u16, incout: i64) ---
     

    BFLOAT16 and INT8 extensions convert float array to BFLOAT16 array by rounding

    scamax ¶
    Source

    scamax :: proc "c" (n: i64, x: [^]complex64, incx: i64) -> f32 ---

    scamin ¶
    Source

    scamin :: proc "c" (n: i64, x: [^]complex64, incx: i64) -> f32 ---

    scasum ¶
    Source

    scasum :: proc "c" (n: i64, x: [^]complex64, incx: i64) -> f32 ---

    scnrm2 ¶
    Source

    scnrm2 :: proc "c" (N: i64, X: [^]complex64, incX: i64) -> f32 ---

    scopy ¶
    Source

    scopy :: proc "c" (n: i64, x: [^]f32, incx: i64, y: [^]f32, incy: i64) ---

    scsum ¶
    Source

    scsum :: proc "c" (n: i64, x: [^]complex64, incx: i64) -> f32 ---

    sdot ¶
    Source

    sdot :: proc "c" (n: i64, x: [^]f32, incx: i64, y: [^]f32, incy: i64) -> f32 ---

    sdsdot ¶
    Source

    sdsdot :: proc "c" (
	n:     i64, 
	alpha: f32, 
	x:     [^]f32, 
	incx:  i64, 
	y:     [^]f32, 
	incy:  i64, 
) -> f32 ---

    sgbmv ¶
    Source

    sgbmv :: proc "c" (
	order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	KL:     i64, 
	KU:     i64, 
	alpha:  f32, 
	A:      [^]f32, 
	lda:    i64, 
	X:      [^]f32, 
	incX:   i64, 
	beta:   f32, 
	Y:      [^]f32, 
	incY:   i64, 
) ---

    sgeadd ¶
    Source

    sgeadd :: proc "c" (
	CORDER: CBLAS_ORDER, 
	crows:  i64, 
	ccols:  i64, 
	calpha: f32, 
	a:      [^]f32, 
	clda:   i64, 
	cbeta:  f32, 
	_c:     [^]f32, 
	cldc:   i64, 
) ---

    sgemm ¶
    Source

    sgemm :: proc "c" (
	Order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	K:      i64, 
	alpha:  f32, 
	A:      [^]f32, 
	lda:    i64, 
	B:      [^]f32, 
	ldb:    i64, 
	beta:   f32, 
	C:      [^]f32, 
	ldc:    i64, 
) ---

    sgemm_batch ¶
    Source

    sgemm_batch :: proc "c" (
	Order:        CBLAS_ORDER, 
	TransA_array: [^]CBLAS_TRANSPOSE, 
	TransB_array: [^]CBLAS_TRANSPOSE, 
	M_array:      [^]i64, 
	N_array:      [^]i64, 
	K_array:      [^]i64, 
	alpha_array:  [^]f32, 
	A_array:      [^]^f32, 
	lda_array:    [^]i64, 
	B_array:      [^]^f32, 
	ldb_array:    [^]i64, 
	beta_array:   [^]f32, 
	C_array:      [^]^f32, 
	ldc_array:    [^]i64, 
	group_count:  i64, 
	group_size:   [^]i64, 
) ---
     

    EVERYTHING BELOW HERE IS NOT WRAPPED:

    sgemmt ¶
    Source

    sgemmt :: proc "c" (
	Order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	K:      i64, 
	alpha:  f32, 
	A:      [^]f32, 
	lda:    i64, 
	B:      [^]f32, 
	ldb:    i64, 
	beta:   f32, 
	C:      [^]f32, 
	ldc:    i64, 
) ---

    sgemv ¶
    Source

    sgemv :: proc "c" (
	order: CBLAS_ORDER, 
	trans: CBLAS_TRANSPOSE, 
	m:     i64, 
	n:     i64, 
	alpha: f32, 
	a:     [^]f32, 
	lda:   i64, 
	x:     [^]f32, 
	incx:  i64, 
	beta:  f32, 
	y:     [^]f32, 
	incy:  i64, 
) ---

    sger ¶
    Source

    sger :: proc "c" (
	order: CBLAS_ORDER, 
	M:     i64, 
	N:     i64, 
	alpha: f32, 
	X:     [^]f32, 
	incX:  i64, 
	Y:     [^]f32, 
	incY:  i64, 
	A:     [^]f32, 
	lda:   i64, 
) ---

    simatcopy ¶
    Source

    simatcopy :: proc "c" (
	CORDER: CBLAS_ORDER, 
	CTRANS: CBLAS_TRANSPOSE, 
	crows:  i64, 
	ccols:  i64, 
	calpha: f32, 
	a:      [^]f32, 
	clda:   i64, 
	cldb:   i64, 
) ---

    snrm2 ¶
    Source

    snrm2 :: proc "c" (N: i64, X: [^]f32, incX: i64) -> f32 ---

    somatcopy ¶
    Source

    somatcopy :: proc "c" (
	CORDER: CBLAS_ORDER, 
	CTRANS: CBLAS_TRANSPOSE, 
	crows:  i64, 
	ccols:  i64, 
	calpha: f32, 
	a:      [^]f32, 
	clda:   i64, 
	b:      [^]f32, 
	cldb:   i64, 
) ---

    srot ¶
    Source

    srot :: proc "c" (
	N:    i64, 
	X:    [^]f32, 
	incX: i64, 
	Y:    [^]f32, 
	incY: i64, 
	_c:   f32, 
	s:    f32, 
) ---

    srotg ¶
    Source

    srotg :: proc "c" (a: ^f32, b: ^f32, _c: ^f32, s: ^f32) ---

    srotm ¶
    Source

    srotm :: proc "c" (
	N:    i64, 
	X:    [^]f32, 
	incX: i64, 
	Y:    [^]f32, 
	incY: i64, 
	P:    [^]f32, 
) ---

    srotmg ¶
    Source

    srotmg :: proc "c" (d1: ^f32, d2: ^f32, b1: ^f32, b2: f32, P: [^]f32) ---

    ssbmv ¶
    Source

    ssbmv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	K:     i64, 
	alpha: f32, 
	A:     [^]f32, 
	lda:   i64, 
	X:     [^]f32, 
	incX:  i64, 
	beta:  f32, 
	Y:     [^]f32, 
	incY:  i64, 
) ---

    sscal ¶
    Source

    sscal :: proc "c" (N: i64, alpha: f32, X: [^]f32, incX: i64) ---

    sspmv ¶
    Source

    sspmv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f32, 
	Ap:    [^]f32, 
	X:     [^]f32, 
	incX:  i64, 
	beta:  f32, 
	Y:     [^]f32, 
	incY:  i64, 
) ---

    sspr ¶
    Source

    sspr :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f32, 
	X:     [^]f32, 
	incX:  i64, 
	Ap:    [^]f32, 
) ---

    sspr2 ¶
    Source

    sspr2 :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f32, 
	X:     [^]f32, 
	incX:  i64, 
	Y:     [^]f32, 
	incY:  i64, 
	A:     [^]f32, 
) ---

    ssum ¶
    Source

    ssum :: proc "c" (n: i64, x: [^]f32, incx: i64) -> f32 ---

    sswap ¶
    Source

    sswap :: proc "c" (n: i64, x: [^]f32, incx: i64, y: [^]f32, incy: i64) ---

    ssymm ¶
    Source

    ssymm :: proc "c" (
	Order: CBLAS_ORDER, 
	Side:  CBLAS_SIDE, 
	Uplo:  CBLAS_UPLO, 
	M:     i64, 
	N:     i64, 
	alpha: f32, 
	A:     [^]f32, 
	lda:   i64, 
	B:     [^]f32, 
	ldb:   i64, 
	beta:  f32, 
	C:     [^]f32, 
	ldc:   i64, 
) ---

    ssymv ¶
    Source

    ssymv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f32, 
	A:     [^]f32, 
	lda:   i64, 
	X:     [^]f32, 
	incX:  i64, 
	beta:  f32, 
	Y:     [^]f32, 
	incY:  i64, 
) ---

    ssyr ¶
    Source

    ssyr :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f32, 
	X:     [^]f32, 
	incX:  i64, 
	A:     [^]f32, 
	lda:   i64, 
) ---

    ssyr2 ¶
    Source

    ssyr2 :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f32, 
	X:     [^]f32, 
	incX:  i64, 
	Y:     [^]f32, 
	incY:  i64, 
	A:     [^]f32, 
	lda:   i64, 
) ---

    ssyr2k ¶
    Source

    ssyr2k :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: f32, 
	A:     [^]f32, 
	lda:   i64, 
	B:     [^]f32, 
	ldb:   i64, 
	beta:  f32, 
	C:     [^]f32, 
	ldc:   i64, 
) ---

    ssyrk ¶
    Source

    ssyrk :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: f32, 
	A:     [^]f32, 
	lda:   i64, 
	beta:  f32, 
	C:     [^]f32, 
	ldc:   i64, 
) ---

    stbmv ¶
    Source

    stbmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	K:      i64, 
	A:      [^]f32, 
	lda:    i64, 
	X:      [^]f32, 
	incX:   i64, 
) ---

    stbsv ¶
    Source

    stbsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	K:      i64, 
	A:      [^]f32, 
	lda:    i64, 
	X:      [^]f32, 
	incX:   i64, 
) ---

    stpmv ¶
    Source

    stpmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	Ap:     [^]f32, 
	X:      [^]f32, 
	incX:   i64, 
) ---

    stpsv ¶
    Source

    stpsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	Ap:     [^]f32, 
	X:      [^]f32, 
	incX:   i64, 
) ---

    strmm ¶
    Source

    strmm :: proc "c" (
	Order:  CBLAS_ORDER, 
	Side:   CBLAS_SIDE, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	M:      i64, 
	N:      i64, 
	alpha:  f32, 
	A:      [^]f32, 
	lda:    i64, 
	B:      [^]f32, 
	ldb:    i64, 
) ---

    strmv ¶
    Source

    strmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	A:      [^]f32, 
	lda:    i64, 
	X:      [^]f32, 
	incX:   i64, 
) ---

    strsm ¶
    Source

    strsm :: proc "c" (
	Order:  CBLAS_ORDER, 
	Side:   CBLAS_SIDE, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	M:      i64, 
	N:      i64, 
	alpha:  f32, 
	A:      [^]f32, 
	lda:    i64, 
	B:      [^]f32, 
	ldb:    i64, 
) ---

    strsv ¶
    Source

    strsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	A:      [^]f32, 
	lda:    i64, 
	X:      [^]f32, 
	incX:   i64, 
) ---

    xerbla ¶
    Source

    xerbla :: proc "c" (p: i64, rout: cstring, form: cstring, .. _: ..any) ---

    zaxpby ¶
    Source

    zaxpby :: proc "c" (
	n:     i64, 
	alpha: ^complex128, 
	x:     [^]complex128, 
	incx:  i64, 
	beta:  ^complex128, 
	y:     [^]complex128, 
	incy:  i64, 
) ---

    zaxpy ¶
    Source

    zaxpy :: proc "c" (
	n:     i64, 
	alpha: ^complex128, 
	x:     [^]complex128, 
	incx:  i64, 
	y:     [^]complex128, 
	incy:  i64, 
) ---

    zaxpyc ¶
    Source

    zaxpyc :: proc "c" (
	n:     i64, 
	alpha: ^complex128, 
	x:     [^]complex128, 
	incx:  i64, 
	y:     [^]complex128, 
	incy:  i64, 
) ---

    zcopy ¶
    Source

    zcopy :: proc "c" (n: i64, x: [^]complex128, incx: i64, y: [^]complex128, incy: i64) ---

    zdotc ¶
    Source

    zdotc :: proc "c" (n: i64, x: [^]complex128, incx: i64, y: [^]complex128, incy: i64) -> complex128 ---

    zdotc_sub ¶
    Source

    zdotc_sub :: proc "c" (
	n:    i64, 
	x:    [^]complex128, 
	incx: i64, 
	y:    [^]complex128, 
	incy: i64, 
	ret:  ^complex128, 
) ---

    zdotu ¶
    Source

    zdotu :: proc "c" (n: i64, x: [^]complex128, incx: i64, y: [^]complex128, incy: i64) -> complex128 ---

    zdotu_sub ¶
    Source

    zdotu_sub :: proc "c" (
	n:    i64, 
	x:    [^]complex128, 
	incx: i64, 
	y:    [^]complex128, 
	incy: i64, 
	ret:  ^complex128, 
) ---

    zdrot ¶
    Source

    zdrot :: proc "c" (
	n:    i64, 
	x:    [^]complex128, 
	incx: i64, 
	y:    [^]complex128, 
	incY: i64, 
	_c:   f64, 
	s:    f64, 
) ---

    zdscal ¶
    Source

    zdscal :: proc "c" (N: i64, alpha: f64, X: [^]complex128, incX: i64) ---

    zgbmv ¶
    Source

    zgbmv :: proc "c" (
	order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	KL:     i64, 
	KU:     i64, 
	alpha:  ^complex128, 
	A:      [^]complex128, 
	lda:    i64, 
	X:      [^]complex128, 
	incX:   i64, 
	beta:   ^complex128, 
	Y:      [^]complex128, 
	incY:   i64, 
) ---

    zgeadd ¶
    Source

    zgeadd :: proc "c" (
	CORDER: CBLAS_ORDER, 
	crows:  i64, 
	ccols:  i64, 
	calpha: ^complex128, 
	a:      [^]complex128, 
	clda:   i64, 
	cbeta:  ^complex128, 
	_c:     [^]complex128, 
	cldc:   i64, 
) ---

    zgemm ¶
    Source

    zgemm :: proc "c" (
	Order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	K:      i64, 
	alpha:  ^complex128, 
	A:      [^]complex128, 
	lda:    i64, 
	B:      [^]complex128, 
	ldb:    i64, 
	beta:   ^complex128, 
	C:      [^]complex128, 
	ldc:    i64, 
) ---

    zgemm3m ¶
    Source

    zgemm3m :: proc "c" (
	Order:  CBLAS_ORDER, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	N:      i64, 
	K:      i64, 
	alpha:  ^complex128, 
	A:      [^]complex128, 
	lda:    i64, 
	B:      [^]complex128, 
	ldb:    i64, 
	beta:   ^complex128, 
	C:      [^]complex128, 
	ldc:    i64, 
) ---

    zgemm_batch ¶
    Source

    zgemm_batch :: proc "c" (
	Order:        CBLAS_ORDER, 
	TransA_array: [^]CBLAS_TRANSPOSE, 
	TransB_array: [^]CBLAS_TRANSPOSE, 
	M_array:      [^]i64, 
	N_array:      [^]i64, 
	K_array:      [^]i64, 
	alpha_array:  [^]complex128, 
	A_array:      [^][^]complex128, 
	lda_array:    [^]i64, 
	B_array:      [^][^]complex128, 
	ldb_array:    [^]i64, 
	beta_array:   [^]complex128, 
	C_array:      [^][^]complex128, 
	ldc_array:    [^]i64, 
	group_count:  i64, 
	group_size:   [^]i64, 
) ---

    zgemmt ¶
    Source

    zgemmt :: proc "c" (
	Order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	TransB: CBLAS_TRANSPOSE, 
	M:      i64, 
	K:      i64, 
	alpha:  ^complex128, 
	A:      [^]complex128, 
	lda:    i64, 
	B:      [^]complex128, 
	ldb:    i64, 
	beta:   ^complex128, 
	C:      [^]complex128, 
	ldc:    i64, 
) ---

    zgemv ¶
    Source

    zgemv :: proc "c" (
	order: CBLAS_ORDER, 
	trans: CBLAS_TRANSPOSE, 
	m:     i64, 
	n:     i64, 
	alpha: ^complex128, 
	a:     [^]complex128, 
	lda:   i64, 
	x:     [^]complex128, 
	incx:  i64, 
	beta:  ^complex128, 
	y:     [^]complex128, 
	incy:  i64, 
) ---

    zgerc ¶
    Source

    zgerc :: proc "c" (
	order: CBLAS_ORDER, 
	M:     i64, 
	N:     i64, 
	alpha: ^complex128, 
	X:     [^]complex128, 
	incX:  i64, 
	Y:     [^]complex128, 
	incY:  i64, 
	A:     [^]complex128, 
	lda:   i64, 
) ---

    zgeru ¶
    Source

    zgeru :: proc "c" (
	order: CBLAS_ORDER, 
	M:     i64, 
	N:     i64, 
	alpha: ^complex128, 
	X:     [^]complex128, 
	incX:  i64, 
	Y:     [^]complex128, 
	incY:  i64, 
	A:     [^]complex128, 
	lda:   i64, 
) ---

    zhbmv ¶
    Source

    zhbmv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	K:     i64, 
	alpha: ^complex128, 
	A:     [^]complex128, 
	lda:   i64, 
	X:     [^]complex128, 
	incX:  i64, 
	beta:  ^complex128, 
	Y:     [^]complex128, 
	incY:  i64, 
) ---

    zhemm ¶
    Source

    zhemm :: proc "c" (
	Order: CBLAS_ORDER, 
	Side:  CBLAS_SIDE, 
	Uplo:  CBLAS_UPLO, 
	M:     i64, 
	N:     i64, 
	alpha: ^complex128, 
	A:     [^]complex128, 
	lda:   i64, 
	B:     [^]complex128, 
	ldb:   i64, 
	beta:  ^complex128, 
	C:     [^]complex128, 
	ldc:   i64, 
) ---

    zhemv ¶
    Source

    zhemv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: ^complex128, 
	A:     [^]complex128, 
	lda:   i64, 
	X:     [^]complex128, 
	incX:  i64, 
	beta:  ^complex128, 
	Y:     [^]complex128, 
	incY:  i64, 
) ---

    zher ¶
    Source

    zher :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f64, 
	X:     [^]complex128, 
	incX:  i64, 
	A:     [^]complex128, 
	lda:   i64, 
) ---

    zher2 ¶
    Source

    zher2 :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: ^complex128, 
	X:     [^]complex128, 
	incX:  i64, 
	Y:     [^]complex128, 
	incY:  i64, 
	A:     [^]complex128, 
	lda:   i64, 
) ---

    zher2k ¶
    Source

    zher2k :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: ^complex128, 
	A:     [^]complex128, 
	lda:   i64, 
	B:     [^]complex128, 
	ldb:   i64, 
	beta:  f64, 
	C:     [^]complex128, 
	ldc:   i64, 
) ---

    zherk ¶
    Source

    zherk :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: f64, 
	A:     [^]complex128, 
	lda:   i64, 
	beta:  f64, 
	C:     [^]complex128, 
	ldc:   i64, 
) ---

    zhpmv ¶
    Source

    zhpmv :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: ^complex128, 
	Ap:    [^]complex128, 
	X:     [^]complex128, 
	incX:  i64, 
	beta:  ^complex128, 
	Y:     [^]complex128, 
	incY:  i64, 
) ---

    zhpr ¶
    Source

    zhpr :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: f64, 
	X:     [^]complex128, 
	incX:  i64, 
	A:     [^]complex128, 
) ---

    zhpr2 ¶
    Source

    zhpr2 :: proc "c" (
	order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	N:     i64, 
	alpha: ^complex128, 
	X:     [^]complex128, 
	incX:  i64, 
	Y:     [^]complex128, 
	incY:  i64, 
	Ap:    [^]complex128, 
) ---

    zimatcopy ¶
    Source

    zimatcopy :: proc "c" (
	CORDER: CBLAS_ORDER, 
	CTRANS: CBLAS_TRANSPOSE, 
	crows:  i64, 
	ccols:  i64, 
	calpha: ^complex128, 
	a:      [^]complex128, 
	clda:   i64, 
	cldb:   i64, 
) ---

    zomatcopy ¶
    Source

    zomatcopy :: proc "c" (
	CORDER: CBLAS_ORDER, 
	CTRANS: CBLAS_TRANSPOSE, 
	crows:  i64, 
	ccols:  i64, 
	calpha: ^complex128, 
	a:      [^]complex128, 
	clda:   i64, 
	b:      [^]complex128, 
	cldb:   i64, 
) ---

    zrotg ¶
    Source

    zrotg :: proc "c" (a: ^complex128, b: ^complex128, _c: ^f64, s: ^complex128) ---

    zscal ¶
    Source

    zscal :: proc "c" (N: i64, alpha: ^complex128, X: [^]complex128, incX: i64) ---

    zswap ¶
    Source

    zswap :: proc "c" (n: i64, x: [^]complex128, incx: i64, y: [^]complex128, incy: i64) ---

    zsymm ¶
    Source

    zsymm :: proc "c" (
	Order: CBLAS_ORDER, 
	Side:  CBLAS_SIDE, 
	Uplo:  CBLAS_UPLO, 
	M:     i64, 
	N:     i64, 
	alpha: ^complex128, 
	A:     [^]complex128, 
	lda:   i64, 
	B:     [^]complex128, 
	ldb:   i64, 
	beta:  ^complex128, 
	C:     [^]complex128, 
	ldc:   i64, 
) ---

    zsyr2k ¶
    Source

    zsyr2k :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: ^complex128, 
	A:     [^]complex128, 
	lda:   i64, 
	B:     [^]complex128, 
	ldb:   i64, 
	beta:  ^complex128, 
	C:     [^]complex128, 
	ldc:   i64, 
) ---

    zsyrk ¶
    Source

    zsyrk :: proc "c" (
	Order: CBLAS_ORDER, 
	Uplo:  CBLAS_UPLO, 
	Trans: CBLAS_TRANSPOSE, 
	N:     i64, 
	K:     i64, 
	alpha: ^complex128, 
	A:     [^]complex128, 
	lda:   i64, 
	beta:  ^complex128, 
	C:     [^]complex128, 
	ldc:   i64, 
) ---

    ztbmv ¶
    Source

    ztbmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	K:      i64, 
	A:      [^]complex128, 
	lda:    i64, 
	X:      [^]complex128, 
	incX:   i64, 
) ---

    ztbsv ¶
    Source

    ztbsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	K:      i64, 
	A:      [^]complex128, 
	lda:    i64, 
	X:      [^]complex128, 
	incX:   i64, 
) ---

    ztpmv ¶
    Source

    ztpmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	Ap:     [^]complex128, 
	X:      [^]complex128, 
	incX:   i64, 
) ---

    ztpsv ¶
    Source

    ztpsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	Ap:     [^]complex128, 
	X:      [^]complex128, 
	incX:   i64, 
) ---

    ztrmm ¶
    Source

    ztrmm :: proc "c" (
	Order:  CBLAS_ORDER, 
	Side:   CBLAS_SIDE, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	M:      i64, 
	N:      i64, 
	alpha:  ^complex128, 
	A:      [^]complex128, 
	lda:    i64, 
	B:      [^]complex128, 
	ldb:    i64, 
) ---

    ztrmv ¶
    Source

    ztrmv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	A:      [^]complex128, 
	lda:    i64, 
	X:      [^]complex128, 
	incX:   i64, 
) ---

    ztrsm ¶
    Source

    ztrsm :: proc "c" (
	Order:  CBLAS_ORDER, 
	Side:   CBLAS_SIDE, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	M:      i64, 
	N:      i64, 
	alpha:  ^complex128, 
	A:      [^]complex128, 
	lda:    i64, 
	B:      [^]complex128, 
	ldb:    i64, 
) ---

    ztrsv ¶
    Source

    ztrsv :: proc "c" (
	order:  CBLAS_ORDER, 
	Uplo:   CBLAS_UPLO, 
	TransA: CBLAS_TRANSPOSE, 
	Diag:   CBLAS_DIAG, 
	N:      i64, 
	A:      [^]complex128, 
	lda:    i64, 
	X:      [^]complex128, 
	incX:   i64, 
) ---

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2025-11 (vendor "odin") Linux_amd64 @ 2025-11-15 02:28:15.803652413 +0000 UTC