linalg.h File Reference

#include <stdbool.h>
#include <complex.h>

Include dependency graph for linalg.h:

Go to the source code of this file.

Macros
#define	LA_NO_OPERATION   0
#define	LA_TRANSPOSE   1
#define	LA_HERMITIAN_TRANSPOSE   2
#define	LA_NO_ERROR   0
#define	LA_INVALID_INPUT_ERROR   101
#define	LA_ARRAY_SIZE_ERROR   102
#define	LA_SINGULAR_MATRIX_ERROR   103
#define	LA_MATRIX_FORMAT_ERROR   104
#define	LA_OUT_OF_MEMORY_ERROR   105
#define	LA_CONVERGENCE_ERROR   106
#define	LA_INVALID_OPERATION_ERROR   107

Functions
int	la_rank1_update (int m, int n, double alpha, const double *x, const double *y, double *a, int lda)
int	la_rank1_update_cmplx (int m, int n, double complex alpha, const double complex *x, const double complex *y, double complex *a, int lda)
int	la_trace (int m, int n, const double *a, int lda, double *rst)
int	la_trace_cmplx (int m, int n, const double complex *a, int lda, double complex *rst)
int	la_mtx_mult (bool transa, bool transb, int m, int n, int k, double alpha, const double *a, int lda, const double *b, int ldb, double beta, double *c, int ldc)
int	la_mtx_mult_cmplx (int opa, int opb, int m, int n, int k, double complex alpha, const double complex *a, int lda, const double complex *b, int ldb, double complex beta, double complex *c, int ldc)
int	la_diag_mtx_mult (bool lside, bool transb, int m, int n, int k, double alpha, const double *a, const double *b, int ldb, double beta, double *c, int ldc)
int	la_diag_mtx_mult_cmplx (bool lside, int opb, int m, int n, int k, double complex alpha, const double complex *a, const double complex *b, int ldb, double complex beta, double complex *c, int ldc)
int	la_diag_mtx_mult_mixed (bool lside, int opb, int m, int n, int k, double complex alpha, const double *a, const double complex *b, int ldb, double complex beta, double complex *c, int ldc)
int	la_rank (int m, int n, double *a, int lda, int *rnk)
int	la_rank_cmplx (int m, int n, double complex *a, int lda, int *rnk)
int	la_det (int n, double *a, int lda, double *d)
int	la_det_cmplx (int n, double complex *a, int lda, double complex *d)
int	la_tri_mtx_mult (bool upper, double alpha, int n, const double *a, int lda, double beta, double *b, int ldb)
int	la_tri_mtx_mult_cmplx (bool upper, double complex alpha, int n, const double complex *a, int lda, double complex beta, double complex *b, int ldb)
int	la_lu_factor (int m, int n, double *a, int lda, int *ipvt)
int	la_lu_factor_cmplx (int m, int n, double complex *a, int lda, int *ipvt)
int	la_form_lu (int n, double *a, int lda, int *ipvt, double *u, int ldu, double *p, int ldp)
int	la_form_lu_cmplx (int n, double complex *a, int lda, int *ipvt, double complex *u, int ldu, double *p, int ldp)
int	la_qr_factor (int m, int n, double *a, int lda, double *tau)
int	la_qr_factor_cmplx (int m, int n, double complex *a, int lda, double complex *tau)
int	la_qr_factor_pvt (int m, int n, double *a, int lda, double *tau, int *jpvt)
int	la_qr_factor_cmplx_pvt (int m, int n, double complex *a, int lda, double complex *tau, int *jpvt)
int	la_form_qr (bool fullq, int m, int n, double *r, int ldr, const double *tau, double *q, int ldq)
int	la_form_qr_cmplx (bool fullq, int m, int n, double complex *r, int ldr, const double complex *tau, double complex *q, int ldq)
int	la_form_qr_pvt (bool fullq, int m, int n, double *r, int ldr, const double *tau, const int *pvt, double *q, int ldq, double *p, int ldp)
int	la_form_qr_cmplx_pvt (bool fullq, int m, int n, double complex *r, int ldr, const double complex *tau, const int *pvt, double complex *q, int ldq, double complex *p, int ldp)
int	la_mult_qr (bool lside, bool trans, int m, int n, int k, double *a, int lda, const double *tau, double *c, int ldc)
int	la_mult_qr_cmplx (bool lside, bool trans, int m, int n, int k, double complex *a, int lda, const double complex *tau, double complex *c, int ldc)
int	la_qr_rank1_update (int m, int n, double *q, int ldq, double *r, int ldr, double *u, double *v)
int	la_cholesky_factor (bool upper, int n, double *a, int lda)
int	la_cholesky_factor_cmplx (bool upper, int n, double complex *a, int lda)
int	la_cholesky_rank1_update (int n, double *r, int ldr, double *u)
int	la_cholesky_rank1_downdate (int n, double *r, int ldr, double *u)
int	la_cholesky_rank1_downdate_cmplx (int n, double complex *r, int ldr, double complex *u)
int	la_svd (int m, int n, double *a, int lda, double *s, double *u, int ldu, double *vt, int ldv)
int	la_svd_cmplx (int m, int n, double complex *a, int lda, double *s, double complex *u, int ldu, double complex *vt, int ldv)
int	la_solve_tri_mtx (bool lside, bool upper, bool trans, bool nounit, int m, int n, double alpha, const double *a, int lda, double *b, int ldb)
int	la_solve_tri_mtx_cmplx (bool lside, bool upper, bool trans, bool nounit, int m, int n, double complex alpha, const double complex *a, int lda, double complex *b, int ldb)
int	la_solve_lu (int m, int n, const double *a, int lda, const int *ipvt, double *b, int ldb)
int	la_solve_lu_cmplx (int m, int n, const double complex *a, int lda, const int *ipvt, double complex *b, int ldb)
int	la_solve_qr (int m, int n, int k, double *a, int lda, const double *tau, double *b, int ldb)
int	la_solve_qr_cmplx (int m, int n, int k, double complex *a, int lda, const double complex *tau, double complex *b, int ldb)
int	la_solve_qr_pvt (int m, int n, int k, double *a, int lda, const double *tau, const int *jpvt, double *b, int ldb)
int	la_solve_qr_cmplx_pvt (int m, int n, int k, double complex *a, int lda, const double complex *tau, const int *jpvt, double complex *b, int ldb)
int	la_solve_cholesky (bool upper, int m, int n, const double *a, int lda, double *b, int ldb)
int	la_solve_cholesky_cmplx (bool upper, int m, int n, const double complex *a, int lda, double complex *b, int ldb)
int	la_solve_least_squares (int m, int n, int k, double *a, int lda, double *b, int ldb)
int	la_solve_least_squares_cmplx (int m, int n, int k, double complex *a, int lda, double complex *b, int ldb)
int	la_inverse (int n, double *a, int lda)
int	la_inverse_cmplx (int n, double complex *a, int lda)
int	la_pinverse (int m, int n, double *a, int lda, double *ainv, int ldai)
int	la_pinverse_cmplx (int m, int n, double complex *a, int lda, double complex *ainv, int ldai)
int	la_eigen_symm (bool vecs, int n, double *a, int lda, double *vals)
int	la_eigen_asymm (bool vecs, int n, double *a, int lda, double complex *vals, double complex *v, int ldv)
int	la_eigen_gen (bool vecs, int n, double *a, int lda, double *b, int ldb, double complex *alpha, double *beta, double complex *v, int ldv)
int	la_eigen_cmplx (bool vecs, int n, double complex *a, int lda, double complex *vals, double complex *v, int ldv)
int	la_sort_eigen (bool ascend, int n, double *vals, double *vecs, int ldv)
int	la_sort_eigen_cmplx (bool ascend, int n, double complex *vals, double complex *vecs, int ldv)
int	la_lq_factor (int m, int n, double *a, int lda, double *tau)
int	la_form_lq (int m, int n, double *l, int ldl, const double *tau, double *q, int ldq)
int	la_mult_lq (bool lside, bool trans, int m, int n, int k, const double *a, int lda, const double *tau, double *c, int ldc)
int	la_solve_lq (int m, int n, int k, const double *a, int lda, const double *tau, double *b, int ldb)
int	la_qr_rank1_update_cmplx (int m, int n, double complex *q, int ldq, double complex *r, int ldr, double complex *u, double complex *v)
int	la_cholesky_rank1_update_cmplx (int n, double complex *r, int ldr, double complex *u)
int	la_lq_factor_cmplx (int m, int n, double complex *a, int lda, double complex *tau)
int	la_form_lq_cmplx (int m, int n, double complex *l, int ldl, const double complex *tau, double complex *q, int ldq)
int	la_mult_lq_cmplx (bool lside, bool trans, int m, int n, int k, const double complex *a, int lda, const double complex *tau, double complex *c, int ldc)
int	la_solve_lq_cmplx (int m, int n, int k, const double complex *a, int lda, const double complex *tau, double complex *b, int ldb)
int	la_band_mtx_vec_mult (bool trans, int m, int n, int kl, int ku, double alpha, const double *a, int lda, const double *x, double beta, double *y)
int	la_band_mtx_vec_mult_cmplx (int trans, int m, int n, int kl, int ku, double complex alpha, const double complex *a, int lda, const double complex *x, double complex beta, double complex *y)
int	la_band_to_full_mtx (int m, int n, int kl, int ku, const double *b, int ldb, double *f, int ldf)
int	la_band_to_full_mtx_cmplx (int m, int n, int kl, int ku, const double complex *b, int ldb, double complex *f, int ldf)
int	la_band_diag_mtx_mult (bool left, int m, int n, int kl, int ku, double alpha, double *a, int lda, const double *b)
int	la_band_diag_mtx_mult_cmplx (bool left, int m, int n, int kl, int ku, double complex alpha, double complex *a, int lda, const double complex *b)

