molstar/lib/commonjs/mol-util/array.js

A comprehensive macromolecular library.

"use strict";
/**
 * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
 *
 * @author Alexander Rose <alexander.rose@weirdbyte.de>
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.arrayMapUpsert = exports.arrayIsIdentity = exports.arrayEqual = exports.arrayIntersectionSize = exports.arrayAreIntersecting = exports.arraySetRemove = exports.arraySetAdd = exports.arrayRemoveAtInPlace = exports.arrayRemoveInPlace = exports.fillSerial = exports.arrayRms = exports.arrayMean = exports.arraySum = exports.arrayMinMax = exports.arrayMin = exports.arrayMax = void 0;
// TODO move to mol-math as Vector???
/** Get the maximum value in an array */
function arrayMax(array) {
    var max = -Infinity;
    for (var i = 0, il = array.length; i < il; ++i) {
        if (array[i] > max)
            max = array[i];
    }
    return max;
}
exports.arrayMax = arrayMax;
/** Get the minimum value in an array */
function arrayMin(array) {
    var min = Infinity;
    for (var i = 0, il = array.length; i < il; ++i) {
        if (array[i] < min)
            min = array[i];
    }
    return min;
}
exports.arrayMin = arrayMin;
/** Get the minimum & maximum value in an array */
function arrayMinMax(array) {
    var min = Infinity;
    var max = -Infinity;
    for (var i = 0, il = array.length; i < il; ++i) {
        if (array[i] < min)
            min = array[i];
        if (array[i] > max)
            max = array[i];
    }
    return [min, max];
}
exports.arrayMinMax = arrayMinMax;
/** Get the sum of values in an array */
function arraySum(array, stride, offset) {
    if (stride === void 0) { stride = 1; }
    if (offset === void 0) { offset = 0; }
    var n = array.length;
    var sum = 0;
    for (var i = offset; i < n; i += stride) {
        sum += array[i];
    }
    return sum;
}
exports.arraySum = arraySum;
/** Get the mean of values in an array */
function arrayMean(array, stride, offset) {
    if (stride === void 0) { stride = 1; }
    if (offset === void 0) { offset = 0; }
    return arraySum(array, stride, offset) / (array.length / stride);
}
exports.arrayMean = arrayMean;
/** Get the root mean square of values in an array */
function arrayRms(array) {
    var n = array.length;
    var sumSq = 0;
    for (var i = 0; i < n; ++i) {
        var di = array[i];
        sumSq += di * di;
    }
    return Math.sqrt(sumSq / n);
}
exports.arrayRms = arrayRms;
/** Fill an array with serial numbers starting from 0 until n - 1 (defaults to array.length) */
function fillSerial(array, n) {
    for (var i = 0, il = n ? Math.min(n, array.length) : array.length; i < il; ++i)
        array[i] = i;
    return array;
}
exports.fillSerial = fillSerial;
function arrayRemoveInPlace(xs, x) {
    var i = 0, found = false;
    for (var il = xs.length; i < il; i++) {
        if (xs[i] === x) {
            found = true;
            break;
        }
    }
    if (!found)
        return false;
    arrayRemoveAtInPlace(xs, i);
    return true;
}
exports.arrayRemoveInPlace = arrayRemoveInPlace;
function arrayRemoveAtInPlace(xs, idx) {
    for (var i = idx, _i = xs.length - 1; i < _i; i++) {
        xs[i] = xs[i + 1];
    }
    xs.pop();
}
exports.arrayRemoveAtInPlace = arrayRemoveAtInPlace;
function arraySetAdd(xs, x) {
    if (xs.indexOf(x) >= 0)
        return false;
    xs.push(x);
    return true;
}
exports.arraySetAdd = arraySetAdd;
function arraySetRemove(xs, x) {
    var idx = xs.indexOf(x);
    if (idx < 0)
        return false;
    for (var i = idx, _i = xs.length - 1; i < _i; i++) {
        xs[i] = xs[i + 1];
    }
    xs.pop();
    return true;
}
exports.arraySetRemove = arraySetRemove;
/**
 * Caution, O(n^2) complexity. Only use for small input sizes.
 * For larger inputs consider using `SortedArray`.
 */
function arrayAreIntersecting(xs, ys) {
    for (var i = 0, il = xs.length; i < il; ++i) {
        if (ys.includes(xs[i]))
            return true;
    }
    return false;
}
exports.arrayAreIntersecting = arrayAreIntersecting;
/**
 * Caution, O(n^2) complexity. Only use for small input sizes.
 * For larger inputs consider using `SortedArray`.
 */
function arrayIntersectionSize(xs, ys) {
    var count = 0;
    for (var i = 0, il = xs.length; i < il; ++i) {
        if (ys.includes(xs[i]))
            count += 1;
    }
    return count;
}
exports.arrayIntersectionSize = arrayIntersectionSize;
function arrayEqual(xs, ys) {
    if (!xs || xs.length === 0)
        return !ys || ys.length === 0;
    if (!ys)
        return false;
    var lenX = xs.length;
    if (lenX !== ys.length)
        return false;
    for (var i = 0; i < lenX; i++) {
        if (xs[i] !== ys[i])
            return false;
    }
    return true;
}
exports.arrayEqual = arrayEqual;
function arrayIsIdentity(xs) {
    for (var i = 0, _i = xs.length; i < _i; i++) {
        if (xs[i] !== i)
            return false;
    }
    return true;
}
exports.arrayIsIdentity = arrayIsIdentity;
function arrayMapUpsert(xs, key, value) {
    for (var i = 0, il = xs.length; i < il; ++i) {
        if (xs[i][0] === key) {
            xs[i][1] = value;
            return;
        }
    }
    xs.push([key, value]);
}
exports.arrayMapUpsert = arrayMapUpsert;