OpenBLAS

java.lang.Object
- smile.math.blas.openblas.OpenBLAS

All Implemented Interfaces:: BLAS, LAPACK

public class OpenBLAS
extends java.lang.Object
implements BLAS, LAPACK

OpenBLAS library wrapper.

Field Summary
- Fields inherited from interface smile.math.blas.BLAS
  engine
- Fields inherited from interface smile.math.blas.LAPACK
  engine

Constructor Summary

Constructors
Constructor and Description

OpenBLAS()

Constructors
Constructor and Description
`OpenBLAS()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`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.
`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.
`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.
`int`	`gbsv(Layout layout, int n, int kl, int ku, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb)` Solves a real system of linear equations.
`int`	`gbsv(Layout layout, int n, int kl, int ku, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.DoubleBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`gbsv(Layout layout, int n, int kl, int ku, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb)` Solves a real system of linear equations.
`int`	`gbsv(Layout layout, int n, int kl, int ku, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.FloatBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`gbtrf(Layout layout, int m, int n, int kl, int ku, double[] AB, int ldab, int[] ipiv)` Computes an LU factorization of a band matrix A using partial pivoting with row interchanges.
`int`	`gbtrf(Layout layout, int m, int n, int kl, int ku, java.nio.DoubleBuffer AB, int ldab, java.nio.IntBuffer ipiv)` Computes an LU factorization of a band matrix A using partial pivoting with row interchanges.
`int`	`gbtrf(Layout layout, int m, int n, int kl, int ku, float[] AB, int ldab, int[] ipiv)` Computes an LU factorization of a band matrix A using partial pivoting with row interchanges.
`int`	`gbtrf(Layout layout, int m, int n, int kl, int ku, java.nio.FloatBuffer AB, int ldab, java.nio.IntBuffer ipiv)` Computes an LU factorization of a band matrix A using partial pivoting with row interchanges.
`int`	`gbtrs(Layout layout, Transpose trans, int n, int kl, int ku, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb)` Solves a system of linear equations
`int`	`gbtrs(Layout layout, Transpose trans, int n, int kl, int ku, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.DoubleBuffer B, int ldb)` Solves a system of linear equations
`int`	`gbtrs(Layout layout, Transpose trans, int n, int kl, int ku, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb)` Solves a system of linear equations
`int`	`gbtrs(Layout layout, Transpose trans, int n, int kl, int ku, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.FloatBuffer B, int ldb)` Solves a system of linear equations
`int`	`geev(Layout layout, EVDJob jobvl, EVDJob jobvr, int n, double[] A, int lda, double[] wr, double[] wi, double[] Vl, int ldvl, double[] Vr, int ldvr)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors.
`int`	`geev(Layout layout, EVDJob jobvl, EVDJob jobvr, int n, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer wr, java.nio.DoubleBuffer wi, java.nio.DoubleBuffer Vl, int ldvl, java.nio.DoubleBuffer Vr, int ldvr)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors.
`int`	`geev(Layout layout, EVDJob jobvl, EVDJob jobvr, int n, float[] A, int lda, float[] wr, float[] wi, float[] Vl, int ldvl, float[] Vr, int ldvr)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors.
`int`	`geev(Layout layout, EVDJob jobvl, EVDJob jobvr, int n, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer wr, java.nio.FloatBuffer wi, java.nio.FloatBuffer Vl, int ldvl, java.nio.FloatBuffer Vr, int ldvr)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors.
`int`	`gels(Layout layout, Transpose trans, int m, int n, int nrhs, double[] A, int lda, double[] B, int ldb)` Solves an overdetermined or underdetermined system, using a QR or LQ factorization of A.
`int`	`gels(Layout layout, Transpose trans, int m, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb)` Solves an overdetermined or underdetermined system, using a QR or LQ factorization of A.
`int`	`gels(Layout layout, Transpose trans, int m, int n, int nrhs, float[] A, int lda, float[] B, int ldb)` Solves an overdetermined or underdetermined system, using a QR or LQ factorization of A.
`int`	`gels(Layout layout, Transpose trans, int m, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb)` Solves an overdetermined or underdetermined system, using a QR or LQ factorization of A.
`int`	`gelsd(Layout layout, int m, int n, int nrhs, double[] A, int lda, double[] B, int ldb, double[] s, double rcond, int[] rank)` Solves an overdetermined or underdetermined system, using a divide and conquer algorithm with the singular value decomposition (SVD) of A.
`int`	`gelsd(Layout layout, int m, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb, java.nio.DoubleBuffer s, double rcond, java.nio.IntBuffer rank)` Solves an overdetermined or underdetermined system, using a divide and conquer algorithm with the singular value decomposition (SVD) of A.
`int`	`gelsd(Layout layout, int m, int n, int nrhs, float[] A, int lda, float[] B, int ldb, float[] s, float rcond, int[] rank)` Solves an overdetermined or underdetermined system, using a divide and conquer algorithm with the singular value decomposition (SVD) of A.
`int`	`gelsd(Layout layout, int m, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb, java.nio.FloatBuffer s, float rcond, java.nio.IntBuffer rank)` Solves an overdetermined or underdetermined system, using a divide and conquer algorithm with the singular value decomposition (SVD) of A.
`int`	`gelss(Layout layout, int m, int n, int nrhs, double[] A, int lda, double[] B, int ldb, double[] s, double rcond, int[] rank)` Solves an overdetermined or underdetermined system, using the singular value decomposition (SVD) of A.
`int`	`gelss(Layout layout, int m, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb, java.nio.DoubleBuffer s, double rcond, java.nio.IntBuffer rank)` Solves an overdetermined or underdetermined system, using the singular value decomposition (SVD) of A.
`int`	`gelss(Layout layout, int m, int n, int nrhs, float[] A, int lda, float[] B, int ldb, float[] s, float rcond, int[] rank)` Solves an overdetermined or underdetermined system, using the singular value decomposition (SVD) of A.
`int`	`gelss(Layout layout, int m, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb, java.nio.FloatBuffer s, float rcond, java.nio.IntBuffer rank)` Solves an overdetermined or underdetermined system, using the singular value decomposition (SVD) of A.
`int`	`gelsy(Layout layout, int m, int n, int nrhs, double[] A, int lda, double[] B, int ldb, int[] jpvt, double rcond, int[] rank)` Solves an overdetermined or underdetermined system, using a complete orthogonal factorization of A.
`int`	`gelsy(Layout layout, int m, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb, java.nio.IntBuffer jpvt, double rcond, java.nio.IntBuffer rank)` Solves an overdetermined or underdetermined system, using a complete orthogonal factorization of A.
`int`	`gelsy(Layout layout, int m, int n, int nrhs, float[] A, int lda, float[] B, int ldb, int[] jpvt, float rcond, int[] rank)` Solves an overdetermined or underdetermined system, using a complete orthogonal factorization of A.
`int`	`gelsy(Layout layout, int m, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb, java.nio.IntBuffer jpvt, float rcond, java.nio.IntBuffer rank)` Solves an overdetermined or underdetermined system, using a complete orthogonal factorization of A.
`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.
`int`	`geqrf(Layout layout, int m, int n, double[] A, int lda, double[] tau)` Computes a QR factorization of a general M-by-N matrix A.
`int`	`geqrf(Layout layout, int m, int n, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer tau)` Computes a QR factorization of a general M-by-N matrix A.
`int`	`geqrf(Layout layout, int m, int n, float[] A, int lda, float[] tau)` Computes a QR factorization of a general M-by-N matrix A.
`int`	`geqrf(Layout layout, int m, int n, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer tau)` Computes a QR factorization of a general M-by-N matrix A.
`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.
`int`	`gesdd(Layout layout, SVDJob jobz, int m, int n, double[] A, int lda, double[] s, double[] U, int ldu, double[] VT, int ldvt)` Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
`int`	`gesdd(Layout layout, SVDJob jobz, int m, int n, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer s, java.nio.DoubleBuffer U, int ldu, java.nio.DoubleBuffer VT, int ldvt)` Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
`int`	`gesdd(Layout layout, SVDJob jobz, int m, int n, float[] A, int lda, float[] s, float[] U, int ldu, float[] VT, int ldvt)` Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
`int`	`gesdd(Layout layout, SVDJob jobz, int m, int n, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer s, java.nio.FloatBuffer U, int ldu, java.nio.FloatBuffer VT, int ldvt)` Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
`int`	`gesv(Layout layout, int n, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb)` Solves a real system of linear equations.
`int`	`gesv(Layout layout, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.DoubleBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`gesv(Layout layout, int n, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb)` Solves a real system of linear equations.
`int`	`gesv(Layout layout, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.FloatBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`gesvd(Layout layout, SVDJob jobu, SVDJob jobvt, int m, int n, double[] A, int lda, double[] s, double[] U, int ldu, double[] VT, int ldvt, double[] superb)` Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
`int`	`gesvd(Layout layout, SVDJob jobu, SVDJob jobvt, int m, int n, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer s, java.nio.DoubleBuffer U, int ldu, java.nio.DoubleBuffer VT, int ldvt, java.nio.DoubleBuffer superb)` Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
`int`	`gesvd(Layout layout, SVDJob jobu, SVDJob jobvt, int m, int n, float[] A, int lda, float[] s, float[] U, int ldu, float[] VT, int ldvt, float[] superb)` Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
`int`	`gesvd(Layout layout, SVDJob jobu, SVDJob jobvt, int m, int n, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer s, java.nio.FloatBuffer U, int ldu, java.nio.FloatBuffer VT, int ldvt, java.nio.FloatBuffer superb)` Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
`int`	`getrf(Layout layout, int m, int n, double[] A, int lda, int[] ipiv)` Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
`int`	`getrf(Layout layout, int m, int n, java.nio.DoubleBuffer A, int lda, java.nio.IntBuffer ipiv)` Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
`int`	`getrf(Layout layout, int m, int n, float[] A, int lda, int[] ipiv)` Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
`int`	`getrf(Layout layout, int m, int n, java.nio.FloatBuffer A, int lda, java.nio.IntBuffer ipiv)` Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
`int`	`getrf2(Layout layout, int m, int n, double[] A, int lda, int[] ipiv)` Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
`int`	`getrf2(Layout layout, int m, int n, java.nio.DoubleBuffer A, int lda, java.nio.IntBuffer ipiv)` Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
`int`	`getrf2(Layout layout, int m, int n, float[] A, int lda, int[] ipiv)` Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
`int`	`getrf2(Layout layout, int m, int n, java.nio.FloatBuffer A, int lda, java.nio.IntBuffer ipiv)` Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
`int`	`getrs(Layout layout, Transpose trans, int n, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb)` Solves a system of linear equations
`int`	`getrs(Layout layout, Transpose trans, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.DoubleBuffer B, int ldb)` Solves a system of linear equations
`int`	`getrs(Layout layout, Transpose trans, int n, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb)` Solves a system of linear equations
`int`	`getrs(Layout layout, Transpose trans, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.FloatBuffer B, int ldb)` Solves a system of linear equations
`int`	`ggglm(Layout layout, int n, int m, int p, double[] A, int lda, double[] B, int ldb, double[] d, double[] x, double[] y)` Solves a general Gauss-Markov linear model (GLM) problem.
`int`	`ggglm(Layout layout, int n, int m, int p, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb, java.nio.DoubleBuffer d, java.nio.DoubleBuffer x, java.nio.DoubleBuffer y)` Solves a general Gauss-Markov linear model (GLM) problem.
`int`	`ggglm(Layout layout, int n, int m, int p, float[] A, int lda, float[] B, int ldb, float[] d, float[] x, float[] y)` Solves a general Gauss-Markov linear model (GLM) problem.
`int`	`ggglm(Layout layout, int n, int m, int p, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb, java.nio.FloatBuffer d, java.nio.FloatBuffer x, java.nio.FloatBuffer y)` Solves a general Gauss-Markov linear model (GLM) problem.
`int`	`gglse(Layout layout, int m, int n, int p, double[] A, int lda, double[] B, int ldb, double[] c, double[] d, double[] x)` Solves a linear equality-constrained least squares (LSE) problem.
`int`	`gglse(Layout layout, int m, int n, int p, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb, java.nio.DoubleBuffer c, java.nio.DoubleBuffer d, java.nio.DoubleBuffer x)` Solves a linear equality-constrained least squares (LSE) problem.
`int`	`gglse(Layout layout, int m, int n, int p, float[] A, int lda, float[] B, int ldb, float[] c, float[] d, float[] x)` Solves a linear equality-constrained least squares (LSE) problem.
`int`	`gglse(Layout layout, int m, int n, int p, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb, java.nio.FloatBuffer c, java.nio.FloatBuffer d, java.nio.FloatBuffer x)` Solves a linear equality-constrained least squares (LSE) problem.
`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.
`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.
`int`	`ormqr(Layout layout, Side side, Transpose trans, int m, int n, int k, double[] A, int lda, double[] tau, double[] C, int ldc)` Overwrites the general real M-by-N matrix C with
`int`	`ormqr(Layout layout, Side side, Transpose trans, int m, int n, int k, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer tau, java.nio.DoubleBuffer C, int ldc)` Overwrites the general real M-by-N matrix C with
`int`	`ormqr(Layout layout, Side side, Transpose trans, int m, int n, int k, float[] A, int lda, float[] tau, float[] C, int ldc)` Overwrites the general real M-by-N matrix C with
`int`	`ormqr(Layout layout, Side side, Transpose trans, int m, int n, int k, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer tau, java.nio.FloatBuffer C, int ldc)` Overwrites the general real M-by-N matrix C with
`int`	`pbtrf(Layout layout, UPLO uplo, int n, int kd, double[] AB, int ldab)` Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
`int`	`pbtrf(Layout layout, UPLO uplo, int n, int kd, java.nio.DoubleBuffer AB, int ldab)` Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
`int`	`pbtrf(Layout layout, UPLO uplo, int n, int kd, float[] AB, int ldab)` Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
`int`	`pbtrf(Layout layout, UPLO uplo, int n, int kd, java.nio.FloatBuffer AB, int ldab)` Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
`int`	`pbtrs(Layout layout, UPLO uplo, int n, int kd, int nrhs, double[] AB, int ldab, double[] B, int ldb)` Solves a system of linear equations
`int`	`pbtrs(Layout layout, UPLO uplo, int n, int kd, int nrhs, java.nio.DoubleBuffer AB, int ldab, java.nio.DoubleBuffer B, int ldb)` Solves a system of linear equations
`int`	`pbtrs(Layout layout, UPLO uplo, int n, int kd, int nrhs, float[] AB, int ldab, float[] B, int ldb)` Solves a system of linear equations
`int`	`pbtrs(Layout layout, UPLO uplo, int n, int kd, int nrhs, java.nio.FloatBuffer AB, int ldab, java.nio.FloatBuffer B, int ldb)` Solves a system of linear equations
`int`	`posv(Layout layout, UPLO uplo, int n, int nrhs, double[] A, int lda, double[] B, int ldb)` Solves a real system of linear equations.
`int`	`posv(Layout layout, UPLO uplo, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`posv(Layout layout, UPLO uplo, int n, int nrhs, float[] A, int lda, float[] B, int ldb)` Solves a real system of linear equations.
`int`	`posv(Layout layout, UPLO uplo, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`potrf(Layout layout, UPLO uplo, int n, double[] A, int lda)` Computes the Cholesky factorization of a real symmetric positive definite matrix A.
`int`	`potrf(Layout layout, UPLO uplo, int n, java.nio.DoubleBuffer A, int lda)` Computes the Cholesky factorization of a real symmetric positive definite matrix A.
`int`	`potrf(Layout layout, UPLO uplo, int n, float[] A, int lda)` Computes the Cholesky factorization of a real symmetric positive definite matrix A.
`int`	`potrf(Layout layout, UPLO uplo, int n, java.nio.FloatBuffer A, int lda)` Computes the Cholesky factorization of a real symmetric positive definite matrix A.
`int`	`potrf2(Layout layout, UPLO uplo, int n, double[] A, int lda)` Computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm.
`int`	`potrf2(Layout layout, UPLO uplo, int n, java.nio.DoubleBuffer A, int lda)` Computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm.
`int`	`potrf2(Layout layout, UPLO uplo, int n, float[] A, int lda)` Computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm.
`int`	`potrf2(Layout layout, UPLO uplo, int n, java.nio.FloatBuffer A, int lda)` Computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm.
`int`	`potrs(Layout layout, UPLO uplo, int n, int nrhs, double[] A, int lda, double[] B, int ldb)` Solves a system of linear equations
`int`	`potrs(Layout layout, UPLO uplo, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb)` Solves a system of linear equations
`int`	`potrs(Layout layout, UPLO uplo, int n, int nrhs, float[] A, int lda, float[] B, int ldb)` Solves a system of linear equations
`int`	`potrs(Layout layout, UPLO uplo, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb)` Solves a system of linear equations
`int`	`ppsv(Layout layout, UPLO uplo, int n, int nrhs, double[] A, double[] B, int ldb)` Solves a real system of linear equations.
`int`	`ppsv(Layout layout, UPLO uplo, int n, int nrhs, java.nio.DoubleBuffer A, java.nio.DoubleBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`ppsv(Layout layout, UPLO uplo, int n, int nrhs, float[] A, float[] B, int ldb)` Solves a real system of linear equations.
`int`	`ppsv(Layout layout, UPLO uplo, int n, int nrhs, java.nio.FloatBuffer A, java.nio.FloatBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`pptrf(Layout layout, UPLO uplo, int n, double[] AP)` Computes the Cholesky factorization of a real symmetric positive definite packed matrix A.
`int`	`pptrf(Layout layout, UPLO uplo, int n, java.nio.DoubleBuffer AP)` Computes the Cholesky factorization of a real symmetric positive definite packed matrix A.
`int`	`pptrf(Layout layout, UPLO uplo, int n, float[] AP)` Computes the Cholesky factorization of a real symmetric positive definite packed matrix A.
`int`	`pptrf(Layout layout, UPLO uplo, int n, java.nio.FloatBuffer AP)` Computes the Cholesky factorization of a real symmetric positive definite packed matrix A.
`int`	`pptrs(Layout layout, UPLO uplo, int n, int nrhs, double[] AP, double[] B, int ldb)` Solves a system of linear equations
`int`	`pptrs(Layout layout, UPLO uplo, int n, int nrhs, java.nio.DoubleBuffer AP, java.nio.DoubleBuffer B, int ldb)` Solves a system of linear equations
`int`	`pptrs(Layout layout, UPLO uplo, int n, int nrhs, float[] AP, float[] B, int ldb)` Solves a system of linear equations
`int`	`pptrs(Layout layout, UPLO uplo, int n, int nrhs, java.nio.FloatBuffer AP, java.nio.FloatBuffer B, int ldb)` Solves a system of linear equations
`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.
`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.
`int`	`spsv(Layout layout, UPLO uplo, int n, int nrhs, double[] A, int[] ipiv, double[] B, int ldb)` Solves a real system of linear equations.
`int`	`spsv(Layout layout, UPLO uplo, int n, int nrhs, java.nio.DoubleBuffer A, java.nio.IntBuffer ipiv, java.nio.DoubleBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`spsv(Layout layout, UPLO uplo, int n, int nrhs, float[] A, int[] ipiv, float[] B, int ldb)` Solves a real system of linear equations.
`int`	`spsv(Layout layout, UPLO uplo, int n, int nrhs, java.nio.FloatBuffer A, java.nio.IntBuffer ipiv, java.nio.FloatBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`sptrf(Layout layout, UPLO uplo, int n, double[] AP, int[] ipiv)` Computes the Bunch–Kaufman factorization of a symmetric packed matrix A.
`int`	`sptrf(Layout layout, UPLO uplo, int n, java.nio.DoubleBuffer AP, java.nio.IntBuffer ipiv)` Computes the Bunch–Kaufman factorization of a symmetric packed matrix A.
`int`	`sptrf(Layout layout, UPLO uplo, int n, float[] AP, int[] ipiv)` Computes the Bunch–Kaufman factorization of a symmetric packed matrix A.
`int`	`sptrf(Layout layout, UPLO uplo, int n, java.nio.FloatBuffer AP, java.nio.IntBuffer ipiv)` Computes the Bunch–Kaufman factorization of a symmetric packed matrix A.
`int`	`sptrs(Layout layout, UPLO uplo, int n, int nrhs, double[] AP, int[] ipiv, double[] B, int ldb)` Solves a system of linear equations
`int`	`sptrs(Layout layout, UPLO uplo, int n, int nrhs, java.nio.DoubleBuffer AP, java.nio.IntBuffer ipiv, java.nio.DoubleBuffer B, int ldb)` Solves a system of linear equations
`int`	`sptrs(Layout layout, UPLO uplo, int n, int nrhs, float[] AP, int[] ipiv, float[] B, int ldb)` Solves a system of linear equations
`int`	`sptrs(Layout layout, UPLO uplo, int n, int nrhs, java.nio.FloatBuffer AP, java.nio.IntBuffer ipiv, java.nio.FloatBuffer B, int ldb)` Solves a system of linear equations
`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.
`int`	`syev(Layout layout, EVDJob jobz, UPLO uplo, int n, double[] A, int lda, double[] w)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syev(Layout layout, EVDJob jobz, UPLO uplo, int n, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer w)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syev(Layout layout, EVDJob jobz, UPLO uplo, int n, float[] A, int lda, float[] w)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syev(Layout layout, EVDJob jobz, UPLO uplo, int n, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer w)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syevd(Layout layout, EVDJob jobz, UPLO uplo, int n, double[] A, int lda, double[] w)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syevd(Layout layout, EVDJob jobz, UPLO uplo, int n, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer w)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syevd(Layout layout, EVDJob jobz, UPLO uplo, int n, float[] A, int lda, float[] w)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syevd(Layout layout, EVDJob jobz, UPLO uplo, int n, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer w)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syevr(Layout layout, EVDJob jobz, EigenRange range, UPLO uplo, int n, double[] A, int lda, double vl, double vu, int il, int iu, double abstol, int[] m, double[] w, double[] Z, int ldz, int[] isuppz)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syevr(Layout layout, EVDJob jobz, EigenRange range, UPLO uplo, int n, java.nio.DoubleBuffer A, int lda, double vl, double vu, int il, int iu, double abstol, java.nio.IntBuffer m, java.nio.DoubleBuffer w, java.nio.DoubleBuffer Z, int ldz, java.nio.IntBuffer isuppz)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syevr(Layout layout, EVDJob jobz, EigenRange range, UPLO uplo, int n, float[] A, int lda, float vl, float vu, int il, int iu, float abstol, int[] m, float[] w, float[] Z, int ldz, int[] isuppz)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`int`	`syevr(Layout layout, EVDJob jobz, EigenRange range, UPLO uplo, int n, java.nio.FloatBuffer A, int lda, float vl, float vu, int il, int iu, float abstol, java.nio.IntBuffer m, java.nio.FloatBuffer w, java.nio.FloatBuffer Z, int ldz, java.nio.IntBuffer isuppz)` Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
`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.
`int`	`sysv(Layout layout, UPLO uplo, int n, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb)` Solves a real system of linear equations.
`int`	`sysv(Layout layout, UPLO uplo, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.DoubleBuffer B, int ldb)` Solves a real system of linear equations.
`int`	`sysv(Layout layout, UPLO uplo, int n, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb)` Solves a real system of linear equations.
`int`	`sysv(Layout layout, UPLO uplo, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.IntBuffer ipiv, java.nio.FloatBuffer B, int ldb)` Solves a real system of linear equations.
`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.
`int`	`trtrs(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, int nrhs, double[] A, int lda, double[] B, int ldb)` Solves a triangular system of the form
`int`	`trtrs(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, int nrhs, java.nio.DoubleBuffer A, int lda, java.nio.DoubleBuffer B, int ldb)` Solves a triangular system of the form
`int`	`trtrs(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, int nrhs, float[] A, int lda, float[] B, int ldb)` Solves a triangular system of the form
`int`	`trtrs(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, int nrhs, java.nio.FloatBuffer A, int lda, java.nio.FloatBuffer B, int ldb)` Solves a triangular system of the form

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

Methods inherited from interface smile.math.blas.BLAS
asum, asum, axpy, axpy, dot, dot, getInstance, iamax, iamax, MKL, nrm2, nrm2, scal, scal, swap, swap

Methods inherited from interface smile.math.blas.LAPACK
getInstance, MKL

- Constructor Detail
  - OpenBLAS
```
public OpenBLAS()
```
- Method Detail
  - asum
```
public double asum(int n,
                   double[] x,
                   int incx)
```
    Description copied from interface: BLAS
    
    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.
    
    Specified by:
    
    asum in interface BLAS
    
    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
```
public float asum(int n,
                  float[] x,
                  int incx)
```
    Description copied from interface: BLAS
    
    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.
    
    Specified by:
    
    asum in interface BLAS
    
    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.
  - axpy
```
public void axpy(int n,
                 double alpha,
                 double[] x,
                 int incx,
                 double[] y,
                 int incy)
```
    Description copied from interface: BLAS
    
    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.
    
    Specified by:
    
    axpy in interface BLAS
    
    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
```
public void axpy(int n,
                 float alpha,
                 float[] x,
                 int incx,
                 float[] y,
                 int incy)
```
    Description copied from interface: BLAS
    
    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.
    
    Specified by:
    
    axpy in interface BLAS
    
    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.
  - dot
```
public double dot(int n,
                  double[] x,
                  int incx,
                  double[] y,
                  int incy)
```
    Description copied from interface: BLAS
    
    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.
    
    Specified by:
    
    dot in interface BLAS
    
    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
```
public float dot(int n,
                 float[] x,
                 int incx,
                 float[] y,
                 int incy)
```
    Description copied from interface: BLAS
    
    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.
    
    Specified by:
    
    dot in interface BLAS
    
    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.
  - nrm2
```
public double nrm2(int n,
                   double[] x,
                   int incx)
```
    Description copied from interface: BLAS
    
    Computes the Euclidean (L2) norm of a vector.
    
    Specified by:
    
    nrm2 in interface BLAS
    
    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
```
public float nrm2(int n,
                  float[] x,
                  int incx)
```
    Description copied from interface: BLAS
    
    Computes the Euclidean (L2) norm of a vector.
    
    Specified by:
    
    nrm2 in interface BLAS
    
    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.
  - scal
```
public void scal(int n,
                 double alpha,
                 double[] x,
                 int incx)
```
    Description copied from interface: BLAS
    
    Scales a vector with a scalar.
    
    Specified by:
    
    scal in interface BLAS
    
    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
```
public void scal(int n,
                 float alpha,
                 float[] x,
                 int incx)
```
    Description copied from interface: BLAS
    
    Scales a vector with a scalar.
    
    Specified by:
    
    scal in interface BLAS
    
    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.
  - swap
```
public void swap(int n,
                 double[] x,
                 int incx,
                 double[] y,
                 int incy)
```
    Description copied from interface: BLAS
    
    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.
    
    Specified by:
    
    swap in interface BLAS
    
    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
```
public void swap(int n,
                 float[] x,
                 int incx,
                 float[] y,
                 int incy)
```
    Description copied from interface: BLAS
    
    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.
    
    Specified by:
    
    swap in interface BLAS
    
    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.
  - iamax
```
public long iamax(int n,
                  double[] x,
                  int incx)
```
    Description copied from interface: BLAS
    
    Searches a vector for the first occurrence of the the maximum absolute value.
    
    Specified by:
    
    iamax in interface BLAS
    
    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
```
public long iamax(int n,
                  float[] x,
                  int incx)
```
    Description copied from interface: BLAS
    
    Searches a vector for the first occurrence of the the maximum absolute value.
    
    Specified by:
    
    iamax in interface BLAS
    
    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.
  - gemv
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    gemv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    gemv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    gemv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    gemv in interface BLAS
    
    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
```
public void symv(Layout layout,
                 UPLO uplo,
                 int n,
                 double alpha,
                 double[] A,
                 int lda,
                 double[] x,
                 int incx,
                 double beta,
                 double[] y,
                 int incy)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    symv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    symv in interface BLAS
    
    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
```
public void symv(Layout layout,
                 UPLO uplo,
                 int n,
                 float alpha,
                 float[] A,
                 int lda,
                 float[] x,
                 int incx,
                 float beta,
                 float[] y,
                 int incy)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    symv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    symv in interface BLAS
    
    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
```
public void spmv(Layout layout,
                 UPLO uplo,
                 int n,
                 double alpha,
                 double[] A,
                 double[] x,
                 int incx,
                 double beta,
                 double[] y,
                 int incy)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    spmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    spmv in interface BLAS
    
    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
```
public void spmv(Layout layout,
                 UPLO uplo,
                 int n,
                 float alpha,
                 float[] A,
                 float[] x,
                 int incx,
                 float beta,
                 float[] y,
                 int incy)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    spmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    spmv in interface BLAS
    
    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
```
public void trmv(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 double[] A,
                 int lda,
                 double[] x,
                 int incx)
```
    Description copied from interface: BLAS
    Performs the matrix-vector operation using a triangular matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Specified by:
    
    trmv in interface BLAS
    
    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
```
public void trmv(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer x,
                 int incx)
```
    Description copied from interface: BLAS
    Performs the matrix-vector operation using a triangular matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Specified by:
    
    trmv in interface BLAS
    
    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
```
public void trmv(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 float[] A,
                 int lda,
                 float[] x,
                 int incx)
```
    Description copied from interface: BLAS
    Performs the matrix-vector operation using a triangular matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Specified by:
    
    trmv in interface BLAS
    
    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
```
public void trmv(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer x,
                 int incx)
```
    Description copied from interface: BLAS
    Performs the matrix-vector operation using a triangular matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Specified by:
    
    trmv in interface BLAS
    
    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
```
public void tpmv(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 double[] A,
                 double[] x,
                 int incx)
```
    Description copied from interface: BLAS
    Performs the matrix-vector operation using a triangular packed matrix.
```
     x := A*x
 
```
    or
```
     y := A'*x
 
```
    Specified by:
    
    tpmv in interface BLAS
    
    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
```
public void tpmv(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 java.nio.DoubleBuffer A,
                 java.nio.DoubleBuffer x,
                 int incx)
```
    Description copied from interface: BLAS
    Performs the matrix-vector operation using a triangular packed matrix.
```
     x := A*x
 
```
    or
```
     y := A'*x
 
```
    Specified by:
    
    tpmv in interface BLAS
    
    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
```
public void tpmv(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 float[] A,
                 float[] x,
                 int incx)
```
    Description copied from interface: BLAS
    Performs the matrix-vector operation using a triangular packed matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Specified by:
    
    tpmv in interface BLAS
    
    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
```
public void tpmv(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 java.nio.FloatBuffer A,
                 java.nio.FloatBuffer x,
                 int incx)
```
    Description copied from interface: BLAS
    Performs the matrix-vector operation using a triangular packed matrix.
```
     x := A*x
 
```
    or
```
     x := A'*x
 
```
    Specified by:
    
    tpmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    gbmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    gbmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    gbmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    gbmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    sbmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    sbmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    sbmv in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    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.
    Specified by:
    
    sbmv in interface BLAS
    
    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
```
public void ger(Layout layout,
                int m,
                int n,
                double alpha,
                double[] x,
                int incx,
                double[] y,
                int incy,
                double[] A,
                int lda)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation.
```
     A := A + alpha*x*y'
 
```
    Specified by:
    
    ger in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation.
```
     A := A + alpha*x*y'
 
```
    Specified by:
    
    ger in interface BLAS
    
    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
```
public void ger(Layout layout,
                int m,
                int n,
                float alpha,
                float[] x,
                int incx,
                float[] y,
                int incy,
                float[] A,
                int lda)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation.
```
     A := A + alpha*x*y'
 
```
    Specified by:
    
    ger in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation.
```
     A := A + alpha*x*y'
 
```
    Specified by:
    
    ger in interface BLAS
    
    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
```
public void syr(Layout layout,
                UPLO uplo,
                int n,
                double alpha,
                double[] x,
                int incx,
                double[] A,
                int lda)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation to symmetric matrix.
```
     A := A + alpha*x*x'
 
```
    Specified by:
    
    syr in interface BLAS
    
    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
```
public void syr(Layout layout,
                UPLO uplo,
                int n,
                double alpha,
                java.nio.DoubleBuffer x,
                int incx,
                java.nio.DoubleBuffer A,
                int lda)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation to symmetric matrix.
```
     A := A + alpha*x*x'
 
```
    Specified by:
    
    syr in interface BLAS
    
    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
```
public void syr(Layout layout,
                UPLO uplo,
                int n,
                float alpha,
                float[] x,
                int incx,
                float[] A,
                int lda)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation to symmetric matrix.
```
     A := A + alpha*x*x'
 
```
    Specified by:
    
    syr in interface BLAS
    
    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
```
public void syr(Layout layout,
                UPLO uplo,
                int n,
                float alpha,
                java.nio.FloatBuffer x,
                int incx,
                java.nio.FloatBuffer A,
                int lda)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation to symmetric matrix.
```
     A := A + alpha*x*x'
 
```
    Specified by:
    
    syr in interface BLAS
    
    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
```
public void spr(Layout layout,
                UPLO uplo,
                int n,
                double alpha,
                double[] x,
                int incx,
                double[] A)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation to symmetric packed matrix.
```
     A := A + alpha*x*x'
 
```
    Specified by:
    
    spr in interface BLAS
    
    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
```
public void spr(Layout layout,
                UPLO uplo,
                int n,
                double alpha,
                java.nio.DoubleBuffer x,
                int incx,
                java.nio.DoubleBuffer A)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation to symmetric packed matrix.
```
     A := A + alpha*x*x'
 
```
    Specified by:
    
    spr in interface BLAS
    
    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
```
public void spr(Layout layout,
                UPLO uplo,
                int n,
                float alpha,
                float[] x,
                int incx,
                float[] A)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation to symmetric packed matrix.
```
     A := A + alpha*x*x'
 
```
    Specified by:
    
    spr in interface BLAS
    
    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
```
public void spr(Layout layout,
                UPLO uplo,
                int n,
                float alpha,
                java.nio.FloatBuffer x,
                int incx,
                java.nio.FloatBuffer A)
```
    Description copied from interface: BLAS
    Performs the rank-1 update operation to symmetric packed matrix.
```
     A := A + alpha*x*x'
 
```
    Specified by:
    
    spr in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the matrix-matrix operation.
```
     C := alpha*A*B + beta*C
 
```
    Specified by:
    
    gemm in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the matrix-matrix operation.
```
     C := alpha*A*B + beta*C
 
```
    Specified by:
    
    gemm in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the matrix-matrix operation.
```
     C := alpha*A*B + beta*C
 
```
    Specified by:
    
    gemm in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the matrix-matrix operation.
```
     C := alpha*A*B + beta*C
 
```
    Specified by:
    
    gemm in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the matrix-matrix operation where the matrix A is symmetric.
```
     C := alpha*A*B + beta*C
 
```
    or
```
     C := alpha*B*A + beta*C
 
```
    Specified by:
    
    symm in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the matrix-matrix operation where the matrix A is symmetric.
```
     C := alpha*A*B + beta*C
 
```
    or
```
     C := alpha*B*A + beta*C
 
```
    Specified by:
    
    symm in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the matrix-matrix operation where one input matrix is symmetric.
```
     C := alpha*A*B + beta*C
 
```
    Specified by:
    
    symm in interface BLAS
    
    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
```
public 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)
```
    Description copied from interface: BLAS
    Performs the matrix-matrix operation where one input matrix is symmetric.
```
     C := alpha*A*B + beta*C
 
```
    Specified by:
    
    symm in interface BLAS
    
    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.
  - gesv
```
public int gesv(Layout layout,
                int n,
                int nrhs,
                double[] A,
                int lda,
                int[] ipiv,
                double[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as
```
     A = P * L * U
 
```
    where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    gesv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
  - gesv
```
public int gesv(Layout layout,
                int n,
                int nrhs,
                java.nio.DoubleBuffer A,
                int lda,
                java.nio.IntBuffer ipiv,
                java.nio.DoubleBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as
```
     A = P * L * U
 
```
    where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    gesv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
  - gesv
```
public int gesv(Layout layout,
                int n,
                int nrhs,
                float[] A,
                int lda,
                int[] ipiv,
                float[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as
```
     A = P * L * U
 
```
    where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    gesv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
  - gesv
```
public int gesv(Layout layout,
                int n,
                int nrhs,
                java.nio.FloatBuffer A,
                int lda,
                java.nio.IntBuffer ipiv,
                java.nio.FloatBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as
```
     A = P * L * U
 
```
    where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    gesv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
  - sysv
```
public int sysv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                double[] A,
                int lda,
                int[] ipiv,
                double[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as
```
     A = U * D * U**T,  if UPLO = 'U'
 
```
    or
```
     A = L * D * L**T,  if UPLO = 'L'
 
```
    where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    sysv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - sysv
```
public int sysv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                java.nio.DoubleBuffer A,
                int lda,
                java.nio.IntBuffer ipiv,
                java.nio.DoubleBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as
```
     A = U * D * U**T,  if UPLO = 'U'
 
```
    or
```
     A = L * D * L**T,  if UPLO = 'L'
 
```
    where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    sysv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - sysv
```
public int sysv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                float[] A,
                int lda,
                int[] ipiv,
                float[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as
```
     A = U * D * U**T,  if UPLO = 'U'
 
```
    or
```
     A = L * D * L**T,  if UPLO = 'L'
 
```
    where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    sysv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - sysv
```
public int sysv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                java.nio.FloatBuffer A,
                int lda,
                java.nio.IntBuffer ipiv,
                java.nio.FloatBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as
```
     A = U * D * U**T,  if UPLO = 'U'
 
```
    or
```
     A = L * D * L**T,  if UPLO = 'L'
 
```
    where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    sysv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - spsv
```
public int spsv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                double[] A,
                int[] ipiv,
                double[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as
```
     A = U * D * U**T,  if UPLO = 'U'
 
```
    or
```
     A = L * D * L**T,  if UPLO = 'L'
 
```
    where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    spsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, in the same storage format as A.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - spsv
```
public int spsv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                java.nio.DoubleBuffer A,
                java.nio.IntBuffer ipiv,
                java.nio.DoubleBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as
```
     A = U * D * U**T,  if UPLO = 'U'
 
```
    or
```
     A = L * D * L**T,  if UPLO = 'L'
 
```
    where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    spsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, in the same storage format as A.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - spsv
```
public int spsv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                float[] A,
                int[] ipiv,
                float[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as
```
     A = U * D * U**T,  if UPLO = 'U'
 
```
    or
```
     A = L * D * L**T,  if UPLO = 'L'
 
```
    where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    spsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, in the same storage format as A.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - spsv
```
public int spsv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                java.nio.FloatBuffer A,
                java.nio.IntBuffer ipiv,
                java.nio.FloatBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric matrix and X and B are N-by-NRHS matrices. The diagonal pivoting method is used to factor A as
```
     A = U * D * U**T,  if UPLO = 'U'
 
```
    or
```
     A = L * D * L**T,  if UPLO = 'L'
 
```
    where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    spsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, in the same storage format as A.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - posv
```
public int posv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                double[] A,
                int lda,
                double[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
```
     A = U**T* U,  if UPLO = 'U'
 
```
    or
```
     A = L * L**T,  if UPLO = 'L'
 
```
    where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    posv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - posv
```
public int posv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                java.nio.DoubleBuffer A,
                int lda,
                java.nio.DoubleBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
```
     A = U**T* U,  if UPLO = 'U'
 
```
    or
```
     A = L * L**T,  if UPLO = 'L'
 
```
    where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    posv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - posv
```
public int posv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                float[] A,
                int lda,
                float[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
```
     A = U**T* U,  if UPLO = 'U'
 
```
    or
```
     A = L * L**T,  if UPLO = 'L'
 
```
    where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    posv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - posv
```
public int posv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                java.nio.FloatBuffer A,
                int lda,
                java.nio.FloatBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
```
     A = U**T* U,  if UPLO = 'U'
 
```
    or
```
     A = L * L**T,  if UPLO = 'L'
 
```
    where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    posv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - ppsv
```
public int ppsv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                double[] A,
                double[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
```
     A = U**T* U,  if UPLO = 'U'
 
```
    or
```
     A = L * L**T,  if UPLO = 'L'
 
```
    where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    ppsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, in the same storage format as A.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - ppsv
```
public int ppsv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                java.nio.DoubleBuffer A,
                java.nio.DoubleBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
```
     A = U**T* U,  if UPLO = 'U'
 
```
    or
```
     A = L * L**T,  if UPLO = 'L'
 
```
    where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    ppsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, in the same storage format as A.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - ppsv
```
public int ppsv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                float[] A,
                float[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
```
     A = U**T* U,  if UPLO = 'U'
 
```
    or
```
     A = L * L**T,  if UPLO = 'L'
 
```
    where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    ppsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, in the same storage format as A.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - ppsv
```
public int ppsv(Layout layout,
                UPLO uplo,
                int n,
                int nrhs,
                java.nio.FloatBuffer A,
                java.nio.FloatBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as
```
     A = U**T* U,  if UPLO = 'U'
 
```
    or
```
     A = L * L**T,  if UPLO = 'L'
 
```
    where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    ppsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The symmetric packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, in the same storage format as A.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.
  - gbsv
```
public int gbsv(Layout layout,
                int n,
                int kl,
                int ku,
                int nrhs,
                double[] A,
                int lda,
                int[] ipiv,
                double[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N band matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as
```
     A = P * L * U
 
```
    where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    gbsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kl - the number of subdiagonal elements of band matrix.
    
    ku - the number of superdiagonal elements of band matrix.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On entry, the matrix A in band storage, in rows KL+1 to 2*KL+KU+1; rows 1 to KL of the array need not be set. The j-th column of A is stored in the j-th column of the matrix AB as follows: AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL) On exit, details of the factorization: U is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and the multipliers used during the factorization are stored in rows KL+KU+2 to 2*KL+KU+1.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
  - gbsv
```
public int gbsv(Layout layout,
                int n,
                int kl,
                int ku,
                int nrhs,
                java.nio.DoubleBuffer A,
                int lda,
                java.nio.IntBuffer ipiv,
                java.nio.DoubleBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N band matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as
```
     A = P * L * U
 
```
    where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    gbsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kl - the number of subdiagonal elements of band matrix.
    
    ku - the number of superdiagonal elements of band matrix.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On entry, the matrix A in band storage, in rows KL+1 to 2*KL+KU+1; rows 1 to KL of the array need not be set. The j-th column of A is stored in the j-th column of the matrix AB as follows: AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL) On exit, details of the factorization: U is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and the multipliers used during the factorization are stored in rows KL+KU+2 to 2*KL+KU+1.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
  - gbsv
```
public int gbsv(Layout layout,
                int n,
                int kl,
                int ku,
                int nrhs,
                float[] A,
                int lda,
                int[] ipiv,
                float[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N band matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as
```
     A = P * L * U
 
```
    where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    gbsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kl - the number of subdiagonal elements of band matrix.
    
    ku - the number of superdiagonal elements of band matrix.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On entry, the matrix A in band storage, in rows KL+1 to 2*KL+KU+1; rows 1 to KL of the array need not be set. The j-th column of A is stored in the j-th column of the matrix AB as follows: AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL) On exit, details of the factorization: U is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and the multipliers used during the factorization are stored in rows KL+KU+2 to 2*KL+KU+1.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
  - gbsv
```
public int gbsv(Layout layout,
                int n,
                int kl,
                int ku,
                int nrhs,
                java.nio.FloatBuffer A,
                int lda,
                java.nio.IntBuffer ipiv,
                java.nio.FloatBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    Solves a real system of linear equations.
```
     A * X = B
 
```
    where A is an N-by-N band matrix and X and B are N-by-NRHS matrices. The LU decomposition with partial pivoting and row interchanges is used to factor A as
```
     A = P * L * U
 
```
    where P is a permutation matrix, L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.
    Specified by:
    
    gbsv in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kl - the number of subdiagonal elements of band matrix.
    
    ku - the number of superdiagonal elements of band matrix.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On entry, the matrix A in band storage, in rows KL+1 to 2*KL+KU+1; rows 1 to KL of the array need not be set. The j-th column of A is stored in the j-th column of the matrix AB as follows: AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL) On exit, details of the factorization: U is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and the multipliers used during the factorization are stored in rows KL+KU+2 to 2*KL+KU+1.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.
  - gels
```
public int gels(Layout layout,
                Transpose trans,
                int m,
                int n,
                int nrhs,
                double[] A,
                int lda,
                double[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a QR or LQ factorization of A. It is assumed that A has full rank.
    
    Specified by:
    
    gels in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    trans - The normal or transpose of the matrix A.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gels
```
public int gels(Layout layout,
                Transpose trans,
                int m,
                int n,
                int nrhs,
                java.nio.DoubleBuffer A,
                int lda,
                java.nio.DoubleBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a QR or LQ factorization of A. It is assumed that A has full rank.
    
    Specified by:
    
    gels in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    trans - The normal or transpose of the matrix A.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gels
```
public int gels(Layout layout,
                Transpose trans,
                int m,
                int n,
                int nrhs,
                float[] A,
                int lda,
                float[] B,
                int ldb)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a QR or LQ factorization of A. It is assumed that A has full rank.
    
    Specified by:
    
    gels in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    trans - The normal or transpose of the matrix A.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gels
```
public int gels(Layout layout,
                Transpose trans,
                int m,
                int n,
                int nrhs,
                java.nio.FloatBuffer A,
                int lda,
                java.nio.FloatBuffer B,
                int ldb)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a QR or LQ factorization of A. It is assumed that A has full rank.
    
    Specified by:
    
    gels in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    trans - The normal or transpose of the matrix A.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelsy
```
public int gelsy(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 double[] A,
                 int lda,
                 double[] B,
                 int ldb,
                 int[] jpvt,
                 double rcond,
                 int[] rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a complete orthogonal factorization of A. A may be rank-deficient.
    
    Specified by:
    
    gelsy in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    jpvt - On entry, if JPVT(i) != 0, the i-th column of A is permuted to the front of AP, otherwise column i is a free column. On exit, if JPVT(i) = k, then the i-th column of AP was the k-th column of A.
    
    rcond - RCOND is used to determine the effective rank of A, which is defined as the order of the largest leading triangular submatrix R11 in the QR factorization with pivoting of A, whose estimated condition number < 1/RCOND.
    
    rank - The effective rank of A, i.e., the order of the submatrix R11. This is the same as the order of the submatrix T11 in the complete orthogonal factorization of A.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelsy
```
public int gelsy(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer B,
                 int ldb,
                 java.nio.IntBuffer jpvt,
                 double rcond,
                 java.nio.IntBuffer rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a complete orthogonal factorization of A. A may be rank-deficient.
    
    Specified by:
    
    gelsy in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    jpvt - On entry, if JPVT(i) != 0, the i-th column of A is permuted to the front of AP, otherwise column i is a free column. On exit, if JPVT(i) = k, then the i-th column of AP was the k-th column of A.
    
    rcond - RCOND is used to determine the effective rank of A, which is defined as the order of the largest leading triangular submatrix R11 in the QR factorization with pivoting of A, whose estimated condition number < 1/RCOND.
    
    rank - The effective rank of A, i.e., the order of the submatrix R11. This is the same as the order of the submatrix T11 in the complete orthogonal factorization of A.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelsy
```
public int gelsy(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 float[] A,
                 int lda,
                 float[] B,
                 int ldb,
                 int[] jpvt,
                 float rcond,
                 int[] rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a complete orthogonal factorization of A. A may be rank-deficient.
    
    Specified by:
    
    gelsy in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    jpvt - On entry, if JPVT(i) != 0, the i-th column of A is permuted to the front of AP, otherwise column i is a free column. On exit, if JPVT(i) = k, then the i-th column of AP was the k-th column of A.
    
    rcond - RCOND is used to determine the effective rank of A, which is defined as the order of the largest leading triangular submatrix R11 in the QR factorization with pivoting of A, whose estimated condition number < 1/RCOND.
    
    rank - The effective rank of A, i.e., the order of the submatrix R11. This is the same as the order of the submatrix T11 in the complete orthogonal factorization of A.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelsy
```
public int gelsy(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer B,
                 int ldb,
                 java.nio.IntBuffer jpvt,
                 float rcond,
                 java.nio.IntBuffer rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a complete orthogonal factorization of A. A may be rank-deficient.
    
    Specified by:
    
    gelsy in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    jpvt - On entry, if JPVT(i) != 0, the i-th column of A is permuted to the front of AP, otherwise column i is a free column. On exit, if JPVT(i) = k, then the i-th column of AP was the k-th column of A.
    
    rcond - RCOND is used to determine the effective rank of A, which is defined as the order of the largest leading triangular submatrix R11 in the QR factorization with pivoting of A, whose estimated condition number < 1/RCOND.
    
    rank - The effective rank of A, i.e., the order of the submatrix R11. This is the same as the order of the submatrix T11 in the complete orthogonal factorization of A.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelss
```
public int gelss(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 double[] A,
                 int lda,
                 double[] B,
                 int ldb,
                 double[] s,
                 double rcond,
                 int[] rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using the singular value decomposition (SVD) of A. A may be rank-deficient. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
    
    Specified by:
    
    gelss in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    s - The singular values of A in decreasing order. The condition number of A in the 2-norm = S(1)/S(min(m,n)).
    
    rcond - RCOND is used to determine the effective rank of A. Singular values S(i) <= RCOND*S(1) are treated as zero. If RCOND < 0, machine precision is used instead.
    
    rank - The effective rank of A, i.e., the number of singular values which are greater than RCOND*S(1).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelss
```
public int gelss(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer B,
                 int ldb,
                 java.nio.DoubleBuffer s,
                 double rcond,
                 java.nio.IntBuffer rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using the singular value decomposition (SVD) of A. A may be rank-deficient. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
    
    Specified by:
    
    gelss in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    s - The singular values of A in decreasing order. The condition number of A in the 2-norm = S(1)/S(min(m,n)).
    
    rcond - RCOND is used to determine the effective rank of A. Singular values S(i) <= RCOND*S(1) are treated as zero. If RCOND < 0, machine precision is used instead.
    
    rank - The effective rank of A, i.e., the number of singular values which are greater than RCOND*S(1).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelss
```
public int gelss(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 float[] A,
                 int lda,
                 float[] B,
                 int ldb,
                 float[] s,
                 float rcond,
                 int[] rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using the singular value decomposition (SVD) of A. A may be rank-deficient. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
    
    Specified by:
    
    gelss in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    s - The singular values of A in decreasing order. The condition number of A in the 2-norm = S(1)/S(min(m,n)).
    
    rcond - RCOND is used to determine the effective rank of A. Singular values S(i) <= RCOND*S(1) are treated as zero. If RCOND < 0, machine precision is used instead.
    
    rank - The effective rank of A, i.e., the number of singular values which are greater than RCOND*S(1).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelss
```
public int gelss(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer B,
                 int ldb,
                 java.nio.FloatBuffer s,
                 float rcond,
                 java.nio.IntBuffer rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using the singular value decomposition (SVD) of A. A may be rank-deficient. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
    
    Specified by:
    
    gelss in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    s - The singular values of A in decreasing order. The condition number of A in the 2-norm = S(1)/S(min(m,n)).
    
    rcond - RCOND is used to determine the effective rank of A. Singular values S(i) <= RCOND*S(1) are treated as zero. If RCOND < 0, machine precision is used instead.
    
    rank - The effective rank of A, i.e., the number of singular values which are greater than RCOND*S(1).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelsd
```
public int gelsd(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 double[] A,
                 int lda,
                 double[] B,
                 int ldb,
                 double[] s,
                 double rcond,
                 int[] rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a divide and conquer algorithm with the singular value decomposition (SVD) of A. A may be rank-deficient. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
    
    Specified by:
    
    gelsd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    s - The singular values of A in decreasing order. The condition number of A in the 2-norm = S(1)/S(min(m,n)).
    
    rcond - RCOND is used to determine the effective rank of A. Singular values S(i) <= RCOND*S(1) are treated as zero. If RCOND < 0, machine precision is used instead.
    
    rank - The effective rank of A, i.e., the number of singular values which are greater than RCOND*S(1).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelsd
```
public int gelsd(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer B,
                 int ldb,
                 java.nio.DoubleBuffer s,
                 double rcond,
                 java.nio.IntBuffer rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a divide and conquer algorithm with the singular value decomposition (SVD) of A. A may be rank-deficient. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
    
    Specified by:
    
    gelsd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    s - The singular values of A in decreasing order. The condition number of A in the 2-norm = S(1)/S(min(m,n)).
    
    rcond - RCOND is used to determine the effective rank of A. Singular values S(i) <= RCOND*S(1) are treated as zero. If RCOND < 0, machine precision is used instead.
    
    rank - The effective rank of A, i.e., the number of singular values which are greater than RCOND*S(1).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelsd
```
public int gelsd(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 float[] A,
                 int lda,
                 float[] B,
                 int ldb,
                 float[] s,
                 float rcond,
                 int[] rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a divide and conquer algorithm with the singular value decomposition (SVD) of A. A may be rank-deficient. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
    
    Specified by:
    
    gelsd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    s - The singular values of A in decreasing order. The condition number of A in the 2-norm = S(1)/S(min(m,n)).
    
    rcond - RCOND is used to determine the effective rank of A. Singular values S(i) <= RCOND*S(1) are treated as zero. If RCOND < 0, machine precision is used instead.
    
    rank - The effective rank of A, i.e., the number of singular values which are greater than RCOND*S(1).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gelsd
```
public int gelsd(Layout layout,
                 int m,
                 int n,
                 int nrhs,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer B,
                 int ldb,
                 java.nio.FloatBuffer s,
                 float rcond,
                 java.nio.IntBuffer rank)
```
    Description copied from interface: LAPACK
    
    Solves an overdetermined or underdetermined system, using a divide and conquer algorithm with the singular value decomposition (SVD) of A. A may be rank-deficient. The effective rank of A is determined by treating as zero those singular values which are less than RCOND times the largest singular value.
    
    Specified by:
    
    gelsd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The matrix of dimension (LDA, N). On exit, A is overwritten by the factorization.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - The right hand side matrix of dimension (LDB, NRHS). On exit, if INFO = 0, B is overwritten by the solution vectors, stored columnwise.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,M,N).
    
    s - The singular values of A in decreasing order. The condition number of A in the 2-norm = S(1)/S(min(m,n)).
    
    rcond - RCOND is used to determine the effective rank of A. Singular values S(i) <= RCOND*S(1) are treated as zero. If RCOND < 0, machine precision is used instead.
    
    rank - The effective rank of A, i.e., the number of singular values which are greater than RCOND*S(1).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of the triangular factor of A is zero, so that A does not have full rank; the least squares solution could not be computed.
  - gglse
```
public int gglse(Layout layout,
                 int m,
                 int n,
                 int p,
                 double[] A,
                 int lda,
                 double[] B,
                 int ldb,
                 double[] c,
                 double[] d,
                 double[] x)
```
    Description copied from interface: LAPACK
    Solves a linear equality-constrained least squares (LSE) problem.
```
     minimize || c - A*x ||_2   subject to   B*x = d
 
```
    where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and
```
     rank(B) = P and  rank( (A) ) = N
                          ( (B) )
 
```
    These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by
```
     B = (0 R)*Q,   A = Z*T*Q
 
```
    Specified by:
    
    gglse in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A and B.
    
    p - The number of rows of the matrix B. 0 <= P <= N <= M+P.
    
    A - The matrix of dimension (LDA, N). On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - On entry, the P-by-N matrix B. On exit, the upper triangle of the submatrix B(1:P,N-P+1:N) contains the P-by-P upper triangular matrix R.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,P).
    
    c - Dimension (M). On entry, C contains the right hand side vector for the least squares part of the LSE problem. On exit, the residual sum of squares for the solution is given by the sum of squares of elements N-P+1 to M of vector C.
    
    d - Dimension (P). On entry, D contains the right hand side vector for the constrained equation. On exit, D is destroyed.
    
    x - Dimension (N). On exit, X is the solution of the LSE problem.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value = 1: the upper triangular factor R associated with B in the generalized RQ factorization of the pair (B, A) is singular, so that rank(B) < P; the least squares solution could not be computed. = 2: the (N-P) by (N-P) part of the upper trapezoidal factor T associated with A in the generalized RQ factorization of the pair (B, A) is singular, so that rank( A, B ) < N; the least squares solution could not be computed.
  - gglse
```
public int gglse(Layout layout,
                 int m,
                 int n,
                 int p,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer B,
                 int ldb,
                 java.nio.DoubleBuffer c,
                 java.nio.DoubleBuffer d,
                 java.nio.DoubleBuffer x)
```
    Description copied from interface: LAPACK
    Solves a linear equality-constrained least squares (LSE) problem.
```
     minimize || c - A*x ||_2   subject to   B*x = d
 
```
    where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and
```
     rank(B) = P and  rank( (A) ) = N
                          ( (B) )
 
```
    These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by
```
     B = (0 R)*Q,   A = Z*T*Q
 
```
    Specified by:
    
    gglse in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A and B.
    
    p - The number of rows of the matrix B. 0 <= P <= N <= M+P.
    
    A - The matrix of dimension (LDA, N). On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - On entry, the P-by-N matrix B. On exit, the upper triangle of the submatrix B(1:P,N-P+1:N) contains the P-by-P upper triangular matrix R.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,P).
    
    c - Dimension (M). On entry, C contains the right hand side vector for the least squares part of the LSE problem. On exit, the residual sum of squares for the solution is given by the sum of squares of elements N-P+1 to M of vector C.
    
    d - Dimension (P). On entry, D contains the right hand side vector for the constrained equation. On exit, D is destroyed.
    
    x - Dimension (N). On exit, X is the solution of the LSE problem.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value = 1: the upper triangular factor R associated with B in the generalized RQ factorization of the pair (B, A) is singular, so that rank(B) < P; the least squares solution could not be computed. = 2: the (N-P) by (N-P) part of the upper trapezoidal factor T associated with A in the generalized RQ factorization of the pair (B, A) is singular, so that rank( A, B ) < N; the least squares solution could not be computed.
  - gglse
```
public int gglse(Layout layout,
                 int m,
                 int n,
                 int p,
                 float[] A,
                 int lda,
                 float[] B,
                 int ldb,
                 float[] c,
                 float[] d,
                 float[] x)
```
    Description copied from interface: LAPACK
    Solves a linear equality-constrained least squares (LSE) problem.
```
     minimize || c - A*x ||_2   subject to   B*x = d
 
```
    where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and
```
     rank(B) = P and  rank( (A) ) = N
                          ( (B) )
 
```
    These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by
```
     B = (0 R)*Q,   A = Z*T*Q
 
```
    Specified by:
    
    gglse in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A and B.
    
    p - The number of rows of the matrix B. 0 <= P <= N <= M+P.
    
    A - The matrix of dimension (LDA, N). On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - On entry, the P-by-N matrix B. On exit, the upper triangle of the submatrix B(1:P,N-P+1:N) contains the P-by-P upper triangular matrix R.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,P).
    
    c - Dimension (M). On entry, C contains the right hand side vector for the least squares part of the LSE problem. On exit, the residual sum of squares for the solution is given by the sum of squares of elements N-P+1 to M of vector C.
    
    d - Dimension (P). On entry, D contains the right hand side vector for the constrained equation. On exit, D is destroyed.
    
    x - Dimension (N). On exit, X is the solution of the LSE problem.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value = 1: the upper triangular factor R associated with B in the generalized RQ factorization of the pair (B, A) is singular, so that rank(B) < P; the least squares solution could not be computed. = 2: the (N-P) by (N-P) part of the upper trapezoidal factor T associated with A in the generalized RQ factorization of the pair (B, A) is singular, so that rank( A, B ) < N; the least squares solution could not be computed.
  - gglse
```
public int gglse(Layout layout,
                 int m,
                 int n,
                 int p,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer B,
                 int ldb,
                 java.nio.FloatBuffer c,
                 java.nio.FloatBuffer d,
                 java.nio.FloatBuffer x)
```
    Description copied from interface: LAPACK
    Solves a linear equality-constrained least squares (LSE) problem.
```
     minimize || c - A*x ||_2   subject to   B*x = d
 
```
    where A is an M-by-N matrix, B is a P-by-N matrix, c is a given M-vector, and d is a given P-vector. It is assumed that P <= N <= M+P, and
```
     rank(B) = P and  rank( (A) ) = N
                          ( (B) )
 
```
    These conditions ensure that the LSE problem has a unique solution, which is obtained using a generalized RQ factorization of the matrices (B, A) given by
```
     B = (0 R)*Q,   A = Z*T*Q
 
```
    Specified by:
    
    gglse in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A and B.
    
    p - The number of rows of the matrix B. 0 <= P <= N <= M+P.
    
    A - The matrix of dimension (LDA, N). On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    B - On entry, the P-by-N matrix B. On exit, the upper triangle of the submatrix B(1:P,N-P+1:N) contains the P-by-P upper triangular matrix R.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,P).
    
    c - Dimension (M). On entry, C contains the right hand side vector for the least squares part of the LSE problem. On exit, the residual sum of squares for the solution is given by the sum of squares of elements N-P+1 to M of vector C.
    
    d - Dimension (P). On entry, D contains the right hand side vector for the constrained equation. On exit, D is destroyed.
    
    x - Dimension (N). On exit, X is the solution of the LSE problem.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value = 1: the upper triangular factor R associated with B in the generalized RQ factorization of the pair (B, A) is singular, so that rank(B) < P; the least squares solution could not be computed. = 2: the (N-P) by (N-P) part of the upper trapezoidal factor T associated with A in the generalized RQ factorization of the pair (B, A) is singular, so that rank( A, B ) < N; the least squares solution could not be computed.
  - ggglm
```
public int ggglm(Layout layout,
                 int n,
                 int m,
                 int p,
                 double[] A,
                 int lda,
                 double[] B,
                 int ldb,
                 double[] d,
                 double[] x,
                 double[] y)
```
    Description copied from interface: LAPACK
    Solves a general Gauss-Markov linear model (GLM) problem.
```
     minimize || y ||_2   subject to   d = A*x + B*y
         x
 
```
    where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and
```
     rank(A) = M    and    rank( A B ) = N
 
```
    Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by
```
     A = Q*(R),   B = Q*T*Z
           (0)
 
```
    In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem
```
     minimize || inv(B)*(d-A*x) ||_2
         x
 
```
    where inv(B) denotes the inverse of B.
    Specified by:
    
    ggglm in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of rows of the matrix A and B.
    
    m - The number of columns of the matrix A. 0 <= M <= N.
    
    p - The number of columns of the matrix B. P >= N-M.
    
    A - The matrix of dimension (LDA, M). On exit, the upper triangular part of the matrix A contains the M-by-M upper triangular matrix R.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-P matrix B. On exit, if N <= P, the upper triangle of the subarray B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T; if N > P, the elements on and above the (N-P)th subdiagonal contain the N-by-P upper trapezoidal matrix T.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    d - Dimension (N). On entry, D is the left hand side of the GLM equation. On exit, D is destroyed.
    
    x - Dimension (M). On exit, X and Y are the solutions of the GLM problem.
    
    y - Dimension (P). On exit, X and Y are the solutions of the GLM problem.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value = 1: the upper triangular factor R associated with A in the generalized QR factorization of the pair (A, B) is singular, so that rank(A) < M; the least squares solution could not be computed. = 2: the bottom (N-M) by (N-M) part of the upper trapezoidal factor T associated with B in the generalized QR factorization of the pair (A, B) is singular, so that rank( A B ) < N; the least squares solution could not be computed.
  - ggglm
```
public int ggglm(Layout layout,
                 int n,
                 int m,
                 int p,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer B,
                 int ldb,
                 java.nio.DoubleBuffer d,
                 java.nio.DoubleBuffer x,
                 java.nio.DoubleBuffer y)
```
    Description copied from interface: LAPACK
    Solves a general Gauss-Markov linear model (GLM) problem.
```
     minimize || y ||_2   subject to   d = A*x + B*y
         x
 
```
    where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and
```
     rank(A) = M    and    rank( A B ) = N
 
```
    Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by
```
     A = Q*(R),   B = Q*T*Z
           (0)
 
```
    In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem
```
     minimize || inv(B)*(d-A*x) ||_2
         x
 
```
    where inv(B) denotes the inverse of B.
    Specified by:
    
    ggglm in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of rows of the matrix A and B.
    
    m - The number of columns of the matrix A. 0 <= M <= N.
    
    p - The number of columns of the matrix B. P >= N-M.
    
    A - The matrix of dimension (LDA, M). On exit, the upper triangular part of the matrix A contains the M-by-M upper triangular matrix R.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-P matrix B. On exit, if N <= P, the upper triangle of the subarray B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T; if N > P, the elements on and above the (N-P)th subdiagonal contain the N-by-P upper trapezoidal matrix T.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    d - Dimension (N). On entry, D is the left hand side of the GLM equation. On exit, D is destroyed.
    
    x - Dimension (M). On exit, X and Y are the solutions of the GLM problem.
    
    y - Dimension (P). On exit, X and Y are the solutions of the GLM problem.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value = 1: the upper triangular factor R associated with A in the generalized QR factorization of the pair (A, B) is singular, so that rank(A) < M; the least squares solution could not be computed. = 2: the bottom (N-M) by (N-M) part of the upper trapezoidal factor T associated with B in the generalized QR factorization of the pair (A, B) is singular, so that rank( A B ) < N; the least squares solution could not be computed.
  - ggglm
```
public int ggglm(Layout layout,
                 int n,
                 int m,
                 int p,
                 float[] A,
                 int lda,
                 float[] B,
                 int ldb,
                 float[] d,
                 float[] x,
                 float[] y)
```
    Description copied from interface: LAPACK
    Solves a general Gauss-Markov linear model (GLM) problem.
```
     minimize || y ||_2   subject to   d = A*x + B*y
         x
 
```
    where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and
```
     rank(A) = M    and    rank( A B ) = N
 
```
    Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by
```
     A = Q*(R),   B = Q*T*Z
           (0)
 
```
    In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem
```
     minimize || inv(B)*(d-A*x) ||_2
         x
 
```
    where inv(B) denotes the inverse of B.
    Specified by:
    
    ggglm in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of rows of the matrix A and B.
    
    m - The number of columns of the matrix A. 0 <= M <= N.
    
    p - The number of columns of the matrix B. P >= N-M.
    
    A - The matrix of dimension (LDA, M). On exit, the upper triangular part of the matrix A contains the M-by-M upper triangular matrix R.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-P matrix B. On exit, if N <= P, the upper triangle of the subarray B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T; if N > P, the elements on and above the (N-P)th subdiagonal contain the N-by-P upper trapezoidal matrix T.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    d - Dimension (N). On entry, D is the left hand side of the GLM equation. On exit, D is destroyed.
    
    x - Dimension (M). On exit, X and Y are the solutions of the GLM problem.
    
    y - Dimension (P). On exit, X and Y are the solutions of the GLM problem.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value = 1: the upper triangular factor R associated with A in the generalized QR factorization of the pair (A, B) is singular, so that rank(A) < M; the least squares solution could not be computed. = 2: the bottom (N-M) by (N-M) part of the upper trapezoidal factor T associated with B in the generalized QR factorization of the pair (A, B) is singular, so that rank( A B ) < N; the least squares solution could not be computed.
  - ggglm
```
public int ggglm(Layout layout,
                 int n,
                 int m,
                 int p,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer B,
                 int ldb,
                 java.nio.FloatBuffer d,
                 java.nio.FloatBuffer x,
                 java.nio.FloatBuffer y)
```
    Description copied from interface: LAPACK
    Solves a general Gauss-Markov linear model (GLM) problem.
```
     minimize || y ||_2   subject to   d = A*x + B*y
         x
 
```
    where A is an N-by-M matrix, B is an N-by-P matrix, and d is a given N-vector. It is assumed that M <= N <= M+P, and
```
     rank(A) = M    and    rank( A B ) = N
 
```
    Under these assumptions, the constrained equation is always consistent, and there is a unique solution x and a minimal 2-norm solution y, which is obtained using a generalized QR factorization of the matrices (A, B) given by
```
     A = Q*(R),   B = Q*T*Z
           (0)
 
```
    In particular, if matrix B is square nonsingular, then the problem GLM is equivalent to the following weighted linear least squares problem
```
     minimize || inv(B)*(d-A*x) ||_2
         x
 
```
    where inv(B) denotes the inverse of B.
    Specified by:
    
    ggglm in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of rows of the matrix A and B.
    
    m - The number of columns of the matrix A. 0 <= M <= N.
    
    p - The number of columns of the matrix B. P >= N-M.
    
    A - The matrix of dimension (LDA, M). On exit, the upper triangular part of the matrix A contains the M-by-M upper triangular matrix R.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-P matrix B. On exit, if N <= P, the upper triangle of the subarray B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T; if N > P, the elements on and above the (N-P)th subdiagonal contain the N-by-P upper trapezoidal matrix T.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    d - Dimension (N). On entry, D is the left hand side of the GLM equation. On exit, D is destroyed.
    
    x - Dimension (M). On exit, X and Y are the solutions of the GLM problem.
    
    y - Dimension (P). On exit, X and Y are the solutions of the GLM problem.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value = 1: the upper triangular factor R associated with A in the generalized QR factorization of the pair (A, B) is singular, so that rank(A) < M; the least squares solution could not be computed. = 2: the bottom (N-M) by (N-M) part of the upper trapezoidal factor T associated with B in the generalized QR factorization of the pair (A, B) is singular, so that rank( A B ) < N; the least squares solution could not be computed.
  - geev
```
public int geev(Layout layout,
                EVDJob jobvl,
                EVDJob jobvr,
                int n,
                double[] A,
                int lda,
                double[] wr,
                double[] wi,
                double[] Vl,
                int ldvl,
                double[] Vr,
                int ldvr)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
    
    Specified by:
    
    geev in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobvl - The option for computing all or part of the matrix U.
    
    jobvr - The option for computing all or part of the matrix VT.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    wr - Dimension N. WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
    
    wi - Dimension N. WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
    
    Vl - Left eigenvectors. If JOBVL = 'N', Vl is not referenced.
    
    ldvl - The leading dimension of the matrix Vl.
    
    Vr - Right eigenvectors. If JOBVR = 'N', Vr is not referenced.
    
    ldvr - The leading dimension of the matrix Vr.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the QR algorithm failed to compute all the eigenvalues, and no eigenvectors have been computed; elements i+1:N of WR and WI contain eigenvalues which have converged.
  - geev
```
public int geev(Layout layout,
                EVDJob jobvl,
                EVDJob jobvr,
                int n,
                java.nio.DoubleBuffer A,
                int lda,
                java.nio.DoubleBuffer wr,
                java.nio.DoubleBuffer wi,
                java.nio.DoubleBuffer Vl,
                int ldvl,
                java.nio.DoubleBuffer Vr,
                int ldvr)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
    
    Specified by:
    
    geev in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobvl - The option for computing all or part of the matrix U.
    
    jobvr - The option for computing all or part of the matrix VT.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    wr - Dimension N. WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
    
    wi - Dimension N. WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
    
    Vl - Left eigenvectors. If JOBVL = 'N', Vl is not referenced.
    
    ldvl - The leading dimension of the matrix Vl.
    
    Vr - Right eigenvectors. If JOBVR = 'N', Vr is not referenced.
    
    ldvr - The leading dimension of the matrix Vr.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the QR algorithm failed to compute all the eigenvalues, and no eigenvectors have been computed; elements i+1:N of WR and WI contain eigenvalues which have converged.
  - geev
```
public int geev(Layout layout,
                EVDJob jobvl,
                EVDJob jobvr,
                int n,
                float[] A,
                int lda,
                float[] wr,
                float[] wi,
                float[] Vl,
                int ldvl,
                float[] Vr,
                int ldvr)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
    
    Specified by:
    
    geev in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobvl - The option for computing all or part of the matrix U.
    
    jobvr - The option for computing all or part of the matrix VT.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    wr - Dimension N. WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
    
    wi - Dimension N. WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
    
    Vl - Left eigenvectors. If JOBVL = 'N', Vl is not referenced.
    
    ldvl - The leading dimension of the matrix Vl.
    
    Vr - Right eigenvectors. If JOBVR = 'N', Vr is not referenced.
    
    ldvr - The leading dimension of the matrix Vr.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the QR algorithm failed to compute all the eigenvalues, and no eigenvectors have been computed; elements i+1:N of WR and WI contain eigenvalues which have converged.
  - geev
```
public int geev(Layout layout,
                EVDJob jobvl,
                EVDJob jobvr,
                int n,
                java.nio.FloatBuffer A,
                int lda,
                java.nio.FloatBuffer wr,
                java.nio.FloatBuffer wi,
                java.nio.FloatBuffer Vl,
                int ldvl,
                java.nio.FloatBuffer Vr,
                int ldvr)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors. The computed eigenvectors are normalized to have Euclidean norm equal to 1 and largest component real.
    
    Specified by:
    
    geev in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobvl - The option for computing all or part of the matrix U.
    
    jobvr - The option for computing all or part of the matrix VT.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    wr - Dimension N. WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
    
    wi - Dimension N. WR and WI contain the real and imaginary parts, respectively, of the computed eigenvalues. Complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
    
    Vl - Left eigenvectors. If JOBVL = 'N', Vl is not referenced.
    
    ldvl - The leading dimension of the matrix Vl.
    
    Vr - Right eigenvectors. If JOBVR = 'N', Vr is not referenced.
    
    ldvr - The leading dimension of the matrix Vr.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the QR algorithm failed to compute all the eigenvalues, and no eigenvectors have been computed; elements i+1:N of WR and WI contain eigenvalues which have converged.
  - syev
```
public int syev(Layout layout,
                EVDJob jobz,
                UPLO uplo,
                int n,
                double[] A,
                int lda,
                double[] w)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
    
    Specified by:
    
    syev in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    w - Dimension N. If INFO = 0, the eigenvalues in ascending order.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
  - syev
```
public int syev(Layout layout,
                EVDJob jobz,
                UPLO uplo,
                int n,
                java.nio.DoubleBuffer A,
                int lda,
                java.nio.DoubleBuffer w)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
    
    Specified by:
    
    syev in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    w - Dimension N. If INFO = 0, the eigenvalues in ascending order.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
  - syev
```
public int syev(Layout layout,
                EVDJob jobz,
                UPLO uplo,
                int n,
                float[] A,
                int lda,
                float[] w)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
    
    Specified by:
    
    syev in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    w - Dimension N. If INFO = 0, the eigenvalues in ascending order.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
  - syev
```
public int syev(Layout layout,
                EVDJob jobz,
                UPLO uplo,
                int n,
                java.nio.FloatBuffer A,
                int lda,
                java.nio.FloatBuffer w)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A.
    
    Specified by:
    
    syev in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    w - Dimension N. If INFO = 0, the eigenvalues in ascending order.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
  - syevd
```
public int syevd(Layout layout,
                 EVDJob jobz,
                 UPLO uplo,
                 int n,
                 double[] A,
                 int lda,
                 double[] w)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm.
    
    Specified by:
    
    syevd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    w - Dimension N. If INFO = 0, the eigenvalues in ascending order.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
  - syevd
```
public int syevd(Layout layout,
                 EVDJob jobz,
                 UPLO uplo,
                 int n,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer w)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm.
    
    Specified by:
    
    syevd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    w - Dimension N. If INFO = 0, the eigenvalues in ascending order.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
  - syevd
```
public int syevd(Layout layout,
                 EVDJob jobz,
                 UPLO uplo,
                 int n,
                 float[] A,
                 int lda,
                 float[] w)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm.
    
    Specified by:
    
    syevd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    w - Dimension N. If INFO = 0, the eigenvalues in ascending order.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
  - syevd
```
public int syevd(Layout layout,
                 EVDJob jobz,
                 UPLO uplo,
                 int n,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer w)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A. If eigenvectors are desired, it uses a divide and conquer algorithm.
    
    Specified by:
    
    syevd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    w - Dimension N. If INFO = 0, the eigenvalues in ascending order.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if INFO = i, the algorithm failed to converge; i off-diagonal elements of an intermediate tridiagonal form did not converge to zero.
  - syevr
```
public int syevr(Layout layout,
                 EVDJob jobz,
                 EigenRange range,
                 UPLO uplo,
                 int n,
                 double[] A,
                 int lda,
                 double vl,
                 double vu,
                 int il,
                 int iu,
                 double abstol,
                 int[] m,
                 double[] w,
                 double[] Z,
                 int ldz,
                 int[] isuppz)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, DSYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. The desired accuracy of the output can be specified by the input parameter ABSTOL.
    
    Specified by:
    
    syevr in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    range - The range of eigenvalues to compute.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    vl - The lower bound of the interval to be searched for eigenvalues. Not referenced if RANGE = 'A' or 'I'.
    
    vu - The upper bound of the interval to be searched for eigenvalues. Not referenced if RANGE = 'A' or 'I'.
    
    il - The index of the smallest eigenvalue to be returned. Not referenced if RANGE = 'A' or 'V'.
    
    iu - The index of the largest eigenvalue to be returned. Not referenced if RANGE = 'A' or 'V'.
    
    abstol - The absolute error tolerance for the eigenvalues.
    
    m - The total number of eigenvalues found.
    
    w - The first M elements contain the selected eigenvalues in ascending order.
    
    Z - Dimension (LDZ, max(1,M)). If JOBZ = 'V', then if INFO = 0, the first M columns of Z contain the orthonormal eigenvectors of the matrix A corresponding to the selected eigenvalues, with the i-th column of Z holding the eigenvector associated with W(i). If JOBZ = 'N', then Z is not referenced.
    
    ldz - The leading dimension of the matrix Z.
    
    isuppz - Dimension 2 * max(1,M). The support of the eigenvectors in Z, i.e., the indices indicating the nonzero elements in Z. The i-th eigenvector is nonzero only in elements ISUPPZ( 2*i-1 ) through ISUPPZ( 2*i ). This is an output of DSTEMR (tridiagonal matrix). The support of the eigenvectors of A is typically 1:N because of the orthogonal transformations applied by DORMTR. Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: Internal error
  - syevr
```
public int syevr(Layout layout,
                 EVDJob jobz,
                 EigenRange range,
                 UPLO uplo,
                 int n,
                 java.nio.DoubleBuffer A,
                 int lda,
                 double vl,
                 double vu,
                 int il,
                 int iu,
                 double abstol,
                 java.nio.IntBuffer m,
                 java.nio.DoubleBuffer w,
                 java.nio.DoubleBuffer Z,
                 int ldz,
                 java.nio.IntBuffer isuppz)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, DSYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. The desired accuracy of the output can be specified by the input parameter ABSTOL.
    
    Specified by:
    
    syevr in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    range - The range of eigenvalues to compute.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    vl - The lower bound of the interval to be searched for eigenvalues. Not referenced if RANGE = 'A' or 'I'.
    
    vu - The upper bound of the interval to be searched for eigenvalues. Not referenced if RANGE = 'A' or 'I'.
    
    il - The index of the smallest eigenvalue to be returned. Not referenced if RANGE = 'A' or 'V'.
    
    iu - The index of the largest eigenvalue to be returned. Not referenced if RANGE = 'A' or 'V'.
    
    abstol - The absolute error tolerance for the eigenvalues.
    
    m - The total number of eigenvalues found.
    
    w - The first M elements contain the selected eigenvalues in ascending order.
    
    Z - Dimension (LDZ, max(1,M)). If JOBZ = 'V', then if INFO = 0, the first M columns of Z contain the orthonormal eigenvectors of the matrix A corresponding to the selected eigenvalues, with the i-th column of Z holding the eigenvector associated with W(i). If JOBZ = 'N', then Z is not referenced.
    
    ldz - The leading dimension of the matrix Z.
    
    isuppz - Dimension 2 * max(1,M). The support of the eigenvectors in Z, i.e., the indices indicating the nonzero elements in Z. The i-th eigenvector is nonzero only in elements ISUPPZ( 2*i-1 ) through ISUPPZ( 2*i ). This is an output of DSTEMR (tridiagonal matrix). The support of the eigenvectors of A is typically 1:N because of the orthogonal transformations applied by DORMTR. Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: Internal error
  - syevr
```
public int syevr(Layout layout,
                 EVDJob jobz,
                 EigenRange range,
                 UPLO uplo,
                 int n,
                 float[] A,
                 int lda,
                 float vl,
                 float vu,
                 int il,
                 int iu,
                 float abstol,
                 int[] m,
                 float[] w,
                 float[] Z,
                 int ldz,
                 int[] isuppz)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, DSYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. The desired accuracy of the output can be specified by the input parameter ABSTOL.
    
    Specified by:
    
    syevr in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    range - The range of eigenvalues to compute.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    vl - The lower bound of the interval to be searched for eigenvalues. Not referenced if RANGE = 'A' or 'I'.
    
    vu - The upper bound of the interval to be searched for eigenvalues. Not referenced if RANGE = 'A' or 'I'.
    
    il - The index of the smallest eigenvalue to be returned. Not referenced if RANGE = 'A' or 'V'.
    
    iu - The index of the largest eigenvalue to be returned. Not referenced if RANGE = 'A' or 'V'.
    
    abstol - The absolute error tolerance for the eigenvalues.
    
    m - The total number of eigenvalues found.
    
    w - The first M elements contain the selected eigenvalues in ascending order.
    
    Z - Dimension (LDZ, max(1,M)). If JOBZ = 'V', then if INFO = 0, the first M columns of Z contain the orthonormal eigenvectors of the matrix A corresponding to the selected eigenvalues, with the i-th column of Z holding the eigenvector associated with W(i). If JOBZ = 'N', then Z is not referenced.
    
    ldz - The leading dimension of the matrix Z.
    
    isuppz - Dimension 2 * max(1,M). The support of the eigenvectors in Z, i.e., the indices indicating the nonzero elements in Z. The i-th eigenvector is nonzero only in elements ISUPPZ( 2*i-1 ) through ISUPPZ( 2*i ). This is an output of DSTEMR (tridiagonal matrix). The support of the eigenvectors of A is typically 1:N because of the orthogonal transformations applied by DORMTR. Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: Internal error
  - syevr
```
public int syevr(Layout layout,
                 EVDJob jobz,
                 EigenRange range,
                 UPLO uplo,
                 int n,
                 java.nio.FloatBuffer A,
                 int lda,
                 float vl,
                 float vu,
                 int il,
                 int iu,
                 float abstol,
                 java.nio.IntBuffer m,
                 java.nio.FloatBuffer w,
                 java.nio.FloatBuffer Z,
                 int ldz,
                 java.nio.IntBuffer isuppz)
```
    Description copied from interface: LAPACK
    
    Computes the eigenvalues and, optionally, the left and/or right eigenvectors of a real symmetric matrix A. Eigenvalues and eigenvectors can be selected by specifying either a range of values or a range of indices for the desired eigenvalues. SYEVR first reduces the matrix A to tridiagonal form T with a call to DSYTRD. Then, whenever possible, DSYEVR calls DSTEMR to compute the eigenspectrum using Relatively Robust Representations. DSTEMR computes eigenvalues by the dqds algorithm, while orthogonal eigenvectors are computed from various "good" L D L^T representations (also known as Relatively Robust Representations). Gram-Schmidt orthogonalization is avoided as far as possible. More specifically, the various steps of the algorithm are as follows. The desired accuracy of the output can be specified by the input parameter ABSTOL.
    
    Specified by:
    
    syevr in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option if computing eigen vectors.
    
    range - The range of eigenvalues to compute.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On entry, the N-by-N matrix A. On exit, A has been overwritten.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    vl - The lower bound of the interval to be searched for eigenvalues. Not referenced if RANGE = 'A' or 'I'.
    
    vu - The upper bound of the interval to be searched for eigenvalues. Not referenced if RANGE = 'A' or 'I'.
    
    il - The index of the smallest eigenvalue to be returned. Not referenced if RANGE = 'A' or 'V'.
    
    iu - The index of the largest eigenvalue to be returned. Not referenced if RANGE = 'A' or 'V'.
    
    abstol - The absolute error tolerance for the eigenvalues.
    
    m - The total number of eigenvalues found.
    
    w - The first M elements contain the selected eigenvalues in ascending order.
    
    Z - Dimension (LDZ, max(1,M)). If JOBZ = 'V', then if INFO = 0, the first M columns of Z contain the orthonormal eigenvectors of the matrix A corresponding to the selected eigenvalues, with the i-th column of Z holding the eigenvector associated with W(i). If JOBZ = 'N', then Z is not referenced.
    
    ldz - The leading dimension of the matrix Z.
    
    isuppz - Dimension 2 * max(1,M). The support of the eigenvectors in Z, i.e., the indices indicating the nonzero elements in Z. The i-th eigenvector is nonzero only in elements ISUPPZ( 2*i-1 ) through ISUPPZ( 2*i ). This is an output of DSTEMR (tridiagonal matrix). The support of the eigenvectors of A is typically 1:N because of the orthogonal transformations applied by DORMTR. Implemented only for RANGE = 'A' or 'I' and IU - IL = N - 1.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: Internal error
  - gesvd
```
public int gesvd(Layout layout,
                 SVDJob jobu,
                 SVDJob jobvt,
                 int m,
                 int n,
                 double[] A,
                 int lda,
                 double[] s,
                 double[] U,
                 int ldu,
                 double[] VT,
                 int ldvt,
                 double[] superb)
```
    Description copied from interface: LAPACK
    
    Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
    
    Specified by:
    
    gesvd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobu - The option for computing all or part of the matrix U.
    
    jobvt - The option for computing all or part of the matrix VT.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). If JOBU = 'O', A is overwritten with the first min(m,n) columns of U (the left singular vectors, stored columnwise). If JOBVT = 'O',A is overwritten with the first min(m,n) rows of VT (the right singular vectors, stored rowwise). If JOBU != 'O' and JOBVT != 'O', the contents of A are destroyed.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    s - The singular values of A, sorted so that S(i) >= S(i+1). Dimension min(M,N).
    
    U - If JOBU = 'N' or 'O', U is not referenced.
    
    ldu - The leading dimension of the matrix U.
    
    VT - If JOBVT = 'N' or 'O', VT is not referenced.
    
    ldvt - The leading dimension of the matrix VT.
    
    superb - The superdiagonal of the upper bidiagonal matrix B. Dimension min(M,N)-1.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if DBDSQR did not converge, INFO specifies how many superdiagonals of an intermediate bidiagonal form B did not converge to zero.
  - gesvd
```
public int gesvd(Layout layout,
                 SVDJob jobu,
                 SVDJob jobvt,
                 int m,
                 int n,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer s,
                 java.nio.DoubleBuffer U,
                 int ldu,
                 java.nio.DoubleBuffer VT,
                 int ldvt,
                 java.nio.DoubleBuffer superb)
```
    Description copied from interface: LAPACK
    
    Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
    
    Specified by:
    
    gesvd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobu - The option for computing all or part of the matrix U.
    
    jobvt - The option for computing all or part of the matrix VT.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). If JOBU = 'O', A is overwritten with the first min(m,n) columns of U (the left singular vectors, stored columnwise). If JOBVT = 'O',A is overwritten with the first min(m,n) rows of VT (the right singular vectors, stored rowwise). If JOBU != 'O' and JOBVT != 'O', the contents of A are destroyed.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    s - The singular values of A, sorted so that S(i) >= S(i+1). Dimension min(M,N).
    
    U - If JOBU = 'N' or 'O', U is not referenced.
    
    ldu - The leading dimension of the matrix U.
    
    VT - If JOBVT = 'N' or 'O', VT is not referenced.
    
    ldvt - The leading dimension of the matrix VT.
    
    superb - The superdiagonal of the upper bidiagonal matrix B. Dimension min(M,N)-1.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if DBDSQR did not converge, INFO specifies how many superdiagonals of an intermediate bidiagonal form B did not converge to zero.
  - gesvd
```
public int gesvd(Layout layout,
                 SVDJob jobu,
                 SVDJob jobvt,
                 int m,
                 int n,
                 float[] A,
                 int lda,
                 float[] s,
                 float[] U,
                 int ldu,
                 float[] VT,
                 int ldvt,
                 float[] superb)
```
    Description copied from interface: LAPACK
    
    Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
    
    Specified by:
    
    gesvd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobu - The option for computing all or part of the matrix U.
    
    jobvt - The option for computing all or part of the matrix VT.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). If JOBU = 'O', A is overwritten with the first min(m,n) columns of U (the left singular vectors, stored columnwise). If JOBVT = 'O',A is overwritten with the first min(m,n) rows of VT (the right singular vectors, stored rowwise). If JOBU != 'O' and JOBVT != 'O', the contents of A are destroyed.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    s - The singular values of A, sorted so that S(i) >= S(i+1). Dimension min(M,N).
    
    U - If JOBU = 'N' or 'O', U is not referenced.
    
    ldu - The leading dimension of the matrix U.
    
    VT - If JOBVT = 'N' or 'O', VT is not referenced.
    
    ldvt - The leading dimension of the matrix VT.
    
    superb - The superdiagonal of the upper bidiagonal matrix B. Dimension min(M,N)-1.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if DBDSQR did not converge, INFO specifies how many superdiagonals of an intermediate bidiagonal form B did not converge to zero.
  - gesvd
```
public int gesvd(Layout layout,
                 SVDJob jobu,
                 SVDJob jobvt,
                 int m,
                 int n,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer s,
                 java.nio.FloatBuffer U,
                 int ldu,
                 java.nio.FloatBuffer VT,
                 int ldvt,
                 java.nio.FloatBuffer superb)
```
    Description copied from interface: LAPACK
    
    Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors.
    
    Specified by:
    
    gesvd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobu - The option for computing all or part of the matrix U.
    
    jobvt - The option for computing all or part of the matrix VT.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). If JOBU = 'O', A is overwritten with the first min(m,n) columns of U (the left singular vectors, stored columnwise). If JOBVT = 'O',A is overwritten with the first min(m,n) rows of VT (the right singular vectors, stored rowwise). If JOBU != 'O' and JOBVT != 'O', the contents of A are destroyed.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    s - The singular values of A, sorted so that S(i) >= S(i+1). Dimension min(M,N).
    
    U - If JOBU = 'N' or 'O', U is not referenced.
    
    ldu - The leading dimension of the matrix U.
    
    VT - If JOBVT = 'N' or 'O', VT is not referenced.
    
    ldvt - The leading dimension of the matrix VT.
    
    superb - The superdiagonal of the upper bidiagonal matrix B. Dimension min(M,N)-1.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: if DBDSQR did not converge, INFO specifies how many superdiagonals of an intermediate bidiagonal form B did not converge to zero.
  - gesdd
```
public int gesdd(Layout layout,
                 SVDJob jobz,
                 int m,
                 int n,
                 double[] A,
                 int lda,
                 double[] s,
                 double[] U,
                 int ldu,
                 double[] VT,
                 int ldvt)
```
    Description copied from interface: LAPACK
    
    Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm.
    
    Specified by:
    
    gesdd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option for computing all or part of the matrix U.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). If JOBZ = 'O', A is overwritten with the first N columns of U (the left singular vectors, stored columnwise) if M >= N; A is overwritten with the first M rows of V**T (the right singular vectors, stored rowwise) otherwise. If JOBZ != 'O', the contents of A are destroyed.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    s - The singular values of A, sorted so that S(i) >= S(i+1). Dimension min(M,N).
    
    U - If JOBU = 'N' or 'O', U is not referenced.
    
    ldu - The leading dimension of the matrix U.
    
    VT - If JOBVT = 'N' or 'O', VT is not referenced.
    
    ldvt - The leading dimension of the matrix VT.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: DBDSDC did not converge, updating process failed.
  - gesdd
```
public int gesdd(Layout layout,
                 SVDJob jobz,
                 int m,
                 int n,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer s,
                 java.nio.DoubleBuffer U,
                 int ldu,
                 java.nio.DoubleBuffer VT,
                 int ldvt)
```
    Description copied from interface: LAPACK
    
    Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm.
    
    Specified by:
    
    gesdd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option for computing all or part of the matrix U.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). If JOBZ = 'O', A is overwritten with the first N columns of U (the left singular vectors, stored columnwise) if M >= N; A is overwritten with the first M rows of V**T (the right singular vectors, stored rowwise) otherwise. If JOBZ != 'O', the contents of A are destroyed.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    s - The singular values of A, sorted so that S(i) >= S(i+1). Dimension min(M,N).
    
    U - If JOBU = 'N' or 'O', U is not referenced.
    
    ldu - The leading dimension of the matrix U.
    
    VT - If JOBVT = 'N' or 'O', VT is not referenced.
    
    ldvt - The leading dimension of the matrix VT.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: DBDSDC did not converge, updating process failed.
  - gesdd
```
public int gesdd(Layout layout,
                 SVDJob jobz,
                 int m,
                 int n,
                 float[] A,
                 int lda,
                 float[] s,
                 float[] U,
                 int ldu,
                 float[] VT,
                 int ldvt)
```
    Description copied from interface: LAPACK
    
    Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm.
    
    Specified by:
    
    gesdd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option for computing all or part of the matrix U.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). If JOBZ = 'O', A is overwritten with the first N columns of U (the left singular vectors, stored columnwise) if M >= N; A is overwritten with the first M rows of V**T (the right singular vectors, stored rowwise) otherwise. If JOBZ != 'O', the contents of A are destroyed.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    s - The singular values of A, sorted so that S(i) >= S(i+1). Dimension min(M,N).
    
    U - If JOBU = 'N' or 'O', U is not referenced.
    
    ldu - The leading dimension of the matrix U.
    
    VT - If JOBVT = 'N' or 'O', VT is not referenced.
    
    ldvt - The leading dimension of the matrix VT.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: DBDSDC did not converge, updating process failed.
  - gesdd
```
public int gesdd(Layout layout,
                 SVDJob jobz,
                 int m,
                 int n,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer s,
                 java.nio.FloatBuffer U,
                 int ldu,
                 java.nio.FloatBuffer VT,
                 int ldvt)
```
    Description copied from interface: LAPACK
    
    Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. If singular vectors are desired, it uses a divide-and-conquer algorithm.
    
    Specified by:
    
    gesdd in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    jobz - The option for computing all or part of the matrix U.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). If JOBZ = 'O', A is overwritten with the first N columns of U (the left singular vectors, stored columnwise) if M >= N; A is overwritten with the first M rows of V**T (the right singular vectors, stored rowwise) otherwise. If JOBZ != 'O', the contents of A are destroyed.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,M).
    
    s - The singular values of A, sorted so that S(i) >= S(i+1). Dimension min(M,N).
    
    U - If JOBU = 'N' or 'O', U is not referenced.
    
    ldu - The leading dimension of the matrix U.
    
    VT - If JOBVT = 'N' or 'O', VT is not referenced.
    
    ldvt - The leading dimension of the matrix VT.
    
    Returns:
    
    INFO flag. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: DBDSDC did not converge, updating process failed.
  - getrf
```
public int getrf(Layout layout,
                 int m,
                 int n,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.IntBuffer ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
    
    Specified by:
    
    getrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - getrf
```
public int getrf(Layout layout,
                 int m,
                 int n,
                 double[] A,
                 int lda,
                 int[] ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
    
    Specified by:
    
    getrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - getrf
```
public int getrf(Layout layout,
                 int m,
                 int n,
                 float[] A,
                 int lda,
                 int[] ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
    
    Specified by:
    
    getrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - getrf
```
public int getrf(Layout layout,
                 int m,
                 int n,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.IntBuffer ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
    
    Specified by:
    
    getrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - getrf2
```
public int getrf2(Layout layout,
                  int m,
                  int n,
                  double[] A,
                  int lda,
                  int[] ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. This is the recursive version of the algorithm.
    
    Specified by:
    
    getrf2 in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - getrf2
```
public int getrf2(Layout layout,
                  int m,
                  int n,
                  java.nio.DoubleBuffer A,
                  int lda,
                  java.nio.IntBuffer ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. This is the recursive version of the algorithm.
    
    Specified by:
    
    getrf2 in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - getrf2
```
public int getrf2(Layout layout,
                  int m,
                  int n,
                  float[] A,
                  int lda,
                  int[] ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. This is the recursive version of the algorithm.
    
    Specified by:
    
    getrf2 in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - getrf2
```
public int getrf2(Layout layout,
                  int m,
                  int n,
                  java.nio.FloatBuffer A,
                  int lda,
                  java.nio.IntBuffer ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. This is the recursive version of the algorithm.
    
    Specified by:
    
    getrf2 in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - gbtrf
```
public int gbtrf(Layout layout,
                 int m,
                 int n,
                 int kl,
                 int ku,
                 double[] AB,
                 int ldab,
                 int[] ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a band matrix A using partial pivoting with row interchanges.
    
    Specified by:
    
    gbtrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    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.
    
    AB - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    ldab - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - gbtrf
```
public int gbtrf(Layout layout,
                 int m,
                 int n,
                 int kl,
                 int ku,
                 java.nio.DoubleBuffer AB,
                 int ldab,
                 java.nio.IntBuffer ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a band matrix A using partial pivoting with row interchanges.
    
    Specified by:
    
    gbtrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    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.
    
    AB - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    ldab - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - gbtrf
```
public int gbtrf(Layout layout,
                 int m,
                 int n,
                 int kl,
                 int ku,
                 float[] AB,
                 int ldab,
                 int[] ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a band matrix A using partial pivoting with row interchanges.
    
    Specified by:
    
    gbtrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    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.
    
    AB - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    ldab - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - gbtrf
```
public int gbtrf(Layout layout,
                 int m,
                 int n,
                 int kl,
                 int ku,
                 java.nio.FloatBuffer AB,
                 int ldab,
                 java.nio.IntBuffer ipiv)
```
    Description copied from interface: LAPACK
    
    Computes an LU factorization of a band matrix A using partial pivoting with row interchanges.
    
    Specified by:
    
    gbtrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    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.
    
    AB - The matrix of dimension (LDA, N). On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
    
    ldab - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - sptrf
```
public int sptrf(Layout layout,
                 UPLO uplo,
                 int n,
                 double[] AP,
                 int[] ipiv)
```
    Description copied from interface: LAPACK
    
    Computes the Bunch–Kaufman factorization of a symmetric packed matrix A.
    
    Specified by:
    
    sptrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    AP - The packed matrix.
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, D(i,i) is exactly zero. The factorization has been completed, but the block diagonal matrix D is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - sptrf
```
public int sptrf(Layout layout,
                 UPLO uplo,
                 int n,
                 java.nio.DoubleBuffer AP,
                 java.nio.IntBuffer ipiv)
```
    Description copied from interface: LAPACK
    
    Computes the Bunch–Kaufman factorization of a symmetric packed matrix A.
    
    Specified by:
    
    sptrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    AP - The packed matrix.
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, D(i,i) is exactly zero. The factorization has been completed, but the block diagonal matrix D is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - sptrf
```
public int sptrf(Layout layout,
                 UPLO uplo,
                 int n,
                 float[] AP,
                 int[] ipiv)
```
    Description copied from interface: LAPACK
    
    Computes the Bunch–Kaufman factorization of a symmetric packed matrix A.
    
    Specified by:
    
    sptrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    AP - The packed matrix.
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, D(i,i) is exactly zero. The factorization has been completed, but the block diagonal matrix D is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - sptrf
```
public int sptrf(Layout layout,
                 UPLO uplo,
                 int n,
                 java.nio.FloatBuffer AP,
                 java.nio.IntBuffer ipiv)
```
    Description copied from interface: LAPACK
    
    Computes the Bunch–Kaufman factorization of a symmetric packed matrix A.
    
    Specified by:
    
    sptrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    AP - The packed matrix.
    
    ipiv - The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i). Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, D(i,i) is exactly zero. The factorization has been completed, but the block diagonal matrix D is exactly singular, and division by zero will occur if it is used to solve a system of equations.
  - getrs
```
public int getrs(Layout layout,
                 Transpose trans,
                 int n,
                 int nrhs,
                 double[] A,
                 int lda,
                 int[] ipiv,
                 double[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N matrix and X and B are N-by-NRHS matrices using the LU factorization computed by GETRF.
    Specified by:
    
    getrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The LU factorization computed by GETRF.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - getrs
```
public int getrs(Layout layout,
                 Transpose trans,
                 int n,
                 int nrhs,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.IntBuffer ipiv,
                 java.nio.DoubleBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N matrix and X and B are N-by-NRHS matrices using the LU factorization computed by GETRF.
    Specified by:
    
    getrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The LU factorization computed by GETRF.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - getrs
```
public int getrs(Layout layout,
                 Transpose trans,
                 int n,
                 int nrhs,
                 float[] A,
                 int lda,
                 int[] ipiv,
                 float[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N matrix and X and B are N-by-NRHS matrices using the LU factorization computed by GETRF.
    Specified by:
    
    getrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The LU factorization computed by GETRF.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - getrs
```
public int getrs(Layout layout,
                 Transpose trans,
                 int n,
                 int nrhs,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.IntBuffer ipiv,
                 java.nio.FloatBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N matrix and X and B are N-by-NRHS matrices using the LU factorization computed by GETRF.
    Specified by:
    
    getrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The LU factorization computed by GETRF.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - gbtrs
```
public int gbtrs(Layout layout,
                 Transpose trans,
                 int n,
                 int kl,
                 int ku,
                 int nrhs,
                 double[] A,
                 int lda,
                 int[] ipiv,
                 double[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N band matrix and X and B are N-by-NRHS matrices using the LU factorization computed by GBTRF.
    Specified by:
    
    gbtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kl - The number of subdiagonal elements of band matrix.
    
    ku - The number of superdiagonal elements of band matrix.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The LU factorization computed by GBTRF.
    
    lda - The leading dimension of the matrix AB. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - gbtrs
```
public int gbtrs(Layout layout,
                 Transpose trans,
                 int n,
                 int kl,
                 int ku,
                 int nrhs,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.IntBuffer ipiv,
                 java.nio.DoubleBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N band matrix and X and B are N-by-NRHS matrices using the LU factorization computed by GBTRF.
    Specified by:
    
    gbtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kl - The number of subdiagonal elements of band matrix.
    
    ku - The number of superdiagonal elements of band matrix.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The LU factorization computed by GBTRF.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - gbtrs
```
public int gbtrs(Layout layout,
                 Transpose trans,
                 int n,
                 int kl,
                 int ku,
                 int nrhs,
                 float[] A,
                 int lda,
                 int[] ipiv,
                 float[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N band matrix and X and B are N-by-NRHS matrices using the LU factorization computed by GBTRF.
    Specified by:
    
    gbtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kl - The number of subdiagonal elements of band matrix.
    
    ku - The number of superdiagonal elements of band matrix.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The LU factorization computed by GBTRF.
    
    lda - The leading dimension of the matrix AB. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - gbtrs
```
public int gbtrs(Layout layout,
                 Transpose trans,
                 int n,
                 int kl,
                 int ku,
                 int nrhs,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.IntBuffer ipiv,
                 java.nio.FloatBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N band matrix and X and B are N-by-NRHS matrices using the LU factorization computed by GBTRF.
    Specified by:
    
    gbtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kl - The number of subdiagonal elements of band matrix.
    
    ku - The number of superdiagonal elements of band matrix.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The LU factorization computed by GBTRF.
    
    lda - The leading dimension of the matrix AB. LDA >= max(1,N).
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - sptrs
```
public int sptrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 double[] AP,
                 int[] ipiv,
                 double[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N packed matrix and X and B are N-by-NRHS matrices using the Bunch-Kaufman factorization computed by SPTRF.
    Specified by:
    
    sptrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AP - The Bunch-Kaufman factorization computed by SPTRF.
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - sptrs
```
public int sptrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 java.nio.DoubleBuffer AP,
                 java.nio.IntBuffer ipiv,
                 java.nio.DoubleBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N packed matrix and X and B are N-by-NRHS matrices using the Bunch-Kaufman factorization computed by SPTRF.
    Specified by:
    
    sptrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AP - The Bunch-Kaufman factorization computed by SPTRF.
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - sptrs
```
public int sptrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 float[] AP,
                 int[] ipiv,
                 float[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N packed matrix and X and B are N-by-NRHS matrices using the Bunch-Kaufman factorization computed by SPTRF.
    Specified by:
    
    sptrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AP - The Bunch-Kaufman factorization computed by SPTRF.
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - sptrs
```
public int sptrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 java.nio.FloatBuffer AP,
                 java.nio.IntBuffer ipiv,
                 java.nio.FloatBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is an N-by-N packed matrix and X and B are N-by-NRHS matrices using the Bunch-Kaufman factorization computed by SPTRF.
    Specified by:
    
    sptrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AP - The Bunch-Kaufman factorization computed by SPTRF.
    
    ipiv - The pivot indices that define the permutation matrix P; row i of the matrix was interchanged with row IPIV(i).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - potrf
```
public int potrf(Layout layout,
                 UPLO uplo,
                 int n,
                 double[] A,
                 int lda)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite matrix A.
    
    Specified by:
    
    potrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - potrf
```
public int potrf(Layout layout,
                 UPLO uplo,
                 int n,
                 java.nio.DoubleBuffer A,
                 int lda)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite matrix A.
    
    Specified by:
    
    potrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - potrf
```
public int potrf(Layout layout,
                 UPLO uplo,
                 int n,
                 float[] A,
                 int lda)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite matrix A.
    
    Specified by:
    
    potrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - potrf
```
public int potrf(Layout layout,
                 UPLO uplo,
                 int n,
                 java.nio.FloatBuffer A,
                 int lda)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite matrix A.
    
    Specified by:
    
    potrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - potrf2
```
public int potrf2(Layout layout,
                  UPLO uplo,
                  int n,
                  double[] A,
                  int lda)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm.
    
    Specified by:
    
    potrf2 in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - potrf2
```
public int potrf2(Layout layout,
                  UPLO uplo,
                  int n,
                  java.nio.DoubleBuffer A,
                  int lda)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm.
    
    Specified by:
    
    potrf2 in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - potrf2
```
public int potrf2(Layout layout,
                  UPLO uplo,
                  int n,
                  float[] A,
                  int lda)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm.
    
    Specified by:
    
    potrf2 in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - potrf2
```
public int potrf2(Layout layout,
                  UPLO uplo,
                  int n,
                  java.nio.FloatBuffer A,
                  int lda)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite matrix A using the recursive algorithm.
    
    Specified by:
    
    potrf2 in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - pbtrf
```
public int pbtrf(Layout layout,
                 UPLO uplo,
                 int n,
                 int kd,
                 double[] AB,
                 int ldab)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
    
    Specified by:
    
    pbtrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    kd - The number of superdiagonals/subdiagonals of the matrix A.
    
    AB - The band matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    ldab - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - pbtrf
```
public int pbtrf(Layout layout,
                 UPLO uplo,
                 int n,
                 int kd,
                 java.nio.DoubleBuffer AB,
                 int ldab)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
    
    Specified by:
    
    pbtrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    kd - The number of superdiagonals/subdiagonals of the matrix A.
    
    AB - The band matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    ldab - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - pbtrf
```
public int pbtrf(Layout layout,
                 UPLO uplo,
                 int n,
                 int kd,
                 float[] AB,
                 int ldab)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
    
    Specified by:
    
    pbtrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    kd - The number of superdiagonals/subdiagonals of the matrix A.
    
    AB - The band matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    ldab - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - pbtrf
```
public int pbtrf(Layout layout,
                 UPLO uplo,
                 int n,
                 int kd,
                 java.nio.FloatBuffer AB,
                 int ldab)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite band matrix A.
    
    Specified by:
    
    pbtrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    kd - The number of superdiagonals/subdiagonals of the matrix A.
    
    AB - The band matrix of dimension (LDA, N). On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    ldab - The leading dimension of the matrix A. LDA >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - pptrf
```
public int pptrf(Layout layout,
                 UPLO uplo,
                 int n,
                 double[] AP)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite packed matrix A.
    
    Specified by:
    
    pptrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    AP - The packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - pptrf
```
public int pptrf(Layout layout,
                 UPLO uplo,
                 int n,
                 java.nio.DoubleBuffer AP)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite packed matrix A.
    
    Specified by:
    
    pptrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    AP - The packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - pptrf
```
public int pptrf(Layout layout,
                 UPLO uplo,
                 int n,
                 float[] AP)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite packed matrix A.
    
    Specified by:
    
    pptrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    AP - The packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - pptrf
```
public int pptrf(Layout layout,
                 UPLO uplo,
                 int n,
                 java.nio.FloatBuffer AP)
```
    Description copied from interface: LAPACK
    
    Computes the Cholesky factorization of a real symmetric positive definite packed matrix A.
    
    Specified by:
    
    pptrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The dimension of the matrix A.
    
    AP - The packed matrix. On exit, the factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the leading minor of order i is not positive definite, and the factorization could not be completed.
  - potrs
```
public int potrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 double[] A,
                 int lda,
                 double[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by POTRF.
    Specified by:
    
    potrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by POTRF.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - potrs
```
public int potrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by POTRF.
    Specified by:
    
    potrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by POTRF.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - potrs
```
public int potrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 float[] A,
                 int lda,
                 float[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by POTRF.
    Specified by:
    
    potrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by POTRF.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - potrs
```
public int potrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by POTRF.
    Specified by:
    
    potrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    A - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by POTRF.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - pbtrs
```
public int pbtrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int kd,
                 int nrhs,
                 double[] AB,
                 int ldab,
                 double[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by POTRF.
    Specified by:
    
    pbtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kd - The number of superdiagonals/subdiagonals of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AB - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by PBTRF.
    
    ldab - The leading dimension of the matrix AB. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - pbtrs
```
public int pbtrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int kd,
                 int nrhs,
                 java.nio.DoubleBuffer AB,
                 int ldab,
                 java.nio.DoubleBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by POTRF.
    Specified by:
    
    pbtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kd - The number of superdiagonals/subdiagonals of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AB - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by PBTRF.
    
    ldab - The leading dimension of the matrix AB. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - pbtrs
```
public int pbtrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int kd,
                 int nrhs,
                 float[] AB,
                 int ldab,
                 float[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by POTRF.
    Specified by:
    
    pbtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kd - The number of superdiagonals/subdiagonals of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AB - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by PBTRF.
    
    ldab - The leading dimension of the matrix AB. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - pbtrs
```
public int pbtrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int kd,
                 int nrhs,
                 java.nio.FloatBuffer AB,
                 int ldab,
                 java.nio.FloatBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite band matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by POTRF.
    Specified by:
    
    pbtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    kd - The number of superdiagonals/subdiagonals of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AB - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by PBTRF.
    
    ldab - The leading dimension of the matrix AB. LDA >= max(1,N).
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - pptrs
```
public int pptrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 double[] AP,
                 double[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite packed matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by PPTRF.
    Specified by:
    
    pptrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AP - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by PPTRF.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - pptrs
```
public int pptrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 java.nio.DoubleBuffer AP,
                 java.nio.DoubleBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite packed matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by PPTRF.
    Specified by:
    
    pptrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AP - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by PPTRF.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - pptrs
```
public int pptrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 float[] AP,
                 float[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite packed matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by PPTRF.
    Specified by:
    
    pptrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AP - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by PPTRF.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - pptrs
```
public int pptrs(Layout layout,
                 UPLO uplo,
                 int n,
                 int nrhs,
                 java.nio.FloatBuffer AP,
                 java.nio.FloatBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a system of linear equations
```
     A * X = B
 
```
    where A is an N-by-N symmetric positive definite packed matrix and X and B are N-by-NRHS matrices using the Cholesky factorization A = U**T*U or A = L*L**T computed by PPTRF.
    Specified by:
    
    pptrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    n - The number of linear equations, i.e., the order of the matrix A.
    
    nrhs - The number of right hand sides, i.e., the number of columns of the matrix B.
    
    AP - The triangular factor U or L from the Cholesky factorization A = U**T*U or A = L*L**T, as computed by PPTRF.
    
    B - On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if INFO = 0, the N-by-NRHS solution matrix X.
    
    ldb - The leading dimension of the matrix B. LDB >= max(1,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - geqrf
```
public int geqrf(Layout layout,
                 int m,
                 int n,
                 double[] A,
                 int lda,
                 double[] tau)
```
    Description copied from interface: LAPACK
    
    Computes a QR factorization of a general M-by-N matrix A.
    
    Specified by:
    
    geqrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    tau - The scalar factors of the elementary reflectors. Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - geqrf
```
public int geqrf(Layout layout,
                 int m,
                 int n,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer tau)
```
    Description copied from interface: LAPACK
    
    Computes a QR factorization of a general M-by-N matrix A.
    
    Specified by:
    
    geqrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    tau - The scalar factors of the elementary reflectors. Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - geqrf
```
public int geqrf(Layout layout,
                 int m,
                 int n,
                 float[] A,
                 int lda,
                 float[] tau)
```
    Description copied from interface: LAPACK
    
    Computes a QR factorization of a general M-by-N matrix A.
    
    Specified by:
    
    geqrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    tau - The scalar factors of the elementary reflectors. Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - geqrf
```
public int geqrf(Layout layout,
                 int m,
                 int n,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer tau)
```
    Description copied from interface: LAPACK
    
    Computes a QR factorization of a general M-by-N matrix A.
    
    Specified by:
    
    geqrf in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    A - The matrix of dimension (LDA, N). On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors.
    
    lda - The leading dimension of the matrix A. LDA >= max(1,N).
    
    tau - The scalar factors of the elementary reflectors. Dimension min(M,N).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - ormqr
```
public int ormqr(Layout layout,
                 Side side,
                 Transpose trans,
                 int m,
                 int n,
                 int k,
                 double[] A,
                 int lda,
                 double[] tau,
                 double[] C,
                 int ldc)
```
    Description copied from interface: LAPACK
    Overwrites the general real M-by-N matrix C with
```
                  SIDE = 'L'     SIDE = 'R'
  TRANS = 'N':      Q * C          C * Q
  TRANS = 'T':      Q**T * C       C * Q**T
 
```
    where Q is a real orthogonal matrix defined as the product of k elementary reflectors
```
        Q = H(1) H(2) . . . H(k)
 
```
    as returned by GEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
    Specified by:
    
    ormqr in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    side - Apply Q or Q**T from the Left; or apply Q or Q**T from the Right.
    
    trans - No transpose, apply Q; Transpose, apply Q**T.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    k - The number of elementary reflectors whose product defines the matrix Q.
    
    A - The matrix of dimension (LDA, K). The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by GEQRF in the first k columns of its array argument A.
    
    lda - The leading dimension of the matrix A. If SIDE = 'L', LDA >= max(1,M); if SIDE = 'R', LDA >= max(1,N).
    
    tau - The scalar factors of the elementary reflectors, as returned by GEQRF.
    
    C - On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
    
    ldc - The leading dimension of the matrix C. LDC >= max(1,M).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - ormqr
```
public int ormqr(Layout layout,
                 Side side,
                 Transpose trans,
                 int m,
                 int n,
                 int k,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer tau,
                 java.nio.DoubleBuffer C,
                 int ldc)
```
    Description copied from interface: LAPACK
    Overwrites the general real M-by-N matrix C with
```
                  SIDE = 'L'     SIDE = 'R'
  TRANS = 'N':      Q * C          C * Q
  TRANS = 'T':      Q**T * C       C * Q**T
 
```
    where Q is a real orthogonal matrix defined as the product of k elementary reflectors
```
        Q = H(1) H(2) . . . H(k)
 
```
    as returned by GEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
    Specified by:
    
    ormqr in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    side - Apply Q or Q**T from the Left; or apply Q or Q**T from the Right.
    
    trans - No transpose, apply Q; Transpose, apply Q**T.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    k - The number of elementary reflectors whose product defines the matrix Q.
    
    A - The matrix of dimension (LDA, K). The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by GEQRF in the first k columns of its array argument A.
    
    lda - The leading dimension of the matrix A. If SIDE = 'L', LDA >= max(1,M); if SIDE = 'R', LDA >= max(1,N).
    
    tau - The scalar factors of the elementary reflectors, as returned by GEQRF.
    
    C - On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
    
    ldc - The leading dimension of the matrix C. LDC >= max(1,M).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - ormqr
```
public int ormqr(Layout layout,
                 Side side,
                 Transpose trans,
                 int m,
                 int n,
                 int k,
                 float[] A,
                 int lda,
                 float[] tau,
                 float[] C,
                 int ldc)
```
    Description copied from interface: LAPACK
    Overwrites the general real M-by-N matrix C with
```
                  SIDE = 'L'     SIDE = 'R'
  TRANS = 'N':      Q * C          C * Q
  TRANS = 'T':      Q**T * C       C * Q**T
 
```
    where Q is a real orthogonal matrix defined as the product of k elementary reflectors
```
        Q = H(1) H(2) . . . H(k)
 
```
    as returned by GEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
    Specified by:
    
    ormqr in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    side - Apply Q or Q**T from the Left; or apply Q or Q**T from the Right.
    
    trans - No transpose, apply Q; Transpose, apply Q**T.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    k - The number of elementary reflectors whose product defines the matrix Q.
    
    A - The matrix of dimension (LDA, K). The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by GEQRF in the first k columns of its array argument A.
    
    lda - The leading dimension of the matrix A. If SIDE = 'L', LDA >= max(1,M); if SIDE = 'R', LDA >= max(1,N).
    
    tau - The scalar factors of the elementary reflectors, as returned by GEQRF.
    
    C - On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
    
    ldc - The leading dimension of the matrix C. LDC >= max(1,M).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - ormqr
```
public int ormqr(Layout layout,
                 Side side,
                 Transpose trans,
                 int m,
                 int n,
                 int k,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer tau,
                 java.nio.FloatBuffer C,
                 int ldc)
```
    Description copied from interface: LAPACK
    Overwrites the general real M-by-N matrix C with
```
                  SIDE = 'L'     SIDE = 'R'
  TRANS = 'N':      Q * C          C * Q
  TRANS = 'T':      Q**T * C       C * Q**T
 
```
    where Q is a real orthogonal matrix defined as the product of k elementary reflectors
```
        Q = H(1) H(2) . . . H(k)
 
```
    as returned by GEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
    Specified by:
    
    ormqr in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    side - Apply Q or Q**T from the Left; or apply Q or Q**T from the Right.
    
    trans - No transpose, apply Q; Transpose, apply Q**T.
    
    m - The number of rows of the matrix A.
    
    n - The number of columns of the matrix A.
    
    k - The number of elementary reflectors whose product defines the matrix Q.
    
    A - The matrix of dimension (LDA, K). The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by GEQRF in the first k columns of its array argument A.
    
    lda - The leading dimension of the matrix A. If SIDE = 'L', LDA >= max(1,M); if SIDE = 'R', LDA >= max(1,N).
    
    tau - The scalar factors of the elementary reflectors, as returned by GEQRF.
    
    C - On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
    
    ldc - The leading dimension of the matrix C. LDC >= max(1,M).
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
  - trtrs
```
public int trtrs(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 int nrhs,
                 double[] A,
                 int lda,
                 double[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a triangular system of the form
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
    Specified by:
    
    trtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    trans - The normal or transpose of the matrix A.
    
    diag - A is unit diagonal triangular or not.
    
    n - The order of the matrix A.
    
    nrhs - The number of right hand sides.
    
    A - The triangular matrix A.
    
    lda - The leading dimension of the matrix A.
    
    B - On entry, the right hand side matrix B. On exit, if INFO = 0, the solution matrix X.
    
    ldb - The leading dimension of the matrix B.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of A is zero, indicating that the matrix is singular and the solutions X have not been computed.
  - trtrs
```
public int trtrs(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 int nrhs,
                 java.nio.DoubleBuffer A,
                 int lda,
                 java.nio.DoubleBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a triangular system of the form
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
    Specified by:
    
    trtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    trans - The normal or transpose of the matrix A.
    
    diag - A is unit diagonal triangular or not.
    
    n - The order of the matrix A.
    
    nrhs - The number of right hand sides.
    
    A - The triangular matrix A.
    
    lda - The leading dimension of the matrix A.
    
    B - On entry, the right hand side matrix B. On exit, if INFO = 0, the solution matrix X.
    
    ldb - The leading dimension of the matrix B.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of A is zero, indicating that the matrix is singular and the solutions X have not been computed.
  - trtrs
```
public int trtrs(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 int nrhs,
                 float[] A,
                 int lda,
                 float[] B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a triangular system of the form
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
    Specified by:
    
    trtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    trans - The normal or transpose of the matrix A.
    
    diag - A is unit diagonal triangular or not.
    
    n - The order of the matrix A.
    
    nrhs - The number of right hand sides.
    
    A - The triangular matrix A.
    
    lda - The leading dimension of the matrix A.
    
    B - On entry, the right hand side matrix B. On exit, if INFO = 0, the solution matrix X.
    
    ldb - The leading dimension of the matrix B.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of A is zero, indicating that the matrix is singular and the solutions X have not been computed.
  - trtrs
```
public int trtrs(Layout layout,
                 UPLO uplo,
                 Transpose trans,
                 Diag diag,
                 int n,
                 int nrhs,
                 java.nio.FloatBuffer A,
                 int lda,
                 java.nio.FloatBuffer B,
                 int ldb)
```
    Description copied from interface: LAPACK
    Solves a triangular system of the form
```
     A * X = B
 
```
    or
```
     A**T * X = B
 
```
    where A is a triangular matrix of order N, and B is an N-by-NRHS matrix. A check is made to verify that A is nonsingular.
    Specified by:
    
    trtrs in interface LAPACK
    
    Parameters:
    
    layout - The matrix layout.
    
    uplo - The upper or lower triangular part of the matrix A is to be referenced.
    
    trans - The normal or transpose of the matrix A.
    
    diag - A is unit diagonal triangular or not.
    
    n - The order of the matrix A.
    
    nrhs - The number of right hand sides.
    
    A - The triangular matrix A.
    
    lda - The leading dimension of the matrix A.
    
    B - On entry, the right hand side matrix B. On exit, if INFO = 0, the solution matrix X.
    
    ldb - The leading dimension of the matrix B.
    
    Returns:
    
    INFO flag. = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, the i-th diagonal element of A is zero, indicating that the matrix is singular and the solutions X have not been computed.

Class OpenBLAS

Field Summary

Fields inherited from interface smile.math.blas.BLAS

Fields inherited from interface smile.math.blas.LAPACK

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface smile.math.blas.BLAS

Methods inherited from interface smile.math.blas.LAPACK

Constructor Detail

OpenBLAS

Method Detail

asum

asum

axpy

axpy

dot

dot

nrm2

nrm2

scal

scal

swap

swap

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

symm

symm

symm

symm

gesv

gesv

gesv

gesv

sysv

sysv