Macro Definition Documentation

LA_ARRAY_SIZE_ERROR

#define LA_ARRAY_SIZE_ERROR   102

Definition at line 196 of file linalg.h.

LA_CONVERGENCE_ERROR

#define LA_CONVERGENCE_ERROR   106

Definition at line 200 of file linalg.h.

LA_HERMITIAN_TRANSPOSE

#define LA_HERMITIAN_TRANSPOSE   2

Definition at line 193 of file linalg.h.

LA_INVALID_INPUT_ERROR

#define LA_INVALID_INPUT_ERROR   101

Definition at line 195 of file linalg.h.

LA_INVALID_OPERATION_ERROR

#define LA_INVALID_OPERATION_ERROR   107

Definition at line 201 of file linalg.h.

LA_MATRIX_FORMAT_ERROR

#define LA_MATRIX_FORMAT_ERROR   104

Definition at line 198 of file linalg.h.

LA_NO_ERROR

#define LA_NO_ERROR   0

Definition at line 194 of file linalg.h.

LA_NO_OPERATION

#define LA_NO_OPERATION   0

Definition at line 191 of file linalg.h.

LA_OUT_OF_MEMORY_ERROR

#define LA_OUT_OF_MEMORY_ERROR   105

Definition at line 199 of file linalg.h.

LA_SINGULAR_MATRIX_ERROR

#define LA_SINGULAR_MATRIX_ERROR   103

Definition at line 197 of file linalg.h.

LA_TRANSPOSE

#define LA_TRANSPOSE   1

Definition at line 192 of file linalg.h.

Function Documentation

la_band_diag_mtx_mult()

int la_band_diag_mtx_mult	(	bool	left,
		int	m,
		int	n,
		int	kl,
		int	ku,
		double	alpha,
		double *	a,
		int	lda,
		const double *	b )

Multiplies a banded matrix, A, with a diagonal matrix, B, such that A = alpha * A * B, or A = alpha * B * A.

Parameters

left	Set to true to compute A = alpha * A * B; else, set to false to compute A = alpha * B * A.
m	The number of rows in matrix A.
kl	The number of subdiagonals. Must be at least 0.
ku	The number of superdiagonals. Must be at least 0.
alpha	The scalar multiplier.
a	The M-by-N matrix A storing the banded matrix in a compressed form supplied column by column. The following code segment transfers between a full matrix to the banded matrix storage scheme. do j = 1, n k = ku + 1 - j do i = max(1, j - ku), min(m, j + kl) a(k + i, j) = matrix(i, j) end do end do
b	An array containing the diagonal elements of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_ARRAY_SIZE_ERROR: Occurs if b and f are not compatible in size.
• LA_ARRAY_SIZE_ERROR: Occurs if a and b are not compatible in terms of internal dimensions.
• LA_INVALID_INPUT_ERROR: Occurs if either ku or kl are not zero or greater.

la_band_diag_mtx_mult_cmplx()

int la_band_diag_mtx_mult_cmplx	(	bool	left,
		int	m,
		int	n,
		int	kl,
		int	ku,
		double complex	alpha,
		double complex *	a,
		int	lda,
		const double complex *	b )

Multiplies a banded matrix, A, with a diagonal matrix, B, such that A = alpha * A * B, or A = alpha * B * A.

Parameters

left	Set to true to compute A = alpha * A * B; else, set to false to compute A = alpha * B * A.
m	The number of rows in matrix A.
kl	The number of subdiagonals. Must be at least 0.
ku	The number of superdiagonals. Must be at least 0.
alpha	The scalar multiplier.
a	The M-by-N matrix A storing the banded matrix in a compressed form supplied column by column. The following code segment transfers between a full matrix to the banded matrix storage scheme. do j = 1, n k = ku + 1 - j do i = max(1, j - ku), min(m, j + kl) a(k + i, j) = matrix(i, j) end do end do
b	An array containing the diagonal elements of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_ARRAY_SIZE_ERROR: Occurs if b and f are not compatible in size.
• LA_ARRAY_SIZE_ERROR: Occurs if a and b are not compatible in terms of internal dimensions.
• LA_INVALID_INPUT_ERROR: Occurs if either ku or kl are not zero or greater.

la_band_mtx_vec_mult()

int la_band_mtx_vec_mult	(	bool	trans,
		int	m,
		int	n,
		int	kl,
		int	ku,
		double	alpha,
		const double *	a,
		int	lda,
		const double *	x,
		double	beta,
		double *	y )

Multiplies a banded matrix, A, by a vector x such that alpha * op(A) * x + beta * y = y.

Parameters

trans	Set to true for op(A) == A^T; else, false for op(A) == A.
kl	The number of subdiagonals. Must be at least 0.
ku	The number of superdiagonals. Must be at least 0.
alpha	A scalar multiplier.
a	The M-by-N matrix A storing the banded matrix in a compressed form supplied column by column.
x	If trans is true, this is an M-element vector; else, if trans is false, this is an N-element vector.
beta	A scalar multiplier.
y	On input, the vector Y. On output, the resulting vector. if trans is true, this vector is an N-element vector; else, it is an M-element vector.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_ARRAY_SIZE_ERROR: Occurs if any of the input arrays are not sized appropriately.
• LA_INVALID_INPUT_ERROR: Occurs if either ku or kl are not zero or greater.

la_band_mtx_vec_mult_cmplx()

int la_band_mtx_vec_mult_cmplx	(	int	trans,
		int	m,
		int	n,
		int	kl,
		int	ku,
		double complex	alpha,
		const double complex *	a,
		int	lda,
		const double complex *	x,
		double complex	beta,
		double complex *	y )

Multiplies a banded matrix, A, by a vector x such that alpha * op(A) * x + beta * y = y.

Parameters

trans	Set to LA_TRANSPOSE if op(A) = A^T, set to LA_HERMITIAN_TRANSPOSE if op(A) = A^H, otherwise set to LA_NO_OPERATION if op(A) = A.
kl	The number of subdiagonals. Must be at least 0.
ku	The number of superdiagonals. Must be at least 0.
alpha	A scalar multiplier.
a	The M-by-N matrix A storing the banded matrix in a compressed form supplied column by column.
x	If trans is true, this is an M-element vector; else, if trans is false, this is an N-element vector.
beta	A scalar multiplier.
y	On input, the vector Y. On output, the resulting vector. if trans is true, this vector is an N-element vector; else, it is an M-element vector.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_ARRAY_SIZE_ERROR: Occurs if any of the input arrays are not sized appropriately.
• LA_INVALID_INPUT_ERROR: Occurs if either ku or kl are not zero or greater.

la_band_to_full_mtx()

int la_band_to_full_mtx	(	int	m,
		int	n,
		int	kl,
		int	ku,
		const double *	b,
		int	ldb,
		double *	f,
		int	ldf )

Converts a banded matrix stored in dense form to a full matrix.

Parameters

kl	The number of subdiagonals. Must be at least 0.
ku	The number of superdiagonals. Must be at least 0.
b	The banded matrix to convert, stored in dense form. See band_mtx_vec_mult for details on this storage method.
f	The M-by-N element full matrix.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_ARRAY_SIZE_ERROR: Occurs if b and f are not compatible in size.
• LA_INVALID_INPUT_ERROR: Occurs if either ku or kl are not zero or greater.

la_band_to_full_mtx_cmplx()

int la_band_to_full_mtx_cmplx	(	int	m,
		int	n,
		int	kl,
		int	ku,
		const double complex *	b,
		int	ldb,
		double complex *	f,
		int	ldf )

Converts a banded matrix stored in dense form to a full matrix.

Parameters

kl	The number of subdiagonals. Must be at least 0.
ku	The number of superdiagonals. Must be at least 0.
b	The banded matrix to convert, stored in dense form. See band_mtx_vec_mult for details on this storage method.
f	The M-by-N element full matrix.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_ARRAY_SIZE_ERROR: Occurs if b and f are not compatible in size.
• LA_INVALID_INPUT_ERROR: Occurs if either ku or kl are not zero or greater.

la_cholesky_factor()

int la_cholesky_factor	(	bool	upper,
		int	n,
		double *	a,
		int	lda )

Computes the Cholesky factorization of a symmetric, positive definite matrix.

Parameters

upper	Set to true to compute the upper triangular factoriztion \( A = U^T U \); else, set to false to compute the lower triangular factorzation \( A = L L^T \).
n	The dimension of matrix A.
a	On input, the N-by-N matrix to factor. On output, the factored matrix is returned in either the upper or lower triangular portion of the matrix, dependent upon the value of upper.
lda	The leading dimension of matrix A.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_MATRIX_FORMAT_ERROR: Occurs if a is not positive definite.

la_cholesky_factor_cmplx()

int la_cholesky_factor_cmplx	(	bool	upper,
		int	n,
		double complex *	a,
		int	lda )

Computes the Cholesky factorization of a symmetric, positive definite matrix.

Parameters

