BLAS

All Known Implementing Classes:

OpenBLAS
```
public interface BLAS
```
Basic Linear Algebra Subprograms. BLAS is a specification that prescribes a set of low-level routines for performing common linear algebra operations such as vector addition, scalar multiplication, dot products, linear combinations, and matrix multiplication. They are the de facto standard low-level routines for linear algebra libraries.

Field Summary

Fields
Modifier and Type Field and Description

static BLAS engine
The default BLAS engine.

Fields
Modifier and Type	Field and Description
`static BLAS`	`engine` The default BLAS engine.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default double`	`asum(double[] x)` Sums the absolute values of the elements of a vector.
`default float`	`asum(float[] x)` Sums the absolute values of the elements of a vector.
`double`	`asum(int n, double[] x, int incx)` Sums the absolute values of the elements of a vector.
`float`	`asum(int n, float[] x, int incx)` Sums the absolute values of the elements of a vector.
`default void`	`axpy(double alpha, double[] x, double[] y)` Computes a constant alpha times a vector x plus a vector y.
`default void`	`axpy(float alpha, float[] x, float[] y)` Computes a constant alpha times a vector x plus a vector y.
`void`	`axpy(int n, double alpha, double[] x, int incx, double[] y, int incy)` Computes a constant alpha times a vector x plus a vector y.
`void`	`axpy(int n, float alpha, float[] x, int incx, float[] y, int incy)` Computes a constant alpha times a vector x plus a vector y.
`default double`	`dot(double[] x, double[] y)` Computes the dot product of two vectors.
`default float`	`dot(float[] x, float[] y)` Computes the dot product of two vectors.
`double`	`dot(int n, double[] x, int incx, double[] y, int incy)` Computes the dot product of two vectors.
`float`	`dot(int n, float[] x, int incx, float[] y, int incy)` Computes the dot product of two vectors.
`void`	`gbmv(Layout layout, Transpose trans, int m, int n, int kl, int ku, double alpha, double[] A, int lda, double[] x, int incx, double beta, double[] y, int incy)` Performs the matrix-vector operation using a band matrix.
`void`	`gbmv(Layout layout, Transpose trans, int m, int n, int kl, int ku, double alpha, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer x, int incx, double beta, java.nio.DoubleBuffer y, int incy)` Performs the matrix-vector operation using a band matrix.
`void`	`gbmv(Layout layout, Transpose trans, int m, int n, int kl, int ku, float alpha, float[] A, int lda, float[] x, int incx, float beta, float[] y, int incy)` Performs the matrix-vector operation using a band matrix.
`void`	`gbmv(Layout layout, Transpose trans, int m, int n, int kl, int ku, float alpha, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer x, int incx, float beta, java.nio.FloatBuffer y, int incy)` Performs the matrix-vector operation using a band matrix.
`void`	`gemm(Layout layout, Transpose transA, Transpose transB, int m, int n, int k, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc)` Performs the matrix-matrix operation.
`void`	`gemm(Layout layout, Transpose transA, Transpose transB, int m, int n, int k, double alpha, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb, double beta, java.nio.DoubleBuffer C, int ldc)` Performs the matrix-matrix operation.
`void`	`gemm(Layout layout, Transpose transA, Transpose transB, int m, int n, int k, float alpha, float[] A, int lda, float[] B, int ldb, float beta, float[] C, int ldc)` Performs the matrix-matrix operation.
`void`	`gemm(Layout layout, Transpose transA, Transpose transB, int m, int n, int k, float alpha, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb, float beta, java.nio.FloatBuffer C, int ldc)` Performs the matrix-matrix operation.
`void`	`gemv(Layout layout, Transpose trans, int m, int n, double alpha, double[] A, int lda, double[] x, int incx, double beta, double[] y, int incy)` Performs the matrix-vector operation.
`void`	`gemv(Layout layout, Transpose trans, int m, int n, double alpha, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer x, int incx, double beta, java.nio.DoubleBuffer y, int incy)` Performs the matrix-vector operation.
`void`	`gemv(Layout layout, Transpose trans, int m, int n, float alpha, float[] A, int lda, float[] x, int incx, float beta, float[] y, int incy)` Performs the matrix-vector operation.
`void`	`gemv(Layout layout, Transpose trans, int m, int n, float alpha, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer x, int incx, float beta, java.nio.FloatBuffer y, int incy)` Performs the matrix-vector operation.
`void`	`ger(Layout layout, int m, int n, double alpha, double[] x, int incx, double[] y, int incy, double[] A, int lda)` Performs the rank-1 update operation.
`void`	`ger(Layout layout, int m, int n, double alpha, java.nio.DoubleBuffer x, int incx, java.nio.DoubleBuffer y, int incy, java.nio.DoubleBuffer A, int lda)` Performs the rank-1 update operation.
`void`	`ger(Layout layout, int m, int n, float alpha, float[] x, int incx, float[] y, int incy, float[] A, int lda)` Performs the rank-1 update operation.
`void`	`ger(Layout layout, int m, int n, float alpha, java.nio.FloatBuffer x, int incx, java.nio.FloatBuffer y, int incy, java.nio.FloatBuffer A, int lda)` Performs the rank-1 update operation.
`static BLAS`	`getInstance()` Creates an instance.
`default long`	`iamax(double[] x)` Searches a vector for the first occurrence of the the maximum absolute value.
`default long`	`iamax(float[] x)` Searches a vector for the first occurrence of the the maximum absolute value.
`long`	`iamax(int n, double[] x, int incx)` Searches a vector for the first occurrence of the the maximum absolute value.
`long`	`iamax(int n, float[] x, int incx)` Searches a vector for the first occurrence of the the maximum absolute value.
`static BLAS`	`MKL()` Creates an MKL instance.
`default double`	`nrm2(double[] x, double[] y)` Computes the Euclidean (L2) norm of a vector.
`default float`	`nrm2(float[] x, float[] y)` Computes the Euclidean (L2) norm of a vector.
`double`	`nrm2(int n, double[] x, int incx)` Computes the Euclidean (L2) norm of a vector.
`float`	`nrm2(int n, float[] x, int incx)` Computes the Euclidean (L2) norm of a vector.
`void`	`sbmv(Layout layout, UPLO uplo, int n, int k, double alpha, double[] A, int lda, double[] x, int incx, double beta, double[] y, int incy)` Performs the matrix-vector operation using a symmetric band matrix.
`void`	`sbmv(Layout layout, UPLO uplo, int n, int k, double alpha, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer x, int incx, double beta, java.nio.DoubleBuffer y, int incy)` Performs the matrix-vector operation using a symmetric band matrix.
`void`	`sbmv(Layout layout, UPLO uplo, int n, int k, float alpha, float[] A, int lda, float[] x, int incx, float beta, float[] y, int incy)` Performs the matrix-vector operation using a symmetric band matrix.
`void`	`sbmv(Layout layout, UPLO uplo, int n, int k, float alpha, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer x, int incx, float beta, java.nio.FloatBuffer y, int incy)` Performs the matrix-vector operation using a symmetric band matrix.
`default void`	`scal(double alpha, double[] x)` Scales a vector with a scalar.
`default void`	`scal(float alpha, float[] x)` Scales a vector with a scalar.
`void`	`scal(int n, double alpha, double[] x, int incx)` Scales a vector with a scalar.
`void`	`scal(int n, float alpha, float[] x, int incx)` Scales a vector with a scalar.
`void`	`spmv(Layout layout, UPLO uplo, int n, double alpha, double[] A, double[] x, int incx, double beta, double[] y, int incy)` Performs the matrix-vector operation using a symmetric packed matrix.
`void`	`spmv(Layout layout, UPLO uplo, int n, double alpha, java.nio.DoubleBuffer A, java.nio.DoubleBuffer x, int incx, double beta, java.nio.DoubleBuffer y, int incy)` Performs the matrix-vector operation using a symmetric packed matrix.
`void`	`spmv(Layout layout, UPLO uplo, int n, float alpha, float[] A, float[] x, int incx, float beta, float[] y, int incy)` Performs the matrix-vector operation using a symmetric packed matrix.
`void`	`spmv(Layout layout, UPLO uplo, int n, float alpha, java.nio.FloatBuffer A, java.nio.FloatBuffer x, int incx, float beta, java.nio.FloatBuffer y, int incy)` Performs the matrix-vector operation using a symmetric packed matrix.
`void`	`spr(Layout layout, UPLO uplo, int n, double alpha, double[] x, int incx, double[] A)` Performs the rank-1 update operation to symmetric packed matrix.
`void`	`spr(Layout layout, UPLO uplo, int n, double alpha, java.nio.DoubleBuffer x, int incx, java.nio.DoubleBuffer A)` Performs the rank-1 update operation to symmetric packed matrix.
`void`	`spr(Layout layout, UPLO uplo, int n, float alpha, float[] x, int incx, float[] A)` Performs the rank-1 update operation to symmetric packed matrix.
`void`	`spr(Layout layout, UPLO uplo, int n, float alpha, java.nio.FloatBuffer x, int incx, java.nio.FloatBuffer A)` Performs the rank-1 update operation to symmetric packed matrix.
`default void`	`swap(double[] x, double[] y)` Swaps two vectors.
`default void`	`swap(float[] x, float[] y)` Swaps two vectors.
`void`	`swap(int n, double[] x, int incx, double[] y, int incy)` Swaps two vectors.
`void`	`swap(int n, float[] x, int incx, float[] y, int incy)` Swaps two vectors.
`void`	`symm(Layout layout, Side side, UPLO uplo, int m, int n, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc)` Performs the matrix-matrix operation where the matrix A is symmetric.
`void`	`symm(Layout layout, Side side, UPLO uplo, int m, int n, double alpha, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb, double beta, java.nio.DoubleBuffer C, int ldc)` Performs the matrix-matrix operation where the matrix A is symmetric.
`void`	`symm(Layout layout, Side side, UPLO uplo, int m, int n, float alpha, float[] A, int lda, float[] B, int ldb, float beta, float[] C, int ldc)` Performs the matrix-matrix operation where one input matrix is symmetric.
`void`	`symm(Layout layout, Side side, UPLO uplo, int m, int n, float alpha, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb, float beta, java.nio.FloatBuffer C, int ldc)` Performs the matrix-matrix operation where one input matrix is symmetric.
`void`	`symv(Layout layout, UPLO uplo, int n, double alpha, double[] A, int lda, double[] x, int incx, double beta, double[] y, int incy)` Performs the matrix-vector operation using a symmetric matrix.
`void`	`symv(Layout layout, UPLO uplo, int n, double alpha, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer x, int incx, double beta, java.nio.DoubleBuffer y, int incy)` Performs the matrix-vector operation using a symmetric matrix.
`void`	`symv(Layout layout, UPLO uplo, int n, float alpha, float[] A, int lda, float[] x, int incx, float beta, float[] y, int incy)` Performs the matrix-vector operation using a symmetric matrix.
`void`	`symv(Layout layout, UPLO uplo, int n, float alpha, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer x, int incx, float beta, java.nio.FloatBuffer y, int incy)` Performs the matrix-vector operation using a symmetric matrix.
`void`	`syr(Layout layout, UPLO uplo, int n, double alpha, double[] x, int incx, double[] A, int lda)` Performs the rank-1 update operation to symmetric matrix.
`void`	`syr(Layout layout, UPLO uplo, int n, double alpha, java.nio.DoubleBuffer x, int incx, java.nio.DoubleBuffer A, int lda)` Performs the rank-1 update operation to symmetric matrix.
`void`	`syr(Layout layout, UPLO uplo, int n, float alpha, float[] x, int incx, float[] A, int lda)` Performs the rank-1 update operation to symmetric matrix.
`void`	`syr(Layout layout, UPLO uplo, int n, float alpha, java.nio.FloatBuffer x, int incx, java.nio.FloatBuffer A, int lda)` Performs the rank-1 update operation to symmetric matrix.
`void`	`tpmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, double[] A, double[] x, int incx)` Performs the matrix-vector operation using a triangular packed matrix.
`void`	`tpmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, java.nio.DoubleBuffer A, java.nio.DoubleBuffer x, int incx)` Performs the matrix-vector operation using a triangular packed matrix.
`void`	`tpmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, float[] A, float[] x, int incx)` Performs the matrix-vector operation using a triangular packed matrix.
`void`	`tpmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, java.nio.FloatBuffer A, java.nio.FloatBuffer x, int incx)` Performs the matrix-vector operation using a triangular packed matrix.
`void`	`trmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, double[] A, int lda, double[] x, int incx)` Performs the matrix-vector operation using a triangular matrix.
`void`	`trmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer x, int incx)` Performs the matrix-vector operation using a triangular matrix.
`void`	`trmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, float[] A, int lda, float[] x, int incx)` Performs the matrix-vector operation using a triangular matrix.
`void`	`trmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer x, int incx)` Performs the matrix-vector operation using a triangular matrix.

- Field Detail
  - engine
```
static final BLAS engine
```
    The default BLAS engine.
- Method Detail
  - getInstance
```
static BLAS getInstance()
```
    Creates an instance.
  - MKL
```
static BLAS MKL()
```
    Creates an MKL instance.
  - asum
```
double asum(int n,
            double[] x,
            int incx)
