@Override final public Matrix transpose() { return new DiagonalMatrix(this); }
@Override public void set( final int rowIndex, final int columnIndex, final double value) { setElement(rowIndex, columnIndex, value); }
@Override public final Vector preTimes( final DenseVector vector) { // Only true for diagonal (and symmetric) matrices: pre-mult vector is the same as post-mult // vector return times(vector); }
@Override public final Matrix times( final DiagonalMatrix other) { this.assertMultiplicationDimensions(other); DiagonalMatrix result = new DiagonalMatrix(this); for (int i = 0; i < diagonal.length; ++i) { result.diagonal[i] *= other.diagonal[i]; } return result; }
DiagonalMatrix diag = new DiagonalMatrix( multipartiteAdjacency.getNumRows()); diag.setElement(i, i, rowSum); Matrix tmp = diag.times(multipartiteAdjacency); Matrix DAD = tmp.times(diag); Matrix minusDAD = DAD.scale(-1); new DiagonalMatrix(multipartiteAdjacency.getNumRows()); I.identity(); Matrix l_tilde = I.plus(minusDAD); if (l_tilde instanceof SparseMatrix)
/** * Creates a new {@link MatrixVectorMultiplierDiagonalPreconditioner} for * the given matrix. * * @param m * The matrix. */ public MatrixVectorMultiplierDiagonalPreconditioner(Matrix m) { super(m); if (!m.isSquare()) { throw new IllegalArgumentException("This preconditioner only works " + "on square matrices"); } int n = m.getNumRows(); Minv = new DiagonalMatrix(n); for (int i = 0; i < n; ++i) { double ij = m.getElement(i, i); if (ij == 0) { throw new IllegalArgumentException("Diagonal preconditioner " + "only serves for matrices with non-zero diagonal elements"); } Minv.setElement(i, i, 1.0 / ij); } }
DiagonalMatrix I = new DiagonalMatrix(m); I.identity(); DenseVector v = new DenseVector(m); int imax = Math.min(m, n); result.Q = result.Q.times(I.minus( v.outerProduct(v).scale(tau[i])));
@Override public void scaledPlusEquals( final DiagonalMatrix other, final double scaleFactor) { this.assertSameDimensions(other); for (int i = 0; i < diagonal.length; ++i) { diagonal[i] += other.diagonal[i] * scaleFactor; } }
@Override public final void plusEquals( final DiagonalMatrix other) { this.assertSameDimensions(other); final int numRows = this.getNumRows(); for (int i = 0; i < numRows; ++i) { this.rows[i].values[i] += other.get(i, i); } }
@Override final public Matrix getSubMatrix( final int minRow, final int maxRow, final int minColumn, final int maxColumn) { checkSubmatrixRange(minRow, maxRow, minColumn, maxColumn); SparseMatrix result = new SparseMatrix(maxRow - minRow + 1, maxColumn - minColumn + 1); // You only need worry about the diagonal, so one of the extents will do for (int i = minRow; i <= maxRow; ++i) { // Check to make sure that this element of the diagonal is also in // the other extents if (i >= minColumn && i <= maxColumn) { // If it is, add it at the right place in the output result.setElement(i - minRow, i - minColumn, get(i, i)); } } return result; }
final DiagonalMatrix other) other.assertMultiplicationDimensions(this); if (!isCompressed()) result.values[i] = values[i] * other.get(curRow, curRow);
@Override public double get( final int rowIndex, final int columnIndex) { checkBounds(rowIndex, columnIndex); if (rowIndex == columnIndex) { return diagonal[rowIndex]; } return 0.0; }
@Override final public Vector solve( final Vector b) { checkSolveDimensions(b); Vector result = b.clone(); for (int i = 0; i < diagonal.length; ++i) { if (diagonal[i] == 0) { if (result.get(i) != 0) { throw new UnsupportedOperationException("Unable to solve " + "Ax=b because b spans different space than A"); } } else { result.setElement(i, result.get(i) / diagonal[i]); } } return result; }
@Override public final Matrix times( final DenseMatrix other) { this.assertMultiplicationDimensions(other); final DenseVector[] rows = new DenseVector[diagonal.length]; for (int i = 0; i < diagonal.length; ++i) { DenseVector v = other.row(i); rows[i] = (DenseVector) v.scale(diagonal[i]); } return new DenseMatrix(rows); }
DiagonalMatrix diag = new DiagonalMatrix( multipartiteAdjacency.getNumRows()); diag.setElement(i, i, rowSum); Matrix tmp = diag.times(multipartiteAdjacency); Matrix DAD = tmp.times(diag); Matrix minusDAD = DAD.scale(-1); new DiagonalMatrix(multipartiteAdjacency.getNumRows()); I.identity(); Matrix l_tilde = I.plus(minusDAD); if (l_tilde instanceof SparseMatrix)
/** * Creates a new {@link MatrixVectorMultiplierDiagonalPreconditioner} for * the given matrix. * * @param m * The matrix. */ public MatrixVectorMultiplierDiagonalPreconditioner(Matrix m) { super(m); if (!m.isSquare()) { throw new IllegalArgumentException("This preconditioner only works " + "on square matrices"); } int n = m.getNumRows(); Minv = new DiagonalMatrix(n); for (int i = 0; i < n; ++i) { double ij = m.getElement(i, i); if (ij == 0) { throw new IllegalArgumentException("Diagonal preconditioner " + "only serves for matrices with non-zero diagonal elements"); } Minv.setElement(i, i, 1.0 / ij); } }
DiagonalMatrix I = new DiagonalMatrix(m); I.identity(); DenseVector v = new DenseVector(m); int imax = Math.min(m, n); result.Q = result.Q.times(I.minus( v.outerProduct(v).scale(tau[i])));
@Override public final Matrix times( final DiagonalMatrix other) { this.assertMultiplicationDimensions(other); DiagonalMatrix result = new DiagonalMatrix(this); for (int i = 0; i < diagonal.length; ++i) { result.diagonal[i] *= other.diagonal[i]; } return result; }
@Override public final void dotTimesEquals( final DiagonalMatrix other) { this.assertSameDimensions(other); for (int i = 0; i < diagonal.length; ++i) { diagonal[i] *= other.diagonal[i]; } }
@Override public void scaledPlusEquals( final DiagonalMatrix other, final double scaleFactor) { this.assertSameDimensions(other); final int numRows = this.getNumRows(); for (int i = 0; i < numRows; ++i) { this.rows[i].values[i] += other.get(i, i) * scaleFactor; } }