@formant/ava 3.4.1-formant

package/esm/data/analysis/field/index.js

@@ -0,0 +1,336 @@
+import { max, maxIndex, mean, min, minIndex, quantile, standardDeviation, sum, variance, valueMap as statsValueMap, } from '../../statistics';
+import { isBasicType, isBoolean, isDate, isDateString, isFloatString, isInteger, isIntegerString, isNil, isNumber, isNumberString, isString, unique, } from '../../utils';
+/**
+ * Check if it is StringFieldInfo.
+ */
+export function isStringFieldInfo(x) {
+    return x.recommendation === 'string';
+}
+/**
+ * Check if it is NumberFieldInfo.
+ */
+export function isNumberFieldInfo(x) {
+    return x.recommendation === 'integer' || x.recommendation === 'float';
+}
+/**
+ * Check if it is DateFieldInfo.
+ */
+export function isDateFieldInfo(x) {
+    return x.recommendation === 'date';
+}
+/**
+ * Checks if field is constant
+ * @param info - The {@link FieldInfo} to process
+ */
+export function isConst(info) {
+    return info.distinct === 1;
+}
+/**
+ * Checks if field is an ordinal.
+ * @param info - Field Info
+ */
+export function isOrdinal(info) {
+    var rawData = info.rawData, recommendation = info.recommendation;
+    if (recommendation !== 'string')
+        return false;
+    if (isConst(info))
+        return false;
+    var list = rawData.filter(function (item) { return !isNil(item) && isBasicType(item); });
+    if (list.length === 0)
+        return false;
+    var start = null;
+    var end = null;
+    var startIndex = -1;
+    var endIndex = -1;
+    var through = true;
+    while (through) {
+        var through_1 = true;
+        for (var i = 0; i < list.length; i += 1) {
+            var item = list[i];
+            var char = item[startIndex + 1];
+            if (start === null || i === 0)
+                start = char;
+            if (char !== start) {
+                through_1 = false;
+                break;
+            }
+        }
+        if (!through_1)
+            break;
+        startIndex += 1;
+    }
+    through = true;
+    while (through) {
+        var through_2 = true;
+        for (var i = 0; i < list.length; i += 1) {
+            var item = list[i];
+            var char = item[item.length - 1 - (endIndex + 1)];
+            if (end === null || i === 0)
+                end = char;
+            if (char !== end) {
+                through_2 = false;
+                break;
+            }
+        }
+        if (!through_2)
+            break;
+        endIndex += 1;
+    }
+    var patterns = [/\d+/, /(零|一|二|三|四|五|六|七|八|九|十)+/, /(一|二|三|四|五|六|日)/, /^[a-z]$/, /^[A-Z]$/];
+    if (startIndex === -1 && endIndex === -1)
+        return false;
+    var arr = list.map(function (item) {
+        return item.slice(startIndex === -1 ? 0 : startIndex + 1, endIndex === -1 ? undefined : item.length - endIndex - 1);
+    });
+    var _loop_1 = function (i) {
+        var p = patterns[i];
+        var notMatch = arr.some(function (item) { return !p.test(item); });
+        if (!notMatch)
+            return { value: true };
+    };
+    for (var i = 0; i < patterns.length; i += 1) {
+        var state_1 = _loop_1(i);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return false;
+}
+/**
+ * Checks if field is an unique.
+ * @param info - The {@link FieldInfo} to process
+ */
+export function isUnique(info) {
+    return info.distinct === info.count;
+}
+/**
+ * Checks if field is discrete.
+ * @remarks
+ * @param info - The {@link FieldInfo} to process
+ */
+export function isDiscrete(info) {
+    return info.recommendation === 'integer';
+}
+/**
+ * Checks if field is a continuous.
+ * @param info - The {@link FieldInfo} to process
+ */
+export function isContinuous(info) {
+    return info.recommendation === 'float';
+}
+/**
+ * Checks if field is an interval.
+ * @param info - The {@link FieldInfo} to process
+ */
+export function isInterval(info) {
+    return info.recommendation === 'integer' || info.recommendation === 'float';
+}
+/**
+ * Checks if field is a nominal.
+ * @param info - The {@link FieldInfo} to process
+ */
+export function isNominal(info) {
+    if (info.recommendation === 'boolean')
+        return true;
+    if (info.recommendation === 'string')
+        return !isOrdinal(info);
+    return false;
+}
+/**
+ * Checks if field is a time.
+ * @param info - Field Info
+ */
+export function isTime(info) {
+    return info.recommendation === 'date';
+}
+/**
+ * Analyze string field info.
+ * @param value - data
+ */
+export function analyzeString(value) {
+    var lenArray = value.map(function (item) { return item.length; });
+    return {
+        maxLength: max(lenArray),
+        minLength: min(lenArray),
+        meanLength: mean(lenArray),
+        containsChar: value.some(function (item) { return /[A-z]/.test(item); }),
+        containsDigit: value.some(function (item) { return /[0-9]/.test(item); }),
+        containsSpace: value.some(function (item) { return /\s/.test(item); }),
+    };
+}
+/**
+ * Analyze number field info.
+ * @param value - data
+ */
+export function analyzeNumber(value) {
+    return {
+        minimum: min(value),
+        maximum: max(value),
+        mean: mean(value),
+        percentile5: quantile(value, 5),
+        percentile25: quantile(value, 25),
+        percentile50: quantile(value, 50),
+        percentile75: quantile(value, 75),
+        percentile95: quantile(value, 95),
+        sum: sum(value),
+        variance: variance(value),
+        standardDeviation: standardDeviation(value),
+        zeros: value.filter(function (item) { return item === 0; }).length,
+    };
+}
+/**
+ * Analyze date field info.
+ * @param value - data
+ */
+export function analyzeDate(value, isInteger) {
+    if (isInteger === void 0) { isInteger = false; }
+    var list = value.map(function (item) {
+        if (isInteger) {
+            var str = "".concat(item);
+            if (str.length === 8)
+                return new Date("".concat(str.substring(0, 4), "/").concat(str.substring(4, 2), "/").concat(str.substring(6, 2))).getTime();
+        }
+        return new Date(item).getTime();
+    });
+    return {
+        minimum: value[minIndex(list)],
+        maximum: value[maxIndex(list)],
+    };
+}
+/**
+ * Determine what type a value is, may be one of [integer float date string null].
+ */
+export function analyzeType(value, strictDatePattern) {
+    if (isNil(value))
+        return 'null';
+    if (isNumber(value)) {
+        if (isInteger(value))
+            return 'integer';
+        return 'float';
+    }
+    // 优先识别日期类型，避免字符型日期被判断成字符
+    if (isDate(value) || isDateString(value, strictDatePattern))
+        return 'date';
+    if (isString(value)) {
+        if (isNumberString(value)) {
+            if (value.includes('.'))
+                return 'float';
+            return 'integer';
+        }
+    }
+    return 'string';
+}
+/**
+ * Analyze field info.
+ * @param value - data
+ * @public
+ */
+export function analyzeField(value, strictDatePattern) {
+    var list = value.map(function (item) { return (isNil(item) ? null : item); });
+    var valueMap = statsValueMap(list);
+    var recommendation;
+    var nonNullArray = valueMap.null ? list.filter(function (item) { return item !== null; }) : list;
+    var typeArray = list.map(function (item) { return analyzeType(item, strictDatePattern); });
+    var types = Object.keys(statsValueMap(typeArray)).filter(function (item) { return item !== 'null'; });
+    // generate recommendation
+    switch (types.length) {
+        case 0:
+            recommendation = 'null';
+            break;
+        case 1:
+            recommendation = types[0];
+            // an integer field may be a date field
+            if (recommendation === 'integer') {
+                var data = list.filter(function (item) { return item !== null; });
+                if (data.map(function (num) { return "".concat(num); }).every(function (str) { return isDateString(str); })) {
+                    recommendation = 'date';
+                }
+            }
+            break;
+        case 2:
+            if ((types.includes('integer') || types.includes('date')) && types.includes('float')) {
+                recommendation = 'float';
+                break;
+            }
+            if (types.includes('integer') && types.includes('date')) {
+                // an integer field may be a date field
+                var data = list.filter(function (item) { return item !== null; });
+                if (data.map(function (num) { return "".concat(num); }).every(function (str) { return isDateString(str); })) {
+                    recommendation = 'date';
+                }
+                else {
+                    recommendation = 'integer';
+                }
+                break;
+            }
+            recommendation = 'string';
+            break;
+        default:
+            recommendation = 'string';
+    }
+    var uniqueArray = unique(nonNullArray);
+    var fieldInfo = {
+        count: value.length,
+        distinct: uniqueArray.length,
+        type: types.length <= 1 ? types[0] || 'null' : 'mixed',
+        recommendation: recommendation,
+        missing: valueMap.null || 0,
+        rawData: value,
+        valueMap: valueMap,
+    };
+    if (types.length > 1) {
+        var meta_1 = {};
+        var restNotNullArray_1 = nonNullArray;
+        types.forEach(function (item) {
+            if (item === 'date') {
+                meta_1.date = analyzeField(restNotNullArray_1.filter(function (item) { return isDateString(item); }), strictDatePattern);
+                restNotNullArray_1 = restNotNullArray_1.filter(function (item) { return !isDateString(item); });
+            }
+            else if (item === 'integer') {
+                meta_1.integer = analyzeField(restNotNullArray_1.filter(function (item) { return isIntegerString(item) && !isDateString(item); }), strictDatePattern);
+                restNotNullArray_1 = restNotNullArray_1.filter(function (item) { return !isIntegerString(item); });
+            }
+            else if (item === 'float') {
+                meta_1.float = analyzeField(restNotNullArray_1.filter(function (item) { return isFloatString(item) && !isDateString(item); }), strictDatePattern);
+                restNotNullArray_1 = restNotNullArray_1.filter(function (item) { return !isFloatString(item); });
+            }
+            else if (item === 'string') {
+                meta_1.string = analyzeField(restNotNullArray_1.filter(function (item) { return analyzeType(item, strictDatePattern) === 'string'; }));
+                restNotNullArray_1 = restNotNullArray_1.filter(function (item) { return analyzeType(item, strictDatePattern) !== 'string'; });
+            }
+        });
+        fieldInfo.meta = meta_1;
+    }
+    if (fieldInfo.distinct === 2 && fieldInfo.recommendation !== 'date') {
+        // temporarily threshold
+        if (list.length >= 100) {
+            fieldInfo.recommendation = 'boolean';
+        }
+        else if (isBoolean(uniqueArray, true)) {
+            fieldInfo.recommendation = 'boolean';
+        }
+    }
+    if (recommendation === 'string') {
+        Object.assign(fieldInfo, analyzeString(nonNullArray.map(function (item) { return "".concat(item); })));
+    }
+    if (recommendation === 'integer' || recommendation === 'float') {
+        Object.assign(fieldInfo, analyzeNumber(nonNullArray.map(function (item) { return item * 1; })));
+    }
+    if (recommendation === 'date') {
+        Object.assign(fieldInfo, analyzeDate(nonNullArray, fieldInfo.type === 'integer'));
+    }
+    var levelOfMeasurements = [];
+    if (isNominal(fieldInfo))
+        levelOfMeasurements.push('Nominal');
+    if (isOrdinal(fieldInfo))
+        levelOfMeasurements.push('Ordinal');
+    if (isInterval(fieldInfo))
+        levelOfMeasurements.push('Interval');
+    if (isDiscrete(fieldInfo))
+        levelOfMeasurements.push('Discrete');
+    if (isContinuous(fieldInfo))
+        levelOfMeasurements.push('Continuous');
+    if (isTime(fieldInfo))
+        levelOfMeasurements.push('Time');
+    fieldInfo.levelOfMeasurements = levelOfMeasurements;
+    return fieldInfo;
+}

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

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

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

@@ -0,0 +1,170 @@
+import { __assign, __read, __spreadArray } from "tslib";
+// TODO @chenluli: move @antv/algorithm from devDep to dep after this file is complete
+// eslint-disable-next-line import/no-extraneous-dependencies
+import * as AlgorithmSync from '@antv/algorithm';
+import { analyzeField } from '../field';
+var GraphAlgorithms = __assign({}, AlgorithmSync);
+function generateColDataFromArray(arr, columnNames) {
+    var fields = [];
+    for (var i = 0; i < arr.length; i += 1) {
+        var datum = arr[i];
+        for (var j = 0; j < columnNames.length; j += 1) {
+            var column = columnNames[j];
+            if (fields[j]) {
+                fields[j].push(datum[column]);
+            }
+            else {
+                fields[j] = [datum[column]];
+            }
+        }
+    }
+    return fields;
+}
+export function getNodeFields(nodes) {
+    var _a = __read(nodes, 1), node0 = _a[0];
+    var nodeFieldNames = node0 ? Object.keys(node0) : [];
+    var nodeFields = generateColDataFromArray(nodes, nodeFieldNames);
+    return { nodeFields: nodeFields, nodeFieldNames: nodeFieldNames };
+}
+export function getLinkFields(links) {
+    var _a = __read(links, 1), link0 = _a[0];
+    var linkFieldNames = link0 ? Object.keys(link0) : [];
+    var linkFields = generateColDataFromArray(links, linkFieldNames);
+    return { linkFields: linkFields, linkFieldNames: linkFieldNames };
+}
+// Analyze fields
+function getFieldInfo(dataField, fieldName) {
+    var fieldInfo = analyzeField(dataField);
+    return __assign(__assign({}, fieldInfo), { name: fieldName });
+}
+export function getAllFieldsInfo(dataFields, fieldNames) {
+    var fields = [];
+    for (var i = 0; i < dataFields.length; i += 1) {
+        var dataField = dataFields[i];
+        fields.push(getFieldInfo(dataField, fieldNames[i]));
+    }
+    return fields;
+}
+/* eslint-disable no-param-reassign */
+/**
+ * find node clusters and assign the cluster field to each node
+ * @param nodes
+ * @param links
+ */
+export function clusterNodes(nodes, nodeFieldsInfo, links) {
+    var MAX_CLUSTER_NUM = 10;
+    var fieldForCluster;
+    for (var i = 0; i < nodeFieldsInfo.length; i += 1) {
+        var field = nodeFieldsInfo[i];
+        if (field.levelOfMeasurements.indexOf('Nominal') > -1 ||
+            (field.levelOfMeasurements.indexOf('Ordinal') > -1 &&
+                field.missing === 0 &&
+                field.distinct > 1 &&
+                field.distinct <= MAX_CLUSTER_NUM)) {
+            fieldForCluster = field;
+            break;
+        }
+    }
+    if (fieldForCluster) {
+        for (var nodeIdx = 0; nodeIdx < nodes.length; nodeIdx += 1) {
+            nodes[nodeIdx].cluster = nodes[nodeIdx][fieldForCluster.name];
+        }
+    }
+    else {
+        var clusters = GraphAlgorithms.louvain({ nodes: nodes, edges: links }).clusters;
+        var values = [];
+        for (var i = 0; i < clusters.length; i += 1) {
+            var cluster = clusters[i];
+            var nodes_1 = cluster.nodes, id = cluster.id;
+            for (var nodeIdx = 0; nodeIdx < nodes_1.length; nodeIdx += 1) {
+                nodes_1[nodeIdx].cluster = id;
+            }
+            values.push(id);
+        }
+        fieldForCluster = __assign(__assign({}, analyzeField(values)), { name: 'cluster' });
+    }
+    return fieldForCluster;
+}
+/* eslint-disable no-param-reassign */
+/**
+ * Calculate statistical and structural features for graph
+ * @param nodes
+ * @param links
+ */
+export function getAllStructFeats(nodes, links) {
+    var nodeStructFeats = [];
+    var linkStructFeats = [];
+    // TODO: whether the graph is directed need to be passed in
+    var isDirected = false;
+    var degrees = GraphAlgorithms.getDegree({ nodes: nodes, edges: links });
+    var pageRanks = GraphAlgorithms.pageRank({ nodes: nodes, edges: links });
+    var cycles = GraphAlgorithms.detectAllCycles({ nodes: nodes, edges: links }, false);
+    var directedCycles = GraphAlgorithms.detectAllDirectedCycle({ nodes: nodes, edges: links });
+    var components = GraphAlgorithms.connectedComponent({ nodes: nodes, edges: links }, false);
+    var strongConnectedComponents = GraphAlgorithms.connectedComponent({ nodes: nodes, edges: links }, true);
+    var cycleCountMap = {};
+    for (var i = 0; i < cycles.length; i += 1) {
+        var nodeIds = Object.keys(cycles[i]);
+        for (var j = 0; j < nodeIds.length; j += 1) {
+            var nodeId = nodeIds[j];
+            if (cycleCountMap[nodeId]) {
+                cycleCountMap[nodeId] += 1;
+            }
+            else {
+                cycleCountMap[nodeId] = 1;
+            }
+        }
+    }
+    var numberOfNodeInCycle = Object.values(cycleCountMap).filter(function (count) { return count; }).length;
+    var cycleParticipate = numberOfNodeInCycle / nodes.length;
+    for (var index = 0; index < nodes.length; index += 1) {
+        var node = nodes[index];
+        var nodeFeat = {
+            degree: degrees[node.id].degree,
+            inDegree: degrees[node.id].inDegree,
+            outDegree: degrees[node.id].outDegree,
+            pageRank: pageRanks[node.id],
+            cycleCount: cycleCountMap[node.id] || 0,
+        };
+        nodeStructFeats.push(nodeFeat);
+        nodes[index] = __assign(__assign({}, node), nodeFeat);
+    }
+    for (var index = 0; index < links.length; index += 1) {
+        var link = links[index];
+        var linkFeat = {};
+        linkStructFeats.push(linkFeat);
+        links[index] = __assign(__assign({}, link), linkFeat);
+    }
+    var nodeFeatNames = Object.keys(nodeStructFeats[0]);
+    var linkFeatNames = Object.keys(linkStructFeats[0]);
+    var nodeFeats = getAllFieldsInfo(generateColDataFromArray(nodeStructFeats, nodeFeatNames), nodeFeatNames);
+    var linkFeats = getAllFieldsInfo(generateColDataFromArray(linkStructFeats, linkFeatNames), linkFeatNames);
+    // Calculate the structural features and statistics of all nodes and links
+    var nodeDegrees = nodes.map(function (node) { return Number(node.degree); });
+    var avgDegree = nodeDegrees.reduce(function (x, y) { return x + y; }) / nodeDegrees.length;
+    var degreeDev = nodeDegrees.map(function (x) { return x - avgDegree; });
+    var degreeStd = Math.sqrt(degreeDev.map(function (x) { return Math.pow(x, 2); }).reduce(function (x, y) { return x + y; }) / (nodeDegrees.length - 1));
+    var graphInfo = {
+        isDirected: isDirected,
+        nodeCount: nodes.length,
+        linkCount: links.length,
+        isConnected: components && components.length === 1,
+        isDAG: isDirected && directedCycles.length === 0,
+        maxDegree: Math.max.apply(Math, __spreadArray([], __read(nodeDegrees), false)),
+        avgDegree: avgDegree,
+        degreeStd: degreeStd,
+        cycleParticipate: cycleParticipate,
+        cycleCount: cycles.length,
+        directedCycleCount: directedCycles.length,
+        // triangleCount: triangleMatches.length,
+        componentCount: components.length,
+        components: components,
+        strongConnectedComponents: strongConnectedComponents,
+        strongConnectedComponentCount: strongConnectedComponents.length,
+    };
+    return {
+        nodeFeats: nodeFeats,
+        linkFeats: linkFeats,
+        graphInfo: graphInfo,
+    };
+}

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

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

package/esm/data/analysis/index.js

@@ -0,0 +1 @@
+export { analyzeField } from './field';

package/esm/data/analysis/types.js

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

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

@@ -0,0 +1,76 @@
+import { assert, isArray, isObject, isBasicType } from '../../utils';
+import { generateArrayIndex, fillMissingValue, convertDataType } from './utils';
+/* Base data structure */
+var BaseFrame = /** @class */ (function () {
+    function BaseFrame(data, extra) {
+        var _a, _b, _c, _d, _e;
+        this.axes = [[]];
+        this.data = [];
+        assert(!extra || isObject(extra), 'If extra exists, it must be an object.');
+        /* 1D: basic type */
+        if (isBasicType(data)) {
+            // generate indexes
+            if (extra === null || extra === void 0 ? void 0 : extra.indexes) {
+                this.setAxis(0, extra === null || extra === void 0 ? void 0 : extra.indexes);
+                this.data = Array(extra === null || extra === void 0 ? void 0 : extra.indexes.length).fill(convertDataType(fillMissingValue(data, 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]));
+            }
+            else {
+                this.data = [convertDataType(fillMissingValue(data, extra === null || extra === void 0 ? void 0 : extra.fillValue), (_b = extra === null || extra === void 0 ? void 0 : extra.columnTypes) === null || _b === void 0 ? void 0 : _b[0])];
+                this.setAxis(0, [0]);
+            }
+        }
+        else if (isArray(data)) {
+            /* 1D: array */
+            var legal = true;
+            for (var i = 0; i < data.length; i += 1) {
+                var datum = data[i];
+                // For DataFrame, as long as any datum in data is basic type, it's a 1D array
+                if (!isBasicType(datum)) {
+                    legal = false;
+                    break;
+                }
+            }
+            this.setAxis(0, generateArrayIndex(data, extra === null || extra === void 0 ? void 0 : extra.indexes));
+            if (legal) {
+                if (extra === null || extra === void 0 ? void 0 : extra.indexes) {
+                    assert(((_c = extra === null || extra === void 0 ? void 0 : extra.indexes) === null || _c === void 0 ? void 0 : _c.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 = (extra === null || extra === void 0 ? void 0 : extra.fillValue) ? data.map(function (datum) { return fillMissingValue(datum, extra === null || extra === void 0 ? void 0 : extra.fillValue); }) : data;
+                if ((_d = extra === null || extra === void 0 ? void 0 : extra.columnTypes) === null || _d === void 0 ? void 0 : _d.length) {
+                    for (var i = 0; i < this.data.length; i += 1) {
+                        this.data[i] = convertDataType(this.data[i], (_e = extra === null || extra === void 0 ? void 0 : extra.columnTypes) === null || _e === void 0 ? void 0 : _e[0]);
+                    }
+                }
+            }
+        }
+    }
+    Object.defineProperty(BaseFrame.prototype, "indexes", {
+        get: function () {
+            return this.getAxis(0);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseFrame.prototype, "columns", {
+        get: function () {
+            return this.getAxis(1);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseFrame.prototype.getAxis = function (axis) {
+        return this.axes[axis];
+    };
+    /**
+     * Set axis. Only the 0 and 1 are currently supported.
+     * @param axis
+     * @param labels
+     */
+    BaseFrame.prototype.setAxis = function (axis, values) {
+        assert(isArray(values), 'Index or columns must be Axis array.');
+        this.axes[axis] = values;
+    };
+    return BaseFrame;
+}());
+export default BaseFrame;