Package smile.math.blas

Interface BLAS

All Known Implementing Classes:

OpenBLAS

public interface BLAS

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

Field Summary

Fields

Modifier and Type	Field	Description
static final BLAS	engine	The default BLAS engine.

Method Summary

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

Field Details

engine

static final BLAS engine

The default BLAS engine.

Method Details

getInstance

static BLAS getInstance()

Creates an instance.

Returns:

a BLAS instance.

asum

double asum(int n,
 double[] x,
 int incx)

Sums the absolute values of the elements of a vector. When working backward (incx < 0), each routine starts at the end of the vector and moves backward.

Parameters:

n - Number of vector elements to be summed.

x - Array of dimension (n-1) * abs(incx)+ 1. Vector that contains elements to be summed.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

Returns:

Sum of the absolute values of the elements of the vector x. If n <= 0, DASUM is set to 0.

asum

float asum(int n,
 float[] x,
 int incx)

Sums the absolute values of the elements of a vector. When working backward (incx < 0), each routine starts at the end of the vector and moves backward.

Parameters:

n - Number of vector elements to be summed.

x - Array of dimension (n-1) * abs(incx)+ 1. Vector that contains elements to be summed.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

Returns:

Sum of the absolute values of the elements of the vector x. If n <= 0, DASUM is set to 0.

asum

default double asum(double[] x)

Sums the absolute values of the elements of a vector.

Parameters:

x - Vector that contains elements to be summed.

Returns:

Sum of the absolute values of the elements of the vector x.

asum

default float asum(float[] x)

Sums the absolute values of the elements of a vector.

Parameters:

x - Vector that contains elements to be summed.

Returns:

Sum of the absolute values of the elements of the vector x.

axpy

void axpy(int n,
 double alpha,
 double[] x,
 int incx,
 double[] y,
 int incy)

Computes a constant alpha times a vector x plus a vector y. The result overwrites the initial values of vector y. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.

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

Parameters:

n - Number of elements in the vectors. If n <= 0, these routines return without any computation.

alpha - If alpha = 0 this routine returns without any computation.

x - Input array of dimension (n-1) * |incx| + 1. Contains the vector to be scaled before summation.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

y - Input and output array of dimension (n-1) * |incy| + 1. Before calling the routine, y contains the vector to be summed. After the routine ends, y contains the result of the summation.

incy - Increment between elements of y. If incy = 0, the results will be unpredictable.

axpy

void axpy(int n,
 float alpha,
 float[] x,
 int incx,
 float[] y,
 int incy)

Computes a constant alpha times a vector x plus a vector y. The result overwrites the initial values of vector y. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.

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

Parameters:

n - Number of elements in the vectors. If n <= 0, these routines return without any computation.

alpha - If alpha = 0 this routine returns without any computation.

x - Input array of dimension (n-1) * |incx| + 1. Contains the vector to be scaled before summation.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

y - Input and output array of dimension (n-1) * |incy| + 1. Before calling the routine, y contains the vector to be summed. After the routine ends, y contains the result of the summation.

incy - Increment between elements of y. If incy = 0, the results will be unpredictable.

axpy

default void axpy(double alpha,
 double[] x,
 double[] y)

Computes a constant alpha times a vector x plus a vector y. The result overwrites the initial values of vector y.

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

Parameters:

alpha - If alpha = 0 this routine returns without any computation.

x - The vector to be scaled before summation.

y - Input and output array. Before calling the routine, y contains the vector to be summed. After the routine ends, y contains the result of the summation.

axpy

default void axpy(float alpha,
 float[] x,
 float[] y)

Computes a constant alpha times a vector x plus a vector y. The result overwrites the initial values of vector y.

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

Parameters:

alpha - If alpha = 0 this routine returns without any computation.

x - The vector to be scaled before summation.

y - Input and output array. Before calling the routine, y contains the vector to be summed. After the routine ends, y contains the result of the summation.

dot

double dot(int n,
 double[] x,
 int incx,
 double[] y,
 int incy)

Computes the dot product of two vectors. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.

Parameters:

n - Number of elements in the vectors.

x - Input array of dimension (n-1) * |incx| + 1. Array x contains the first vector operand.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

y - Input array of dimension (n-1) * |incy| + 1. Array y contains the second vector operand.

incy - Increment between elements of y. If incy = 0, the results will be unpredictable.

Returns:

dot product. If n <= 0, return 0.

dot

float dot(int n,
 float[] x,
 int incx,
 float[] y,
 int incy)

