openblas_nolapack (JavaCPP Presets for OpenBLAS 0.3.9-1-1.5.3 API)

java.lang.Object
- org.bytedeco.openblas.presets.openblas_nolapack
- - org.bytedeco.openblas.global.openblas_nolapack

All Implemented Interfaces:: LoadEnabled, InfoMapper

public class openblas_nolapack
extends openblas_nolapack

Nested Class Summary
- Nested classes/interfaces inherited from class org.bytedeco.openblas.presets.openblas_nolapack
  openblas_nolapack.MklDomainSetNumThreads, openblas_nolapack.MklSetNumThreadsLocal, openblas_nolapack.SetNumThreads

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CblasColMajor` enum CBLAS_ORDER
`static int`	`CblasConjNoTrans` enum CBLAS_TRANSPOSE
`static int`	`CblasConjTrans` enum CBLAS_TRANSPOSE
`static int`	`CblasLeft` enum CBLAS_SIDE
`static int`	`CblasLower` enum CBLAS_UPLO
`static int`	`CblasNonUnit` enum CBLAS_DIAG
`static int`	`CblasNoTrans` enum CBLAS_TRANSPOSE
`static int`	`CblasRight` enum CBLAS_SIDE
`static int`	`CblasRowMajor` enum CBLAS_ORDER
`static int`	`CblasTrans` enum CBLAS_TRANSPOSE
`static int`	`CblasUnit` enum CBLAS_DIAG
`static int`	`CblasUpper` enum CBLAS_UPLO
`static int`	`OPENBLAS___64BIT__`
`static int`	`OPENBLAS_ARCH_X86_64`
`static int`	`OPENBLAS_C_GCC`
`static String`	`OPENBLAS_CHAR_CORENAME`
`static int`	`OPENBLAS_CLOCAL_BUFFER_SIZE`
`static int`	`OPENBLAS_DLOCAL_BUFFER_SIZE`
`static int`	`OPENBLAS_DTB_DEFAULT_ENTRIES`
`static int`	`OPENBLAS_DTB_SIZE`
`static int`	`OPENBLAS_GEMM_MULTITHREAD_THRESHOLD`
`static int`	`OPENBLAS_L1_DATA_LINESIZE`
`static int`	`OPENBLAS_L1_DATA_SIZE`
`static int`	`OPENBLAS_L2_LINESIZE`
`static int`	`OPENBLAS_L2_SIZE`
`static int`	`OPENBLAS_NEEDBUNDERSCORE`
`static int`	`OPENBLAS_OPENMP`
`static int`	`OPENBLAS_OS_DARWIN`
`static int`	`OPENBLAS_SEQUENTIAL`
`static int`	`OPENBLAS_SLOCAL_BUFFER_SIZE`
`static int`	`OPENBLAS_THREAD`
`static String`	`OPENBLAS_VERSION`
`static int`	`OPENBLAS_ZLOCAL_BUFFER_SIZE`

Constructor Summary

Constructors
Constructor and Description

openblas_nolapack()

Constructors
Constructor and Description
`openblas_nolapack()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`cblas_caxpy(int n, Pointer alpha, Pointer x, int incx, Pointer y, int incy)`
`static void`	`cblas_ccopy(int n, Pointer x, int incx, Pointer y, int incy)`
`static void`	`cblas_cdotc_sub(int n, Pointer x, int incx, Pointer y, int incy, Pointer ret)`
`static void`	`cblas_cdotu_sub(int n, Pointer x, int incx, Pointer y, int incy, Pointer ret)`
`static void`	`cblas_cgbmv(int order, int TransA, int M, int N, int KL, int KU, Pointer alpha, Pointer A, int lda, Pointer X, int incX, Pointer beta, Pointer Y, int incY)`
`static void`	`cblas_cgemm(int Order, int TransA, int TransB, int M, int N, int K, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_cgemv(int order, int trans, int m, int n, Pointer alpha, Pointer a, int lda, Pointer x, int incx, Pointer beta, Pointer y, int incy)`
`static void`	`cblas_cgerc(int order, int M, int N, Pointer alpha, Pointer X, int incX, Pointer Y, int incY, Pointer A, int lda)`
`static void`	`cblas_cgeru(int order, int M, int N, Pointer alpha, Pointer X, int incX, Pointer Y, int incY, Pointer A, int lda)`
`static void`	`cblas_chbmv(int order, int Uplo, int N, int K, Pointer alpha, Pointer A, int lda, Pointer X, int incX, Pointer beta, Pointer Y, int incY)`
`static void`	`cblas_chemm(int Order, int Side, int Uplo, int M, int N, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_chemv(int order, int Uplo, int N, Pointer alpha, Pointer A, int lda, Pointer X, int incX, Pointer beta, Pointer Y, int incY)`
`static void`	`cblas_cher(int order, int Uplo, int N, float alpha, Pointer X, int incX, Pointer A, int lda)`
`static void`	`cblas_cher2(int order, int Uplo, int N, Pointer alpha, Pointer X, int incX, Pointer Y, int incY, Pointer A, int lda)`
`static void`	`cblas_cher2k(int Order, int Uplo, int Trans, int N, int K, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, float beta, Pointer C, int ldc)`
`static void`	`cblas_cherk(int Order, int Uplo, int Trans, int N, int K, float alpha, Pointer A, int lda, float beta, Pointer C, int ldc)`
`static void`	`cblas_chpmv(int order, int Uplo, int N, Pointer alpha, Pointer Ap, Pointer X, int incX, Pointer beta, Pointer Y, int incY)`
`static void`	`cblas_chpr(int order, int Uplo, int N, float alpha, Pointer X, int incX, Pointer A)`
`static void`	`cblas_chpr2(int order, int Uplo, int N, Pointer alpha, Pointer X, int incX, Pointer Y, int incY, Pointer Ap)`
`static void`	`cblas_cscal(int N, Pointer alpha, Pointer X, int incX)`
`static void`	`cblas_csscal(int N, float alpha, Pointer X, int incX)`
`static void`	`cblas_cswap(int n, Pointer x, int incx, Pointer y, int incy)`
`static void`	`cblas_csymm(int Order, int Side, int Uplo, int M, int N, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_csyr2k(int Order, int Uplo, int Trans, int N, int K, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_csyrk(int Order, int Uplo, int Trans, int N, int K, Pointer alpha, Pointer A, int lda, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_ctbmv(int order, int Uplo, int TransA, int Diag, int N, int K, Pointer A, int lda, Pointer X, int incX)`
`static void`	`cblas_ctbsv(int order, int Uplo, int TransA, int Diag, int N, int K, Pointer A, int lda, Pointer X, int incX)`
`static void`	`cblas_ctpmv(int order, int Uplo, int TransA, int Diag, int N, Pointer Ap, Pointer X, int incX)`
`static void`	`cblas_ctpsv(int order, int Uplo, int TransA, int Diag, int N, Pointer Ap, Pointer X, int incX)`
`static void`	`cblas_ctrmm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, Pointer alpha, Pointer A, int lda, Pointer B, int ldb)`
`static void`	`cblas_ctrmv(int order, int Uplo, int TransA, int Diag, int N, Pointer A, int lda, Pointer X, int incX)`
`static void`	`cblas_ctrsm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, Pointer alpha, Pointer A, int lda, Pointer B, int ldb)`
`static void`	`cblas_ctrsv(int order, int Uplo, int TransA, int Diag, int N, Pointer A, int lda, Pointer X, int incX)`
`static double`	`cblas_dasum(int n, double[] x, int incx)`
`static double`	`cblas_dasum(int n, DoubleBuffer x, int incx)`
`static double`	`cblas_dasum(int n, DoublePointer x, int incx)`
`static void`	`cblas_daxpy(int n, double alpha, double[] x, int incx, double[] y, int incy)`
`static void`	`cblas_daxpy(int n, double alpha, DoubleBuffer x, int incx, DoubleBuffer y, int incy)`
`static void`	`cblas_daxpy(int n, double alpha, DoublePointer x, int incx, DoublePointer y, int incy)`
`static void`	`cblas_dcopy(int n, double[] x, int incx, double[] y, int incy)`
`static void`	`cblas_dcopy(int n, DoubleBuffer x, int incx, DoubleBuffer y, int incy)`
`static void`	`cblas_dcopy(int n, DoublePointer x, int incx, DoublePointer y, int incy)`
`static double`	`cblas_ddot(int n, double[] x, int incx, double[] y, int incy)`
`static double`	`cblas_ddot(int n, DoubleBuffer x, int incx, DoubleBuffer y, int incy)`
`static double`	`cblas_ddot(int n, DoublePointer x, int incx, DoublePointer y, int incy)`
`static void`	`cblas_dgbmv(int order, int TransA, int M, int N, int KL, int KU, double alpha, double[] A, int lda, double[] X, int incX, double beta, double[] Y, int incY)`
`static void`	`cblas_dgbmv(int order, int TransA, int M, int N, int KL, int KU, double alpha, DoubleBuffer A, int lda, DoubleBuffer X, int incX, double beta, DoubleBuffer Y, int incY)`
`static void`	`cblas_dgbmv(int order, int TransA, int M, int N, int KL, int KU, double alpha, DoublePointer A, int lda, DoublePointer X, int incX, double beta, DoublePointer Y, int incY)`
`static void`	`cblas_dgemm(int Order, int TransA, int TransB, int M, int N, int K, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc)`
`static void`	`cblas_dgemm(int Order, int TransA, int TransB, int M, int N, int K, double alpha, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, double beta, DoubleBuffer C, int ldc)`
`static void`	`cblas_dgemm(int Order, int TransA, int TransB, int M, int N, int K, double alpha, DoublePointer A, int lda, DoublePointer B, int ldb, double beta, DoublePointer C, int ldc)`
`static void`	`cblas_dgemv(int order, int trans, int m, int n, double alpha, double[] a, int lda, double[] x, int incx, double beta, double[] y, int incy)`
`static void`	`cblas_dgemv(int order, int trans, int m, int n, double alpha, DoubleBuffer a, int lda, DoubleBuffer x, int incx, double beta, DoubleBuffer y, int incy)`
`static void`	`cblas_dgemv(int order, int trans, int m, int n, double alpha, DoublePointer a, int lda, DoublePointer x, int incx, double beta, DoublePointer y, int incy)`
`static void`	`cblas_dger(int order, int M, int N, double alpha, double[] X, int incX, double[] Y, int incY, double[] A, int lda)`
`static void`	`cblas_dger(int order, int M, int N, double alpha, DoubleBuffer X, int incX, DoubleBuffer Y, int incY, DoubleBuffer A, int lda)`
`static void`	`cblas_dger(int order, int M, int N, double alpha, DoublePointer X, int incX, DoublePointer Y, int incY, DoublePointer A, int lda)`
`static double`	`cblas_dnrm2(int N, double[] X, int incX)`
`static double`	`cblas_dnrm2(int N, DoubleBuffer X, int incX)`
`static double`	`cblas_dnrm2(int N, DoublePointer X, int incX)`
`static void`	`cblas_drot(int N, double[] X, int incX, double[] Y, int incY, double c, double s)`
`static void`	`cblas_drot(int N, DoubleBuffer X, int incX, DoubleBuffer Y, int incY, double c, double s)`
`static void`	`cblas_drot(int N, DoublePointer X, int incX, DoublePointer Y, int incY, double c, double s)`
`static void`	`cblas_drotg(double[] a, double[] b, double[] c, double[] s)`
`static void`	`cblas_drotg(DoubleBuffer a, DoubleBuffer b, DoubleBuffer c, DoubleBuffer s)`
`static void`	`cblas_drotg(DoublePointer a, DoublePointer b, DoublePointer c, DoublePointer s)`
`static void`	`cblas_drotm(int N, double[] X, int incX, double[] Y, int incY, double[] P)`
`static void`	`cblas_drotm(int N, DoubleBuffer X, int incX, DoubleBuffer Y, int incY, DoubleBuffer P)`
`static void`	`cblas_drotm(int N, DoublePointer X, int incX, DoublePointer Y, int incY, DoublePointer P)`
`static void`	`cblas_drotmg(double[] d1, double[] d2, double[] b1, double b2, double[] P)`
`static void`	`cblas_drotmg(DoubleBuffer d1, DoubleBuffer d2, DoubleBuffer b1, double b2, DoubleBuffer P)`
`static void`	`cblas_drotmg(DoublePointer d1, DoublePointer d2, DoublePointer b1, double b2, DoublePointer P)`
`static void`	`cblas_dsbmv(int order, int Uplo, int N, int K, double alpha, double[] A, int lda, double[] X, int incX, double beta, double[] Y, int incY)`
`static void`	`cblas_dsbmv(int order, int Uplo, int N, int K, double alpha, DoubleBuffer A, int lda, DoubleBuffer X, int incX, double beta, DoubleBuffer Y, int incY)`
`static void`	`cblas_dsbmv(int order, int Uplo, int N, int K, double alpha, DoublePointer A, int lda, DoublePointer X, int incX, double beta, DoublePointer Y, int incY)`
`static void`	`cblas_dscal(int N, double alpha, double[] X, int incX)`
`static void`	`cblas_dscal(int N, double alpha, DoubleBuffer X, int incX)`
`static void`	`cblas_dscal(int N, double alpha, DoublePointer X, int incX)`
`static double`	`cblas_dsdot(int n, float[] x, int incx, float[] y, int incy)`
`static double`	`cblas_dsdot(int n, FloatBuffer x, int incx, FloatBuffer y, int incy)`
`static double`	`cblas_dsdot(int n, FloatPointer x, int incx, FloatPointer y, int incy)`
`static void`	`cblas_dspmv(int order, int Uplo, int N, double alpha, double[] Ap, double[] X, int incX, double beta, double[] Y, int incY)`
`static void`	`cblas_dspmv(int order, int Uplo, int N, double alpha, DoubleBuffer Ap, DoubleBuffer X, int incX, double beta, DoubleBuffer Y, int incY)`
`static void`	`cblas_dspmv(int order, int Uplo, int N, double alpha, DoublePointer Ap, DoublePointer X, int incX, double beta, DoublePointer Y, int incY)`
`static void`	`cblas_dspr(int order, int Uplo, int N, double alpha, double[] X, int incX, double[] Ap)`
`static void`	`cblas_dspr(int order, int Uplo, int N, double alpha, DoubleBuffer X, int incX, DoubleBuffer Ap)`
`static void`	`cblas_dspr(int order, int Uplo, int N, double alpha, DoublePointer X, int incX, DoublePointer Ap)`
`static void`	`cblas_dspr2(int order, int Uplo, int N, double alpha, double[] X, int incX, double[] Y, int incY, double[] A)`
`static void`	`cblas_dspr2(int order, int Uplo, int N, double alpha, DoubleBuffer X, int incX, DoubleBuffer Y, int incY, DoubleBuffer A)`
`static void`	`cblas_dspr2(int order, int Uplo, int N, double alpha, DoublePointer X, int incX, DoublePointer Y, int incY, DoublePointer A)`
`static void`	`cblas_dswap(int n, double[] x, int incx, double[] y, int incy)`
`static void`	`cblas_dswap(int n, DoubleBuffer x, int incx, DoubleBuffer y, int incy)`
`static void`	`cblas_dswap(int n, DoublePointer x, int incx, DoublePointer y, int incy)`
`static void`	`cblas_dsymm(int Order, int Side, int Uplo, int M, int N, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc)`
`static void`	`cblas_dsymm(int Order, int Side, int Uplo, int M, int N, double alpha, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, double beta, DoubleBuffer C, int ldc)`
`static void`	`cblas_dsymm(int Order, int Side, int Uplo, int M, int N, double alpha, DoublePointer A, int lda, DoublePointer B, int ldb, double beta, DoublePointer C, int ldc)`
`static void`	`cblas_dsymv(int order, int Uplo, int N, double alpha, double[] A, int lda, double[] X, int incX, double beta, double[] Y, int incY)`
`static void`	`cblas_dsymv(int order, int Uplo, int N, double alpha, DoubleBuffer A, int lda, DoubleBuffer X, int incX, double beta, DoubleBuffer Y, int incY)`
`static void`	`cblas_dsymv(int order, int Uplo, int N, double alpha, DoublePointer A, int lda, DoublePointer X, int incX, double beta, DoublePointer Y, int incY)`
`static void`	`cblas_dsyr(int order, int Uplo, int N, double alpha, double[] X, int incX, double[] A, int lda)`
`static void`	`cblas_dsyr(int order, int Uplo, int N, double alpha, DoubleBuffer X, int incX, DoubleBuffer A, int lda)`
`static void`	`cblas_dsyr(int order, int Uplo, int N, double alpha, DoublePointer X, int incX, DoublePointer A, int lda)`
`static void`	`cblas_dsyr2(int order, int Uplo, int N, double alpha, double[] X, int incX, double[] Y, int incY, double[] A, int lda)`
`static void`	`cblas_dsyr2(int order, int Uplo, int N, double alpha, DoubleBuffer X, int incX, DoubleBuffer Y, int incY, DoubleBuffer A, int lda)`
`static void`	`cblas_dsyr2(int order, int Uplo, int N, double alpha, DoublePointer X, int incX, DoublePointer Y, int incY, DoublePointer A, int lda)`
`static void`	`cblas_dsyr2k(int Order, int Uplo, int Trans, int N, int K, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc)`
`static void`	`cblas_dsyr2k(int Order, int Uplo, int Trans, int N, int K, double alpha, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, double beta, DoubleBuffer C, int ldc)`
`static void`	`cblas_dsyr2k(int Order, int Uplo, int Trans, int N, int K, double alpha, DoublePointer A, int lda, DoublePointer B, int ldb, double beta, DoublePointer C, int ldc)`
`static void`	`cblas_dsyrk(int Order, int Uplo, int Trans, int N, int K, double alpha, double[] A, int lda, double beta, double[] C, int ldc)`
`static void`	`cblas_dsyrk(int Order, int Uplo, int Trans, int N, int K, double alpha, DoubleBuffer A, int lda, double beta, DoubleBuffer C, int ldc)`
`static void`	`cblas_dsyrk(int Order, int Uplo, int Trans, int N, int K, double alpha, DoublePointer A, int lda, double beta, DoublePointer C, int ldc)`
`static void`	`cblas_dtbmv(int order, int Uplo, int TransA, int Diag, int N, int K, double[] A, int lda, double[] X, int incX)`
`static void`	`cblas_dtbmv(int order, int Uplo, int TransA, int Diag, int N, int K, DoubleBuffer A, int lda, DoubleBuffer X, int incX)`
`static void`	`cblas_dtbmv(int order, int Uplo, int TransA, int Diag, int N, int K, DoublePointer A, int lda, DoublePointer X, int incX)`
`static void`	`cblas_dtbsv(int order, int Uplo, int TransA, int Diag, int N, int K, double[] A, int lda, double[] X, int incX)`
`static void`	`cblas_dtbsv(int order, int Uplo, int TransA, int Diag, int N, int K, DoubleBuffer A, int lda, DoubleBuffer X, int incX)`
`static void`	`cblas_dtbsv(int order, int Uplo, int TransA, int Diag, int N, int K, DoublePointer A, int lda, DoublePointer X, int incX)`
`static void`	`cblas_dtpmv(int order, int Uplo, int TransA, int Diag, int N, double[] Ap, double[] X, int incX)`
`static void`	`cblas_dtpmv(int order, int Uplo, int TransA, int Diag, int N, DoubleBuffer Ap, DoubleBuffer X, int incX)`
`static void`	`cblas_dtpmv(int order, int Uplo, int TransA, int Diag, int N, DoublePointer Ap, DoublePointer X, int incX)`
`static void`	`cblas_dtpsv(int order, int Uplo, int TransA, int Diag, int N, double[] Ap, double[] X, int incX)`
`static void`	`cblas_dtpsv(int order, int Uplo, int TransA, int Diag, int N, DoubleBuffer Ap, DoubleBuffer X, int incX)`
`static void`	`cblas_dtpsv(int order, int Uplo, int TransA, int Diag, int N, DoublePointer Ap, DoublePointer X, int incX)`
`static void`	`cblas_dtrmm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, double alpha, double[] A, int lda, double[] B, int ldb)`
`static void`	`cblas_dtrmm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, double alpha, DoubleBuffer A, int lda, DoubleBuffer B, int ldb)`
`static void`	`cblas_dtrmm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, double alpha, DoublePointer A, int lda, DoublePointer B, int ldb)`
`static void`	`cblas_dtrmv(int order, int Uplo, int TransA, int Diag, int N, double[] A, int lda, double[] X, int incX)`
`static void`	`cblas_dtrmv(int order, int Uplo, int TransA, int Diag, int N, DoubleBuffer A, int lda, DoubleBuffer X, int incX)`
`static void`	`cblas_dtrmv(int order, int Uplo, int TransA, int Diag, int N, DoublePointer A, int lda, DoublePointer X, int incX)`
`static void`	`cblas_dtrsm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, double alpha, double[] A, int lda, double[] B, int ldb)`
`static void`	`cblas_dtrsm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, double alpha, DoubleBuffer A, int lda, DoubleBuffer B, int ldb)`
`static void`	`cblas_dtrsm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, double alpha, DoublePointer A, int lda, DoublePointer B, int ldb)`
`static void`	`cblas_dtrsv(int order, int Uplo, int TransA, int Diag, int N, double[] A, int lda, double[] X, int incX)`
`static void`	`cblas_dtrsv(int order, int Uplo, int TransA, int Diag, int N, DoubleBuffer A, int lda, DoubleBuffer X, int incX)`
`static void`	`cblas_dtrsv(int order, int Uplo, int TransA, int Diag, int N, DoublePointer A, int lda, DoublePointer X, int incX)`
`static double`	`cblas_dzasum(int n, Pointer x, int incx)`
`static double`	`cblas_dznrm2(int N, Pointer X, int incX)`
`static long`	`cblas_icamax(int n, Pointer x, int incx)`
`static long`	`cblas_idamax(int n, double[] x, int incx)`
`static long`	`cblas_idamax(int n, DoubleBuffer x, int incx)`
`static long`	`cblas_idamax(int n, DoublePointer x, int incx)`
`static long`	`cblas_isamax(int n, float[] x, int incx)`
`static long`	`cblas_isamax(int n, FloatBuffer x, int incx)`
`static long`	`cblas_isamax(int n, FloatPointer x, int incx)`
`static long`	`cblas_izamax(int n, Pointer x, int incx)`
`static float`	`cblas_sasum(int n, float[] x, int incx)`
`static float`	`cblas_sasum(int n, FloatBuffer x, int incx)`
`static float`	`cblas_sasum(int n, FloatPointer x, int incx)`
`static void`	`cblas_saxpy(int n, float alpha, float[] x, int incx, float[] y, int incy)`
`static void`	`cblas_saxpy(int n, float alpha, FloatBuffer x, int incx, FloatBuffer y, int incy)`
`static void`	`cblas_saxpy(int n, float alpha, FloatPointer x, int incx, FloatPointer y, int incy)`
`static float`	`cblas_scasum(int n, Pointer x, int incx)`
`static float`	`cblas_scnrm2(int N, Pointer X, int incX)`
`static void`	`cblas_scopy(int n, float[] x, int incx, float[] y, int incy)`
`static void`	`cblas_scopy(int n, FloatBuffer x, int incx, FloatBuffer y, int incy)`
`static void`	`cblas_scopy(int n, FloatPointer x, int incx, FloatPointer y, int incy)`
`static float`	`cblas_sdot(int n, float[] x, int incx, float[] y, int incy)`
`static float`	`cblas_sdot(int n, FloatBuffer x, int incx, FloatBuffer y, int incy)`
`static float`	`cblas_sdot(int n, FloatPointer x, int incx, FloatPointer y, int incy)`
`static float`	`cblas_sdsdot(int n, float alpha, float[] x, int incx, float[] y, int incy)`
`static float`	`cblas_sdsdot(int n, float alpha, FloatBuffer x, int incx, FloatBuffer y, int incy)`
`static float`	`cblas_sdsdot(int n, float alpha, FloatPointer x, int incx, FloatPointer y, int incy)`
`static void`	`cblas_sgbmv(int order, int TransA, int M, int N, int KL, int KU, float alpha, float[] A, int lda, float[] X, int incX, float beta, float[] Y, int incY)`
`static void`	`cblas_sgbmv(int order, int TransA, int M, int N, int KL, int KU, float alpha, FloatBuffer A, int lda, FloatBuffer X, int incX, float beta, FloatBuffer Y, int incY)`
`static void`	`cblas_sgbmv(int order, int TransA, int M, int N, int KL, int KU, float alpha, FloatPointer A, int lda, FloatPointer X, int incX, float beta, FloatPointer Y, int incY)`
`static void`	`cblas_sgemm(int Order, int TransA, int TransB, int M, int N, int K, float alpha, float[] A, int lda, float[] B, int ldb, float beta, float[] C, int ldc)`
`static void`	`cblas_sgemm(int Order, int TransA, int TransB, int M, int N, int K, float alpha, FloatBuffer A, int lda, FloatBuffer B, int ldb, float beta, FloatBuffer C, int ldc)`
`static void`	`cblas_sgemm(int Order, int TransA, int TransB, int M, int N, int K, float alpha, FloatPointer A, int lda, FloatPointer B, int ldb, float beta, FloatPointer C, int ldc)`
`static void`	`cblas_sgemv(int order, int trans, int m, int n, float alpha, float[] a, int lda, float[] x, int incx, float beta, float[] y, int incy)`
`static void`	`cblas_sgemv(int order, int trans, int m, int n, float alpha, FloatBuffer a, int lda, FloatBuffer x, int incx, float beta, FloatBuffer y, int incy)`
`static void`	`cblas_sgemv(int order, int trans, int m, int n, float alpha, FloatPointer a, int lda, FloatPointer x, int incx, float beta, FloatPointer y, int incy)`
`static void`	`cblas_sger(int order, int M, int N, float alpha, float[] X, int incX, float[] Y, int incY, float[] A, int lda)`
`static void`	`cblas_sger(int order, int M, int N, float alpha, FloatBuffer X, int incX, FloatBuffer Y, int incY, FloatBuffer A, int lda)`
`static void`	`cblas_sger(int order, int M, int N, float alpha, FloatPointer X, int incX, FloatPointer Y, int incY, FloatPointer A, int lda)`
`static float`	`cblas_snrm2(int N, float[] X, int incX)`
`static float`	`cblas_snrm2(int N, FloatBuffer X, int incX)`
`static float`	`cblas_snrm2(int N, FloatPointer X, int incX)`
`static void`	`cblas_srot(int N, float[] X, int incX, float[] Y, int incY, float c, float s)`
`static void`	`cblas_srot(int N, FloatBuffer X, int incX, FloatBuffer Y, int incY, float c, float s)`
`static void`	`cblas_srot(int N, FloatPointer X, int incX, FloatPointer Y, int incY, float c, float s)`
`static void`	`cblas_srotg(float[] a, float[] b, float[] c, float[] s)`
`static void`	`cblas_srotg(FloatBuffer a, FloatBuffer b, FloatBuffer c, FloatBuffer s)`
`static void`	`cblas_srotg(FloatPointer a, FloatPointer b, FloatPointer c, FloatPointer s)`
`static void`	`cblas_srotm(int N, float[] X, int incX, float[] Y, int incY, float[] P)`
`static void`	`cblas_srotm(int N, FloatBuffer X, int incX, FloatBuffer Y, int incY, FloatBuffer P)`
`static void`	`cblas_srotm(int N, FloatPointer X, int incX, FloatPointer Y, int incY, FloatPointer P)`
`static void`	`cblas_srotmg(float[] d1, float[] d2, float[] b1, float b2, float[] P)`
`static void`	`cblas_srotmg(FloatBuffer d1, FloatBuffer d2, FloatBuffer b1, float b2, FloatBuffer P)`
`static void`	`cblas_srotmg(FloatPointer d1, FloatPointer d2, FloatPointer b1, float b2, FloatPointer P)`
`static void`	`cblas_ssbmv(int order, int Uplo, int N, int K, float alpha, float[] A, int lda, float[] X, int incX, float beta, float[] Y, int incY)`
`static void`	`cblas_ssbmv(int order, int Uplo, int N, int K, float alpha, FloatBuffer A, int lda, FloatBuffer X, int incX, float beta, FloatBuffer Y, int incY)`
`static void`	`cblas_ssbmv(int order, int Uplo, int N, int K, float alpha, FloatPointer A, int lda, FloatPointer X, int incX, float beta, FloatPointer Y, int incY)`
`static void`	`cblas_sscal(int N, float alpha, float[] X, int incX)`
`static void`	`cblas_sscal(int N, float alpha, FloatBuffer X, int incX)`
`static void`	`cblas_sscal(int N, float alpha, FloatPointer X, int incX)`
`static void`	`cblas_sspmv(int order, int Uplo, int N, float alpha, float[] Ap, float[] X, int incX, float beta, float[] Y, int incY)`
`static void`	`cblas_sspmv(int order, int Uplo, int N, float alpha, FloatBuffer Ap, FloatBuffer X, int incX, float beta, FloatBuffer Y, int incY)`
`static void`	`cblas_sspmv(int order, int Uplo, int N, float alpha, FloatPointer Ap, FloatPointer X, int incX, float beta, FloatPointer Y, int incY)`
`static void`	`cblas_sspr(int order, int Uplo, int N, float alpha, float[] X, int incX, float[] Ap)`
`static void`	`cblas_sspr(int order, int Uplo, int N, float alpha, FloatBuffer X, int incX, FloatBuffer Ap)`
`static void`	`cblas_sspr(int order, int Uplo, int N, float alpha, FloatPointer X, int incX, FloatPointer Ap)`
`static void`	`cblas_sspr2(int order, int Uplo, int N, float alpha, float[] X, int incX, float[] Y, int incY, float[] A)`
`static void`	`cblas_sspr2(int order, int Uplo, int N, float alpha, FloatBuffer X, int incX, FloatBuffer Y, int incY, FloatBuffer A)`
`static void`	`cblas_sspr2(int order, int Uplo, int N, float alpha, FloatPointer X, int incX, FloatPointer Y, int incY, FloatPointer A)`
`static void`	`cblas_sswap(int n, float[] x, int incx, float[] y, int incy)`
`static void`	`cblas_sswap(int n, FloatBuffer x, int incx, FloatBuffer y, int incy)`
`static void`	`cblas_sswap(int n, FloatPointer x, int incx, FloatPointer y, int incy)`
`static void`	`cblas_ssymm(int Order, int Side, int Uplo, int M, int N, float alpha, float[] A, int lda, float[] B, int ldb, float beta, float[] C, int ldc)`
`static void`	`cblas_ssymm(int Order, int Side, int Uplo, int M, int N, float alpha, FloatBuffer A, int lda, FloatBuffer B, int ldb, float beta, FloatBuffer C, int ldc)`
`static void`	`cblas_ssymm(int Order, int Side, int Uplo, int M, int N, float alpha, FloatPointer A, int lda, FloatPointer B, int ldb, float beta, FloatPointer C, int ldc)`
`static void`	`cblas_ssymv(int order, int Uplo, int N, float alpha, float[] A, int lda, float[] X, int incX, float beta, float[] Y, int incY)`
`static void`	`cblas_ssymv(int order, int Uplo, int N, float alpha, FloatBuffer A, int lda, FloatBuffer X, int incX, float beta, FloatBuffer Y, int incY)`
`static void`	`cblas_ssymv(int order, int Uplo, int N, float alpha, FloatPointer A, int lda, FloatPointer X, int incX, float beta, FloatPointer Y, int incY)`
`static void`	`cblas_ssyr(int order, int Uplo, int N, float alpha, float[] X, int incX, float[] A, int lda)`
`static void`	`cblas_ssyr(int order, int Uplo, int N, float alpha, FloatBuffer X, int incX, FloatBuffer A, int lda)`
`static void`	`cblas_ssyr(int order, int Uplo, int N, float alpha, FloatPointer X, int incX, FloatPointer A, int lda)`
`static void`	`cblas_ssyr2(int order, int Uplo, int N, float alpha, float[] X, int incX, float[] Y, int incY, float[] A, int lda)`
`static void`	`cblas_ssyr2(int order, int Uplo, int N, float alpha, FloatBuffer X, int incX, FloatBuffer Y, int incY, FloatBuffer A, int lda)`
`static void`	`cblas_ssyr2(int order, int Uplo, int N, float alpha, FloatPointer X, int incX, FloatPointer Y, int incY, FloatPointer A, int lda)`
`static void`	`cblas_ssyr2k(int Order, int Uplo, int Trans, int N, int K, float alpha, float[] A, int lda, float[] B, int ldb, float beta, float[] C, int ldc)`
`static void`	`cblas_ssyr2k(int Order, int Uplo, int Trans, int N, int K, float alpha, FloatBuffer A, int lda, FloatBuffer B, int ldb, float beta, FloatBuffer C, int ldc)`
`static void`	`cblas_ssyr2k(int Order, int Uplo, int Trans, int N, int K, float alpha, FloatPointer A, int lda, FloatPointer B, int ldb, float beta, FloatPointer C, int ldc)`
`static void`	`cblas_ssyrk(int Order, int Uplo, int Trans, int N, int K, float alpha, float[] A, int lda, float beta, float[] C, int ldc)`
`static void`	`cblas_ssyrk(int Order, int Uplo, int Trans, int N, int K, float alpha, FloatBuffer A, int lda, float beta, FloatBuffer C, int ldc)`
`static void`	`cblas_ssyrk(int Order, int Uplo, int Trans, int N, int K, float alpha, FloatPointer A, int lda, float beta, FloatPointer C, int ldc)`
`static void`	`cblas_stbmv(int order, int Uplo, int TransA, int Diag, int N, int K, float[] A, int lda, float[] X, int incX)`
`static void`	`cblas_stbmv(int order, int Uplo, int TransA, int Diag, int N, int K, FloatBuffer A, int lda, FloatBuffer X, int incX)`
`static void`	`cblas_stbmv(int order, int Uplo, int TransA, int Diag, int N, int K, FloatPointer A, int lda, FloatPointer X, int incX)`
`static void`	`cblas_stbsv(int order, int Uplo, int TransA, int Diag, int N, int K, float[] A, int lda, float[] X, int incX)`
`static void`	`cblas_stbsv(int order, int Uplo, int TransA, int Diag, int N, int K, FloatBuffer A, int lda, FloatBuffer X, int incX)`
`static void`	`cblas_stbsv(int order, int Uplo, int TransA, int Diag, int N, int K, FloatPointer A, int lda, FloatPointer X, int incX)`
`static void`	`cblas_stpmv(int order, int Uplo, int TransA, int Diag, int N, float[] Ap, float[] X, int incX)`
`static void`	`cblas_stpmv(int order, int Uplo, int TransA, int Diag, int N, FloatBuffer Ap, FloatBuffer X, int incX)`
`static void`	`cblas_stpmv(int order, int Uplo, int TransA, int Diag, int N, FloatPointer Ap, FloatPointer X, int incX)`
`static void`	`cblas_stpsv(int order, int Uplo, int TransA, int Diag, int N, float[] Ap, float[] X, int incX)`
`static void`	`cblas_stpsv(int order, int Uplo, int TransA, int Diag, int N, FloatBuffer Ap, FloatBuffer X, int incX)`
`static void`	`cblas_stpsv(int order, int Uplo, int TransA, int Diag, int N, FloatPointer Ap, FloatPointer X, int incX)`
`static void`	`cblas_strmm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, float alpha, float[] A, int lda, float[] B, int ldb)`
`static void`	`cblas_strmm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, float alpha, FloatBuffer A, int lda, FloatBuffer B, int ldb)`
`static void`	`cblas_strmm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, float alpha, FloatPointer A, int lda, FloatPointer B, int ldb)`
`static void`	`cblas_strmv(int order, int Uplo, int TransA, int Diag, int N, float[] A, int lda, float[] X, int incX)`
`static void`	`cblas_strmv(int order, int Uplo, int TransA, int Diag, int N, FloatBuffer A, int lda, FloatBuffer X, int incX)`
`static void`	`cblas_strmv(int order, int Uplo, int TransA, int Diag, int N, FloatPointer A, int lda, FloatPointer X, int incX)`
`static void`	`cblas_strsm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, float alpha, float[] A, int lda, float[] B, int ldb)`
`static void`	`cblas_strsm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, float alpha, FloatBuffer A, int lda, FloatBuffer B, int ldb)`
`static void`	`cblas_strsm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, float alpha, FloatPointer A, int lda, FloatPointer B, int ldb)`
`static void`	`cblas_strsv(int order, int Uplo, int TransA, int Diag, int N, float[] A, int lda, float[] X, int incX)`
`static void`	`cblas_strsv(int order, int Uplo, int TransA, int Diag, int N, FloatBuffer A, int lda, FloatBuffer X, int incX)`
`static void`	`cblas_strsv(int order, int Uplo, int TransA, int Diag, int N, FloatPointer A, int lda, FloatPointer X, int incX)`
`static void`	`cblas_zaxpy(int n, Pointer alpha, Pointer x, int incx, Pointer y, int incy)`
`static void`	`cblas_zcopy(int n, Pointer x, int incx, Pointer y, int incy)`
`static void`	`cblas_zdotc_sub(int n, Pointer x, int incx, Pointer y, int incy, Pointer ret)`
`static void`	`cblas_zdotu_sub(int n, Pointer x, int incx, Pointer y, int incy, Pointer ret)`
`static void`	`cblas_zdscal(int N, double alpha, Pointer X, int incX)`
`static void`	`cblas_zgbmv(int order, int TransA, int M, int N, int KL, int KU, Pointer alpha, Pointer A, int lda, Pointer X, int incX, Pointer beta, Pointer Y, int incY)`
`static void`	`cblas_zgemm(int Order, int TransA, int TransB, int M, int N, int K, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_zgemv(int order, int trans, int m, int n, Pointer alpha, Pointer a, int lda, Pointer x, int incx, Pointer beta, Pointer y, int incy)`
`static void`	`cblas_zgerc(int order, int M, int N, Pointer alpha, Pointer X, int incX, Pointer Y, int incY, Pointer A, int lda)`
`static void`	`cblas_zgeru(int order, int M, int N, Pointer alpha, Pointer X, int incX, Pointer Y, int incY, Pointer A, int lda)`
`static void`	`cblas_zhbmv(int order, int Uplo, int N, int K, Pointer alpha, Pointer A, int lda, Pointer X, int incX, Pointer beta, Pointer Y, int incY)`
`static void`	`cblas_zhemm(int Order, int Side, int Uplo, int M, int N, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_zhemv(int order, int Uplo, int N, Pointer alpha, Pointer A, int lda, Pointer X, int incX, Pointer beta, Pointer Y, int incY)`
`static void`	`cblas_zher(int order, int Uplo, int N, double alpha, Pointer X, int incX, Pointer A, int lda)`
`static void`	`cblas_zher2(int order, int Uplo, int N, Pointer alpha, Pointer X, int incX, Pointer Y, int incY, Pointer A, int lda)`
`static void`	`cblas_zher2k(int Order, int Uplo, int Trans, int N, int K, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, double beta, Pointer C, int ldc)`
`static void`	`cblas_zherk(int Order, int Uplo, int Trans, int N, int K, double alpha, Pointer A, int lda, double beta, Pointer C, int ldc)`
`static void`	`cblas_zhpmv(int order, int Uplo, int N, Pointer alpha, Pointer Ap, Pointer X, int incX, Pointer beta, Pointer Y, int incY)`
`static void`	`cblas_zhpr(int order, int Uplo, int N, double alpha, Pointer X, int incX, Pointer A)`
`static void`	`cblas_zhpr2(int order, int Uplo, int N, Pointer alpha, Pointer X, int incX, Pointer Y, int incY, Pointer Ap)`
`static void`	`cblas_zscal(int N, Pointer alpha, Pointer X, int incX)`
`static void`	`cblas_zswap(int n, Pointer x, int incx, Pointer y, int incy)`
`static void`	`cblas_zsymm(int Order, int Side, int Uplo, int M, int N, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_zsyr2k(int Order, int Uplo, int Trans, int N, int K, Pointer alpha, Pointer A, int lda, Pointer B, int ldb, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_zsyrk(int Order, int Uplo, int Trans, int N, int K, Pointer alpha, Pointer A, int lda, Pointer beta, Pointer C, int ldc)`
`static void`	`cblas_ztbmv(int order, int Uplo, int TransA, int Diag, int N, int K, Pointer A, int lda, Pointer X, int incX)`
`static void`	`cblas_ztbsv(int order, int Uplo, int TransA, int Diag, int N, int K, Pointer A, int lda, Pointer X, int incX)`
`static void`	`cblas_ztpmv(int order, int Uplo, int TransA, int Diag, int N, Pointer Ap, Pointer X, int incX)`
`static void`	`cblas_ztpsv(int order, int Uplo, int TransA, int Diag, int N, Pointer Ap, Pointer X, int incX)`
`static void`	`cblas_ztrmm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, Pointer alpha, Pointer A, int lda, Pointer B, int ldb)`
`static void`	`cblas_ztrmv(int order, int Uplo, int TransA, int Diag, int N, Pointer A, int lda, Pointer X, int incX)`
`static void`	`cblas_ztrsm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, Pointer alpha, Pointer A, int lda, Pointer B, int ldb)`
`static void`	`cblas_ztrsv(int order, int Uplo, int TransA, int Diag, int N, Pointer A, int lda, Pointer X, int incX)`

