Deterministic¶

Cauchy¶

An \(m \times n\) matrix \(A\) is called Cauchy if there exist vectors \(x\) and \(y\) such that

\[\alpha_{i,j} = \frac{1}{\chi_i - \eta_j},\]

where \(\chi_i\) is the \(i\)’th entry of \(x\) and \(\eta_j\) is the \(j\)’th entry of \(y\).

void Cauchy(Matrix<F> &A, const std::vector<F> &x, const std::vector<F> &y)¶

void Cauchy(DistMatrix<F, U, V> &A, const std::vector<F> &x, const std::vector<F> &y)¶: Generate a Cauchy matrix using the defining vectors, \(x\) and \(y\).

Cauchy-like¶

An \(m \times n\) matrix \(A\) is called Cauchy-like if there exist vectors \(r\), \(s\), \(x\), and \(y\) such that

\[\alpha_{i,j} = \frac{\rho_i \psi_j}{\chi_i - \eta_j},\]

where \(\rho_i\) is the \(i\)’th entry of \(r\), \(\psi_j\) is the \(j\)’th entry of \(s\), \(\chi_i\) is the \(i\)’th entry of \(x\), and \(\eta_j\) is the \(j\)’th entry of \(y\).

void CauchyLike(Matrix<F> &A, const std::vector<F> &r, const std::vector<F> &s, const std::vector<F> &x, const std::vector<F> &y)¶

void CauchyLike(DistMatrix<F, U, V> &A, const std::vector<F> &r, const std::vector<F> &s, const std::vector<F> &x, const std::vector<F> &y)¶: Generate a Cauchy-like matrix using the defining vectors: \(r\), \(s\), \(x\), and \(y\).

Circulant¶

An \(n \times n\) matrix \(A\) is called circulant if there exists a vector \(b\) such that

\[\alpha_{i,j} = \beta_{(i-j) \bmod n},\]

where \(\beta_k\) is the \(k\)’th entry of vector \(b\).

void Circulant(Matrix<T> &A, const std::vector<T> &a)¶

void Circulant(DistMatrix<T, U, V> &A, const std::vector<T> &a)¶: Generate a circulant matrix using the vector a.

Diagonal¶

An \(n \times n\) matrix \(A\) is called diagonal if each entry \((i,j)\), where \(i \neq j\), is \(0\). They are therefore defined by the diagonal values, where \(i = j\).

void Diagonal(Matrix<T> &D, const std::vector<T> &d)¶

void Diagonal(DistMatrix<T, U, V> &D, const std::vector<T> &d)¶: Construct a diagonal matrix from the vector of diagonal values, \(d\).

Egorov¶

Sets \(A\) to an \(n \times n\) matrix with the \((i,j)\) entry equal to

\[\exp(i \phi(i,j)).\]

void Egorov(Matrix<Complex<Real>> &A, const RealFunctor &phase, int n)¶

void Egorov(DistMatrix<Complex<Real>, U, V> &A, const RealFunctor &phase, int n)¶

Extended Kahan¶

TODO

void ExtendedKahan(Matrix<F> &A, int k, Base<F> phi, Base<F> mu)¶

void ExtendedKahan(DistMatrix<F, U, V> &A, int k, Base<F> phi, Base<F> mu)¶

Fiedler¶

TODO

void Fiedler(Matrix<F> &A, const std::vector<F> &c)¶

void Fiedler(DistMatrix<F, U, V> &A, const std::vector<F> &c)¶

Forsythe¶

TODO

void Forsythe(Matrix<T> &J, int n, T alpha, T lambda)¶

void Forsythe(DistMatrix<T, U, V> &J, int n, T alpha, T lambda)¶

Fourier¶

The \(n \times n\) Discrete Fourier Transform (DFT) matrix, say \(A\), is given by

\[\alpha_{i,j} = \frac{e^{-2\pi i j / n}}{\sqrt{n}}.\]

void Fourier(Matrix<Complex<Real>> &A, int n)¶

void Fourier(DistMatrix<Complex<Real>, U, V> &A, int n)¶: Set the matrix A equal to the \(n \times n\) DFT matrix.

void MakeFourier(Matrix<Complex<Real>> &A)¶

void MakeFourier(DistMatrix<Complex<Real>, U, V> &A)¶: Turn the existing \(n \times n\) matrix A into a DFT matrix.

