Matrix Decomposition¶

geqrf¶

geqrf overload (1)¶

#include "MatrixDecomposition/geqrf.hpp"

template <
    typename T,
    int NRMAX,
    int NCMAX,
    int NCU
    >
int geqrf (
    int m,
    int n,
    T* A,
    int lda,
    T* tau
    )

This function computes QR decomposition of matrix $A$

$\begin{equation*} {A = Q R}\end{equation*}$

where $A$ is a dense matrix of size $m \times n$ , $Q$ is a $m \times n$ matrix with orthonormal columns, and $R$ is an upper triangular matrix.

The maximum matrix size supported in FPGA is templated by NRMAX and NCMAX.

Parameters:

T	data type (support float and double)
NRMAX	maximum number of rows of input matrix
NCMAX	maximum number of columns of input matrix
NCU	number of computation unit
m	number of rows of matrix A
n	number of cols of matrix A
A	input matrix of size $m \times lda$ , and overwritten by the output triangular R matrix and min(m,n) elementary reflectors
lda	leading dimension of matrix A
tau	scalar factors for elementary reflectors

gesvdj¶

#include "MatrixDecomposition/gesvdj.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void gesvdj (
    int m,
    T* A,
    int lda,
    T* S,
    T* U,
    int ldu,
    T* V,
    int ldv,
    int& info
    )

Symmetric Matrix Jacobi based Singular Value Decomposition (GESVDJ) .

$\begin{equation*} {A = U \Sigma {V}^T}\end{equation*}$

where $A$ is a dense symmetric matrix of size $m \times m$ , $U$ and $V$ are $m \times m$ matrix with orthonormal columns, and $\Sigma$ is diagonal matrix.

The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double).
NMAX	maximum number of rows/columns of input matrix
NCU	number of computation unit
m	number of rows/cols of matrix A
A	input matrix of size $m \times m$
S	decomposed diagonal singular matrix of size $m \times m$
U	left U matrix of SVD
V	right V matrix of SVD
lda	leading dimension of matrix A
ldu	leading dimension of matrix U
ldv	leading dimension of matrix V
info	output info (unused)

gesvj¶

#include "MatrixDecomposition/gesvj.hpp"

template <
    typename T,
    int NRMAX,
    int NCMAX,
    int MCU,
    int NCU
    >
void gesvj (
    int m,
    int n,
    T* A,
    T* U,
    T* S,
    T* V
    )

This function implements singular value decomposition of matrix A using one-sided Jacobi algorihtm.

$\begin{equation*} {A = U \Sigma {V}^T}\end{equation*}$

where $A$ is a dense matrix of size $m \times n$ , $U$ is $m \times m$ matrix with orthonormal columns, $V$ is $n \times n$ matrix with orthonormal columns, and $\Sigma$ is diagonal matrix.

The maximum matrix size supported in FPGA is templated by NCMAX, NRMAX.

Parameters:

T
:	the data type of gesvj
NRMAX	maximum number of rows of input matrix
NCMAX	maximum number of columns of input matrix
MCU	number of computation unit of M
NCU	number of computation unit of N
m	number of rows of matrix A
n	number of cols of matrix A
A	input matrix of size $m \times n$
S	decomposed diagonal singular matrix of size n
U	left U matrix of SVD of size $m \times m$
V	right V matrix of SVD $n \times n$

getrf¶

#include "MatrixDecomposition/getrf.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void getrf (
    int n,
    T* A,
    int lda,
    int* ipiv,
    int& info
    )

This function computes the LU decomposition (with partial pivoting) of matrix $A$

$\begin{equation*} {P A = L U}\end{equation*}$

where $P$ is a permutation matrix, $A$ is a dense matrix of size $n \times n$ , $L$ is a lower triangular matrix with unit diagonal, and $U$ is an upper triangular matrix. This function does not implement pivoting.

The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double)
NMAX	maximum number of rows/columns of input matrix
NCU	number of computation unit
n	number of rows/cols of matrix A
A	input matrix, and overwritten by the output upper and lower triangular matrix
lda	leading dimention of input matrix A
pivot	indices, row i of matrix A is stored in row[i]
info	output info (unused)

getrf_nopivot¶

#include "MatrixDecomposition/getrf_nopivot.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void getrf_nopivot (
    int n,
    T* A,
    int lda,
    int& info
    )

This function computes the LU decomposition (without pivoting) of matrix $A$

$\begin{equation*} {A = L U}\end{equation*}$

where $A$ is a dense matrix of size $n \times n$ , $L$ is a lower triangular matrix with unit diagonal, and $U$ is an upper triangular matrix. This function does not implement pivoting.

The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double)
NMAX	maximum number of rows/cols of input matrix
NCU	number of computation unit
n	number of rows/cols of matrix A
A	input matrix
lda	leading dimention of input matrix A
info	output info (unused)

potrf¶

#include "MatrixDecomposition/potrf.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void potrf (
    int m,
    T* A,
    int lda,
    int& info
    )

This function computes the Cholesky decomposition of matrix $A$

$\begin{equation*} {A = L {L}^T}\end{equation*}$

where $A$ is a dense symmetric positive-definite matrix of size $m \times m$ , $L$ is a lower triangular matrix, and ${L}^T$ is the transposed matrix of $L$ .

The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double)
NMAX	maximum number of rows/columns of input matrix
NCU	number of computation unit
m	number of rows/cols of matrix A
A	input matrix of size $m \times m$
lda	leading dimention of input matrix A
info	output info (unused)

Linear Solver¶

gelinearsolver¶

