Interface 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
    Description
    static final BLAS
    The default BLAS engine.
  • Method Summary

    Modifier and Type
    Method
    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, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, 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, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, 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, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, double beta, DoubleBuffer C, int ldc)
    Performs the matrix-matrix operation.
    void
    gemm(Layout layout, Transpose transA, Transpose transB, int m, int n, int k, double alpha, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer B, int ldb, double beta, org.bytedeco.javacpp.DoublePointer 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, FloatBuffer A, int lda, FloatBuffer B, int ldb, float beta, 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, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, DoubleBuffer y, int incy)
    Performs the matrix-vector operation.
    void
    gemv(Layout layout, Transpose trans, int m, int n, double alpha, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer x, int incx, double beta, org.bytedeco.javacpp.DoublePointer 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, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, 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, DoubleBuffer x, int incx, DoubleBuffer y, int incy, DoubleBuffer A, int lda)
    Performs the rank-1 update operation.
    void
    ger(Layout layout, int m, int n, double alpha, org.bytedeco.javacpp.DoublePointer x, int incx, org.bytedeco.javacpp.DoublePointer y, int incy, org.bytedeco.javacpp.DoublePointer 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, FloatBuffer x, int incx, FloatBuffer y, int incy, FloatBuffer A, int lda)
    Performs the rank-1 update operation.
    static BLAS
    Creates an instance.
    default long
    iamax(double[] x)
    Searches a vector for the first occurrence of the maximum absolute value.
    default long
    iamax(float[] x)
    Searches a vector for the first occurrence of the maximum absolute value.
    long
    iamax(int n, double[] x, int incx)
    Searches a vector for the first occurrence of the maximum absolute value.
    long
    iamax(int n, float[] x, int incx)
    Searches a vector for the first occurrence of the maximum absolute value.
    default double
    nrm2(double[] x)
    Computes the Euclidean (L2) norm of a vector.
    default float
    nrm2(float[] x)
    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, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, 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, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, 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, DoubleBuffer A, DoubleBuffer x, int incx, double beta, 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, FloatBuffer A, FloatBuffer x, int incx, float beta, 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, DoubleBuffer x, int incx, 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, FloatBuffer x, int incx, 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, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, double beta, 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, double alpha, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer B, int ldb, double beta, org.bytedeco.javacpp.DoublePointer 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, FloatBuffer A, int lda, FloatBuffer B, int ldb, float beta, 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, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, DoubleBuffer y, int incy)
    Performs the matrix-vector operation using a symmetric matrix.
    void
    symv(Layout layout, UPLO uplo, int n, double alpha, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer x, int incx, double beta, org.bytedeco.javacpp.DoublePointer 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, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, 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, DoubleBuffer x, int incx, DoubleBuffer A, int lda)
    Performs the rank-1 update operation to symmetric matrix.
    void
    syr(Layout layout, UPLO uplo, int n, double alpha, org.bytedeco.javacpp.DoublePointer x, int incx, org.bytedeco.javacpp.DoublePointer 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, FloatBuffer x, int incx, 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, 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, DoubleBuffer A, 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, FloatBuffer A, 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, 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, DoubleBuffer A, int lda, 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, FloatBuffer A, int lda, FloatBuffer x, int incx)
    Performs the matrix-vector operation using a triangular matrix.
    void
    trmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer x, int incx)
    Performs the matrix-vector operation using a triangular matrix.
  • Field Details

    • engine

      static final BLAS engine
      The default BLAS engine.
  • Method Details

    • getInstance

      static BLAS getInstance()
      Creates an instance.
      Returns:
      a BLAS 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.
      Parameters:
      x - Vector that contains elements to be summed.
      Returns:
      Sum of the absolute values of the elements of the vector x.
    • asum

      default float asum(float[] x)
      Sums the absolute values of the elements of a vector.
      Parameters:
      x - Vector that contains elements to be summed.
      Returns:
      Sum of the absolute values of the elements of the vector x.
    • 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. The result overwrites the initial values of vector y.

      When alpha = 0., this routine returns immediately with no change in its arguments.

      Parameters:
      alpha - If alpha = 0 this routine returns without any computation.
      x - The vector to be scaled before summation.
      y - Input and output array. Before calling the routine, y contains the vector to be summed. After the routine ends, y contains the result of the summation.
    • axpy

      default void axpy(float alpha, float[] x, float[] y)
      Computes a constant alpha times a vector x plus a vector y. The result overwrites the initial values of vector y.

      When alpha = 0., this routine returns immediately with no change in its arguments.

      Parameters:
      alpha - If alpha = 0 this routine returns without any computation.
      x - The vector to be scaled before summation.
      y - Input and output array. Before calling the routine, y contains the vector to be summed. After the routine ends, y contains the result of the summation.
    • 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.
      Parameters:
      x - Array x contains the first vector operand.
      y - Array y contains the second vector operand.
      Returns:
      dot product. If n <= 0, return 0.
    • dot

      default float dot(float[] x, float[] y)
      Computes the dot product of two vectors.
      Parameters:
      x - Array x contains the first vector operand.
      y - Array y contains the second vector operand.
      Returns:
      dot product. If n <= 0, return 0.
    • 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)
      Computes the Euclidean (L2) norm of a vector.
      Parameters:
      x - Array x contains the vector operand.
      Returns:
      Euclidean norm.
    • nrm2

      default float nrm2(float[] x)
      Computes the Euclidean (L2) norm of a vector.
      Parameters:
      x - Array x contains the vector operand.
      Returns:
      Euclidean norm.
    • 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.
      alpha - The scaling factor.
      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.
      alpha - The scaling factor.
      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.
      Parameters:
      alpha - The scaling factor.
      x - Input and output vector to be scaled.
    • scal

      default void scal(float alpha, float[] x)
      Scales a vector with a scalar.
      Parameters:
      alpha - The scaling factor.
      x - Input and output vector to be scaled.
    • 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.
      Parameters:
      x - Input and output vector to be swapped.
      y - Input and output vector to be swapped.
    • swap

      default void swap(float[] x, float[] y)
      Swaps two vectors.
      Parameters:
      x - Input and output vector to be swapped.
      y - Input and output vector to be swapped.
    • iamax

      long iamax(int n, double[] x, int incx)
      Searches a vector for the first occurrence of 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 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 maximum absolute value.
      Parameters:
      x - Vector to be searched.
      Returns:
      The first index of the maximum absolute value of vector x.
    • iamax

      default long iamax(float[] x)
      Searches a vector for the first occurrence of the maximum absolute value.
      Parameters:
      x - Vector to be searched.
      Returns:
      The first index of the maximum absolute value of vector x.
    • 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, 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, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, 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, 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, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer x, int incx, double beta, org.bytedeco.javacpp.DoublePointer 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, 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, 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, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, 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, 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, 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, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, 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, 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, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer x, int incx, double beta, org.bytedeco.javacpp.DoublePointer 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, 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, 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, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, 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, 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, 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, DoubleBuffer A, DoubleBuffer x, int incx, double beta, 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, 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, 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, FloatBuffer A, FloatBuffer x, int incx, float beta, 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, 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, DoubleBuffer A, int lda, 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, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer 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, FloatBuffer A, int lda, 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, DoubleBuffer A, 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, FloatBuffer A, 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, 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, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, 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, 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, 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, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, 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, 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, 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, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, 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, 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, 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, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, 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, 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, DoubleBuffer x, int incx, DoubleBuffer y, int incy, 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, double alpha, org.bytedeco.javacpp.DoublePointer x, int incx, org.bytedeco.javacpp.DoublePointer y, int incy, org.bytedeco.javacpp.DoublePointer 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, FloatBuffer x, int incx, FloatBuffer y, int incy, 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, DoubleBuffer x, int incx, 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, double alpha, org.bytedeco.javacpp.DoublePointer x, int incx, org.bytedeco.javacpp.DoublePointer 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, FloatBuffer x, int incx, 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, DoubleBuffer x, int incx, 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.
      A - the symmetric packed matrix.
    • spr

      void spr(Layout layout, UPLO uplo, int n, float alpha, FloatBuffer x, int incx, 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.
      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, 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, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, double beta, 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, 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, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer B, int ldb, double beta, org.bytedeco.javacpp.DoublePointer 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, 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, 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, FloatBuffer A, int lda, FloatBuffer B, int ldb, float beta, 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, 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, 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, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, double beta, 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, 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, org.bytedeco.javacpp.DoublePointer A, int lda, org.bytedeco.javacpp.DoublePointer B, int ldb, double beta, org.bytedeco.javacpp.DoublePointer 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, 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, 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, FloatBuffer A, int lda, FloatBuffer B, int ldb, float beta, 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, y need not be set on input.
      C - the matrix C.
      ldc - the leading dimension of C as declared in the caller.