upper	Set to true to compute the upper triangular factoriztion \( A = U^T U \); else, set to false to compute the lower triangular factorzation \( A = L L^T \).
n	The dimension of matrix A.
a	On input, the N-by-N matrix to factor. On output, the factored matrix is returned in either the upper or lower triangular portion of the matrix, dependent upon the value of upper.
lda	The leading dimension of matrix A.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_MATRIX_FORMAT_ERROR: Occurs if a is not positive definite.

la_cholesky_rank1_downdate()

int la_cholesky_rank1_downdate	(	int	n,
		double *	r,
		int	ldr,
		double *	u )

Computes the rank 1 downdate to a Cholesky factored matrix (upper triangular).

Parameters

n	The dimension of the matrix.
r	On input, the N-by-N upper triangular matrix R. On output, the updated matrix R1.
ldr	The leading dimension of matrix R.
u	On input, the N-element update vector U. On output, the rotation sines used to transform R to R1.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldr is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_MATRIX_FORMAT_ERROR: Occurs if the downdated matrix is not positive definite.

la_cholesky_rank1_downdate_cmplx()

int la_cholesky_rank1_downdate_cmplx	(	int	n,
		double complex *	r,
		int	ldr,
		double complex *	u )

Computes the rank 1 downdate to a Cholesky factored matrix (upper triangular).

Parameters

n	The dimension of the matrix.
r	On input, the N-by-N upper triangular matrix R. On output, the updated matrix R1.
ldr	The leading dimension of matrix R.
u	On input, the N-element update vector U. On output, the rotation sines used to transform R to R1.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldr is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_MATRIX_FORMAT_ERROR: Occurs if the downdated matrix is not positive definite.

la_cholesky_rank1_update()

int la_cholesky_rank1_update	(	int	n,
		double *	r,
		int	ldr,
		double *	u )

Computes the rank 1 update to a Cholesky factored matrix (upper triangular).

Parameters

n	The dimension of the matrix.
r	On input, the N-by-N upper triangular matrix R. On output, the updated matrix R1.
ldr	The leading dimension of matrix R.
u	On input, the N-element update vector U. On output, the rotation sines used to transform R to R1.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldr is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_cholesky_rank1_update_cmplx()

int la_cholesky_rank1_update_cmplx	(	int	n,
		double complex *	r,
		int	ldr,
		double complex *	u )

Computes the rank 1 update to a Cholesky factored matrix (upper triangular).

WARNING

Untested code that needs more work before being ready for normal use.

Parameters

n	The dimension of the matrix.
r	On input, the N-by-N upper triangular matrix R. On output, the updated matrix R1.
ldr	The leading dimension of matrix R.
u	On input, the N-element update vector U. On output, the rotation sines used to transform R to R1.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldr is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_det()

int la_det	(	int	n,
		double *	a,
		int	lda,
		double *	d )

Computes the determinant of a square matrix.

Parameters

n	The dimension of the matrix.
a	The N-by-N matrix. The matrix is overwritten on output.
lda	The leading dimension of the matrix.
d	The determinant of a.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_ARRAY_SIZE_ERROR: Occurs if any of the input arrays are not sized appropriately.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_det_cmplx()

int la_det_cmplx	(	int	n,
		double complex *	a,
		int	lda,
		double complex *	d )

Computes the determinant of a square matrix.

Parameters

n	The dimension of the matrix.
a	The N-by-N matrix. The matrix is overwritten on output.
lda	The leading dimension of the matrix.
d	The determinant of a.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_ARRAY_SIZE_ERROR: Occurs if any of the input arrays are not sized appropriately.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_diag_mtx_mult()

int la_diag_mtx_mult	(	bool	lside,
		bool	transb,
		int	m,
		int	n,
		int	k,
		double	alpha,
		const double *	a,
		const double *	b,
		int	ldb,
		double	beta,
		double *	c,
		int	ldc )

Computes the matrix operation: \( C = \alpha A op(B) + \beta C \), or \( C = \alpha op(B) A + \beta C \).

Parameters

lside	Set to true to apply matrix A from the left; else, set to false to apply matrix A from the left.
trans	Set to true if op(B) == B**T; else, set to false if op(B) == B.
m	The number of rows in the matrix C.
n	The number of columns in the matrix C.
k	The inner dimension of the matrix product A * op(B).
alpha	A scalar multiplier.
a	A P-element array containing the diagonal elements of matrix A where P = MIN(m, k) if lside is true; else, P = MIN(n, k) if lside is false.
b	The LDB-by-TDB matrix B where (LDB = leading dimension of B, and TDB = trailing dimension of B): lside == true & trans == true: LDB = n, TDB = k lside == true & trans == false: LDB = k, TDB = n lside == false & trans == true: LDB = k, TDB = m lside == false & trans == false: LDB = m, TDB = k
ldb	The leading dimension of matrix B.
beta	A scalar multiplier.
c	The m by n matrix C.
ldc	The leading dimension of matrix C.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldb, or ldc are not correct.
• LA_ARRAY_SIZE_ERROR: Occurs if any of the input array sizes are incorrect.

la_diag_mtx_mult_cmplx()

int la_diag_mtx_mult_cmplx	(	bool	lside,
		int	opb,
		int	m,
		int	n,
		int	k,
		double complex	alpha,
		const double complex *	a,
		const double complex *	b,
		int	ldb,
		double complex	beta,
		double complex *	c,
		int	ldc )

Computes the matrix operation: \( C = \alpha A op(B) + \beta C \), or \( C = \alpha op(B) A + \beta * C \).

Parameters

lside	Set to true to apply matrix A from the left; else, set to false to apply matrix A from the left.
opb	Set to LA_TRANSPOSE to compute op(B) as a direct transpose of B, set to LA_HERMITIAN_TRANSPOSE to compute op(B) as the Hermitian transpose of B, otherwise, set to LA_NO_OPERATION to compute op(B) as B.
m	The number of rows in the matrix C.
n	The number of columns in the matrix C.
k	The inner dimension of the matrix product A * op(B).
alpha	A scalar multiplier.
a	A P-element array containing the diagonal elements of matrix A where P = MIN(m, k) if lside is true; else, P = MIN(n, k) if lside is false.
b	The LDB-by-TDB matrix B where (LDB = leading dimension of B, and TDB = trailing dimension of B): lside == true & trans == true: LDB = n, TDB = k lside == true & trans == false: LDB = k, TDB = n lside == false & trans == true: LDB = k, TDB = m lside == false & trans == false: LDB = m, TDB = k
ldb	The leading dimension of matrix B.
beta	A scalar multiplier.
c	The m by n matrix C.
ldc	The leading dimension of matrix C.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldb, or ldc are not correct.
• LA_ARRAY_SIZE_ERROR: Occurs if any of the input array sizes are incorrect.

la_diag_mtx_mult_mixed()

int la_diag_mtx_mult_mixed	(	bool	lside,
		int	opb,
		int	m,
		int	n,
		int	k,
		double complex	alpha,
		const double *	a,
		const double complex *	b,
		int	ldb,
		double complex	beta,
		double complex *	c,
		int	ldc )

Computes the matrix operation: \( C = \alpha A op(B) + \beta C \), or \( C = \alpha op(B) A + \beta C \).

Parameters

lside	Set to true to apply matrix A from the left; else, set to false to apply matrix A from the left.
opb	Set to LA_TRANSPOSE to compute op(B) as a direct transpose of B, set to LA_HERMITIAN_TRANSPOSE to compute op(B) as the Hermitian transpose of B, otherwise, set to LA_NO_OPERATION to compute op(B) as B.
m	The number of rows in the matrix C.
n	The number of columns in the matrix C.
k	The inner dimension of the matrix product A * op(B).
alpha	A scalar multiplier.
a	A P-element array containing the diagonal elements of matrix A where P = MIN(m, k) if lside is true; else, P = MIN(n, k) if lside is false.
b	The LDB-by-TDB matrix B where (LDB = leading dimension of B, and TDB = trailing dimension of B): lside == true & trans == true: LDB = n, TDB = k lside == true & trans == false: LDB = k, TDB = n lside == false & trans == true: LDB = k, TDB = m lside == false & trans == false: LDB = m, TDB = k
ldb	The leading dimension of matrix B.
beta	A scalar multiplier.
c	The m by n matrix C.
ldc	The leading dimension of matrix C.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldb, or ldc are not correct.
• LA_ARRAY_SIZE_ERROR: Occurs if any of the input array sizes are incorrect.

la_eigen_asymm()

int la_eigen_asymm	(	bool	vecs,
		int	n,
		double *	a,
		int	lda,
		double complex *	vals,
		double complex *	v,
		int	ldv )

Computes the eigenvalues, and optionally the right eigenvectors of a square matrix.

Parameters

vecs	Set to true to compute the eigenvectors as well as the eigenvalues; else, set to false to just compute the eigenvalues.
n	The dimension of the matrix.
a	On input, the N-by-N matrix on which to operate. On output, the contents of this matrix are overwritten.
lda	The leading dimension of matrix A.
vals	An N-element array containing the eigenvalues of the matrix. The eigenvalues are not sorted.
v	An N-by-N matrix where the right eigenvectors will be written (one per column).

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda or ldv is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_CONVERGENCE_ERROR: Occurs if the algorithm failed to converge.

la_eigen_cmplx()

int la_eigen_cmplx	(	bool	vecs,
		int	n,
		double complex *	a,
		int	lda,
		double complex *	vals,
		double complex *	v,
		int	ldv )

Computes the eigenvalues, and optionally the right eigenvectors of a square matrix.