Computes the dot product of two vectors. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.

Parameters:

n - Number of elements in the vectors.

x - Input array of dimension (n-1) * |incx| + 1. Array x contains the first vector operand.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

y - Input array of dimension (n-1) * |incy| + 1. Array y contains the second vector operand.

incy - Increment between elements of y. If incy = 0, the results will be unpredictable.

Returns:

dot product. If n <= 0, return 0.

dot

default double dot(double[] x,
 double[] y)

Computes the dot product of two vectors.

Parameters:

x - Array x contains the first vector operand.

y - Array y contains the second vector operand.

Returns:

dot product. If n <= 0, return 0.

dot

default float dot(float[] x,
 float[] y)

Computes the dot product of two vectors.

Parameters:

x - Array x contains the first vector operand.

y - Array y contains the second vector operand.

Returns:

dot product. If n <= 0, return 0.

nrm2

double nrm2(int n,
 double[] x,
 int incx)

Computes the Euclidean (L2) norm of a vector.

Parameters:

n - Number of elements in the vectors.

x - Input array of dimension (n-1) * |incx| + 1. Array x contains the vector operand.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

Returns:

Euclidean norm. If n <= 0, return 0.

nrm2

float nrm2(int n,
 float[] x,
 int incx)

Computes the Euclidean (L2) norm of a vector.

Parameters:

n - Number of elements in the vectors.

x - Input array of dimension (n-1) * |incx| + 1. Array x contains the vector operand.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

Returns:

Euclidean norm. If n <= 0, return 0.

nrm2

default double nrm2(double[] x)

Computes the Euclidean (L2) norm of a vector.

Parameters:

x - Array x contains the vector operand.

Returns:

Euclidean norm.

nrm2

default float nrm2(float[] x)

Computes the Euclidean (L2) norm of a vector.

Parameters:

x - Array x contains the vector operand.

Returns:

Euclidean norm.

scal

void scal(int n,
 double alpha,
 double[] x,
 int incx)

Scales a vector with a scalar.

Parameters:

n - Number of elements in the vectors.

alpha - The scaling factor.

x - Input and output array of dimension (n-1) * |incx| + 1. Vector to be scaled.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

scal

void scal(int n,
 float alpha,
 float[] x,
 int incx)

Scales a vector with a scalar.

Parameters:

n - Number of elements in the vectors.

alpha - The scaling factor.

x - Input and output array of dimension (n-1) * |incx| + 1. Vector to be scaled.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

scal

default void scal(double alpha,
 double[] x)

Scales a vector with a scalar.

Parameters:

alpha - The scaling factor.

x - Input and output vector to be scaled.

scal

default void scal(float alpha,
 float[] x)

Scales a vector with a scalar.

Parameters:

alpha - The scaling factor.

x - Input and output vector to be scaled.

swap

void swap(int n,
 double[] x,
 int incx,
 double[] y,
 int incy)

Swaps two vectors. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.

Parameters:

n - Number of elements in the vectors.

x - Input and output array of dimension (n-1) * |incx| + 1. Vector to be swapped.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

y - Input and output array of dimension (n-1) * |incy| + 1. Vector to be swapped.

incy - Increment between elements of y. If incy = 0, the results will be unpredictable.

swap

void swap(int n,
 float[] x,
 int incx,
 float[] y,
 int incy)

Swaps two vectors. incx and incy specify the increment between two consecutive elements of respectively vector x and y. When working backward (incx < 0 or incy < 0), each routine starts at the end of the vector and moves backward.

Parameters:

n - Number of elements in the vectors.

x - Input and output array of dimension (n-1) * |incx| + 1. Vector to be swapped.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

y - Input and output array of dimension (n-1) * |incy| + 1. Vector to be swapped.

incy - Increment between elements of y. If incy = 0, the results will be unpredictable.

swap

default void swap(double[] x,
 double[] y)

Swaps two vectors.

Parameters:

x - Input and output vector to be swapped.

y - Input and output vector to be swapped.

swap

default void swap(float[] x,
 float[] y)

Swaps two vectors.

Parameters:

x - Input and output vector to be swapped.

y - Input and output vector to be swapped.

iamax

long iamax(int n,
 double[] x,
 int incx)

Searches a vector for the first occurrence of the the maximum absolute value.

Parameters:

n - Number of elements in the vectors.

x - Input array of dimension (n-1) * |incx| + 1. Vector to be searched.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

Returns:

