mol-data refactoring, add IntMap

src/mol-data/_spec/equiv-index.spec.ts

@@ -4,7 +4,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import EquivalenceClasses from '../util/equivalence-classes'
+import { EquivalenceClasses } from '../util'
 
 describe('equiv-classes', () => {
     it('integer mod classes', () => {

src/mol-data/db/column.ts

@@ -80,6 +80,10 @@ namespace Column {
         valueKind?: (row: number) => ValueKind,
     }
 
+    export function is(v: any): v is Column<any> {
+        return !!v && !!(v as Column<any>).schema && !!(v as Column<any>).value;
+    }
+
     export const enum ValueKind { Present = 0, NotPresent = 1, Unknown = 2 }
 
     export function Undefined<T extends Schema>(rowCount: number, schema: T): Column<T['T']> {
@@ -306,6 +310,7 @@ function mapToArrayImpl<T, S>(c: Column<T>, f: (v: T) => S, ctor: Column.ArrayCt
 }
 
 function areColumnsEqual(a: Column<any>, b: Column<any>) {
+    if (a === b) return true;
     if (a.rowCount !== b.rowCount || a.isDefined !== b.isDefined || a.schema.valueType !== b.schema.valueType) return false;
     if (!!a['@array'] && !!b['@array']) return areArraysEqual(a, b);
     return areValuesEqual(a, b);

src/mol-data/db/table.ts

@@ -130,6 +130,26 @@ namespace Table {
 
         return true;
     }
+
+    /** Allocate a new object with the given row values. */
+    export function getRow<S extends Schema>(table: Table<S>, index: number) {
+        const row: Row<S> = Object.create(null);
+        const { _columns: cols } = table;
+        for (let i = 0; i < cols.length; i++) {
+            const c = cols[i];
+            row[c] = table[c].value(index);
+        }
+        return row;
+    }
+
+    export function getRows<S extends Schema>(table: Table<S>) {
+        const ret: Row<S>[] = [];
+        const { _rowCount: c } = table;
+        for (let i = 0; i < c; i++) {
+            ret[i] = getRow(table, i);
+        }
+        return ret;
+    }
 }
 
 export default Table

src/mol-data/int.ts

@@ -10,6 +10,7 @@ import Segmentation from './int/segmentation'
 import SortedArray from './int/sorted-array'
 import Tuple from './int/tuple'
 import LinkedIndex from './int/linked-index'
+import IntMap from './int/map'
 import Iterator from './iterator'
 
-export { Interval, OrderedSet, Segmentation, SortedArray, Tuple, LinkedIndex, Iterator }
+export { Interval, OrderedSet, Segmentation, SortedArray, Tuple, LinkedIndex, IntMap, Iterator }

src/mol-data/int/map.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { iterableToArray } from '../util'
+
+/** Immutable by convention IntMap */
+interface IntMap<T> {
+    keys(): IterableIterator<number>,
+    values(): IterableIterator<T>,
+    get(key: number): T,
+    readonly size: number
+}
+
+namespace IntMap {
+    export interface Mutable<T> extends IntMap<T> {
+        set(key: number, value: T): void;
+    }
+
+    export function keyArray<T>(map: IntMap<T>): number[] {
+        return iterableToArray(map.keys());
+    }
+
+    export function ofObj<T>(obj: { [key: number]: T }): IntMap<T> {
+        const keys = Object.keys(obj);
+        const ret = new Map<number, T>();
+        for (let i = 0, _i = keys.length; i < _i; i++) {
+            const k = keys[i];
+            ret.set(+k, obj[k as any]);
+        }
+        return ret as IntMap<T>;
+    }
+
+    export function Mutable<T>(): Mutable<T> {
+        return new Map<number, T>() as Mutable<T>;
+    }
+
+    export function asImmutable<T>(map: IntMap<T>): IntMap<T> {
+        return map;
+    }
+}
+
+export default IntMap;

src/mol-data/util.ts

@@ -4,12 +4,11 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import ChunkedArray from './util/chunked-array'
-import EquivalenceClasses from './util/chunked-array'
-import HashSet from './util/hash-set'
-import UniqueArray from './util/unique-array'
-
+export * from './util/chunked-array'
+export * from './util/unique-array'
+export * from './util/hash-set'
+export * from './util/equivalence-classes'
 export * from './util/hash-functions'
 export * from './util/sort'
-
-export { ChunkedArray, EquivalenceClasses, HashSet, UniqueArray }
+export * from './util/grouping'
+export * from './util/array'

src/mol-data/util/array.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * from https://github.com/dsehnal/CIFTools.js
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+export function arrayFind<T>(array: ArrayLike<T>, f: (v: T) => boolean): T | undefined {
+    for (let i = 0, _i = array.length; i < _i; i++) {
+        if (f(array[i])) return array[i];
+    }
+    return void 0;
+}
+
+export function iterableToArray<T>(it: IterableIterator<T>): T[] {
+    if (Array.from) return Array.from(it);
+    
+    const ret = [];
+    while (true) {
+        const { done, value } = it.next();
+        if (done) break;
+        ret[ret.length] = value;
+    }
+    return ret;
+}

src/mol-data/util/chunked-array.ts

@@ -134,4 +134,4 @@ namespace ChunkedArray {
     }
 }
 
-export default ChunkedArray
+export { ChunkedArray }

src/mol-data/util/equivalence-classes.ts

@@ -41,8 +41,6 @@ class EquivalenceClassesImpl<K, V> {
     constructor(private getHash: (v: V) => any, private areEqual: (a: V, b: V) => boolean) { }
 }
 
-function EquivalenceClasses<K, V>(getHash: (x: V) => any, areEqual: (a: V, b: V) => boolean) {
+export function EquivalenceClasses<K, V>(getHash: (x: V) => any, areEqual: (a: V, b: V) => boolean) {
     return new EquivalenceClassesImpl<K, V>(getHash, areEqual);
 }
-
-export default EquivalenceClasses;

src/mol-data/util/grouping.ts

@@ -4,31 +4,34 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
+import { Column } from '../db'
+
 export interface Grouping<V, K> {
+    map: Map<K, V[]>,
     keys: ReadonlyArray<K>,
     groups: ReadonlyArray<ReadonlyArray<V>>
 }
 
 class GroupingImpl<K, V> {
-    private byKey = new Map<K, V[]>();
+    readonly map = new Map<K, V[]>();
     readonly keys: K[] = [];
     readonly groups: V[][] = [];
 
     add(a: V) {
         const key = this.getKey(a) as any;
-        if (!!this.byKey.has(key)) {
-            const group = this.byKey.get(key)!;
+        if (!!this.map.has(key)) {
+            const group = this.map.get(key)!;
             group[group.length] = a;
         } else {
             const group = [a];
-            this.byKey.set(key, group);
+            this.map.set(key, group);
             this.keys[this.keys.length] = key;
             this.groups[this.groups.length] = group;
         }
     }
 
     getGrouping(): Grouping<V, K> {
-        return { keys: this.keys, groups: this.groups };
+        return { keys: this.keys, groups: this.groups, map: this.map };
     }
 
     constructor(private getKey: (v: V) => K) { }
@@ -38,10 +41,13 @@ export function Grouper<V, K>(getKey: (x: V) => K) {
     return new GroupingImpl<K, V>(getKey);
 }
 
-function groupBy<V, K>(values: ArrayLike<V>, getKey: (x: V) => K) {
+export function groupBy<V, K>(values: ArrayLike<V> | Column<V>, getKey: (x: V) => K) {
     const gs = Grouper(getKey);
-    for (let i = 0, _i = values.length; i < _i; i++) gs.add(values[i]);
+    if (Column.is(values)) {
+        const v = values.value;
+        for (let i = 0, _i = values.rowCount; i < _i; i++) gs.add(v(i));
+    } else {
+        for (let i = 0, _i = values.length; i < _i; i++) gs.add(values[i]);
+    }
     return gs.getGrouping();
-}
-
-export default groupBy;
+}

src/mol-data/util/hash-set.ts

@@ -45,8 +45,6 @@ class HashSetImpl<T> implements SetLike<T> {
 }
 // TODO: add implementations with multilevel hashing support?
 
-function HashSet<T>(getHash: (v: T) => any, areEqual: (a: T, b: T) => boolean): SetLike<T> {
+export function HashSet<T>(getHash: (v: T) => any, areEqual: (a: T, b: T) => boolean): SetLike<T> {
     return new HashSetImpl<T>(getHash, areEqual);
-}
-
-export default HashSet;
+}

src/mol-data/util/unique-array.ts

@@ -21,4 +21,4 @@ namespace UniqueArray {
     }
 }
 
-export default UniqueArray
+export { UniqueArray }

src/mol-io/common/binary-cif/array-encoder.ts

@@ -7,7 +7,7 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import ChunkedArray from 'mol-data/util/chunked-array'
+import { ChunkedArray } from 'mol-data/util'
 import { Encoding, EncodedData } from './encoding'
 
 export interface ArrayEncoder {

src/mol-model/structure/model/properties/symmetry.ts

@@ -5,6 +5,7 @@
  */
 
 import SymmetryOperator from 'mol-math/geometry/symmetry-operator'
+import { arrayFind } from 'mol-data/util'
 import { Query } from '../../query'
 import { Model } from '../../model'
 
@@ -47,12 +48,8 @@ namespace Symmetry {
     export const Empty: Symmetry = { assemblies: [] };
 
     export function findAssembly(model: Model, id: string): Assembly | undefined {
-        const { assemblies } = model.symmetry;
         const _id = id.toLocaleLowerCase();
-        for (let i = 0; i < assemblies.length; i++) {
-            if (assemblies[i].id.toLowerCase() === _id) return assemblies[i];
-        }
-        return void 0;
+        return arrayFind(model.symmetry.assemblies, a => a.id.toLowerCase() === _id);
     }
 }
 

src/mol-model/structure/query/selection.ts

@@ -5,7 +5,7 @@
  */
 
 import Iterator from 'mol-data/iterator'
-import HashSet from 'mol-data/util/hash-set'
+import { HashSet } from 'mol-data/util'
 import { Structure, Atom, AtomSet } from '../structure'
 
 type Selection =

src/mol-model/structure/structure/structure.ts

@@ -5,7 +5,7 @@
  */
 
 import { OrderedSet, Iterator } from 'mol-data/int'
-import UniqueArray from 'mol-data/util/unique-array'
+import { UniqueArray } from 'mol-data/util'
 import SymmetryOperator from 'mol-math/geometry/symmetry-operator'
 import { Model, Format } from '../model'
 import Unit from './unit'

src/perf-tests/chunked-array-vs-native.ts

@@ -1,5 +1,5 @@
 import * as B from 'benchmark'
-import ChunkedArray from 'mol-data/util/chunked-array'
+import { ChunkedArray } from 'mol-data/util'
 
 function testNative(size: number) {
     const xs = new Array(size);

src/perf-tests/sets.ts

@@ -331,7 +331,120 @@ export namespace ObjectVsMap {
     }
 }
 
-ObjectVsMap.run();
+export namespace IntVsStringIndices {
+    type WithKeys<K> = { keys: K[], data: { [key: number]: number } }
+    type MapWithKeys = { keys: number[], map: Map<number, number> }
+
+    function createCacheKeys(n: number): WithKeys<number> {
+        const data = Object.create(null), keys = [];
+        data.__ = void 0;
+        delete data.__;
+        for (let i = 1; i <= n; i++) {
+            const k = i * (i + 1);
+            keys[keys.length] = k;
+            data[k] = i + 1;
+        }
+        return { data, keys };
+    }
+
+    function createMapKeys(n: number): MapWithKeys {
+        const map = new Map<number, number>(), keys = [];
+        for (let i = 1; i <= n; i++) {
+            const k = i * (i + 1);
+            keys[keys.length] = k;
+            map.set(k, i + 1);
+        }
+        return { map, keys };
+    }
+
+    export function createInt(n: number) {
+        const ret = Object.create(null);
+        ret.__ = void 0;
+        delete ret.__;
+        for (let i = 1; i <= n; i++) ret[i * (i + 1)] = i + 1;
+        return ret;
+    }
+
+    export function createStr(n: number) {
+        const ret = Object.create(null);
+        ret.__ = void 0;
+        delete ret.__;
+        for (let i = 1; i <= n; i++) ret['' + (i * (i + 1))] = i + 1;
+        return ret;
+    }
+
+    export function createMap(n: number) {
+        const map = new Map<number, number>();
+        for (let i = 1; i <= n; i++) map.set(i * (i + 1), i + 1);
+        return map;
+    }
+
+    export function sumInt(xs: { [key: number]: number }) {
+        let s = 0;
+        const keys = Object.keys(xs);
+        for (let i = 0, _i = keys.length; i < _i; i++) s += xs[+keys[i]];
+        return s;
+    }
+
+    export function sumStr(xs: { [key: string]: number }) {
+        let s = 0;
+        const keys = Object.keys(xs);
+        for (let i = 0, _i = keys.length; i < _i; i++) s += xs[keys[i]];
+        return s;
+    }
+
+    export function sumMap(map: Map<number, number>) {
+        let s = 0;
+        const values = map.keys();
+        while (true) {
+            const { done, value } = values.next();
+            if (done) break;
+            s += value;
+        }
+        return s;
+    }
+
+    export function sumCached(xs: WithKeys<number>) {
+        let s = 0;
+        const keys = xs.keys, data = xs.data;
+        for (let i = 0, _i = keys.length; i < _i; i++) s += data[keys[i]];
+        return s;
+    }
+
+    export function sumKeyMap(xs: MapWithKeys) {
+        let s = 0;
+        const keys = xs.keys, map = xs.map;
+        for (let i = 0, _i = keys.length; i < _i; i++) s += map.get(keys[i])!;
+        return s;
+    }
+
+    export function run() {
+        const N = 1000;
+        //const int = createInt(N);
+        const map = createMap(N);
+        //const str = createStr(N);
+        const keys = createCacheKeys(N);
+        const keyMap = createMapKeys(N);
+        console.log(sumMap(map), sumCached(keys), sumKeyMap(keyMap));
+        new B.Suite()
+            //.add('c int', () => createInt(N))
+            .add('q map', () => sumMap(map))
+            .add('c map', () => createMap(N))
+            .add('c mk', () => createMapKeys(N))
+            //.add('c str', () => createStr(N))
+            .add('c cc', () => createCacheKeys(N))
+            //.add('q int', () => sumInt(int))
+            .add('q mk', () => sumKeyMap(keyMap))
+            //.add('q str', () => sumStr(str))
+            .add('q cc', () => sumCached(keys))
+            .on('cycle', (e: any) => console.log(String(e.target)))
+            .run();
+    }
+}
+
+IntVsStringIndices.run();
+
+//ObjectVsMap.run();
 
 //testSegments();