Parameters

vecs	Set to true to compute the eigenvectors as well as the eigenvalues; else, set to false to just compute the eigenvalues.
n	The dimension of the matrix.
a	On input, the N-by-N matrix on which to operate. On output, the contents of this matrix are overwritten.
lda	The leading dimension of matrix A.
vals	An N-element array containing the eigenvalues of the matrix. The eigenvalues are not sorted.
v	An N-by-N matrix where the right eigenvectors will be written (one per column).

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda or ldv is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_CONVERGENCE_ERROR: Occurs if the algorithm failed to converge.

la_eigen_gen()

int la_eigen_gen	(	bool	vecs,
		int	n,
		double *	a,
		int	lda,
		double *	b,
		int	ldb,
		double complex *	alpha,
		double *	beta,
		double complex *	v,
		int	ldv )

Computes the eigenvalues, and optionally the right eigenvectors of a square matrix assuming the structure of the eigenvalue problem is \( A X = \lambda B X \).

Parameters

vecs	Set to true to compute the eigenvectors as well as the eigenvalues; else, set to false to just compute the eigenvalues.
n	The dimension of the matrix.
a	On input, the N-by-N matrix A. On output, the contents of this matrix are overwritten.
lda	The leading dimension of matrix A.
b	On input, the N-by-N matrix B. On output, the contents of this matrix are overwritten.
ldb	The leading dimension of matrix B.
alpha	An N-element array a factor of the eigenvalues. The eigenvalues must be computed as ALPHA / BETA. This however, is not as trivial as it seems as it is entirely possible, and likely, that ALPHA / BETA can overflow or underflow. With that said, the values in ALPHA will always be less than and usually comparable with the NORM(A).
beta	An N-element array that contains the denominator used to determine the eigenvalues as ALPHA / BETA. If used, the values in this array will always be less than and usually comparable with the NORM(B).
v	An N-by-N matrix where the right eigenvectors will be written (one per column).

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda or ldv is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_CONVERGENCE_ERROR: Occurs if the algorithm failed to converge.

la_eigen_symm()

int la_eigen_symm	(	bool	vecs,
		int	n,
		double *	a,
		int	lda,
		double *	vals )

Computes the eigenvalues, and optionally the eigenvectors of a real, symmetric matrix.

Parameters

vecs	Set to true to compute the eigenvectors as well as the eigenvalues; else, set to false to just compute the eigenvalues.
n	The dimension of the matrix.
a	On input, the N-by-N symmetric matrix on which to operate. On output, and if vecs is set to true, the matrix will contain the eigenvectors (one per column) corresponding to each eigenvalue in vals. If vecs is set to false, the lower triangular portion of the matrix is overwritten.
lda	The leading dimension of matrix A.
vals	An N-element array that will contain the eigenvalues sorted into ascending order.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_CONVERGENCE_ERROR: Occurs if the algorithm failed to converge.

la_form_lq()

int la_form_lq	(	int	m,
		int	n,
		double *	l,
		int	ldl,
		const double *	tau,
		double *	q,
		int	ldq )

Forms the matrix Q with orthonormal rows from the elementary reflectors returned by the base QR factorization algorithm.

Parameters

m	The number of rows in R.
n	The number of columns in R.
l	On input, the M-by-N factored matrix as returned by the LQ factorization routine. On output, the lower triangular matrix L.
ldl	The leading dimension of matrix L.
tau	A MIN(M, N)-element array containing the scalar factors of each elementary reflector defined in r.
q	An N-by-N matrix where the Q matrix will be written.
ldq	The leading dimension of matrix Q.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldl or ldq are not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_form_lq_cmplx()

int la_form_lq_cmplx	(	int	m,
		int	n,
		double complex *	l,
		int	ldl,
		const double complex *	tau,
		double complex *	q,
		int	ldq )

Forms the matrix Q with orthonormal rows from the elementary reflectors returned by the base QR factorization algorithm.

WARNING

Untested code that needs more work before being ready for normal use.

Parameters

m	The number of rows in R.
n	The number of columns in R.
l	On input, the M-by-N factored matrix as returned by the LQ factorization routine. On output, the lower triangular matrix L.
ldl	The leading dimension of matrix L.
tau	A MIN(M, N)-element array containing the scalar factors of each elementary reflector defined in r.
q	An N-by-N matrix where the Q matrix will be written.
ldq	The leading dimension of matrix Q.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldl or ldq are not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_form_lu()

int la_form_lu	(	int	n,
		double *	a,
		int	lda,
		int *	ipvt,
		double *	u,
		int	ldu,
		double *	p,
		int	ldp )

Extracts the L, U, and P matrices from the LU factorization output from la_lu_factor.

Parameters

n	The dimension of the input matrix.
a	On input, the N-by-N matrix as output by la_lu_factor. On output, the N-by-N lower triangular matrix L.
lda	The leading dimension of a.
ipvt	The N-element pivot array as output by la_lu_factor.
u	An N-by-N matrix where the U matrix will be written.
ldu	The leading dimension of u.
p	An N-by-N matrix where the row permutation matrix will be written.
ldp	The leading dimension of p.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, ldu, or ldp is not correct.

la_form_lu_cmplx()

int la_form_lu_cmplx	(	int	n,
		double complex *	a,
		int	lda,
		int *	ipvt,
		double complex *	u,
		int	ldu,
		double *	p,
		int	ldp )

Extracts the L, U, and P matrices from the LU factorization output from la_lu_factor_cmplx.

Parameters

n	The dimension of the input matrix.
a	On input, the N-by-N matrix as output by la_lu_factor_cmplx. On output, the N-by-N lower triangular matrix L.
lda	The leading dimension of a.
ipvt	The N-element pivot array as output by la_lu_factor_cmplx.
u	An N-by-N matrix where the U matrix will be written.
ldu	The leading dimension of u.
p	An N-by-N matrix where the row permutation matrix will be written.
ldp	The leading dimension of p.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, ldu, or ldp is not correct.

la_form_qr()

int la_form_qr	(	bool	fullq,
		int	m,
		int	n,
		double *	r,
		int	ldr,
		const double *	tau,
		double *	q,
		int	ldq )

Forms the full M-by-M orthogonal matrix Q from the elementary reflectors returned by the base QR factorization algorithm.

Parameters

fullq	Set to true to always return the full Q matrix; else, set to false, and in the event that M > N, Q may be supplied as M-by-N, and therefore only return the useful submatrix Q1 (Q = [Q1, Q2]) as the factorization can be written as Q * R = [Q1, Q2] * [R1; 0].
m	The number of rows in R.
n	The number of columns in R.
r	On input, the M-by-N factored matrix as returned by the QR factorization routine. On output, the upper triangular matrix R.
ldr	The leading dimension of matrix R.
tau	A MIN(M, N)-element array containing the scalar factors of each elementary reflector defined in r.
q	An M-by-M matrix where the full Q matrix will be written. In the event that fullq is set to false, and M > N, this matrix need only by M-by-N.
ldq	The leading dimension of matrix Q.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldr or ldq are not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_form_qr_cmplx()

int la_form_qr_cmplx	(	bool	fullq,
		int	m,
		int	n,
		double complex *	r,
		int	ldr,
		const double complex *	tau,
		double complex *	q,
		int	ldq )

Forms the full M-by-M orthogonal matrix Q from the elementary reflectors returned by the base QR factorization algorithm.

Parameters

fullq	Set to true to always return the full Q matrix; else, set to false, and in the event that M > N, Q may be supplied as M-by-N, and therefore only return the useful submatrix Q1 (Q = [Q1, Q2]) as the factorization can be written as Q * R = [Q1, Q2] * [R1; 0].
m	The number of rows in R.
n	The number of columns in R.
r	On input, the M-by-N factored matrix as returned by the QR factorization routine. On output, the upper triangular matrix R.
ldr	The leading dimension of matrix R.
tau	A MIN(M, N)-element array containing the scalar factors of each elementary reflector defined in r.
q	An M-by-M matrix where the full Q matrix will be written. In the event that fullq is set to false, and M > N, this matrix need only by M-by-N.
ldq	The leading dimension of matrix Q.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldr or ldq are not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_form_qr_cmplx_pvt()

int la_form_qr_cmplx_pvt	(	bool	fullq,
		int	m,
		int	n,
		double complex *	r,
		int	ldr,
		const double complex *	tau,
		const int *	pvt,
		double complex *	q,
		int	ldq,
		double complex *	p,
		int	ldp )

Forms the full M-by-M orthogonal matrix Q from the elementary reflectors returned by the base QR factorization algorithm. This routine also inflates the pivot array into an N-by-N matrix P such that \( A P = Q R \).

Parameters

fullq	Set to true to always return the full Q matrix; else, set to false, and in the event that M > N, Q may be supplied as M-by-N, and therefore only return the useful submatrix Q1 (Q = [Q1, Q2]) as the factorization can be written as Q * R = [Q1, Q2] * [R1; 0].
m	The number of rows in R.
n	The number of columns in R.
r	On input, the M-by-N factored matrix as returned by the QR factorization routine. On output, the upper triangular matrix R.
ldr	The leading dimension of matrix R.
tau	A MIN(M, N)-element array containing the scalar factors of each elementary reflector defined in r.
pvt	An N-element array containing the pivot information from the QR factorization.
q	An M-by-M matrix where the full Q matrix will be written. In the event that fullq is set to false, and M > N, this matrix need only by M-by-N.
ldq	The leading dimension of matrix Q.
p	An N-by-N matrix where the pivot matrix P will be written.
ldp	The leading dimension of matrix P.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_form_qr_pvt()

