@Override
public RQ factor(DenseMatrix A) {
if (Q.numRows() != A.numRows())
throw new IllegalArgumentException("Q.numRows() != A.numRows()");
else if (Q.numColumns() != A.numColumns())
throw new IllegalArgumentException("Q.numColumns() != A.numColumns()");
else if (R == null) throw new IllegalArgumentException("R == null");
/*
* Calculate factorisation, and extract the triangular factor
*/
intW info = new intW(0);
LAPACK.getInstance().dgerqf(m, n, A.getData(), Matrices.ld(m), tau, work, work.length, info);
if (info.val < 0) throw new IllegalArgumentException();
R.zero();
for (MatrixEntry e : A)
if (e.column() >= (n - m) + e.row()) R.set(e.row(), e.column() - (n - m), e.get());
/*
* Generate the orthogonal matrix
*/
info.val = 0;
LAPACK
.getInstance()
.dorgrq(m, n, k, A.getData(), Matrices.ld(m), tau, workGen, workGen.length, info);
if (info.val < 0) throw new IllegalArgumentException();
Q.set(A);
return this;
}
/** Solves for <code>B</code>, overwriting it on return */
public DenseMatrix solve(DenseMatrix B) throws MatrixNotSPDException {
if (notspd) throw new MatrixNotSPDException();
if (B.numRows() != n) throw new IllegalArgumentException("B.numRows() != n");
intW info = new intW(0);
if (upper)
LAPACK
.getInstance()
.dpptrs(
UpLo.Upper.netlib(),
Cu.numRows(),
B.numColumns(),
Cu.getData(),
B.getData(),
Matrices.ld(Cu.numRows()),
info);
else
LAPACK
.getInstance()
.dpptrs(
UpLo.Lower.netlib(),
Cl.numRows(),
B.numColumns(),
Cl.getData(),
B.getData(),
Matrices.ld(Cl.numRows()),
info);
if (info.val < 0) throw new IllegalArgumentException();
return B;
}
public void testColsIndexeddense() {
DenseMatrix A = new DenseMatrix("1 5 3; 2 8 5; 1 9 4; 2 5 3").t();
DenseMatrix indexes = new DenseMatrix("2; 1; 1");
DenseMatrix B = A.cols(indexes);
System.out.println(B);
assertTrue(B.equals(new DenseMatrix("1 9 4; 2 8 5; 2 8 5").t()));
}
public void testConstructorByString() {
DenseMatrix foo = new DenseMatrix("1 3; 5 7; 3 5");
assertEquals(3, foo.rows);
assertEquals(2, foo.cols);
assertTrue(foo.equals(new DenseMatrix(new double[][] {{1, 3}, {5, 7}, {3, 5}})));
assertEquals(5.0, foo.get(1, 0));
assertEquals(7.0, foo.get(1, 1));
}
/**
* Do vector operation: {@code a * b^t}
*
* @return the outer product of two vectors
*/
public DenseMatrix outer(DenseVector vec) {
DenseMatrix mat = new DenseMatrix(this.size, vec.size);
for (int i = 0; i < mat.numRows; i++)
for (int j = 0; j < mat.numColumns; j++) mat.set(i, j, get(i) * vec.get(j));
return mat;
}
public void testMultBasic() {
DenseMatrix A = new DenseMatrix(new double[][] {{3, 4}, {5, 6}, {3, 9}});
DenseMatrix B = new DenseMatrix(new double[][] {{2, 9, 1, 2}, {4, 1, 3, 2}});
DenseMatrix C = A.mmul(B);
System.out.println(C);
DenseMatrix Ccorrect =
new DenseMatrix(new double[][] {{22, 31, 15, 14}, {34, 51, 23, 22}, {42, 36, 30, 24}});
assertTrue(C.equals(Ccorrect));
}
public void testldltsolve() {
int K = thousandconstant;
DenseMatrix A_ = rand(K, K);
DenseMatrix A = A_.t().mmul(A_);
DenseMatrix B = rand(K, K);
Timer timer = new Timer();
DenseMatrix X = A.ldltSolve(B);
timer.printTimeCheckMilliseconds();
assertTrue(A.mmul(X).equals(B));
}
public void testSparseDenseMmul() {
int K = 60;
int N = thousandconstant;
SparseMatrixLil A = SparseMatrixLil.rand(K, N);
DenseMatrix B = DenseMatrix.rand(N, K);
Timer timer = new Timer();
DenseMatrix C = A.mmul(B);
timer.printTimeCheckMilliseconds();
DenseMatrix C2 = A.toDense().mmul(B);
assertTrue(C.equals(C2));
}
public void testSvd() {
DenseMatrix A = rand(5, 8);
SvdResult result = A.svd();
assertEquals(A, result.U.mmul(diag(result.S)).mmul(result.V.t()));
Timer timer = new Timer();
A = rand(500, thousandconstant);
timer.printTimeCheckMilliseconds();
result = A.svd();
timer.printTimeCheckMilliseconds();
assertEquals(A, result.U.mmul(diag(result.S)).mmul(result.V.t()));
}
public void testfullpivhouseholderqrsolve() {
int K = thousandconstant;
DenseMatrix A = rand(K, K / 2);
DenseMatrix B = rand(K, K / 3);
Timer timer = new Timer();
DenseMatrix X = A.fullPivHouseholderQRSolve(B);
timer.printTimeCheckMilliseconds();
DenseMatrix AX = A.mmul(X);
double diff = AX.sub(B).abs().sum().s();
assertTrue(diff < 0.01 * K * K / 3);
}
public void testOne() {
DenseMatrix A = ones(3, 3);
System.out.println(A);
DenseMatrix B = ones(3, 3);
System.out.println(B);
DenseMatrix C = A.mmul(B);
System.out.println(C);
assertEquals(3.0, C.get(0, 0));
assertEquals(3.0, C.get(0, 2));
assertEquals(3.0, C.get(2, 0));
assertEquals(3.0, C.get(2, 2));
}
public void testCreateSparse() {
DenseMatrix A = rand(5, 5);
SparseMatrixLil B = A.toSparseLil();
assertTrue(B.equals(B.mmul(eye(5))));
assertTrue(B.equals(B.t().mmul(eye(5)).t()));
B = spzeros(2, 2);
B.append(1, 0, 5);
B.append(0, 1, 7);
B.append(0, 0, 11);
System.out.println(B.toDense());
System.out.println(B.mmul(eye(2)));
assertTrue(B.equals(B.mmul(eye(2))));
}
public void testVarOverCols() {
SparseMatrixLil A = new SparseMatrixLil("1 5 3; 2 8 5");
DenseMatrix B = meanOverCols(A);
assertEquals(1, B.cols);
assertEquals(2, B.rows);
assertEquals(3.0, B.get(0, 0));
assertEquals(5.0, B.get(1, 0));
B = varOverCols(A);
assertEquals(1, B.cols);
assertEquals(2, B.rows);
assertEquals(4.0, B.get(0, 0));
assertEquals(9.0, B.get(1, 0));
}
public void testVarOverRows() {
SparseMatrixLil A = new SparseMatrixLil("1 5 3; 2 8 5");
DenseMatrix B = meanOverRows(A);
assertEquals(3, B.cols);
assertEquals(1, B.rows);
assertEquals(1.5, B.get(0, 0));
assertEquals(6.5, B.get(0, 1));
B = varOverRows(A);
assertEquals(3, B.cols);
assertEquals(1, B.rows);
assertEquals(0.5, B.get(0, 0));
assertEquals(4.5, B.get(0, 1));
}
/**
* Solves for "x" in the equation: this*x = b
*
* @param b must satisfy this.getNumColumns() == b.getDimensionality()
* @return x Vector with dimensions (this.getNumRows())
*/
public Vector solve(final AbstractMTJVector b) {
DenseVector x = new DenseVector(this.getNumColumns());
DenseVector bdense;
if (b instanceof DenseVector) {
bdense = (DenseVector) b;
} else {
bdense = new DenseVector(b);
}
DenseMatrix Adense;
if (this instanceof DenseMatrix) {
Adense = (DenseMatrix) this;
} else {
Adense = new DenseMatrix(this);
}
boolean usePseudoInverse = false;
try {
Adense.solveInto(bdense, x);
usePseudoInverse = false;
} catch (MatrixSingularException e) {
Logger.getLogger(AbstractMTJMatrix.class.getName())
.log(Level.WARNING, "AbstractMTJMatrix.solve(): Matrix is singular.");
usePseudoInverse = true;
}
// Sometimes LAPACK will return NaNs or infs as the solutions, but MTJ
// won't throw the exception, so we need to check for this.
// If we detect this, then we'll use a pseudoinverse
if (!usePseudoInverse) {
for (int i = 0; i < x.getDimensionality(); i++) {
double v = x.getElement(i);
if (Double.isNaN(v) || Double.isInfinite(v)) {
Logger.getLogger(AbstractMTJMatrix.class.getName())
.log(Level.WARNING, "AbstractMTJMatrix.solve(): Solver produced invalid results.");
usePseudoInverse = true;
break;
}
}
}
if (usePseudoInverse) {
// The original LU solver produced a sucky answer, so let's use
// the absurdly expensive SVD least-squares solution
return Adense.pseudoInverse().times(b);
}
return x;
}
public void testElements() {
DenseMatrix A = rand(5, 8);
DenseMatrix B = rand(5, 8);
assertTrue(zeros(5, 8).equals(A.sub(A)));
assertTrue(A.equals(A.add(A).div(2)));
assertTrue(ones(5, 8).equals(A.div(A)));
assertTrue(A.equals(A.mul(A).div(A)));
assertTrue(A.neg().abs().equals(A));
assertTrue(A.neg().add(A).equals(zeros(5, 8)));
}
public void testTranspose() {
DenseMatrix A = rand(5, 8);
DenseMatrix At = A.t();
assertEquals(5, At.cols);
assertEquals(8, At.rows);
assertTrue(A.equals(At.t()));
SparseMatrixLil B = A.toSparseLil();
SparseMatrixLil Bt = B.t();
assertEquals(5, Bt.cols);
assertEquals(8, Bt.rows);
assertTrue(At.equals(Bt));
assertTrue(A.equals(Bt.t()));
}
@Test
public void testFastMultiply() throws Exception {
DenseMatrix a = new DenseMatrix(N, M, generateRandomIntArray(N, M));
DenseMatrix b = new DenseMatrix(M, N, generateRandomIntArray(M, N));
long startTime = System.nanoTime();
DenseMatrix result = a.fastMultiply(b);
long estimatedTime = System.nanoTime() - startTime;
System.out.println("Execution time(ms) fast multiply " + (estimatedTime / 1000000));
int[][] correct = new int[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < M; k++) {
correct[i][j] += a.get(i, k) * b.get(k, j);
}
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
assertTrue(result.get(i, j) == correct[i][j]);
}
}
}
public void testSum() {
DenseMatrix A = new DenseMatrix(new double[][] {{1, 9}, {7, 3}});
assertTrue(new DenseMatrix(new double[][] {{8, 12}}).equals(A.sumOverRows()));
assertTrue(new DenseMatrix(new double[][] {{10}, {10}}).equals(A.sumOverCols()));
SparseMatrixLil B = A.toSparseLil();
assertTrue(new DenseMatrix(new double[][] {{8, 12}}).toSparseLil().equals(B.sumOverRows()));
assertTrue(new DenseMatrix(new double[][] {{10}, {10}}).toSparseLil().equals(B.sumOverCols()));
assertTrue(B.sumOverRows().equals(A.sumOverRows()));
assertTrue(B.sumOverCols().equals(A.sumOverCols()));
assertEquals(B.sum().sum().s(), A.sum().sum().s());
SparseMatrixLil C = spzeros(4, 5);
C.append(1, 2, 5);
C.append(3, 1, 3);
C.append(3, 2, 7);
C.append(1, 4, 11);
System.out.println(C.sumOverRows());
assertTrue(new DenseMatrix(new double[][] {{0, 3, 12, 0, 11}}).equals(C.sumOverRows()));
System.out.println(C.sumOverCols());
assertTrue(new DenseMatrix(new double[][] {{0}, {16}, {0}, {10}}).equals(C.sumOverCols()));
assertEquals(26.0, C.sumOverCols().sumOverRows().s());
assertEquals(26.0, C.sumOverRows().sumOverCols().s());
}
public void testminovercols() {
DenseMatrix A = new DenseMatrix("1 5 3; 2 8 5; 1 9 4; 2 5 3");
DenseMatrix B = A.minOverCols();
assertTrue(B.equals(new DenseMatrix("1; 2; 1; 2")));
}
public static final DenseMatrix meanOverRows(DenseMatrix mat) {
return mat.sumOverRows().div(mat.rows);
}
public void testmaxoverrows() {
DenseMatrix A = new DenseMatrix("1 5 3; 2 8 5; 1 9 4; 2 5 3");
DenseMatrix B = A.maxOverRows();
assertTrue(B.equals(new DenseMatrix("2 9 5")));
}
public void testmaxovercols() {
DenseMatrix A = new DenseMatrix("1 5 3; 2 8 5; 1 9 4; 2 5 3");
DenseMatrix B = A.maxOverCols();
assertTrue(B.equals(new DenseMatrix("5; 8; 9; 5")));
}
public void testnonzerocols() {
DenseMatrix A = new DenseMatrix("1 2 0 3 5 0");
DenseMatrix B = A.nonZeroCols();
assertTrue(B.equals(new DenseMatrix("0; 1; 3; 4")));
}
public void testSlice() {
DenseMatrix A = rand(5, 8);
DenseMatrix B = rand(5, 12);
DenseMatrix C = rand(4, 8);
DenseMatrix AB = A.concatRight(B);
assertTrue(A.equals(AB.cols(0, 8)));
assertTrue(B.equals(AB.cols(8, 20)));
DenseMatrix AC = A.concatDown(C);
assertTrue(A.equals(AC.rows(0, 5)));
assertTrue(C.equals(AC.rows(5, 9)));
}
public void testnonzerorows() {
DenseMatrix A = new DenseMatrix("1; 2; 0; 3; 5; 0");
DenseMatrix B = A.nonZeroRows();
assertTrue(B.equals(new DenseMatrix("0; 1; 3; 4")));
}
public static final DenseMatrix meanOverCols(DenseMatrix mat) {
return mat.sumOverCols().div(mat.cols);
}
public void testToSparse() {
DenseMatrix A = rand(5, 8);
assertTrue(A.equals(A.toSparseLil().toDense()));
}
public static final DenseMatrix varOverRows(DenseMatrix mat) {
return mat.pow(2).sumOverRows().sub(mat.sumOverRows().pow(2).div(mat.rows)).div(mat.rows - 1);
}
public void testMin() {
SparseMatrixLil A = speye(5);
DenseMatrix B = A.minOverCols();
System.out.println(B);
assertEquals(5.0, B.sumOverRows().s());
}