molstar
Version:
A comprehensive macromolecular library.
425 lines • 16.8 kB
JavaScript
"use strict";
/**
* Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* @author David Sehnal <david.sehnal@gmail.com>
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.Column = void 0;
var tslib_1 = require("tslib");
var ColumnHelpers = (0, tslib_1.__importStar)(require("./column-helpers"));
var linear_algebra_1 = require("../../mol-math/linear-algebra");
var number_parser_1 = require("../../mol-io/reader/common/text/number-parser");
var Column;
(function (Column) {
var Schema;
(function (Schema) {
// T also serves as a default value for undefined columns
Schema.str = { '@type': 'str', T: '', valueType: 'str' };
Schema.int = { '@type': 'int', T: 0, valueType: 'int' };
Schema.coord = { '@type': 'coord', T: 0, valueType: 'float' };
Schema.float = { '@type': 'float', T: 0, valueType: 'float' };
function Str(defaultValue) {
if (defaultValue === void 0) { defaultValue = ''; }
return { '@type': 'str', T: defaultValue, valueType: 'str' };
}
Schema.Str = Str;
;
function Int(defaultValue) {
if (defaultValue === void 0) { defaultValue = 0; }
return { '@type': 'int', T: defaultValue, valueType: 'int' };
}
Schema.Int = Int;
;
function Float(defaultValue) {
if (defaultValue === void 0) { defaultValue = 0; }
return { '@type': 'float', T: defaultValue, valueType: 'float' };
}
Schema.Float = Float;
;
function Tensor(space, baseType) {
if (baseType === void 0) { baseType = Schema.float; }
return { '@type': 'tensor', T: space.create(), space: space, valueType: 'tensor', baseType: baseType };
}
Schema.Tensor = Tensor;
function Vector(dim, baseType) {
if (baseType === void 0) { baseType = Schema.float; }
return Tensor(linear_algebra_1.Tensor.Vector(dim, baseType['@type'] === 'int' ? Int32Array : Float64Array), baseType);
}
Schema.Vector = Vector;
function Matrix(rows, cols, baseType) {
if (baseType === void 0) { baseType = Schema.float; }
return Tensor(linear_algebra_1.Tensor.ColumnMajorMatrix(rows, cols, baseType['@type'] === 'int' ? Int32Array : Float64Array), baseType);
}
Schema.Matrix = Matrix;
function Aliased(t, defaultValue) {
if (typeof defaultValue !== 'undefined')
return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, t), { T: defaultValue });
return t;
}
Schema.Aliased = Aliased;
function List(separator, itemParse, defaultValue) {
if (defaultValue === void 0) { defaultValue = []; }
return { '@type': 'list', T: defaultValue, separator: separator, itemParse: itemParse, valueType: 'list' };
}
Schema.List = List;
})(Schema = Column.Schema || (Column.Schema = {}));
function is(v) {
return !!v && !!v.schema && !!v.value;
}
Column.is = is;
function Undefined(rowCount, schema) {
return constColumn(schema['T'], rowCount, schema, 1 /* NotPresent */);
}
Column.Undefined = Undefined;
function ofConst(v, rowCount, type) {
return constColumn(v, rowCount, type, 0 /* Present */);
}
Column.ofConst = ofConst;
function ofLambda(spec) {
return lambdaColumn(spec);
}
Column.ofLambda = ofLambda;
/** values [min, max] (i.e. include both values) */
function range(min, max) {
return ofLambda({
value: function (i) { return i + min; },
rowCount: Math.max(max - min + 1, 0),
schema: Schema.int
});
}
Column.range = range;
function ofArray(spec) {
return arrayColumn(spec);
}
Column.ofArray = ofArray;
function ofIntArray(array) {
return arrayColumn({ array: array, schema: Schema.int });
}
Column.ofIntArray = ofIntArray;
function ofFloatArray(array) {
return arrayColumn({ array: array, schema: Schema.float });
}
Column.ofFloatArray = ofFloatArray;
function ofStringArray(array) {
return arrayColumn({ array: array, schema: Schema.str });
}
Column.ofStringArray = ofStringArray;
function ofStringAliasArray(array) {
return arrayColumn({ array: array, schema: Schema.Aliased(Schema.str) });
}
Column.ofStringAliasArray = ofStringAliasArray;
function ofStringListArray(array, separator) {
if (separator === void 0) { separator = ','; }
return arrayColumn({ array: array, schema: Schema.List(separator, function (x) { return x; }) });
}
Column.ofStringListArray = ofStringListArray;
function ofIntTokens(tokens) {
var count = tokens.count, data = tokens.data, indices = tokens.indices;
return lambdaColumn({
value: function (row) { return (0, number_parser_1.parseInt)(data, indices[2 * row], indices[2 * row + 1]) || 0; },
rowCount: count,
schema: Schema.int,
});
}
Column.ofIntTokens = ofIntTokens;
function ofFloatTokens(tokens) {
var count = tokens.count, data = tokens.data, indices = tokens.indices;
return lambdaColumn({
value: function (row) { return (0, number_parser_1.parseFloat)(data, indices[2 * row], indices[2 * row + 1]) || 0; },
rowCount: count,
schema: Schema.float,
});
}
Column.ofFloatTokens = ofFloatTokens;
function ofStringTokens(tokens) {
var count = tokens.count, data = tokens.data, indices = tokens.indices;
return lambdaColumn({
value: function (row) {
var ret = data.substring(indices[2 * row], indices[2 * row + 1]);
if (ret === '.' || ret === '?')
return '';
return ret;
},
rowCount: count,
schema: Schema.str,
});
}
Column.ofStringTokens = ofStringTokens;
function window(column, start, end) {
return windowColumn(column, start, end);
}
Column.window = window;
function view(column, indices, checkIndentity) {
if (checkIndentity === void 0) { checkIndentity = true; }
return columnView(column, indices, checkIndentity);
}
Column.view = view;
/** A map of the 1st occurence of each value. */
function createFirstIndexMap(column) {
return createFirstIndexMapOfColumn(column);
}
Column.createFirstIndexMap = createFirstIndexMap;
function createIndexer(column) {
return createIndexerOfColumn(column);
}
Column.createIndexer = createIndexer;
function mapToArray(column, f, ctor) {
return mapToArrayImpl(column, f, ctor || Array);
}
Column.mapToArray = mapToArray;
function areEqual(a, b) {
return areColumnsEqual(a, b);
}
Column.areEqual = areEqual;
function indicesOf(c, test) {
return columnIndicesOf(c, test);
}
Column.indicesOf = indicesOf;
/** Makes the column backed by an array. Useful for columns that are accessed often. */
function asArrayColumn(c, array) {
if (c.__array)
return c;
if (!c.isDefined)
return Undefined(c.rowCount, c.schema);
return arrayColumn({ array: c.toArray({ array: array }), schema: c.schema, valueKind: c.valueKind });
}
Column.asArrayColumn = asArrayColumn;
function copyToArray(c, array, offset) {
if (offset === void 0) { offset = 0; }
if (!c.isDefined)
return;
var cArray = c.__array;
if (cArray) {
for (var i = 0, _i = cArray.length; i < _i; i++)
array[offset + i] = cArray[i];
}
else {
for (var i = 0, _i = c.rowCount; i < _i; i++)
array[offset + i] = c.value(i);
}
}
Column.copyToArray = copyToArray;
function isIdentity(c) {
for (var i = 0, _i = c.rowCount; i < _i; i++) {
if (i !== c.value(i))
return false;
}
return true;
}
Column.isIdentity = isIdentity;
})(Column || (Column = {}));
exports.Column = Column;
function createFirstIndexMapOfColumn(c) {
var map = new Map();
for (var i = 0, _i = c.rowCount; i < _i; i++) {
var v = c.value(i);
if (!map.has(v))
map.set(c.value(i), i);
}
return map;
}
function createIndexerOfColumn(c) {
var map = new Map();
for (var i = 0, _i = c.rowCount; i < _i; i++) {
var v = c.value(i);
if (!map.has(v))
map.set(c.value(i), i);
}
return function (v) { return map.has(v) ? map.get(v) : -1; };
}
function constColumn(v, rowCount, schema, valueKind) {
var value = function (row) { return v; };
return {
schema: schema,
__array: void 0,
isDefined: valueKind === 0 /* Present */,
rowCount: rowCount,
value: value,
valueKind: function (row) { return valueKind; },
toArray: function (params) {
var array = ColumnHelpers.createArray(rowCount, params).array;
for (var i = 0, _i = array.length; i < _i; i++)
array[i] = v;
return array;
},
areValuesEqual: function (rowA, rowB) { return true; }
};
}
function lambdaColumn(_a) {
var value = _a.value, valueKind = _a.valueKind, areValuesEqual = _a.areValuesEqual, rowCount = _a.rowCount, schema = _a.schema;
return {
schema: schema,
__array: void 0,
isDefined: true,
rowCount: rowCount,
value: value,
valueKind: valueKind ? valueKind : function (row) { return 0 /* Present */; },
toArray: function (params) {
var _a = ColumnHelpers.createArray(rowCount, params), array = _a.array, start = _a.start;
for (var i = 0, _i = array.length; i < _i; i++)
array[i] = value(i + start);
return array;
},
areValuesEqual: areValuesEqual ? areValuesEqual : function (rowA, rowB) { return value(rowA) === value(rowB); }
};
}
function arrayColumn(_a) {
var array = _a.array, schema = _a.schema, valueKind = _a.valueKind;
var rowCount = array.length;
var value = schema.valueType === 'str'
? function (row) { var v = array[row]; return typeof v === 'string' ? v : '' + v; }
: function (row) { return array[row]; };
var isTyped = ColumnHelpers.isTypedArray(array);
return {
schema: schema,
__array: array,
isDefined: true,
rowCount: rowCount,
value: value,
valueKind: valueKind ? valueKind : function (row) { return 0 /* Present */; },
toArray: schema.valueType === 'str'
? function (params) {
var _a = ColumnHelpers.getArrayBounds(rowCount, params), start = _a.start, end = _a.end;
var ret = new (params && typeof params.array !== 'undefined' ? params.array : array.constructor)(end - start);
for (var i = 0, _i = end - start; i < _i; i++) {
var v = array[start + i];
ret[i] = typeof v === 'string' ? v : '' + v;
}
return ret;
}
: isTyped
? function (params) { return ColumnHelpers.typedArrayWindow(array, params); }
: function (params) {
var _a = ColumnHelpers.getArrayBounds(rowCount, params), start = _a.start, end = _a.end;
if (start === 0 && end === array.length)
return array;
var ret = new (params && typeof params.array !== 'undefined' ? params.array : array.constructor)(end - start);
for (var i = 0, _i = end - start; i < _i; i++)
ret[i] = array[start + i];
return ret;
},
areValuesEqual: function (rowA, rowB) { return array[rowA] === array[rowB]; }
};
}
function windowColumn(column, start, end) {
if (!column.isDefined)
return Column.Undefined(end - start, column.schema);
if (start === 0 && end === column.rowCount)
return column;
if (!!column.__array && ColumnHelpers.isTypedArray(column.__array))
return windowTyped(column, start, end);
return windowFull(column, start, end);
}
function windowTyped(c, start, end) {
var array = ColumnHelpers.typedArrayWindow(c.__array, { start: start, end: end });
var vk = c.valueKind;
return arrayColumn({ array: array, schema: c.schema, valueKind: function (row) { return vk(start + row); } });
}
function windowFull(c, start, end) {
var v = c.value, vk = c.valueKind, ave = c.areValuesEqual;
var value = start === 0 ? v : function (row) { return v(row + start); };
var rowCount = end - start;
return {
schema: c.schema,
__array: void 0,
isDefined: c.isDefined,
rowCount: rowCount,
value: value,
valueKind: start === 0 ? vk : function (row) { return vk(row + start); },
toArray: function (params) {
var array = ColumnHelpers.createArray(rowCount, params).array;
for (var i = 0, _i = array.length; i < _i; i++)
array[i] = v(i + start);
return array;
},
areValuesEqual: start === 0 ? ave : function (rowA, rowB) { return ave(rowA + start, rowB + start); }
};
}
function isIdentity(map, rowCount) {
if (map.length !== rowCount)
return false;
for (var i = 0, _i = map.length; i < _i; i++) {
if (map[i] !== i)
return false;
}
return true;
}
function columnView(c, map, checkIdentity) {
if (c.rowCount === 0)
return c;
if (checkIdentity && isIdentity(map, c.rowCount))
return c;
if (!!c.__array && typeof c.value(0) === typeof c.__array[0])
return arrayView(c, map);
return viewFull(c, map);
}
function arrayView(c, map) {
var array = c.__array;
var ret = new array.constructor(map.length);
for (var i = 0, _i = map.length; i < _i; i++)
ret[i] = array[map[i]];
var vk = c.valueKind;
return arrayColumn({ array: ret, schema: c.schema, valueKind: function (row) { return vk(map[row]); } });
}
function viewFull(c, map) {
var v = c.value, vk = c.valueKind, ave = c.areValuesEqual;
var value = function (row) { return v(map[row]); };
var rowCount = map.length;
return {
schema: c.schema,
__array: void 0,
isDefined: c.isDefined,
rowCount: rowCount,
value: value,
valueKind: function (row) { return vk(map[row]); },
toArray: function (params) {
var array = ColumnHelpers.createArray(rowCount, params).array;
for (var i = 0, _i = array.length; i < _i; i++)
array[i] = v(map[i]);
return array;
},
areValuesEqual: function (rowA, rowB) { return ave(map[rowA], map[rowB]); }
};
}
function mapToArrayImpl(c, f, ctor) {
var ret = new ctor(c.rowCount);
for (var i = 0, _i = c.rowCount; i < _i; i++)
ret[i] = f(c.value(i));
return ret;
}
function areColumnsEqual(a, b) {
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);
}
function areArraysEqual(a, b) {
var xs = a.__array, ys = b.__array;
for (var i = 0, _i = a.rowCount; i < _i; i++) {
if (xs[i] !== ys[i])
return false;
}
return true;
}
function areValuesEqual(a, b) {
var va = a.value, vb = b.value;
for (var i = 0, _i = a.rowCount; i < _i; i++) {
if (va(i) !== vb(i))
return false;
}
return true;
}
function columnIndicesOf(c, test) {
var ret = [], v = c.value;
for (var i = 0, _i = c.rowCount; i < _i; i++) {
if (test(v(i)))
ret[ret.length] = i;
}
return ret;
}
//# sourceMappingURL=column.js.map