int la_form_qr_pvt	(	bool	fullq,
		int	m,
		int	n,
		double *	r,
		int	ldr,
		const double *	tau,
		const int *	pvt,
		double *	q,
		int	ldq,
		double *	p,
		int	ldp )

Forms the full M-by-M orthogonal matrix Q from the elementary reflectors returned by the base QR factorization algorithm. This routine also inflates the pivot array into an N-by-N matrix P such that \( A P = Q R \).

Parameters

fullq	Set to true to always return the full Q matrix; else, set to false, and in the event that M > N, Q may be supplied as M-by-N, and therefore only return the useful submatrix Q1 (Q = [Q1, Q2]) as the factorization can be written as Q * R = [Q1, Q2] * [R1; 0].
m	The number of rows in R.
n	The number of columns in R.
r	On input, the M-by-N factored matrix as returned by the QR factorization routine. On output, the upper triangular matrix R.
ldr	The leading dimension of matrix R.
tau	A MIN(M, N)-element array containing the scalar factors of each elementary reflector defined in r.
pvt	An N-element array containing the pivot information from the QR factorization.
q	An M-by-M matrix where the full Q matrix will be written. In the event that fullq is set to false, and M > N, this matrix need only by M-by-N.
ldq	The leading dimension of matrix Q.
p	An N-by-N matrix where the pivot matrix P will be written.
ldp	The leading dimension of matrix P.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_inverse()

int la_inverse	(	int	n,
		double *	a,
		int	lda )

Computes the inverse of a square matrix.

Parameters

n	The dimension of matrix A.
a	On input, the N-by-N matrix to invert. On output, the inverted matrix.
lda	The leading dimension of matrix A.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_SINGULAR_MATRIX_ERROR: Occurs if the input matrix is singular.

la_inverse_cmplx()

int la_inverse_cmplx	(	int	n,
		double complex *	a,
		int	lda )

Computes the inverse of a square matrix.

Parameters

n	The dimension of matrix A.
a	On input, the N-by-N matrix to invert. On output, the inverted matrix.
lda	The leading dimension of matrix A.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_SINGULAR_MATRIX_ERROR: Occurs if the input matrix is singular.

la_lq_factor()

int la_lq_factor	(	int	m,
		int	n,
		double *	a,
		int	lda,
		double *	tau )

Computes the LQ factorization of an M-by-N matrix without pivoting.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix to factor. On output, the elements on and above the diagonal contain the MIN(M, N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N). The elements below the diagonal, along with the array tau, represent the orthogonal matrix Q as a product of elementary reflectors.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array used to store the scalar factors of the elementary reflectors.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_lq_factor_cmplx()

int la_lq_factor_cmplx	(	int	m,
		int	n,
		double complex *	a,
		int	lda,
		double complex *	tau )

Computes the LQ factorization of an M-by-N matrix without pivoting.

WARNING

Untested code that needs more work before being ready for normal use.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix to factor. On output, the elements on and above the diagonal contain the MIN(M, N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N). The elements below the diagonal, along with the array tau, represent the orthogonal matrix Q as a product of elementary reflectors.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array used to store the scalar factors of the elementary reflectors.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_lu_factor()

int la_lu_factor	(	int	m,
		int	n,
		double *	a,
		int	lda,
		int *	ipvt )

Computes the LU factorization of an M-by-N matrix.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix on which to operate. On output, the LU factored matrix in the form [L\U] where the unit diagonal elements of L are not stored.
lda	The leading dimension of matrix A.
ipvt	An MIN(M, N)-element array used to track row-pivot operations. The array stored pivot information such that row I is interchanged with row IPVT(I).

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_SINGULAR_MATRIX_ERROR: Occurs as a warning if a is found to be singular.

la_lu_factor_cmplx()

int la_lu_factor_cmplx	(	int	m,
		int	n,
		double complex *	a,
		int	lda,
		int *	ipvt )

Computes the LU factorization of an M-by-N matrix.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix on which to operate. On output, the LU factored matrix in the form [L\U] where the unit diagonal elements of L are not stored.
lda	The leading dimension of matrix A.
ipvt	An MIN(M, N)-element array used to track row-pivot operations. The array stored pivot information such that row I is interchanged with row IPVT(I).

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_SINGULAR_MATRIX_ERROR: Occurs as a warning if a is found to be singular.

la_mtx_mult()

int la_mtx_mult	(	bool	transa,
		bool	transb,
		int	m,
		int	n,
		int	k,
		double	alpha,
		const double *	a,
		int	lda,
		const double *	b,
		int	ldb,
		double	beta,
		double *	c,
		int	ldc )

Computes the matrix operation \( C = \alpha op(A) op(B) + \beta C \).

Parameters

transa	Set to true to compute op(A) as the transpose of A; else, set to false to compute op(A) as A.
transb	Set to true to compute op(B) as the transpose of B; else, set to false to compute op(B) as B.
m	The number of rows in c.
n	The number of columns in c.
k	The interior dimension of the product a and b.
alpha	A scalar multiplier.
a	If transa is true, this matrix must be k by m; else, if transa is false, this matrix must be m by k.
lda	The leading dimension of matrix a.
b	If transb is true, this matrix must be n by k; else, if transb is false, this matrix must be k by n.
ldb	The leading dimension of matrix b.
beta	A scalar multiplier.
c	The m by n matrix C.
ldc	The leading dimension of matrix c.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, ldb, or ldc are not correct.

la_mtx_mult_cmplx()

int la_mtx_mult_cmplx	(	int	opa,
		int	opb,
		int	m,
		int	n,
		int	k,
		double complex	alpha,
		const double complex *	a,
		int	lda,
		const double complex *	b,
		int	ldb,
		double complex	beta,
		double complex *	c,
		int	ldc )

Computes the matrix operation \( C = \alpha op(A) op(B) + \beta C \).

Parameters

opa	Set to LA_TRANSPOSE to compute op(A) as a direct transpose of A, set to LA_HERMITIAN_TRANSPOSE to compute op(A) as the Hermitian transpose of A, otherwise, set to LA_NO_OPERATION to compute op(A) as A.
opb	Set to TLA_RANSPOSE to compute op(B) as a direct transpose of B, set to LA_HERMITIAN_TRANSPOSE to compute op(B) as the Hermitian transpose of B, otherwise, set to LA_NO_OPERATION to compute op(B) as B.
mThe	number of rows in c.
n	The number of columns in c.
k	The interior dimension of the product a and b.
alpha	A scalar multiplier.
a	If opa is LA_TRANSPOSE or LA_HERMITIAN_TRANSPOSE, this matrix must be k by m; else, this matrix must be m by k.
lda	The leading dimension of matrix a.
b	If opb is LA_TRANSPOSE or LA_HERMITIAN_TRANSPOSE, this matrix must be n by k; else, this matrix must be k by n.
ldb	The leading dimension of matrix b.
beta	A scalar multiplier.
c	The m by n matrix C.
ldc	The leading dimension of matrix c.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, ldb, or ldc are not correct.

la_mult_lq()

int la_mult_lq	(	bool	lside,
		bool	trans,
		int	m,
		int	n,
		int	k,
		const double *	a,
		int	lda,
		const double *	tau,
		double *	c,
		int	ldc )

Multiplies a general matrix by the orthogonal matrix Q from a LQ factorization such that: \( C = op(Q) C \), or \( C = C op(Q) \).

Parameters

lside	Set to true to apply \( Q \) or \( Q^T \) from the left; else, set to false to apply \( Q \) or \( Q^T \) from the right.
trans	Set to true to apply \( Q^T \); else, set to false.
m	The number of rows in matrix C.
n	The number of columns in matrix C.
k	The number of elementary reflectors whose product defines the matrix Q.
a	On input, an K-by-P matrix containing the elementary reflectors output from the LQ factorization. If lside is set to true, P = M; else, if lside is set to false, P = N.
lda	The leading dimension of matrix A.
tau	A K-element array containing the scalar factors of each elementary reflector defined in a.
c	On input, the M-by-N matrix C. On output, the product of the orthogonal matrix Q and the original matrix C.
ldc	The leading dimension of matrix C.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda or ldc are not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_mult_lq_cmplx()

int la_mult_lq_cmplx	(	bool	lside,
		bool	trans,
		int	m,
		int	n,
		int	k,
		const double complex *	a,
		int	lda,
		const double complex *	tau,
		double complex *	c,
		int	ldc )

Multiplies a general matrix by the orthogonal matrix Q from a LQ factorization such that: \( C = op(Q) C \), or \( C = C op(Q) \).

WARNING

Untested code that needs more work before being ready for normal use.

Parameters

lside	Set to true to apply \( Q \) or \( Q^H \) from the left; else, set to false to apply \( Q \) or \( Q^H \) from the right.
trans	Set to true to apply \( Q^H \); else, set to false.
m	The number of rows in matrix C.
n	The number of columns in matrix C.
k	The number of elementary reflectors whose product defines the matrix Q.
a	On input, an K-by-P matrix containing the elementary reflectors output from the LQ factorization. If lside is set to true, P = M; else, if lside is set to false, P = N.
lda	The leading dimension of matrix A.
tau	A K-element array containing the scalar factors of each elementary reflector defined in a.
c	On input, the M-by-N matrix C. On output, the product of the orthogonal matrix Q and the original matrix C.
ldc	The leading dimension of matrix C.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda or ldc are not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_mult_qr()