```
    Sums the absolute values of the elements of a vector. When working backward (incx < 0), each routine starts at the end of the vector and moves backward.
    
    Parameters:
    
    n - Number of vector elements to be summed.
    
    x - Array of dimension (n-1) * abs(incx)+ 1. Vector that contains elements to be summed.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    Returns:
    
    Sum of the absolute values of the elements of the vector x. If n <= 0, DASUM is set to 0.
  - asum
```
float asum(int n,
           float[] x,
           int incx)
```
    Sums the absolute values of the elements of a vector. When working backward (incx < 0), each routine starts at the end of the vector and moves backward.
    
    Parameters:
    
    n - Number of vector elements to be summed.
    
    x - Array of dimension (n-1) * abs(incx)+ 1. Vector that contains elements to be summed.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    Returns:
    
    Sum of the absolute values of the elements of the vector x. If n <= 0, DASUM is set to 0.
  - asum
```
default double asum(double[] x)
```
    Sums the absolute values of the elements of a vector.
  - asum
```
default float asum(float[] x)
```
    Sums the absolute values of the elements of a vector.
  - axpy
```
void axpy(int n,
          double alpha,
          double[] x,
          int incx,
          double[] y,
          int incy)
```
    Computes a constant alpha times a vector x plus a vector y. The result overwrites the initial values of vector y. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.
    When n <= 0, or alpha = 0., this routine returns immediately with no change in its arguments.
    
    Parameters:
    
    n - Number of elements in the vectors. If n <= 0, these routines return without any computation.
    
    alpha - If alpha = 0 this routine returns without any computation.
    
    x - Input array of dimension (n-1) * |incx| + 1. Contains the vector to be scaled before summation.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    y - Input and output array of dimension (n-1) * |incy| + 1. Before calling the routine, y contains the vector to be summed. After the routine ends, y contains the result of the summation.
    
    incy - Increment between elements of y. If incy = 0, the results will be unpredictable.
  - axpy
```
void axpy(int n,
          float alpha,
          float[] x,
          int incx,
          float[] y,
          int incy)