The first index of the maximum absolute value of vector x. If n <= 0, return 0.

iamax

long iamax(int n,
 float[] x,
 int incx)

Searches a vector for the first occurrence of the the maximum absolute value.

Parameters:

n - Number of elements in the vectors.

x - Input array of dimension (n-1) * |incx| + 1. Vector to be searched.

incx - Increment between elements of x. If incx = 0, the results will be unpredictable.

Returns:

The first index of the maximum absolute value of vector x. If n <= 0, return 0.

iamax

default long iamax(double[] x)

Searches a vector for the first occurrence of the the maximum absolute value.

Parameters:

x - Vector to be searched.

Returns:

The first index of the maximum absolute value of vector x.

iamax

default long iamax(float[] x)

Searches a vector for the first occurrence of the the maximum absolute value.

Parameters:

x - Vector to be searched.

Returns:

The first index of the maximum absolute value of vector x.

gemv

void gemv(Layout layout,
 Transpose trans,
 int m,
 int n,
 double alpha,
 double[] A,
 int lda,
 double[] x,
 int incx,
 double beta,
 double[] y,
 int incy)

Performs the matrix-vector operation.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

trans - normal, transpose, or conjugate transpose operation on the matrix.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (m - 1) * abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1) * abs(incy)) otherwise.

incy - the increment for the elements of y, which must not be zero.

gemv

void gemv(Layout layout,
 Transpose trans,
 int m,
 int n,
 double alpha,
 DoubleBuffer A,
 int lda,
 DoubleBuffer x,
 int incx,
 double beta,
 DoubleBuffer y,
 int incy)

Performs the matrix-vector operation.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

trans - normal, transpose, or conjugate transpose operation on the matrix.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (m - 1) * abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1) * abs(incy)) otherwise.

incy - the increment for the elements of y, which must not be zero.

gemv

void gemv(Layout layout,
 Transpose trans,
 int m,
 int n,
 double alpha,
 org.bytedeco.javacpp.DoublePointer A,
 int lda,
 org.bytedeco.javacpp.DoublePointer x,
 int incx,
 double beta,
 org.bytedeco.javacpp.DoublePointer y,
 int incy)

Performs the matrix-vector operation.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

trans - normal, transpose, or conjugate transpose operation on the matrix.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (m - 1) * abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1) * abs(incy)) otherwise.

incy - the increment for the elements of y, which must not be zero.

gemv

void gemv(Layout layout,
 Transpose trans,
 int m,
 int n,
 float alpha,
 float[] A,
 int lda,
 float[] x,
 int incx,
 float beta,
 float[] y,
 int incy)

Performs the matrix-vector operation.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

trans - normal, transpose, or conjugate transpose operation on the matrix.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1)*abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (m - 1) * abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1) * abs(incy)) otherwise.

incy - the increment for the elements of y, which must not be zero.

gemv

void gemv(Layout layout,
 Transpose trans,
 int m,
 int n,
 float alpha,
 FloatBuffer A,
 int lda,
 FloatBuffer x,
 int incx,
 float beta,
 FloatBuffer y,
 int incy)

Performs the matrix-vector operation.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

trans - normal, transpose, or conjugate transpose operation on the matrix.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (m - 1) * abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1) * abs(incy)) otherwise.

incy - the increment for the elements of y, which must not be zero.

symv

void symv(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 double[] A,
 int lda,
 double[] x,
 int incx,
 double beta,
 double[] y,
 int incy)

Performs the matrix-vector operation using a symmetric matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric matrix A.

alpha - the scalar alpha.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

symv

void symv(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 DoubleBuffer A,
 int lda,
 DoubleBuffer x,
 int incx,
 double beta,
 DoubleBuffer y,
 int incy)

Performs the matrix-vector operation using a symmetric matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric matrix A.

alpha - the scalar alpha.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

symv

void symv(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 org.bytedeco.javacpp.DoublePointer A,
 int lda,
 org.bytedeco.javacpp.DoublePointer x,
 int incx,
 double beta,
 org.bytedeco.javacpp.DoublePointer y,
 int incy)

Performs the matrix-vector operation using a symmetric matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric matrix A.

alpha - the scalar alpha.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

symv

void symv(Layout layout,
 UPLO uplo,
 int n,
 float alpha,
 float[] A,
 int lda,
 float[] x,
 int incx,
 float beta,
 float[] y,
 int incy)

Performs the matrix-vector operation using a symmetric matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric matrix A.

