/** * @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; }
/** * @param rowcol * @return a matrix of ones in the diagonal */ public static DiagonalMatrix zeros(int rowcol) { return fill(rowcol,0.); }
@Override public SparseMatrix laplacian(SparseMatrix adj, DiagonalMatrix degree) { DiagonalMatrix invSqrtDegree = MatlibMatrixUtils.powInplace(degree,-1./2.); for (int i = 0; i < degree.rowCount(); i++) { if(Double.isNaN(degree.get(i, i)) || Double.isInfinite(degree.get(i, i)) ) invSqrtDegree.put(i, i, 0); } SparseMatrix ret = MatlibMatrixUtils.times( MatlibMatrixUtils.times( invSqrtDegree, adj ), invSqrtDegree ); return ret; }
/** * @param adj the adjanceny matrix should be square and symmetric * @return the laplacian */ public SparseMatrix laplacian(SparseMatrix adj){ DiagonalMatrix degree = new DiagonalMatrix(adj.rowCount()); int i = 0; for (Vector row : adj.rows()) { // row.put(i, 0); degree.put(i, i, row.sum()); i++; } return laplacian(adj,degree); }
/** * Sum the diagonal of the given matrix * * @param d * the matrix * @return the sum along the diagonal */ public static double sum(DiagonalMatrix d) { return ArrayUtils.sumValues(d.getVals()); }
@Override public Vector transposeNonTransposeMultiply(Vector x) { double[] y = new double[this.columnCount()]; for (int i = 0; i < y.length; i++) { y[i] = this.vals[i] * this.vals[i] * x.get(i); } return Vector.wrap(y); }
@Override public Vector transposeMultiply(Vector x) { return mult(x); }
/** * Add two matrices, storing the results in the second: * <code>A = D + A</code> * * @param D * first matrix * @param A * second matrix * @return second matrix * */ public static <T extends Matrix> T plusInplace(DiagonalMatrix D, T A) { final double[] Dval = D.getVals(); for (int i = 0; i < Dval.length; i++) { A.put(i, i, A.get(i, i) + Dval[i]); } return A; }
@Override public Vector mult(Vector x) { double[] y = new double[this.columnCount()]; for (int i = 0; i < y.length; i++) { y[i] = this.vals[i] * x.get(i); } return Vector.wrap(y); }
@Override public Matrix newInstance(int rows, int cols) { return new DiagonalMatrix(rows); } }
@Override public SparseMatrix laplacian(SparseMatrix adj, DiagonalMatrix degree) { DiagonalMatrix invDegree = MatlibMatrixUtils.powInplace(degree,-1.); for (int i = 0; i < degree.rowCount(); i++) { if(Double.isNaN(degree.get(i, i)) || Double.isInfinite(degree.get(i, i)) ) invDegree.put(i, i, 0); } SparseMatrix ret = MatlibMatrixUtils.times( MatlibMatrixUtils.times( invDegree, adj ), invDegree ); return ret; }
/** * Subtract two matrices, storing the result in the second: * <code>A = D - A</code> * * @param D * first matrix * @param A * second matrix * @return second matrix * */ public static <T extends Matrix> T minusInplace(DiagonalMatrix D, T A) { final double[] Dval = D.getVals(); for (int i = 0; i < Dval.length; i++) { final Iterable<Entry> rowents = A.row(i).entries(); for (final Entry entry : rowents) { A.put(i, entry.index, -entry.value); } A.put(i, i, Dval[i] - A.get(i, i)); } return A; }
/** * @param rowcol * @return a matrix of ones in the diagonal */ public static DiagonalMatrix ones(int rowcol) { return fill(rowcol,1.); }
@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; } }
/** * Left multiply two matrices: <code>R = D . A</code> * * @param D * first matrix * @param A * second matrix * @return result of multiplication */ public static SparseMatrix times(DiagonalMatrix D, SparseMatrix A) { final SparseMatrix mat = new SparseMatrix(A.rowCount(), A.columnCount()); final double[] Dvals = D.getVals(); int rowIndex = 0; for (final Vector row : A.rows()) { for (final Entry ent : row.entries()) { mat.put(rowIndex, ent.index, ent.value * Dvals[rowIndex]); } rowIndex++; } return mat; }
private void initParams(Matrix x, Matrix y, int xrows, int xcols, int ycols) { final InitStrategy wstrat = getInitStrat(BilinearLearnerParameters.WINITSTRAT,x,y); final InitStrategy ustrat = getInitStrat(BilinearLearnerParameters.UINITSTRAT,x,y); this.w = wstrat.init(xrows, ycols); this.u = ustrat.init(xcols, ycols); this.bias = SparseMatrix.sparse(ycols,ycols); if(this.biasMode){ final InitStrategy bstrat = getInitStrat(BilinearLearnerParameters.BIASINITSTRAT,x,y); this.bias = bstrat.init(ycols, ycols); this.diagX = new DiagonalMatrix(ycols,1); } }
/** * Right multiply two matrices: <code>R = A . D</code> * * @param D * first matrix * @param A * second matrix * @return result of multiplication */ public static SparseMatrix times(SparseMatrix A, DiagonalMatrix D) { final SparseMatrix mat = new SparseMatrix(A.rowCount(), A.columnCount()); int rowIndex = 0; final double[] Dvals = D.getVals(); for (final Vector row : A.rows()) { for (final Entry ent : row.entries()) { mat.put(rowIndex, ent.index, ent.value * Dvals[ent.index]); } rowIndex++; } return mat; }