```
    Computes a constant alpha times a vector x plus a vector y. The result overwrites the initial values of vector y. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.
    When n <= 0, or alpha = 0., this routine returns immediately with no change in its arguments.
    
    Parameters:
    
    n - Number of elements in the vectors. If n <= 0, these routines return without any computation.
    
    alpha - If alpha = 0 this routine returns without any computation.
    
    x - Input array of dimension (n-1) * |incx| + 1. Contains the vector to be scaled before summation.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    y - Input and output array of dimension (n-1) * |incy| + 1. Before calling the routine, y contains the vector to be summed. After the routine ends, y contains the result of the summation.
    
    incy - Increment between elements of y. If incy = 0, the results will be unpredictable.
  - axpy
```
default void axpy(double alpha,
                  double[] x,
                  double[] y)
```
    Computes a constant alpha times a vector x plus a vector y.
  - axpy
```
default void axpy(float alpha,
                  float[] x,
                  float[] y)
```
    Computes a constant alpha times a vector x plus a vector y.
  - dot
```
double dot(int n,
           double[] x,
           int incx,
           double[] y,
           int incy)
```
    Computes the dot product of two vectors. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input array of dimension (n-1) * |incx| + 1. Array x contains the first vector operand.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    y - Input array of dimension (n-1) * |incy| + 1. Array y contains the second vector operand.
    
    incy - Increment between elements of y. If incy = 0, the results will be unpredictable.
    
    Returns:
    
    dot product. If n <= 0, return 0.
  - dot
```
float dot(int n,
          float[] x,
          int incx,
          float[] y,
          int incy)
```
    Computes the dot product of two vectors. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input array of dimension (n-1) * |incx| + 1. Array x contains the first vector operand.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    y - Input array of dimension (n-1) * |incy| + 1. Array y contains the second vector operand.
    
    incy - Increment between elements of y. If incy = 0, the results will be unpredictable.
    
    Returns:
    
    dot product. If n <= 0, return 0.
  - dot
```
default double dot(double[] x,
                   double[] y)
```
    Computes the dot product of two vectors.
  - dot
```
default float dot(float[] x,
                  float[] y)
