edu.gwu.lintool

Class LinTool

java.lang.Object

edu.gwu.lintool.LinTool

Direct Known Subclasses:

LinToolImpl

public abstract class LinTool
extends java.lang.Object

Abstract class LinTool is what you need to extend in order to provide implementations of methods herein. For convenience an empty implementation is provided in LinToolEmpty. In general, if there's an error or incompatible vectors/matrices, return null or -1 as appropriate (depending on the return type).

Constructor Summary

Constructors

Constructor and Description
LinTool()

Method Summary

Modifier and Type	Method and Description
abstract ComplexNumber[][]	add(ComplexNumber[][] A, ComplexNumber[][] B) Add two complex matrices.
abstract ComplexNumber[]	add(ComplexNumber[] u, ComplexNumber[] v) Add two complex vectors.
abstract double[][]	add(double[][] A, double[][] B) Add two matrices.
abstract double[]	add(double[] u, double[] v) Take in two vectors and return the sum.
abstract double	add(double a, double b)
abstract boolean	approxEquals(double[][] A, double[][] B, double errorTolerance) See if the sum of squared differences of elements is within a tolerance.
abstract boolean	approxEquals(double[] u, double[] v, double errorTolerance) Take in two vectors, and a small number (the error, or tolerance), and check if the squared difference is within the tolerance.
abstract boolean	areColumnsLI(double[][] A) See if the columns of A are linearly independent.
abstract ComplexNumber[]	computeDFT(double[] signal) Compute the DFT of a real-valued signal.
abstract LinResult	computeEigenvalues(double[][] A) Compute eigenvalues, returning an instance of LinResult with the eigenvalues in lambda and the eigenvectors in S.
abstract LinResult	computeEigenvaluesAndVectors(double[][] A) Compute eigenvalues, testing that the matrix is symmetric, returning an instance of LinResult with the eigenvalues in lambda and the eigenvectors in S.
abstract LinResult	computeEigenvaluesAndVectorsSymmetric(double[][] A) Compute eigenvalues, testing that the matrix is symmetric, returning an instance of LinResult with the eigenvalues in lambda and the eigenvectors in S.
abstract ComplexNumber[]	computeFFT(double[] signal) Compute the FFT of a real-valued signal.
abstract ComplexNumber[]	computeInverseDFT(ComplexNumber[] spectrum) Compute the inverse DFT.
abstract ComplexNumber[]	computeInverseFFT(ComplexNumber[] spectrum) Compute the inverse of a real-valued signal.
abstract LinResult	computeQR(double[][] A) Assuming the columns of A are independent, compute the QR decomposition.
abstract LinResult	computeREF(double[][] A, double[] b) Compute the REF and return an instance of LinResult with the ref variable set to the REF and the isPivotColumn variable set correctly.
abstract LinResult	computeRREF(double[][] A, double[] b) Compute the RREF and return an instance of LinResult with the rref variable set to the RREF and the isPivotColumn variable set correctly.
abstract LinResult	computeSpectralDecompositionSymmetric(double[][] A) Compute the spectral decomposition for symmetric matrices, returning an instance of LinResult with the eigenvalues in lambda, the eigenvectors in S and the inverse of S in Sinv.
abstract LinResult	computeSVD(double[][] A) Compute the SVD of A, returning an instance of LinResult with the U,V matrices set, singular values both in Sigma (as matrix) and in sigma (as a vector).
abstract double	cosine(double[] u, double[] v) Return the cosine of the angle between two vectors.
abstract ComplexNumber	dotProduct(ComplexNumber[] u, ComplexNumber[] v) Compute the (Hermitian) dot product.
abstract double	dotProduct(double[] u, double[] v) Take in two vectors and return the dot product. Return -1 if there's an error
abstract double	frobeniusNorm(double[][] A) Compute the Frobenius norm: add the squares of the elements.
abstract double[]	getColumnAsVector(double[][] A, int col) Extract the given column from the matrix and return as a vector.
abstract double[]	getRowAsVector(double[][] A, int row) Extract the given row from the matrix and return as a vector.
abstract LinResult	gramSchmidt(double[][] A) Assuming the columns of A are independent (form a basis), use Gram-Schmidt to find the orthogonal basis.
abstract ComplexNumber[][]	hermitianTranspose(ComplexNumber[][] A) Compute the Hermitian transpose.
abstract LinResult	inverse(double[][] A) Compute the inverse of A and return an instance of LinResult with the inverse in Ainv.
abstract ComplexNumber[][]	makeDFTMatrix(int n) Compute the DFT matrix of size n.
static LinTool	makeInstance()
abstract ComplexNumber[][]	makeInverseDFTMatrix(int n) Compute the inverse DFT matrix of size n.
abstract ComplexNumber[]	matrixVectorMult(ComplexNumber[][] A, ComplexNumber[] v) Product of a complex matrix and a complex vector.
abstract double[]	matrixVectorMult(double[][] A, double[] v) Product of a matrix and a vector.
abstract ComplexNumber[][]	mult(ComplexNumber[][] A, ComplexNumber[][] B) Product of two complex matrices.
abstract double[][]	mult(double[][] A, double[][] B) Product of two matrices.
abstract double	norm(ComplexNumber[] v) Compute the norm.
abstract double	norm(double[] v) Compute the norm of a vector.
abstract LinResult	pseudoInverse(double[][] A) Use the LinToolLibrary's SVD to compute the pseudoinverse, returning an instance of LinResult with the pseudoinverse in A_plus.
abstract ComplexNumber[]	scalarProduct(ComplexNumber alpha, ComplexNumber[] v) Compute the scalar product (where the scalar is complex).
abstract ComplexNumber[][]	scalarProduct(ComplexNumber alpha, ComplexNumber[][] A) Product of scalar (complex) and a complex matrix.
abstract double[]	scalarProduct(double alpha, double[] v) Take in a scalar and a vector and return the scalar product.
abstract double[][]	scalarProduct(double alpha, double[][] A) Scalar product: scalar times a matrix.
abstract LinResult	solveFromREF(double[][] A, double[] b) Solve for x in Ax=b using REF and return an instance of LinResult with ref, isPivotColumn, pivotRow, rank, x, solutionExists, isUniqueSolution.
abstract LinResult	solveFromRREF(double[][] A, double[] b) Solve for x in Ax=b using RREF and return an instance of LinResult with x, rref, isPivotColumn, pivotRow, rank, solutionExists, isUniqueSolution.
abstract LinResult	solveLeastSquares(double[][] A, double[] b) Use the LinToolLibrary's SVD to solve least-squares, returning an instance of LinResult with the solution in x.
abstract double[][]	transpose(double[][] A) Matrix transpose.
abstract double[][]	vectorLeftMult(double[] u, double[] v) Left multiplication of two vectors: results in a matrix such that A[i][j]=u[i]*v[j]. This is not tested by LinTool. Write your own tests.
abstract double[]	vectorMatrixMult(double[] v, double[][] A) Product of a vector and a matrix (left multiplication).

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LinTool