Methods inherited from class org.bytedeco.openblas.presets.openblas_nolapack
blas_get_num_threads, blas_get_vendor, blas_set_num_threads, init, map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- OPENBLAS_OS_DARWIN
```
public static final int OPENBLAS_OS_DARWIN
```
  See Also:
  
  Constant Field Values
- OPENBLAS_ARCH_X86_64
```
public static final int OPENBLAS_ARCH_X86_64
```
  See Also:
  
  Constant Field Values
- OPENBLAS_C_GCC
```
public static final int OPENBLAS_C_GCC
```
  See Also:
  
  Constant Field Values
- OPENBLAS___64BIT__
```
public static final int OPENBLAS___64BIT__
```
  See Also:
  
  Constant Field Values
- OPENBLAS_NEEDBUNDERSCORE
```
public static final int OPENBLAS_NEEDBUNDERSCORE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_L1_DATA_SIZE
```
public static final int OPENBLAS_L1_DATA_SIZE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_L1_DATA_LINESIZE
```
public static final int OPENBLAS_L1_DATA_LINESIZE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_L2_SIZE
```
public static final int OPENBLAS_L2_SIZE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_L2_LINESIZE
```
public static final int OPENBLAS_L2_LINESIZE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_DTB_DEFAULT_ENTRIES
```
public static final int OPENBLAS_DTB_DEFAULT_ENTRIES
```
  See Also:
  
  Constant Field Values
- OPENBLAS_DTB_SIZE
```
public static final int OPENBLAS_DTB_SIZE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_CHAR_CORENAME
```
public static final String OPENBLAS_CHAR_CORENAME
```
  See Also:
  
  Constant Field Values
