exporter needs to normalize values too

Author: mneedham

algo/pom.xml

@@ -109,6 +109,13 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-inline</artifactId>
+            <version>2.23.4</version>
+            <scope>test</scope>
+        </dependency>
+
     </dependencies>
 
     <build>

algo/src/main/java/org/neo4j/graphalgo/CentralityUtils.java

@@ -15,6 +15,7 @@
 import org.neo4j.kernel.internal.GraphDatabaseAPI;
 import org.neo4j.logging.Log;
 
+import java.util.function.Function;
 import java.util.stream.IntStream;
 import java.util.stream.LongStream;
 import java.util.stream.Stream;
@@ -63,4 +64,12 @@ static Stream<CentralityScore> streamResults(Graph graph, CentralityResult score
                     );
                 });
     }
+
+    public static void normalizeArray(double[][] partitions, Function<Double, Double> normalizationFunction) {
+        for (double[] partition : partitions) {
+            for (int j = 0; j < partition.length; j++) {
+                partition[j] = normalizationFunction.apply(partition[j]);
+            }
+        }
+    }
 }

algo/src/main/java/org/neo4j/graphalgo/impl/results/CentralityResult.java

@@ -20,6 +20,8 @@
 
 import org.neo4j.graphalgo.core.write.Exporter;
 