```
    Computes the dot product of two vectors.
  - nrm2
```
double nrm2(int n,
            double[] x,
            int incx)
```
    Computes the Euclidean (L2) norm of a vector.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input array of dimension (n-1) * |incx| + 1. Array x contains the vector operand.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    Returns:
    
    Euclidean norm. If n <= 0, return 0.
  - nrm2
```
float nrm2(int n,
           float[] x,
           int incx)
```
    Computes the Euclidean (L2) norm of a vector.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input array of dimension (n-1) * |incx| + 1. Array x contains the vector operand.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    Returns:
    
    Euclidean norm. If n <= 0, return 0.
  - nrm2
```
default double nrm2(double[] x,
                    double[] y)
```
    Computes the Euclidean (L2) norm of a vector.
  - nrm2
```
default float nrm2(float[] x,
                   float[] y)
```
    Computes the Euclidean (L2) norm of a vector.
  - scal
```
void scal(int n,
          double alpha,
          double[] x,
          int incx)
```
    Scales a vector with a scalar.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input and output array of dimension (n-1) * |incx| + 1. Vector to be scaled.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
  - scal
```
void scal(int n,
          float alpha,
          float[] x,
          int incx)
```
    Scales a vector with a scalar.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input and output array of dimension (n-1) * |incx| + 1. Vector to be scaled.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
  - scal
```
default void scal(double alpha,
                  double[] x)
```
    Scales a vector with a scalar.
  - scal
```
default void scal(float alpha,
                  float[] x)
```
    Scales a vector with a scalar.
  - swap
```
void swap(int n,
          double[] x,
          int incx,
          double[] y,
          int incy)
```
    Swaps two vectors. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input and output array of dimension (n-1) * |incx| + 1. Vector to be swapped.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    y - Input and output array of dimension (n-1) * |incy| + 1. Vector to be swapped.
    
    incy - Increment between elements of y. If incy = 0, the results will be unpredictable.
  - swap
```
void swap(int n,
          float[] x,
          int incx,
          float[] y,
          int incy)
```
    Swaps two vectors. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input and output array of dimension (n-1) * |incx| + 1. Vector to be swapped.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    y - Input and output array of dimension (n-1) * |incy| + 1. Vector to be swapped.
    
    incy - Increment between elements of y. If incy = 0, the results will be unpredictable.
  - swap
```
default void swap(double[] x,
                  double[] y)
```
    Swaps two vectors.
  - swap
```
default void swap(float[] x,
                  float[] y)
```
    Swaps two vectors.
  - iamax
```
long iamax(int n,
           double[] x,
           int incx)
```
    Searches a vector for the first occurrence of the the maximum absolute value.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input array of dimension (n-1) * |incx| + 1. Vector to be searched.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    Returns:
    
    The first index of the maximum absolute value of vector x. If n <= 0, return 0.
  - iamax
```
long iamax(int n,
           float[] x,
           int incx)
```
    Searches a vector for the first occurrence of the the maximum absolute value.
    
    Parameters:
    
    n - Number of elements in the vectors.
    
    x - Input array of dimension (n-1) * |incx| + 1. Vector to be searched.
    
    incx - Increment between elements of x. If incx = 0, the results will be unpredictable.
    
    Returns:
    
    The first index of the maximum absolute value of vector x. If n <= 0, return 0.
  - iamax
```
default long iamax(double[] x)
```
    Searches a vector for the first occurrence of the the maximum absolute value.
  - iamax
```
default long iamax(float[] x)
```
    Searches a vector for the first occurrence of the the maximum absolute value.
  - gemv
```
void gemv(Layout layout,
          Transpose trans,
          int m,
          int n,
          double alpha,
          double[] A,
          int lda,
          double[] x,
          int incx,
          double beta,
          double[] y,
          int incy)
```
    Performs the matrix-vector operation.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    A - the leading m by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (m - 1)*abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1)*abs(incy)) otherwise.
    
    incy - the increment for the elements of y, which must not be zero.
  - gemv
```
void gemv(Layout layout,
          Transpose trans,
          int m,
          int n,
          double alpha,
          java.nio.DoubleBuffer A,
          int lda,
          java.nio.DoubleBuffer x,
          int incx,
          double beta,
          java.nio.DoubleBuffer y,
          int incy)
```
    Performs the matrix-vector operation.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    A - the leading m by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (m - 1)*abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1)*abs(incy)) otherwise.
    
    incy - the increment for the elements of y, which must not be zero.
  - gemv
```
void gemv(Layout layout,
          Transpose trans,
          int m,
          int n,
          float alpha,
          float[] A,
          int lda,
          float[] x,
          int incx,
          float beta,
          float[] y,
          int incy)
```
    Performs the matrix-vector operation.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    A - the leading m by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (m - 1)*abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1)*abs(incy)) otherwise.
    
    incy - the increment for the elements of y, which must not be zero.
  - gemv
```
void gemv(Layout layout,
          Transpose trans,
          int m,
          int n,
          float alpha,
          java.nio.FloatBuffer A,
          int lda,
          java.nio.FloatBuffer x,
          int incx,
          float beta,
          java.nio.FloatBuffer y,
          int incy)