- OPENBLAS_SLOCAL_BUFFER_SIZE
```
public static final int OPENBLAS_SLOCAL_BUFFER_SIZE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_DLOCAL_BUFFER_SIZE
```
public static final int OPENBLAS_DLOCAL_BUFFER_SIZE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_CLOCAL_BUFFER_SIZE
```
public static final int OPENBLAS_CLOCAL_BUFFER_SIZE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_ZLOCAL_BUFFER_SIZE
```
public static final int OPENBLAS_ZLOCAL_BUFFER_SIZE
```
  See Also:
  
  Constant Field Values
- OPENBLAS_GEMM_MULTITHREAD_THRESHOLD
```
public static final int OPENBLAS_GEMM_MULTITHREAD_THRESHOLD
```
  See Also:
  
  Constant Field Values
- OPENBLAS_VERSION
```
public static final String OPENBLAS_VERSION
```
  See Also:
  
  Constant Field Values
- OPENBLAS_SEQUENTIAL
```
public static final int OPENBLAS_SEQUENTIAL
```
  See Also:
  
  Constant Field Values
- OPENBLAS_THREAD
```
public static final int OPENBLAS_THREAD
```
  See Also:
  
  Constant Field Values
- OPENBLAS_OPENMP
```
public static final int OPENBLAS_OPENMP
```
  See Also:
  
  Constant Field Values
- CblasRowMajor
```
public static final int CblasRowMajor
```
  enum CBLAS_ORDER
  
  See Also:
  
  Constant Field Values
- CblasColMajor
```
public static final int CblasColMajor
```
  enum CBLAS_ORDER
  
  See Also:
  
  Constant Field Values
- CblasNoTrans
```
public static final int CblasNoTrans
```
  enum CBLAS_TRANSPOSE
  
  See Also:
  
  Constant Field Values
- CblasTrans
```
public static final int CblasTrans
```
  enum CBLAS_TRANSPOSE
  
  See Also:
  
  Constant Field Values
- CblasConjTrans
```
public static final int CblasConjTrans
```
  enum CBLAS_TRANSPOSE
  
  See Also:
  
  Constant Field Values
- CblasConjNoTrans
```
public static final int CblasConjNoTrans
```
  enum CBLAS_TRANSPOSE
  
  See Also:
  
  Constant Field Values
- CblasUpper
```
public static final int CblasUpper
```
  enum CBLAS_UPLO
  
  See Also:
  
  Constant Field Values
- CblasLower
```
public static final int CblasLower
```
  enum CBLAS_UPLO
  
  See Also:
  
  Constant Field Values
- CblasNonUnit
```
public static final int CblasNonUnit
```
  enum CBLAS_DIAG
  
  See Also:
  
  Constant Field Values
- CblasUnit
```
public static final int CblasUnit
```
  enum CBLAS_DIAG
  
  See Also:
  
  Constant Field Values
- CblasLeft
```
public static final int CblasLeft
```
  enum CBLAS_SIDE
  
  See Also:
  
  Constant Field Values
- CblasRight
```
public static final int CblasRight
```
  enum CBLAS_SIDE
  
  See Also:
  
  Constant Field Values

Constructor Detail
- openblas_nolapack
```
public openblas_nolapack()
```

Method Detail

cblas_sdsdot

public static float cblas_sdsdot(@Cast(value="const blasint")
                                 int n,
                                 float alpha,
                                 @Const
                                 FloatPointer x,
                                 @Cast(value="const blasint")
                                 int incx,
                                 @Const
                                 FloatPointer y,
                                 @Cast(value="const blasint")
                                 int incy)

cblas_sdsdot

public static float cblas_sdsdot(@Cast(value="const blasint")
                                 int n,
                                 float alpha,
                                 @Const
                                 FloatBuffer x,
                                 @Cast(value="const blasint")
                                 int incx,
                                 @Const
                                 FloatBuffer y,
                                 @Cast(value="const blasint")
                                 int incy)

cblas_sdsdot

public static float cblas_sdsdot(@Cast(value="const blasint")
                                 int n,
                                 float alpha,
                                 @Const
                                 float[] x,
                                 @Cast(value="const blasint")
                                 int incx,
                                 @Const
                                 float[] y,
                                 @Cast(value="const blasint")
                                 int incy)

cblas_dsdot

public static double cblas_dsdot(@Cast(value="const blasint")
                                 int n,
                                 @Const
                                 FloatPointer x,
                                 @Cast(value="const blasint")
                                 int incx,
                                 @Const
                                 FloatPointer y,
                                 @Cast(value="const blasint")
                                 int incy)

cblas_dsdot

public static double cblas_dsdot(@Cast(value="const blasint")
                                 int n,
                                 @Const
                                 FloatBuffer x,
                                 @Cast(value="const blasint")
                                 int incx,
                                 @Const
                                 FloatBuffer y,
                                 @Cast(value="const blasint")
                                 int incy)

cblas_dsdot

public static double cblas_dsdot(@Cast(value="const blasint")
                                 int n,
                                 @Const
                                 float[] x,
                                 @Cast(value="const blasint")
                                 int incx,
                                 @Const
                                 float[] y,
                                 @Cast(value="const blasint")
                                 int incy)

cblas_sdot

public static float cblas_sdot(@Cast(value="const blasint")
                               int n,
                               @Const
                               FloatPointer x,
                               @Cast(value="const blasint")
                               int incx,
                               @Const
                               FloatPointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_sdot

public static float cblas_sdot(@Cast(value="const blasint")
                               int n,
                               @Const
                               FloatBuffer x,
                               @Cast(value="const blasint")
                               int incx,
                               @Const
                               FloatBuffer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_sdot

public static float cblas_sdot(@Cast(value="const blasint")
                               int n,
                               @Const
                               float[] x,
                               @Cast(value="const blasint")
                               int incx,
                               @Const
                               float[] y,
                               @Cast(value="const blasint")
                               int incy)

cblas_ddot

public static double cblas_ddot(@Cast(value="const blasint")
                                int n,
                                @Const
                                DoublePointer x,
                                @Cast(value="const blasint")
                                int incx,
                                @Const
                                DoublePointer y,
                                @Cast(value="const blasint")
                                int incy)

cblas_ddot

public static double cblas_ddot(@Cast(value="const blasint")
                                int n,
                                @Const
                                DoubleBuffer x,
                                @Cast(value="const blasint")
                                int incx,
                                @Const
                                DoubleBuffer y,
                                @Cast(value="const blasint")
                                int incy)

cblas_ddot

public static double cblas_ddot(@Cast(value="const blasint")
                                int n,
                                @Const
                                double[] x,
                                @Cast(value="const blasint")
                                int incx,
                                @Const
                                double[] y,
                                @Cast(value="const blasint")
                                int incy)

cblas_cdotu_sub

public static void cblas_cdotu_sub(@Cast(value="const blasint")
                                   int n,
                                   @Const
                                   Pointer x,
                                   @Cast(value="const blasint")
                                   int incx,
                                   @Const
                                   Pointer y,
                                   @Cast(value="const blasint")
                                   int incy,
                                   Pointer ret)

cblas_cdotc_sub

public static void cblas_cdotc_sub(@Cast(value="const blasint")
                                   int n,
                                   @Const
                                   Pointer x,
                                   @Cast(value="const blasint")
                                   int incx,
                                   @Const
                                   Pointer y,
                                   @Cast(value="const blasint")
                                   int incy,
                                   Pointer ret)

cblas_zdotu_sub

public static void cblas_zdotu_sub(@Cast(value="const blasint")
                                   int n,
                                   @Const
                                   Pointer x,
                                   @Cast(value="const blasint")
                                   int incx,
                                   @Const
                                   Pointer y,
                                   @Cast(value="const blasint")
                                   int incy,
                                   Pointer ret)

cblas_zdotc_sub

public static void cblas_zdotc_sub(@Cast(value="const blasint")
                                   int n,
                                   @Const
                                   Pointer x,
                                   @Cast(value="const blasint")
                                   int incx,
                                   @Const
                                   Pointer y,
                                   @Cast(value="const blasint")
                                   int incy,
                                   Pointer ret)

cblas_sasum

public static float cblas_sasum(@Cast(value="const blasint")
                                int n,
                                @Const
                                FloatPointer x,
                                @Cast(value="const blasint")
                                int incx)

cblas_sasum

public static float cblas_sasum(@Cast(value="const blasint")
                                int n,
                                @Const
                                FloatBuffer x,
                                @Cast(value="const blasint")
                                int incx)

cblas_sasum

public static float cblas_sasum(@Cast(value="const blasint")
                                int n,
                                @Const
                                float[] x,
                                @Cast(value="const blasint")
                                int incx)

cblas_dasum

public static double cblas_dasum(@Cast(value="const blasint")
                                 int n,
                                 @Const
                                 DoublePointer x,
                                 @Cast(value="const blasint")
                                 int incx)

cblas_dasum

public static double cblas_dasum(@Cast(value="const blasint")
                                 int n,
                                 @Const
                                 DoubleBuffer x,
                                 @Cast(value="const blasint")
                                 int incx)

cblas_dasum

public static double cblas_dasum(@Cast(value="const blasint")
                                 int n,
                                 @Const
                                 double[] x,
                                 @Cast(value="const blasint")
                                 int incx)

cblas_scasum

public static float cblas_scasum(@Cast(value="const blasint")
                                 int n,
                                 @Const
                                 Pointer x,
                                 @Cast(value="const blasint")
                                 int incx)

cblas_dzasum

public static double cblas_dzasum(@Cast(value="const blasint")
                                  int n,
                                  @Const
                                  Pointer x,
                                  @Cast(value="const blasint")
                                  int incx)

cblas_snrm2

public static float cblas_snrm2(@Cast(value="const blasint")
                                int N,
                                @Const
                                FloatPointer X,
                                @Cast(value="const blasint")
                                int incX)

cblas_snrm2

public static float cblas_snrm2(@Cast(value="const blasint")
                                int N,
                                @Const
                                FloatBuffer X,
                                @Cast(value="const blasint")
                                int incX)

cblas_snrm2

public static float cblas_snrm2(@Cast(value="const blasint")
                                int N,
                                @Const
                                float[] X,
                                @Cast(value="const blasint")
                                int incX)

cblas_dnrm2

public static double cblas_dnrm2(@Cast(value="const blasint")
                                 int N,
                                 @Const
                                 DoublePointer X,
                                 @Cast(value="const blasint")
                                 int incX)

cblas_dnrm2

public static double cblas_dnrm2(@Cast(value="const blasint")
                                 int N,
                                 @Const
                                 DoubleBuffer X,
                                 @Cast(value="const blasint")
                                 int incX)

cblas_dnrm2

public static double cblas_dnrm2(@Cast(value="const blasint")
                                 int N,
                                 @Const
                                 double[] X,
                                 @Cast(value="const blasint")
                                 int incX)

cblas_scnrm2

public static float cblas_scnrm2(@Cast(value="const blasint")
                                 int N,
                                 @Const
                                 Pointer X,
                                 @Cast(value="const blasint")
                                 int incX)

cblas_dznrm2

public static double cblas_dznrm2(@Cast(value="const blasint")
                                  int N,
                                  @Const
                                  Pointer X,
                                  @Cast(value="const blasint")
                                  int incX)

cblas_isamax

@Cast(value="size_t")
public static long cblas_isamax(@Cast(value="const blasint")
                                                      int n,
                                                      @Const
                                                      FloatPointer x,
                                                      @Cast(value="const blasint")
                                                      int incx)

cblas_isamax

@Cast(value="size_t")
public static long cblas_isamax(@Cast(value="const blasint")
                                                      int n,
                                                      @Const
                                                      FloatBuffer x,
                                                      @Cast(value="const blasint")
                                                      int incx)

cblas_isamax

@Cast(value="size_t")
public static long cblas_isamax(@Cast(value="const blasint")
                                                      int n,
                                                      @Const
                                                      float[] x,
                                                      @Cast(value="const blasint")
                                                      int incx)

cblas_idamax

@Cast(value="size_t")
public static long cblas_idamax(@Cast(value="const blasint")
                                                      int n,
                                                      @Const
                                                      DoublePointer x,
                                                      @Cast(value="const blasint")
                                                      int incx)

cblas_idamax

@Cast(value="size_t")
public static long cblas_idamax(@Cast(value="const blasint")
                                                      int n,
                                                      @Const
                                                      DoubleBuffer x,
                                                      @Cast(value="const blasint")
                                                      int incx)

cblas_idamax

@Cast(value="size_t")
public static long cblas_idamax(@Cast(value="const blasint")
                                                      int n,
                                                      @Const
                                                      double[] x,
                                                      @Cast(value="const blasint")
                                                      int incx)

cblas_icamax

@Cast(value="size_t")
public static long cblas_icamax(@Cast(value="const blasint")
                                                      int n,
                                                      @Const
                                                      Pointer x,
                                                      @Cast(value="const blasint")
                                                      int incx)

cblas_izamax

@Cast(value="size_t")
public static long cblas_izamax(@Cast(value="const blasint")
                                                      int n,
                                                      @Const
                                                      Pointer x,
                                                      @Cast(value="const blasint")
                                                      int incx)

cblas_saxpy

public static void cblas_saxpy(@Cast(value="const blasint")
                               int n,
                               float alpha,
                               @Const
                               FloatPointer x,
                               @Cast(value="const blasint")
                               int incx,
                               FloatPointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_saxpy

public static void cblas_saxpy(@Cast(value="const blasint")
                               int n,
                               float alpha,
                               @Const
                               FloatBuffer x,
                               @Cast(value="const blasint")
                               int incx,
                               FloatBuffer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_saxpy

public static void cblas_saxpy(@Cast(value="const blasint")
                               int n,
                               float alpha,
                               @Const
                               float[] x,
                               @Cast(value="const blasint")
                               int incx,
                               float[] y,
                               @Cast(value="const blasint")
                               int incy)

cblas_daxpy

public static void cblas_daxpy(@Cast(value="const blasint")
                               int n,
                               double alpha,
                               @Const
                               DoublePointer x,
                               @Cast(value="const blasint")
                               int incx,
                               DoublePointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_daxpy

public static void cblas_daxpy(@Cast(value="const blasint")
                               int n,
                               double alpha,
                               @Const
                               DoubleBuffer x,
                               @Cast(value="const blasint")
                               int incx,
                               DoubleBuffer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_daxpy

public static void cblas_daxpy(@Cast(value="const blasint")
                               int n,
                               double alpha,
                               @Const
                               double[] x,
                               @Cast(value="const blasint")
                               int incx,
                               double[] y,
                               @Cast(value="const blasint")
                               int incy)

cblas_caxpy

public static void cblas_caxpy(@Cast(value="const blasint")
                               int n,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer x,
                               @Cast(value="const blasint")
                               int incx,
                               Pointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_zaxpy

public static void cblas_zaxpy(@Cast(value="const blasint")
                               int n,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer x,
                               @Cast(value="const blasint")
                               int incx,
                               Pointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_scopy

public static void cblas_scopy(@Cast(value="const blasint")
                               int n,
                               @Const
                               FloatPointer x,
                               @Cast(value="const blasint")
                               int incx,
                               FloatPointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_scopy

public static void cblas_scopy(@Cast(value="const blasint")
                               int n,
                               @Const
                               FloatBuffer x,
                               @Cast(value="const blasint")
                               int incx,
                               FloatBuffer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_scopy

public static void cblas_scopy(@Cast(value="const blasint")
                               int n,
                               @Const
                               float[] x,
                               @Cast(value="const blasint")
                               int incx,
                               float[] y,
                               @Cast(value="const blasint")
                               int incy)

cblas_dcopy

public static void cblas_dcopy(@Cast(value="const blasint")
                               int n,
                               @Const
                               DoublePointer x,
                               @Cast(value="const blasint")
                               int incx,
                               DoublePointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_dcopy

public static void cblas_dcopy(@Cast(value="const blasint")
                               int n,
                               @Const
                               DoubleBuffer x,
                               @Cast(value="const blasint")
                               int incx,
                               DoubleBuffer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_dcopy

public static void cblas_dcopy(@Cast(value="const blasint")
                               int n,
                               @Const
                               double[] x,
                               @Cast(value="const blasint")
                               int incx,
                               double[] y,
                               @Cast(value="const blasint")
                               int incy)

cblas_ccopy

public static void cblas_ccopy(@Cast(value="const blasint")
                               int n,
                               @Const
                               Pointer x,
                               @Cast(value="const blasint")
                               int incx,
                               Pointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_zcopy

public static void cblas_zcopy(@Cast(value="const blasint")
                               int n,
                               @Const
                               Pointer x,
                               @Cast(value="const blasint")
                               int incx,
                               Pointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_sswap

public static void cblas_sswap(@Cast(value="const blasint")
                               int n,
                               FloatPointer x,
                               @Cast(value="const blasint")
                               int incx,
                               FloatPointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_sswap

public static void cblas_sswap(@Cast(value="const blasint")
                               int n,
                               FloatBuffer x,
                               @Cast(value="const blasint")
                               int incx,
                               FloatBuffer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_sswap

public static void cblas_sswap(@Cast(value="const blasint")
                               int n,
                               float[] x,
                               @Cast(value="const blasint")
                               int incx,
                               float[] y,
                               @Cast(value="const blasint")
                               int incy)

cblas_dswap

public static void cblas_dswap(@Cast(value="const blasint")
                               int n,
                               DoublePointer x,
                               @Cast(value="const blasint")
                               int incx,
                               DoublePointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_dswap

public static void cblas_dswap(@Cast(value="const blasint")
                               int n,
                               DoubleBuffer x,
                               @Cast(value="const blasint")
                               int incx,
                               DoubleBuffer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_dswap

public static void cblas_dswap(@Cast(value="const blasint")
                               int n,
                               double[] x,
                               @Cast(value="const blasint")
                               int incx,
                               double[] y,
                               @Cast(value="const blasint")
                               int incy)

cblas_cswap

public static void cblas_cswap(@Cast(value="const blasint")
                               int n,
                               Pointer x,
                               @Cast(value="const blasint")
                               int incx,
                               Pointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_zswap

public static void cblas_zswap(@Cast(value="const blasint")
                               int n,
                               Pointer x,
                               @Cast(value="const blasint")
                               int incx,
                               Pointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_srot

public static void cblas_srot(@Cast(value="const blasint")
                              int N,
                              FloatPointer X,
                              @Cast(value="const blasint")
                              int incX,
                              FloatPointer Y,
                              @Cast(value="const blasint")
                              int incY,
                              float c,
                              float s)

cblas_srot

public static void cblas_srot(@Cast(value="const blasint")
                              int N,
                              FloatBuffer X,
                              @Cast(value="const blasint")
                              int incX,
                              FloatBuffer Y,
                              @Cast(value="const blasint")
                              int incY,
                              float c,
                              float s)

cblas_srot

public static void cblas_srot(@Cast(value="const blasint")
                              int N,
                              float[] X,
                              @Cast(value="const blasint")
                              int incX,
                              float[] Y,
                              @Cast(value="const blasint")
                              int incY,
                              float c,
                              float s)

cblas_drot

public static void cblas_drot(@Cast(value="const blasint")
                              int N,
                              DoublePointer X,
                              @Cast(value="const blasint")
                              int incX,
                              DoublePointer Y,
                              @Cast(value="const blasint")
                              int incY,
                              double c,
                              double s)

cblas_drot

public static void cblas_drot(@Cast(value="const blasint")
                              int N,
                              DoubleBuffer X,
                              @Cast(value="const blasint")
                              int incX,
                              DoubleBuffer Y,
                              @Cast(value="const blasint")
                              int incY,
                              double c,
                              double s)

cblas_drot

public static void cblas_drot(@Cast(value="const blasint")
                              int N,
                              double[] X,
                              @Cast(value="const blasint")
                              int incX,
                              double[] Y,
                              @Cast(value="const blasint")
                              int incY,
                              double c,
                              double s)

cblas_srotg

public static void cblas_srotg(FloatPointer a,
                               FloatPointer b,
                               FloatPointer c,
                               FloatPointer s)

cblas_srotg

public static void cblas_srotg(FloatBuffer a,
                               FloatBuffer b,
                               FloatBuffer c,
                               FloatBuffer s)

cblas_srotg

public static void cblas_srotg(float[] a,
                               float[] b,
                               float[] c,
                               float[] s)

cblas_drotg

public static void cblas_drotg(DoublePointer a,
                               DoublePointer b,
                               DoublePointer c,
                               DoublePointer s)

cblas_drotg

public static void cblas_drotg(DoubleBuffer a,
                               DoubleBuffer b,
                               DoubleBuffer c,
                               DoubleBuffer s)

cblas_drotg

public static void cblas_drotg(double[] a,
                               double[] b,
                               double[] c,
                               double[] s)

cblas_srotm

public static void cblas_srotm(@Cast(value="const blasint")
                               int N,
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX,
                               FloatPointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               @Const
                               FloatPointer P)

cblas_srotm

public static void cblas_srotm(@Cast(value="const blasint")
                               int N,
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               FloatBuffer Y,
                               @Cast(value="const blasint")
                               int incY,
                               @Const
                               FloatBuffer P)

cblas_srotm

public static void cblas_srotm(@Cast(value="const blasint")
                               int N,
                               float[] X,
                               @Cast(value="const blasint")
                               int incX,
                               float[] Y,
                               @Cast(value="const blasint")
                               int incY,
                               @Const
                               float[] P)

cblas_drotm

public static void cblas_drotm(@Cast(value="const blasint")
                               int N,
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX,
                               DoublePointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               @Const
                               DoublePointer P)

cblas_drotm

public static void cblas_drotm(@Cast(value="const blasint")
                               int N,
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               DoubleBuffer Y,
                               @Cast(value="const blasint")
                               int incY,
                               @Const
                               DoubleBuffer P)

cblas_drotm

public static void cblas_drotm(@Cast(value="const blasint")
                               int N,
                               double[] X,
                               @Cast(value="const blasint")
                               int incX,
                               double[] Y,
                               @Cast(value="const blasint")
                               int incY,
                               @Const
                               double[] P)

cblas_srotmg

public static void cblas_srotmg(FloatPointer d1,
                                FloatPointer d2,
                                FloatPointer b1,
                                float b2,
                                FloatPointer P)

cblas_srotmg

public static void cblas_srotmg(FloatBuffer d1,
                                FloatBuffer d2,
                                FloatBuffer b1,
                                float b2,
                                FloatBuffer P)

cblas_srotmg

public static void cblas_srotmg(float[] d1,
                                float[] d2,
                                float[] b1,
                                float b2,
                                float[] P)

cblas_drotmg

public static void cblas_drotmg(DoublePointer d1,
                                DoublePointer d2,
                                DoublePointer b1,
                                double b2,
                                DoublePointer P)

cblas_drotmg

public static void cblas_drotmg(DoubleBuffer d1,
                                DoubleBuffer d2,
                                DoubleBuffer b1,
                                double b2,
                                DoubleBuffer P)

cblas_drotmg

public static void cblas_drotmg(double[] d1,
                                double[] d2,
                                double[] b1,
                                double b2,
                                double[] P)

cblas_sscal

public static void cblas_sscal(@Cast(value="const blasint")
                               int N,
                               float alpha,
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_sscal

public static void cblas_sscal(@Cast(value="const blasint")
                               int N,
                               float alpha,
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_sscal

public static void cblas_sscal(@Cast(value="const blasint")
                               int N,
                               float alpha,
                               float[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dscal

public static void cblas_dscal(@Cast(value="const blasint")
                               int N,
                               double alpha,
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dscal

public static void cblas_dscal(@Cast(value="const blasint")
                               int N,
                               double alpha,
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dscal

public static void cblas_dscal(@Cast(value="const blasint")
                               int N,
                               double alpha,
                               double[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_cscal

public static void cblas_cscal(@Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_zscal

public static void cblas_zscal(@Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_csscal

public static void cblas_csscal(@Cast(value="const blasint")
                                int N,
                                float alpha,
                                Pointer X,
                                @Cast(value="const blasint")
                                int incX)

cblas_zdscal

public static void cblas_zdscal(@Cast(value="const blasint")
                                int N,
                                double alpha,
                                Pointer X,
                                @Cast(value="const blasint")
                                int incX)

cblas_sgemv

public static void cblas_sgemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int trans,
                               @Cast(value="const blasint")
                               int m,
                               @Cast(value="const blasint")
                               int n,
                               float alpha,
                               @Const
                               FloatPointer a,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatPointer x,
                               @Cast(value="const blasint")
                               int incx,
                               float beta,
                               FloatPointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_sgemv

public static void cblas_sgemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int trans,
                               @Cast(value="const blasint")
                               int m,
                               @Cast(value="const blasint")
                               int n,
                               float alpha,
                               @Const
                               FloatBuffer a,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatBuffer x,
                               @Cast(value="const blasint")
                               int incx,
                               float beta,
                               FloatBuffer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_sgemv

public static void cblas_sgemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int trans,
                               @Cast(value="const blasint")
                               int m,
                               @Cast(value="const blasint")
                               int n,
                               float alpha,
                               @Const
                               float[] a,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               float[] x,
                               @Cast(value="const blasint")
                               int incx,
                               float beta,
                               float[] y,
                               @Cast(value="const blasint")
                               int incy)

cblas_dgemv

public static void cblas_dgemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int trans,
                               @Cast(value="const blasint")
                               int m,
                               @Cast(value="const blasint")
                               int n,
                               double alpha,
                               @Const
                               DoublePointer a,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoublePointer x,
                               @Cast(value="const blasint")
                               int incx,
                               double beta,
                               DoublePointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_dgemv

public static void cblas_dgemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int trans,
                               @Cast(value="const blasint")
                               int m,
                               @Cast(value="const blasint")
                               int n,
                               double alpha,
                               @Const
                               DoubleBuffer a,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoubleBuffer x,
                               @Cast(value="const blasint")
                               int incx,
                               double beta,
                               DoubleBuffer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_dgemv

public static void cblas_dgemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int trans,
                               @Cast(value="const blasint")
                               int m,
                               @Cast(value="const blasint")
                               int n,
                               double alpha,
                               @Const
                               double[] a,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               double[] x,
                               @Cast(value="const blasint")
                               int incx,
                               double beta,
                               double[] y,
                               @Cast(value="const blasint")
                               int incy)

cblas_cgemv

public static void cblas_cgemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int trans,
                               @Cast(value="const blasint")
                               int m,
                               @Cast(value="const blasint")
                               int n,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer a,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer x,
                               @Cast(value="const blasint")
                               int incx,
                               @Const
                               Pointer beta,
                               Pointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_zgemv

public static void cblas_zgemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int trans,
                               @Cast(value="const blasint")
                               int m,
                               @Cast(value="const blasint")
                               int n,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer a,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer x,
                               @Cast(value="const blasint")
                               int incx,
                               @Const
                               Pointer beta,
                               Pointer y,
                               @Cast(value="const blasint")
                               int incy)

cblas_sger

public static void cblas_sger(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const blasint")
                              int M,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              FloatPointer X,
                              @Cast(value="const blasint")
                              int incX,
                              @Const
                              FloatPointer Y,
                              @Cast(value="const blasint")
                              int incY,
                              FloatPointer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_sger

public static void cblas_sger(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const blasint")
                              int M,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              FloatBuffer X,
                              @Cast(value="const blasint")
                              int incX,
                              @Const
                              FloatBuffer Y,
                              @Cast(value="const blasint")
                              int incY,
                              FloatBuffer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_sger

public static void cblas_sger(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const blasint")
                              int M,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              float[] X,
                              @Cast(value="const blasint")
                              int incX,
                              @Const
                              float[] Y,
                              @Cast(value="const blasint")
                              int incY,
                              float[] A,
                              @Cast(value="const blasint")
                              int lda)

cblas_dger

public static void cblas_dger(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const blasint")
                              int M,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              DoublePointer X,
                              @Cast(value="const blasint")
                              int incX,
                              @Const
                              DoublePointer Y,
                              @Cast(value="const blasint")
                              int incY,
                              DoublePointer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_dger

public static void cblas_dger(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const blasint")
                              int M,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              DoubleBuffer X,
                              @Cast(value="const blasint")
                              int incX,
                              @Const
                              DoubleBuffer Y,
                              @Cast(value="const blasint")
                              int incY,
                              DoubleBuffer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_dger

public static void cblas_dger(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const blasint")
                              int M,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              double[] X,
                              @Cast(value="const blasint")
                              int incX,
                              @Const
                              double[] Y,
                              @Cast(value="const blasint")
                              int incY,
                              double[] A,
                              @Cast(value="const blasint")
                              int lda)

cblas_cgeru

public static void cblas_cgeru(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_cgerc

public static void cblas_cgerc(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_zgeru

public static void cblas_zgeru(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_zgerc

public static void cblas_zgerc(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_strsv

public static void cblas_strsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_strsv

public static void cblas_strsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_strsv

public static void cblas_strsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               float[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtrsv

public static void cblas_dtrsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtrsv

public static void cblas_dtrsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtrsv

public static void cblas_dtrsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               double[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ctrsv

public static void cblas_ctrsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ztrsv

public static void cblas_ztrsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_strmv

public static void cblas_strmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_strmv

public static void cblas_strmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_strmv

public static void cblas_strmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               float[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtrmv

public static void cblas_dtrmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtrmv

public static void cblas_dtrmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtrmv

public static void cblas_dtrmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               double[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ctrmv

public static void cblas_ctrmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ztrmv

public static void cblas_ztrmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ssyr

public static void cblas_ssyr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              FloatPointer X,
                              @Cast(value="const blasint")
                              int incX,
                              FloatPointer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_ssyr

public static void cblas_ssyr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              FloatBuffer X,
                              @Cast(value="const blasint")
                              int incX,
                              FloatBuffer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_ssyr

public static void cblas_ssyr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              float[] X,
                              @Cast(value="const blasint")
                              int incX,
                              float[] A,
                              @Cast(value="const blasint")
                              int lda)

cblas_dsyr

public static void cblas_dsyr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              DoublePointer X,
                              @Cast(value="const blasint")
                              int incX,
                              DoublePointer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_dsyr

public static void cblas_dsyr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              DoubleBuffer X,
                              @Cast(value="const blasint")
                              int incX,
                              DoubleBuffer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_dsyr

public static void cblas_dsyr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              double[] X,
                              @Cast(value="const blasint")
                              int incX,
                              double[] A,
                              @Cast(value="const blasint")
                              int lda)

cblas_cher

public static void cblas_cher(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              Pointer X,
                              @Cast(value="const blasint")
                              int incX,
                              Pointer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_zher

public static void cblas_zher(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              Pointer X,
                              @Cast(value="const blasint")
                              int incX,
                              Pointer A,
                              @Cast(value="const blasint")
                              int lda)

cblas_ssyr2

public static void cblas_ssyr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               FloatPointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_ssyr2

public static void cblas_ssyr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               FloatBuffer Y,
                               @Cast(value="const blasint")
                               int incY,
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_ssyr2

public static void cblas_ssyr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               float[] X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               float[] Y,
                               @Cast(value="const blasint")
                               int incY,
                               float[] A,
                               @Cast(value="const blasint")
                               int lda)

cblas_dsyr2

public static void cblas_dsyr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               DoublePointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_dsyr2

public static void cblas_dsyr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               DoubleBuffer Y,
                               @Cast(value="const blasint")
                               int incY,
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_dsyr2

public static void cblas_dsyr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               double[] X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               double[] Y,
                               @Cast(value="const blasint")
                               int incY,
                               double[] A,
                               @Cast(value="const blasint")
                               int lda)

cblas_cher2

public static void cblas_cher2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_zher2

public static void cblas_zher2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda)

cblas_sgbmv

public static void cblas_sgbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int KL,
                               @Cast(value="const blasint")
                               int KU,
                               float alpha,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               FloatPointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_sgbmv

public static void cblas_sgbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int KL,
                               @Cast(value="const blasint")
                               int KU,
                               float alpha,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               FloatBuffer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_sgbmv

public static void cblas_sgbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int KL,
                               @Cast(value="const blasint")
                               int KU,
                               float alpha,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               float[] X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               float[] Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dgbmv

public static void cblas_dgbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int KL,
                               @Cast(value="const blasint")
                               int KU,
                               double alpha,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               DoublePointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dgbmv

public static void cblas_dgbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int KL,
                               @Cast(value="const blasint")
                               int KU,
                               double alpha,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               DoubleBuffer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dgbmv

public static void cblas_dgbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int KL,
                               @Cast(value="const blasint")
                               int KU,
                               double alpha,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               double[] X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               double[] Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_cgbmv

public static void cblas_cgbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int KL,
                               @Cast(value="const blasint")
                               int KU,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer beta,
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_zgbmv

public static void cblas_zgbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int KL,
                               @Cast(value="const blasint")
                               int KU,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer beta,
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_ssbmv

public static void cblas_ssbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               FloatPointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_ssbmv

public static void cblas_ssbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               FloatBuffer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_ssbmv

public static void cblas_ssbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               float[] X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               float[] Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dsbmv

public static void cblas_dsbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               DoublePointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dsbmv

public static void cblas_dsbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               DoubleBuffer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dsbmv

public static void cblas_dsbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               double[] X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               double[] Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_stbmv

public static void cblas_stbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stbmv

public static void cblas_stbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stbmv

public static void cblas_stbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               float[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtbmv

public static void cblas_dtbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtbmv

public static void cblas_dtbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtbmv

public static void cblas_dtbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               double[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ctbmv

public static void cblas_ctbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ztbmv

public static void cblas_ztbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stbsv

public static void cblas_stbsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stbsv

public static void cblas_stbsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stbsv

public static void cblas_stbsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               float[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtbsv

public static void cblas_dtbsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtbsv

public static void cblas_dtbsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtbsv

public static void cblas_dtbsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               double[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ctbsv

public static void cblas_ctbsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ztbsv

public static void cblas_ztbsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stpmv

public static void cblas_stpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               FloatPointer Ap,
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stpmv

public static void cblas_stpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               FloatBuffer Ap,
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stpmv

public static void cblas_stpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               float[] Ap,
                               float[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtpmv

public static void cblas_dtpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               DoublePointer Ap,
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtpmv

public static void cblas_dtpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               DoubleBuffer Ap,
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtpmv

public static void cblas_dtpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               double[] Ap,
                               double[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ctpmv

public static void cblas_ctpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer Ap,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ztpmv

public static void cblas_ztpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer Ap,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stpsv

public static void cblas_stpsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               FloatPointer Ap,
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stpsv

public static void cblas_stpsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               FloatBuffer Ap,
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_stpsv

public static void cblas_stpsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               float[] Ap,
                               float[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtpsv

public static void cblas_dtpsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               DoublePointer Ap,
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtpsv

public static void cblas_dtpsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               DoubleBuffer Ap,
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_dtpsv

public static void cblas_dtpsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               double[] Ap,
                               double[] X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ctpsv

public static void cblas_ctpsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer Ap,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ztpsv

public static void cblas_ztpsv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer Ap,
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX)

cblas_ssymv

public static void cblas_ssymv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               FloatPointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_ssymv

public static void cblas_ssymv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               FloatBuffer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_ssymv

public static void cblas_ssymv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               float[] X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               float[] Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dsymv

public static void cblas_dsymv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               DoublePointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dsymv

public static void cblas_dsymv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               DoubleBuffer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dsymv

public static void cblas_dsymv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               double[] X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               double[] Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_chemv

public static void cblas_chemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer beta,
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_zhemv

public static void cblas_zhemv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer beta,
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_sspmv

public static void cblas_sspmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatPointer Ap,
                               @Const
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               FloatPointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_sspmv

public static void cblas_sspmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatBuffer Ap,
                               @Const
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               FloatBuffer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_sspmv

public static void cblas_sspmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               float[] Ap,
                               @Const
                               float[] X,
                               @Cast(value="const blasint")
                               int incX,
                               float beta,
                               float[] Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dspmv

public static void cblas_dspmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoublePointer Ap,
                               @Const
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               DoublePointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dspmv

public static void cblas_dspmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoubleBuffer Ap,
                               @Const
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               DoubleBuffer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_dspmv

public static void cblas_dspmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               double[] Ap,
                               @Const
                               double[] X,
                               @Cast(value="const blasint")
                               int incX,
                               double beta,
                               double[] Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_sspr

public static void cblas_sspr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              FloatPointer X,
                              @Cast(value="const blasint")
                              int incX,
                              FloatPointer Ap)

cblas_sspr

public static void cblas_sspr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              FloatBuffer X,
                              @Cast(value="const blasint")
                              int incX,
                              FloatBuffer Ap)

cblas_sspr

public static void cblas_sspr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              float[] X,
                              @Cast(value="const blasint")
                              int incX,
                              float[] Ap)

cblas_dspr

public static void cblas_dspr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              DoublePointer X,
                              @Cast(value="const blasint")
                              int incX,
                              DoublePointer Ap)

cblas_dspr

public static void cblas_dspr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              DoubleBuffer X,
                              @Cast(value="const blasint")
                              int incX,
                              DoubleBuffer Ap)

cblas_dspr

public static void cblas_dspr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              double[] X,
                              @Cast(value="const blasint")
                              int incX,
                              double[] Ap)

cblas_chpr

public static void cblas_chpr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              float alpha,
                              @Const
                              Pointer X,
                              @Cast(value="const blasint")
                              int incX,
                              Pointer A)

cblas_zhpr

public static void cblas_zhpr(@Cast(value="const CBLAS_ORDER")
                              int order,
                              @Cast(value="const CBLAS_UPLO")
                              int Uplo,
                              @Cast(value="const blasint")
                              int N,
                              double alpha,
                              @Const
                              Pointer X,
                              @Cast(value="const blasint")
                              int incX,
                              Pointer A)

cblas_sspr2

public static void cblas_sspr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatPointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               FloatPointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               FloatPointer A)

cblas_sspr2

public static void cblas_sspr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               FloatBuffer Y,
                               @Cast(value="const blasint")
                               int incY,
                               FloatBuffer A)

cblas_sspr2

public static void cblas_sspr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               float[] X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               float[] Y,
                               @Cast(value="const blasint")
                               int incY,
                               float[] A)

cblas_dspr2

public static void cblas_dspr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoublePointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               DoublePointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               DoublePointer A)

cblas_dspr2

public static void cblas_dspr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoubleBuffer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               DoubleBuffer Y,
                               @Cast(value="const blasint")
                               int incY,
                               DoubleBuffer A)

cblas_dspr2

public static void cblas_dspr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               double[] X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               double[] Y,
                               @Cast(value="const blasint")
                               int incY,
                               double[] A)

cblas_chpr2

public static void cblas_chpr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               Pointer Ap)

cblas_zhpr2

public static void cblas_zhpr2(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY,
                               Pointer Ap)

cblas_chbmv

public static void cblas_chbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer beta,
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_zhbmv

public static void cblas_zhbmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer beta,
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_chpmv

public static void cblas_chpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer Ap,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer beta,
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_zhpmv

public static void cblas_zhpmv(@Cast(value="const CBLAS_ORDER")
                               int order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer Ap,
                               @Const
                               Pointer X,
                               @Cast(value="const blasint")
                               int incX,
                               @Const
                               Pointer beta,
                               Pointer Y,
                               @Cast(value="const blasint")
                               int incY)

cblas_sgemm

public static void cblas_sgemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransB,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatPointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               float beta,
                               FloatPointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_sgemm

public static void cblas_sgemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransB,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatBuffer B,
                               @Cast(value="const blasint")
                               int ldb,
                               float beta,
                               FloatBuffer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_sgemm

public static void cblas_sgemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransB,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               float[] B,
                               @Cast(value="const blasint")
                               int ldb,
                               float beta,
                               float[] C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_dgemm

public static void cblas_dgemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransB,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoublePointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               double beta,
                               DoublePointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_dgemm

public static void cblas_dgemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransB,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoubleBuffer B,
                               @Cast(value="const blasint")
                               int ldb,
                               double beta,
                               DoubleBuffer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_dgemm

public static void cblas_dgemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransB,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               double[] B,
                               @Cast(value="const blasint")
                               int ldb,
                               double beta,
                               double[] C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_cgemm

public static void cblas_cgemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransB,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               @Const
                               Pointer beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_zgemm

public static void cblas_zgemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransB,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               @Const
                               Pointer beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_ssymm

public static void cblas_ssymm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatPointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               float beta,
                               FloatPointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_ssymm

public static void cblas_ssymm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               FloatBuffer B,
                               @Cast(value="const blasint")
                               int ldb,
                               float beta,
                               FloatBuffer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_ssymm

public static void cblas_ssymm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               float[] B,
                               @Cast(value="const blasint")
                               int ldb,
                               float beta,
                               float[] C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_dsymm

public static void cblas_dsymm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoublePointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               double beta,
                               DoublePointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_dsymm

public static void cblas_dsymm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               DoubleBuffer B,
                               @Cast(value="const blasint")
                               int ldb,
                               double beta,
                               DoubleBuffer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_dsymm

public static void cblas_dsymm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               double[] B,
                               @Cast(value="const blasint")
                               int ldb,
                               double beta,
                               double[] C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_csymm

public static void cblas_csymm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               @Const
                               Pointer beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_zsymm

public static void cblas_zsymm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               @Const
                               Pointer beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_ssyrk

public static void cblas_ssyrk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               float beta,
                               FloatPointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_ssyrk

public static void cblas_ssyrk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               float beta,
                               FloatBuffer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_ssyrk

public static void cblas_ssyrk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               float beta,
                               float[] C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_dsyrk

public static void cblas_dsyrk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               double beta,
                               DoublePointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_dsyrk

public static void cblas_dsyrk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               double beta,
                               DoubleBuffer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_dsyrk

public static void cblas_dsyrk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               double beta,
                               double[] C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_csyrk

public static void cblas_csyrk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_zsyrk

public static void cblas_zsyrk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_ssyr2k

public static void cblas_ssyr2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                float alpha,
                                @Const
                                FloatPointer A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                FloatPointer B,
                                @Cast(value="const blasint")
                                int ldb,
                                float beta,
                                FloatPointer C,
                                @Cast(value="const blasint")
                                int ldc)

cblas_ssyr2k

public static void cblas_ssyr2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                float alpha,
                                @Const
                                FloatBuffer A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                FloatBuffer B,
                                @Cast(value="const blasint")
                                int ldb,
                                float beta,
                                FloatBuffer C,
                                @Cast(value="const blasint")
                                int ldc)

cblas_ssyr2k

public static void cblas_ssyr2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                float alpha,
                                @Const
                                float[] A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                float[] B,
                                @Cast(value="const blasint")
                                int ldb,
                                float beta,
                                float[] C,
                                @Cast(value="const blasint")
                                int ldc)

cblas_dsyr2k

public static void cblas_dsyr2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                double alpha,
                                @Const
                                DoublePointer A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                DoublePointer B,
                                @Cast(value="const blasint")
                                int ldb,
                                double beta,
                                DoublePointer C,
                                @Cast(value="const blasint")
                                int ldc)

cblas_dsyr2k

public static void cblas_dsyr2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                double alpha,
                                @Const
                                DoubleBuffer A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                DoubleBuffer B,
                                @Cast(value="const blasint")
                                int ldb,
                                double beta,
                                DoubleBuffer C,
                                @Cast(value="const blasint")
                                int ldc)

cblas_dsyr2k

public static void cblas_dsyr2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                double alpha,
                                @Const
                                double[] A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                double[] B,
                                @Cast(value="const blasint")
                                int ldb,
                                double beta,
                                double[] C,
                                @Cast(value="const blasint")
                                int ldc)

cblas_csyr2k

public static void cblas_csyr2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                @Const
                                Pointer alpha,
                                @Const
                                Pointer A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                Pointer B,
                                @Cast(value="const blasint")
                                int ldb,
                                @Const
                                Pointer beta,
                                Pointer C,
                                @Cast(value="const blasint")
                                int ldc)

cblas_zsyr2k

public static void cblas_zsyr2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                @Const
                                Pointer alpha,
                                @Const
                                Pointer A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                Pointer B,
                                @Cast(value="const blasint")
                                int ldb,
                                @Const
                                Pointer beta,
                                Pointer C,
                                @Cast(value="const blasint")
                                int ldc)

cblas_strmm

public static void cblas_strmm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatPointer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_strmm

public static void cblas_strmm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatBuffer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_strmm

public static void cblas_strmm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               float[] B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_dtrmm

public static void cblas_dtrmm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoublePointer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_dtrmm

public static void cblas_dtrmm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoubleBuffer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_dtrmm

public static void cblas_dtrmm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               double[] B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_ctrmm

public static void cblas_ctrmm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_ztrmm

public static void cblas_ztrmm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_strsm

public static void cblas_strsm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatPointer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatPointer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_strsm

public static void cblas_strsm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               FloatBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               FloatBuffer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_strsm

public static void cblas_strsm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               float alpha,
                               @Const
                               float[] A,
                               @Cast(value="const blasint")
                               int lda,
                               float[] B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_dtrsm

public static void cblas_dtrsm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoublePointer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoublePointer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_dtrsm

public static void cblas_dtrsm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               DoubleBuffer A,
                               @Cast(value="const blasint")
                               int lda,
                               DoubleBuffer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_dtrsm

public static void cblas_dtrsm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               double alpha,
                               @Const
                               double[] A,
                               @Cast(value="const blasint")
                               int lda,
                               double[] B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_ctrsm

public static void cblas_ctrsm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_ztrsm

public static void cblas_ztrsm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int TransA,
                               @Cast(value="const CBLAS_DIAG")
                               int Diag,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb)

cblas_chemm

public static void cblas_chemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               @Const
                               Pointer beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_zhemm

public static void cblas_zhemm(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_SIDE")
                               int Side,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const blasint")
                               int M,
                               @Cast(value="const blasint")
                               int N,
                               @Const
                               Pointer alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               @Const
                               Pointer B,
                               @Cast(value="const blasint")
                               int ldb,
                               @Const
                               Pointer beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_cherk

public static void cblas_cherk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               float alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               float beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_zherk

public static void cblas_zherk(@Cast(value="const CBLAS_ORDER")
                               int Order,
                               @Cast(value="const CBLAS_UPLO")
                               int Uplo,
                               @Cast(value="const CBLAS_TRANSPOSE")
                               int Trans,
                               @Cast(value="const blasint")
                               int N,
                               @Cast(value="const blasint")
                               int K,
                               double alpha,
                               @Const
                               Pointer A,
                               @Cast(value="const blasint")
                               int lda,
                               double beta,
                               Pointer C,
                               @Cast(value="const blasint")
                               int ldc)

cblas_cher2k

public static void cblas_cher2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                @Const
                                Pointer alpha,
                                @Const
                                Pointer A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                Pointer B,
                                @Cast(value="const blasint")
                                int ldb,
                                float beta,
                                Pointer C,
                                @Cast(value="const blasint")
                                int ldc)

cblas_zher2k

public static void cblas_zher2k(@Cast(value="const CBLAS_ORDER")
                                int Order,
                                @Cast(value="const CBLAS_UPLO")
                                int Uplo,
                                @Cast(value="const CBLAS_TRANSPOSE")
                                int Trans,
                                @Cast(value="const blasint")
                                int N,
                                @Cast(value="const blasint")
                                int K,
                                @Const
                                Pointer alpha,
                                @Const
                                Pointer A,
                                @Cast(value="const blasint")
                                int lda,
                                @Const
                                Pointer B,
                                @Cast(value="const blasint")
                                int ldb,
                                double beta,
                                Pointer C,
                                @Cast(value="const blasint")
                                int ldc)

Class openblas_nolapack

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.openblas.presets.openblas_nolapack

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.openblas.presets.openblas_nolapack

Methods inherited from class java.lang.Object

Field Detail

OPENBLAS_OS_DARWIN

OPENBLAS_ARCH_X86_64

OPENBLAS_C_GCC

OPENBLAS___64BIT__

OPENBLAS_NEEDBUNDERSCORE

OPENBLAS_L1_DATA_SIZE

OPENBLAS_L1_DATA_LINESIZE

OPENBLAS_L2_SIZE

OPENBLAS_L2_LINESIZE

OPENBLAS_DTB_DEFAULT_ENTRIES

OPENBLAS_DTB_SIZE

OPENBLAS_CHAR_CORENAME

OPENBLAS_SLOCAL_BUFFER_SIZE

OPENBLAS_DLOCAL_BUFFER_SIZE

OPENBLAS_CLOCAL_BUFFER_SIZE

OPENBLAS_ZLOCAL_BUFFER_SIZE

OPENBLAS_GEMM_MULTITHREAD_THRESHOLD

OPENBLAS_VERSION

OPENBLAS_SEQUENTIAL

OPENBLAS_THREAD

OPENBLAS_OPENMP

CblasRowMajor

CblasColMajor

CblasNoTrans

CblasTrans

CblasConjTrans

CblasConjNoTrans

CblasUpper

CblasLower

CblasNonUnit

CblasUnit

CblasLeft

CblasRight

Constructor Detail

openblas_nolapack

Method Detail

cblas_sdsdot

cblas_sdsdot

cblas_sdsdot

cblas_dsdot

cblas_dsdot

cblas_dsdot

cblas_sdot

cblas_sdot

cblas_sdot

cblas_ddot

cblas_ddot

cblas_ddot

cblas_cdotu_sub

cblas_cdotc_sub

cblas_zdotu_sub

cblas_zdotc_sub

cblas_sasum

cblas_sasum

cblas_sasum

cblas_dasum

cblas_dasum

cblas_dasum

cblas_scasum

cblas_dzasum

cblas_snrm2

cblas_snrm2

cblas_snrm2

cblas_dnrm2

cblas_dnrm2

cblas_dnrm2

cblas_scnrm2

cblas_dznrm2

cblas_isamax

cblas_isamax

cblas_isamax

OPENBLAS_64BIT