GCDMatrix¶

TODO

void GCDMatrix(Matrix<T> &G, int m, int n)¶

void GCDMatrix(DistMatrix<T, U, V> &G, int m, int n)¶

Gear¶

TODO

void Gear(Matrix<T> &G, int n, int s, int t)¶

void Gear(DistMatrix<T, U, V> &G, int n, int s, int t)¶

Golub/Klema/Stewart¶

TODO

void GKS(Matrix<F> &A, int n)¶

void GKS(DistMatrix<F, U, V> &A, int n)¶

Grcar¶

TODO

void Grcar(Matrix<T> &A, int n, int k = 3)¶

void Grcar(DistMatrix<T, U, V> &A, int n, int k = 3)¶

Hankel¶

An \(m \times n\) matrix \(A\) is called a Hankel matrix if there exists a vector \(b\) such that

\[\alpha_{i,j} = \beta_{i+j},\]

where \(\alpha_{i,j}\) is the \((i,j)\) entry of \(A\) and \(\beta_k\) is the \(k\)’th entry of the vector \(b\).

void Hankel(Matrix<T> &A, int m, int n, const std::vector<T> &b)¶

void Hankel(DistMatrix<T, U, V> &A, int m, int n, const std::vector<T> &b)¶: Create an \(m \times n\) Hankel matrix from the generate vector, \(b\).

Hanowa¶

TODO

void Hanowa(Matrix<T> &A, int n, T mu)¶

void Hanowa(DistMatrix<T, U, V> &A, int n, T mu)¶

Helmholtz¶

TODO

void Helmholtz(Matrix<F> &H, int n, F shift)¶

void Helmholtz(DistMatrix<F, U, V> &H, int n, F shift)¶: 1D Helmholtz: TODO

void Helmholtz(Matrix<F> &H, int nx, int ny, F shift)¶

void Helmholtz(DistMatrix<F, U, V> &H, int nx, int ny, F shift)¶: 2D Helmholtz: TODO

void Helmholtz(Matrix<F> &H, int nx, int ny, int nz, F shift)¶

void Helmholtz(DistMatrix<F, U, V> &H, int nx, int ny, int nz, F shift)¶: 3D Helmholtz: TODO

Hilbert¶

The Hilbert matrix of order \(n\) is the \(n \times n\) matrix where entry \((i,j)\) is equal to \(1/(i+j+1)\).

void Hilbert(Matrix<F> &A, int n)¶

void Hilbert(DistMatrix<F, U, V> &A, int n)¶: Generate the \(n \times n\) Hilbert matrix A.

void MakeHilbert(Matrix<F> &A)¶

void MakeHilbert(DistMatrix<F, U, V> &A)¶: Turn the square matrix A into a Hilbert matrix.

HermitianFromEVD¶

Form

\[A := Z \Omega Z^H,\]

where \(\Omega\) is a real diagonal matrix.

void HermitianFromEVD(UpperOrLower uplo, Matrix<F> &A, const Matrix<Base<F>> &w, const Matrix<F> &Z)¶

void HermitianFromEVD(UpperOrLower uplo, DistMatrix<F> &A, const DistMatrix<Base<F>, VR, STAR> &w, const DistMatrix<F> &Z)¶: The diagonal entries of \(\Omega\) are given by the vector \(w\).

Identity¶

The \(n \times n\) identity matrix is simply defined by setting entry \((i,j)\) to one if \(i = j\), and zero otherwise. For various reasons, we generalize this definition to nonsquare, \(m \times n\), matrices.

void Identity(Matrix<T> &A, int m, int n)¶

void Identity(DistMatrix<T, U, V> &A, int m, int n)¶: Set the matrix A equal to the \(m \times n\) identity(-like) matrix.

void MakeIdentity(Matrix<T> &A)¶

void MakeIdentity(DistMatrix<T, U, V> &A)¶: Set the matrix A to be identity-like.

Jordan¶

TODO

void Jordan(Matrix<T> &J, int n, T lambda)¶

void Jordan(DistMatrix<T, U, V> &J, int n, T lambda)¶

Kahan¶

For any pair \((\phi,\zeta)\) such that \(|\phi|^2+|\zeta|^2=1\), the corresponding \(n \times n\) Kahan matrix is given by:

