/**
* Return lower triangular factor
*
* @return L
*/
public Matrix getL()
{
Matrix X = new Matrix(m, n);
double[][] L = X.getArray();
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i > j)
{
L[i][j] = LU[i][j];
}
else if (i == j)
{
L[i][j] = 1.0;
}
else
{
L[i][j] = 0.0;
}
}
}
return(X);
}
/**
* Linear algebraic matrix multiplication, A * B
*
* @param B
* another matrix
* @return Matrix product, A * B
* @exception IllegalArgumentException
* Matrix inner dimensions must agree.
*/
public Matrix times(Matrix B)
{
if (B.m != n)
{
throw new ArgumentException(
"Matrix inner dimensions must agree.");
}
Matrix X = new Matrix(m, B.n);
double[][] C = X.getArray();
double[] Bcolj = new double[n];
for (int j = 0; j < B.n; j++)
{
for (int k = 0; k < n; k++)
{
Bcolj[k] = B.A[k][j];
}
for (int i = 0; i < m; i++)
{
double[] Arowi = A[i];
double s = 0;
for (int k = 0; k < n; k++)
{
s += Arowi[k] * Bcolj[k];
}
C[i][j] = s;
}
}
return(X);
}
/**
* Multiply a matrix by a scalar, C = s*A
*
* @param s
* scalar
* @return s*A
*/
public Matrix times(double s)
{
Matrix X = new Matrix(m, n);
double[][] C = X.getArray();
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
C[i][j] = s * A[i][j];
}
}
return(X);
}
/**
* Frobenius norm
*
* @return sqrt of sum of squares of all elements.
*/
// public double normF () {
// double f = 0;
// for (int i = 0; i < m; i++) {
// for (int j = 0; j < n; j++) {
// f = Maths.hypot(f,A[i][j]);
// }
// }
// return f;
// }
/**
* Unary minus
*
* @return -A
*/
public Matrix uminus()
{
Matrix X = new Matrix(m, n);
double[][] C = X.getArray();
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
C[i][j] = -A[i][j];
}
}
return(X);
}
/**
* Matrix transpose.
*
* @return A'
*/
public Matrix transpose()
{
Matrix X = new Matrix(n, m);
double[][] C = X.getArray();
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
C[j][i] = A[i][j];
}
}
return(X);
}
/**
* Generate matrix with random elements
*
* @param m
* Number of rows.
* @param n
* Number of colums.
* @return An m-by-n matrix with uniformly distributed random elements.
*/
public static Matrix random(int m, int n)
{
Matrix A = new Matrix(m, n);
double[][] X = A.getArray();
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
X[i][j] = new Random().NextDouble();
}
}
return(A);
}
/**
* Generate identity matrix
*
* @param m
* Number of rows.
* @param n
* Number of colums.
* @return An m-by-n matrix with ones on the diagonal and zeros elsewhere.
*/
public static Matrix identity(int m, int n)
{
Matrix A = new Matrix(m, n);
double[][] X = A.getArray();
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
X[i][j] = (i == j ? 1.0 : 0.0);
}
}
return(A);
}
/**
* Element-by-element left division, C = A.\B
*
* @param B
* another matrix
* @return A.\B
*/
public Matrix arrayLeftDivide(Matrix B)
{
checkMatrixDimensions(B);
Matrix X = new Matrix(m, n);
double[][] C = X.getArray();
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
C[i][j] = B.A[i][j] / A[i][j];
}
}
return(X);
}
/**
* Get a submatrix.
*
* @param i0
* Initial row index
* @param i1
* Final row index
* @param j0
* Initial column index
* @param j1
* Final column index
* @return A(i0:i1,j0:j1)
* @exception ArrayIndexOutOfBoundsException
* Submatrix indices
*/
public Matrix getMatrix(int i0, int i1, int j0, int j1)
{
Matrix X = new Matrix(i1 - i0 + 1, j1 - j0 + 1);
double[][] B = X.getArray();
for (int i = i0; i <= i1; i++)
{
for (int j = j0; j <= j1; j++)
{
B[i - i0][j - j0] = A[i][j];
}
}
return(X);
}
/**
* Get a submatrix.
*
* @param r
* Array of row indices.
* @param j0
* Initial column index
* @param j1
* Final column index
* @return A(r(:),j0:j1)
* @exception ArrayIndexOutOfBoundsException
* Submatrix indices
*/
public Matrix getMatrix(int[] r, int j0, int j1)
{
Matrix X = new Matrix(r.Length, j1 - j0 + 1);
double[][] B = X.getArray();
for (int i = 0; i < r.Length; i++)
{
for (int j = j0; j <= j1; j++)
{
B[i][j - j0] = A[r[i]][j];
}
}
return(X);
}
/**
* Get a submatrix.
*
* @param i0
* Initial row index
* @param i1
* Final row index
* @param c
* Array of column indices.
* @return A(i0:i1,c(:))
* @exception ArrayIndexOutOfBoundsException
* Submatrix indices
*/
public Matrix getMatrix(int i0, int i1, int[] c)
{
Matrix X = new Matrix(i1 - i0 + 1, c.Length);
double[][] B = X.getArray();
for (int i = i0; i <= i1; i++)
{
for (int j = 0; j < c.Length; j++)
{
B[i - i0][j] = A[i][c[j]];
}
}
return(X);
}
/**
* Get a submatrix.
*
* @param r
* Array of row indices.
* @param c
* Array of column indices.
* @return A(r(:),c(:))
* @exception ArrayIndexOutOfBoundsException
* Submatrix indices
*/
public Matrix getMatrix(int[] r, int[] c)
{
Matrix X = new Matrix(r.Length, c.Length);
double[][] B = X.getArray();
for (int i = 0; i < r.Length; i++)
{
for (int j = 0; j < c.Length; j++)
{
B[i][j] = A[r[i]][c[j]];
}
}
return(X);
}
/**
* Solve A*X = B
*
* @param B
* A Matrix with as many rows as A and any number of columns.
* @return X so that L*U*X = B(piv,:)
* @exception IllegalArgumentException
* Matrix row dimensions must agree.
* @exception ApplicationException
* Matrix is singular.
*/
public Matrix solve(Matrix B)
{
if (B.getRowDimension() != m)
{
throw new ArgumentException(
"Matrix row dimensions must agree.");
}
if (!this.isNonsingular())
{
throw new ApplicationException("Matrix is singular.");
}
// Copy right hand side with pivoting
int nx = B.getColumnDimension();
Matrix Xmat = B.getMatrix(piv, 0, nx - 1);
double[][] X = Xmat.getArray();
// Solve L*Y = B(piv,:)
for (int k = 0; k < n; k++)
{
for (int i = k + 1; i < n; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * LU[i][k];
}
}
}
// Solve U*X = Y;
for (int k = n - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X[k][j] /= LU[k][k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X[i][j] -= X[k][j] * LU[i][k];
}
}
}
return(Xmat);
}
/*
* ------------------------ Public Methods ------------------------
*/
/**
* Construct a matrix from a copy of a 2-D array.
*
* @param A
* Two-dimensional array of doubles.
* @exception IllegalArgumentException
* All rows must have the same length
*/
public static Matrix constructWithCopy(double[][] A)
{
int m = A.Length;
int n = A[0].Length;
Matrix X = new Matrix(m, n);
double[][] C = X.getArray();
for (int i = 0; i < m; i++)
{
if (A[i].Length != n)
{
throw new ArgumentOutOfRangeException(
"All rows must have the same length.");
}
for (int j = 0; j < n; j++)
{
C[i][j] = A[i][j];
}
}
return(X);
}
/**
* Return upper triangular factor
*
* @return U
*/
public Matrix getU()
{
Matrix X = new Matrix(n, n);
double[][] U = X.getArray();
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (i <= j)
{
U[i][j] = LU[i][j];
}
else
{
U[i][j] = 0.0;
}
}
}
return(X);
}
/**
* Linear algebraic matrix multiplication, A * B
*
* @param B
* another matrix
* @return Matrix product, A * B
* @exception IllegalArgumentException
* Matrix inner dimensions must agree.
*/
public Matrix times(Matrix B) {
if (B.m != n) {
throw new ArgumentException(
"Matrix inner dimensions must agree.");
}
Matrix X = new Matrix(m, B.n);
double[][] C = X.getArray();
double[] Bcolj = new double[n];
for (int j = 0; j < B.n; j++) {
for (int k = 0; k < n; k++) {
Bcolj[k] = B.A[k][j];
}
for (int i = 0; i < m; i++) {
double[] Arowi = A[i];
double s = 0;
for (int k = 0; k < n; k++) {
s += Arowi[k] * Bcolj[k];
}
C[i][j] = s;
}
}
return X;
}
/**
* Multiply a matrix by a scalar, C = s*A
*
* @param s
* scalar
* @return s*A
*/
public Matrix times(double s) {
Matrix X = new Matrix(m, n);
double[][] C = X.getArray();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
C[i][j] = s * A[i][j];
}
}
return X;
}
/**
* Element-by-element left division, C = A.\B
*
* @param B
* another matrix
* @return A.\B
*/
public Matrix arrayLeftDivide(Matrix B) {
checkMatrixDimensions(B);
Matrix X = new Matrix(m, n);
double[][] C = X.getArray();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
C[i][j] = B.A[i][j] / A[i][j];
}
}
return X;
}
/**
* Frobenius norm
*
* @return sqrt of sum of squares of all elements.
*/
// public double normF () {
// double f = 0;
// for (int i = 0; i < m; i++) {
// for (int j = 0; j < n; j++) {
// f = Maths.hypot(f,A[i][j]);
// }
// }
// return f;
// }
/**
* Unary minus
*
* @return -A
*/
public Matrix uminus() {
Matrix X = new Matrix(m, n);
double[][] C = X.getArray();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
C[i][j] = -A[i][j];
}
}
return X;
}
/**
* Matrix transpose.
*
* @return A'
*/
public Matrix transpose() {
Matrix X = new Matrix(n, m);
double[][] C = X.getArray();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
C[j][i] = A[i][j];
}
}
return X;
}
/**
* Get a submatrix.
*
* @param r
* Array of row indices.
* @param j0
* Initial column index
* @param j1
* Final column index
* @return A(r(:),j0:j1)
* @exception ArrayIndexOutOfBoundsException
* Submatrix indices
*/
public Matrix getMatrix(int[] r, int j0, int j1) {
Matrix X = new Matrix(r.Length, j1 - j0 + 1);
double[][] B = X.getArray();
for (int i = 0; i < r.Length; i++) {
for (int j = j0; j <= j1; j++) {
B[i][j - j0] = A[r[i]][j];
}
}
return X;
}
/**
* Get a submatrix.
*
* @param i0
* Initial row index
* @param i1
* Final row index
* @param c
* Array of column indices.
* @return A(i0:i1,c(:))
* @exception ArrayIndexOutOfBoundsException
* Submatrix indices
*/
public Matrix getMatrix(int i0, int i1, int[] c) {
Matrix X = new Matrix(i1 - i0 + 1, c.Length);
double[][] B = X.getArray();
for (int i = i0; i <= i1; i++) {
for (int j = 0; j < c.Length; j++) {
B[i - i0][j] = A[i][c[j]];
}
}
return X;
}
/**
* Get a submatrix.
*
* @param r
* Array of row indices.
* @param c
* Array of column indices.
* @return A(r(:),c(:))
* @exception ArrayIndexOutOfBoundsException
* Submatrix indices
*/
public Matrix getMatrix(int[] r, int[] c) {
Matrix X = new Matrix(r.Length, c.Length);
double[][] B = X.getArray();
for (int i = 0; i < r.Length; i++) {
for (int j = 0; j < c.Length; j++) {
B[i][j] = A[r[i]][c[j]];
}
}
return X;
}
/**
* Get a submatrix.
*
* @param i0
* Initial row index
* @param i1
* Final row index
* @param j0
* Initial column index
* @param j1
* Final column index
* @return A(i0:i1,j0:j1)
* @exception ArrayIndexOutOfBoundsException
* Submatrix indices
*/
public Matrix getMatrix(int i0, int i1, int j0, int j1) {
Matrix X = new Matrix(i1 - i0 + 1, j1 - j0 + 1);
double[][] B = X.getArray();
for (int i = i0; i <= i1; i++) {
for (int j = j0; j <= j1; j++) {
B[i - i0][j - j0] = A[i][j];
}
}
return X;
}
/*
* ------------------------ Public Methods ------------------------
*/
/**
* Construct a matrix from a copy of a 2-D array.
*
* @param A
* Two-dimensional array of doubles.
* @exception IllegalArgumentException
* All rows must have the same length
*/
public static Matrix constructWithCopy(double[][] A) {
int m = A.Length;
int n = A[0].Length;
Matrix X = new Matrix(m, n);
double[][] C = X.getArray();
for (int i = 0; i < m; i++) {
if (A[i].Length != n)
{
throw new ArgumentOutOfRangeException(
"All rows must have the same length.");
}
for (int j = 0; j < n; j++) {
C[i][j] = A[i][j];
}
}
return X;
}
/**
* Generate identity matrix
*
* @param m
* Number of rows.
* @param n
* Number of colums.
* @return An m-by-n matrix with ones on the diagonal and zeros elsewhere.
*/
public static Matrix identity(int m, int n) {
Matrix A = new Matrix(m, n);
double[][] X = A.getArray();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
X[i][j] = (i == j ? 1.0 : 0.0);
}
}
return A;
}
/**
* Generate matrix with random elements
*
* @param m
* Number of rows.
* @param n
* Number of colums.
* @return An m-by-n matrix with uniformly distributed random elements.
*/
public static Matrix random(int m, int n) {
Matrix A = new Matrix(m, n);
double[][] X = A.getArray();
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
X[i][j] = new Random().NextDouble();
}
}
return A;
}
/**
* Return upper triangular factor
*
* @return U
*/
public Matrix getU()
{
Matrix X = new Matrix(n, n);
double[][] U = X.getArray();
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (i <= j)
{
U[i][j] = LU[i][j];
}
else
{
U[i][j] = 0.0;
}
}
}
return X;
}
/**
* Return lower triangular factor
*
* @return L
*/
public Matrix getL()
{
Matrix X = new Matrix(m, n);
double[][] L = X.getArray();
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i > j)
{
L[i][j] = LU[i][j];
}
else if (i == j)
{
L[i][j] = 1.0;
}
else
{
L[i][j] = 0.0;
}
}
}
return X;
}
