@Override public SparseMatrix laplacian(SparseMatrix adj, DiagonalMatrix degree) { SparseMatrix ret = MatlibMatrixUtils.plusInplace( DiagonalMatrix.ones(degree.rowCount()), MatlibMatrixUtils.minusInplace( degree, adj ) ); return ret; } }
/** * Compute the lower-rank approximation of the Moore-Penrose Pseudo-Inverse. * * @param matrix * The matrix to invert. * @param rank * the desired rank. * @return the pseudo-inverse. */ public static Matrix pseudoInverse(Matrix matrix, int rank) { return pseudoInverse(new JamaDenseMatrix(matrix), rank); }
@Override public Matrix predict(Matrix x) { Matrix xt = MatlibMatrixUtils.transpose(x); final Matrix mult = MatlibMatrixUtils.dotProduct(MatlibMatrixUtils.dotProduct(MatlibMatrixUtils.transpose(u), xt),this.w); if(this.biasMode) MatlibMatrixUtils.plusInplace(mult,this.bias); Matrix ydiag = new DiagonalMatrix(mult); return ydiag; } }
/** * Subtract matrices A-B * * @param A * @param B * @return A-B */ public static Matrix minus(Matrix A, Matrix B) { final Matrix ret = copy(A); minusInplace(ret, B); return ret; }
/** * @param dir * @return construct and perform a {@link GramSchmidtProcess} */ public static Vector[] perform(double[] dir) { return new GramSchmidtProcess(0).apply(dir); }
/** * Computes the Moore-Penrose pseudoinverse. This is just a convenience wrapper * around {@link PseudoInverse#pseudoInverse(Matrix)}. * * @param matrix * the matrix to invert. * @return the inverted matrix * @see PseudoInverse#pseudoInverse(Matrix) */ public static Matrix pseudoInverse(Matrix matrix) { return PseudoInverse.pseudoInverse(matrix); }
/** * @param rowcol * @param d * @return a matrix with d in the diagonal */ public static DiagonalMatrix fill(int rowcol, double d) { DiagonalMatrix ret = new DiagonalMatrix(rowcol); for (int i = 0; i < rowcol; i++) { ret.vals[i] = d; } return ret; }
protected Matrix updateBias(Matrix biasGrad, double biasLossWeight) { final Matrix newbias = MatlibMatrixUtils.minus( this.bias, MatlibMatrixUtils.scaleInplace( biasGrad, biasLossWeight ) ); return newbias; } protected Matrix updateW(Matrix currentW, double wLossWeighted, double weightedLambda) {
private double[] center(double[] xt) { double[] mvec = mv.vec(); double[] ret = new double[xt.length]; if(mvec == null) return ret; for (int i = 0; i < mvec.length; i++) { ret[i] = xt[i] - mvec[i]; } return ret; }
public Matrix times(Matrix a, Matrix b) { final double[][] ad = fromMatrix(a); final double[][] bd = fromMatrix(b); return this.times(ad, bd); }
/** * */ public MeanVector() { reset(); }
/** * Construct with Eigen values and vectors. * @param val values * @param vec vectors */ public EigenValueVectorPair(Matrix val, Matrix vec) { this.setValues(val); this.setVectors(vec); }
/** * @param rowcol * @return a matrix of ones in the diagonal */ public static DiagonalMatrix zeros(int rowcol) { return fill(rowcol,0.); }
@Override protected void setCovariances(MultivariateGaussian[] gaussians, Matrix cv) { for (final MultivariateGaussian mg : gaussians) { ((DiagonalMultivariateGaussian) mg).variance = MatrixUtils.diagVector(cv); } }
@Override public void perform(Integer object) { final int rowi = object / answerCols; final int coli = object - (rowi * answerCols); double dot = 0; for (int i = 0; i < a[rowi].length; i++) { dot += a[rowi][i] * b[i][coli]; } ThreadedMatrixMulti.this.setAnswerElement(rowi, coli, dot); } }
/** * uses the second value returned by {@link #minmaxmean(Matrix)} * * @param mat * @return the min */ public static double max(Matrix mat) { return minmaxmean(mat)[1]; }
@Override public ch.akuhn.matrix.Matrix newInstance(int rows, int cols) { return new JamaDenseMatrix(rows, cols); } }
/** * @param x */ public void choldowndate(double[] x) { choldowndate(x,true); }
private double[] center(double[] xt) { double[] mvec = mv.vec(); double[] ret = new double[xt.length]; if(mvec == null) return ret; for (int i = 0; i < mvec.length; i++) { ret[i] = xt[i] - mvec[i]; } return ret; }
/** * @param rowcol * @return a matrix of ones in the diagonal */ public static DiagonalMatrix ones(int rowcol) { return fill(rowcol,1.); }