@Override public double[] getVariances() { return svd.getS(); }
public PCA_MTJ_EVD_SymmMatrix(double[][] gramMatrix) { this.symmGramMatrix = new UpperSymmDenseMatrix(new DenseMatrix(gramMatrix)); runEVD(); }
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); } }
/** * Convenience method for computing a full SVD * * @param A * Matrix to decompose, not modified * @return Newly allocated factorization * @throws NotConvergedException */ public static SVD factorize(Matrix A) throws NotConvergedException { return new SVD(A.numRows(), A.numColumns()).factor(new DenseMatrix(A)); }
private void runEVD() { int gramDimension = gramMatrix.numRows(); try { evd = no.uib.cipr.matrix.EVD.factorize(gramMatrix); } catch (NotConvergedException e) { throw new RuntimeException(e); } // initial eigenpairs eigenvalues = evd.getRealEigenvalues(); Matrix eigenvectorMatrix = evd.getRightEigenvectors(); eigenvectors = LinearAlgebraUtils.reshape1DArray(((DenseMatrix) eigenvectorMatrix).getData(), gramDimension, gramDimension); // sort eigenpairs in descending order according to the magnitude of eigenvalues EigenPair[] eigenPairs = LinearAlgebraUtils.createReverseSortedEigenpairs(eigenvalues, eigenvectors); eigenvalues = LinearAlgebraUtils.extractEigenvaluesFromEigenpairs(eigenPairs); eigenvectors = ArrayUtils.transpose(LinearAlgebraUtils.extractEigenvectorsFromEigenpairs(eigenPairs)); }
private void av(double[] work, int input_offset, int output_offset) { DenseVector w = new DenseVector(work, false); Vector x = new DenseVectorSub(w, input_offset, matrix.numColumns()); Vector y = new DenseVectorSub(w, output_offset, matrix.numColumns()); matrix.mult(x, y); } }
/** * 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)); }
/** * Convenience method to compute a LQ decomposition * * @param A * Matrix to decompose. Not modified * @return Newly allocated decomposition */ public static LQ factorize(Matrix A) { return new LQ(A.numRows(), A.numColumns()).factor(new DenseMatrix(A)); }
private void runEVD() { int gramDimension = symmGramMatrix.numRows(); try { symmDenseEVD = no.uib.cipr.matrix.SymmDenseEVD.factorize(this.symmGramMatrix); } catch (NotConvergedException e) { throw new RuntimeException(e); } // initial eigenpairs eigenvalues = symmDenseEVD.getEigenvalues(); double[] Vt_1D = symmDenseEVD.getEigenvectors().getData(); eigenvectors = LinearAlgebraUtils.reshape1DArray(Vt_1D, gramDimension, gramDimension); // sort eigenpairs in descending order according to the magnitude of eigenvalues EigenPair[] eigenPairs = LinearAlgebraUtils.createReverseSortedEigenpairs(eigenvalues, eigenvectors); eigenvalues = LinearAlgebraUtils.extractEigenvaluesFromEigenpairs(eigenPairs); eigenvectors = ArrayUtils.transpose(LinearAlgebraUtils.extractEigenvectorsFromEigenpairs(eigenPairs)); } }
/** * 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)); }
/** * Calculates a Cholesky decomposition * * @param A * Matrix to decompose. Not modified * @return The current decomposition */ public static DenseCholesky factorize(Matrix A) { return new DenseCholesky(A.numRows(), true) .factor(new UpperSPDDenseMatrix(A)); }
public PCA_MTJ_SVD_DenseMatrix(double[][] gramMatrix) { this.gramMatrix = new DenseMatrix(gramMatrix); runSVD(); }
/** * Solves directly at the coarsest level */ private void directSolve() { int k = m - 1; u[k].set(f[k]); DenseMatrix U = new DenseMatrix(u[k], false); if (transpose) lu.transSolve(U); else lu.solve(U); }
/** * Calculates a Cholesky decomposition * * @param A * Matrix to decompose. Not modified * @return The current decomposition */ public static DenseCholesky factorize(Matrix A) { return new DenseCholesky(A.numRows(), true) .factor(new UpperSPDDenseMatrix(A)); }
public PCA_MTJ_EVD_DenseMatrix(double[][] gramMatrix) { this.gramMatrix = new DenseMatrix(gramMatrix); runEVD(); }