Merge branch 'master' of github.com:mutalyzer/algebra

algebra/lcs/lcs_graph.py

@@ -204,6 +204,29 @@ def traversal(source, path):
 
         return traversal(self._source, [])
 
+    def uniq_atomics(self):
+        """The set of unique atomics for the whole LCS graph."""
+        atomics = set()
+        for *_, variant in self.bfs_traversal():
+            for idx in range(variant[0].start, variant[0].end):
+                atomics |= {(idx, "")}
+                for ch in set(variant[0].sequence):
+                    atomics |= {(idx, ch)}
+            for ch in set(variant[0].sequence):
+                atomics |= {(variant[0].end, ch)}
+        return atomics
+
+    def overlap(self, other):
+        """The set of common unique atomics and the set of all unique
+        atomics for two LCS graphs."""
+        lhs = self.uniq_atomics()
+        rhs = other.uniq_atomics()
+        return lhs.intersection(rhs), lhs.union(rhs)
+
+    def is_disjoint(self, other):
+        """Are two LCS graphs disjoint."""
+        return self.uniq_atomics().isdisjoint(other.uniq_atomics())
+
 
 def trim(lhs, rhs):
     """Find the lengths of the common prefix and common suffix between

algebra/relations/graph_based.py

@@ -1,7 +1,6 @@
 """Functions to compare LCS graphs."""
 
 
-from itertools import product
 from ..lcs import edit_distance
 from .relation import Relation
 
@@ -74,8 +73,7 @@ def compare(reference, lhs, rhs):
     if rhs.distance - lhs.distance == distance:
         return Relation.IS_CONTAINED
 
-    for lhs_variant, rhs_variant in product(lhs.edges(), rhs.edges()):
-        if not lhs_variant.is_disjoint(rhs_variant):
-            return Relation.OVERLAP
+    if lhs.is_disjoint(rhs):
+        return Relation.DISJOINT
 
-    return Relation.DISJOINT
+    return Relation.OVERLAP

algebra/relations/sequence_based.py

@@ -1,7 +1,6 @@
 """Functions to compare variants as sequences."""
 
 
-from itertools import product
 from .relation import Relation
 from ..lcs import LCSgraph, edit_distance
 
@@ -46,14 +45,7 @@ def are_disjoint(reference, lhs, rhs):
     if distance == abs(lhs_distance - rhs_distance):
         return False
 
-    lhs_graph = LCSgraph.from_sequence(reference, lhs)
-    rhs_graph = LCSgraph.from_sequence(reference, rhs)
-
-    for lhs_variant, rhs_variant in product(lhs_graph.edges(), rhs_graph.edges()):
-        if not lhs_variant.is_disjoint(rhs_variant):
-            return False
-
-    return True
+    return LCSgraph.from_sequence(reference, lhs).is_disjoint(LCSgraph.from_sequence(reference, rhs))
 
 
 def have_overlap(reference, lhs, rhs):
@@ -68,14 +60,7 @@ def have_overlap(reference, lhs, rhs):
     if distance in (lhs_distance + rhs_distance, abs(lhs_distance - rhs_distance)):
         return False
 
-    lhs_graph = LCSgraph.from_sequence(reference, lhs)
-    rhs_graph = LCSgraph.from_sequence(reference, rhs)
-
-    for lhs_variant, rhs_variant in product(lhs_graph.edges(), rhs_graph.edges()):
-        if not lhs_variant.is_disjoint(rhs_variant):
-            return True
-
-    return False
+    return not LCSgraph.from_sequence(reference, lhs).is_disjoint(LCSgraph.from_sequence(reference, rhs))
 
 
 def compare(reference, lhs, rhs):
@@ -112,11 +97,7 @@ def compare(reference, lhs, rhs):
     if rhs_distance - lhs_distance == distance:
         return Relation.IS_CONTAINED
 
-    lhs_graph = LCSgraph.from_sequence(reference, lhs)
-    rhs_graph = LCSgraph.from_sequence(reference, rhs)
-
-    for lhs_variant, rhs_variant in product(lhs_graph.edges(), rhs_graph.edges()):
-        if not lhs_variant.is_disjoint(rhs_variant):
-            return Relation.OVERLAP
+    if LCSgraph.from_sequence(reference, lhs).is_disjoint(LCSgraph.from_sequence(reference, rhs)):
+        return Relation.DISJOINT
 
-    return Relation.DISJOINT
+    return Relation.OVERLAP

scripts/benchmark.py

@@ -2,7 +2,7 @@
 import pstats
 import sys
 from itertools import combinations
-from algebra.lcs import LCSgraph
+from algebra import LCSgraph, Relation
 from algebra.utils import fasta_sequence
 from algebra.variants import parse_hgvs, to_hgvs
 from algebra.relations.graph_based import compare
@@ -36,10 +36,20 @@ def graphs(reference, variants):
 
 @benchmark
 def pairwise(reference, variants):
-    return [{"lhs": lhs["label"],
-             "rhs": rhs["label"],
-             "relation": compare(reference, lhs["graph"], rhs["graph"])
-             } for lhs, rhs in combinations(variants, 2)]
+    results = []
+    for lhs, rhs in combinations(variants, 2):
+        relation = compare(reference, lhs["graph"], rhs["graph"])
+        overlap = None
+        if relation == Relation.OVERLAP:
+            common, universe = lhs["graph"].overlap(rhs["graph"])
+            overlap = len(common), len(universe)
+        results.append({
+            "lhs": lhs["label"],
+            "rhs": rhs["label"],
+            "relation": relation,
+            "overlap": overlap,
+        })
+    return results
 
 
 @benchmark
@@ -73,17 +83,11 @@ def main():
     relations = pairwise(reference, variants)
     with open("data/benchmark_fast_relations.txt", "w", encoding="utf-8") as file:
         for entry in relations:
-            print(entry["lhs"], entry["rhs"], entry["relation"].value, file=file)
+            if entry["overlap"]:
+                print(entry["lhs"], entry["rhs"], entry["relation"].value, *entry["overlap"], file=file)
+            else:
+                print(entry["lhs"], entry["rhs"], entry["relation"].value, file=file)
 
 
 if __name__ == "__main__":
-    #main()
-    graph = large_del()
-    count_nodes = 0
-    count_edges = 0
-    for node in graph.nodes():
-        count_nodes += 1
-        count_edges += len(node.edges)
-        #print(node)
-    print(count_nodes, count_edges)
-    print(graph.count_split)
+    main()