Refine search
public PCA_MTJ_SVD_DenseMatrix(double[][] gramMatrix) { this.gramMatrix = new DenseMatrix(gramMatrix); runSVD(); }
private void runSVD() { int gramDimension = gramMatrix.numRows(); try { svd = new no.uib.cipr.matrix.SVD(gramDimension, gramDimension).factor(gramMatrix); } catch (NotConvergedException e) { throw new RuntimeException(e); } double[] Vt_1D = svd.getVt().getData(); rightEigenvectors = LinearAlgebraUtils.reshape1DArray(Vt_1D, gramDimension, gramDimension); } }
/** * Creates an LU decomposition of the given matrix * * @param A * Matrix to decompose. Not modified * @return The current decomposition */ public static DenseLU factorize(Matrix A) { return new DenseLU(A.numRows(), A.numColumns()).factor(new DenseMatrix( A)); }
public Matrix mult(Matrix B, DenseMatrix C) { if (pivots == null) return super.mult(B, C); checkMultAdd(B, C); C.set(B); LAPACK.getInstance().dlaswp(C.numColumns(), C.getData(), Matrices.ld(C.numRows()), 1, pivots.length, pivots, transposed ? -1 : 1); return C; }
@Override public long process(BenchmarkMatrix[] inputs, BenchmarkMatrix[] outputs, long numTrials) { DenseMatrix matA = inputs[0].getOriginal(); DenseMatrix mod = new DenseMatrix(matA.numRows(),matA.numColumns()); long prev = System.nanoTime(); for( long i = 0; i < numTrials; i++ ) { // in-place operator mod.set(matA); mod.scale(BenchmarkConstants.SCALE); } long elapsedTime = System.nanoTime()-prev; if( outputs != null ) { outputs[0] = new MtjBenchmarkMatrix(mod); } return elapsedTime; } }
/** * Convert an mtj matrix into a 2d double array * * @param mat * @return a double array */ public static double[][] mtjToDoubleArray(no.uib.cipr.matrix.DenseMatrix mat) { final double[][] out = new double[mat.numRows()][mat.numColumns()]; final double[] data = mat.getData(); for (int r = 0; r < out.length; r++) { final double[] outr = out[r]; for (int c = 0; c < out[0].length; c++) { outr[c] = data[r + c * out.length]; } } return out; }
@Override public long process(BenchmarkMatrix[] inputs, BenchmarkMatrix[] outputs, long numTrials) { DenseMatrix matA = inputs[0].getOriginal(); DenseMatrix matB = inputs[1].getOriginal(); DenseMatrix result = new DenseMatrix(matA.numRows(),matB.numColumns()); long prev = System.nanoTime(); for( long i = 0; i < numTrials; i++ ) { matA.mult(matB,result); } long elapsedTime = System.nanoTime()-prev; if( outputs != null ) { outputs[0] = new MtjBenchmarkMatrix(result); } return elapsedTime; } }
@Override public long process(BenchmarkMatrix[] inputs, BenchmarkMatrix[] outputs, long numTrials) { DenseMatrix matA = inputs[0].getOriginal(); DenseMatrix result = new DenseMatrix(matA.numColumns(),matA.numRows()); long prev = System.nanoTime(); for( long i = 0; i < numTrials; i++ ) { matA.transpose(result); } long elapsedTime = System.nanoTime()-prev; if( outputs != null ) { outputs[0] = new MtjBenchmarkMatrix(result); } return elapsedTime; } }
@Override public Matrix multAdd(double alpha, Matrix B, Matrix C) { if (!(B instanceof DenseMatrix) || !(C instanceof DenseMatrix)) return super.multAdd(alpha, B, C); checkMultAdd(B, C); double[] Bd = ((DenseMatrix) B).getData(), Cd = ((DenseMatrix) C) .getData(); BLAS.getInstance().dgemm(Transpose.NoTranspose.netlib(), Transpose.NoTranspose.netlib(), C.numRows(), C.numColumns(), numColumns, alpha, data, Math.max(1, numRows), Bd, Math.max(1, B.numRows()), 1, Cd, Math.max(1, C.numRows())); return C; }
/** * Returns the identity matrix of the given size * * @param size * Number of rows/columns of the matrix * @return Matrix of the given size, with ones on the main diagonal */ public static DenseMatrix identity(int size) { DenseMatrix A = new DenseMatrix(size, size); for (int i = 0; i < size; ++i) A.set(i, i, 1); return A; }
/** * Returns the column pivoting matrix. This function allocates a new Matrix * to be returned, a more cheap option is tu use {@link #getPVector()}. */ public Matrix getP() { Matrix P = new DenseMatrix(jpvt.length, jpvt.length); for (int i = 0; i < jpvt.length; i++) { P.set(jpvt[i], i, 1); } return P; }
@Override public long process(BenchmarkMatrix[] inputs, BenchmarkMatrix[] outputs, long numTrials) { DenseMatrix matA = inputs[0].getOriginal(); DenseMatrix I = Matrices.identity(matA.numColumns()); DenseMatrix inv = new DenseMatrix(matA.numColumns(),matA.numColumns()); long prev = System.nanoTime(); for( long i = 0; i < numTrials; i++ ) { matA.solve(I,inv); } long elapsedTime = System.nanoTime()-prev; if( outputs != null ) { outputs[0] = new MtjBenchmarkMatrix(inv); } return elapsedTime; } }
/** * Convenience method for computing the complete eigenvalue decomposition of * the given matrix * * @param A * Matrix to factorize. Not modified * @return Newly allocated decomposition * @throws NotConvergedException */ public static EVD factorize(Matrix A) throws NotConvergedException { return new EVD(A.numRows()).factor(new DenseMatrix(A)); }
private void estimate_internal(Matrix y, Matrix x) { try { final no.uib.cipr.matrix.DenseMatrix mjtX = new no.uib.cipr.matrix.DenseMatrix(x.getArray()); no.uib.cipr.matrix.SVD svd; svd = no.uib.cipr.matrix.SVD.factorize(mjtX); final Matrix u = MatrixUtils.convert(svd.getU(), svd.getU().numRows(), svd.getS().length); final Matrix v = MatrixUtils.convert(svd.getVt(), svd.getS().length, svd.getVt().numColumns()).transpose(); final Matrix d = MatrixUtils.diag(svd.getS()); weights = v.times(MatrixUtils.pseudoInverse(d)).times(u.transpose()).times(y); } catch (final NotConvergedException e) { throw new RuntimeException(e.getMessage()); } }
@Override public Matrix transBmultAdd(double alpha, Matrix B, Matrix C) { if (!(B instanceof DenseMatrix) || !(C instanceof DenseMatrix)) return super.transBmultAdd(alpha, B, C); checkTransBmultAdd(B, C); double[] Bd = ((DenseMatrix) B).getData(), Cd = ((DenseMatrix) C) .getData(); BLAS.getInstance().dgemm(Transpose.NoTranspose.netlib(), Transpose.Transpose.netlib(), C.numRows(), C.numColumns(), numColumns, alpha, data, Math.max(1, numRows), Bd, Math.max(1, B.numRows()), 1, Cd, Math.max(1, C.numRows())); return C; }
@Override public Matrix transAmultAdd(double alpha, Matrix B, Matrix C) { if (!(B instanceof DenseMatrix) || !(C instanceof DenseMatrix)) return super.transAmultAdd(alpha, B, C); checkTransAmultAdd(B, C); double[] Bd = ((DenseMatrix) B).getData(), Cd = ((DenseMatrix) C) .getData(); BLAS.getInstance().dgemm(Transpose.Transpose.netlib(), Transpose.NoTranspose.netlib(), C.numRows(), C.numColumns(), numRows, alpha, data, Math.max(1, numRows), Bd, Math.max(1, B.numRows()), 1, Cd, Math.max(1, C.numRows())); return C; }
public MTJDenseDoubleMatrix2D(Matrix m) { super(m.getRowCount(), m.getColumnCount()); if (m instanceof MTJDenseDoubleMatrix2D) { this.matrix = ((MTJDenseDoubleMatrix2D) m).matrix.copy(); } else { this.matrix = new DenseMatrix(m.toDoubleArray()); } if (m.getMetaData() != null) { setMetaData(m.getMetaData().clone()); } }
@Override public Vector solve(Vector b, Vector x) { DenseMatrix B = new DenseMatrix(b, false), X = new DenseMatrix(x, false); solve(B, X); return x; }
public MTJDenseDoubleMatrix2D(DenseMatrix m) { super(m.numRows(), m.numColumns()); this.matrix = m; }
@Override public Matrix rank1(double alpha, Matrix C) { if (!(C instanceof DenseMatrix)) return super.rank1(alpha, C); checkRank1(C); double[] Cd = ((DenseMatrix) C).getData(); BLAS.getInstance().dsyrk(uplo.netlib(), Transpose.NoTranspose.netlib(), numRows, C.numColumns(), alpha, Cd, Math.max(1, numRows), 1, data, Math.max(1, numRows)); return this; }