Merge 46bd56b into c5f8afe

.gitignore

@@ -6,4 +6,5 @@ __pycache__/
 .coverage
 mieda.egg-info
 htmlcov
-build
+build
+.ipynb_checkpoints

comparisons/iterative.py

@@ -0,0 +1,77 @@
+def createInterval(start, finish, keys, key):
+    new_interval = {}
+    new_interval["start"] = start
+    new_interval["finish"] = finish
+    new_interval[key] = keys.copy()
+    return new_interval
+
+
+def getMainPermutations(intervals, key):
+    conflicts = False
+    new_intervals = []
+    for start_interval in intervals:
+        for compare_interval in intervals:
+            if start_interval["start"] >= compare_interval["finish"] or start_interval["finish"] <= compare_interval["start"]:
+                continue
+            conflicts = True
+
+            first_finish = start_interval["start"]
+            if start_interval["start"] != compare_interval["start"]:
+                first_start = min(start_interval["start"], compare_interval["start"])
+                first_finish = max(start_interval["start"], compare_interval["start"])
+                keys = start_interval[key] if start_interval["start"] < compare_interval["start"] else compare_interval[key]
+                new_interval = createInterval(first_start, first_finish, keys, key)
+                if new_interval not in new_intervals:
+                    new_intervals.append(new_interval)
+
+            last_start = start_interval["finish"]
+            if start_interval["finish"] != compare_interval["finish"]:
+                last_start = min(start_interval["finish"], compare_interval["finish"])
+                last_finish = max(start_interval["finish"], compare_interval["finish"])
+                keys = start_interval[key] if start_interval["finish"] > compare_interval["finish"] else compare_interval[key]
+                new_interval = createInterval(last_start, last_finish, keys, key)
+                if new_interval not in new_intervals:
+                    new_intervals.append(new_interval)
+
+            new_interval = createInterval(first_finish, last_start, start_interval[key].union(compare_interval[key]), key)
+            if new_interval not in new_intervals:
+                new_intervals.append(new_interval)
+    return conflicts, new_intervals
+
+
+def resolveConflicts(intervals, key):
+    resolved_intervals = []
+    skip = {}
+    unresolved = False
+    for i, start_interval in enumerate(intervals):
+        if (start_interval["start"], start_interval["finish"]) in skip:
+            continue
+
+        conflict = False
+        for j, compare_interval in enumerate(intervals):
+            if start_interval["start"] == compare_interval["start"] and start_interval["finish"] > compare_interval["finish"]:
+                compare_interval[key] = compare_interval[key].union(start_interval[key])
+                conflict = True
+                break
+
+            if start_interval["start"] < compare_interval["start"] < start_interval["finish"]:
+                unresolved = True
+
+            elif (start_interval["start"], start_interval["finish"]) == (compare_interval["start"], compare_interval["finish"]):
+                start_interval[key] = start_interval[key].union(compare_interval[key])
+                skip[(start_interval["start"], start_interval["finish"])] = True
+
+        if not conflict:
+            resolved_intervals.append(start_interval)
+    return unresolved, resolved_intervals
+
+class Merge:
+    @staticmethod
+    def union(intervals: list, key: str = "set_items"):
+        while True:
+            conflict, intervals = getMainPermutations(intervals, key)
+            unresolved, intervals = resolveConflicts(intervals, key) if conflict else (False, intervals)
+            if not unresolved:
+                break
+
+        return intervals

comparisons/iterative_optimized.py

@@ -0,0 +1,36 @@
+from operator import itemgetter
+
+
+def create_interval(start, finish, keys, key):
+    new_interval = {"start": start, "finish": finish}
+    new_interval[key] = keys
+    return new_interval
+
+
+def get_max_list_intervals(max_list, key):
+    max_list = sorted(max_list, key=lambda x: x["point"])
+    intervals = []
+    open_ints = set()
+    last_interval = max_list[0]
+    for interval in max_list:
+        if open_ints and last_interval["point"] != interval["point"]:
+            intervals.append(create_interval(last_interval["point"], interval["point"], open_ints, key))
+        open_ints = open_ints.union(interval["keys"]) if interval["label"] == "start" else open_ints.difference(interval["keys"])
+        last_interval = interval
+    return intervals
+
+
+def create_vertex(interval, label, key):
+    vertex = {"point": interval[label], "keys": interval[key], "label": label}
+    return vertex
+
+
+class Merge:
+    @staticmethod
+    def union(intervals: list, key: str = "set_items"):
+        max_list = []
+        for interval in intervals:
+            max_list.append(create_vertex(interval, "start", key))
+            max_list.append(create_vertex(interval, "finish", key))
+
+        return get_max_list_intervals(max_list, key)