int la_mult_qr	(	bool	lside,
		bool	trans,
		int	m,
		int	n,
		int	k,
		double *	a,
		int	lda,
		const double *	tau,
		double *	c,
		int	ldc )

Multiplies a general matrix by the orthogonal matrix Q from a QR factorization such that: \( C = op(Q) C \), or \( C = C op(Q) \).

Parameters

lside	Set to true to apply \( Q \) or \( Q^T \) from the left; else, set to false to apply \( Q \) or \( Q^T \) from the right.
trans	Set to true to apply \( Q^T \); else, set to false.
m	The number of rows in matrix C.
n	The number of columns in matrix C.
k	The number of elementary reflectors whose product defines the matrix Q.
a	On input, an LDA-by-K matrix containing the elementary reflectors output from the QR factorization. If lside is set to true, LDA = M, and M >= K >= 0; else, if lside is set to false, LDA = N, and N >= K >= 0. Notice, the contents of this matrix are restored on exit.
lda	The leading dimension of matrix A.
tau	A K-element array containing the scalar factors of each elementary reflector defined in a.
c	On input, the M-by-N matrix C. On output, the product of the orthogonal matrix Q and the original matrix C.
ldc	The leading dimension of matrix C.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda or ldc are not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_mult_qr_cmplx()

int la_mult_qr_cmplx	(	bool	lside,
		bool	trans,
		int	m,
		int	n,
		int	k,
		double complex *	a,
		int	lda,
		const double complex *	tau,
		double complex *	c,
		int	ldc )

Multiplies a general matrix by the orthogonal matrix Q from a QR factorization such that: \( C = op(Q) C \), or \( C = C op(Q) \).

Parameters

lside	Set to true to apply \( Q \) or \( Q^H \) from the left; else, set to false to apply \( Q \) or \( Q^H \) from the right.
trans	Set to true to apply \( Q^H \); else, set to false.
m	The number of rows in matrix C.
n	The number of columns in matrix C.
k	The number of elementary reflectors whose product defines the matrix Q.
a	On input, an LDA-by-K matrix containing the elementary reflectors output from the QR factorization. If lside is set to true, LDA = M, and M >= K >= 0; else, if lside is set to false, LDA = N, and N >= K >= 0. Notice, the contents of this matrix are restored on exit.
lda	The leading dimension of matrix A.
tau	A K-element array containing the scalar factors of each elementary reflector defined in a.
c	On input, the M-by-N matrix C. On output, the product of the orthogonal matrix Q and the original matrix C.
ldc	The leading dimension of matrix C.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda or ldc are not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_pinverse()

int la_pinverse	(	int	m,
		int	n,
		double *	a,
		int	lda,
		double *	ainv,
		int	ldai )

Computes the Moore-Penrose pseudo-inverse of an M-by-N matrix by means of singular value decomposition.

Parameters

m	The number of rows in the matrix. @parma n The number of columns in the matrix.
a	On input, the M-by-N matrix to invert. The matrix is overwritten on output.
lda	The leading dimension of matrix A.
ainv	The N-by-M matrix where the pseudo-inverse of a will be written.
ldai	The leading dimension of matrix AINV.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldai is not correct.

la_pinverse_cmplx()

int la_pinverse_cmplx	(	int	m,
		int	n,
		double complex *	a,
		int	lda,
		double complex *	ainv,
		int	ldai )

Computes the Moore-Penrose pseudo-inverse of an M-by-N matrix by means of singular value decomposition.

Parameters

m	The number of rows in the matrix. @parma n The number of columns in the matrix.
a	On input, the M-by-N matrix to invert. The matrix is overwritten on output.
lda	The leading dimension of matrix A.
ainv	The N-by-M matrix where the pseudo-inverse of a will be written.
ldai	The leading dimension of matrix AINV.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldai is not correct.

la_qr_factor()

int la_qr_factor	(	int	m,
		int	n,
		double *	a,
		int	lda,
		double *	tau )

Computes the QR factorization of an M-by-N matrix without pivoting.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix to factor. On output, the elements on and above the diagonal contain the MIN(M, N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N). The elements below the diagonal, along with the array tau, represent the orthogonal matrix Q as a product of elementary reflectors.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array used to store the scalar factors of the elementary reflectors.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_qr_factor_cmplx()

int la_qr_factor_cmplx	(	int	m,
		int	n,
		double complex *	a,
		int	lda,
		double complex *	tau )

Computes the QR factorization of an M-by-N matrix without pivoting.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix to factor. On output, the elements on and above the diagonal contain the MIN(M, N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N). The elements below the diagonal, along with the array tau, represent the orthogonal matrix Q as a product of elementary reflectors.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array used to store the scalar factors of the elementary reflectors.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_qr_factor_cmplx_pvt()

int la_qr_factor_cmplx_pvt	(	int	m,
		int	n,
		double complex *	a,
		int	lda,
		double complex *	tau,
		int *	jpvt )

Computes the QR factorization of an M-by-N matrix with column pivoting.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix to factor. On output, the elements on and above the diagonal contain the MIN(M, N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N). The elements below the diagonal, along with the array tau, represent the orthogonal matrix Q as a product of elementary reflectors.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array used to store the scalar factors of the elementary reflectors.
jpvt	On input, an N-element array that if JPVT(I) .ne. 0, the I-th column of A is permuted to the front of A * P; if JPVT(I) = 0, the I-th column of A is a free column. On output, if JPVT(I) = K, then the I-th column of A * P was the K-th column of A.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_qr_factor_pvt()

int la_qr_factor_pvt	(	int	m,
		int	n,
		double *	a,
		int	lda,
		double *	tau,
		int *	jpvt )

Computes the QR factorization of an M-by-N matrix with column pivoting.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix to factor. On output, the elements on and above the diagonal contain the MIN(M, N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N). The elements below the diagonal, along with the array tau, represent the orthogonal matrix Q as a product of elementary reflectors.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array used to store the scalar factors of the elementary reflectors.
jpvt	On input, an N-element array that if JPVT(I) .ne. 0, the I-th column of A is permuted to the front of A * P; if JPVT(I) = 0, the I-th column of A is a free column. On output, if JPVT(I) = K, then the I-th column of A * P was the K-th column of A.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_qr_rank1_update()

int la_qr_rank1_update	(	int	m,
		int	n,
		double *	q,
		int	ldq,
		double *	r,
		int	ldr,
		double *	u,
		double *	v )

Computes the rank 1 update to an M-by-N QR factored matrix A (M >= N) where \( A = Q R \), and \( A1 = A + U V^T \) such that \( A1 = Q1 R1 \).

Parameters

m	The number of rows in R.
n	The number of columns in R.
q	On input, the original M-by-K orthogonal matrix Q. On output, the updated matrix Q1.
ldq	The leading dimension of matrix Q.
r	On input, the M-by-N matrix R. On output, the updated matrix R1.
ldr	The leading dimension of matrix R.
u	On input, the M-element U update vector. On output, the original content of the array is overwritten.
v	On input, the N-element V update vector. On output, the original content of the array is overwritten.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldq or ldr is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_qr_rank1_update_cmplx()

int la_qr_rank1_update_cmplx	(	int	m,
		int	n,
		double complex *	q,
		int	ldq,
		double complex *	r,
		int	ldr,
		double complex *	u,
		double complex *	v )

Computes the rank 1 update to an M-by-N QR factored matrix A (M >= N) where \( A = Q R \), and \( A1 = A + U V^H \) such that \( A1 = Q1 R1 \).

WARNING

Untested code that needs more work before being ready for normal use.

Parameters

m	The number of rows in R.
n	The number of columns in R.
q	On input, the original M-by-K orthogonal matrix Q. On output, the updated matrix Q1.
ldq	The leading dimension of matrix Q.
r	On input, the M-by-N matrix R. On output, the updated matrix R1.
ldr	The leading dimension of matrix R.
u	On input, the M-element U update vector. On output, the original content of the array is overwritten.
v	On input, the N-element V update vector. On output, the original content of the array is overwritten.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldq or ldr is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if there is insufficient memory available.

la_rank()

int la_rank	(	int	m,
		int	n,
		double *	a,
		int	lda,
		int *	rnk )

Computes the rank of a matrix.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	The M-by-N matrix. The matrix is overwritten as part of this operation.
lda	The leading dimension of matrix A.
rnk	The rank of a.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_CONVERGENCE_ERROR: Occurs as a warning if the QR iteration process could not converge to a zero value.

la_rank1_update()

int la_rank1_update	(	int	m,
		int	n,
		double	alpha,
		const double *	x,
		const double *	y,
		double *	a,
		int	lda )

Performs the rank-1 update to matrix A such that: \( A = \alpha X Y^T + A \), where \( A \) is an M-by-N matrix, \( \alpha \) is a scalar, \( X \) is an M-element array, and \( Y \) is an N-element array.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
alpha	The scalar multiplier.
x	An M-element array.
y	An N-element array.
a	On input, the M-by-N matrix to update. On output, the updated M-by-N matrix.
lda	The leading dimension of matrix A.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.

la_rank1_update_cmplx()

int la_rank1_update_cmplx	(	int	m,
		int	n,
		double complex	alpha,
		const double complex *	x,
		const double complex *	y,
		double complex *	a,
		int	lda )