alpha - the scalar alpha.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

symv

void symv(Layout layout,
 UPLO uplo,
 int n,
 float alpha,
 FloatBuffer A,
 int lda,
 FloatBuffer x,
 int incx,
 float beta,
 FloatBuffer y,
 int incy)

Performs the matrix-vector operation using a symmetric matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric matrix A.

alpha - the scalar alpha.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

spmv

void spmv(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 double[] A,
 double[] x,
 int incx,
 double beta,
 double[] y,
 int incy)

Performs the matrix-vector operation using a symmetric packed matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric matrix A.

alpha - the scalar alpha.

A - the symmetric packed matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

spmv

void spmv(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 DoubleBuffer A,
 DoubleBuffer x,
 int incx,
 double beta,
 DoubleBuffer y,
 int incy)

Performs the matrix-vector operation using a symmetric packed matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric matrix A.

alpha - the scalar alpha.

A - the symmetric packed matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

spmv

void spmv(Layout layout,
 UPLO uplo,
 int n,
 float alpha,
 float[] A,
 float[] x,
 int incx,
 float beta,
 float[] y,
 int incy)

Performs the matrix-vector operation using a symmetric packed matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric matrix A.

alpha - the scalar alpha.

A - the symmetric packed matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

spmv

void spmv(Layout layout,
 UPLO uplo,
 int n,
 float alpha,
 FloatBuffer A,
 FloatBuffer x,
 int incx,
 float beta,
 FloatBuffer y,
 int incy)

Performs the matrix-vector operation using a symmetric packed matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric matrix A.

alpha - the scalar alpha.

A - the symmetric packed matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy))

incy - the increment for the elements of y, which must not be zero.

trmv

void trmv(Layout layout,
 UPLO uplo,
 Transpose trans,
 Diag diag,
 int n,
 double[] A,
 int lda,
 double[] x,
 int incx)

Performs the matrix-vector operation using a triangular matrix.

     x := A*x
 

or

     x := A'*x
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

trans - normal, transpose, or conjugate transpose operation on the matrix.

diag - unit diagonal or not.

n - the number of rows/columns of the triangular matrix A.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

trmv

void trmv(Layout layout,
 UPLO uplo,
 Transpose trans,
 Diag diag,
 int n,
 DoubleBuffer A,
 int lda,
 DoubleBuffer x,
 int incx)

Performs the matrix-vector operation using a triangular matrix.

     x := A*x
 

or

     x := A'*x
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

trans - normal, transpose, or conjugate transpose operation on the matrix.

diag - unit diagonal or not.

n - the number of rows/columns of the triangular matrix A.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

trmv

void trmv(Layout layout,
 UPLO uplo,
 Transpose trans,
 Diag diag,
 int n,
 org.bytedeco.javacpp.DoublePointer A,
 int lda,
 org.bytedeco.javacpp.DoublePointer x,
 int incx)

Performs the matrix-vector operation using a triangular matrix.

     x := A*x
 

or

     x := A'*x
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

trans - normal, transpose, or conjugate transpose operation on the matrix.

diag - unit diagonal or not.

n - the number of rows/columns of the triangular matrix A.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

trmv

void trmv(Layout layout,
 UPLO uplo,
 Transpose trans,
 Diag diag,
 int n,
 float[] A,
 int lda,
 float[] x,
 int incx)

Performs the matrix-vector operation using a triangular matrix.

     x := A*x
 

or

     x := A'*x
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

trans - normal, transpose, or conjugate transpose operation on the matrix.

diag - unit diagonal or not.

n - the number of rows/columns of the triangular matrix A.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

trmv

void trmv(Layout layout,
 UPLO uplo,
 Transpose trans,
 Diag diag,
 int n,
 FloatBuffer A,
 int lda,
 FloatBuffer x,
 int incx)

Performs the matrix-vector operation using a triangular matrix.

     x := A*x
 

or

     x := A'*x
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

trans - normal, transpose, or conjugate transpose operation on the matrix.

diag - unit diagonal or not.

n - the number of rows/columns of the triangular matrix A.

A - the symmetric matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

tpmv

void tpmv(Layout layout,
 UPLO uplo,
 Transpose trans,
 Diag diag,
 int n,
 double[] A,
 double[] x,
 int incx)

Performs the matrix-vector operation using a triangular packed matrix.

     x := A*x
 

or

     y := A'*x
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

trans - normal, transpose, or conjugate transpose operation on the matrix.