```
    Performs the matrix-vector operation.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    A - the leading m by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (m - 1)*abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1)*abs(incy)) otherwise.
    
    incy - the increment for the elements of y, which must not be zero.
  - symv
```
void symv(Layout layout,
          UPLO uplo,
          int n,
          double alpha,
          double[] A,
          int lda,
          double[] x,
          int incx,
          double beta,
          double[] y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - symv
```
void symv(Layout layout,
          UPLO uplo,
          int n,
          double alpha,
          java.nio.DoubleBuffer A,
          int lda,
          java.nio.DoubleBuffer x,
          int incx,
          double beta,
          java.nio.DoubleBuffer y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - symv
```
void symv(Layout layout,
          UPLO uplo,
          int n,
          float alpha,
          float[] A,
          int lda,
          float[] x,
          int incx,
          float beta,
          float[] y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - symv
```
void symv(Layout layout,
          UPLO uplo,
          int n,
          float alpha,
          java.nio.FloatBuffer A,
          int lda,
          java.nio.FloatBuffer x,
          int incx,
          float beta,
          java.nio.FloatBuffer y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - spmv
```
void spmv(Layout layout,
          UPLO uplo,
          int n,
          double alpha,
          double[] A,
          double[] x,
          int incx,
          double beta,
          double[] y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric packed matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric packed matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - spmv
```
void spmv(Layout layout,
          UPLO uplo,
          int n,
          double alpha,
          java.nio.DoubleBuffer A,
          java.nio.DoubleBuffer x,
          int incx,
          double beta,
          java.nio.DoubleBuffer y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric packed matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric packed matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - spmv
```
void spmv(Layout layout,
          UPLO uplo,
          int n,
          float alpha,
          float[] A,
          float[] x,
          int incx,
          float beta,
          float[] y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric packed matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric packed matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - spmv
```
void spmv(Layout layout,
          UPLO uplo,
          int n,
          float alpha,
          java.nio.FloatBuffer A,
          java.nio.FloatBuffer x,
          int incx,
          float beta,
          java.nio.FloatBuffer y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric packed matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric packed matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - trmv
```
void trmv(Layout layout,
          UPLO uplo,
          Transpose trans,
          Diag diag,
          int n,
          double[] A,
          int lda,
          double[] x,
          int incx)
```
    Performs the matrix-vector operation using a triangular matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    diag - unit diagonal or not.
    
    n - the number of rows/columns of the triangular matrix A.
    
    A - the symmetric matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
  - trmv
```
void trmv(Layout layout,
          UPLO uplo,
          Transpose trans,
          Diag diag,
          int n,
          java.nio.DoubleBuffer A,
          int lda,
          java.nio.DoubleBuffer x,
          int incx)
```
    Performs the matrix-vector operation using a triangular matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    diag - unit diagonal or not.
    
    n - the number of rows/columns of the triangular matrix A.
    
    A - the symmetric matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
  - trmv
```
void trmv(Layout layout,
          UPLO uplo,
          Transpose trans,
          Diag diag,
          int n,
          float[] A,
          int lda,
          float[] x,
          int incx)
```
    Performs the matrix-vector operation using a triangular matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    diag - unit diagonal or not.
    
    n - the number of rows/columns of the triangular matrix A.
    
    A - the symmetric matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
  - trmv
```
void trmv(Layout layout,
          UPLO uplo,
          Transpose trans,
          Diag diag,
          int n,
          java.nio.FloatBuffer A,
          int lda,
          java.nio.FloatBuffer x,
          int incx)
```
    Performs the matrix-vector operation using a triangular matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    diag - unit diagonal or not.
    
    n - the number of rows/columns of the triangular matrix A.
    
    A - the symmetric matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
  - tpmv
```
void tpmv(Layout layout,
          UPLO uplo,
          Transpose trans,
          Diag diag,
          int n,
          double[] A,
          double[] x,
          int incx)
```
    Performs the matrix-vector operation using a triangular packed matrix.
```
     x := A*x
 
```
    or
```
     y := A'*x
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    diag - unit diagonal or not.
    
    n - the number of rows/columns of the triangular matrix A.
    
    A - the symmetric packed matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
  - tpmv
```
void tpmv(Layout layout,
          UPLO uplo,
          Transpose trans,
          Diag diag,
          int n,
          java.nio.DoubleBuffer A,
          java.nio.DoubleBuffer x,
          int incx)
```
    Performs the matrix-vector operation using a triangular packed matrix.
```
     x := A*x
 
```
    or
```
     y := A'*x
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    diag - unit diagonal or not.
    
    n - the number of rows/columns of the triangular matrix A.
    
    A - the symmetric packed matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
  - tpmv
```
void tpmv(Layout layout,
          UPLO uplo,
          Transpose trans,
          Diag diag,
          int n,
          float[] A,
          float[] x,
          int incx)
```
    Performs the matrix-vector operation using a triangular packed matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    diag - unit diagonal or not.
    
    n - the number of rows/columns of the triangular matrix A.
    
    A - the symmetric packed matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
  - tpmv
```
void tpmv(Layout layout,
          UPLO uplo,
          Transpose trans,
          Diag diag,
          int n,
          java.nio.FloatBuffer A,
          java.nio.FloatBuffer x,
          int incx)
```
    Performs the matrix-vector operation using a triangular packed matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    diag - unit diagonal or not.
    
    n - the number of rows/columns of the triangular matrix A.
    
    A - the symmetric packed matrix.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
  - gbmv
```
void gbmv(Layout layout,
          Transpose trans,
          int m,
          int n,
          int kl,
          int ku,
          double alpha,
          double[] A,
          int lda,
          double[] x,
          int incx,
          double beta,
          double[] y,
          int incy)
```
    Performs the matrix-vector operation using a band matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    kl - the number of subdiagonal elements of band matrix.
    
    ku - the number of superdiagonal elements of band matrix.
    
    alpha - the scalar alpha.
    
    A - the band matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (m - 1)*abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1)*abs(incy)) otherwise.
    
    incy - the increment for the elements of y, which must not be zero.
  - gbmv
```
void gbmv(Layout layout,
          Transpose trans,
          int m,
          int n,
          int kl,
          int ku,
          double alpha,
          java.nio.DoubleBuffer A,
          int lda,
          java.nio.DoubleBuffer x,
          int incx,
          double beta,
          java.nio.DoubleBuffer y,
          int incy)
```
    Performs the matrix-vector operation using a band matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    kl - the number of subdiagonal elements of band matrix.
    
    ku - the number of superdiagonal elements of band matrix.
    
    alpha - the scalar alpha.
    
    A - the band matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (m - 1)*abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1)*abs(incy)) otherwise.
    
    incy - the increment for the elements of y, which must not be zero.
  - gbmv
```
void gbmv(Layout layout,
          Transpose trans,
          int m,
          int n,
          int kl,
          int ku,
          float alpha,
          float[] A,
          int lda,
          float[] x,
          int incx,
          float beta,
          float[] y,
          int incy)
```
    Performs the matrix-vector operation using a band matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    kl - the number of subdiagonal elements of band matrix.
    
    ku - the number of superdiagonal elements of band matrix.
    
    alpha - the scalar alpha.
    
    A - the band matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (m - 1)*abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1)*abs(incy)) otherwise.
    
    incy - the increment for the elements of y, which must not be zero.
  - gbmv
```
void gbmv(Layout layout,
          Transpose trans,
          int m,
          int n,
          int kl,
          int ku,
          float alpha,
          java.nio.FloatBuffer A,
          int lda,
          java.nio.FloatBuffer x,
          int incx,
          float beta,
          java.nio.FloatBuffer y,
          int incy)
```
    Performs the matrix-vector operation using a band matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    trans - normal, transpose, or conjugate transpose operation on the matrix.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    kl - the number of subdiagonal elements of band matrix.
    
    ku - the number of superdiagonal elements of band matrix.
    
    alpha - the scalar alpha.
    
    A - the band matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (m - 1)*abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1)*abs(incy)) otherwise.
    
    incy - the increment for the elements of y, which must not be zero.
  - sbmv
```
void sbmv(Layout layout,
          UPLO uplo,
          int n,
          int k,
          double alpha,
          double[] A,
          int lda,
          double[] x,
          int incx,
          double beta,
          double[] y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric band matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric band matrix A.
    
    k - the number of subdiagonal/superdiagonal elements of the symmetric band matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric band matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)),
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)),
    
    incy - the increment for the elements of y, which must not be zero.
  - sbmv
```
void sbmv(Layout layout,
          UPLO uplo,
          int n,
          int k,
          double alpha,
          java.nio.DoubleBuffer A,
          int lda,
          java.nio.DoubleBuffer x,
          int incx,
          double beta,
          java.nio.DoubleBuffer y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric band matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of rows/columns of the symmetric band matrix A.
    
    k - the number of subdiagonal/superdiagonal elements of the symmetric band matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric band matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)),
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)),
    
    incy - the increment for the elements of y, which must not be zero.
  - sbmv
```
void sbmv(Layout layout,
          UPLO uplo,
          int n,
          int k,
          float alpha,
          float[] A,
          int lda,
          float[] x,
          int incx,
          float beta,
          float[] y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric band matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the symmetric band matrix A.
    
    k - the number of subdiagonal/superdiagonal elements of the symmetric band matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric band matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - sbmv
```
void sbmv(Layout layout,
          UPLO uplo,
          int n,
          int k,
          float alpha,
          java.nio.FloatBuffer A,
          int lda,
          java.nio.FloatBuffer x,
          int incx,
          float beta,
          java.nio.FloatBuffer y,
          int incy)
```
    Performs the matrix-vector operation using a symmetric band matrix.
```
     y := alpha*A*x + beta*y
 
```
    or
```
     y := alpha*A'*x + beta*y
 
```
    where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the symmetric band matrix A.
    
    k - the number of subdiagonal/superdiagonal elements of the symmetric band matrix A.
    
    alpha - the scalar alpha.
    
    A - the symmetric band matrix.
    
    lda - the leading dimension of A as declared in the caller.
    
    x - array of dimension at least (1 + (n - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
  - ger
```
void ger(Layout layout,
         int m,
         int n,
         double alpha,
         double[] x,
         int incx,
         double[] y,
         int incy,
         double[] A,
         int lda)
```
    Performs the rank-1 update operation.
```
     A := A + alpha*x*y'
 
```
    Parameters:
    
    layout - matrix layout.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
    
    A - the leading m by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
  - ger
```
void ger(Layout layout,
         int m,
         int n,
         double alpha,
         java.nio.DoubleBuffer x,
         int incx,
         java.nio.DoubleBuffer y,
         int incy,
         java.nio.DoubleBuffer A,
         int lda)
```
    Performs the rank-1 update operation.
```
     A := A + alpha*x*y'
 
```
    Parameters:
    
    layout - matrix layout.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
    
    A - the leading m by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
  - ger
```
void ger(Layout layout,
         int m,
         int n,
         float alpha,
         float[] x,
         int incx,
         float[] y,
         int incy,
         float[] A,
         int lda)
```
    Performs the rank-1 update operation.
```
     A := A + alpha*x*y'
 
```
    Parameters:
    
    layout - matrix layout.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
    
    A - the leading m by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
  - ger
```
void ger(Layout layout,
         int m,
         int n,
         float alpha,
         java.nio.FloatBuffer x,
         int incx,
         java.nio.FloatBuffer y,
         int incy,
         java.nio.FloatBuffer A,
         int lda)
```
    Performs the rank-1 update operation.
```
     A := A + alpha*x*y'
 
```
    Parameters:
    
    layout - matrix layout.
    
    m - the number of rows of the matrix A.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    y - array of dimension at least (1 + (n - 1)*abs(incy)).
    
    incy - the increment for the elements of y, which must not be zero.
    
    A - the leading m by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
  - syr
```
void syr(Layout layout,
         UPLO uplo,
         int n,
         double alpha,
         double[] x,
         int incx,
         double[] A,
         int lda)
```
    Performs the rank-1 update operation to symmetric matrix.
```
     A := A + alpha*x*x'
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    A - the leading n by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
  - syr
```
void syr(Layout layout,
         UPLO uplo,
         int n,
         double alpha,
         java.nio.DoubleBuffer x,
         int incx,
         java.nio.DoubleBuffer A,
         int lda)
```
    Performs the rank-1 update operation to symmetric matrix.
```
     A := A + alpha*x*x'
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    A - the leading n by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
  - syr
```
void syr(Layout layout,
         UPLO uplo,
         int n,
         float alpha,
         float[] x,
         int incx,
         float[] A,
         int lda)
```
    Performs the rank-1 update operation to symmetric matrix.
```
     A := A + alpha*x*x'
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero. the matrix of coefficients.
    
    A - the leading n by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
  - syr
```
void syr(Layout layout,
         UPLO uplo,
         int n,
         float alpha,
         java.nio.FloatBuffer x,
         int incx,
         java.nio.FloatBuffer A,
         int lda)
```
    Performs the rank-1 update operation to symmetric matrix.
```
     A := A + alpha*x*x'
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero. the matrix of coefficients.
    
    A - the leading n by n part of the array A must contain the matrix of coefficients.
    
    lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.
  - spr
```
void spr(Layout layout,
         UPLO uplo,
         int n,
         double alpha,
         double[] x,
         int incx,
         double[] A)
```
    Performs the rank-1 update operation to symmetric packed matrix.
```
     A := A + alpha*x*x'
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    A - the symmetric packed matrix.
  - spr
```
void spr(Layout layout,
         UPLO uplo,
         int n,
         double alpha,
         java.nio.DoubleBuffer x,
         int incx,
         java.nio.DoubleBuffer A)
```
    Performs the rank-1 update operation to symmetric packed matrix.
```
     A := A + alpha*x*x'
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero.
    
    A - the symmetric packed matrix.
  - spr
```
void spr(Layout layout,
         UPLO uplo,
         int n,
         float alpha,
         float[] x,
         int incx,
         float[] A)
```
    Performs the rank-1 update operation to symmetric packed matrix.
```
     A := A + alpha*x*x'
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero. the matrix of coefficients.
    
    A - the symmetric packed matrix.
  - spr
```
void spr(Layout layout,
         UPLO uplo,
         int n,
         float alpha,
         java.nio.FloatBuffer x,
         int incx,
         java.nio.FloatBuffer A)
```
    Performs the rank-1 update operation to symmetric packed matrix.
```
     A := A + alpha*x*x'
 
```
    Parameters:
    
    layout - matrix layout.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    n - the number of columns of the matrix A.
    
    alpha - the scalar alpha.
    
    x - array of dimension at least (1 + (m - 1)*abs(incx)).
    
    incx - the increment for the elements of x, which must not be zero. the matrix of coefficients.
    
    A - the symmetric packed matrix.
  - gemm
```
void gemm(Layout layout,
          Transpose transA,
          Transpose transB,
          int m,
          int n,
          int k,
          double alpha,
          double[] A,
          int lda,
          double[] B,
          int ldb,
          double beta,
          double[] C,
          int ldc)
```
    Performs the matrix-matrix operation.
```
     C := alpha*A*B + beta*C
 
```
    Parameters:
    
    layout - matrix layout.
    
    transA - normal, transpose, or conjugate transpose operation on the matrix A.
    
    transB - normal, transpose, or conjugate transpose operation on the matrix B.
    
    m - the number of rows of the matrix C.
    
    n - the number of columns of the matrix C.
    
    k - the number of columns of the matrix op(A).
    
    alpha - the scalar alpha.
    
    A - the matrix A.
    
    lda - the leading dimension of A as declared in the caller.
    
    B - the matrix B.
    
    ldb - the leading dimension of B as declared in the caller.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    C - the matrix C.
    
    ldc - the leading dimension of C as declared in the caller.
  - gemm
```
void gemm(Layout layout,
          Transpose transA,
          Transpose transB,
          int m,
          int n,
          int k,
          double alpha,
          java.nio.DoubleBuffer A,
          int lda,
          java.nio.DoubleBuffer B,
          int ldb,
          double beta,
          java.nio.DoubleBuffer C,
          int ldc)
```
    Performs the matrix-matrix operation.
```
     C := alpha*A*B + beta*C
 
```
    Parameters:
    
    layout - matrix layout.
    
    transA - normal, transpose, or conjugate transpose operation on the matrix A.
    
    transB - normal, transpose, or conjugate transpose operation on the matrix B.
    
    m - the number of rows of the matrix C.
    
    n - the number of columns of the matrix C.
    
    k - the number of columns of the matrix op(A).
    
    alpha - the scalar alpha.
    
    A - the matrix A.
    
    lda - the leading dimension of A as declared in the caller.
    
    B - the matrix B.
    
    ldb - the leading dimension of B as declared in the caller.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    C - the matrix C.
    
    ldc - the leading dimension of C as declared in the caller.
  - gemm
```
void gemm(Layout layout,
          Transpose transA,
          Transpose transB,
          int m,
          int n,
          int k,
          float alpha,
          float[] A,
          int lda,
          float[] B,
          int ldb,
          float beta,
          float[] C,
          int ldc)
```
    Performs the matrix-matrix operation.
```
     C := alpha*A*B + beta*C
 
```
    Parameters:
    
    layout - matrix layout.
    
    transA - normal, transpose, or conjugate transpose operation on the matrix A.
    
    transB - normal, transpose, or conjugate transpose operation on the matrix B.
    
    m - the number of rows of the matrix C.
    
    n - the number of columns of the matrix C.
    
    k - the number of columns of the matrix op(A).
    
    alpha - the scalar alpha.
    
    A - the matrix A.
    
    lda - the leading dimension of A as declared in the caller.
    
    B - the matrix B.
    
    ldb - the leading dimension of B as declared in the caller.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    C - the matrix C.
    
    ldc - the leading dimension of C as declared in the caller.
  - gemm
```
void gemm(Layout layout,
          Transpose transA,
          Transpose transB,
          int m,
          int n,
          int k,
          float alpha,
          java.nio.FloatBuffer A,
          int lda,
          java.nio.FloatBuffer B,
          int ldb,
          float beta,
          java.nio.FloatBuffer C,
          int ldc)
```
    Performs the matrix-matrix operation.
```
     C := alpha*A*B + beta*C
 
```
    Parameters:
    
    layout - matrix layout.
    
    transA - normal, transpose, or conjugate transpose operation on the matrix A.
    
    transB - normal, transpose, or conjugate transpose operation on the matrix B.
    
    m - the number of rows of the matrix C.
    
    n - the number of columns of the matrix C.
    
    k - the number of columns of the matrix op(A).
    
    alpha - the scalar alpha.
    
    A - the matrix A.
    
    lda - the leading dimension of A as declared in the caller.
    
    B - the matrix B.
    
    ldb - the leading dimension of B as declared in the caller.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    C - the matrix C.
    
    ldc - the leading dimension of C as declared in the caller.
  - symm
```
void symm(Layout layout,
          Side side,
          UPLO uplo,
          int m,
          int n,
          double alpha,
          double[] A,
          int lda,
          double[] B,
          int ldb,
          double beta,
          double[] C,
          int ldc)
```
    Performs the matrix-matrix operation where the matrix A is symmetric.
```
     C := alpha*A*B + beta*C
 
```
    or
```
     C := alpha*B*A + beta*C
 
```
    Parameters:
    
    layout - matrix layout.
    
    side - C := alpha*A*B + beta*C if side is left or C := alpha*B*A + beta*C if side is right.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    m - the number of rows of the matrix C.
    
    n - the number of columns of the matrix C.
    
    alpha - the scalar alpha.
    
    A - the matrix A.
    
    lda - the leading dimension of A as declared in the caller.
    
    B - the matrix B.
    
    ldb - the leading dimension of B as declared in the caller.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    C - the matrix C.
    
    ldc - the leading dimension of C as declared in the caller.
  - symm
```
void symm(Layout layout,
          Side side,
          UPLO uplo,
          int m,
          int n,
          double alpha,
          java.nio.DoubleBuffer A,
          int lda,
          java.nio.DoubleBuffer B,
          int ldb,
          double beta,
          java.nio.DoubleBuffer C,
          int ldc)
```
    Performs the matrix-matrix operation where the matrix A is symmetric.
```
     C := alpha*A*B + beta*C
 
```
    or
```
     C := alpha*B*A + beta*C
 
```
    Parameters:
    
    layout - matrix layout.
    
    side - C := alpha*A*B + beta*C if side is left or C := alpha*B*A + beta*C if side is right.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    m - the number of rows of the matrix C.
    
    n - the number of columns of the matrix C.
    
    alpha - the scalar alpha.
    
    A - the matrix A.
    
    lda - the leading dimension of A as declared in the caller.
    
    B - the matrix B.
    
    ldb - the leading dimension of B as declared in the caller.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    C - the matrix C.
    
    ldc - the leading dimension of C as declared in the caller.
  - symm
```
void symm(Layout layout,
          Side side,
          UPLO uplo,
          int m,
          int n,
          float alpha,
          float[] A,
          int lda,
          float[] B,
          int ldb,
          float beta,
          float[] C,
          int ldc)
```
    Performs the matrix-matrix operation where one input matrix is symmetric.
```
     C := alpha*A*B + beta*C
 
```
    Parameters:
    
    layout - matrix layout.
    
    side - C := alpha*A*B + beta*C if side is left or C := alpha*B*A + beta*C if side is right.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    m - the number of rows of the matrix C.
    
    n - the number of columns of the matrix C.
    
    alpha - the scalar alpha.
    
    A - the matrix A.
    
    lda - the leading dimension of A as declared in the caller.
    
    B - the matrix B.
    
    ldb - the leading dimension of B as declared in the caller.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    C - the matrix C.
    
    ldc - the leading dimension of C as declared in the caller.
  - symm
```
void symm(Layout layout,
          Side side,
          UPLO uplo,
          int m,
          int n,
          float alpha,
          java.nio.FloatBuffer A,
          int lda,
          java.nio.FloatBuffer B,
          int ldb,
          float beta,
          java.nio.FloatBuffer C,
          int ldc)
```
    Performs the matrix-matrix operation where one input matrix is symmetric.
```
     C := alpha*A*B + beta*C
 
```
    Parameters:
    
    layout - matrix layout.
    
    side - C := alpha*A*B + beta*C if side is left or C := alpha*B*A + beta*C if side is right.
    
    uplo - the upper or lower triangular part of the matrix A is to be referenced.
    
    m - the number of rows of the matrix C.
    
    n - the number of columns of the matrix C.
    
    alpha - the scalar alpha.
    
    A - the matrix A.
    
    lda - the leading dimension of A as declared in the caller.
    
    B - the matrix B.
    
    ldb - the leading dimension of B as declared in the caller.
    
    beta - the scalar beta. When beta is supplied as zero then y need not be set on input.
    
    C - the matrix C.
    
    ldc - the leading dimension of C as declared in the caller.

Interface BLAS

Field Summary

Method Summary

Field Detail

engine

Method Detail

getInstance

MKL

asum

asum

asum

asum

axpy

axpy

axpy

axpy

dot

dot

dot

dot

nrm2

nrm2

nrm2

nrm2

scal

scal

scal

scal

swap

swap

swap

swap

iamax

iamax

iamax

iamax

gemv

gemv

gemv

gemv

symv

symv

symv

symv

spmv

spmv

spmv

spmv

trmv

trmv

trmv

trmv

tpmv

tpmv

tpmv

tpmv

gbmv

gbmv

gbmv

gbmv

sbmv

sbmv

sbmv

sbmv

ger

ger

ger

ger

syr

syr

syr

syr

spr

spr

spr

spr

gemm

gemm

gemm

gemm