Performs the rank-1 update to matrix A such that: \( A = \alpha X Y^H + A \), where \( A \) is an M-by-N matrix, \( \alpha \) is a scalar, \( X \) is an M-element array, and \( Y \) is an N-element array.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
alpha	The scalar multiplier.
x	An M-element array.
y	An N-element array.
a	On input, the M-by-N matrix to update. On output, the updated M-by-N matrix.
lda	The leading dimension of matrix A.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.

la_rank_cmplx()

int la_rank_cmplx	(	int	m,
		int	n,
		double complex *	a,
		int	lda,
		int *	rnk )

Computes the rank of a matrix.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	The M-by-N matrix. The matrix is overwritten as part of this operation.
lda	The leading dimension of matrix A.
rnk	The rank of a.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_CONVERGENCE_ERROR: Occurs as a warning if the QR iteration process could not converge to a zero value.

la_solve_cholesky()

int la_solve_cholesky	(	bool	upper,
		int	m,
		int	n,
		const double *	a,
		int	lda,
		double *	b,
		int	ldb )

Solves a system of Cholesky factored equations.

Parameters

upper	Set to true if the original matrix A was factored such that \( A = U^T U \); else, set to false if the factorization of A was \( A = L^T L \).
m	The number of rows in matrix B.
n	The number of columns in matrix B.
a	The M-by-M Cholesky factored matrix.
lda	The leading dimension of matrix A.
b	On input, the M-by-N right-hand-side matrix B. On output, the M-by-N solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.

la_solve_cholesky_cmplx()

int la_solve_cholesky_cmplx	(	bool	upper,
		int	m,
		int	n,
		const double complex *	a,
		int	lda,
		double complex *	b,
		int	ldb )

Solves a system of Cholesky factored equations.

Parameters

upper	Set to true if the original matrix A was factored such that \( A = U^T U \); else, set to false if the factorization of A was \( A = L^T L \).
m	The number of rows in matrix B.
n	The number of columns in matrix B.
a	The M-by-M Cholesky factored matrix.
lda	The leading dimension of matrix A.
b	On input, the M-by-N right-hand-side matrix B. On output, the M-by-N solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.

la_solve_least_squares()

int la_solve_least_squares	(	int	m,
		int	n,
		int	k,
		double *	a,
		int	lda,
		double *	b,
		int	ldb )

Solves the overdetermined or underdetermined system ( \( A X = B \)) of M equations of N unknowns using a QR or LQ factorization of the matrix A. Notice, it is assumed that matrix A has full rank.

Parameters

m	The number of equations (rows in matrix A).
n	The number of unknowns (columns in matrix A).
k	The number of columns in the right-hand-side matrix.
a	On input, the M-by-N matrix A. On output, if M >= N, the QR factorization of A in the form as output by qr_factor; else, if M < N, the LQ factorization of A.
lda	The leading dimension of matrix A.
b	If M >= N, the M-by-NRHS matrix B. On output, the first N rows contain the N-by-NRHS solution matrix X. If M < N, an N-by-NRHS matrix with the first M rows containing the matrix B. On output, the N-by-NRHS solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_INVALID_OPERATION_ERROR: Occurs if a is not of full rank.

la_solve_least_squares_cmplx()

int la_solve_least_squares_cmplx	(	int	m,
		int	n,
		int	k,
		double complex *	a,
		int	lda,
		double complex *	b,
		int	ldb )

Solves the overdetermined or underdetermined system ( \( A X = B \)) of M equations of N unknowns using a QR or LQ factorization of the matrix A. Notice, it is assumed that matrix A has full rank.

Parameters

m	The number of equations (rows in matrix A).
n	The number of unknowns (columns in matrix A).
k	The number of columns in the right-hand-side matrix.
a	On input, the M-by-N matrix A. On output, if M >= N, the QR factorization of A in the form as output by qr_factor; else, if M < N, the LQ factorization of A.
lda	The leading dimension of matrix A.
b	If M >= N, the M-by-NRHS matrix B. On output, the first N rows contain the N-by-NRHS solution matrix X. If M < N, an N-by-NRHS matrix with the first M rows containing the matrix B. On output, the N-by-NRHS solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_INVALID_OPERATION_ERROR: Occurs if a is not of full rank.

la_solve_lq()

int la_solve_lq	(	int	m,
		int	n,
		int	k,
		const double *	a,
		int	lda,
		const double *	tau,
		double *	b,
		int	ldb )

Solves a system of M QR-factored equations of N unknowns where N >= M.

Parameters

m	The number of equations (rows in matrix A).
n	The number of unknowns (columns in matrix A).
k	The number of columns in the right-hand-side matrix.
a	On input, the M-by-N QR factored matrix as returned by lq_factor.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array containing the scalar factors of the elementary reflectors as returned by lq_factor.
b	On input, an N-by-K matrix containing the first M rows of the right-hand-side matrix. On output, the solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct, or if m is less than n.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_solve_lq_cmplx()

int la_solve_lq_cmplx	(	int	m,
		int	n,
		int	k,
		const double complex *	a,
		int	lda,
		const double complex *	tau,
		double complex *	b,
		int	ldb )

Solves a system of M QR-factored equations of N unknowns where N >= M.

WARNING

Untested code that needs more work before being ready for normal use.

Parameters

m	The number of equations (rows in matrix A).
n	The number of unknowns (columns in matrix A).
k	The number of columns in the right-hand-side matrix.
a	On input, the M-by-N QR factored matrix as returned by lq_factor.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array containing the scalar factors of the elementary reflectors as returned by lq_factor.
b	On input, an N-by-K matrix containing the first M rows of the right-hand-side matrix. On output, the solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct, or if m is less than n.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_solve_lu()

int la_solve_lu	(	int	m,
		int	n,
		const double *	a,
		int	lda,
		const int *	ipvt,
		double *	b,
		int	ldb )

Solves a system of LU-factored equations.

Parameters

m	The number of rows in matrix B.
n	The number of columns in matrix B.
a	The M-by-M LU factored matrix.
lda	The leading dimension of matrix A.
ipvt	The M-element pivot array from the LU factorization.
b	On input, the M-by-N right-hand-side. On output, the M-by-N solution.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.

la_solve_lu_cmplx()

int la_solve_lu_cmplx	(	int	m,
		int	n,
		const double complex *	a,
		int	lda,
		const int *	ipvt,
		double complex *	b,
		int	ldb )

Solves a system of LU-factored equations.

Parameters

m	The number of rows in matrix B.
n	The number of columns in matrix B.
a	The M-by-M LU factored matrix.
lda	The leading dimension of matrix A.
ipvt	The M-element pivot array from the LU factorization.
b	On input, the M-by-N right-hand-side. On output, the M-by-N solution.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.

la_solve_qr()

int la_solve_qr	(	int	m,
		int	n,
		int	k,
		double *	a,
		int	lda,
		const double *	tau,
		double *	b,
		int	ldb )

Solves a system of M QR-factored equations of N unknowns where M >= N.

Parameters

m	The number of equations (rows in matrix A).
n	The number of unknowns (columns in matrix A).
k	The number of columns in the right-hand-side matrix.
a	On input, the M-by-N QR factored matrix as returned by qr_factor. On output, the contents of this matrix are restored.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array containing the scalar factors of the elementary reflectors as returned by qr_factor.
b	On input, the M-by-K right-hand-side matrix. On output, the first N rows are overwritten by the solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct, or if m is less than n.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_solve_qr_cmplx()

int la_solve_qr_cmplx	(	int	m,
		int	n,
		int	k,
		double complex *	a,
		int	lda,
		const double complex *	tau,
		double complex *	b,
		int	ldb )

Solves a system of M QR-factored equations of N unknowns where M >= N.

Parameters

m	The number of equations (rows in matrix A).
n	The number of unknowns (columns in matrix A).
k	The number of columns in the right-hand-side matrix.
a	On input, the M-by-N QR factored matrix as returned by qr_factor. On output, the contents of this matrix are restored.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array containing the scalar factors of the elementary reflectors as returned by qr_factor.
b	On input, the M-by-K right-hand-side matrix. On output, the first N rows are overwritten by the solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct, or if m is less than n.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_solve_qr_cmplx_pvt()

int la_solve_qr_cmplx_pvt	(	int	m,
		int	n,
		int	k,
		double complex *	a,
		int	lda,
		const double complex *	tau,
		const int *	jpvt,
		double complex *	b,
		int	ldb )

Solves a system of M QR-factored equations of N unknowns.

Parameters

m	The number of equations (rows in matrix A).
n	The number of unknowns (columns in matrix A).
k	The number of columns in the right-hand-side matrix.
a	On input, the M-by-N QR factored matrix as returned by qr_factor. On output, the contents of this matrix are restored.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array containing the scalar factors of the elementary reflectors as returned by qr_factor.
jpvt	The N-element array that was used to track the column pivoting operations in the QR factorization.
b	On input, the M-by-K right-hand-side matrix. On output, the first N rows are overwritten by the solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_solve_qr_pvt()

int la_solve_qr_pvt	(	int	m,
		int	n,
		int	k,
		double *	a,
		int	lda,
		const double *	tau,
		const int *	jpvt,
		double *	b,
		int	ldb )

Solves a system of M QR-factored equations of N unknowns.

Parameters