diag - unit diagonal or not.

n - the number of rows/columns of the triangular matrix A.

A - the symmetric packed matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

tpmv

void tpmv(Layout layout,
 UPLO uplo,
 Transpose trans,
 Diag diag,
 int n,
 DoubleBuffer A,
 DoubleBuffer x,
 int incx)

Performs the matrix-vector operation using a triangular packed matrix.

     x := A*x
 

or

     y := A'*x
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

trans - normal, transpose, or conjugate transpose operation on the matrix.

diag - unit diagonal or not.

n - the number of rows/columns of the triangular matrix A.

A - the symmetric packed matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

tpmv

void tpmv(Layout layout,
 UPLO uplo,
 Transpose trans,
 Diag diag,
 int n,
 float[] A,
 float[] x,
 int incx)

Performs the matrix-vector operation using a triangular packed matrix.

     x := A*x
 

or

     x := A'*x
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

trans - normal, transpose, or conjugate transpose operation on the matrix.

diag - unit diagonal or not.

n - the number of rows/columns of the triangular matrix A.

A - the symmetric packed matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

tpmv

void tpmv(Layout layout,
 UPLO uplo,
 Transpose trans,
 Diag diag,
 int n,
 FloatBuffer A,
 FloatBuffer x,
 int incx)

Performs the matrix-vector operation using a triangular packed matrix.

     x := A*x
 

or

     x := A'*x
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

trans - normal, transpose, or conjugate transpose operation on the matrix.

diag - unit diagonal or not.

n - the number of rows/columns of the triangular matrix A.

A - the symmetric packed matrix.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

gbmv

void gbmv(Layout layout,
 Transpose trans,
 int m,
 int n,
 int kl,
 int ku,
 double alpha,
 double[] A,
 int lda,
 double[] x,
 int incx,
 double beta,
 double[] y,
 int incy)

Performs the matrix-vector operation using a band matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

trans - normal, transpose, or conjugate transpose operation on the matrix.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

kl - the number of subdiagonal elements of band matrix.

ku - the number of superdiagonal elements of band matrix.

alpha - the scalar alpha.

A - the band matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (m - 1) * abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1) * abs(incy)) otherwise.

incy - the increment for the elements of y, which must not be zero.

gbmv

void gbmv(Layout layout,
 Transpose trans,
 int m,
 int n,
 int kl,
 int ku,
 double alpha,
 DoubleBuffer A,
 int lda,
 DoubleBuffer x,
 int incx,
 double beta,
 DoubleBuffer y,
 int incy)

Performs the matrix-vector operation using a band matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

trans - normal, transpose, or conjugate transpose operation on the matrix.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

kl - the number of subdiagonal elements of band matrix.

ku - the number of superdiagonal elements of band matrix.

alpha - the scalar alpha.

A - the band matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (m - 1) * abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1) * abs(incy)) otherwise.

incy - the increment for the elements of y, which must not be zero.

gbmv

void gbmv(Layout layout,
 Transpose trans,
 int m,
 int n,
 int kl,
 int ku,
 float alpha,
 float[] A,
 int lda,
 float[] x,
 int incx,
 float beta,
 float[] y,
 int incy)

Performs the matrix-vector operation using a band matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

trans - normal, transpose, or conjugate transpose operation on the matrix.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

kl - the number of subdiagonal elements of band matrix.

ku - the number of superdiagonal elements of band matrix.

alpha - the scalar alpha.

A - the band matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (m - 1) * abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1) * abs(incy)) otherwise.

incy - the increment for the elements of y, which must not be zero.

gbmv

void gbmv(Layout layout,
 Transpose trans,
 int m,
 int n,
 int kl,
 int ku,
 float alpha,
 FloatBuffer A,
 int lda,
 FloatBuffer x,
 int incx,
 float beta,
 FloatBuffer y,
 int incy)

Performs the matrix-vector operation using a band matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

trans - normal, transpose, or conjugate transpose operation on the matrix.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

kl - the number of subdiagonal elements of band matrix.

ku - the number of superdiagonal elements of band matrix.

alpha - the scalar alpha.

A - the band matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)) when trans = 'N' or 'n' and at least (1 + (m - 1) * abs(incx)) otherwise.

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (m - 1) * abs(incy)) when trans = 'N' or 'n' and at least (1 + (n - 1) * abs(incy)) otherwise.

incy - the increment for the elements of y, which must not be zero.