#include "LinearSolver/gelinearsolver.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void gelinearsolver (
    int n,
    T* A,
    int b,
    T* B,
    int lda,
    int ldb,
    int& info
    )

This function solves a system of linear equation with general matrix along with multiple right-hand side vector

$\begin{equation*} {Ax=B}\end{equation*}$

where $A$ is a dense general matrix of size $n \times n$ , $x$ is a vector need to be computed, and $B$ is input vector.

The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double)
NMAX	maximum number of rows/columns of input matrix
NCU	number of computation unit
n	number of rows/cols of matrix A
A	input matrix of size $n \times n$
b	number of columns of matrix B
B	input matrix of size $b \times n$ , and overwritten by the output matrix x
lda	leading dimention of input matrix A
ldb	leading dimention of input matrix B
info	output info (unused)

gematrixinverse¶

#include "LinearSolver/gematrixinverse.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void gematrixinverse (
    int m,
    T* A,
    int lda,
    int& info
    )

This function computes the inverse matrix of $A$

$\begin{equation*} {A}^{-1}\end{equation*}$

where $A$ is a dense general matrix of size $m \times m$ . The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double)
NMAX	maximum number of rows/columns of input matrix
NCU	number of computation unit
m	number of rows/cols of matrix A
A	input matrix of size $n \times n$
lda	leading dimention of input matrix A
info	output info (unused)

gtsv¶

#include "LinearSolver/gtsv_pcr.hpp"

template <
    typename T,
    unsigned int NMAX,
    unsigned int NCU
    >
int gtsv (
    unsigned int n,
    T* matDiagLow,
    T* matDiag,
    T* matDiagUp,
    T* rhs
    )

Tri-diagonal linear solver. Compute solution to linear system with a tridiagonal matrix. Parallel Cyclic Reduction method.

Parameters:

T	data type (support float and double)
NMAX	matrix size
NCU	number of compute units
matDiagLow	lower diagonal of matrix
matDiag	diagonal of matrix
matDiagUp	upper diagonal of matrix
rhs	right-hand side

polinearsolver¶

#include "LinearSolver/polinearsolver.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void polinearsolver (
    int n,
    T* A,
    int b,
    T* B,
    int lda,
    int ldb,
    int& info
    )

This function solves a system of linear equation with symmetric positive definite (SPD) matrix along with multiple right-hand side vector

$\begin{equation*} {Ax=B}\end{equation*}$

where $A$ is a dense SPD triangular matrix of size $m \times m$ , $x$ is a vector need to be computed, and $B$ is input vector.

The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double)
NMAX	maximum number of rows/columns of input matrix
NCU	number of computation unit
n	number of rows/cols of matrix A
A	input matrix of size $n \times n$
b	number of columns of matrix B
B	input matrix of size $b \times n$ , and overwritten by the output matrix x
lda	leading dimention of input matrix A
ldb	leading dimention of input matrix B
info	output info (unused)

pomatrixinverse¶

#include "LinearSolver/pomatrixinverse.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void pomatrixinverse (
    int m,
    T* A,
    int lda,
    int& info
    )

This function computes the inverse matrix of $A$

$\begin{equation*} {A}^{-1}\end{equation*}$

where $A$ is a dense symmetric positive-definite matrix of size $m \times m$ . The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double)
NMAX	maximum number of rows/columns of input matrix
NCU	number of computation unit
m	number of rows/cols of matrix A
A	input matrix of size $n \times n$
lda	leading dimention of input matrix A
info	output info (unused)

trtrs¶

#include "LinearSolver/trtrs.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void trtrs (
    char uplo,
    int m,
    T* A,
    int b,
    T* B,
    int lda,
    int ldb,
    int& info
    )

This function solves a system of linear equation with triangular coefficient matrix along with multiple right-hand side vector

$\begin{equation*} {Ax=B}\end{equation*}$

where $A$ is a dense lower or upper triangular matrix of size $m \times m$ , $x$ is a vector need to be computed, and $B$ is input vector.

The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double)
NMAX	maximum number of rows/columns of input matrix
NCU	number of computation unit
m	number of rows/cols of matrix A
A	input matrix of size $n \times n$
b	number of columns of matrix B
B	input matrix of size $b \times n$ , and overwritten by the output matrix x
lda	leading dimention of input matrix A
ldb	leading dimention of input matrix B
info	output info (unused)

Eigenvalue Solver¶

syevj¶

#include "EigenSolver/syevj.hpp"

template <
    typename T,
    int NMAX,
    int NCU
    >
void syevj (
    int m,
    T* A,
    int lda,
    T* S,
    T* U,
    int ldu,
    int& info
    )

Symmetric Matrix Jacobi based Eigenvalue Decomposition (SYEVJ) .

$\begin{equation*} {A U = U \Sigma, }\end{equation*}$

where $A$ is a dense symmetric matrix of size $m \times m$ , $U$ is a $m \times m$ matrix with orthonormal columns, each column of U is the eigenvector $v_{i}$ , and $\Sigma$ is diagonal matrix, which contains the eigenvalues $\lambda_{i}$ of matrix A.

The maximum matrix size supported in FPGA is templated by NMAX.

Parameters:

T	data type (support float and double).
NMAX	maximum number of rows/columns of input matrix
NCU	number of computation unit
m	number of rows/cols of matrix A
A	input matrix of size $m \times m$
S	decomposed diagonal singular matrix of size $m \times m$
U	left U matrix of SVD
lda	leading dimension of matrix A
ldu	leading dimension of matrix U
info	output info (unused)