refactored ordered set

src/mol-base/_spec/collections.spec.ts

@@ -7,7 +7,6 @@
 import Iterator from '../collections/iterator'
 import IntTuple from '../collections/int-tuple'
 import * as Sort from '../collections/sort'
-import OrderedSet from '../collections/ordered-set'
 import LinkedIndex from '../collections/linked-index'
 import EquivalenceClasses from '../collections/equivalence-classes'
 import Interval from '../collections/interval'
@@ -235,175 +234,6 @@ describe('sortedArray', () => {
     testI('findRange', SortedArray.findRange(a2468, 2, 4), Interval.ofRange(0, 1));
 });
 
-describe('ordered set', () => {
-    function ordSetToArray(set: OrderedSet) {
-        const ret = [];
-        for (let i = 0, _i = OrderedSet.size(set); i < _i; i++) ret.push(OrderedSet.getAt(set, i));
-        return ret;
-    }
-
-    function testEq(name: string, set: OrderedSet, expected: number[]) {
-        it(name, () => {
-            // copy the arrays to ensure "compatibility" between typed and native arrays
-            expect(Array.prototype.slice.call(ordSetToArray(set))).toEqual(Array.prototype.slice.call(expected));
-        });
-    }
-
-    const empty = OrderedSet.Empty;
-    const singleton10 = OrderedSet.ofSingleton(10);
-    const range1_4 = OrderedSet.ofRange(1, 4);
-    const arr136 = OrderedSet.ofSortedArray([1, 3, 6]);
-
-    testEq('empty', empty, []);
-    testEq('singleton', singleton10, [10]);
-    testEq('range', range1_4, [1, 2, 3, 4]);
-    testEq('sorted array', arr136, [1, 3, 6]);
-
-    it('equality', () => {
-        expect(OrderedSet.areEqual(empty, singleton10)).toBe(false);
-        expect(OrderedSet.areEqual(singleton10, singleton10)).toBe(true);
-        expect(OrderedSet.areEqual(range1_4, singleton10)).toBe(false);
-        expect(OrderedSet.areEqual(arr136, OrderedSet.ofSortedArray([1, 3, 6]))).toBe(true);
-        expect(OrderedSet.areEqual(arr136, OrderedSet.ofSortedArray([1, 4, 6]))).toBe(false);
-    });
-
-    it('areIntersecting', () => {
-        expect(OrderedSet.areIntersecting(range1_4, arr136)).toBe(true);
-        expect(OrderedSet.areIntersecting(empty, empty)).toBe(true);
-        expect(OrderedSet.areIntersecting(empty, singleton10)).toBe(false);
-        expect(OrderedSet.areIntersecting(empty, range1_4)).toBe(false);
-        expect(OrderedSet.areIntersecting(empty, arr136)).toBe(false);
-    });
-
-    it('isSubset', () => {
-        expect(OrderedSet.isSubset(singleton10, empty)).toBe(true);
-        expect(OrderedSet.isSubset(range1_4, empty)).toBe(true);
-        expect(OrderedSet.isSubset(arr136, empty)).toBe(true);
-        expect(OrderedSet.isSubset(empty, empty)).toBe(true);
-        expect(OrderedSet.isSubset(empty, singleton10)).toBe(false);
-        expect(OrderedSet.isSubset(empty, range1_4)).toBe(false);
-        expect(OrderedSet.isSubset(empty, arr136)).toBe(false);
-
-        expect(OrderedSet.isSubset(singleton10, range1_4)).toBe(false);
-        expect(OrderedSet.isSubset(range1_4, OrderedSet.ofRange(2, 3))).toBe(true);
-        expect(OrderedSet.isSubset(arr136, range1_4)).toBe(false);
-        expect(OrderedSet.isSubset(arr136, arr136)).toBe(true);
-        expect(OrderedSet.isSubset(arr136, OrderedSet.ofSortedArray([1, 3]))).toBe(true);
-        expect(OrderedSet.isSubset(arr136, OrderedSet.ofSortedArray([1, 3, 7]))).toBe(false);
-        expect(OrderedSet.isSubset(OrderedSet.ofSortedArray([0, 1, 2, 3, 7, 10]), OrderedSet.ofSortedArray([1, 3, 7]))).toBe(true);
-        expect(OrderedSet.isSubset(arr136, OrderedSet.ofSortedArray([1, 3, 10, 45]))).toBe(false);
-        expect(OrderedSet.isSubset(arr136, OrderedSet.ofSortedArray([12, 13, 16]))).toBe(false);
-    });
-
-    it('access/membership', () => {
-        expect(OrderedSet.has(empty, 10)).toBe(false);
-        expect(OrderedSet.indexOf(empty, 10)).toBe(-1);
-
-        expect(OrderedSet.has(singleton10, 10)).toBe(true);
-        expect(OrderedSet.has(singleton10, 11)).toBe(false);
-        expect(OrderedSet.indexOf(singleton10, 10)).toBe(0);
-        expect(OrderedSet.indexOf(singleton10, 11)).toBe(-1);
-
-        expect(OrderedSet.has(range1_4, 4)).toBe(true);
-        expect(OrderedSet.has(range1_4, 5)).toBe(false);
-        expect(OrderedSet.indexOf(range1_4, 4)).toBe(3);
-        expect(OrderedSet.indexOf(range1_4, 11)).toBe(-1);
-
-        expect(OrderedSet.has(arr136, 3)).toBe(true);
-        expect(OrderedSet.has(arr136, 4)).toBe(false);
-        expect(OrderedSet.indexOf(arr136, 3)).toBe(1);
-        expect(OrderedSet.indexOf(arr136, 11)).toBe(-1);
-    });
-
-    it('interval range', () => {
-        expect(OrderedSet.findIntervalRange(empty, 9, 11)).toEqual({ start: 0, end: 0 });
-        expect(OrderedSet.findIntervalRange(empty, -9, -6)).toEqual({ start: 0, end: 0 });
-        expect(OrderedSet.findIntervalRange(singleton10, 9, 11)).toEqual({ start: 0, end: 1 });
-        expect(OrderedSet.findIntervalRange(range1_4, 2, 3)).toEqual({ start: 1, end: 3 });
-        expect(OrderedSet.findIntervalRange(range1_4, -10, 2)).toEqual({ start: 0, end: 2 });
-        expect(OrderedSet.findIntervalRange(range1_4, -10, 20)).toEqual({ start: 0, end: 4 });
-        expect(OrderedSet.findIntervalRange(range1_4, 3, 20)).toEqual({ start: 2, end: 4 });
-        expect(OrderedSet.findIntervalRange(arr136, 0, 1)).toEqual({ start: 0, end: 1 });
-        expect(OrderedSet.findIntervalRange(arr136, 0, 3)).toEqual({ start: 0, end: 2 });
-        expect(OrderedSet.findIntervalRange(arr136, 0, 4)).toEqual({ start: 0, end: 2 });
-        expect(OrderedSet.findIntervalRange(arr136, 2, 4)).toEqual({ start: 1, end: 2 });
-        expect(OrderedSet.findIntervalRange(arr136, 2, 7)).toEqual({ start: 1, end: 3 });
-    })
-
-    testEq('union ES', OrderedSet.union(empty, singleton10), [10]);
-    testEq('union ER', OrderedSet.union(empty, range1_4), [1, 2, 3, 4]);
-    testEq('union EA', OrderedSet.union(empty, arr136), [1, 3, 6]);
-    testEq('union SS', OrderedSet.union(singleton10, OrderedSet.ofSingleton(16)), [10, 16]);
-    testEq('union SR', OrderedSet.union(range1_4, singleton10), [1, 2, 3, 4, 10]);
-    testEq('union SA', OrderedSet.union(arr136, singleton10), [1, 3, 6, 10]);
-    testEq('union SA1', OrderedSet.union(arr136, OrderedSet.ofSingleton(3)), [1, 3, 6]);
-    testEq('union RR', OrderedSet.union(range1_4, range1_4), [1, 2, 3, 4]);
-    testEq('union RR1', OrderedSet.union(range1_4, OrderedSet.ofRange(6, 7)), [1, 2, 3, 4, 6, 7]);
-    testEq('union RR2', OrderedSet.union(range1_4, OrderedSet.ofRange(3, 5)), [1, 2, 3, 4, 5]);
-    testEq('union RA', OrderedSet.union(range1_4, arr136), [1, 2, 3, 4, 6]);
-    testEq('union AA', OrderedSet.union(arr136, OrderedSet.ofSortedArray([2, 4, 6, 7])), [1, 2, 3, 4, 6, 7]);
-    testEq('union AA1', OrderedSet.union(arr136, OrderedSet.ofSortedArray([2, 3, 4, 6, 7])), [1, 2, 3, 4, 6, 7]);
-    testEq('union AA2', OrderedSet.union(arr136, OrderedSet.ofSortedArray([2, 4, 5, 6, 7])), [1, 2, 3, 4, 5, 6, 7]);
-    testEq('union AA3', OrderedSet.union(OrderedSet.ofSortedArray([1, 3]), OrderedSet.ofSortedArray([2, 4])), [1, 2, 3, 4]);
-    testEq('union AA4', OrderedSet.union(OrderedSet.ofSortedArray([1, 3]), OrderedSet.ofSortedArray([1, 3, 4])), [1, 3, 4]);
-    testEq('union AA5', OrderedSet.union(OrderedSet.ofSortedArray([1, 3, 4]), OrderedSet.ofSortedArray([1, 3])), [1, 3, 4]);
-    it('union AA6', () => expect(OrderedSet.union(arr136, OrderedSet.ofSortedArray([1, 3, 6]))).toBe(arr136));
-
-    testEq('intersect ES', OrderedSet.intersect(empty, singleton10), []);
-    testEq('intersect ER', OrderedSet.intersect(empty, range1_4), []);
-    testEq('intersect EA', OrderedSet.intersect(empty, arr136), []);
-    testEq('intersect SS', OrderedSet.intersect(singleton10, OrderedSet.ofSingleton(16)), []);
-    testEq('intersect SS1', OrderedSet.intersect(singleton10, singleton10), [10]);
-    testEq('intersect SR', OrderedSet.intersect(range1_4, singleton10), []);
-    testEq('intersect RR', OrderedSet.intersect(range1_4, range1_4), [1, 2, 3, 4]);
-    testEq('intersect RR2', OrderedSet.intersect(range1_4, OrderedSet.ofRange(3, 5)), [3, 4]);
-    testEq('intersect RA', OrderedSet.intersect(range1_4, arr136), [1, 3]);
-    testEq('intersect AA', OrderedSet.intersect(arr136, OrderedSet.ofSortedArray([2, 3, 4, 6, 7])), [3, 6]);
-    it('intersect AA1', () => expect(OrderedSet.union(arr136, OrderedSet.ofSortedArray([1, 3, 6]))).toBe(arr136));
-
-    testEq('subtract ES', OrderedSet.subtract(empty, singleton10), []);
-    testEq('subtract ER', OrderedSet.subtract(empty, range1_4), []);
-    testEq('subtract EA', OrderedSet.subtract(empty, arr136), []);
-    testEq('subtract SS', OrderedSet.subtract(singleton10, OrderedSet.ofSingleton(16)), [10]);
-    testEq('subtract SS1', OrderedSet.subtract(singleton10, singleton10), []);
-    testEq('subtract SR', OrderedSet.subtract(range1_4, singleton10), [1, 2, 3, 4]);
-    testEq('subtract SR1', OrderedSet.subtract(range1_4, OrderedSet.ofSingleton(4)), [1, 2, 3]);
-    testEq('subtract SR2', OrderedSet.subtract(range1_4, OrderedSet.ofSingleton(3)), [1, 2, 4]);
-    testEq('subtract RR', OrderedSet.subtract(range1_4, range1_4), []);
-    testEq('subtract RR1', OrderedSet.subtract(range1_4, OrderedSet.ofRange(3, 5)), [1, 2]);
-
-    testEq('subtract RA', OrderedSet.subtract(range1_4, arr136), [2, 4]);
-    testEq('subtract RA1', OrderedSet.subtract(range1_4, OrderedSet.ofSortedArray([0, 1, 2, 3, 4, 7])), []);
-    testEq('subtract RA2', OrderedSet.subtract(range1_4, OrderedSet.ofSortedArray([0, 2, 3])), [1, 4]);
-
-    testEq('subtract AR', OrderedSet.subtract(arr136, range1_4), [6]);
-    testEq('subtract AR1', OrderedSet.subtract(arr136, OrderedSet.ofRange(0, 10)), []);
-    testEq('subtract AR1', OrderedSet.subtract(arr136, OrderedSet.ofRange(2, 10)), [1]);
-
-    testEq('subtract AA', OrderedSet.subtract(arr136, arr136), []);
-    testEq('subtract AA1', OrderedSet.subtract(arr136, OrderedSet.ofSortedArray([2, 3, 4, 6, 7])), [1]);
-    testEq('subtract AA2', OrderedSet.subtract(arr136, OrderedSet.ofSortedArray([0, 1, 6])), [3]);
-
-    it('segments', () => {
-        const data = OrderedSet.ofSortedArray([4, 9, 10, 11, 14, 15, 16]);
-        const segs = OrderedSet.ofSortedArray([0, 4, 10, 12, 13, 15, 25]);
-        const it = OrderedSet.segments(segs, data);
-
-        const t = Object.create(null);
-        for (let s = it.move(); !it.done; s = it.move()) {
-            for (let j = s.start; j < s.end; j++) {
-                const x = t[s.segment];
-                const v = OrderedSet.getAt(data, j);
-                if (!x) t[s.segment] = [v];
-                else x[x.length] = v;
-            }
-        }
-
-        expect(t).toEqual({ 1: [4, 9], 2: [10, 11], 4: [14], 5: [15, 16] });
-    });
-});
-
-
 describe('linked-index', () => {
     it('initial state', () => {
         const index = LinkedIndex(2);

src/mol-base/_spec/ordered-set.spec.ts

@@ -0,0 +1,178 @@
+/**
+ * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import OrderedSet from '../collections/ordered-set'
+import Interval from '../collections/interval'
+
+describe('ordered set', () => {
+    function ordSetToArray(set: OrderedSet) {
+        const ret = [];
+        for (let i = 0, _i = OrderedSet.size(set); i < _i; i++) ret.push(OrderedSet.getAt(set, i));
+        return ret;
+    }
+
+    function testEq(name: string, set: OrderedSet, expected: number[]) {
+        it(name, () => {
+            // copy the arrays to ensure "compatibility" between typed and native arrays
+            expect(Array.prototype.slice.call(ordSetToArray(set))).toEqual(Array.prototype.slice.call(expected));
+        });
+    }
+
+    const empty = OrderedSet.Empty;
+    const singleton10 = OrderedSet.ofSingleton(10);
+    const range1_4 = OrderedSet.ofRange(1, 4);
+    const arr136 = OrderedSet.ofSortedArray([1, 3, 6]);
+
+    const iB = (s: number, e: number) => Interval.ofBounds(s, e);
+
+    testEq('empty', empty, []);
+    testEq('singleton', singleton10, [10]);
+    testEq('range', range1_4, [1, 2, 3, 4]);
+    testEq('sorted array', arr136, [1, 3, 6]);
+
+    it('equality', () => {
+        expect(OrderedSet.areEqual(empty, singleton10)).toBe(false);
+        expect(OrderedSet.areEqual(singleton10, singleton10)).toBe(true);
+        expect(OrderedSet.areEqual(range1_4, singleton10)).toBe(false);
+        expect(OrderedSet.areEqual(arr136, OrderedSet.ofSortedArray([1, 3, 6]))).toBe(true);
+        expect(OrderedSet.areEqual(arr136, OrderedSet.ofSortedArray([1, 4, 6]))).toBe(false);
+    });
+
+    it('areIntersecting', () => {
+        expect(OrderedSet.areIntersecting(range1_4, arr136)).toBe(true);
+        expect(OrderedSet.areIntersecting(empty, empty)).toBe(true);
+        expect(OrderedSet.areIntersecting(empty, singleton10)).toBe(false);
+        expect(OrderedSet.areIntersecting(empty, range1_4)).toBe(false);
+        expect(OrderedSet.areIntersecting(empty, arr136)).toBe(false);
+    });
+
+    it('isSubset', () => {
+        expect(OrderedSet.isSubset(singleton10, empty)).toBe(true);
+        expect(OrderedSet.isSubset(range1_4, empty)).toBe(true);
+        expect(OrderedSet.isSubset(arr136, empty)).toBe(true);
+        expect(OrderedSet.isSubset(empty, empty)).toBe(true);
+        expect(OrderedSet.isSubset(empty, singleton10)).toBe(false);
+        expect(OrderedSet.isSubset(empty, range1_4)).toBe(false);
+        expect(OrderedSet.isSubset(empty, arr136)).toBe(false);
+
+        expect(OrderedSet.isSubset(singleton10, range1_4)).toBe(false);
+        expect(OrderedSet.isSubset(range1_4, OrderedSet.ofRange(2, 3))).toBe(true);
+        expect(OrderedSet.isSubset(arr136, range1_4)).toBe(false);
+        expect(OrderedSet.isSubset(arr136, arr136)).toBe(true);
+        expect(OrderedSet.isSubset(arr136, OrderedSet.ofSortedArray([1, 3]))).toBe(true);
+        expect(OrderedSet.isSubset(arr136, OrderedSet.ofSortedArray([1, 3, 7]))).toBe(false);
+        expect(OrderedSet.isSubset(OrderedSet.ofSortedArray([0, 1, 2, 3, 7, 10]), OrderedSet.ofSortedArray([1, 3, 7]))).toBe(true);
+        expect(OrderedSet.isSubset(arr136, OrderedSet.ofSortedArray([1, 3, 10, 45]))).toBe(false);
+        expect(OrderedSet.isSubset(arr136, OrderedSet.ofSortedArray([12, 13, 16]))).toBe(false);
+    });
+
+    it('access/membership', () => {
+        expect(OrderedSet.has(empty, 10)).toBe(false);
+        expect(OrderedSet.indexOf(empty, 10)).toBe(-1);
+
+        expect(OrderedSet.has(singleton10, 10)).toBe(true);
+        expect(OrderedSet.has(singleton10, 11)).toBe(false);
+        expect(OrderedSet.indexOf(singleton10, 10)).toBe(0);
+        expect(OrderedSet.indexOf(singleton10, 11)).toBe(-1);
+
+        expect(OrderedSet.has(range1_4, 4)).toBe(true);
+        expect(OrderedSet.has(range1_4, 5)).toBe(false);
+        expect(OrderedSet.indexOf(range1_4, 4)).toBe(3);
+        expect(OrderedSet.indexOf(range1_4, 11)).toBe(-1);
+
+        expect(OrderedSet.has(arr136, 3)).toBe(true);
+        expect(OrderedSet.has(arr136, 4)).toBe(false);
+        expect(OrderedSet.indexOf(arr136, 3)).toBe(1);
+        expect(OrderedSet.indexOf(arr136, 11)).toBe(-1);
+    });
+
+    it('interval range', () => {
+        expect(OrderedSet.findRange(empty, 9, 11)).toEqual(iB(0, 0));
+        expect(OrderedSet.findRange(empty, -9, -6)).toEqual(iB(0, 0));
+        expect(OrderedSet.findRange(singleton10, 9, 11)).toEqual(iB(0, 1));
+        expect(OrderedSet.findRange(range1_4, 2, 3)).toEqual(iB(1, 3));
+        expect(OrderedSet.findRange(range1_4, -10, 2)).toEqual(iB(0, 2));
+        expect(OrderedSet.findRange(range1_4, -10, 20)).toEqual(iB(0, 4));
+        expect(OrderedSet.findRange(range1_4, 3, 20)).toEqual(iB(2, 4));
+        expect(OrderedSet.findRange(arr136, 0, 1)).toEqual(iB(0, 1));
+        expect(OrderedSet.findRange(arr136, 0, 3)).toEqual(iB(0, 2));
+        expect(OrderedSet.findRange(arr136, 0, 4)).toEqual(iB(0, 2));
+        expect(OrderedSet.findRange(arr136, 2, 4)).toEqual(iB(1, 2));
+        expect(OrderedSet.findRange(arr136, 2, 7)).toEqual(iB(1, 3));
+    })
+
+    testEq('union ES', OrderedSet.union(empty, singleton10), [10]);
+    testEq('union ER', OrderedSet.union(empty, range1_4), [1, 2, 3, 4]);
+    testEq('union EA', OrderedSet.union(empty, arr136), [1, 3, 6]);
+    testEq('union SS', OrderedSet.union(singleton10, OrderedSet.ofSingleton(16)), [10, 16]);
+    testEq('union SR', OrderedSet.union(range1_4, singleton10), [1, 2, 3, 4, 10]);
+    testEq('union SA', OrderedSet.union(arr136, singleton10), [1, 3, 6, 10]);
+    testEq('union SA1', OrderedSet.union(arr136, OrderedSet.ofSingleton(3)), [1, 3, 6]);
+    testEq('union RR', OrderedSet.union(range1_4, range1_4), [1, 2, 3, 4]);
+    testEq('union RR1', OrderedSet.union(range1_4, OrderedSet.ofRange(6, 7)), [1, 2, 3, 4, 6, 7]);
+    testEq('union RR2', OrderedSet.union(range1_4, OrderedSet.ofRange(3, 5)), [1, 2, 3, 4, 5]);
+    testEq('union RA', OrderedSet.union(range1_4, arr136), [1, 2, 3, 4, 6]);
+    testEq('union AA', OrderedSet.union(arr136, OrderedSet.ofSortedArray([2, 4, 6, 7])), [1, 2, 3, 4, 6, 7]);
+    testEq('union AA1', OrderedSet.union(arr136, OrderedSet.ofSortedArray([2, 3, 4, 6, 7])), [1, 2, 3, 4, 6, 7]);
+    testEq('union AA2', OrderedSet.union(arr136, OrderedSet.ofSortedArray([2, 4, 5, 6, 7])), [1, 2, 3, 4, 5, 6, 7]);
+    testEq('union AA3', OrderedSet.union(OrderedSet.ofSortedArray([1, 3]), OrderedSet.ofSortedArray([2, 4])), [1, 2, 3, 4]);
+    testEq('union AA4', OrderedSet.union(OrderedSet.ofSortedArray([1, 3]), OrderedSet.ofSortedArray([1, 3, 4])), [1, 3, 4]);
+    testEq('union AA5', OrderedSet.union(OrderedSet.ofSortedArray([1, 3, 4]), OrderedSet.ofSortedArray([1, 3])), [1, 3, 4]);
+    it('union AA6', () => expect(OrderedSet.union(arr136, OrderedSet.ofSortedArray([1, 3, 6]))).toBe(arr136));
+
+    testEq('intersect ES', OrderedSet.intersect(empty, singleton10), []);
+    testEq('intersect ER', OrderedSet.intersect(empty, range1_4), []);
+    testEq('intersect EA', OrderedSet.intersect(empty, arr136), []);
+    testEq('intersect SS', OrderedSet.intersect(singleton10, OrderedSet.ofSingleton(16)), []);
+    testEq('intersect SS1', OrderedSet.intersect(singleton10, singleton10), [10]);
+    testEq('intersect SR', OrderedSet.intersect(range1_4, singleton10), []);
+    testEq('intersect RR', OrderedSet.intersect(range1_4, range1_4), [1, 2, 3, 4]);
+    testEq('intersect RR2', OrderedSet.intersect(range1_4, OrderedSet.ofRange(3, 5)), [3, 4]);
+    testEq('intersect RA', OrderedSet.intersect(range1_4, arr136), [1, 3]);
+    testEq('intersect AA', OrderedSet.intersect(arr136, OrderedSet.ofSortedArray([2, 3, 4, 6, 7])), [3, 6]);
+    it('intersect AA1', () => expect(OrderedSet.union(arr136, OrderedSet.ofSortedArray([1, 3, 6]))).toBe(arr136));
+
+    testEq('subtract ES', OrderedSet.subtract(empty, singleton10), []);
+    testEq('subtract ER', OrderedSet.subtract(empty, range1_4), []);
+    testEq('subtract EA', OrderedSet.subtract(empty, arr136), []);
+    testEq('subtract SS', OrderedSet.subtract(singleton10, OrderedSet.ofSingleton(16)), [10]);
+    testEq('subtract SS1', OrderedSet.subtract(singleton10, singleton10), []);
+    testEq('subtract SR', OrderedSet.subtract(range1_4, singleton10), [1, 2, 3, 4]);
+    testEq('subtract SR1', OrderedSet.subtract(range1_4, OrderedSet.ofSingleton(4)), [1, 2, 3]);
+    testEq('subtract SR2', OrderedSet.subtract(range1_4, OrderedSet.ofSingleton(3)), [1, 2, 4]);
+    testEq('subtract RR', OrderedSet.subtract(range1_4, range1_4), []);
+    testEq('subtract RR1', OrderedSet.subtract(range1_4, OrderedSet.ofRange(3, 5)), [1, 2]);
+
+    testEq('subtract RA', OrderedSet.subtract(range1_4, arr136), [2, 4]);
+    testEq('subtract RA1', OrderedSet.subtract(range1_4, OrderedSet.ofSortedArray([0, 1, 2, 3, 4, 7])), []);
+    testEq('subtract RA2', OrderedSet.subtract(range1_4, OrderedSet.ofSortedArray([0, 2, 3])), [1, 4]);
+
+    testEq('subtract AR', OrderedSet.subtract(arr136, range1_4), [6]);
+    testEq('subtract AR1', OrderedSet.subtract(arr136, OrderedSet.ofRange(0, 10)), []);
+    testEq('subtract AR1', OrderedSet.subtract(arr136, OrderedSet.ofRange(2, 10)), [1]);
+
+    testEq('subtract AA', OrderedSet.subtract(arr136, arr136), []);
+    testEq('subtract AA1', OrderedSet.subtract(arr136, OrderedSet.ofSortedArray([2, 3, 4, 6, 7])), [1]);
+    testEq('subtract AA2', OrderedSet.subtract(arr136, OrderedSet.ofSortedArray([0, 1, 6])), [3]);
+
+    it('segments', () => {
+        const data = OrderedSet.ofSortedArray([4, 9, 10, 11, 14, 15, 16]);
+        const segs = OrderedSet.ofSortedArray([0, 4, 10, 12, 13, 15, 25]);
+        const it = OrderedSet.segments(segs, data);
+
+        const t = Object.create(null);
+        for (let s = it.move(); !it.done; s = it.move()) {
+            for (let j = s.start; j < s.end; j++) {
+                const x = t[s.segment];
+                const v = OrderedSet.getAt(data, j);
+                if (!x) t[s.segment] = [v];
+                else x[x.length] = v;
+            }
+        }
+
+        expect(t).toEqual({ 1: [4, 9], 2: [10, 11], 4: [14], 5: [15, 16] });
+    });
+});

src/mol-base/collections/impl/interval.ts

@@ -7,8 +7,8 @@
 import IntTuple from '../int-tuple'
 
 export const Empty = IntTuple.Zero;
-export function ofRange(min: number, max: number) { return max < min ? Empty : IntTuple.create(min, max + 1); }
-export function ofBounds(min: number, max: number) { return max <= min ? Empty : IntTuple.create(min, max); }
+export function ofRange(min: number, max: number) { return max < min ? IntTuple.create(min, min) : IntTuple.create(min, max + 1); }
+export function ofBounds(min: number, max: number) { return max <= min ? IntTuple.create(min, min) : IntTuple.create(min, max); }
 export const is = IntTuple.is;
 
 export const start = IntTuple.fst;

src/mol-base/collections/impl/ordered-set.ts

@@ -0,0 +1,429 @@
+/**
+ * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import S from '../sorted-array'
+import I from '../interval'
+
+type OrderedSetImpl = I | S
+type Nums = ArrayLike<number>
+
+export const Empty: OrderedSetImpl = I.Empty;
+
+export const ofSingleton = I.ofSingleton
+export const ofRange = I.ofRange
+
+export function ofSortedArray(xs: Nums): OrderedSetImpl {
+    if (!xs.length) return Empty;
+    // check if the array is just a range
+    if (xs[xs.length - 1] - xs[0] + 1 === xs.length) return I.ofRange(xs[0], xs[xs.length - 1]);
+    return xs as any;
+}
+
+export function size(set: OrderedSetImpl) { return I.is(set) ? I.size(set) : S.size(set); }
+export function has(set: OrderedSetImpl, x: number) { return I.is(set) ? I.has(set, x) : S.has(set, x); }
+export function indexOf(set: OrderedSetImpl, x: number) { return I.is(set) ? I.indexOf(set, x) : S.indexOf(set, x); }
+export function getAt(set: OrderedSetImpl, i: number) { return I.is(set) ? I.getAt(set, i) : S.getAt(set, i); }
+export function min(set: OrderedSetImpl) { return I.is(set) ? I.min(set) : S.min(set); }
+export function max(set: OrderedSetImpl) { return I.is(set) ? I.max(set) : S.max(set); }
+
+export function hashCode(set: OrderedSetImpl) { return I.is(set) ? I.hashCode(set) : S.hashCode(set); }
+// TODO: possibly add more hash functions to allow for multilevel hashing.
+
+export function areEqual(a: OrderedSetImpl, b: OrderedSetImpl) {
+    if (I.is(a)) {
+        if (I.is(b)) return I.areEqual(a, b);
+        return areEqualIS(a, b);
+    } else if (I.is(b)) return areEqualIS(b, a);
+    return S.areEqual(a, b);
+}
+
+export function areIntersecting(a: OrderedSetImpl, b: OrderedSetImpl) {
+    if (I.is(a)) {
+        if (I.is(b)) return I.areIntersecting(a, b);
+        return areIntersectingSI(b, a);
+    } else if (I.is(b)) return areIntersectingSI(a, b);
+    return areIntersectingSS(a, b);
+}
+
+/** Check if the 2nd argument is a subset of the 1st */
+export function isSubset(a: OrderedSetImpl, b: OrderedSetImpl) {
+    if (I.is(a)) {
+        if (I.is(b)) return I.isSubInterval(a, b);
+        return isSubsetIS(a, b);
+    } else if (I.is(b)) return isSubsetSI(a, b);
+    return isSubsetSS(a, b);
+}
+
+export function findPredecessorIndex(set: OrderedSetImpl, x: number) {
+    return I.is(set) ? I.findPredecessorIndex(set, x) : S.findPredecessorIndex(set, x);
+}
+
+export function findPredecessorIndexInInterval(set: OrderedSetImpl, x: number, bounds: I) {
+    return I.is(set) ? I.findPredecessorIndexInInterval(set, x, bounds) : S.findPredecessorIndexInInterval(set, x, bounds);
+}
+
+export function findRange(set: OrderedSetImpl, min: number, max: number) {
+    return I.is(set) ? I.findRange(set, min, max) : S.findRange(set, min, max);
+}
+
+export function union(a: OrderedSetImpl, b: OrderedSetImpl) {
+    if (I.is(a)) {
+        if (I.is(b)) return unionII(a, b);
+        return unionSI(b, a);
+    } else if (I.is(b)) return unionSI(a, b);
+    return unionSS(a, b);
+}
+
+export function intersect(a: OrderedSetImpl, b: OrderedSetImpl) {
+    if (I.is(a)) {
+        if (I.is(b)) return I.intersect(a, b);
+        return intersectSI(b, a);
+    } else if (I.is(b)) return intersectSI(a, b);
+    return intersectSS(a, b);
+}
+
+export function subtract(a: OrderedSetImpl, b: OrderedSetImpl) {
+    if (I.is(a)) {
+        if (I.is(b)) return subtractII(a, b);
+        return subtractIS(a, b);
+    } else if (I.is(b)) return subtractSI(a, b);
+    return subtractSS(a, b);
+}
+
+const _maxIntRangeRet = { startI: 0, startJ: 0, endI: 0, endJ: 0 };
+function getMaxIntersectionRange(a: S, b: S) {
+    _maxIntRangeRet.startI = S.findPredecessorIndex(a, S.start(b));
+    _maxIntRangeRet.startJ = S.findPredecessorIndex(b, S.start(a));
+    _maxIntRangeRet.endI = S.findPredecessorIndex(a, S.end(b));
+    _maxIntRangeRet.endJ = S.findPredecessorIndex(b, S.end(a));
+    return _maxIntRangeRet;
+}
+
+function areEqualIS(a: I, b: S) { return I.size(a) === S.size(b) && I.start(a) === S.start(b) && I.end(a) === S.end(b); }
+
+function areIntersectingSI(a: S, b: I) {
+    return areRangesIntersecting(a, b);
+}
+
+function areIntersectingSS(a: S, b: S) {
+    if (a === b) return true;
+
+    const xs = S.values(a), ys = S.values(b);
+    let { startI: i, startJ: j, endI, endJ } = getMaxIntersectionRange(a, b);
+    while (i < endI && j < endJ) {
+        const x = xs[i], y = ys[j];
+        if (x < y) { i++; }
+        else if (x > y) { j++; }
+        else return true;
+    }
+    return false;
+}
+
+function isSubsetSI(a: S, b: I) {
+    const minB = I.min(b), maxB = I.max(b);
+    if (maxB - minB + 1 === 0) return true;
+    const minA = S.min(a), maxA = S.max(a);
+    if (minB < minA || maxB > maxA) return false;
+    const r = S.findRange(a, minB, maxB);
+    return I.size(r) === I.size(b);
+}
+
+function isSubsetIS(a: I, b: S) {
+    const minA = I.min(a), maxA = I.max(a);
+    if (maxA - minA + 1 === 0) return false;
+    const minB = S.min(b), maxB = S.max(b);
+    return minB >= minA && maxA <= maxB;
+}
+
+function isSubsetSS(a: S, b: S) {
+    if (a === b) return true;
+
+    const xs = S.values(a), ys = S.values(b);
+    const lenB = ys.length;
+    let { startI: i, startJ: j, endI, endJ } = getMaxIntersectionRange(a, b);
+    // must be able to advance by lenB elements
+    if (endJ - j < lenB || endI - i < lenB) return false;
+
+    let equal = 0;
+    while (i < endI && j < endJ) {
+        const x = xs[i], y = ys[j];
+        if (x < y) { i++; }
+        else if (x > y) { j++; }
+        else { i++; j++; equal++; }
+    }
+    return equal === lenB;
+}
+
+function areRangesIntersecting(a: OrderedSetImpl, b: OrderedSetImpl) {
+    const sa = size(a), sb = size(b);
+    if (sa === 0 && sb === 0) return true;
+    return sa > 0 && sb > 0 && max(a) >= min(b) && min(a) <= max(b);
+}
+
+function isRangeSubset(a: OrderedSetImpl, b: OrderedSetImpl) {
+    if (!size(a)) return size(b) === 0;
+    if (!size(b)) return true;
+    return min(a) <= min(b) && max(a) >= max(b);
+}
+
+function unionII(a: I, b: I) {
+    if (I.areEqual(a, b)) return a;
+
+    const sizeA = I.size(a), sizeB = I.size(b);
+    if (!sizeA) return b;
+    if (!sizeB) return a;
+    const minA = I.min(a), minB = I.min(b);
+    if (areRangesIntersecting(a, b)) return I.ofRange(Math.min(minA, minB), Math.max(I.max(a), I.max(b)));
+    let lSize, lMin, rSize, rMin;
+    if (minA < minB) { lSize = sizeA; lMin = minA; rSize = sizeB; rMin = minB; }
+    else { lSize = sizeB; lMin = minB; rSize = sizeA; rMin = minA; }
+    const arr = new Int32Array(sizeA + sizeB);
+    for (let i = 0; i < lSize; i++) arr[i] = i + lMin;
+    for (let i = 0; i < rSize; i++) arr[i + lSize] = i + rMin;
+    return ofSortedArray(arr);
+}
+
+function unionSI(a: S, b: I) {
+    const bSize = I.size(b);
+    if (!bSize) return a;
+    // is the array fully contained in the range?
+    if (isRangeSubset(b, a)) return b;
+
+    const min = I.min(b), max = I.max(b);
+    const r = S.findRange(a, min, max);
+    const start = I.start(r), end = I.end(r);
+    const xs = S.values(a);
+    const indices = new Int32Array(start + (xs.length - end) + bSize);
+    let offset = 0;
+    for (let i = 0; i < start; i++) indices[offset++] = xs[i];
+    for (let i = min; i <= max; i++) indices[offset++] = i;
+    for (let i = end, _i = xs.length; i < _i; i++) indices[offset] = xs[i];
+
+    return ofSortedArray(indices);
+}
+
+function unionSS(a: S, b: S) {
+    if (a === b) return a;
+
+    const xs = S.values(a), ys = S.values(b);
+    const { startI: sI, startJ: sJ, endI, endJ } = getMaxIntersectionRange(a, b);
+    let i = sI, j = sJ;
+    let commonCount = 0;
+    while (i < endI && j < endJ) {
+        const x = xs[i], y = ys[j];
+        if (x < y) { i++; }
+        else if (x > y) { j++; }
+        else { i++; j++; commonCount++; }
+    }
+
+    const lenA = xs.length, lenB = ys.length;
+    // A === B || B is subset of A ==> A
+    if ((commonCount === lenA && commonCount === lenB) || commonCount === lenB) return xs;
+    // A is subset of B ===> B
+    if (commonCount === lenA) return ys;
+
+    const resultSize = lenA + lenB - commonCount;
+    const l = Math.min(xs[0], ys[0]), r = Math.max(xs[lenA - 1], ys[lenB - 1]);
+    // is this just a range?
+    if (resultSize === r - l + 1) {
+        return I.ofRange(l, r);
+    }
+
+    const indices = new Int32Array(lenA + lenB - commonCount);
+    let offset = 0;
+
+    // insert the "prefixes"
+    for (let k = 0; k < sI; k++) indices[offset++] = xs[k];
+    for (let k = 0; k < sJ; k++) indices[offset++] = ys[k];
+
+    // insert the common part
+    i = sI;
+    j = sJ;
+    while (i < endI && j < endJ) {
+        const x = xs[i], y = ys[j];
+        if (x < y) { indices[offset++] = x; i++; }
+        else if (x > y) { indices[offset++] = y; j++; }
+        else { indices[offset++] = x; i++; j++; }
+    }
+
+    // insert the "tail"
+    for (; i < lenA; i++) indices[offset++] = xs[i];
+    for (; j < lenB; j++) indices[offset++] = ys[j];
+
+    return ofSortedArray(indices);
+}
+
+function intersectSI(a: S, b: I) {
+    if (!I.size(b)) return Empty;
+
+    const r = S.findRange(a, I.min(b), I.max(b));
+    const start = I.start(r), end = I.end(r);
+    const resultSize = end - start;
+    if (!resultSize) return Empty;
+
+    const xs = S.values(a);
+    const indices = new Int32Array(resultSize);
+    let offset = 0;
+    for (let i = start; i < end; i++) {
+        indices[offset++] = xs[i];
+    }
+    return ofSortedArray(indices);
+}
+
+function intersectSS(a: S, b: S) {
+    if (a === b) return a;
+
+    const xs = S.values(a), ys = S.values(b);
+    const { startI: sI, startJ: sJ, endI, endJ } = getMaxIntersectionRange(a, b);
+    let i = sI, j = sJ;
+    let commonCount = 0;
+    while (i < endI && j < endJ) {
+        const x = xs[i], y = ys[j];
+        if (x < y) { i++; }
+        else if (x > y) { j++; }
+        else { i++; j++; commonCount++; }
+    }
+
+    const lenA = xs.length, lenB = ys.length;
+    // no common elements
+    if (!commonCount) return Empty;
+    // A === B || B is subset of A ==> B
+    if ((commonCount === lenA && commonCount === lenB) || commonCount === lenB) return b;
+    // A is subset of B ==> A
+    if (commonCount === lenA) return a;
+
+    const indices = new Int32Array(commonCount);
+    let offset = 0;
+    i = sI;
+    j = sJ;
+    while (i < endI && j < endJ) {
+        const x = xs[i], y = ys[j];
+        if (x < y) { i++; }
+        else if (x > y) { j++; }
+        else { indices[offset++] = x; i++; j++; }
+    }
+
+    return ofSortedArray(indices);
+}
+
+function subtractII(a: I, b: I) {
+    if (I.areEqual(a, b)) return Empty;
+    if (!I.areIntersecting(a, b)) return a;
+
+    const minA = I.min(a), maxA = I.max(a);
+    const minB = I.min(b), maxB = I.max(b);
+
+    if (maxA < minA || maxB < minB) return a;
+    // is A subset of B? ==> Empty
+    if (I.isSubInterval(b, a)) return Empty;
+    if (I.isSubInterval(a, b)) {
+        // this splits the interval into two, gotta represent it as a set.
+        const l = minB - minA, r = maxA - maxB;
+        if (l <= 0) return I.ofRange(maxB + 1, maxB + r);
+        if (r <= 0) return I.ofRange(minA, minA + l - 1);
+        const ret = new Int32Array(l + r);
+        let offset = 0;
+        for (let i = 0; i < l; i++) ret[offset++] = minA + i;
+        for (let i = 1; i <= r; i++) ret[offset++] = maxB + i;
+        return ofSortedArray(ret);
+    }
+    if (minA < minB) return I.ofRange(minA, minB - 1);
+    return I.ofRange(maxB + 1, maxA);
+}
+
+function subtractSI(a: S, b: I) {
+    const min = I.min(b), max = I.max(b);
+    // is empty?
+    if (max < min) return a;
+
+    const xs = S.values(a);
+    const r = S.findRange(a, min, max);
+    const start = I.start(r), end = I.end(r);
+    const resultSize = xs.length - (end - start);
+    // A is subset of B
+    if (resultSize <= 0) return Empty;
+    // No common elements
+    if (resultSize === xs.length) return xs;
+
+    const ret = new Int32Array(resultSize);
+    let offset = 0;
+    for (let i = 0; i < start; i++) ret[offset++] = xs[i];
+    for (let i = end, _i = xs.length; i < _i; i++) ret[offset++] = xs[i];
+    return ofSortedArray(ret);
+}
+
+function subtractIS(a: I, b: S) {
+    const min = I.min(a), max = I.max(a);
+
+    // is empty?
+    if (max < min) return a;
+
+    const rSize = max - min + 1;
+    const interval = S.findRange(b, min, max);
+    const start = I.start(interval), end = I.end(interval);
+    const commonCount = end - start;
+
+    // No common elements.
+    if (commonCount === 0) return a;
+
+    const resultSize = rSize - commonCount;
+    // A is subset of B
+    if (resultSize <= 0) return Empty;
+
+    const xs = S.values(b);
+    const ret = new Int32Array(resultSize);
+    const li = xs.length - 1;
+    const fst = xs[Math.min(start, li)], last = xs[Math.min(end, li)];
+    let offset = 0;
+    for (let i = min; i < fst; i++) ret[offset++] = i;
+    for (let i = fst; i <= last; i++) {
+        if (S.indexOfInterval(b, i, interval) < 0) ret[offset++] = i;
+    }
+    for (let i = last + 1; i <= max; i++) ret[offset++] = i;
+    return ofSortedArray(ret);
+}
+
+function subtractSS(a: S, b: S) {
+    if (a === b) return Empty;
+
+    const xs = S.values(a), ys = S.values(b);
+    const lenA = xs.length;
+
+    const { startI: sI, startJ: sJ, endI, endJ } = getMaxIntersectionRange(a, b);
+    let i = sI, j = sJ;
+    let commonCount = 0;
+    while (i < endI && j < endJ) {
+        const x = xs[i], y = ys[j];
+        if (x < y) { i++; }
+        else if (x > y) { j++; }
+        else { i++; j++; commonCount++; }
+    }
+
+    // A isnt intersecting B ===> A
+    if (!commonCount) return xs;
+    // A === B || A is subset of B ===> Empty
+    if (commonCount >= lenA) return Empty;
+
+    const indices = new Int32Array(lenA - commonCount);
+    let offset = 0;
+
+    // insert the "prefix"
+    for (let k = 0; k < sI; k++) indices[offset++] = xs[k];
+
+    i = sI;
+    j = sJ;
+    while (i < endI && j < endJ) {
+        const x = xs[i], y = ys[j];
+        if (x < y) { indices[offset++] = x; i++; }
+        else if (x > y) { j++; }
+        else { i++; j++; }
+    }
+
+    // insert the "tail"
+    for (; i < lenA; i++) indices[offset++] = xs[i];
+
+    return ofSortedArray(indices);
+}

src/mol-base/collections/impl/sorted-array.ts

@@ -34,6 +34,11 @@ export function indexOf(xs: Nums, v: number) {
     const l = xs.length;
     return l === 0 ? -1 : xs[0] <= v && v <= xs[l - 1] ? binarySearchRange(xs, v, 0, l) : -1;
 }
+export function indexOfInterval(xs: Nums, v: number, bounds: Interval) {
+    const l = xs.length;
+    const s = Interval.start(bounds), e = Interval.end(bounds);
+    return l === 0 || e <= s ? -1 : xs[s] <= v && v <= xs[e - 1] ? binarySearchRange(xs, v, s, e) : -1;
+}
 export function has(xs: Nums, v: number) { return indexOf(xs, v) >= 0; }
 
 export function getAt(xs: Nums, i: number) { return xs[i]; }

src/mol-base/collections/interval.ts

@@ -9,6 +9,7 @@ import * as Impl from './impl/interval'
 namespace Interval {
     export const Empty: Interval = Impl.Empty as any;
 
+    export const ofSingleton: (value: number) => Interval = (v) => Impl.ofRange(v, v) as any;
     /** Create interval [min, max] */
     export const ofRange: (min: number, max: number) => Interval = Impl.ofRange as any;
     /** Create interval [min, max) */

src/mol-base/collections/ordered-set.ts

@@ -4,14 +4,12 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import * as Base from './ordered-set/base'
+//import * as Base from './ordered-set/base'
+import * as Base from './impl/ordered-set'
+import Interval from './interval'
 import SegmentIterator from './ordered-set/segment-iterator'
 
 namespace OrderedSet {
-    /** Range of indices to be iterated as start <= i < end. */
-    export interface IndexRange { start: number, end: number }
-    export function IndexRange(start?: number, end?: number): IndexRange { return { start: start || 0, end: end || 0 }; }
-
     export const Empty: OrderedSet = Base.Empty as any;
     export const ofSingleton: (value: number) => OrderedSet = Base.ofSingleton as any;
     export const ofRange: (min: number, max: number) => OrderedSet = Base.ofRange as any;
@@ -22,8 +20,8 @@ namespace OrderedSet {
     export const indexOf: (set: OrderedSet, x: number) => number = Base.indexOf as any;
     export const getAt: (set: OrderedSet, i: number) => number = Base.getAt as any;
 
-    export const min: (set: OrderedSet) => number = Base.minValue as any;
-    export const max: (set: OrderedSet) => number = Base.maxValue as any;
+    export const min: (set: OrderedSet) => number = Base.min as any;
+    export const max: (set: OrderedSet) => number = Base.max as any;
     export const size: (set: OrderedSet) => number = Base.size as any;
     export const hashCode: (set: OrderedSet) => number = Base.hashCode as any;
 
@@ -35,9 +33,9 @@ namespace OrderedSet {
     export const intersect: (a: OrderedSet, b: OrderedSet) => OrderedSet = Base.intersect as any;
     export const subtract: (a: OrderedSet, b: OrderedSet) => OrderedSet = Base.subtract as any;
 
-    export const findPredecessorIndex: (set: OrderedSet, x: number) => number = Base.getPredIndex as any;
-    export const findPredecessorIndexInRange: (set: OrderedSet, x: number, range: IndexRange) => number = Base.getPredIndexInRange as any;
-    export const findIntervalRange: (set: OrderedSet, min: number, max: number) => IndexRange = Base.getIntervalRange as any;
+    export const findPredecessorIndex: (set: OrderedSet, x: number) => number = Base.findPredecessorIndex as any;
+    export const findPredecessorIndexInRange: (set: OrderedSet, x: number, range: Interval) => number = Base.findPredecessorIndexInInterval as any;
+    export const findRange: (set: OrderedSet, min: number, max: number) => Interval = Base.findRange as any;
 
     export const segments = SegmentIterator;
 }

src/mol-base/collections/ordered-set/segment-iterator.ts

@@ -6,14 +6,17 @@
 
 import Iterator from '../iterator'
 import OrderedSet from '../ordered-set'
+import Interval from '../interval'
 
-class SegmentIterator implements Iterator<{ segment: number } & OrderedSet.IndexRange> {
-    private segmentRange = OrderedSet.IndexRange();
-    private setRange = OrderedSet.IndexRange();
+class SegmentIterator implements Iterator<{ segment: number, start: number, end: number }> {
+    private segmentStart = 0;
+    private segmentEnd = 0;
+    // private segmentRange = Interval.Empty;
+    private setRange = Interval.Empty;
     private value = { segment: 0, start: 0, end: 0 };
     private last: number = 0;
 
-    [Symbol.iterator]() { return new SegmentIterator(this.segments, this.set, this.start, this.end); };
+    [Symbol.iterator]() { return new SegmentIterator(this.segments, this.set, this.inputRange); };
     done: boolean = false;
 
     next() {
@@ -22,12 +25,12 @@ class SegmentIterator implements Iterator<{ segment: number } & OrderedSet.Index
     }
 
     move() {
-        this.done = this.segmentRange.end <= this.segmentRange.start;
+        this.done = this.segmentEnd <= this.segmentStart;
         while (!this.done) {
             if (!this.updateValue()) {
                 this.updateSegmentRange();
             } else {
-                this.value.segment = this.segmentRange.start++;
+                this.value.segment = this.segmentStart++;
                 break;
             }
         }
@@ -40,33 +43,34 @@ class SegmentIterator implements Iterator<{ segment: number } & OrderedSet.Index
     }
 
     private updateValue() {
-        const segmentEnd = OrderedSet.getAt(this.segments, this.segmentRange.start + 1);
+        const segmentEnd = OrderedSet.getAt(this.segments, this.segmentStart + 1);
         const setEnd = OrderedSet.findPredecessorIndexInRange(this.set, segmentEnd, this.setRange);
-        this.value.start = this.setRange.start;
+        this.value.start = Interval.start(this.setRange);
         this.value.end = setEnd;
-        this.setRange.start = setEnd;
+        this.setRange = Interval.ofBounds(setEnd, Interval.end(this.setRange))
+        //this.setRange.start = setEnd;
+        //throw '';
         return setEnd > this.value.start;
     }
 
     private updateSegmentRange() {
-        const min = OrderedSet.getAt(this.set, this.setRange.start), max = OrderedSet.getAt(this.set, this.setRange.end - 1);
-        this.segmentRange.start = this.getSegmentIndex(min);
-        this.segmentRange.end = this.getSegmentIndex(max) + 1;
-        this.done = this.segmentRange.end <= this.segmentRange.start;
+        const min = OrderedSet.getAt(this.set, Interval.min(this.setRange));
+        const max = OrderedSet.getAt(this.set, Interval.max(this.setRange));
+        this.segmentStart = this.getSegmentIndex(min);
+        this.segmentEnd = this.getSegmentIndex(max) + 1;
+        this.done = this.segmentEnd <= this.segmentStart;
     }
 
-    constructor(private segments: OrderedSet, private set: OrderedSet, private start: number, private end: number) {
+    constructor(private segments: OrderedSet, private set: OrderedSet, private inputRange: Interval) {
         this.last = OrderedSet.max(segments);
-        this.setRange.start = start;
-        this.setRange.end = end;
+        this.setRange = inputRange;
         this.updateSegmentRange();
     }
 }
 
-function createIterator(segments: OrderedSet, set: OrderedSet, range?: OrderedSet.IndexRange) {
-    const start = !!range ? range.start : 0;
-    const end = !!range ? range.end : OrderedSet.size(set);
-    return new SegmentIterator(segments, set, start, end);
+function createIterator(segments: OrderedSet, set: OrderedSet, range?: Interval) {
+    const int = typeof range !== 'undefined' ? range : Interval.ofBounds(0, OrderedSet.size(set));
+    return new SegmentIterator(segments, set, int);
 }
 
 export default createIterator

src/mol-base/collections/sorted-array.ts

@@ -14,22 +14,25 @@ namespace SortedArray {
     export const ofSortedArray: (xs: ArrayLike<number>) => SortedArray = Impl.ofSortedArray as any;
     export const is: (v: any) => v is Interval = Impl.is as any;
 
-    export const has: (interval: SortedArray, x: number) => boolean = Impl.has as any;
-    export const indexOf: (interval: SortedArray, x: number) => number = Impl.indexOf as any;
-    export const getAt: (interval: SortedArray, i: number) => number = Impl.getAt as any;
+    export const values: (array: SortedArray) => ArrayLike<number> = (xs) => xs as any;
 
-    export const start: (interval: SortedArray) => number = Impl.start as any;
-    export const end: (interval: SortedArray) => number = Impl.end as any;
-    export const min: (interval: SortedArray) => number = Impl.min as any;
-    export const max: (interval: SortedArray) => number = Impl.max as any;
-    export const size: (interval: SortedArray) => number = Impl.size as any;
-    export const hashCode: (interval: SortedArray) => number = Impl.hashCode as any;
+    export const has: (array: SortedArray, x: number) => boolean = Impl.has as any;
+    export const indexOf: (array: SortedArray, x: number) => number = Impl.indexOf as any;
+    export const indexOfInterval: (array: SortedArray, x: number, bounds: Interval) => number = Impl.indexOfInterval as any;
+    export const getAt: (array: SortedArray, i: number) => number = Impl.getAt as any;
+
+    export const start: (array: SortedArray) => number = Impl.start as any;
+    export const end: (array: SortedArray) => number = Impl.end as any;
+    export const min: (array: SortedArray) => number = Impl.min as any;
+    export const max: (array: SortedArray) => number = Impl.max as any;
+    export const size: (array: SortedArray) => number = Impl.size as any;
+    export const hashCode: (array: SortedArray) => number = Impl.hashCode as any;
 
     export const areEqual: (a: SortedArray, b: SortedArray) => boolean = Impl.areEqual as any;
 
-    export const findPredecessorIndex: (interval: SortedArray, x: number) => number = Impl.findPredecessorIndex as any;
-    export const findPredecessorIndexInInterval: (interval: SortedArray, x: number, bounds: Interval) => number = Impl.findPredecessorIndexInInterval as any;
-    export const findRange: (interval: SortedArray, min: number, max: number) => Interval = Impl.findRange as any;
+    export const findPredecessorIndex: (array: SortedArray, x: number) => number = Impl.findPredecessorIndex as any;
+    export const findPredecessorIndexInInterval: (array: SortedArray, x: number, bounds: Interval) => number = Impl.findPredecessorIndexInInterval as any;
+    export const findRange: (array: SortedArray, min: number, max: number) => Interval = Impl.findRange as any;
 }
 
 interface SortedArray { '@type': 'int-sorted-array' }

src/mol-data/atom-set/base.ts

@@ -7,6 +7,7 @@
 import OrderedSet from '../../mol-base/collections/ordered-set'
 import Iterator from '../../mol-base/collections/iterator'
 import IntTuple from '../../mol-base/collections/int-tuple'
+import Interval from '../../mol-base/collections/interval'
 import { sortArray } from '../../mol-base/collections/sort'
 import { hash1 } from '../../mol-base/collections/hash-functions'
 
@@ -345,7 +346,8 @@ function areIntersectingEE(a: AtomSetElements, b: AtomSetElements) {
     if (a === b) return true;
     const keysA = a.keys, keysB = b.keys;
     if (!OrderedSet.areIntersecting(a.keys, b.keys)) return false;
-    const { start, end } = OrderedSet.findIntervalRange(keysA, OrderedSet.min(keysB), OrderedSet.max(keysB));
+    const r = OrderedSet.findRange(keysA, OrderedSet.min(keysB), OrderedSet.max(keysB));
+    const start = Interval.start(r), end = Interval.end(r);
     for (let i = start; i < end; i++) {
         const k = OrderedSet.getAt(keysA, i);
         if (OrderedSet.has(keysB, k) && OrderedSet.areIntersecting(a[k], b[k])) return true;
@@ -363,7 +365,8 @@ function intersectEE(a: AtomSetElements, b: AtomSetElements) {
 
     const keysA = a.keys, keysB = b.keys;
     if (!OrderedSet.areIntersecting(a.keys, b.keys)) return Empty;
-    const { start, end } = OrderedSet.findIntervalRange(keysA, OrderedSet.min(keysB), OrderedSet.max(keysB));
+    const r = OrderedSet.findRange(keysA, OrderedSet.min(keysB), OrderedSet.max(keysB));
+    const start = Interval.start(r), end = Interval.end(r);
 
     const keys = [], ret = Object.create(null);
     for (let i = start; i < end; i++) {
@@ -409,7 +412,8 @@ function subtractEE(a: AtomSetElements, b: AtomSetElements) {
 
     const keysA = a.keys, keysB = b.keys;
     if (!OrderedSet.areIntersecting(a.keys, b.keys)) return Empty;
-    const { start, end } = OrderedSet.findIntervalRange(keysA, OrderedSet.min(keysB), OrderedSet.max(keysB));
+    const r = OrderedSet.findRange(keysA, OrderedSet.min(keysB), OrderedSet.max(keysB));
+    const start = Interval.start(r), end = Interval.end(r);
 
     const keys = [], ret = Object.create(null);
     for (let i = 0; i < start; i++) {

src/perf-tests/sets.ts

@@ -279,7 +279,9 @@ export function testSegments() {
     }
 }
 
-Tuples.run();
+testSegments();
+
+//Tuples.run();
 
 // interface AA { kind: 'a' }
 // //interface BB { kind: 'b' }