public LinTool()

Method Detail

add

public abstract double add(double a,
                           double b)

add

public abstract double[] add(double[] u,
                             double[] v)

Take in two vectors and return the sum.

norm

public abstract double norm(double[] v)

Compute the norm of a vector.

dotProduct

public abstract double dotProduct(double[] u,
                                  double[] v)

Take in two vectors and return the dot product.

scalarProduct

public abstract double[] scalarProduct(double alpha,
                                       double[] v)

Take in a scalar and a vector and return the scalar product.

approxEquals

public abstract boolean approxEquals(double[] u,
                                     double[] v,
                                     double errorTolerance)

Take in two vectors, and a small number (the error, or tolerance), and check if the squared difference is within the tolerance. Also, return false if the vectors are not of the same length.

cosine

public abstract double cosine(double[] u,
                              double[] v)

Return the cosine of the angle between two vectors.

add

public abstract double[][] add(double[][] A,
                               double[][] B)

Add two matrices. Return null if not compatible.

scalarProduct

public abstract double[][] scalarProduct(double alpha,
                                         double[][] A)

Scalar product: scalar times a matrix.

mult

public abstract double[][] mult(double[][] A,
                                double[][] B)

Product of two matrices. Return null if not compatible.

matrixVectorMult

public abstract double[] matrixVectorMult(double[][] A,
                                          double[] v)

Product of a matrix and a vector. Return null if not compatible.

vectorMatrixMult

public abstract double[] vectorMatrixMult(double[] v,
                                          double[][] A)

Product of a vector and a matrix (left multiplication). Return null if not compatible.

vectorLeftMult

public abstract double[][] vectorLeftMult(double[] u,
                                          double[] v)

Left multiplication of two vectors. Return null if not compatible.

transpose

public abstract double[][] transpose(double[][] A)

Matrix transpose.

frobeniusNorm

public abstract double frobeniusNorm(double[][] A)

Compute the Frobenius norm: add the squares of the elements. Then take the square root of that sum.

approxEquals

public abstract boolean approxEquals(double[][] A,
                                     double[][] B,
                                     double errorTolerance)

See if the sum of squared differences of elements is within a tolerance.

getColumnAsVector

public abstract double[] getColumnAsVector(double[][] A,
                                           int col)

Extract the given column from the matrix and return as a vector.

getRowAsVector

public abstract double[] getRowAsVector(double[][] A,
                                        int row)

Extract the given row from the matrix and return as a vector.

computeREF

public abstract LinResult computeREF(double[][] A,
                                     double[] b)

Compute the REF and return an instance of LinResult with the ref variable set to the REF. Also properly set isPivotColumn, pivotRow, and rank.

computeRREF

public abstract LinResult computeRREF(double[][] A,
                                      double[] b)

Compute the RREF and return an instance of LinResult with the rref variable set to the REF. Also properly set isPivotColumn, pivotRow, rank.

solveFromREF

public abstract LinResult solveFromREF(double[][] A,
                                       double[] b)

Solve for x in Ax=b using REF and return an instance of LinResult with x, solutionExists, isUniqueSolution.

solveFromRREF