sbmv

void sbmv(Layout layout,
 UPLO uplo,
 int n,
 int k,
 double alpha,
 double[] A,
 int lda,
 double[] x,
 int incx,
 double beta,
 double[] y,
 int incy)

Performs the matrix-vector operation using a symmetric band matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric band matrix A.

k - the number of subdiagonal/superdiagonal elements of the symmetric band matrix A.

alpha - the scalar alpha.

A - the symmetric band matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)),

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)),

incy - the increment for the elements of y, which must not be zero.

sbmv

void sbmv(Layout layout,
 UPLO uplo,
 int n,
 int k,
 double alpha,
 DoubleBuffer A,
 int lda,
 DoubleBuffer x,
 int incx,
 double beta,
 DoubleBuffer y,
 int incy)

Performs the matrix-vector operation using a symmetric band matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of rows/columns of the symmetric band matrix A.

k - the number of subdiagonal/superdiagonal elements of the symmetric band matrix A.

alpha - the scalar alpha.

A - the symmetric band matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)),

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)),

incy - the increment for the elements of y, which must not be zero.

sbmv

void sbmv(Layout layout,
 UPLO uplo,
 int n,
 int k,
 float alpha,
 float[] A,
 int lda,
 float[] x,
 int incx,
 float beta,
 float[] y,
 int incy)

Performs the matrix-vector operation using a symmetric band matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the symmetric band matrix A.

k - the number of subdiagonal/superdiagonal elements of the symmetric band matrix A.

alpha - the scalar alpha.

A - the symmetric band matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

sbmv

void sbmv(Layout layout,
 UPLO uplo,
 int n,
 int k,
 float alpha,
 FloatBuffer A,
 int lda,
 FloatBuffer x,
 int incx,
 float beta,
 FloatBuffer y,
 int incy)

Performs the matrix-vector operation using a symmetric band matrix.

     y := alpha*A*x + beta*y
 

or

     y := alpha*A'*x + beta*y
 

where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the symmetric band matrix A.

k - the number of subdiagonal/superdiagonal elements of the symmetric band matrix A.

alpha - the scalar alpha.

A - the symmetric band matrix.

lda - the leading dimension of A as declared in the caller.

