molstar
Version:
A comprehensive macromolecular library.
396 lines • 12.3 kB
JavaScript
/**
* Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author David Sehnal <david.sehnal@gmail.com>
*/
import { SortedArray as S } from '../sorted-array';
import { Interval as I } from '../interval';
export var Empty = I.Empty;
export var ofSingleton = I.ofSingleton;
export var ofRange = I.ofRange;
export var ofBounds = I.ofBounds;
export function ofSortedArray(xs) {
if (!xs.length)
return Empty;
// check if the array is just a range
if (S.isRange(xs))
return I.ofRange(xs[0], xs[xs.length - 1]);
return xs;
}
export function size(set) { return I.is(set) ? I.size(set) : S.size(set); }
export function has(set, x) { return I.is(set) ? I.has(set, x) : S.has(set, x); }
/** Returns the index of `x` in `set` or -1 if not found. */
export function indexOf(set, x) { return I.is(set) ? I.indexOf(set, x) : S.indexOf(set, x); }
export function getAt(set, i) { return I.is(set) ? I.getAt(set, i) : set[i]; }
export function min(set) { return I.is(set) ? I.min(set) : S.min(set); }
export function max(set) { return I.is(set) ? I.max(set) : S.max(set); }
export function start(set) { return I.is(set) ? I.start(set) : S.start(set); }
export function end(set) { return I.is(set) ? I.end(set) : S.end(set); }
export function hashCode(set) { return I.is(set) ? I.hashCode(set) : S.hashCode(set); }
// TODO: possibly add more hash functions to allow for multilevel hashing.
export function toString(set) { return I.is(set) ? I.toString(set) : S.toString(set); }
export function areEqual(a, b) {
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, b) {
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 S.areIntersecting(a, b);
}
/** Check if the 2nd argument is a subset of the 1st */
export function isSubset(a, b) {
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 S.isSubset(a, b);
}
export function findPredecessorIndex(set, x) {
return I.is(set) ? I.findPredecessorIndex(set, x) : S.findPredecessorIndex(set, x);
}
export function findPredecessorIndexInInterval(set, x, bounds) {
return I.is(set) ? I.findPredecessorIndexInInterval(set, x, bounds) : S.findPredecessorIndexInInterval(set, x, bounds);
}
export function findRange(set, min, max) {
return I.is(set) ? I.findRange(set, min, max) : S.findRange(set, min, max);
}
export function intersectionSize(a, b) {
if (I.is(a)) {
if (I.is(b))
return I.intersectionSize(a, b);
return intersectionSizeSI(b, a);
}
else if (I.is(b))
return intersectionSizeSI(a, b);
return S.intersectionSize(a, b);
}
export function union(a, b) {
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 ofSortedArray(S.union(a, b));
}
export function intersect(a, b) {
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 ofSortedArray(S.intersect(a, b));
}
export function subtract(a, b) {
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 ofSortedArray(S.subtract(a, b));
}
function areEqualIS(a, b) { return I.size(a) === S.size(b) && I.start(a) === S.start(b) && I.end(a) === S.end(b); }
function areIntersectingSI(a, b) {
return a.length !== 0 && I.size(S.findRange(a, I.min(b), I.max(b))) !== 0;
}
function isSubsetSI(a, b) {
var minB = I.min(b), maxB = I.max(b);
if (maxB - minB + 1 === 0)
return true;
var minA = S.min(a), maxA = S.max(a);
if (minB < minA || maxB > maxA)
return false;
var r = S.findRange(a, minB, maxB);
return I.size(r) === I.size(b);
}
function isSubsetIS(a, b) {
var minA = I.min(a), maxA = I.max(a);
if (maxA - minA + 1 === 0)
return false;
var minB = S.min(b), maxB = S.max(b);
return minB >= minA && maxB <= maxA;
}
function areRangesIntersecting(a, b) {
var 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, b) {
if (!size(a))
return size(b) === 0;
if (!size(b))
return true;
return min(a) <= min(b) && max(a) >= max(b);
}
function unionII(a, b) {
if (I.areEqual(a, b))
return a;
var sizeA = I.size(a), sizeB = I.size(b);
if (!sizeB)
return a;
if (!sizeA)
return b;
var 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)));
var lSize, lMin, rSize, rMin;
if (minA < minB) {
lSize = sizeA;
lMin = minA;
rSize = sizeB;
rMin = minB;
}
else {
lSize = sizeB;
lMin = minB;
rSize = sizeA;
rMin = minA;
}
var arr = new Int32Array(sizeA + sizeB);
for (var i = 0; i < lSize; i++)
arr[i] = i + lMin;
for (var i = 0; i < rSize; i++)
arr[i + lSize] = i + rMin;
return ofSortedArray(arr);
}
function unionSI(a, b) {
var bSize = I.size(b);
if (!bSize)
return a;
// is the array fully contained in the range?
if (isRangeSubset(b, a))
return b;
var min = I.min(b), max = I.max(b);
var r = S.findRange(a, min, max);
var start = I.start(r), end = I.end(r);
var indices = new Int32Array(start + (a.length - end) + bSize);
var offset = 0;
for (var i = 0; i < start; i++)
indices[offset++] = a[i];
for (var i = min; i <= max; i++)
indices[offset++] = i;
for (var i = end, _i = a.length; i < _i; i++)
indices[offset++] = a[i];
return ofSortedArray(indices);
}
function intersectionSizeSI(a, b) {
if (!I.size(b))
return 0;
var r = S.findRange(a, I.min(b), I.max(b));
return I.end(r) - I.start(r);
}
function intersectSI(a, b) {
if (!I.size(b))
return Empty;
var r = S.findRange(a, I.min(b), I.max(b));
var start = I.start(r), end = I.end(r);
var resultSize = end - start;
if (!resultSize)
return Empty;
if (resultSize === a.length)
return a;
var indices = new Int32Array(resultSize);
var offset = 0;
for (var i = start; i < end; i++) {
indices[offset++] = a[i];
}
return ofSortedArray(indices);
}
function subtractII(a, b) {
if (I.areEqual(a, b))
return Empty;
if (!I.areIntersecting(a, b))
return a;
var minA = I.min(a), maxA = I.max(a);
var 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.
var 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);
var ret = new Int32Array(l + r);
var offset = 0;
for (var i = 0; i < l; i++)
ret[offset++] = minA + i;
for (var 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, b) {
var min = I.min(b), max = I.max(b);
// is empty?
if (max < min)
return a;
var r = S.findRange(a, min, max);
var start = I.start(r), end = I.end(r);
var resultSize = a.length - (end - start);
// A is subset of B
if (resultSize <= 0)
return Empty;
// No common elements
if (resultSize === a.length)
return a;
var ret = new Int32Array(resultSize);
var offset = 0;
for (var i = 0; i < start; i++)
ret[offset++] = a[i];
for (var i = end, _i = a.length; i < _i; i++)
ret[offset++] = a[i];
return ofSortedArray(ret);
}
function subtractIS(a, b) {
var min = I.min(a), max = I.max(a);
// is empty?
if (max < min)
return a;
var rSize = max - min + 1;
var interval = S.findRange(b, min, max);
var start = I.start(interval), end = I.end(interval);
var commonCount = end - start;
// No common elements.
if (commonCount === 0)
return a;
var resultSize = rSize - commonCount;
// A is subset of B
if (resultSize <= 0)
return Empty;
var ret = new Int32Array(resultSize);
var li = b.length - 1;
var fst = b[Math.min(start, li)], last = b[Math.min(end, li)];
var offset = 0;
for (var i = min; i < fst; i++)
ret[offset++] = i;
for (var i = fst; i <= last; i++) {
if (S.indexOfInInterval(b, i, interval) < 0)
ret[offset++] = i;
}
for (var i = last + 1; i <= max; i++)
ret[offset++] = i;
return ofSortedArray(ret);
}
export function forEach(set, f, ctx) {
if (I.is(set)) {
var start_1 = I.min(set);
for (var i = start_1, _i = I.max(set); i <= _i; i++) {
f(i, i - start_1, ctx);
}
}
else {
for (var i = 0, _i = set.length; i < _i; i++) {
f(set[i], i, ctx);
}
}
return ctx;
}
export function forEachSegment(set, segment, f, ctx) {
if (I.is(set)) {
var sI = 0;
for (var i = I.min(set), _i = I.max(set); i <= _i; i++) {
var s = segment(i);
var endI = i + 1;
while (endI < _i && segment(endI) === s)
endI++;
i = endI - 1;
f(s, sI, ctx);
sI++;
}
}
else {
var sI = 0;
for (var i = 0, _i = set.length; i < _i; i++) {
var s = segment(set[i]);
var endI = i + 1;
while (endI < _i && segment(set[endI]) === s)
endI++;
i = endI - 1;
f(s, sI, ctx);
sI++;
}
}
return ctx;
}
export function indexedIntersect(idxA, a, b) {
if (a === b)
return idxA;
var lenI = size(idxA), lenA = a.length, lenB = b.length;
if (lenI === 0 || lenA === 0 || lenB === 0)
return Empty;
var startJ = S.findPredecessorIndex(b, a[min(idxA)]);
var endJ = S.findPredecessorIndex(b, a[max(idxA)] + 1);
var commonCount = 0;
var offset = 0;
var O = 0;
var j = startJ;
while (O < lenI && j < endJ) {
var x = a[getAt(idxA, O)], y = b[j];
if (x < y) {
O++;
}
else if (x > y) {
j++;
}
else {
commonCount++;
O++;
j++;
}
}
// no common elements
if (commonCount === 0)
return Empty;
// A === B
if (commonCount === lenA && commonCount === lenB)
return idxA;
var indices = new Int32Array(commonCount);
offset = 0;
O = 0;
j = startJ;
while (O < lenI && j < endJ) {
var x = a[getAt(idxA, O)], y = b[j];
if (x < y) {
O++;
}
else if (x > y) {
j++;
}
else {
indices[offset++] = j;
O++;
j++;
}
}
return ofSortedArray(indices);
}
//# sourceMappingURL=ordered-set.js.map