improve SparseMatrix.Entry

Author: haifengl

math/src/main/java/smile/math/matrix/SparseMatrix.java

@@ -260,7 +260,7 @@ public void foreachNonzero(int startColumn, int endColumn, MatrixElementConsumer
      * Provides a stream over all of the non-zero elements of a sparse matrix.
      */
     public Stream<Entry> nonzeros() {
-        return StreamSupport.stream(new SparseMatrixSpliterator(this, 0, ncols), false);
+        return StreamSupport.stream(new SparseMatrixSpliterator(0, ncols), false);
     }
 
     /**
@@ -270,42 +270,40 @@ public Stream<Entry> nonzeros() {
      * @param endColumn   The first column after the ones that we should scan.
      */
     public Stream<Entry> nonzeros(int startColumn, int endColumn) {
-        return StreamSupport.stream(new SparseMatrixSpliterator(this, startColumn, endColumn), false);
+        return StreamSupport.stream(new SparseMatrixSpliterator(startColumn, endColumn), false);
     }
 
     /**
      * Provides a spliterator for access to a sparse matrix in column major order.
      * <p>
      * This is exposed to facilitate lower level access to the stream API for a matrix.
      */
-    private static class SparseMatrixSpliterator implements Spliterator<Entry> {
-        private final SparseMatrix m;
+    private class SparseMatrixSpliterator implements Spliterator<Entry> {
         private int col;      // current column, advanced on split or traversal
         private int index;    // current element within column
         private final int fence; // one past the last column to process
 
-        SparseMatrixSpliterator(SparseMatrix matrix, int col, int fence) {
-            this.m = matrix;
+        SparseMatrixSpliterator(int col, int fence) {
             this.col = col;
-            this.index = m.colIndex[col];
+            this.index = colIndex[col];
             this.fence = fence;
         }
 
         public void forEachRemaining(Consumer<? super Entry> action) {
             for (; col < fence; col++) {
-                for (; index < m.colIndex[col + 1]; index++) {
-                    action.accept(new Entry(m.rowIndex[index], col, m.x[index], index, m.x));
+                for (; index < colIndex[col + 1]; index++) {
+                    action.accept(new Entry(rowIndex[index], col, x[index], index));
                 }
             }
         }
 
         public boolean tryAdvance(Consumer<? super Entry> action) {
             if (col < fence) {
-                while (col < fence && index >= m.colIndex[col + 1]) {
+                while (col < fence && index >= colIndex[col + 1]) {
                     col++;
                 }
                 if (col < fence) {
-                    action.accept(new Entry(m.rowIndex[index], col, m.x[index], index, m.x));
+                    action.accept(new Entry(rowIndex[index], col, x[index], index));
                     index++;
                     return true;
                 } else {
@@ -322,15 +320,15 @@ public Spliterator<Entry> trySplit() {
             int mid = ((lo + fence) >>> 1) & ~1; // force midpoint to be even
             if (lo < mid) { // split out left half
                 col = mid; // reset this Spliterator's origin
-                return new SparseMatrixSpliterator(m, lo, mid);
+                return new SparseMatrixSpliterator(lo, mid);
             } else {
                 // too small to split
                 return null;
             }
         }
 
         public long estimateSize() {
-            return (long) (m.colIndex[fence] - m.colIndex[col]);
+            return (long) (colIndex[fence] - colIndex[col]);
         }
 
         public int characteristics() {
@@ -339,32 +337,37 @@ public int characteristics() {
     }
 
     /**
-     * Encapsulates important information about an entry in a matrix for use
-     * in streaming, including a string that leads back to the original cell
-     * so that in-place updates are possible.
+     * Encapsulates an entry in a matrix for use in streaming. As typical stream object,
+     * this object is immutable. But we can update the corresponding value in the matrix
+     * through <code>update</code> method. This provides an efficient way to update the
+     * non-zero entries of a sparse matrix.
      */
-    public static class Entry {
+    public class Entry {
         // these fields are exposed for direct access to simplify in-lining by the JVM
         public final int row;
         public final int col;
-        public double x;
+        public final double value;
 
         // these are hidden due to internal dependency
         private final int index;
-        private double[] values;
 
-
-        public Entry(int row, int col, double x, int index, double[] values) {
+        /**
+         * Private constructor. Only the enclosure matrix can creates
+         * the instances of entry.
+         */
+        private Entry(int row, int col, double value, int index) {
             this.row = row;
             this.col = col;
-            this.x = x;
+            this.value = value;
             this.index = index;
-            this.values = values;
         }
 
-        public void set(double value) {
-            this.x = value;
-            values[index] = value;
+        /**
+         * Update the value of entry in the matrix. Note that the field <code>value</code>
+         * is final and thus not updated.
+         */
+        public void update(double value) {
+            x[index] = value;
         }
     }
 

math/src/test/java/smile/math/matrix/SparseMatrixTest.java

@@ -225,7 +225,7 @@ public void nonZeroIterator() {
                         entry -> {
                             int i = entry.row;
                             int j = entry.col;
-                            double x = entry.x;
+                            double x = entry.value;
 
                             assertEquals(d[i][j], x, 0);
                             assertEquals(d[i][j], m.get(i, j), 0);
@@ -243,7 +243,7 @@ public void nonZeroIterator() {
                             assertTrue(col >= 100);
                             assertTrue(col < 400);
 
-                            assertEquals(d[entry.row][col], entry.x, 0);
+                            assertEquals(d[entry.row][col], entry.value, 0);
                             assertEquals(d[entry.row][col], m.get(entry.row, col), 0);
                             k.incrementAndGet();
                         }
@@ -283,7 +283,7 @@ public void iterationSpeed() {
         double[] sum2 = new double[2000];
         for (int rep = 0; rep < 1000; rep++) {
             m.nonzeros()
-                    .forEach(entry -> sum2[entry.col] += entry.x);
+                    .forEach(entry -> sum2[entry.col] += entry.value);
         }
         t1 = System.nanoTime() / 1e9;
         sum = 0;

plot/src/main/java/smile/plot/SparseMatrixPlot.java

@@ -114,7 +114,7 @@ public SparseMatrixPlot(SparseMatrix sparse, Color[] palette) {
 
         // In case of outliers, we use 1% and 99% quantiles as lower and
         // upper limits instead of min and max.
-        double[] values = sparse.nonzeros().mapToDouble(entry -> entry.x).filter(x -> !Double.isNaN(x)).toArray();
+        double[] values = sparse.nonzeros().mapToDouble(entry -> entry.value).filter(x -> !Double.isNaN(x)).toArray();
 
         if (values.length == 0) {
             throw new IllegalArgumentException("Sparse matrix has no non-zero values");