@formant/ava 3.4.1-formant

package/lib/data/analysis/field/types.d.ts

@@ -0,0 +1,99 @@
+import type { LevelOfMeasurement } from '../../../ckb';
+/**
+ * Field Type
+ * @public
+ */
+export type FieldType = 'null' | 'boolean' | 'integer' | 'float' | 'date' | 'string';
+/**
+ * The field meta which be existed only the Field type is mixed
+ */
+export type FieldMeta = {
+    integer?: NumberFieldInfo;
+    float?: NumberFieldInfo;
+    date?: DateFieldInfo;
+    string?: StringFieldInfo;
+};
+/**
+ * Basic info of field
+ * @public
+ */
+export type FieldInfo = {
+    /** field name */
+    name?: string;
+    /** field type */
+    type: FieldType | 'mixed';
+    /** recommendation type */
+    recommendation: FieldType;
+    /** number of empty includes null undefined or empty string */
+    missing?: number;
+    /** distinct count */
+    distinct?: number;
+    /** Number of each distinct item */
+    valueMap?: Record<string, number>;
+    /** count of rawData */
+    count?: number;
+    /** rawData */
+    rawData: any[];
+    /** more info */
+    meta?: FieldMeta;
+    /** level of measurements */
+    levelOfMeasurements?: LevelOfMeasurement[];
+};
+/**
+ * String Field
+ * @public
+ */
+export type StringFieldInfo = FieldInfo & {
+    /** max length */
+    maxLength: number;
+    /** min length */
+    minLength: number;
+    /** mean of length */
+    meanLength: number;
+    /** is contain charts */
+    containsChar: boolean;
+    /**  is contain digits */
+    containsDigit: boolean;
+    /** is contain white space */
+    containsSpace: boolean;
+};
+/**
+ * Number Field
+ * @public
+ */
+export type NumberFieldInfo = FieldInfo & {
+    /** the counts of zero value */
+    zeros: number;
+    /** minimum */
+    minimum: number;
+    /** 5% percentile */
+    percentile5: number;
+    /** 25% percentile */
+    percentile25: number;
+    /** 50% percentile */
+    percentile50: number;
+    /** 75% percentile */
+    percentile75: number;
+    /** 95% percentile */
+    percentile95: number;
+    /** maximum */
+    maximum: number;
+    /** standardDeviation */
+    standardDeviation: number;
+    /** mean */
+    mean: number;
+    /** sum */
+    sum: number;
+    /** variance */
+    variance: number;
+};
+/**
+ * Date Field
+ * @public
+ */
+export interface DateFieldInfo extends FieldInfo {
+    /** minimum date */
+    minimum: string | number | Date;
+    /** maximum date */
+    maximum: string | number | Date;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/data/analysis/graph/index.d.ts

@@ -0,0 +1,28 @@
+import type { NodeData, LinkData } from '../../dataset/graph/types';
+import type { FieldInfo } from '../field/types';
+import type { GraphFeat } from './types';
+export declare function getNodeFields(nodes: NodeData[]): {
+    nodeFields: any[];
+    nodeFieldNames: string[];
+};
+export declare function getLinkFields(links: LinkData[]): {
+    linkFields: any[];
+    linkFieldNames: string[];
+};
+export declare function getAllFieldsInfo(dataFields: any[], fieldNames: string[]): FieldInfo[];
+/**
+ * find node clusters and assign the cluster field to each node
+ * @param nodes
+ * @param links
+ */
+export declare function clusterNodes(nodes: NodeData[], nodeFieldsInfo: FieldInfo[], links: LinkData[]): FieldInfo;
+/**
+ * Calculate statistical and structural features for graph
+ * @param nodes
+ * @param links
+ */
+export declare function getAllStructFeats(nodes: NodeData[], links: LinkData[]): {
+    nodeFeats: FieldInfo[];
+    linkFeats: FieldInfo[];
+    graphInfo: Partial<GraphFeat>;
+};

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

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllStructFeats = exports.clusterNodes = exports.getAllFieldsInfo = exports.getLinkFields = exports.getNodeFields = void 0;
+var tslib_1 = require("tslib");
+// TODO @chenluli: move @antv/algorithm from devDep to dep after this file is complete
+// eslint-disable-next-line import/no-extraneous-dependencies
+var AlgorithmSync = tslib_1.__importStar(require("@antv/algorithm"));
+var field_1 = require("../field");
+var GraphAlgorithms = tslib_1.__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;
+}
+function getNodeFields(nodes) {
+    var _a = tslib_1.__read(nodes, 1), node0 = _a[0];
+    var nodeFieldNames = node0 ? Object.keys(node0) : [];
+    var nodeFields = generateColDataFromArray(nodes, nodeFieldNames);
+    return { nodeFields: nodeFields, nodeFieldNames: nodeFieldNames };
+}
+exports.getNodeFields = getNodeFields;
+function getLinkFields(links) {
+    var _a = tslib_1.__read(links, 1), link0 = _a[0];
+    var linkFieldNames = link0 ? Object.keys(link0) : [];
+    var linkFields = generateColDataFromArray(links, linkFieldNames);
+    return { linkFields: linkFields, linkFieldNames: linkFieldNames };
+}
+exports.getLinkFields = getLinkFields;
+// Analyze fields
+function getFieldInfo(dataField, fieldName) {
+    var fieldInfo = (0, field_1.analyzeField)(dataField);
+    return tslib_1.__assign(tslib_1.__assign({}, fieldInfo), { name: fieldName });
+}
+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;
+}
+exports.getAllFieldsInfo = getAllFieldsInfo;
+/* eslint-disable no-param-reassign */
+/**
+ * find node clusters and assign the cluster field to each node
+ * @param nodes
+ * @param links
+ */
+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 = tslib_1.__assign(tslib_1.__assign({}, (0, field_1.analyzeField)(values)), { name: 'cluster' });
+    }
+    return fieldForCluster;
+}
+exports.clusterNodes = clusterNodes;
+/* eslint-disable no-param-reassign */
+/**
+ * Calculate statistical and structural features for graph
+ * @param nodes
+ * @param links
+ */
+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] = tslib_1.__assign(tslib_1.__assign({}, node), nodeFeat);
+    }
+    for (var index = 0; index < links.length; index += 1) {
+        var link = links[index];
+        var linkFeat = {};
+        linkStructFeats.push(linkFeat);
+        links[index] = tslib_1.__assign(tslib_1.__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, tslib_1.__spreadArray([], tslib_1.__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,
+    };
+}
+exports.getAllStructFeats = getAllStructFeats;

package/lib/data/analysis/graph/types.d.ts

@@ -0,0 +1,62 @@
+import type { FieldInfo } from '../field/types';
+export type NodeStructFeat = {
+    degree: number;
+    inDegree: number;
+    outDegree: number;
+    pageRank: number;
+    closeness: number;
+    kCore: number;
+    cycleCount: number;
+    triangleCount: number;
+    starCount: number;
+    cliqueCount: number;
+    clusterCoeff: number;
+};
+export type LinkStructFeat = {
+    isDirected: Boolean;
+    centrality: number;
+    cycleCount: number;
+    triangleCount: number;
+    starCount: number;
+    cliqueCount: number;
+};
+export type GraphFeat = {
+    nodeCount: number;
+    linkCount: number;
+    direction: number;
+    isDirected: Boolean;
+    isDAG: Boolean;
+    isCycle: Boolean;
+    isConnected: Boolean;
+    ratio: number;
+    breadth: number;
+    depth: number;
+    maxDegree: number;
+    minDegree: number;
+    avgDegree: number;
+    degreeStd: number;
+    maxPageRank: number;
+    minPageRank: number;
+    avgPageRank: number;
+    components: any[];
+    componentCount: number;
+    strongConnectedComponents: any[];
+    strongConnectedComponentCount: number;
+    cycleCount: number;
+    directedCycleCount: number;
+    starCount: number;
+    cliqueCount: number;
+    cycleParticipate: number;
+    triangleCount: number;
+    localClusterCoeff: number;
+    globalClusterCoeff: number;
+    maxKCore: number;
+};
+export type GraphProps = {
+    nodeFeats: FieldInfo[];
+    linkFeats: FieldInfo[];
+    graphInfo: Partial<GraphFeat>;
+    nodeFieldsInfo: FieldInfo[];
+    linkFieldsInfo: FieldInfo[];
+    [key: string]: any;
+};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/data/analysis/index.d.ts

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

package/lib/data/analysis/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeField = void 0;
+var field_1 = require("./field");
+Object.defineProperty(exports, "analyzeField", { enumerable: true, get: function () { return field_1.analyzeField; } });

package/lib/data/analysis/types.d.ts

@@ -0,0 +1 @@
+export type { FieldType, FieldInfo, StringFieldInfo, NumberFieldInfo, DateFieldInfo } from './field/types';

package/lib/data/analysis/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/data/dataset/field/baseFrame.d.ts

@@ -0,0 +1,30 @@
+import type { NDArray, SeriesData, FrameData, Axis, Extra } from './types';
+export default abstract class BaseFrame {
+    axes: [Axis[]] | [Axis[], Axis[]];
+    data: NDArray;
+    colData?: NDArray;
+    extra?: Extra;
+    constructor(data: SeriesData | FrameData, extra?: Extra);
+    abstract get shape(): [number] | [number, number];
+    get indexes(): Axis[];
+    get columns(): Axis[];
+    private getAxis;
+    /**
+     * Set axis. Only the 0 and 1 are currently supported.
+     * @param axis
+     * @param labels
+     */
+    setAxis(axis: number, values: Axis[]): void;
+    /**
+     * Get data by row location and column location.
+     * @param rowLoc
+     * @param colLoc
+     */
+    abstract get(rowLoc: Axis | Axis[] | string, colLoc?: Axis | Axis[] | string): BaseFrame;
+    /**
+     * Get data by row location and column location using integer index.
+     * @param rowLoc
+     * @param colLoc
+     */
+    abstract getByIndex(rowLoc: number | number[] | string, colLoc?: number | number[] | string): BaseFrame;
+}

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../utils");
+var utils_2 = require("./utils");
+/* Base data structure */
+var BaseFrame = /** @class */ (function () {
+    function BaseFrame(data, extra) {
+        var _a, _b, _c, _d, _e;
+        this.axes = [[]];
+        this.data = [];
+        (0, utils_1.assert)(!extra || (0, utils_1.isObject)(extra), 'If extra exists, it must be an object.');
+        /* 1D: basic type */
+        if ((0, utils_1.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((0, utils_2.convertDataType)((0, utils_2.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 = [(0, utils_2.convertDataType)((0, utils_2.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 ((0, utils_1.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 (!(0, utils_1.isBasicType)(datum)) {
+                    legal = false;
+                    break;
+                }
+            }
+            this.setAxis(0, (0, utils_2.generateArrayIndex)(data, extra === null || extra === void 0 ? void 0 : extra.indexes));
+            if (legal) {
+                if (extra === null || extra === void 0 ? void 0 : extra.indexes) {
+                    (0, utils_1.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 (0, utils_2.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] = (0, utils_2.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) {
+        (0, utils_1.assert)((0, utils_1.isArray)(values), 'Index or columns must be Axis array.');
+        this.axes[axis] = values;
+    };
+    return BaseFrame;
+}());
+exports.default = BaseFrame;

package/lib/data/dataset/field/dataFrame.d.ts

@@ -0,0 +1,35 @@
+import BaseFrame from './baseFrame';
+import Series from './series';
+import type { FrameData, Axis, Extra, FieldsInfo } from './types';
+export default class DataFrame extends BaseFrame {
+    constructor(data: FrameData, extra?: Extra);
+    /**
+     * Generate columns.
+     * @param columns
+     * @param extra
+     */
+    private generateColumns;
+    /**
+     * Generate this.data and this.colData.
+     * @param isObj
+     * @param data
+     * @param columns
+     */
+    private generateDataAndColDataFromArray;
+    get shape(): [number, number];
+    get(rowLoc: Axis | Axis[] | string, colLoc?: Axis | Axis[] | string): DataFrame | Series | any;
+    getByIndex(rowLoc: number | number[] | string, colLoc?: number | number[] | string): DataFrame | Series | any;
+    /**
+     * Get data by column.
+     * @param col
+     */
+    getByColumn(col: Axis): Series;
+    /**
+     * Get statistics.
+     */
+    info(): FieldsInfo;
+    /**
+     * Get tabular data string.
+     */
+    toString(): string;
+}