\[\begin{split}K = \text{diag}(1,\phi,\ldots,\phi^{n-1}) \begin{pmatrix} 1 & -\zeta & -\zeta & \cdots & -\zeta \\ 0 & 1 & -\zeta & \cdots & -\zeta \\ & \ddots & & \vdots & \vdots \\ \vdots & & & 1 & -\zeta \\ 0 & & \cdots & & 1 \end{pmatrix}\end{split}\]

void Kahan(Matrix<F> &A, int n, F phi)¶

void Kahan(DistMatrix<F> &A, int n, F phi)¶: Sets the matrix A equal to the \(n \times n\) Kahan matrix with the specified value for \(\phi\).

KMS¶

TODO

void KMS(Matrix<T> &K, int n, T rho)¶

void KMS(DistMatrix<T, U, V> &K, int n, T rho)¶

Laplacian¶

TODO

void Laplacian(Matrix<F> &L, int n)¶

void Laplacian(DistMatrix<F, U, V> &L, int n)¶: 1D Laplacian: TODO

void Laplacian(Matrix<F> &L, int nx, int ny)¶

void Laplacian(DistMatrix<F, U, V> &L, int nx, int ny)¶: 2D Laplacian: TODO

void Laplacian(Matrix<F> &L, int nx, int ny, int nz)¶

void Laplacian(DistMatrix<F, U, V> &L, int nx, int ny, int nz)¶: 3D Laplacian: TODO

Lauchli¶

TODO

void Lauchli(Matrix<T> &A, int n, T mu)¶

void Lauchli(DistMatrix<T, U, V> &A, int n, T mu)¶

Legendre¶

The \(n \times n\) tridiagonal Jacobi matrix associated with the Legendre polynomials. Its main diagonal is zero, and the off-diagonal terms are given by

\[\beta_j = \frac{1}{2}\left(1-(2(j+1))^{-2}\right)^{-1/2},\]

where \(\beta_j\) connects the \(j\)’th degree of freedom to the \(j+1\)’th degree of freedom, counting from zero. The eigenvalues of this matrix lie in \([-1,1]\) and are the locations for Gaussian quadrature of order \(n\). The corresponding weights may be found by doubling the square of the first entry of the corresponding normalized eigenvector.

void Legendre(Matrix<F> &A, int n)¶

void Legendre(DistMatrix<F, U, V> &A, int n)¶: Sets the matrix A equal to the \(n \times n\) Jacobi matrix.

Lehmer¶

TODO

void Lehmer(Matrix<F> &L, int n)¶

void Lehmer(DistMatrix<F, U, V> &L, int n)¶

Lotkin¶

TODO

void Lotkin(Matrix<F> &A, int n)¶

void Lotkin(DistMatrix<F, U, V> &A, int n)¶

MinIJ¶

TODO

void MinIJ(Matrix<T> &M, int n)¶

void MinIJ(DistMatrix<T, U, V> &M, int n)¶

NormalFromEVD¶

Form

\[A := Z \Omega Z^H,\]

where \(\Omega\) is a complex diagonal matrix.

void NormalFromEVD(Matrix<Complex<Real>> &A, const Matrix<Complex<Real>> &w, const Matrix<Complex<Real>> &Z)¶

void NormalFromEVD(DistMatrix<Complex<Real>> &A, const DistMatrix<Complex<Real>, VR, STAR> &w, const DistMatrix<Complex<Real>> &Z)¶: The diagonal entries of \(\Omega\) are given by the vector \(w\).

Ones¶

Create an \(m \times n\) matrix of all ones.

void Ones(Matrix<T> &A, int m, int n)¶

void Ones(DistMatrix<T, U, V> &A, int m, int n)¶: Set the matrix A to be an \(m \times n\) matrix of all ones.

Change all entries of the matrix \(A\) to one.

void MakeOnes(Matrix<T> &A)¶

void MakeOnes(DistMatrix<T, U, V> &A)¶: Change the entries of the matrix to ones.

OneTwoOne¶

A “1-2-1” matrix is tridiagonal with a diagonal of all twos and sub- and super-diagonals of all ones.

void OneTwoOne(Matrix<T> &A, int n)¶

void OneTwoOne(DistMatrix<T, U, V> &A, int n)¶: Set A to a \(n \times n\) “1-2-1” matrix.

void MakeOneTwoOne(Matrix<T> &A)¶

