import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
public Iterator<MatrixEntry> iterator() {
    return new Iterator<MatrixEntry>() {
        Node cur = links.head;
        ReusableMatrixEntry entry = new ReusableMatrixEntry();

        @Override
        public boolean hasNext() {
            return cur != null;
        }

        @Override
        public MatrixEntry next() {
            entry.row = cur.row;
            entry.col = cur.col;
            entry.val = cur.val;
            cur = cur.rowTail;
            return entry;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("TODO");
        }
    };
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
private static <
	V extends Vertex<V,E,F>,
	E extends Edge<V,E,F>,
	F extends Face<V,E,F>,
	HDS extends HalfEdgeDataStructure<V, E, F>
> Matrix calculateCodifferential(HDS heds, AdapterSet adapters, int dim) {
	Matrix hs0inv = invertDiagonalMatrix(getHodgeStar(heds, adapters, dim));
	Matrix hs1 = getHodgeStar(heds, adapters, dim+1);
	Matrix bd = getBoundaryOperator(heds, adapters, dim);
	
	int[][] nz = getColumnNonZeros(bd);
	Matrix M = new CompColMatrix(bd.numRows(),bd.numColumns(),nz);
	M.set(bd);
	for(MatrixEntry me : M) {
		double val = me.get();
		me.set(-1.0*hs0inv.get(me.row(), me.row())*hs1.get(me.column(), me.column())*val);
	}
	return M;
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
/**
 * Optimized method for matrix and diagonal matrix multiplication
 * 
 * @param documents
 * 		A List of documents
 * @return sparse input matrix
 */
public Matrix transform(List<String> documents) {
	Matrix X = this.countVocab(documents);
	
	if (this.useIdf) {
		// theoretically, use X * idf_diagonal should be faster.
		// unfortunately, the writer of mtj doesn't optimize it.
		// I use a manully optimization to make it faster.
		for(MatrixEntry e: X){
			e.set(e.get() * this.idfDiag[e.column()]);
		}
	} 
	// normalization
	this.rowNormalize(X);
	return X;
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
public DenseDoubleMatrix asDenseMatrix() {
   DenseDoubleMatrix result = new DenseDoubleMatrix(internalMatrix.numRows(), internalMatrix.numColumns());
   for (MatrixEntry matrixEntry : internalMatrix) {
      result.setValue(matrixEntry.row(), matrixEntry.column(), matrixEntry.get());
   }
   return result;
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
public SparseDoubleMatrix asSparseMatrix() {
   SparseDoubleMatrix result = new SparseDoubleMatrix(internalMatrix.numRows(), internalMatrix.numColumns());
   for (MatrixEntry matrixEntry : internalMatrix) {
      if (Double.compare(matrixEntry.get(), 0.0) != 0)
         result.setValue(matrixEntry.row(), matrixEntry.column(), matrixEntry.get());
   }
   return result;
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
public double getFrobeniusNorm() {
   double norm = 0;
   for (MatrixEntry matrixEntry : internalMatrix) {
      norm += matrixEntry.get() * matrixEntry.get();
   }
   return Math.sqrt(norm);
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
public Matrix scale(double alpha) {
    if (alpha == 0)
        zero();
    else if (alpha != 1)
        for (MatrixEntry e : this)
            set(e.row(), e.column(), e.get() * alpha);
    return this;
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
public MatrixEntry next() {
    entry.update(column, cursor);

    // Next position is in the same column
    if (cursor < columnPointer[column + 1] - 1)
        cursor++;

    // Next position is at the following (non-empty) column
    else {
        column++;
        nextNonEmptyColumn();
    }

    return entry;
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
public MatrixEntry next() {
    entry.update(diagonal, index);

    // Move along current diagonal
    if (index < diag[diagonal].length - 1)
        index++;

    // Move to the next diagonal
    else {
        diagonal++;
        index = 0;
    }

    return entry;
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
/**
 * @see AbstractMatrix#getSubMatrix(int, int, int, int)
 */
@Override
// optimized for sparse matrices
// Non optimal for dense matrices (we only need it for sparse matrices)
public AbstractMatrix getSubMatrix(int startRow, int endRow, int startColumn, int endColumn) {
  if (startRow > endRow) {
    throw new IllegalArgumentException("startRow > endRow");
  }
  if (startColumn > endColumn) {
    throw new IllegalArgumentException("startColumn > endColumn");
  }

  final int n = endRow - startRow + 1;
  final int m = endColumn - startColumn + 1;
  FlexCompRowMatrix subMatrix = new FlexCompRowMatrix(n, m);
  Iterator<MatrixEntry> it = this.matrix.iterator();

  while (it.hasNext()) {
    MatrixEntry entry = it.next();
    int row = entry.row();
    int column = entry.column();
    if (row >= startRow && row <= endRow && column >= startColumn && column <= endColumn) {
      int subMatrixRow = row - startRow;
      int subMatrixColumn = column - startColumn;
      subMatrix.set(subMatrixRow, subMatrixColumn, entry.get());
    }
  }

  return new MtjMatrix(subMatrix);
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
/**
 * @see AbstractMatrix#setSubMatrix(AbstractMatrix, int, int)
 */
@Override
public void setSubMatrix(AbstractMatrix subMatrix, int row, int column) {
  if (subMatrix instanceof MtjMatrix) {
    no.uib.cipr.matrix.AbstractMatrix s = ((MtjMatrix) subMatrix).getMatrix();
    Iterator<MatrixEntry> it = s.iterator();
    while (it.hasNext()) {
      MatrixEntry entry = it.next();
      int i = row + entry.row();
      int j = column + entry.column();
      double value = entry.get();
      this.matrix.set(i, j, value);
    }
  }
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
private static CompDiagMatrix invertDiagonalMatrix(Matrix m) {
	CompDiagMatrix minv = new CompDiagMatrix(m.numRows(),m.numColumns());
	Iterator<MatrixEntry> it = m.iterator();
	while(it.hasNext()) {
		MatrixEntry me = it.next();
		minv.set(me.row(),me.column(),1.0/me.get());
	}
	return minv;
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
protected void forEach(final ElementVisitorFunction func) {
	for (final MatrixEntry entry : this.matrix) {
		func.visit(
				entry.row(),
				entry.column(),
				entry.get(),
				entry::set);
	}
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
public Iterator<MatrixEntry> iterator() {
    return new RowMatrixIterator();
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
public MatrixEntry next() {
    SuperIteratorEntry<VectorEntry> se = iterator.next();
    entry.update(se.index(), se.get());
    return entry;
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
public Iterator<MatrixEntry> iterator() {
    return new CompColMatrixIterator();
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
public Iterator<MatrixEntry> iterator() {
    return new CompDiagMatrixIterator();
}
 

import no.uib.cipr.matrix.MatrixEntry; //导入依赖的package包/类
@Override
public Iterator<MatrixEntry> iterator() {
    return new ColMatrixIterator();
}