@formant/ava 3.4.1-formant

package/esm/data/dataset/field/series.js

@@ -0,0 +1,149 @@
+import { __extends, __read } from "tslib";
+import { isObject, isNumber, isString, isInteger, isBasicType, isArray, range, assert } from '../../utils';
+import { fillMissingValue, convertDataType } from './utils';
+import BaseFrame from './baseFrame';
+/** 1D data structure */
+var Series = /** @class */ (function (_super) {
+    __extends(Series, _super);
+    function Series(data, extra) {
+        var _this = this;
+        var _a, _b, _c, _d;
+        _this = _super.call(this, data, extra) || this;
+        assert(isObject(data) || isBasicType(data) || isArray(data), 'Data type is illegal');
+        /* 1D: object */
+        if (isObject(data)) {
+            // generate indexes
+            var indexes = Object.keys(data);
+            if (extra === null || extra === void 0 ? void 0 : extra.indexes) {
+                assert(((_a = extra === null || extra === void 0 ? void 0 : extra.indexes) === null || _a === void 0 ? void 0 : _a.length) <= indexes.length, "Index length ".concat((_b = extra === null || extra === void 0 ? void 0 : extra.indexes) === null || _b === void 0 ? void 0 : _b.length, " is greater than data size ").concat(indexes.length));
+                for (var i = 0; i < (extra === null || extra === void 0 ? void 0 : extra.indexes.length); i += 1) {
+                    var idx = extra === null || extra === void 0 ? void 0 : extra.indexes[i];
+                    if (indexes.includes(idx)) {
+                        _this.data.push(convertDataType(fillMissingValue(data[idx], extra === null || extra === void 0 ? void 0 : extra.fillValue), (_c = extra === null || extra === void 0 ? void 0 : extra.columnTypes) === null || _c === void 0 ? void 0 : _c[0]));
+                    }
+                }
+                _this.setAxis(0, extra === null || extra === void 0 ? void 0 : extra.indexes);
+            }
+            else {
+                _this.data = Object.values(data).map(function (datum) { var _a; return convertDataType(fillMissingValue(datum, extra === null || extra === void 0 ? void 0 : extra.fillValue), (_a = extra === null || extra === void 0 ? void 0 : extra.columnTypes) === null || _a === void 0 ? void 0 : _a[0]); });
+                _this.setAxis(0, indexes);
+            }
+        }
+        else if (isArray(data)) {
+            /* 1D: array */
+            var _e = __read(data, 1), data0 = _e[0];
+            if (!isBasicType(data0)) {
+                if (extra === null || extra === void 0 ? void 0 : extra.indexes) {
+                    assert(((_d = extra === null || extra === void 0 ? void 0 : extra.indexes) === null || _d === void 0 ? void 0 : _d.length) === data.length, "Index length is ".concat(extra === null || extra === void 0 ? void 0 : extra.indexes.length, ", but data size ").concat(data.length));
+                    _this.setAxis(0, extra === null || extra === void 0 ? void 0 : extra.indexes);
+                }
+                _this.data = data;
+            }
+        }
+        return _this;
+    }
+    Object.defineProperty(Series.prototype, "shape", {
+        get: function () {
+            return [this.axes[0].length];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Get data by row location and column location.
+     * @param rowLoc
+     */
+    Series.prototype.get = function (rowLoc) {
+        assert(isNumber(rowLoc) ||
+            (isString(rowLoc) && !rowLoc.includes(':')) ||
+            isArray(rowLoc) ||
+            (isString(rowLoc) && rowLoc.includes(':')), 'The rowLoc is illegal');
+        // input is like 0 || 'a'
+        if (isNumber(rowLoc) || (isString(rowLoc) && !rowLoc.includes(':'))) {
+            assert(this.indexes.includes(rowLoc), 'The rowLoc is not found in the indexes.');
+            if (isNumber(rowLoc)) {
+                return this.data[rowLoc];
+            }
+            if (isString(rowLoc)) {
+                var rowIdx = this.indexes.indexOf(rowLoc);
+                return this.data[rowIdx];
+            }
+        }
+        if (isArray(rowLoc)) {
+            // input is like [0, 1, 2] || ['a', 'b', 'c']
+            var newData = [];
+            var newIndex = [];
+            for (var i = 0; i < rowLoc.length; i += 1) {
+                var loc = rowLoc[i];
+                assert(this.indexes.includes(loc), 'The rowLoc is not found in the indexes.');
+                var idxInIndex = this.indexes.indexOf(loc);
+                newData.push(this.data[idxInIndex]);
+                newIndex.push(this.indexes[idxInIndex]);
+            }
+            return new Series(newData, { indexes: newIndex });
+        }
+        if (isString(rowLoc) && rowLoc.includes(':')) {
+            // input is like '0:2' || 'a:c'
+            var rowLocArr = rowLoc.split(':');
+            assert(rowLocArr.length === 2, 'The rowLoc is not found in the indexes.');
+            var startLoc = rowLocArr[0];
+            var endLoc = rowLocArr[1];
+            if (isInteger(Number(startLoc)) && isInteger(Number(endLoc))) {
+                var startIdx = Number(startLoc);
+                var endIdx = Number(endLoc);
+                var newData = this.data.slice(startIdx, endIdx);
+                var newIndex = this.indexes.slice(startIdx, endIdx);
+                return new Series(newData, { indexes: newIndex });
+            }
+            if (isString(startLoc) && isString(endLoc)) {
+                var startIdx = this.indexes.indexOf(startLoc);
+                var endIdx = this.indexes.indexOf(endLoc);
+                var newData = this.data.slice(startIdx, endIdx);
+                var newIndex = this.indexes.slice(startIdx, endIdx);
+                return new Series(newData, { indexes: newIndex });
+            }
+        }
+        throw new Error('The rowLoc is illegal');
+    };
+    /**
+     * Get data by row location and column location using integer index.
+     * @param rowLoc
+     */
+    Series.prototype.getByIndex = function (rowLoc) {
+        assert(isInteger(rowLoc) || isArray(rowLoc) || (isString(rowLoc) && rowLoc.includes(':')), 'The rowLoc is illegal');
+        // input is like 1
+        if (isInteger(rowLoc)) {
+            assert(range(this.indexes.length).includes(rowLoc), 'The rowLoc is not found in the indexes.');
+            if (range(this.indexes.length).includes(rowLoc)) {
+                return this.data[rowLoc];
+            }
+        }
+        if (isArray(rowLoc)) {
+            // input is like [0, 1, 2]
+            var newData = [];
+            var newIndex = [];
+            for (var i = 0; i < rowLoc.length; i += 1) {
+                var idx = rowLoc[i];
+                assert(range(this.indexes.length).includes(idx), 'The rowLoc is not found in the indexes.');
+                newData.push(this.data[idx]);
+                newIndex.push(this.indexes[idx]);
+            }
+            return new Series(newData, { indexes: newIndex });
+        }
+        if (isString(rowLoc) && rowLoc.includes(':')) {
+            // input is like '0:2'
+            var rowLocArr = rowLoc.split(':');
+            if (rowLocArr.length === 2) {
+                var startIdx = Number(rowLocArr[0]);
+                var endIdx = Number(rowLocArr[1]);
+                assert(isInteger(startIdx) && isInteger(endIdx), 'The rowLoc is not found in the indexes.');
+                var newData = this.data.slice(startIdx, endIdx);
+                var newIndex = this.indexes.slice(startIdx, endIdx);
+                return new Series(newData, { indexes: newIndex });
+            }
+        }
+        throw new Error('The rowLoc is illegal');
+    };
+    return Series;
+}(BaseFrame));
+export default Series;

package/esm/data/dataset/field/types.js

@@ -0,0 +1 @@
+export {};

package/esm/data/dataset/field/utils.js

@@ -0,0 +1,58 @@
+import { isArray, isNumber, isString, range, assert, isBoolean, isNil, isDate } from '../../utils';
+export function isAxis(value) {
+    return isNumber(value) || isString(value);
+}
+// generate indexes for 1D and 2D array
+export function generateArrayIndex(data, extraIndex) {
+    assert(isArray(data), 'Data must be an array');
+    if (extraIndex) {
+        assert((extraIndex === null || extraIndex === void 0 ? void 0 : extraIndex.length) === data.length, "Index length is ".concat(extraIndex === null || extraIndex === void 0 ? void 0 : extraIndex.length, ", but data size is ").concat(data.length));
+        return extraIndex;
+    }
+    return range(data.length);
+}
+export function fillMissingValue(datum, fillValue) {
+    return !datum && JSON.stringify(fillValue) ? fillValue : datum;
+}
+export function generateSplit(length) {
+    return Array(isNumber(length) ? length : 0)
+        .fill(' ')
+        .concat('  ')
+        .join('');
+}
+export function stringify(value) {
+    var _a, _b, _c, _d, _e, _f;
+    return (((_f = (_e = (_d = (_c = (_b = (_a = JSON.stringify(value)) === null || _a === void 0 ? void 0 : _a.replace(/\\n/g, '')) === null || _b === void 0 ? void 0 : _b.replace(/\\/g, '')) === null || _c === void 0 ? void 0 : _c.replace(/"\[/g, '[')) === null || _d === void 0 ? void 0 : _d.replace(/\]"/g, ']')) === null || _e === void 0 ? void 0 : _e.replace(/"\{/g, '{')) === null || _f === void 0 ? void 0 : _f.replace(/\}"/g, ' }')) || 'undefined');
+}
+export function getStringifyLength(value) {
+    var _a;
+    return (_a = stringify(value)) === null || _a === void 0 ? void 0 : _a.length;
+}
+/**
+ * Convert data to specified data type.
+ * @param data
+ * @param type
+ */
+export function convertDataType(data, type) {
+    try {
+        if (type === 'string' && !isString(data)) {
+            return "".concat(data);
+        }
+        if (type === 'boolean' && !isBoolean(data)) {
+            return Boolean(data);
+        }
+        if (type === 'null' && !isNil(data)) {
+            return null;
+        }
+        if ((type === 'integer' || type === 'float') && !isNumber(data)) {
+            return +data;
+        }
+        if (type === 'date' && !isDate(data) && (isNumber(data) || isString(data))) {
+            return new Date(data);
+        }
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+    return data;
+}

package/esm/data/dataset/graph/index.js

@@ -0,0 +1,186 @@
+import { __assign, __read, __spreadArray } from "tslib";
+import { analyzeField } from '../../analysis';
+import { getNodeFields, getLinkFields, getAllFieldsInfo, getAllStructFeats, clusterNodes } from '../../analysis/graph';
+import { isUnique } from '../../analysis/field';
+import { assert, isArray, isObject, isBasicType } from '../../utils';
+import DataFrame from '../field/dataFrame';
+import { flatObject } from './utils';
+/* eslint-disable no-param-reassign */
+function parseTreeNode(data, extra) {
+    var nodes = [];
+    var links = [];
+    var childrenKey = (extra === null || extra === void 0 ? void 0 : extra.childrenKey) || 'children';
+    var parseTree = function (treeNode) {
+        var children = treeNode[childrenKey] || [];
+        delete treeNode[childrenKey];
+        nodes === null || nodes === void 0 ? void 0 : nodes.push(treeNode);
+        for (var i = 0; i < children.length; i += 1) {
+            var item = children[i];
+            links === null || links === void 0 ? void 0 : links.push({
+                source: treeNode.id,
+                target: item.id,
+            });
+            parseTree(item);
+        }
+    };
+    parseTree(data);
+    return { nodes: nodes, links: links };
+}
+/**
+ * @param data link array
+ */
+function parseArray(data, extra) {
+    var _a = __read(data, 1), data0 = _a[0];
+    assert(isObject(data0), 'Data is unable transform to graph');
+    var sourceKey = (extra === null || extra === void 0 ? void 0 : extra.sourceKey) || ('source' in data0 && 'source') || ('from' in data0 && 'from');
+    var targetKey = (extra === null || extra === void 0 ? void 0 : extra.targetKey) || ('target' in data0 && 'target') || ('to' in data0 && 'to');
+    var childrenKey = (extra === null || extra === void 0 ? void 0 : extra.childrenKey) || ('children' in data0 && 'children') || ('to' in data0 && 'to');
+    assert(sourceKey || targetKey || childrenKey, 'Data is unable transform to graph');
+    var nodes = [];
+    var links = [];
+    var _b = data0, _c = sourceKey, source = _b[_c], _d = targetKey, target = _b[_d], _e = childrenKey, children = _b[_e];
+    if (isBasicType(source) && isBasicType(target)) {
+        var _loop_1 = function (i) {
+            var link = data[i];
+            var _g = link, _h = sourceKey, source_1 = _g[_h], _j = targetKey, target_1 = _g[_j];
+            if (nodes.findIndex(function (n) { return n.id === source_1; }) === -1) {
+                nodes.push({ id: source_1 });
+            }
+            if (nodes.findIndex(function (n) { return n.id === target_1; }) === -1) {
+                nodes.push({ id: target_1 });
+            }
+            var formatLink = __assign(__assign({}, link), { source: source_1, target: target_1 });
+            links.push(formatLink);
+        };
+        for (var i = 0; i < data.length; i += 1) {
+            _loop_1(i);
+        }
+    }
+    else if (isArray(children)) {
+        // try to parse the array as multiple trees
+        for (var i = 0; i < data.length; i += 1) {
+            var tree = data[i];
+            var _f = parseTreeNode(tree, extra), subNodes = _f.nodes, subLinks = _f.links;
+            var _loop_2 = function (i_1) {
+                var node = subNodes[i_1];
+                var repeatNode = nodes.find(function (n) { return n.id === node.id; });
+                if (repeatNode) {
+                    repeatNode = __assign(__assign({}, node), repeatNode);
+                }
+                else {
+                    nodes.push(node);
+                }
+            };
+            for (var i_1 = 0; i_1 < subNodes.length; i_1 += 1) {
+                _loop_2(i_1);
+            }
+            links.push.apply(links, __spreadArray([], __read(subLinks), false));
+        }
+    }
+    return { nodes: nodes, links: links };
+}
+function isNodeArray(arr) {
+    if (!isArray(arr) || arr.length <= 1)
+        return false;
+    var nodeIdInfo = analyzeField(arr.map(function (node) { return node.id; }));
+    return isUnique(nodeIdInfo);
+}
+function isValidNodeLinks(nodes, links) {
+    if (!isArray(links) || !isNodeArray(nodes) || links.length <= 1)
+        return false;
+    var _loop_3 = function (i) {
+        var link = links[i];
+        var source = link.source, target = link.target;
+        var hasSourceNode = nodes.findIndex(function (item) { return item.id === source; });
+        var hasTargetNode = nodes.findIndex(function (item) { return item.id === target; });
+        if (!(hasSourceNode > -1 && hasTargetNode > -1)) {
+            return { value: false };
+        }
+    };
+    for (var i = 0; i < links.length; i += 1) {
+        var state_1 = _loop_3(i);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return true;
+}
+// TODO: The automatic parsing function has not been completed yet, for now, the GraphData constructor only accepts input data in several specified formats (see type GraphInput)
+var GraphData = /** @class */ (function () {
+    function GraphData(data, extra) {
+        this.data = {
+            nodes: [],
+            links: [],
+        };
+        this.extra = extra;
+        var _a = this.autoParse(data, extra), nodes = _a.nodes, links = _a.links;
+        assert(isValidNodeLinks(nodes, links), 'Data is unable transform to graph');
+        this.data = {
+            nodes: nodes.map(function (node) { return flatObject(node); }),
+            links: links.map(function (link) { return flatObject(link); }),
+        };
+    }
+    GraphData.prototype.autoParse = function (data, extra) {
+        var nodes;
+        var links;
+        assert(isArray(data) || isObject(data), 'Data is unable transform to graph');
+        // try parse data as link array or multiple trees
+        if (isArray(data)) {
+            var parsedData = parseArray(data, extra);
+            nodes = parsedData.nodes;
+            links = parsedData.links;
+        }
+        // if passed data tyoe is object
+        if (isObject(data)) {
+            if ((extra === null || extra === void 0 ? void 0 : extra.nodeKey) && (extra === null || extra === void 0 ? void 0 : extra.linkKey)) {
+                nodes = data[extra.nodeKey];
+                links = data[extra.linkKey];
+            }
+            else if ((extra === null || extra === void 0 ? void 0 : extra.childrenKey) || 'children' in data) {
+                var parsedTree = parseTreeNode(data, extra);
+                nodes = parsedTree.nodes;
+                links = parsedTree.links;
+            }
+            else {
+                var nodeKey = 'nodes' in data && 'nodes';
+                var linkKey = ('links' in data && 'links') || ('edges' in data && 'edges');
+                nodes = data[nodeKey];
+                links = data[linkKey];
+            }
+        }
+        return { nodes: nodes, links: links };
+    };
+    GraphData.prototype.getNodeFrame = function () {
+        var _a, _b;
+        var extra = {
+            indexes: (_a = this.extra) === null || _a === void 0 ? void 0 : _a.nodeIndexes,
+            columns: (_b = this.extra) === null || _b === void 0 ? void 0 : _b.nodeColumns,
+        };
+        return new DataFrame(this.data.nodes, extra);
+    };
+    GraphData.prototype.getLinkFrame = function () {
+        var _a, _b;
+        var extra = {
+            indexes: (_a = this.extra) === null || _a === void 0 ? void 0 : _a.linkIndexes,
+            columns: (_b = this.extra) === null || _b === void 0 ? void 0 : _b.linkColumns,
+        };
+        return new DataFrame(this.data.links, extra);
+    };
+    /**
+     * Get statistics.
+     */
+    GraphData.prototype.info = function () {
+        var _a = this.data, nodes = _a.nodes, links = _a.links;
+        // calc fields statistics and structural statistics
+        var graphStructFeats = getAllStructFeats(nodes, links);
+        var _b = getNodeFields(nodes), nodeFields = _b.nodeFields, nodeFieldNames = _b.nodeFieldNames;
+        var _c = getLinkFields(links), linkFields = _c.linkFields, linkFieldNames = _c.linkFieldNames;
+        var nodeFieldsInfo = getAllFieldsInfo(nodeFields, nodeFieldNames);
+        var linkFieldsInfo = getAllFieldsInfo(linkFields, linkFieldNames);
+        var getClusterField = clusterNodes(nodes, nodeFieldsInfo, links);
+        nodeFieldsInfo.push(getClusterField);
+        var graphProps = __assign({ nodeFieldsInfo: nodeFieldsInfo, linkFieldsInfo: linkFieldsInfo }, graphStructFeats);
+        return graphProps;
+    };
+    return GraphData;
+}());
+export default GraphData;

package/esm/data/dataset/graph/types.js

@@ -0,0 +1 @@
+export {};

package/esm/data/dataset/graph/utils.js

@@ -0,0 +1,15 @@
+import { __assign } from "tslib";
+export function flatObject(obj, concatenator) {
+    if (concatenator === void 0) { concatenator = '.'; }
+    return Object.keys(obj).reduce(function (acc, key) {
+        var _a;
+        if (typeof obj[key] !== 'object' || obj[key] === null) {
+            return __assign(__assign({}, acc), (_a = {}, _a[key] = obj[key], _a));
+        }
+        var flattenedChild = flatObject(obj[key], concatenator);
+        return __assign(__assign({}, acc), Object.keys(flattenedChild).reduce(function (childAcc, childKey) {
+            var _a;
+            return (__assign(__assign({}, childAcc), (_a = {}, _a["".concat(key).concat(concatenator).concat(childKey)] = flattenedChild[childKey], _a)));
+        }, {}));
+    }, {});
+}

package/esm/data/dataset/index.js

@@ -0,0 +1 @@
+export * from './field';

package/esm/data/dataset/types.js

@@ -0,0 +1 @@
+export * from './field/types';

package/esm/data/index.js

@@ -0,0 +1,5 @@
+export * from './analysis';
+export * from './dataset';
+export * from './statistics';
+export * from './utils';
+export * from './types';

package/esm/data/statistics/IQR.js

@@ -0,0 +1,49 @@
+import { ascending } from '../../insight/algorithms/base/compare';
+function getQuartilePercentValue(array, percent) {
+    var product = percent * array.length;
+    var ceil = Math.ceil(product);
+    if (ceil === product) {
+        if (ceil === 0) {
+            return array[0];
+        }
+        if (ceil === array.length) {
+            return array[array.length - 1];
+        }
+        return (array[ceil - 1] + array[ceil]) / 2;
+    }
+    return array[ceil - 1];
+}
+/**
+ *
+ * @param data
+ * @param params
+ * @returns
+ */
+export function IQR(data, params) {
+    var k = (params === null || params === void 0 ? void 0 : params.k) || 1.5;
+    var sorted = data.slice().sort(ascending);
+    var q25 = getQuartilePercentValue(sorted, 0.25);
+    var q75 = getQuartilePercentValue(sorted, 0.75);
+    var iqr = q75 - q25;
+    var outliers = {
+        upper: {
+            threshold: 0,
+            indexes: [],
+        },
+        lower: {
+            threshold: 0,
+            indexes: [],
+        },
+    };
+    outliers.lower.threshold = q25 - k * iqr;
+    outliers.upper.threshold = q75 + k * iqr;
+    data.forEach(function (item, index) {
+        if (item <= outliers.lower.threshold) {
+            outliers.lower.indexes.push(index);
+        }
+        else if (item >= outliers.upper.threshold) {
+            outliers.upper.indexes.push(index);
+        }
+    });
+    return outliers;
+}