/** * Construct and returns a new 2-d matrix <i>of the corresponding dynamic type</i>, entirelly independent of the receiver. * For example, if the receiver is an instance of type <tt>DenseDoubleMatrix1D</tt> the new matrix must be of type <tt>DenseDoubleMatrix2D</tt>, * if the receiver is an instance of type <tt>SparseDoubleMatrix1D</tt> the new matrix must be of type <tt>SparseDoubleMatrix2D</tt>, etc. * * @param rows the number of rows the matrix shall have. * @param columns the number of columns the matrix shall have. * @return a new matrix of the corresponding dynamic type. */ public DoubleMatrix2D like2D(int rows, int columns) { return new SparseDoubleMatrix2D(rows,columns); } /**
public static final SparseDoubleMatrix2D dcsToMatrix(Dcs_common.Dcs dcs) { SparseDoubleMatrix2D A = new SparseDoubleMatrix2D(dcs.m, dcs.n); final int[] rowIndexes = dcs.i; final int[] columnPointers = dcs.p; final double values[] = dcs.x; //for example //rowIndexes 2, 0, 2, 3, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 //columnPointers 0, 2, 3, 5, 7 //values 2.0, 1.0, 3.0, 4.0, 2.0, 4.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 int cnt =0; for (int j = 0; j < dcs.n; j++) { int colStartIndex = columnPointers[j];//example 5 int colEndIndex = columnPointers[j+1];//example 7 for (int pointer = colStartIndex; pointer < colEndIndex; pointer++) { int i = rowIndexes[pointer]; A.setQuick(i, j, values[cnt]); cnt++; } } //log.debug("A: " + ArrayUtils.toString(A.toArray())); return A; }
int signatureNodeCount = signatureAdjacencyMatrix.rows(); int functionNodeCount = functionAdjacencyMatrix.rows(); SparseDoubleMatrix2D candidateList = new SparseDoubleMatrix2D(signatureNodeCount, functionNodeCount); SparseDoubleMatrix2D signatureVector = new SparseDoubleMatrix2D(1, signatureNodeCount); SparseDoubleMatrix2D functionVector = new SparseDoubleMatrix2D(1, functionNodeCount); if(signatureAdjacencyMatrix.viewColumn(j).cardinality() == 0) signatureVector.set(0, j, 1.0); if(functionAdjacencyMatrix.viewColumn(j).cardinality() == 0) { functionVector.set(0, j, 1.0); signatureVector.set(0, 0, 1.0); functionVector.set(0, 0, 1.0); if(signatureVector.cardinality() > functionVector.cardinality()) { SparseDoubleMatrix2D functionSelector = new SparseDoubleMatrix2D(1, functionNodeCount); SparseDoubleMatrix2D signatureSelector = new SparseDoubleMatrix2D(1, signatureNodeCount); signatureVector.getNonZeros(unusedInt, signatureNonZeros, unusedDouble); functionVector.getNonZeros(unusedInt, functionNonZeros, unusedDouble); signatureSelector.assign(0.0); signatureSelector.set(0, signatureNonZeros.get(i), 1.0); int signatureChildCount = Algebra.DEFAULT.mult(signatureSelector, signatureAdjacencyMatrix).cardinality(); functionSelector.assign(0.0);
public void normalize() { int adjacencyMatrixSize = adjacencyMatrix.columns(); DoubleMatrix2D selector = new SparseDoubleMatrix2D(1, adjacencyMatrixSize); selector.set(0, 0, 1.0); SparseDoubleMatrix2D reduced = new SparseDoubleMatrix2D(cardinality, cardinality); int iCurrentVertex = 0; for(int i=0; i<adjacencyMatrixSize; ++i) { for(int j=0; j<adjacencyMatrixSize; ++j) { if(selector.get(0, j) != 0.0){ reduced.set(iCurrentVertex, jCurrentVertex, adjacencyMatrix.get(i, j)); ++jCurrentVertex; vertexCount = adjacencyMatrix.columns(); edgeCount = adjacencyMatrix.cardinality();
int signatureNodeCount = signatureAdjacencyMatrix.rows(); int functionNodeCount = functionAdjacencyMatrix.rows(); SparseDoubleMatrix2D candidateList = new SparseDoubleMatrix2D(signatureNodeCount, functionNodeCount); candidateList.assign(0); SparseDoubleMatrix2D signatureVector = new SparseDoubleMatrix2D(1, signatureNodeCount); SparseDoubleMatrix2D functionVector = new SparseDoubleMatrix2D(1, functionNodeCount); signatureVector.set(0, 0, 1.0); functionVector.set(0, functionEntry, 1.0); candidateList.set(0, functionEntry, 1.0);
SparseDoubleMatrix2D candidateList) { SparseDoubleMatrix2D signatureSelector = new SparseDoubleMatrix2D(1, signatureDepths.length); SparseDoubleMatrix2D functionSelector = new SparseDoubleMatrix2D(1, functionDepths.length); continue; signatureSelector.assign(0.0); signatureSelector.set(0, i, 1.0); if(candidateList.get(i, j) == 0.0) continue; functionSelector.assign(0.0); functionSelector.set(0, j, 1.0); if( candidateList.get(i, j) > 0 && (signatureIncestParentCount > functionIncestParentCount || !bipartiteMatchingVector(candidateList, signatureNodeParentVector, functionNodeParentVector, signatureDepths, functionDepths))) { candidateList.set(i, j, 0.0);
adjacencyMatrix = new SparseDoubleMatrix2D(size, size); List<String> lookup = new ArrayList<String>(); adjacencyMatrix.set(basicBlockIdx, destIdx, 1.0); edgeCount = adjacencyMatrix.cardinality(); vertexCount = size;
public Matrix mtimes(Matrix m) { if (m instanceof ColtSparseDoubleMatrix2D) { SparseDoubleMatrix2D ret = new SparseDoubleMatrix2D((int) getRowCount(), (int) m.getColumnCount()); matrix.zMult(((ColtSparseDoubleMatrix2D) m).matrix, ret); return new ColtSparseDoubleMatrix2D(ret); } else { return super.mtimes(m); } }
if (kind.equals("sparse")) matrix = new SparseDoubleMatrix2D(rows,columns,initialCapacity,minLoadFactor,maxLoadFactor); else if (kind.equals("dense")) matrix = new DenseDoubleMatrix2D(rows,columns); matrix.assign(0); matrix.ensureCapacity(initialCapacity); if (kind.equals("sparse")) ((SparseDoubleMatrix2D)matrix).ensureCapacity(initialCapacity); timer1.start(); int value = 0;
SparseDoubleMatrix2D functionSelector = new SparseDoubleMatrix2D(1, functionDepths.length); SparseDoubleMatrix2D signatureSelector = new SparseDoubleMatrix2D(1, signatureDepths.length); signatureSelector.assign(0.0); signatureSelector.set(0, signatureNonZeros.get(i), 1.0); int signatureChildCount = Algebra.DEFAULT.mult(signatureSelector, signatureAdjacencyMatrix).cardinality(); DoubleMatrix2D signatureNodeParentVector = Algebra.DEFAULT.mult(signatureSelector, Algebra.DEFAULT.transpose(signatureAdjacencyMatrix)); functionSelector.assign(0.0); functionSelector.set(0, functionNonZeros.get(j), 1.0); int functionChildCount = Algebra.DEFAULT.mult(functionSelector, functionAdjacencyMatrix).cardinality(); DoubleMatrix2D functionNodeParentVector = Algebra.DEFAULT.mult(functionSelector, Algebra.DEFAULT.transpose(functionAdjacencyMatrix)); bipartiteMatchingVector(candidateList, signatureNodeParentVector, functionNodeParentVector, signatureDepths, functionDepths)) { candidateList.set(signatureNonZeros.get(i), functionNonZeros.get(j), 1.0);
adjacencyMatrix = new SparseDoubleMatrix2D(vertexCount, vertexCount); for(BasicBlock bb : basicBlocks) { continue; adjacencyMatrix.set(row, col, 1.0);
m = A.rows(); n = A.columns(); double[] cn_2_scaled = null; if(log.isDebugEnabled()){ cn_00_original = ColtUtils.getConditionNumberRange(new Array2DRowRealMatrix(A.toArray()), Integer.MAX_VALUE); log.debug("cn_00_original Q before scaling: " + ArrayUtils.toString(cn_00_original)); cn_2_original = ColtUtils.getConditionNumberRange(new Array2DRowRealMatrix(A.toArray()), 2); log.debug("cn_2_original Q before scaling : " + ArrayUtils.toString(cn_2_original)); cn_00_scaled = ColtUtils.getConditionNumberRange(new Array2DRowRealMatrix(A.toArray()), Integer.MAX_VALUE); log.debug("cn_00_scaled Q after scaling : " + ArrayUtils.toString(cn_00_scaled)); cn_2_scaled = ColtUtils.getConditionNumberRange(new Array2DRowRealMatrix(A.toArray()), 2); log.debug("cn_2_scaled Q after scaling : " + ArrayUtils.toString(cn_2_scaled));
A = (useSparsity)? new SparseDoubleMatrix2D(originalA.rows(), originalA.columns()) : F2.make(originalA.rows(), originalA.columns());//this will change during the process DoubleMatrix2D P = Q.viewPart(0, column, originalMeq, 1); P.forEachNonZero(new IntIntDoubleFunction() { @Override presolvedA = (useSparsity)? new SparseDoubleMatrix2D(presolvedMeq, presolvedN) : F2.make(presolvedMeq, presolvedN); presolvedB = F1.make(presolvedMeq); presolvedYlb = F1.make(presolvedMeq);
public double getDouble(int row, int column) { return matrix.getQuick(row, column); }
/** * @param Q sparse symmetric positive definite matrix. Only its subdiagonal lower left part is relevant. */ public CholeskySparseFactorization(SparseDoubleMatrix2D Q, MatrixRescaler rescaler) { //ColtUtils.dumpSparseMatrix(Q); //log.debug(org.apache.commons.lang3.ArrayUtils.toString(Q.toArray())); this.dim = Q.rows(); this.Q = Q; this.rescaler = rescaler; }
public synchronized void setDouble(double value, int row, int column) { matrix.setQuick(row, column, value); }
public Matrix transpose() { return new ColtSparseDoubleMatrix2D((SparseDoubleMatrix2D) matrix.viewDice().copy()); }