@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()); }