+import java.util.function.Function;
+
 public interface CentralityResult {
 
     double score(int nodeId);
@@ -28,6 +30,8 @@ public interface CentralityResult {
 
     void export(String propertyName, Exporter exporter);
 
+    void export(String propertyName, Exporter exporter, Function<Double, Double> normalizationFunction);
+
     double computeMax();
 
     double computeL2Norm();

algo/src/main/java/org/neo4j/graphalgo/impl/results/DoubleArrayResult.java

@@ -3,6 +3,9 @@
 import org.neo4j.graphalgo.core.write.Exporter;
 import org.neo4j.graphalgo.core.write.Translators;
 
+import java.util.Arrays;
+import java.util.function.Function;
+
 public final class DoubleArrayResult implements CentralityResult {
     private final double[] result;
 
@@ -19,6 +22,14 @@ public void export(
                 Translators.DOUBLE_ARRAY_TRANSLATOR);
     }
 
+    @Override
+    public void export(String propertyName, Exporter exporter, Function<Double, Double> normalizationFunction) {
+        exporter.write(
+                propertyName,
+                Arrays.stream(result).map(normalizationFunction::apply).toArray(),
+                Translators.DOUBLE_ARRAY_TRANSLATOR);
+    }
+
     @Override
     public double computeMax() {
         return NormalizationComputations.max(result, 1.0);

algo/src/main/java/org/neo4j/graphalgo/impl/results/NormalizedCentralityResult.java

@@ -14,8 +14,8 @@ public NormalizedCentralityResult(CentralityResult result, Function<Double, Doub
     }
 
     @Override
-    public void export(String propertyName, Exporter exporter) {
-        result.export(propertyName, exporter);
+    public void export(String propertyName, Exporter exporter, Function<Double, Double> normalizationFunction) {
+        result.export(propertyName, exporter, normalizationFunction);
     }
 
     @Override
@@ -28,6 +28,11 @@ public double score(long nodeId) {
         return normalizationFunction.apply(result.score(nodeId));
     }
 
+    @Override
+    public void export(String propertyName, Exporter exporter) {
+        export(propertyName, exporter, normalizationFunction);
+    }
+
     @Override
     public double computeMax() {
         return result.computeMax();

algo/src/main/java/org/neo4j/graphalgo/impl/results/PartitionedDoubleArrayResult.java

@@ -1,8 +1,11 @@
 package org.neo4j.graphalgo.impl.results;
 
+import org.neo4j.graphalgo.CentralityUtils;
 import org.neo4j.graphalgo.core.write.Exporter;
 import org.neo4j.graphalgo.core.write.PropertyTranslator;
 
+import java.util.function.Function;
+
 import static org.neo4j.graphalgo.core.utils.ArrayUtil.binaryLookup;
 
 public final class PartitionedDoubleArrayResult implements CentralityResult, PropertyTranslator.OfDouble<double[][]> {
@@ -21,6 +24,14 @@ public void export(final String propertyName, final Exporter exporter) {
         exporter.write(propertyName, partitions, this);
     }
 
+
+    @Override
+    public void export(String propertyName, Exporter exporter, Function<Double, Double> normalizationFunction) {
+        CentralityUtils.normalizeArray(partitions, normalizationFunction);
+        export(propertyName, exporter);
+    }
+
+
     @Override
     public double computeMax() {
         return NormalizationComputations.max(partitions);

algo/src/main/java/org/neo4j/graphalgo/impl/results/PartitionedPrimitiveDoubleArrayResult.java

@@ -1,8 +1,11 @@
 package org.neo4j.graphalgo.impl.results;
 
+import org.neo4j.graphalgo.CentralityUtils;
 import org.neo4j.graphalgo.core.write.Exporter;
 import org.neo4j.graphalgo.core.write.PropertyTranslator;
 
+import java.util.function.Function;
+
 import static org.neo4j.graphalgo.core.utils.ArrayUtil.binaryLookup;
 
 public final class PartitionedPrimitiveDoubleArrayResult implements CentralityResult, PropertyTranslator.OfDouble<double[][]> {
@@ -27,10 +30,15 @@ public void export(
         );
     }
 
+    @Override
+    public void export(String propertyName, Exporter exporter, Function<Double, Double> normalizationFunction) {
+        CentralityUtils.normalizeArray(partitions, normalizationFunction);
+        export(propertyName, exporter);
+    }
+
     @Override
     public double computeMax() {
         return NormalizationComputations.max(partitions);
-
     }
 
     @Override

algo/src/test/java/org/neo4j/graphalgo/impl/results/CentralityResultTest.java

@@ -1,8 +1,15 @@
 package org.neo4j.graphalgo.impl.results;
 
 import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.neo4j.graphalgo.Normalization;
+import org.neo4j.graphalgo.core.write.Exporter;
+import org.neo4j.graphalgo.core.write.Translators;
+
+import java.util.Arrays;
 
 import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
 
 public class CentralityResultTest {
     @Test
@@ -14,6 +21,18 @@ public void doubleArrayResult() {
         assertEquals(5.477225575051661, result.computeL2Norm(), 0.01);
     }
 
+
+    @Test
+    public void doubleArrayResultExport() {
+        String property = "eigenvector";
+        DoubleArrayResult result = new DoubleArrayResult(new double[] {1,2,3,4});
+
+        Exporter exporter = mock(Exporter.class);
+        Normalization.MAX.apply(result).export(property, exporter);
+
+        verify(exporter).write(property, new double[] {0.25,0.5,0.75,1.0}, Translators.DOUBLE_ARRAY_TRANSLATOR);
+    }
+
     @Test
     public void partitionedPrimitiveDoubleArrayResult() {
         double[][] partitions = new double[][] { {1.0,2.0}, {3.0,4.0} };
@@ -25,6 +44,20 @@ public void partitionedPrimitiveDoubleArrayResult() {
         assertEquals(5.477225575051661, result.computeL2Norm(), 0.01);
     }
 
+    @Test
+    public void partitionedPrimitiveDoubleArrayResultExport() {
+        String property = "eigenvector";
+        double[][] partitions = new double[][] { {1.0,2.0}, {3.0,4.0} };
+        int[] starts = new int[] { 0, 2};
+        PartitionedPrimitiveDoubleArrayResult result = new PartitionedPrimitiveDoubleArrayResult(partitions, starts);
+
+        Exporter exporter = mock(Exporter.class);
+        Normalization.MAX.apply(result).export(property, exporter);
+
+        verify(exporter).write(eq(property), argThat(arrayEq(new double[][] { {0.25, 0.5}, {0.75, 1.0} })), eq(result));
+    }
+
+
     @Test
     public void partitionedDoubleArrayResult() {
         double[][] partitions = new double[][] { {1.0,2.0}, {3.0,4.0} };
@@ -35,4 +68,36 @@ public void partitionedDoubleArrayResult() {
         assertEquals(10.0, result.computeL1Norm(), 0.01);
         assertEquals(5.477225575051661, result.computeL2Norm(), 0.01);
     }
-}
+
+    @Test
+    public void partitionedDoubleArrayResultExport() {
+        String property = "eigenvector";
+        double[][] partitions = new double[][] { {1.0,2.0}, {3.0,4.0} };
+        long[] starts = new long[] { 0, 2};
+        PartitionedDoubleArrayResult result = new PartitionedDoubleArrayResult(partitions, starts);
+
+        Exporter exporter = mock(Exporter.class);
+        Normalization.MAX.apply(result).export(property, exporter);
+
+        verify(exporter).write(eq(property), argThat(arrayEq(new double[][] { {0.25, 0.5}, {0.75, 1.0} })), eq(result));
+    }
+
+
+    private ArrayMatcher arrayEq(double[][] expected) {
+        return new ArrayMatcher(expected);
+    }
+
+
+    class ArrayMatcher implements ArgumentMatcher<double[][]> {
+        private double[][] expected;
+
+        public ArrayMatcher(double[][] expected) {
+            this.expected = expected;
+        }
+
+        @Override
+        public boolean matches(double[][] actual) {
+            return Arrays.deepEquals(expected, actual);
+        }
+    }
+}

algo/src/test/java/org/neo4j/graphalgo/impl/results/NormalizedCentralityResultTest.java

@@ -2,10 +2,10 @@
 
 import org.junit.Test;
 import org.neo4j.graphalgo.Normalization;
+import org.neo4j.graphalgo.core.write.Exporter;
 
 import static org.junit.Assert.*;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
 
 public class NormalizedCentralityResultTest {
     @Test