more refactoring

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

@@ -4,7 +4,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import IntTuple from '../int-tuple'
+import IntTuple from '../integer/tuple'
 
 describe('int pair', () => {
     it('works', () => {

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

@@ -4,7 +4,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import Interval from '../interval'
+import Interval from '../integer/interval'
 
 describe('interval', () => {
     function testI(name: string, a: Interval, b: Interval) {

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

@@ -4,8 +4,8 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import OrderedSet from '../ordered-set'
-import Interval from '../interval'
+import OrderedSet from '../integer/ordered-set'
+import Interval from '../integer/interval'
 
 describe('ordered set', () => {
     function ordSetToArray(set: OrderedSet) {

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

@@ -4,10 +4,10 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import OrderedSet from '../ordered-set'
-import Interval from '../interval'
-import Segmentation from '../segmentation'
-import SortedArray from '../sorted-array'
+import OrderedSet from '../integer/ordered-set'
+import Interval from '../integer/interval'
+import Segmentation from '../integer/segmentation'
+import SortedArray from '../integer/sorted-array'
 
 describe('segments', () => {
     const data = OrderedSet.ofSortedArray([4, 9, 10, 11, 14, 15, 16]);

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

@@ -4,8 +4,8 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import Interval from '../interval'
-import SortedArray from '../sorted-array'
+import Interval from '../integer/interval'
+import SortedArray from '../integer/sorted-array'
 
 describe('sortedArray', () => {
     function testI(name: string, a: Interval, b: Interval) {

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

@@ -1,58 +0,0 @@
-/**
- * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import IntTuple from '../int-tuple'
-
-export const Empty = IntTuple.Zero;
-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;
-export const end = IntTuple.snd;
-export const min = IntTuple.fst;
-export function max(i: IntTuple) { return IntTuple.snd(i) - 1; }
-export function size(i: IntTuple) { return IntTuple.snd(i) - IntTuple.fst(i); }
-export const hashCode = IntTuple.hashCode;
-
-export function has(int: IntTuple, v: number) { return IntTuple.fst(int) <= v && v < IntTuple.snd(int); }
-export function indexOf(int: IntTuple, x: number) { const m = start(int); return x >= m && x < end(int) ? x - m : -1; }
-export function getAt(int: IntTuple, i: number) { return IntTuple.fst(int) + i; }
-
-export const areEqual = IntTuple.areEqual;
-export function areIntersecting(a: IntTuple, b: IntTuple) {
-    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);
-}
-export function isSubInterval(a: IntTuple, b: IntTuple) {
-    if (!size(a)) return size(b) === 0;
-    if (!size(b)) return true;
-    return start(a) <= start(b) && end(a) >= end(b);
-}
-
-export function findPredecessorIndex(int: IntTuple, v: number) {
-    const s = start(int);
-    if (v <= s) return 0;
-    const e = end(int);
-    if (v >= e) return e - s;
-    return v - s;
-}
-
-export function findPredecessorIndexInInterval(int: IntTuple, x: number, bounds: IntTuple) {
-    const ret = findPredecessorIndex(int, x);
-    const s = start(bounds), e = end(bounds);
-    return ret <= s ? s : ret >= e ? e : ret;
-}
-
-export function findRange(int: IntTuple, min: number, max: number) {
-    return ofBounds(findPredecessorIndex(int, min), findPredecessorIndex(int, max + 1));
-}
-
-export function intersect(a: IntTuple, b: IntTuple) {
-    if (!areIntersecting(a, b)) return Empty;
-    return ofBounds(Math.max(start(a), start(b)), Math.min(end(a), end(b)));
-}

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

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2017 molio contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import Tuple from '../tuple'
+
+export const Empty = Tuple.Zero;
+export function ofRange(min: number, max: number) { return max < min ? Tuple.create(min, min) : Tuple.create(min, max + 1); }
+export function ofBounds(min: number, max: number) { return max <= min ? Tuple.create(min, min) : Tuple.create(min, max); }
+export const is = Tuple.is;
+
+export const start = Tuple.fst;
+export const end = Tuple.snd;
+export const min = Tuple.fst;
+export function max(i: Tuple) { return Tuple.snd(i) - 1; }
+export function size(i: Tuple) { return Tuple.snd(i) - Tuple.fst(i); }
+export const hashCode = Tuple.hashCode;
+
+export function has(int: Tuple, v: number) { return Tuple.fst(int) <= v && v < Tuple.snd(int); }
+export function indexOf(int: Tuple, x: number) { const m = start(int); return x >= m && x < end(int) ? x - m : -1; }
+export function getAt(int: Tuple, i: number) { return Tuple.fst(int) + i; }
+
+export const areEqual = Tuple.areEqual;
+export function areIntersecting(a: Tuple, b: Tuple) {
+    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);
+}
+export function isSubInterval(a: Tuple, b: Tuple) {
+    if (!size(a)) return size(b) === 0;
+    if (!size(b)) return true;
+    return start(a) <= start(b) && end(a) >= end(b);
+}
+
+export function findPredecessorIndex(int: Tuple, v: number) {
+    const s = start(int);
+    if (v <= s) return 0;
+    const e = end(int);
+    if (v >= e) return e - s;
+    return v - s;
+}
+
+export function findPredecessorIndexInInterval(int: Tuple, x: number, bounds: Tuple) {
+    const ret = findPredecessorIndex(int, x);
+    const s = start(bounds), e = end(bounds);
+    return ret <= s ? s : ret >= e ? e : ret;
+}
+
+export function findRange(int: Tuple, min: number, max: number) {
+    return ofBounds(findPredecessorIndex(int, min), findPredecessorIndex(int, max + 1));
+}
+
+export function intersect(a: Tuple, b: Tuple) {
+    if (!areIntersecting(a, b)) return Empty;
+    return ofBounds(Math.max(start(a), start(b)), Math.min(end(a), end(b)));
+}

src/mol-base/collections/impl/segmentation.ts → src/mol-base/collections/integer/impl/segmentation.ts

@@ -4,7 +4,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import Iterator from '../iterator'
+import Iterator from '../../iterator'
 import OrderedSet from '../ordered-set'
 import Interval from '../interval'
 import SortedArray from '../sorted-array'

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

@@ -4,8 +4,8 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import { sortArray } from '../sort'
-import { hash3, hash4 } from '../hash-functions'
+import { sortArray } from '../../sort'
+import { hash3, hash4 } from '../../hash-functions'
 import Interval from '../interval'
 
 type Nums = ArrayLike<number>

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

@@ -4,10 +4,8 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-//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 {
     export const Empty: OrderedSet = Base.Empty as any;

src/mol-base/collections/segmentation.ts → src/mol-base/collections/integer/segmentation.ts

@@ -4,7 +4,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import Iterator from './iterator'
+import Iterator from '../iterator'
 import Interval from './interval'
 import OrderedSet from './ordered-set'
 import SortedArray from './sorted-array'

src/mol-base/collections/int-tuple.ts → src/mol-base/collections/integer/tuple.ts

@@ -4,7 +4,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import { hash2 } from './hash-functions'
+import { hash2 } from '../hash-functions'
 
 /**
  * Represents a pair of two integers as a double,

src/mol-data/_spec/atom-set.spec.ts

@@ -4,8 +4,8 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import IntTuple from '../../mol-base/collections/int-tuple'
-import OrderedSet from '../../mol-base/collections/ordered-set'
+import IntTuple from '../../mol-base/collections/integer/tuple'
+import OrderedSet from '../../mol-base/collections/integer/ordered-set'
 import AtomSet from '../atom-set'
 
 describe('atom set', () => {

src/mol-data/atom-set.ts

@@ -4,9 +4,9 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import OrderedSet from '../mol-base/collections/ordered-set'
+import OrderedSet from '../mol-base/collections/integer/ordered-set'
 import Iterator from '../mol-base/collections/iterator'
-import IntTuple from '../mol-base/collections/int-tuple'
+import Tuple from '../mol-base/collections/integer/tuple'
 import * as Base from './atom-set/base'
 import createBuilder from './atom-set/builder'
 
@@ -14,7 +14,7 @@ import createBuilder from './atom-set/builder'
 namespace AtomSet {
     export const Empty: AtomSet = Base.Empty as any;
 
-    export const create: (data: IntTuple | ArrayLike<IntTuple> | IntTuple | { [id: number]: OrderedSet }) => AtomSet = Base.create as any;
+    export const create: (data: Tuple | ArrayLike<Tuple> | Tuple | { [id: number]: OrderedSet }) => AtomSet = Base.create as any;
 
     export const units: (set: AtomSet) => OrderedSet = Base.getKeys as any;
     export const unitCount: (set: AtomSet) => number = Base.keyCount as any;
@@ -24,10 +24,10 @@ namespace AtomSet {
     export const getByKey: (set: AtomSet, key: number) => OrderedSet = Base.getByKey as any;
     export const getByIndex: (set: AtomSet, i: number) => OrderedSet = Base.getByIndex as any;
 
-    export const hasAtom: (set: AtomSet, x: IntTuple) => boolean = Base.hasTuple as any;
-    export const indexOfAtom: (set: AtomSet, x: IntTuple) => number = Base.indexOf as any;
-    export const getAtomAt: (set: AtomSet, i: number) => IntTuple = Base.getAt as any;
-    export const atoms: (set: AtomSet) => Iterator<IntTuple> = Base.values as any;
+    export const hasAtom: (set: AtomSet, x: Tuple) => boolean = Base.hasTuple as any;
+    export const indexOfAtom: (set: AtomSet, x: Tuple) => number = Base.indexOf as any;
+    export const getAtomAt: (set: AtomSet, i: number) => Tuple = Base.getAt as any;
+    export const atoms: (set: AtomSet) => Iterator<Tuple> = Base.values as any;
 
     export const atomCount: (set: AtomSet) => number = Base.size as any;
 

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

@@ -4,22 +4,22 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import OrderedSet from '../../mol-base/collections/ordered-set'
+import OrderedSet from '../../mol-base/collections/integer/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 Tuple from '../../mol-base/collections/integer/tuple'
+import Interval from '../../mol-base/collections/integer/interval'
 import { sortArray } from '../../mol-base/collections/sort'
 import { hash1 } from '../../mol-base/collections/hash-functions'
 
 /** Long and painful implementation starts here */
 
 export interface AtomSetElements { [id: number]: OrderedSet, offsets: number[], hashCode: number, keys: OrderedSet }
-export type AtomSetImpl = IntTuple | AtomSetElements
+export type AtomSetImpl = Tuple | AtomSetElements
 
 export const Empty: AtomSetImpl = { offsets: [0], hashCode: 0, keys: OrderedSet.Empty };
 
-export function create(data: IntTuple | ArrayLike<IntTuple> | { [id: number]: OrderedSet }): AtomSetImpl {
-    if (typeof data === 'number' || IntTuple.is(data)) return data;
+export function create(data: Tuple | ArrayLike<Tuple> | { [id: number]: OrderedSet }): AtomSetImpl {
+    if (typeof data === 'number' || Tuple.is(data)) return data;
     if (isArrayLike(data)) return ofTuples(data);
     return ofObject(data as { [id: number]: OrderedSet });
 }
@@ -39,42 +39,42 @@ export function keyCount(set: AtomSetImpl): number {
 }
 
 export function hasKey(set: AtomSetImpl, key: number): boolean {
-    if (typeof set === 'number') return IntTuple.fst(set) === key;
+    if (typeof set === 'number') return Tuple.fst(set) === key;
     return OrderedSet.has((set as AtomSetElements).keys, key);
 }
 
 export function getKey(set: AtomSetImpl, index: number): number {
-    if (typeof set === 'number') return IntTuple.fst(set);
+    if (typeof set === 'number') return Tuple.fst(set);
     return OrderedSet.getAt((set as AtomSetElements).keys, index);
 }
 
-export function hasTuple(set: AtomSetImpl, t: IntTuple): boolean {
-    if (typeof set === 'number') return IntTuple.areEqual(t, set);
-    const unit = IntTuple.fst(t);
+export function hasTuple(set: AtomSetImpl, t: Tuple): boolean {
+    if (typeof set === 'number') return Tuple.areEqual(t, set);
+    const unit = Tuple.fst(t);
     return OrderedSet.has((set as AtomSetElements).keys, unit)
-        ? OrderedSet.has((set as AtomSetElements)[unit], IntTuple.snd(t)) : false;
+        ? OrderedSet.has((set as AtomSetElements)[unit], Tuple.snd(t)) : false;
 }
 
 export function getByKey(set: AtomSetImpl, key: number): OrderedSet {
     if (typeof set === 'number') {
-        return IntTuple.fst(set) === key ? OrderedSet.ofSingleton(IntTuple.snd(set)) : OrderedSet.Empty;
+        return Tuple.fst(set) === key ? OrderedSet.ofSingleton(Tuple.snd(set)) : OrderedSet.Empty;
     }
     return OrderedSet.has((set as AtomSetElements).keys, key) ? (set as AtomSetElements)[key] : OrderedSet.Empty;
 }
 
 export function getByIndex(set: AtomSetImpl, index: number): OrderedSet {
-    if (typeof set === 'number') return index === 0 ? OrderedSet.ofSingleton(IntTuple.snd(set)) : OrderedSet.Empty;
+    if (typeof set === 'number') return index === 0 ? OrderedSet.ofSingleton(Tuple.snd(set)) : OrderedSet.Empty;
     const key = OrderedSet.getAt((set as AtomSetElements).keys, index);
     return (set as AtomSetElements)[key] || OrderedSet.Empty;
 }
 
-export function getAt(set: AtomSetImpl, i: number): IntTuple {
+export function getAt(set: AtomSetImpl, i: number): Tuple {
     if (typeof set === 'number') return set;
     return getAtE(set as AtomSetElements, i);
 }
 
-export function indexOf(set: AtomSetImpl, t: IntTuple) {
-    if (typeof set === 'number') return IntTuple.areEqual(set, t) ? 0 : -1;
+export function indexOf(set: AtomSetImpl, t: Tuple) {
+    if (typeof set === 'number') return Tuple.areEqual(set, t) ? 0 : -1;
     return indexOfE(set as AtomSetElements, t);
 }
 
@@ -85,14 +85,14 @@ export function size(set: AtomSetImpl) {
 }
 
 export function hashCode(set: AtomSetImpl) {
-    if (typeof set === 'number') return IntTuple.hashCode(set);
+    if (typeof set === 'number') return Tuple.hashCode(set);
     if ((set as AtomSetElements).hashCode !== -1) return (set as AtomSetElements).hashCode;
     return computeHash((set as AtomSetElements));
 }
 
 export function areEqual(a: AtomSetImpl, b: AtomSetImpl) {
     if (typeof a === 'number') {
-        if (typeof b === 'number') return IntTuple.areEqual(a, b);
+        if (typeof b === 'number') return Tuple.areEqual(a, b);
         return false;
     }
     if (typeof b === 'number') return false;
@@ -101,7 +101,7 @@ export function areEqual(a: AtomSetImpl, b: AtomSetImpl) {
 
 export function areIntersecting(a: AtomSetImpl, b: AtomSetImpl) {
     if (typeof a === 'number') {
-        if (typeof b === 'number') return IntTuple.areEqual(a, b);
+        if (typeof b === 'number') return Tuple.areEqual(a, b);
         return areIntersectingNE(a, b as AtomSetElements);
     }
     if (typeof b === 'number') return areIntersectingNE(b, a as AtomSetElements);
@@ -110,7 +110,7 @@ export function areIntersecting(a: AtomSetImpl, b: AtomSetImpl) {
 
 export function intersect(a: AtomSetImpl, b: AtomSetImpl) {
     if (typeof a === 'number') {
-        if (typeof b === 'number') return IntTuple.areEqual(a, b) ? a : Empty;
+        if (typeof b === 'number') return Tuple.areEqual(a, b) ? a : Empty;
         return intersectNE(a, b as AtomSetElements);
     }
     if (typeof b === 'number') return intersectNE(b, a as AtomSetElements);
@@ -119,7 +119,7 @@ export function intersect(a: AtomSetImpl, b: AtomSetImpl) {
 
 export function subtract(a: AtomSetImpl, b: AtomSetImpl) {
     if (typeof a === 'number') {
-        if (typeof b === 'number') return IntTuple.areEqual(a, b) ? Empty : a;
+        if (typeof b === 'number') return Tuple.areEqual(a, b) ? Empty : a;
         return subtractNE(a, b as AtomSetElements);
     }
     if (typeof b === 'number') return subtractEN(a as AtomSetElements, b);
@@ -134,7 +134,7 @@ export function unionMany(sets: ArrayLike<AtomSetImpl>) {
     return findUnion(sets);
 }
 
-class ElementsIterator implements Iterator<IntTuple> {
+class ElementsIterator implements Iterator<Tuple> {
     private unit: number = 0;
     private keyCount: number;
     private setIndex = -1;
@@ -147,13 +147,13 @@ class ElementsIterator implements Iterator<IntTuple> {
     next() { const value = this.move(); return { value, done: this.done } }
 
     move() {
-        if (this.done) return IntTuple.Zero;
+        if (this.done) return Tuple.Zero;
 
         if (this.currentIndex >= this.currentSize) {
-            if (!this.advance()) return IntTuple.Zero;
+            if (!this.advance()) return Tuple.Zero;
         }
 
-        return IntTuple.create(this.unit, OrderedSet.getAt(this.currentSet, this.currentIndex++));
+        return Tuple.create(this.unit, OrderedSet.getAt(this.currentSet, this.currentIndex++));
     }
 
     private advance() {
@@ -175,12 +175,12 @@ class ElementsIterator implements Iterator<IntTuple> {
     }
 }
 
-export function values(set: AtomSetImpl): Iterator<IntTuple> {
-    if (typeof set === 'number') return Iterator.Value(set as IntTuple);
+export function values(set: AtomSetImpl): Iterator<Tuple> {
+    if (typeof set === 'number') return Iterator.Value(set as Tuple);
     return new ElementsIterator(set as AtomSetElements);
 }
 
-function isArrayLike(x: any): x is ArrayLike<IntTuple> {
+function isArrayLike(x: any): x is ArrayLike<Tuple> {
     return x && (typeof x.length === 'number' && (x instanceof Array || !!x.buffer));
 }
 
@@ -193,7 +193,7 @@ function ofObject(data: { [id: number]: OrderedSet }) {
     if (!keys.length) return Empty;
     if (keys.length === 1) {
         const set = data[keys[0]];
-        if (OrderedSet.size(set) === 1) return IntTuple.create(keys[0], OrderedSet.getAt(set, 0));
+        if (OrderedSet.size(set) === 1) return Tuple.create(keys[0], OrderedSet.getAt(set, 0));
     }
     return ofObject1(keys, data);
 }
@@ -202,7 +202,7 @@ function ofObject1(keys: number[], data: { [id: number]: OrderedSet }) {
     if (keys.length === 1) {
         const k = keys[0];
         const set = data[k];
-        if (OrderedSet.size(set) === 1) return IntTuple.create(k, OrderedSet.getAt(set, 0));
+        if (OrderedSet.size(set) === 1) return Tuple.create(k, OrderedSet.getAt(set, 0));
     }
     sortArray(keys);
     return _createObjectOrdered(OrderedSet.ofSortedArray(keys), data);
@@ -212,7 +212,7 @@ function ofObjectOrdered(keys: OrderedSet, data: { [id: number]: OrderedSet }) {
     if (OrderedSet.size(keys) === 1) {
         const k = OrderedSet.getAt(keys, 0);
         const set = data[k];
-        if (OrderedSet.size(set) === 1) return IntTuple.create(k, OrderedSet.getAt(set, 0));
+        if (OrderedSet.size(set) === 1) return Tuple.create(k, OrderedSet.getAt(set, 0));
     }
     return _createObjectOrdered(keys, data);
 }
@@ -256,12 +256,12 @@ function normalizeArray(xs: number[]) {
     return xs;
 }
 
-function ofTuples(xs: ArrayLike<IntTuple>) {
+function ofTuples(xs: ArrayLike<Tuple>) {
     if (xs.length === 0) return Empty;
     const sets: { [key: number]: number[] } = Object.create(null);
     for (let i = 0, _i = xs.length; i < _i; i++) {
         const x = xs[i];
-        const u = IntTuple.fst(x), v = IntTuple.snd(x);
+        const u = Tuple.fst(x), v = Tuple.snd(x);
         const set = sets[u];
         if (set) set[set.length] = v;
         else sets[u] = [v];
@@ -291,21 +291,21 @@ function getOffsetIndex(xs: ArrayLike<number>, value: number) {
     return value < xs[min] ? min - 1 : min;
 }
 
-function getAtE(set: AtomSetElements, i: number): IntTuple {
+function getAtE(set: AtomSetElements, i: number): Tuple {
     const { offsets, keys } = set;
     const o = getOffsetIndex(offsets, i);
     if (o >= offsets.length - 1) return 0 as any;
     const k = OrderedSet.getAt(keys, o);
     const e = OrderedSet.getAt(set[k], i - offsets[o]);
-    return IntTuple.create(k, e);
+    return Tuple.create(k, e);
 }
 
-function indexOfE(set: AtomSetElements, t: IntTuple) {
+function indexOfE(set: AtomSetElements, t: Tuple) {
     const { keys } = set;
-    const u = IntTuple.fst(t);
+    const u = Tuple.fst(t);
     const setIdx = OrderedSet.indexOf(keys, u);
     if (setIdx < 0) return -1;
-    const o = OrderedSet.indexOf(set[u], IntTuple.snd(t));
+    const o = OrderedSet.indexOf(set[u], Tuple.snd(t));
     if (o < 0) return -1;
     return set.offsets[setIdx] + o;
 }
@@ -337,9 +337,9 @@ function areEqualEE(a: AtomSetElements, b: AtomSetElements) {
     return true;
 }
 
-function areIntersectingNE(a: IntTuple, b: AtomSetElements) {
-    const u = IntTuple.fst(a);
-    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], IntTuple.snd(a));
+function areIntersectingNE(a: Tuple, b: AtomSetElements) {
+    const u = Tuple.fst(a);
+    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], Tuple.snd(a));
 }
 
 function areIntersectingEE(a: AtomSetElements, b: AtomSetElements) {
@@ -355,9 +355,9 @@ function areIntersectingEE(a: AtomSetElements, b: AtomSetElements) {
     return false;
 }
 
-function intersectNE(a: IntTuple, b: AtomSetElements) {
-    const u = IntTuple.fst(a);
-    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], IntTuple.snd(a)) ? a : Empty;
+function intersectNE(a: Tuple, b: AtomSetElements) {
+    const u = Tuple.fst(a);
+    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], Tuple.snd(a)) ? a : Empty;
 }
 
 function intersectEE(a: AtomSetElements, b: AtomSetElements) {
@@ -382,14 +382,14 @@ function intersectEE(a: AtomSetElements, b: AtomSetElements) {
     return ofObjectOrdered(OrderedSet.ofSortedArray(keys), ret);
 }
 
-function subtractNE(a: IntTuple, b: AtomSetElements) {
-    const u = IntTuple.fst(a);
-    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], IntTuple.snd(a)) ? Empty : a;
+function subtractNE(a: Tuple, b: AtomSetElements) {
+    const u = Tuple.fst(a);
+    return OrderedSet.has(b.keys, u) && OrderedSet.has(b[u], Tuple.snd(a)) ? Empty : a;
 }
 
-function subtractEN(a: AtomSetElements, b: IntTuple): AtomSetImpl {
+function subtractEN(a: AtomSetElements, b: Tuple): AtomSetImpl {
     const aKeys =  a.keys;
-    const u = IntTuple.fst(b), v = IntTuple.snd(b);
+    const u = Tuple.fst(b), v = Tuple.snd(b);
     if (!OrderedSet.has(aKeys, u) || !OrderedSet.has(a[u], v)) return a;
     const set = a[u];
     if (OrderedSet.size(set) === 1) {
@@ -470,7 +470,7 @@ function unionN(sets: ArrayLike<AtomSetImpl>, eCount: { count: number }) {
     }
     eCount.count = countE;
     if (!countN) return Empty;
-    if (countN === sets.length) return ofTuples(sets as ArrayLike<IntTuple>);
+    if (countN === sets.length) return ofTuples(sets as ArrayLike<Tuple>);
     const packed = new Float64Array(countN);
     let offset = 0;
     for (let i = 0, _i = sets.length; i < _i; i++) {
@@ -490,12 +490,12 @@ function unionInto(data: { [key: number]: OrderedSet }, a: AtomSetElements) {
     }
 }
 
-function unionIntoN(data: { [key: number]: OrderedSet }, a: IntTuple) {
-    const u = IntTuple.fst(a);
+function unionIntoN(data: { [key: number]: OrderedSet }, a: Tuple) {
+    const u = Tuple.fst(a);
     const set = data[u];
     if (set) {
-        data[u] = OrderedSet.union(set, OrderedSet.ofSingleton(IntTuple.snd(a)));
+        data[u] = OrderedSet.union(set, OrderedSet.ofSingleton(Tuple.snd(a)));
     } else {
-        data[u] = OrderedSet.ofSingleton(IntTuple.snd(a));
+        data[u] = OrderedSet.ofSingleton(Tuple.snd(a));
     }
 }

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

@@ -5,7 +5,7 @@
  */
 
 import AtomSet from '../atom-set'
-import OrderedSet from '../../mol-base/collections/ordered-set'
+import OrderedSet from '../../mol-base/collections/integer/ordered-set'
 import { sortArray } from '../../mol-base/collections/sort'
 
 class Builder {

src/mol-data/model.ts

@@ -7,7 +7,7 @@
 import * as Formats from './model/formats'
 import CommonInterface from './model/interfaces/common'
 import MacromoleculeInterface from './model/interfaces/common'
-import OrderedSet from '../mol-base/collections/ordered-set'
+import Segmentation from '../mol-base/collections/integer/segmentation'
 
 interface Model {
     data: Formats.RawData,
@@ -15,14 +15,8 @@ interface Model {
     common: CommonInterface,
     macromolecule: MacromoleculeInterface
 
-    // Atom offsets of the "i-th chain" stored as a closed-open range [chainSegments[i], chainSegments[i + 1])
-    chainSegments: OrderedSet,
-    // Atom offsets of the "i-th residue" stored as a closed-open range [residueSegments[i], residueSegments[i + 1])
-    residueSegments: OrderedSet,
-    // Mapping from a residue index to chain index
-    residueChainIndex: ArrayLike<number>,
-    // Mapping from an atom into to residue index
-    atomResidueIndex: ArrayLike<number>
+    chains: Segmentation,
+    residues: Segmentation
 }
 
 export default Model

src/perf-tests/sets.ts

@@ -1,9 +1,9 @@
 import * as B from 'benchmark'
-import IntTuple from '../mol-base/collections/int-tuple'
-import OrdSet from '../mol-base/collections/ordered-set'
+import Tuple from '../mol-base/collections/integer/tuple'
+import OrdSet from '../mol-base/collections/integer/ordered-set'
 import AtomSet from '../mol-data/atom-set'
-import Segmentation from '../mol-base/collections/segmentation'
-import SortedArray from '../mol-base/collections/sorted-array'
+import Segmentation from '../mol-base/collections/integer/segmentation'
+import SortedArray from '../mol-base/collections/integer/sorted-array'
 
 export namespace Iteration {
     const U = 1000, V = 2500;
@@ -29,13 +29,13 @@ export namespace Iteration {
     export function iterators() {
         let s = 0;
         const it = AtomSet.atoms(ms);
-        for (let v = it.move(); !it.done; v = it.move()) s += IntTuple.snd(v);
+        for (let v = it.move(); !it.done; v = it.move()) s += Tuple.snd(v);
         return s;
     }
 
     export function elementAt() {
         let s = 0;
-        for (let i = 0, _i = AtomSet.atomCount(ms); i < _i; i++) s += IntTuple.snd(AtomSet.getAtomAt(ms, i));
+        for (let i = 0, _i = AtomSet.atomCount(ms); i < _i; i++) s += Tuple.snd(AtomSet.getAtomAt(ms, i));
         return s;
     }
 
@@ -234,26 +234,26 @@ export namespace Build {
 
 export namespace Tuples {
     function createData(n: number) {
-        const ret: IntTuple[] = new Float64Array(n) as any;
+        const ret: Tuple[] = new Float64Array(n) as any;
         for (let i = 0; i < n; i++) {
-            ret[i] = IntTuple.create(i, i * i + 1);
+            ret[i] = Tuple.create(i, i * i + 1);
         }
         return ret;
     }
 
-    function sum1(data: ArrayLike<IntTuple>) {
+    function sum1(data: ArrayLike<Tuple>) {
         let s = 0;
         for (let i = 0, _i = data.length; i < _i; i++) {
-            s += IntTuple.fst(data[i]) + IntTuple.snd(data[i]);
+            s += Tuple.fst(data[i]) + Tuple.snd(data[i]);
         }
         return s;
     }
 
-    function sum2(data: ArrayLike<IntTuple>) {
+    function sum2(data: ArrayLike<Tuple>) {
         let s = 0;
         for (let i = 0, _i = data.length; i < _i; i++) {
             const t = data[i];
-            s += IntTuple.fst(t) + IntTuple.snd(t);
+            s += Tuple.fst(t) + Tuple.snd(t);
         }
         return s;
     }