void MakeOneTwoOne(DistMatrix<T, U, V> &A)¶: Modify the entries of the square matrix A to be “1-2-1”.

Parter¶

TODO

void Parter(Matrix<F> &P, int n)¶

void Parter(DistMatrix<F, U, V> &P, int n)¶

Pei¶

TODO

void Pei(Matrix<T> &P, int n, T alpha)¶

void Pei(DistMatrix<T, U, V> &P, int n, T alpha)¶

Redheffer¶

TODO

void Redheffer(Matrix<T> &R, int n)¶

void Redheffer(DistMatrix<T, U, V> &R, int n)¶

Riemann¶

TODO

void Riemann(Matrix<T> &R, int n)¶

void Riemann(DistMatrix<T, U, V> &R, int n)¶

Ris¶

TODO

void Ris(Matrix<F> &R, int n)¶

void Ris(DistMatrix<F, U, V> &R, int n)¶

Toeplitz¶

An \(m \times n\) matrix is Toeplitz if there exists a vector \(b\) such that, for each entry \(\alpha_{i,j}\) of \(A\),

\[\alpha_{i,j} = \beta_{i-j+(n-1)},\]

where \(\beta_k\) is the \(k\)’th entry of \(b\).

void Toeplitz(Matrix<T> &A, int m, int n, const std::vector<T> &b)¶

void Toeplitz(DistMatrix<T, U, V> &A, int m, int n, const std::vector<T> &b)¶: Build the matrix A using the generating vector \(b\).

TriW¶

TODO

void TriW(Matrix<T> &A, int m, int n, T alpha, int k)¶

void TriW(DistMatrix<T, U, V> &A, int m, int n, T alpha, int k)¶

Walsh¶

The Walsh matrix of order \(k\) is a \(2^k \times 2^k\) matrix, where

\[\begin{split}W_1 = \left(\begin{array}{cc} 1 & 1 \\ 1 & -1 \end{array}\right),\end{split}\]

and

\[\begin{split}W_k = \left(\begin{array}{cc} W_{k-1} & W_{k-1} \\ W_{k-1} & -W_{k-1} \end{array}\right).\end{split}\]

A binary Walsh matrix changes the bottom-right entry of \(W_1\) from \(-1\) to \(0\).

void Walsh(Matrix<T> &W, int k, bool binary = false)¶

void Walsh(DistMatrix<T, U, V> &W, int k, bool binary = false)¶: Set the matrix \(W\) equal to the \(k\)’th (possibly binary) Walsh matrix.

Wilkinson¶

A Wilkinson matrix of order \(k\) is a tridiagonal matrix with diagonal

\[[k,k-1,k-2,...,1,0,1,...,k-2,k-1,k],\]

and sub- and super-diagonals of all ones.

void Wilkinson(Matrix<T> &W, int k)¶

void Wilkinson(DistMatrix<T, U, V> &W, int k)¶: Set the matrix \(W\) equal to the \(k\)’th Wilkinson matrix.

Zeros¶

Create an \(m \times n\) matrix of all zeros.

void Zeros(Matrix<T> &A, int m, int n)¶

void Zeros(DistMatrix<T, U, V> &A, int m, int n)¶: Set the matrix A to be an \(m \times n\) matrix of all zeros.

Change all entries of the matrix \(A\) to zero.

void MakeZeros(Matrix<T> &A)¶

void MakeZeros(DistMatrix<T, U, V> &A)¶: Change the entries of the matrix to zero.

Deterministic¶

Cauchy¶

Cauchy-like¶

Circulant¶

Diagonal¶

Egorov¶

Extended Kahan¶

Fiedler¶

Forsythe¶

Fourier¶

GCDMatrix¶

Gear¶

Golub/Klema/Stewart¶

Grcar¶

Hankel¶

Hanowa¶

Helmholtz¶

Hilbert¶

HermitianFromEVD¶

Identity¶

Jordan¶

Kahan¶

KMS¶

Laplacian¶

Lauchli¶

Legendre¶

Lehmer¶

Lotkin¶

MinIJ¶

NormalFromEVD¶

Ones¶

OneTwoOne¶

Parter¶

Pei¶

Redheffer¶

Riemann¶

Ris¶

Toeplitz¶

TriW¶

Walsh¶

Wilkinson¶

Zeros¶

Usage documentation

Developer resources