Merge branch '3.4' of github.com:neo4j-contrib/neo4j-graph-algorithms into 3.4

Author: mneedham

algo/src/main/java/org/neo4j/graphalgo/impl/Prim.java

@@ -45,6 +45,7 @@
  */
 public class Prim extends Algorithm<Prim> {
 
+    public static final int UNUSED = 42;
     private final RelationshipIterator relationshipIterator;
     private final RelationshipWeights weights;
     private final int nodeCount;
@@ -90,11 +91,16 @@ private SpanningTree prim(int startNode, boolean max) {
                 if (visited.contains(t)) {
                     return true;
                 }
-                // invert weight to calculate maximum
+                // inverting the weight calculates maximum- instead of minimum spanning tree
                 final double w = max ? -weights.weightOf(s, t) : weights.weightOf(s, t);
                 if (w < cost.getOrDefault(t, Double.MAX_VALUE)) {
-                    cost.put(t, w);
-                    queue.add(t, -1.0);
+                    if (cost.containsKey(t)) {
+                        cost.put(t, w);
+                        queue.update(t);
+                    } else {
+                        cost.put(t, w);
+                        queue.add(t, w);
+                    }
                     spanningTree.parent[t] = s;
                 }
                 return true;

algo/src/main/java/org/neo4j/graphalgo/impl/ShortestPathDijkstra.java

@@ -39,6 +39,7 @@ public class ShortestPathDijkstra extends Algorithm<ShortestPathDijkstra> {
 
     private static final int PATH_END = -1;
     public static final double NO_PATH_FOUND = -1.0;
+    public static final int UNUSED = 42;
 
     private Graph graph;
 
@@ -152,28 +153,28 @@ private void run(int goal, Direction direction) {
             graph.forEachRelationship(
                     node,
                     direction, (source, target, relId, weight) -> {
-                        boolean oldCostChanged = updateCosts(source, target, weight + costs);
-                        if (!visited.get(target)) {
-                            if (oldCostChanged) {
-                                queue.update(target);
-                            } else {
-                                queue.add(target, 0);
-                            }
-                        }
+                        updateCosts(source, target, weight + costs);
                         return true;
                     });
             progressLogger.logProgress((double) node / (nodeCount - 1));
         }
     }
 
-    private boolean updateCosts(int source, int target, double newCosts) {
-        double oldCosts = costs.getOrDefault(target, Double.MAX_VALUE);
-        if (newCosts < oldCosts) {
-            costs.put(target, newCosts);
-            path.put(target, source);
-            return oldCosts < Double.MAX_VALUE;
+    private void updateCosts(int source, int target, double newCosts) {
+
+        if (costs.containsKey(target)) {
+            if (newCosts < costs.getOrDefault(target, Double.MAX_VALUE)) {
+                costs.put(target, newCosts);
+                path.put(target, source);
+                queue.update(target);
+            }
+        } else  {
+            if (newCosts < costs.getOrDefault(target, Double.MAX_VALUE)) {
+                costs.put(target, newCosts);
+                path.put(target, source);
+                queue.add(target, newCosts);
+            }
         }
-        return false;
     }
 
     @Override

algo/src/main/java/org/neo4j/graphalgo/impl/ShortestPaths.java

@@ -99,7 +99,7 @@ private void run() {
                         final double targetCosts = this.costs.getOrDefault(target, Double.POSITIVE_INFINITY);
                         if (weight + sourceCosts < targetCosts) {
                             costs.put(target, weight + sourceCosts);
-                            queue.set(target, targetCosts);
+                            queue.set(target, weight + sourceCosts);
                         }
                         return true;
                     });

algo/src/main/java/org/neo4j/graphalgo/impl/spanningTrees/KSpanningTree.java

@@ -29,8 +29,6 @@
 import org.neo4j.graphalgo.results.AbstractResultBuilder;
 
 /**
- * Sequential Single-Source minimum weight spanning tree algorithm (PRIM).
- * <p>
  * The algorithm computes the MST by traversing all nodes from a given
  * startNodeId. It aggregates all transitions into a MinPriorityQueue
  * and visits each (unvisited) connected node by following only the

algo/src/main/java/org/neo4j/graphalgo/impl/spanningTrees/Prim.java

@@ -86,8 +86,13 @@ private SpanningTree prim(int startNode, boolean max) {
                 // invert weight to calculate maximum
                 final double w = max ? -weights.weightOf(s, t) : weights.weightOf(s, t);
                 if (w < cost.getOrDefault(t, Double.MAX_VALUE)) {
-                    cost.put(t, w);
-                    queue.add(t, -1.0);
+                    if (cost.containsKey(t)) {
+                        cost.put(t, w);
+                        queue.update(t);
+                    } else {
+                        cost.put(t, w);
+                        queue.add(t, -1.0);
+                    }
                     parent[t] = s;
                 }
                 return true;

algo/src/main/java/org/neo4j/graphalgo/impl/yens/Dijkstra.java

@@ -24,7 +24,6 @@
 import org.neo4j.graphalgo.core.utils.TerminationFlag;
 import org.neo4j.graphalgo.core.utils.queue.IntPriorityQueue;
 import org.neo4j.graphalgo.core.utils.queue.SharedIntPriorityQueue;
-import org.neo4j.graphalgo.core.utils.traverse.SimpleBitSet;
 import org.neo4j.graphdb.Direction;
 
 import java.util.Arrays;
@@ -38,18 +37,19 @@
 public class Dijkstra {
 
     // initial weighted path capacity
+
     public static final int INITIAL_CAPACITY = 64;
 
     private static final int PATH_END = -1;
-
     private final Graph graph;
+
     private final int nodeCount;
 
     private TerminationFlag terminationFlag = TerminationFlag.RUNNING_TRUE;
-
     // node to cost map
     private final IntDoubleMap costs;
     // next node priority queue
+
     private final IntPriorityQueue queue;
     // auxiliary path map
     private final IntIntMap path;
@@ -157,7 +157,8 @@ private boolean dijkstra(int source, int target, Direction direction, int maxDep
         visited.clear();
         costs.put(source, 0.0);
         queue.add(source, 0.0);
-        Arrays.fill(depth, 1);
+        Arrays.fill(depth, 0);
+        depth[source] = 1;
         while (!queue.isEmpty() && terminationFlag.running()) {
             int node = queue.pop();
             final int d = depth[node];
@@ -176,32 +177,49 @@ private boolean dijkstra(int source, int target, Direction direction, int maxDep
                             return true;
                         }
                         final double w = graph.weightOf(s, t);
-                        final boolean updateCosts = updateCosts(s, t, w + costs);
+                        final UpdateResult updateCosts = updateCosts(s, t, w + costs);
                         if (!visited.get(t)) {
-                            depth[t] = d + 1;
-                            if (updateCosts) {
-                                queue.update(t);
-                            } else {
-                                queue.add(t, w);
+                            switch (updateCosts) {
+                                case NO_PREVIOUS_COSTS:
+                                    queue.add(t, w);
+                                    break;
+                                case UPDATED_COST:
+                                    queue.update(t);
+                                    break;
+                                default:
+                                    break;
                             }
+                            depth[t] = depth[s] + 1;
                         }
                         return terminationFlag.running();
                     });
         }
         return false;
     }
 
+
     /**
      * update cost map
      */
-    private boolean updateCosts(int source, int target, double newCosts) {
+    private UpdateResult updateCosts(int source, int target, double newCosts) {
         double oldCosts = costs.getOrDefault(target, Double.MAX_VALUE);
+        if (oldCosts == Double.MAX_VALUE) {
+            if (!costs.containsKey(target)) {
+                costs.put(target, newCosts);
+                path.put(target, source);
+                return UpdateResult.NO_PREVIOUS_COSTS;
+            }
+        }
         if (newCosts < oldCosts) {
             costs.put(target, newCosts);
             path.put(target, source);
-            return oldCosts < Double.MAX_VALUE;
+            return UpdateResult.UPDATED_COST;
         }
-        return false;
+        return UpdateResult.COST_NOT_COMPETITIVE;
+    }
+
+    private enum UpdateResult {
+        NO_PREVIOUS_COSTS, UPDATED_COST, COST_NOT_COMPETITIVE;
     }
 
 }

algo/src/main/java/org/neo4j/graphalgo/similarity/CategoricalInput.java

@@ -26,4 +26,21 @@ SimilarityResult jaccard(double similarityCutoff, CategoricalInput e2) {
         if (jaccard < similarityCutoff) return null;
         return new SimilarityResult(id, e2.id, count1, count2, intersection, jaccard);
     }
+
+    SimilarityResult overlap(double similarityCutoff, CategoricalInput e2) {
+        long intersection = Intersections.intersection3(targets, e2.targets);
+        if (similarityCutoff >= 0d && intersection == 0) return null;
+        int count1 = targets.length;
+        int count2 = e2.targets.length;
+        long denominator = Math.min(count1, count2);
+        double overlap = denominator == 0 ? 0 : (double)intersection / denominator;
+        if (overlap < similarityCutoff) return null;
+
+        if(count1 <= count2) {
+            return new SimilarityResult(id, e2.id, count1, count2, intersection, overlap, false, false);
+        } else {
+            return new SimilarityResult(e2.id, id, count2, count1, intersection, overlap, false, true);
+        }
+
+    }
 }

algo/src/main/java/org/neo4j/graphalgo/similarity/CosineProc.java

@@ -81,7 +81,7 @@ public Stream<SimilaritySummaryResult> cosine(
 
 
         boolean write = configuration.isWriteFlag(false) && similarityCutoff > 0.0;
-        return writeAndAggregateResults(configuration, stream, inputs.length, write);
+        return writeAndAggregateResults(configuration, stream, inputs.length, write, "SIMILAR");
     }
 
 

algo/src/main/java/org/neo4j/graphalgo/similarity/EuclideanProc.java

@@ -80,7 +80,7 @@ public Stream<SimilaritySummaryResult> euclidean(
                 .map(SimilarityResult::squareRooted);
 
         boolean write = configuration.isWriteFlag(false); //  && similarityCutoff != 0.0;
-        return writeAndAggregateResults(configuration, stream, inputs.length, write);
+        return writeAndAggregateResults(configuration, stream, inputs.length, write, "SIMILAR");
     }
 
 

algo/src/main/java/org/neo4j/graphalgo/similarity/JaccardProc.java

@@ -61,7 +61,7 @@ public Stream<SimilaritySummaryResult> jaccard(
         Stream<SimilarityResult> stream = topN(similarityStream(inputs, computer, configuration, similarityCutoff, getTopK(configuration)), getTopN(configuration));
 
         boolean write = configuration.isWriteFlag(false) && similarityCutoff > 0.0;
-        return writeAndAggregateResults(configuration, stream, inputs.length, write);
+        return writeAndAggregateResults(configuration, stream, inputs.length, write, "SIMILAR");
     }