//
|
// Source code recreated from a .class file by IntelliJ IDEA
|
// (powered by FernFlower decompiler)
|
//
|
|
package com.jisuan.Jama;
|
|
//import Jama.util.Maths;
|
import com.jisuan.Jama.util.Maths;
|
|
import java.io.BufferedReader;
|
import java.io.IOException;
|
import java.io.PrintWriter;
|
import java.io.Serializable;
|
import java.io.StreamTokenizer;
|
import java.text.DecimalFormat;
|
import java.text.DecimalFormatSymbols;
|
import java.text.NumberFormat;
|
import java.util.Locale;
|
import java.util.Vector;
|
|
public class Matrix implements Cloneable, Serializable {
|
private double[][] A;
|
private int m;
|
private int n;
|
private static final long serialVersionUID = 1L;
|
|
public Matrix(int var1, int var2) {
|
this.m = var1;
|
this.n = var2;
|
this.A = new double[var1][var2];
|
}
|
|
public Matrix(int var1, int var2, double var3) {
|
this.m = var1;
|
this.n = var2;
|
this.A = new double[var1][var2];
|
|
for(int var5 = 0; var5 < var1; ++var5) {
|
for(int var6 = 0; var6 < var2; ++var6) {
|
this.A[var5][var6] = var3;
|
}
|
}
|
|
}
|
|
public Matrix(double[][] var1) {
|
this.m = var1.length;
|
this.n = var1[0].length;
|
|
for(int var2 = 0; var2 < this.m; ++var2) {
|
if (var1[var2].length != this.n) {
|
throw new IllegalArgumentException("All rows must have the same length.");
|
}
|
}
|
|
this.A = var1;
|
}
|
|
public Matrix(double[][] var1, int var2, int var3) {
|
this.A = var1;
|
this.m = var2;
|
this.n = var3;
|
}
|
|
public Matrix(double[] var1, int var2) {
|
this.m = var2;
|
this.n = var2 != 0 ? var1.length / var2 : 0;
|
if (var2 * this.n != var1.length) {
|
throw new IllegalArgumentException("Array length must be a multiple of m.");
|
} else {
|
this.A = new double[var2][this.n];
|
|
for(int var3 = 0; var3 < var2; ++var3) {
|
for(int var4 = 0; var4 < this.n; ++var4) {
|
this.A[var3][var4] = var1[var3 + var4 * var2];
|
}
|
}
|
|
}
|
}
|
|
public static Matrix constructWithCopy(double[][] var0) {
|
int var1 = var0.length;
|
int var2 = var0[0].length;
|
Matrix var3 = new Matrix(var1, var2);
|
double[][] var4 = var3.getArray();
|
|
for(int var5 = 0; var5 < var1; ++var5) {
|
if (var0[var5].length != var2) {
|
throw new IllegalArgumentException("All rows must have the same length.");
|
}
|
|
for(int var6 = 0; var6 < var2; ++var6) {
|
var4[var5][var6] = var0[var5][var6];
|
}
|
}
|
|
return var3;
|
}
|
|
public Matrix copy() {
|
Matrix var1 = new Matrix(this.m, this.n);
|
double[][] var2 = var1.getArray();
|
|
for(int var3 = 0; var3 < this.m; ++var3) {
|
for(int var4 = 0; var4 < this.n; ++var4) {
|
var2[var3][var4] = this.A[var3][var4];
|
}
|
}
|
|
return var1;
|
}
|
|
public Object clone() {
|
return this.copy();
|
}
|
|
public double[][] getArray() {
|
return this.A;
|
}
|
|
public double[][] getArrayCopy() {
|
double[][] var1 = new double[this.m][this.n];
|
|
for(int var2 = 0; var2 < this.m; ++var2) {
|
for(int var3 = 0; var3 < this.n; ++var3) {
|
var1[var2][var3] = this.A[var2][var3];
|
}
|
}
|
|
return var1;
|
}
|
|
public double[] getColumnPackedCopy() {
|
double[] var1 = new double[this.m * this.n];
|
|
for(int var2 = 0; var2 < this.m; ++var2) {
|
for(int var3 = 0; var3 < this.n; ++var3) {
|
var1[var2 + var3 * this.m] = this.A[var2][var3];
|
}
|
}
|
|
return var1;
|
}
|
|
public double[] getRowPackedCopy() {
|
double[] var1 = new double[this.m * this.n];
|
|
for(int var2 = 0; var2 < this.m; ++var2) {
|
for(int var3 = 0; var3 < this.n; ++var3) {
|
var1[var2 * this.n + var3] = this.A[var2][var3];
|
}
|
}
|
|
return var1;
|
}
|
|
public int getRowDimension() {
|
return this.m;
|
}
|
|
public int getColumnDimension() {
|
return this.n;
|
}
|
|
public double get(int var1, int var2) {
|
return this.A[var1][var2];
|
}
|
|
public Matrix getMatrix(int var1, int var2, int var3, int var4) {
|
Matrix var5 = new Matrix(var2 - var1 + 1, var4 - var3 + 1);
|
double[][] var6 = var5.getArray();
|
|
try {
|
for(int var7 = var1; var7 <= var2; ++var7) {
|
for(int var8 = var3; var8 <= var4; ++var8) {
|
var6[var7 - var1][var8 - var3] = this.A[var7][var8];
|
}
|
}
|
|
return var5;
|
} catch (ArrayIndexOutOfBoundsException var9) {
|
throw new ArrayIndexOutOfBoundsException("Submatrix indices");
|
}
|
}
|
|
public Matrix getMatrix(int[] var1, int[] var2) {
|
Matrix var3 = new Matrix(var1.length, var2.length);
|
double[][] var4 = var3.getArray();
|
|
try {
|
for(int var5 = 0; var5 < var1.length; ++var5) {
|
for(int var6 = 0; var6 < var2.length; ++var6) {
|
var4[var5][var6] = this.A[var1[var5]][var2[var6]];
|
}
|
}
|
|
return var3;
|
} catch (ArrayIndexOutOfBoundsException var7) {
|
throw new ArrayIndexOutOfBoundsException("Submatrix indices");
|
}
|
}
|
|
public Matrix getMatrix(int var1, int var2, int[] var3) {
|
Matrix var4 = new Matrix(var2 - var1 + 1, var3.length);
|
double[][] var5 = var4.getArray();
|
|
try {
|
for(int var6 = var1; var6 <= var2; ++var6) {
|
for(int var7 = 0; var7 < var3.length; ++var7) {
|
var5[var6 - var1][var7] = this.A[var6][var3[var7]];
|
}
|
}
|
|
return var4;
|
} catch (ArrayIndexOutOfBoundsException var8) {
|
throw new ArrayIndexOutOfBoundsException("Submatrix indices");
|
}
|
}
|
|
public Matrix getMatrix(int[] var1, int var2, int var3) {
|
Matrix var4 = new Matrix(var1.length, var3 - var2 + 1);
|
double[][] var5 = var4.getArray();
|
|
try {
|
for(int var6 = 0; var6 < var1.length; ++var6) {
|
for(int var7 = var2; var7 <= var3; ++var7) {
|
var5[var6][var7 - var2] = this.A[var1[var6]][var7];
|
}
|
}
|
|
return var4;
|
} catch (ArrayIndexOutOfBoundsException var8) {
|
throw new ArrayIndexOutOfBoundsException("Submatrix indices");
|
}
|
}
|
|
public void set(int var1, int var2, double var3) {
|
this.A[var1][var2] = var3;
|
}
|
|
public void setMatrix(int var1, int var2, int var3, int var4, Matrix var5) {
|
try {
|
for(int var6 = var1; var6 <= var2; ++var6) {
|
for(int var7 = var3; var7 <= var4; ++var7) {
|
this.A[var6][var7] = var5.get(var6 - var1, var7 - var3);
|
}
|
}
|
|
} catch (ArrayIndexOutOfBoundsException var8) {
|
throw new ArrayIndexOutOfBoundsException("Submatrix indices");
|
}
|
}
|
|
public void setMatrix(int[] var1, int[] var2, Matrix var3) {
|
try {
|
for(int var4 = 0; var4 < var1.length; ++var4) {
|
for(int var5 = 0; var5 < var2.length; ++var5) {
|
this.A[var1[var4]][var2[var5]] = var3.get(var4, var5);
|
}
|
}
|
|
} catch (ArrayIndexOutOfBoundsException var6) {
|
throw new ArrayIndexOutOfBoundsException("Submatrix indices");
|
}
|
}
|
|
public void setMatrix(int[] var1, int var2, int var3, Matrix var4) {
|
try {
|
for(int var5 = 0; var5 < var1.length; ++var5) {
|
for(int var6 = var2; var6 <= var3; ++var6) {
|
this.A[var1[var5]][var6] = var4.get(var5, var6 - var2);
|
}
|
}
|
|
} catch (ArrayIndexOutOfBoundsException var7) {
|
throw new ArrayIndexOutOfBoundsException("Submatrix indices");
|
}
|
}
|
|
public void setMatrix(int var1, int var2, int[] var3, Matrix var4) {
|
try {
|
for(int var5 = var1; var5 <= var2; ++var5) {
|
for(int var6 = 0; var6 < var3.length; ++var6) {
|
this.A[var5][var3[var6]] = var4.get(var5 - var1, var6);
|
}
|
}
|
|
} catch (ArrayIndexOutOfBoundsException var7) {
|
throw new ArrayIndexOutOfBoundsException("Submatrix indices");
|
}
|
}
|
|
public Matrix transpose() {
|
Matrix var1 = new Matrix(this.n, this.m);
|
double[][] var2 = var1.getArray();
|
|
for(int var3 = 0; var3 < this.m; ++var3) {
|
for(int var4 = 0; var4 < this.n; ++var4) {
|
var2[var4][var3] = this.A[var3][var4];
|
}
|
}
|
|
return var1;
|
}
|
|
public double norm1() {
|
double var1 = 0.0;
|
|
for(int var3 = 0; var3 < this.n; ++var3) {
|
double var4 = 0.0;
|
|
for(int var6 = 0; var6 < this.m; ++var6) {
|
var4 += Math.abs(this.A[var6][var3]);
|
}
|
|
var1 = Math.max(var1, var4);
|
}
|
|
return var1;
|
}
|
|
public double norm2() {
|
return (new SingularValueDecomposition(this)).norm2();
|
}
|
|
public double normInf() {
|
double var1 = 0.0;
|
|
for(int var3 = 0; var3 < this.m; ++var3) {
|
double var4 = 0.0;
|
|
for(int var6 = 0; var6 < this.n; ++var6) {
|
var4 += Math.abs(this.A[var3][var6]);
|
}
|
|
var1 = Math.max(var1, var4);
|
}
|
|
return var1;
|
}
|
|
public double normF() {
|
double var1 = 0.0;
|
|
for(int var3 = 0; var3 < this.m; ++var3) {
|
for(int var4 = 0; var4 < this.n; ++var4) {
|
var1 = Maths.hypot(var1, this.A[var3][var4]);
|
}
|
}
|
|
return var1;
|
}
|
|
public Matrix uminus() {
|
Matrix var1 = new Matrix(this.m, this.n);
|
double[][] var2 = var1.getArray();
|
|
for(int var3 = 0; var3 < this.m; ++var3) {
|
for(int var4 = 0; var4 < this.n; ++var4) {
|
var2[var3][var4] = -this.A[var3][var4];
|
}
|
}
|
|
return var1;
|
}
|
|
public Matrix plus(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
Matrix var2 = new Matrix(this.m, this.n);
|
double[][] var3 = var2.getArray();
|
|
for(int var4 = 0; var4 < this.m; ++var4) {
|
for(int var5 = 0; var5 < this.n; ++var5) {
|
var3[var4][var5] = this.A[var4][var5] + var1.A[var4][var5];
|
}
|
}
|
|
return var2;
|
}
|
|
public Matrix plusEquals(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
|
for(int var2 = 0; var2 < this.m; ++var2) {
|
for(int var3 = 0; var3 < this.n; ++var3) {
|
this.A[var2][var3] += var1.A[var2][var3];
|
}
|
}
|
|
return this;
|
}
|
|
public Matrix minus(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
Matrix var2 = new Matrix(this.m, this.n);
|
double[][] var3 = var2.getArray();
|
|
for(int var4 = 0; var4 < this.m; ++var4) {
|
for(int var5 = 0; var5 < this.n; ++var5) {
|
var3[var4][var5] = this.A[var4][var5] - var1.A[var4][var5];
|
}
|
}
|
|
return var2;
|
}
|
|
public Matrix minusEquals(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
|
for(int var2 = 0; var2 < this.m; ++var2) {
|
for(int var3 = 0; var3 < this.n; ++var3) {
|
this.A[var2][var3] -= var1.A[var2][var3];
|
}
|
}
|
|
return this;
|
}
|
|
public Matrix arrayTimes(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
Matrix var2 = new Matrix(this.m, this.n);
|
double[][] var3 = var2.getArray();
|
|
for(int var4 = 0; var4 < this.m; ++var4) {
|
for(int var5 = 0; var5 < this.n; ++var5) {
|
var3[var4][var5] = this.A[var4][var5] * var1.A[var4][var5];
|
}
|
}
|
|
return var2;
|
}
|
|
public Matrix arrayTimesEquals(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
|
for(int var2 = 0; var2 < this.m; ++var2) {
|
for(int var3 = 0; var3 < this.n; ++var3) {
|
this.A[var2][var3] *= var1.A[var2][var3];
|
}
|
}
|
|
return this;
|
}
|
|
public Matrix arrayRightDivide(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
Matrix var2 = new Matrix(this.m, this.n);
|
double[][] var3 = var2.getArray();
|
|
for(int var4 = 0; var4 < this.m; ++var4) {
|
for(int var5 = 0; var5 < this.n; ++var5) {
|
var3[var4][var5] = this.A[var4][var5] / var1.A[var4][var5];
|
}
|
}
|
|
return var2;
|
}
|
|
public Matrix arrayRightDivideEquals(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
|
for(int var2 = 0; var2 < this.m; ++var2) {
|
for(int var3 = 0; var3 < this.n; ++var3) {
|
this.A[var2][var3] /= var1.A[var2][var3];
|
}
|
}
|
|
return this;
|
}
|
|
public Matrix arrayLeftDivide(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
Matrix var2 = new Matrix(this.m, this.n);
|
double[][] var3 = var2.getArray();
|
|
for(int var4 = 0; var4 < this.m; ++var4) {
|
for(int var5 = 0; var5 < this.n; ++var5) {
|
var3[var4][var5] = var1.A[var4][var5] / this.A[var4][var5];
|
}
|
}
|
|
return var2;
|
}
|
|
public Matrix arrayLeftDivideEquals(Matrix var1) {
|
this.checkMatrixDimensions(var1);
|
|
for(int var2 = 0; var2 < this.m; ++var2) {
|
for(int var3 = 0; var3 < this.n; ++var3) {
|
this.A[var2][var3] = var1.A[var2][var3] / this.A[var2][var3];
|
}
|
}
|
|
return this;
|
}
|
|
public Matrix times(double var1) {
|
Matrix var3 = new Matrix(this.m, this.n);
|
double[][] var4 = var3.getArray();
|
|
for(int var5 = 0; var5 < this.m; ++var5) {
|
for(int var6 = 0; var6 < this.n; ++var6) {
|
var4[var5][var6] = var1 * this.A[var5][var6];
|
}
|
}
|
|
return var3;
|
}
|
|
public Matrix timesEquals(double var1) {
|
for(int var3 = 0; var3 < this.m; ++var3) {
|
for(int var4 = 0; var4 < this.n; ++var4) {
|
this.A[var3][var4] = var1 * this.A[var3][var4];
|
}
|
}
|
|
return this;
|
}
|
|
public Matrix times(Matrix var1) {
|
if (var1.m != this.n) {
|
throw new IllegalArgumentException("Matrix inner dimensions must agree.");
|
} else {
|
Matrix var2 = new Matrix(this.m, var1.n);
|
double[][] var3 = var2.getArray();
|
double[] var4 = new double[this.n];
|
|
for(int var5 = 0; var5 < var1.n; ++var5) {
|
int var6;
|
for(var6 = 0; var6 < this.n; ++var6) {
|
var4[var6] = var1.A[var6][var5];
|
}
|
|
for(var6 = 0; var6 < this.m; ++var6) {
|
double[] var7 = this.A[var6];
|
double var8 = 0.0;
|
|
for(int var10 = 0; var10 < this.n; ++var10) {
|
var8 += var7[var10] * var4[var10];
|
}
|
|
var3[var6][var5] = var8;
|
}
|
}
|
|
return var2;
|
}
|
}
|
|
public LUDecomposition lu() {
|
return new LUDecomposition(this);
|
}
|
|
public QRDecomposition qr() {
|
return new QRDecomposition(this);
|
}
|
|
public CholeskyDecomposition chol() {
|
return new CholeskyDecomposition(this);
|
}
|
|
public SingularValueDecomposition svd() {
|
return new SingularValueDecomposition(this);
|
}
|
|
public EigenvalueDecomposition eig() {
|
return new EigenvalueDecomposition(this);
|
}
|
|
public Matrix solve(Matrix var1) {
|
return this.m == this.n ? (new LUDecomposition(this)).solve(var1) : (new QRDecomposition(this)).solve(var1);
|
}
|
|
public Matrix solveTranspose(Matrix var1) {
|
return this.transpose().solve(var1.transpose());
|
}
|
|
public Matrix inverse() {
|
return this.solve(identity(this.m, this.m));
|
}
|
|
public double det() {
|
return (new LUDecomposition(this)).det();
|
}
|
|
public int rank() {
|
return (new SingularValueDecomposition(this)).rank();
|
}
|
|
public double cond() {
|
return (new SingularValueDecomposition(this)).cond();
|
}
|
|
public double trace() {
|
double var1 = 0.0;
|
|
for(int var3 = 0; var3 < Math.min(this.m, this.n); ++var3) {
|
var1 += this.A[var3][var3];
|
}
|
|
return var1;
|
}
|
|
public static Matrix random(int var0, int var1) {
|
Matrix var2 = new Matrix(var0, var1);
|
double[][] var3 = var2.getArray();
|
|
for(int var4 = 0; var4 < var0; ++var4) {
|
for(int var5 = 0; var5 < var1; ++var5) {
|
var3[var4][var5] = Math.random();
|
}
|
}
|
|
return var2;
|
}
|
|
public static Matrix identity(int var0, int var1) {
|
Matrix var2 = new Matrix(var0, var1);
|
double[][] var3 = var2.getArray();
|
|
for(int var4 = 0; var4 < var0; ++var4) {
|
for(int var5 = 0; var5 < var1; ++var5) {
|
var3[var4][var5] = var4 == var5 ? 1.0 : 0.0;
|
}
|
}
|
|
return var2;
|
}
|
|
public void print(int var1, int var2) {
|
this.print(new PrintWriter(System.out, true), var1, var2);
|
}
|
|
public void print(PrintWriter var1, int var2, int var3) {
|
DecimalFormat var4 = new DecimalFormat();
|
var4.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.US));
|
var4.setMinimumIntegerDigits(1);
|
var4.setMaximumFractionDigits(var3);
|
var4.setMinimumFractionDigits(var3);
|
var4.setGroupingUsed(false);
|
this.print(var1, var4, var2 + 2);
|
}
|
|
public void print(NumberFormat var1, int var2) {
|
this.print(new PrintWriter(System.out, true), var1, var2);
|
}
|
|
public void print(PrintWriter var1, NumberFormat var2, int var3) {
|
var1.println();
|
|
for(int var4 = 0; var4 < this.m; ++var4) {
|
for(int var5 = 0; var5 < this.n; ++var5) {
|
String var6 = var2.format(this.A[var4][var5]);
|
int var7 = Math.max(1, var3 - var6.length());
|
|
for(int var8 = 0; var8 < var7; ++var8) {
|
var1.print(' ');
|
}
|
|
var1.print(var6);
|
}
|
|
var1.println();
|
}
|
|
var1.println();
|
}
|
|
public static Matrix read(BufferedReader var0) throws IOException {
|
StreamTokenizer var1 = new StreamTokenizer(var0);
|
var1.resetSyntax();
|
var1.wordChars(0, 255);
|
var1.whitespaceChars(0, 32);
|
var1.eolIsSignificant(true);
|
Vector var2 = new Vector();
|
|
while(var1.nextToken() == 10) {
|
}
|
|
if (var1.ttype == -1) {
|
throw new IOException("Unexpected EOF on matrix read.");
|
} else {
|
do {
|
var2.addElement(Double.valueOf(var1.sval));
|
} while(var1.nextToken() == -3);
|
|
int var3 = var2.size();
|
double[] var4 = new double[var3];
|
|
for(int var5 = 0; var5 < var3; ++var5) {
|
var4[var5] = (Double)var2.elementAt(var5);
|
}
|
|
Vector var8 = new Vector();
|
var8.addElement(var4);
|
|
int var6;
|
do {
|
if (var1.nextToken() != -3) {
|
var6 = var8.size();
|
double[][] var7 = new double[var6][];
|
var8.copyInto(var7);
|
return new Matrix(var7);
|
}
|
|
var8.addElement(var4 = new double[var3]);
|
var6 = 0;
|
|
do {
|
if (var6 >= var3) {
|
throw new IOException("Row " + var8.size() + " is too long.");
|
}
|
|
var4[var6++] = Double.valueOf(var1.sval);
|
} while(var1.nextToken() == -3);
|
} while(var6 >= var3);
|
|
throw new IOException("Row " + var8.size() + " is too short.");
|
}
|
}
|
|
private void checkMatrixDimensions(Matrix var1) {
|
if (var1.m != this.m || var1.n != this.n) {
|
throw new IllegalArgumentException("Matrix dimensions must agree.");
|
}
|
}
|
}
|