x - array of dimension at least (1 + (n - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

ger

void ger(Layout layout,
 int m,
 int n,
 double alpha,
 double[] x,
 int incx,
 double[] y,
 int incy,
 double[] A,
 int lda)

Performs the rank-1 update operation.

     A := A + alpha*x*y'
 

Parameters:

layout - matrix layout.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

ger

void ger(Layout layout,
 int m,
 int n,
 double alpha,
 DoubleBuffer x,
 int incx,
 DoubleBuffer y,
 int incy,
 DoubleBuffer A,
 int lda)

Performs the rank-1 update operation.

     A := A + alpha*x*y'
 

Parameters:

layout - matrix layout.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

ger

void ger(Layout layout,
 int m,
 int n,
 double alpha,
 org.bytedeco.javacpp.DoublePointer x,
 int incx,
 org.bytedeco.javacpp.DoublePointer y,
 int incy,
 org.bytedeco.javacpp.DoublePointer A,
 int lda)

Performs the rank-1 update operation.

     A := A + alpha*x*y'
 

Parameters:

layout - matrix layout.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

ger

void ger(Layout layout,
 int m,
 int n,
 float alpha,
 float[] x,
 int incx,
 float[] y,
 int incy,
 float[] A,
 int lda)

Performs the rank-1 update operation.

     A := A + alpha*x*y'
 

Parameters:

layout - matrix layout.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

ger

void ger(Layout layout,
 int m,
 int n,
 float alpha,
 FloatBuffer x,
 int incx,
 FloatBuffer y,
 int incy,
 FloatBuffer A,
 int lda)

Performs the rank-1 update operation.

     A := A + alpha*x*y'
 

Parameters:

layout - matrix layout.

m - the number of rows of the matrix A.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

y - array of dimension at least (1 + (n - 1) * abs(incy)).

incy - the increment for the elements of y, which must not be zero.

A - the leading m by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

syr

void syr(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 double[] x,
 int incx,
 double[] A,
 int lda)

Performs the rank-1 update operation to symmetric matrix.

     A := A + alpha*x*x'
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

A - the leading n by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

syr

void syr(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 DoubleBuffer x,
 int incx,
 DoubleBuffer A,
 int lda)

Performs the rank-1 update operation to symmetric matrix.

     A := A + alpha*x*x'
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

A - the leading n by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

syr

void syr(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 org.bytedeco.javacpp.DoublePointer x,
 int incx,
 org.bytedeco.javacpp.DoublePointer A,
 int lda)

Performs the rank-1 update operation to symmetric matrix.

     A := A + alpha*x*x'
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

A - the leading n by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

syr

void syr(Layout layout,
 UPLO uplo,
 int n,
 float alpha,
 float[] x,
 int incx,
 float[] A,
 int lda)

Performs the rank-1 update operation to symmetric matrix.

     A := A + alpha*x*x'
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero. the matrix of coefficients.

A - the leading n by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

syr

void syr(Layout layout,
 UPLO uplo,
 int n,
 float alpha,
 FloatBuffer x,
 int incx,
 FloatBuffer A,
 int lda)

Performs the rank-1 update operation to symmetric matrix.

     A := A + alpha*x*x'
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero. the matrix of coefficients.

A - the leading n by n part of the array A must contain the matrix of coefficients.

lda - the leading dimension of A as declared in the caller. LDA must be at least max(1, m). The leading dimension parameter allows use of BLAS/LAPACK routines on a submatrix of a larger matrix.

spr

void spr(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 double[] x,
 int incx,
 double[] A)

Performs the rank-1 update operation to symmetric packed matrix.

     A := A + alpha*x*x'
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

A - the symmetric packed matrix.

spr

void spr(Layout layout,
 UPLO uplo,
 int n,
 double alpha,
 DoubleBuffer x,
 int incx,
 DoubleBuffer A)

Performs the rank-1 update operation to symmetric packed matrix.

     A := A + alpha*x*x'
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

A - the symmetric packed matrix.

spr

void spr(Layout layout,
 UPLO uplo,
 int n,
 float alpha,
 float[] x,
 int incx,
 float[] A)

Performs the rank-1 update operation to symmetric packed matrix.

     A := A + alpha*x*x'
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

A - the symmetric packed matrix.

spr

void spr(Layout layout,
 UPLO uplo,
 int n,
 float alpha,
 FloatBuffer x,
 int incx,
 FloatBuffer A)

Performs the rank-1 update operation to symmetric packed matrix.

     A := A + alpha*x*x'
 

Parameters:

layout - matrix layout.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

n - the number of columns of the matrix A.

alpha - the scalar alpha.

x - array of dimension at least (1 + (m - 1) * abs(incx)).

incx - the increment for the elements of x, which must not be zero.

A - the symmetric packed matrix.

gemm

void gemm(Layout layout,
 Transpose transA,
 Transpose transB,
 int m,
 int n,
 int k,
 double alpha,
 double[] A,
 int lda,
 double[] B,
 int ldb,
 double beta,
 double[] C,
 int ldc)

Performs the matrix-matrix operation.

     C := alpha*A*B + beta*C
 

Parameters:

layout - matrix layout.

transA - normal, transpose, or conjugate transpose operation on the matrix A.

transB - normal, transpose, or conjugate transpose operation on the matrix B.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

k - the number of columns of the matrix op(A).

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.

gemm

void gemm(Layout layout,
 Transpose transA,
 Transpose transB,
 int m,
 int n,
 int k,
 double alpha,
 DoubleBuffer A,
 int lda,
 DoubleBuffer B,
 int ldb,
 double beta,
 DoubleBuffer C,
 int ldc)

Performs the matrix-matrix operation.

     C := alpha*A*B + beta*C
 

Parameters:

layout - matrix layout.

transA - normal, transpose, or conjugate transpose operation on the matrix A.

transB - normal, transpose, or conjugate transpose operation on the matrix B.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

k - the number of columns of the matrix op(A).

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.

gemm

void gemm(Layout layout,
 Transpose transA,
 Transpose transB,
 int m,
 int n,
 int k,
 double alpha,
 org.bytedeco.javacpp.DoublePointer A,
 int lda,
 org.bytedeco.javacpp.DoublePointer B,
 int ldb,
 double beta,
 org.bytedeco.javacpp.DoublePointer C,
 int ldc)

Performs the matrix-matrix operation.

     C := alpha*A*B + beta*C
 

Parameters:

layout - matrix layout.

transA - normal, transpose, or conjugate transpose operation on the matrix A.

transB - normal, transpose, or conjugate transpose operation on the matrix B.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

k - the number of columns of the matrix op(A).

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.

gemm

void gemm(Layout layout,
 Transpose transA,
 Transpose transB,
 int m,
 int n,
 int k,
 float alpha,
 float[] A,
 int lda,
 float[] B,
 int ldb,
 float beta,
 float[] C,
 int ldc)

Performs the matrix-matrix operation.

     C := alpha*A*B + beta*C
 

Parameters:

layout - matrix layout.

transA - normal, transpose, or conjugate transpose operation on the matrix A.

transB - normal, transpose, or conjugate transpose operation on the matrix B.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

k - the number of columns of the matrix op(A).

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.

gemm

void gemm(Layout layout,
 Transpose transA,
 Transpose transB,
 int m,
 int n,
 int k,
 float alpha,
 FloatBuffer A,
 int lda,
 FloatBuffer B,
 int ldb,
 float beta,
 FloatBuffer C,
 int ldc)

Performs the matrix-matrix operation.

     C := alpha*A*B + beta*C
 

Parameters:

layout - matrix layout.

transA - normal, transpose, or conjugate transpose operation on the matrix A.

transB - normal, transpose, or conjugate transpose operation on the matrix B.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

k - the number of columns of the matrix op(A).

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.

symm

void symm(Layout layout,
 Side side,
 UPLO uplo,
 int m,
 int n,
 double alpha,
 double[] A,
 int lda,
 double[] B,
 int ldb,
 double beta,
 double[] C,
 int ldc)

Performs the matrix-matrix operation where the matrix A is symmetric.

     C := alpha*A*B + beta*C
 

or

     C := alpha*B*A + beta*C
 

Parameters:

layout - matrix layout.

side - C := alpha*A*B + beta*C if side is left or C := alpha*B*A + beta*C if side is right.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.

symm

void symm(Layout layout,
 Side side,
 UPLO uplo,
 int m,
 int n,
 double alpha,
 DoubleBuffer A,
 int lda,
 DoubleBuffer B,
 int ldb,
 double beta,
 DoubleBuffer C,
 int ldc)

Performs the matrix-matrix operation where the matrix A is symmetric.

     C := alpha*A*B + beta*C
 

or

     C := alpha*B*A + beta*C
 

Parameters:

layout - matrix layout.

side - C := alpha*A*B + beta*C if side is left or C := alpha*B*A + beta*C if side is right.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.

symm

void symm(Layout layout,
 Side side,
 UPLO uplo,
 int m,
 int n,
 double alpha,
 org.bytedeco.javacpp.DoublePointer A,
 int lda,
 org.bytedeco.javacpp.DoublePointer B,
 int ldb,
 double beta,
 org.bytedeco.javacpp.DoublePointer C,
 int ldc)

Performs the matrix-matrix operation where the matrix A is symmetric.

     C := alpha*A*B + beta*C
 

or

     C := alpha*B*A + beta*C
 

Parameters:

layout - matrix layout.

side - C := alpha*A*B + beta*C if side is left or C := alpha*B*A + beta*C if side is right.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.

symm

void symm(Layout layout,
 Side side,
 UPLO uplo,
 int m,
 int n,
 float alpha,
 float[] A,
 int lda,
 float[] B,
 int ldb,
 float beta,
 float[] C,
 int ldc)

Performs the matrix-matrix operation where one input matrix is symmetric.

     C := alpha*A*B + beta*C
 

Parameters:

layout - matrix layout.

side - C := alpha*A*B + beta*C if side is left or C := alpha*B*A + beta*C if side is right.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.

symm

void symm(Layout layout,
 Side side,
 UPLO uplo,
 int m,
 int n,
 float alpha,
 FloatBuffer A,
 int lda,
 FloatBuffer B,
 int ldb,
 float beta,
 FloatBuffer C,
 int ldc)

Performs the matrix-matrix operation where one input matrix is symmetric.

     C := alpha*A*B + beta*C
 

Parameters:

layout - matrix layout.

side - C := alpha*A*B + beta*C if side is left or C := alpha*B*A + beta*C if side is right.

uplo - the upper or lower triangular part of the matrix A is to be referenced.

m - the number of rows of the matrix C.

n - the number of columns of the matrix C.

alpha - the scalar alpha.

A - the matrix A.

lda - the leading dimension of A as declared in the caller.

B - the matrix B.

ldb - the leading dimension of B as declared in the caller.

beta - the scalar beta. When beta is supplied as zero then y need not be set on input.

C - the matrix C.

ldc - the leading dimension of C as declared in the caller.