public abstract LinResult solveFromRREF(double[][] A,
                                        double[] b)

Solve for x in Ax=b using RREF and return an instance of LinResult with x, solutionExists, isUniqueSolution.

inverse

public abstract LinResult inverse(double[][] A)

Compute the inverse of A and return an instance of LinResult with the inverse in Ainv.

areColumnsLI

public abstract boolean areColumnsLI(double[][] A)

See if the columns of A are linearly independent.

gramSchmidt

public abstract LinResult gramSchmidt(double[][] A)

Assuming the columns of A are independent (form a basis), use Gram-Schmidt to find the orthogonal basis. Return an instance of LinResult with the orthogonal vectors of the basis in V and their orthonormal versions in Q.

computeQR

public abstract LinResult computeQR(double[][] A)

Assuming the columns of A are independent, compute the QR decomposition. Return an instance of LinResult with the orthogonal vectors of the basis in Q and the coefficients in R.

computeEigenvalues

public abstract LinResult computeEigenvalues(double[][] A)

Compute eigenvalues, returning an instance of LinResult with the eigenvalues in lambda and the eigenvectors in S.

computeEigenvaluesAndVectorsSymmetric

public abstract LinResult computeEigenvaluesAndVectorsSymmetric(double[][] A)

Compute eigenvalues, testing that the matrix is symmetric, returning an instance of LinResult with the eigenvalues in lambda and the eigenvectors in S.

computeEigenvaluesAndVectors

public abstract LinResult computeEigenvaluesAndVectors(double[][] A)

Compute eigenvalues, testing that the matrix is symmetric, returning an instance of LinResult with the eigenvalues in lambda and the eigenvectors in S.

computeSpectralDecompositionSymmetric

public abstract LinResult computeSpectralDecompositionSymmetric(double[][] A)

Compute the spectral decomposition for symmetric matrices, returning an instance of LinResult with the eigenvalues in lambda, the eigenvectors in S and the inverse of S in Sinv.

computeSVD

public abstract LinResult computeSVD(double[][] A)

Compute the SVD of A, returning an instance of LinResult with the U,V matrices set, singular values both in Sigma (as matrix) and in sigma (as a vector). The matrices returned should be trimmed down to match the rank, which should be set in rank. And U,V,Sigma,sigma need to be sorted in decreasing order of the singular values.

pseudoInverse

public abstract LinResult pseudoInverse(double[][] A)

Use the LinToolLibrary's SVD to compute the pseudoinverse, returning an instance of LinResult with the pseudoinverse in A_plus.

solveLeastSquares

public abstract LinResult solveLeastSquares(double[][] A,
                                            double[] b)

Use the LinToolLibrary's SVD to solve least-squares, returning an instance of LinResult with the solution in x.

add

public abstract ComplexNumber[] add(ComplexNumber[] u,
                                    ComplexNumber[] v)

Add two complex vectors.

norm

public abstract double norm(ComplexNumber[] v)

Compute the norm.

dotProduct

public abstract ComplexNumber dotProduct(ComplexNumber[] u,
                                         ComplexNumber[] v)

Compute the (Hermitian) dot product.

scalarProduct

public abstract ComplexNumber[] scalarProduct(ComplexNumber alpha,
                                              ComplexNumber[] v)

Compute the scalar product (where the scalar is complex).

add

public abstract ComplexNumber[][] add(ComplexNumber[][] A,
                                      ComplexNumber[][] B)

Add two complex matrices.

scalarProduct

public abstract ComplexNumber[][] scalarProduct(ComplexNumber alpha,
                                                ComplexNumber[][] A)

Product of scalar (complex) and a complex matrix.

mult

public abstract ComplexNumber[][] mult(ComplexNumber[][] A,
                                       ComplexNumber[][] B)

Product of two complex matrices.

matrixVectorMult

public abstract ComplexNumber[] matrixVectorMult(ComplexNumber[][] A,
                                                 ComplexNumber[] v)

Product of a complex matrix and a complex vector.

hermitianTranspose

public abstract ComplexNumber[][] hermitianTranspose(ComplexNumber[][] A)

Compute the Hermitian transpose.

makeDFTMatrix

public abstract ComplexNumber[][] makeDFTMatrix(int n)

Compute the DFT matrix of size n.

makeInverseDFTMatrix

public abstract ComplexNumber[][] makeInverseDFTMatrix(int n)

Compute the inverse DFT matrix of size n.

computeDFT

public abstract ComplexNumber[] computeDFT(double[] signal)

Compute the DFT of a real-valued signal.

computeInverseDFT

public abstract ComplexNumber[] computeInverseDFT(ComplexNumber[] spectrum)

Compute the inverse DFT.

computeFFT

public abstract ComplexNumber[] computeFFT(double[] signal)

Compute the FFT of a real-valued signal. Check that the length is a power-of-2.

computeInverseFFT

public abstract ComplexNumber[] computeInverseFFT(ComplexNumber[] spectrum)

Compute the inverse of a real-valued signal. Check that the length is a power-of-2.

makeInstance

public static LinTool makeInstance()