m	The number of equations (rows in matrix A).
n	The number of unknowns (columns in matrix A).
k	The number of columns in the right-hand-side matrix.
a	On input, the M-by-N QR factored matrix as returned by qr_factor. On output, the contents of this matrix are restored.
lda	The leading dimension of matrix A.
tau	A MIN(M, N)-element array containing the scalar factors of the elementary reflectors as returned by qr_factor.
jpvt	The N-element array that was used to track the column pivoting operations in the QR factorization.
b	On input, the M-by-K right-hand-side matrix. On output, the first N rows are overwritten by the solution matrix X.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_solve_tri_mtx()

int la_solve_tri_mtx	(	bool	lside,
		bool	upper,
		bool	trans,
		bool	nounit,
		int	m,
		int	n,
		double	alpha,
		const double *	a,
		int	lda,
		double *	b,
		int	ldb )

Solves one of the matrix equations: \( op(A) X = \alpha B \), or \( X op(A) = \alpha B \), where \( A \) is a triangular matrix.

Parameters

lside	Set to true to solve \( op(A) X = \alpha B \); else, set to false to solve \( X op(A) = \alpha B \).
upper	Set to true if A is an upper triangular matrix; else, set to false if A is a lower triangular matrix.
trans	Set to true if \( op(A) = A^T \); else, set to false if \( op(A) = A \).
nounit	Set to true if A is not a unit-diagonal matrix (ones on every diagonal element); else, set to false if A is a unit-diagonal matrix.
m	The number of rows in matrix B.
n	The number of columns in matrix B.
alpha	The scalar multiplier to B.
a	If lside is true, the M-by-M triangular matrix on which to operate; else, if lside is false, the N-by-N triangular matrix on which to operate.
lda	The leading dimension of matrix A.
b	On input, the M-by-N right-hand-side. On output, the M-by-N solution.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.

la_solve_tri_mtx_cmplx()

int la_solve_tri_mtx_cmplx	(	bool	lside,
		bool	upper,
		bool	trans,
		bool	nounit,
		int	m,
		int	n,
		double complex	alpha,
		const double complex *	a,
		int	lda,
		double complex *	b,
		int	ldb )

Solves one of the matrix equations: \( op(A) X = \alpha B \), or \( X op(A) = \alpha B \), where \( A \) is a triangular matrix.

Parameters

lside	Set to true to solve \( op(A) X = \alpha B \); else, set to false to solve \( X op(A) = \alpha B \).
upper	Set to true if A is an upper triangular matrix; else, set to false if A is a lower triangular matrix.
trans	Set to true if \( op(A) = A^H \); else, set to false if \( op(A) = A \).
nounit	Set to true if A is not a unit-diagonal matrix (ones on every diagonal element); else, set to false if A is a unit-diagonal matrix.
m	The number of rows in matrix B.
n	The number of columns in matrix B.
alpha	The scalar multiplier to B.
a	If lside is true, the M-by-M triangular matrix on which to operate; else, if lside is false, the N-by-N triangular matrix on which to operate.
lda	The leading dimension of matrix A.
b	On input, the M-by-N right-hand-side. On output, the M-by-N solution.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, or ldb is not correct.

la_sort_eigen()

int la_sort_eigen	(	bool	ascend,
		int	n,
		double *	vals,
		double *	vecs,
		int	ldv )

A sorting routine specifically tailored for sorting of eigenvalues and their associated eigenvectors using a quick-sort approach.

Parameters

ascend
n	The number of eigenvalues.
vals	On input, an N-element array containing the eigenvalues. On output, the sorted eigenvalues.
vecs	On input, an N-by-N matrix containing the eigenvectors associated with vals (one vector per column). On output, the sorted eigenvector matrix.
ldv	The leading dimension of vecs.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldv is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_sort_eigen_cmplx()

int la_sort_eigen_cmplx	(	bool	ascend,
		int	n,
		double complex *	vals,
		double complex *	vecs,
		int	ldv )

A sorting routine specifically tailored for sorting of eigenvalues and their associated eigenvectors using a quick-sort approach.

Parameters

ascend
n	The number of eigenvalues.
vals	On input, an N-element array containing the eigenvalues. On output, the sorted eigenvalues.
vecs	On input, an N-by-N matrix containing the eigenvectors associated with vals (one vector per column). On output, the sorted eigenvector matrix.
ldv	The leading dimension of vecs.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if ldv is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.

la_svd()

int la_svd	(	int	m,
		int	n,
		double *	a,
		int	lda,
		double *	s,
		double *	u,
		int	ldu,
		double *	vt,
		int	ldv )

Computes the singular value decomposition of a matrix \( A \). The SVD is defined as: \( A = U S V^T \), where \( U \) is an M-by-M orthogonal matrix, \( S \) is an M-by-N diagonal matrix, and \( V \) is an N-by-N orthogonal matrix.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix to factor. The matrix is overwritten on output.
lda	The leading dimension of matrix A.
s	A MIN(M, N)-element array containing the singular values of a sorted in descending order.
u	An M-by-M matrix where the orthogonal U matrix will be written.
ldu	The leading dimension of matrix U.
vt	An N-by-N matrix where the transpose of the right singular vector matrix V.
ldv	The leading dimension of matrix V.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, ldu, or ldv is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_CONVERGENCE_ERROR: Occurs as a warning if the QR iteration process could not converge to a zero value.

la_svd_cmplx()

int la_svd_cmplx	(	int	m,
		int	n,
		double complex *	a,
		int	lda,
		double *	s,
		double complex *	u,
		int	ldu,
		double complex *	vt,
		int	ldv )

Computes the singular value decomposition of a matrix \( A \). The SVD is defined as: \( A = U S V^H \), where \( U \) is an M-by-M orthogonal matrix, \( S \) is an M-by-N diagonal matrix, and \( V \) is an N-by-N orthogonal matrix.

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	On input, the M-by-N matrix to factor. The matrix is overwritten on output.
lda	The leading dimension of matrix A.
s	A MIN(M, N)-element array containing the singular values of a sorted in descending order.
u	An M-by-M matrix where the orthogonal U matrix will be written.
ldu	The leading dimension of matrix U.
vt	An N-by-N matrix where the conjugate transpose of the right singular vector matrix V.
ldv	The leading dimension of vt.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda, ldu, or ldv is not correct.
• LA_OUT_OF_MEMORY_ERROR: Occurs if local memory must be allocated, and there is insufficient memory available.
• LA_CONVERGENCE_ERROR: Occurs as a warning if the QR iteration process could not converge to a zero value.

la_trace()

int la_trace	(	int	m,
		int	n,
		const double *	a,
		int	lda,
		double *	rst )

Computes the trace of a matrix (the sum of the main diagonal elements).

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	The M-by-N matrix on which to operate.
lda	The leading dimension of the matrix.
rst	The results of the operation.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.

la_trace_cmplx()

int la_trace_cmplx	(	int	m,
		int	n,
		const double complex *	a,
		int	lda,
		double complex *	rst )

Computes the trace of a matrix (the sum of the main diagonal elements).

Parameters

m	The number of rows in the matrix.
n	The number of columns in the matrix.
a	The M-by-N matrix on which to operate.
lda	The leading dimension of the matrix.
rst	The results of the operation.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda is not correct.

la_tri_mtx_mult()

int la_tri_mtx_mult	(	bool	upper,
		double	alpha,
		int	n,
		const double *	a,
		int	lda,
		double	beta,
		double *	b,
		int	ldb )

Computes the triangular matrix operation: \( B = \alpha A^T A + \beta B \), or \( B = \alpha A A^T + \beta B \), where \( A \) is a triangular matrix.

Parameters

upper	Set to true if matrix \( A \) is upper triangular, and \( B = \alpha A^T A + \beta B \) is to be calculated; else, set to false if \( A \) is lower triangular, and \( B = \alpha A A^T + \beta B \) is to be computed.
alpha	A scalar multiplier.
n	The dimension of the matrix.
a	The n by n triangular matrix A. Notice, if upper is true, only the upper triangular portion of this matrix is referenced; else, if upper is false, only the lower triangular portion of this matrix is referenced.
lda	The leading dimension of matrix A.
beta	A scalar multiplier.
b	On input, the n by n matrix B. On output, the n by n resulting matrix.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda or ldb are not correct.

la_tri_mtx_mult_cmplx()

int la_tri_mtx_mult_cmplx	(	bool	upper,
		double complex	alpha,
		int	n,
		const double complex *	a,
		int	lda,
		double complex	beta,
		double complex *	b,
		int	ldb )

Computes the triangular matrix operation: \( B = \alpha A^T A + \beta B \), or \( B = \alpha A A^T + \beta B \), where \( A \) is a triangular matrix.

Parameters

upper	Set to true if matrix \( A \) is upper triangular, and \( B = \alpha A^T A + \beta B \) is to be calculated; else, set to false if \( A \) is lower triangular, and \( B = \alpha A A^T + \beta B \) is to be computed.
alpha	A scalar multiplier.
n	The dimension of the matrix.
a	The n by n triangular matrix A. Notice, if upper is true, only the upper triangular portion of this matrix is referenced; else, if upper is false, only the lower triangular portion of this matrix is referenced.
lda	The leading dimension of matrix A.
beta	A scalar multiplier.
b	On input, the n by n matrix B. On output, the n by n resulting matrix.
ldb	The leading dimension of matrix B.

Returns

An error code. The following codes are possible.

• LA_NO_ERROR: No error occurred. Successful operation.
• LA_INVALID_INPUT_ERROR: Occurs if lda or ldb are not correct.