nlptoolkit-classification 1.0.0

package/dist/Classifier/RandomClassifier.d.ts

@@ -0,0 +1,12 @@
+import { Classifier } from "./Classifier";
+import { InstanceList } from "../InstanceList/InstanceList";
+import { Parameter } from "../Parameter/Parameter";
+export declare class RandomClassifier extends Classifier {
+    /**
+     * Training algorithm for random classifier.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void;
+}

package/dist/Classifier/RandomClassifier.js

@@ -0,0 +1,32 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Classifier", "../Model/RandomModel"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RandomClassifier = void 0;
+    const Classifier_1 = require("./Classifier");
+    const RandomModel_1 = require("../Model/RandomModel");
+    class RandomClassifier extends Classifier_1.Classifier {
+        /**
+         * Training algorithm for random classifier.
+         *
+         * @param trainSet   Training data given to the algorithm.
+         * @param parameters -
+         */
+        train(trainSet, parameters) {
+            let result = new Array();
+            for (let s of trainSet.classDistribution().keys()) {
+                result.push(s);
+            }
+            this.model = new RandomModel_1.RandomModel(result, parameters.getSeed());
+        }
+    }
+    exports.RandomClassifier = RandomClassifier;
+});
+//# sourceMappingURL=RandomClassifier.js.map

package/dist/Classifier/RandomClassifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RandomClassifier.js","sourceRoot":"","sources":["../../source/Classifier/RandomClassifier.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,6CAAwC;IAGxC,sDAAiD;IAEjD,MAAa,gBAAiB,SAAQ,uBAAU;QAE5C;;;;;WAKG;QACH,KAAK,CAAC,QAAsB,EAAE,UAAqB;YAC/C,IAAI,MAAM,GAAG,IAAI,KAAK,EAAU,CAAA;YAChC,KAAK,IAAI,CAAC,IAAI,QAAQ,CAAC,iBAAiB,EAAE,CAAC,IAAI,EAAE,EAAC;gBAC9C,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;aACjB;YACD,IAAI,CAAC,KAAK,GAAG,IAAI,yBAAW,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;QAC/D,CAAC;KAEJ;IAhBD,4CAgBC"}

package/dist/Classifier/RandomForest.d.ts

@@ -0,0 +1,13 @@
+import { Classifier } from "./Classifier";
+import { InstanceList } from "../InstanceList/InstanceList";
+import { Parameter } from "../Parameter/Parameter";
+export declare class RandomForest extends Classifier {
+    /**
+     * Training algorithm for random forest classifier. Basically the algorithm creates K distinct decision trees from
+     * K bootstrap samples of the original training set.
+     *
+     * @param trainSet   Training data given to the algorithm
+     * @param parameters Parameters of the bagging trees algorithm. ensembleSize returns the number of trees in the random forest.
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void;
+}

package/dist/Classifier/RandomForest.js

@@ -0,0 +1,39 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Classifier", "../InstanceList/InstanceList", "../Model/DecisionTree/DecisionTree", "../Model/DecisionTree/DecisionNode", "../Model/TreeEnsembleModel"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RandomForest = void 0;
+    const Classifier_1 = require("./Classifier");
+    const InstanceList_1 = require("../InstanceList/InstanceList");
+    const DecisionTree_1 = require("../Model/DecisionTree/DecisionTree");
+    const DecisionNode_1 = require("../Model/DecisionTree/DecisionNode");
+    const TreeEnsembleModel_1 = require("../Model/TreeEnsembleModel");
+    class RandomForest extends Classifier_1.Classifier {
+        /**
+         * Training algorithm for random forest classifier. Basically the algorithm creates K distinct decision trees from
+         * K bootstrap samples of the original training set.
+         *
+         * @param trainSet   Training data given to the algorithm
+         * @param parameters Parameters of the bagging trees algorithm. ensembleSize returns the number of trees in the random forest.
+         */
+        train(trainSet, parameters) {
+            let forestSize = parameters.getEnsembleSize();
+            let forest = new Array();
+            for (let i = 0; i < forestSize; i++) {
+                let bootstrap = trainSet.bootstrap(i);
+                let tree = new DecisionTree_1.DecisionTree(new DecisionNode_1.DecisionNode(new InstanceList_1.InstanceList(bootstrap.getSample()), undefined, parameters, false));
+                forest.push(tree);
+            }
+            this.model = new TreeEnsembleModel_1.TreeEnsembleModel(forest);
+        }
+    }
+    exports.RandomForest = RandomForest;
+});
+//# sourceMappingURL=RandomForest.js.map

package/dist/Classifier/RandomForest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RandomForest.js","sourceRoot":"","sources":["../../source/Classifier/RandomForest.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,6CAAwC;IACxC,+DAA0D;IAG1D,qEAAgE;IAChE,qEAAgE;IAChE,kEAA6D;IAE7D,MAAa,YAAa,SAAQ,uBAAU;QAExC;;;;;;WAMG;QACH,KAAK,CAAC,QAAsB,EAAE,UAAqB;YAC/C,IAAI,UAAU,GAA4B,UAAW,CAAC,eAAe,EAAE,CAAC;YACxE,IAAI,MAAM,GAAG,IAAI,KAAK,EAAgB,CAAC;YACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAC;gBAChC,IAAI,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;gBACtC,IAAI,IAAI,GAAG,IAAI,2BAAY,CAAC,IAAI,2BAAY,CAAC,IAAI,2BAAY,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,SAAS,EAA0B,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC;gBAC7I,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACrB;YACD,IAAI,CAAC,KAAK,GAAG,IAAI,qCAAiB,CAAC,MAAM,CAAC,CAAC;QAC/C,CAAC;KAEJ;IApBD,oCAoBC"}

package/dist/DataSet/DataDefinition.d.ts

@@ -0,0 +1,59 @@
+import { AttributeType } from "../Attribute/AttributeType";
+import { FeatureSubSet } from "../FeatureSelection/FeatureSubSet";
+export declare class DataDefinition {
+    private attributeTypes;
+    /**
+     * Constructor for creating a new {@link DataDefinition} with given attribute types.
+     *
+     * @param attributeTypes Attribute types of the data definition.
+     */
+    constructor(attributeTypes?: Array<AttributeType>);
+    /**
+     * Returns the number of attribute types.
+     *
+     * @return Number of attribute types.
+     */
+    attributeCount(): number;
+    /**
+     * Counts the occurrences of binary and discrete type attributes.
+     *
+     * @return Count of binary and discrete type attributes.
+     */
+    discreteAttributeCount(): number;
+    /**
+     * Counts the occurrences of binary and continuous type attributes.
+     *
+     * @return Count of of binary and continuous type attributes.
+     */
+    continuousAttributeCount(): number;
+    /**
+     * Returns the attribute type of the corresponding item at given index.
+     *
+     * @param index Index of the attribute type.
+     * @return Attribute type of the corresponding item at given index.
+     */
+    getAttributeType(index: number): AttributeType;
+    /**
+     * Adds an attribute type to the list of attribute types.
+     *
+     * @param attributeType Attribute type to add to the list of attribute types.
+     */
+    addAttribute(attributeType: AttributeType): void;
+    /**
+     * Removes the attribute type at given index from the list of attributes.
+     *
+     * @param index Index to remove attribute type from list.
+     */
+    removeAttribute(index: number): void;
+    /**
+     * Clears all the attribute types from list.
+     */
+    removeAllAttributes(): void;
+    /**
+     * Generates new subset of attribute types by using given feature subset.
+     *
+     * @param featureSubSet {@link FeatureSubSet} input.
+     * @return DataDefinition with new subset of attribute types.
+     */
+    getSubSetOfFeatures(featureSubSet: FeatureSubSet): DataDefinition;
+}

package/dist/DataSet/DataDefinition.js

@@ -0,0 +1,108 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../Attribute/AttributeType"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DataDefinition = void 0;
+    const AttributeType_1 = require("../Attribute/AttributeType");
+    class DataDefinition {
+        /**
+         * Constructor for creating a new {@link DataDefinition} with given attribute types.
+         *
+         * @param attributeTypes Attribute types of the data definition.
+         */
+        constructor(attributeTypes) {
+            if (attributeTypes != undefined) {
+                this.attributeTypes = attributeTypes;
+            }
+        }
+        /**
+         * Returns the number of attribute types.
+         *
+         * @return Number of attribute types.
+         */
+        attributeCount() {
+            return this.attributeTypes.length;
+        }
+        /**
+         * Counts the occurrences of binary and discrete type attributes.
+         *
+         * @return Count of binary and discrete type attributes.
+         */
+        discreteAttributeCount() {
+            let count = 0;
+            for (let attributeType of this.attributeTypes) {
+                if (attributeType == AttributeType_1.AttributeType.DISCRETE || attributeType == AttributeType_1.AttributeType.BINARY) {
+                    count++;
+                }
+            }
+            return count;
+        }
+        /**
+         * Counts the occurrences of binary and continuous type attributes.
+         *
+         * @return Count of of binary and continuous type attributes.
+         */
+        continuousAttributeCount() {
+            let count = 0;
+            for (let attributeType of this.attributeTypes) {
+                if (attributeType == AttributeType_1.AttributeType.CONTINUOUS) {
+                    count++;
+                }
+            }
+            return count;
+        }
+        /**
+         * Returns the attribute type of the corresponding item at given index.
+         *
+         * @param index Index of the attribute type.
+         * @return Attribute type of the corresponding item at given index.
+         */
+        getAttributeType(index) {
+            return this.attributeTypes[index];
+        }
+        /**
+         * Adds an attribute type to the list of attribute types.
+         *
+         * @param attributeType Attribute type to add to the list of attribute types.
+         */
+        addAttribute(attributeType) {
+            this.attributeTypes.push(attributeType);
+        }
+        /**
+         * Removes the attribute type at given index from the list of attributes.
+         *
+         * @param index Index to remove attribute type from list.
+         */
+        removeAttribute(index) {
+            this.attributeTypes.splice(index, 1);
+        }
+        /**
+         * Clears all the attribute types from list.
+         */
+        removeAllAttributes() {
+            this.attributeTypes = new Array();
+        }
+        /**
+         * Generates new subset of attribute types by using given feature subset.
+         *
+         * @param featureSubSet {@link FeatureSubSet} input.
+         * @return DataDefinition with new subset of attribute types.
+         */
+        getSubSetOfFeatures(featureSubSet) {
+            let newAttributeTypes = new Array();
+            for (let i = 0; i < featureSubSet.size(); i++) {
+                newAttributeTypes.push(this.attributeTypes[featureSubSet.get(i)]);
+            }
+            return new DataDefinition(newAttributeTypes);
+        }
+    }
+    exports.DataDefinition = DataDefinition;
+});
+//# sourceMappingURL=DataDefinition.js.map

package/dist/DataSet/DataDefinition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataDefinition.js","sourceRoot":"","sources":["../../source/DataSet/DataDefinition.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,8DAAyD;IAGzD,MAAa,cAAc;QAIvB;;;;WAIG;QACH,YAAY,cAAqC;YAC7C,IAAI,cAAc,IAAI,SAAS,EAAC;gBAC5B,IAAI,CAAC,cAAc,GAAG,cAAc,CAAA;aACvC;QACL,CAAC;QAED;;;;WAIG;QACH,cAAc;YACV,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,CAAA;QACrC,CAAC;QAED;;;;WAIG;QACH,sBAAsB;YAClB,IAAI,KAAK,GAAG,CAAC,CAAC;YACd,KAAK,IAAI,aAAa,IAAI,IAAI,CAAC,cAAc,EAAE;gBAC3C,IAAI,aAAa,IAAI,6BAAa,CAAC,QAAQ,IAAI,aAAa,IAAI,6BAAa,CAAC,MAAM,EAAE;oBAClF,KAAK,EAAE,CAAC;iBACX;aACJ;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;QAED;;;;WAIG;QACH,wBAAwB;YACpB,IAAI,KAAK,GAAG,CAAC,CAAC;YACd,KAAK,IAAI,aAAa,IAAI,IAAI,CAAC,cAAc,EAAE;gBAC3C,IAAI,aAAa,IAAI,6BAAa,CAAC,UAAU,EAAE;oBAC3C,KAAK,EAAE,CAAC;iBACX;aACJ;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;QAED;;;;;WAKG;QACH,gBAAgB,CAAC,KAAa;YAC1B,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;QACrC,CAAC;QAED;;;;WAIG;QACH,YAAY,CAAC,aAA4B;YACrC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;QAC3C,CAAC;QAED;;;;WAIG;QACH,eAAe,CAAC,KAAa;YACzB,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;QACxC,CAAC;QAED;;WAEG;QACH,mBAAmB;YACf,IAAI,CAAC,cAAc,GAAG,IAAI,KAAK,EAAiB,CAAA;QACpD,CAAC;QAED;;;;;WAKG;QACH,mBAAmB,CAAC,aAA4B;YAC5C,IAAI,iBAAiB,GAAG,IAAI,KAAK,EAAiB,CAAC;YACnD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,EAAE;gBAC3C,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aACrE;YACD,OAAO,IAAI,cAAc,CAAC,iBAAiB,CAAC,CAAC;QACjD,CAAC;KACJ;IAtGD,wCAsGC"}

package/dist/DataSet/DataSet.d.ts

@@ -0,0 +1,111 @@
+import { InstanceList } from "../InstanceList/InstanceList";
+import { DataDefinition } from "./DataDefinition";
+import { Instance } from "../Instance/Instance";
+import { FeatureSubSet } from "../FeatureSelection/FeatureSubSet";
+export declare class DataSet {
+    private instances;
+    private definition;
+    /**
+     * Constructor for generating a new {@link DataSet} with given {@link DataDefinition}.
+     *
+     * @param definition Data definition of the data set.
+     * @param separator  Separator character which separates the attribute values in the data file.
+     * @param fileName   Name of the data set file.
+     */
+    constructor(definition?: any, separator?: string, fileName?: string);
+    /**
+     * Checks the correctness of the attribute type, for instance, if the attribute of given instance is a Binary attribute,
+     * and the attribute type of the corresponding item of the data definition is also a Binary attribute, it then
+     * returns true, and false otherwise.
+     *
+     * @param instance {@link Instance} to checks the attribute type.
+     * @return true if attribute types of given {@link Instance} and data definition matches.
+     */
+    private checkDefinition;
+    /**
+     * Adds the attribute types according to given {@link Instance}. For instance, if the attribute type of given {@link Instance}
+     * is a Discrete type, it than adds a discrete attribute type to the list of attribute types.
+     *
+     * @param instance {@link Instance} input.
+     */
+    private setDefinition;
+    /**
+     * Returns the size of the {@link InstanceList}.
+     *
+     * @return Size of the {@link InstanceList}.
+     */
+    sampleSize(): number;
+    /**
+     * Returns the size of the class label distribution of {@link InstanceList}.
+     *
+     * @return Size of the class label distribution of {@link InstanceList}.
+     */
+    classCount(): number;
+    /**
+     * Returns the number of attribute types at {@link DataDefinition} list.
+     *
+     * @return The number of attribute types at {@link DataDefinition} list.
+     */
+    attributeCount(): number;
+    /**
+     * Returns the number of discrete attribute types at {@link DataDefinition} list.
+     *
+     * @return The number of discrete attribute types at {@link DataDefinition} list.
+     */
+    discreteAttributeCount(): number;
+    /**
+     * Returns the number of continuous attribute types at {@link DataDefinition} list.
+     *
+     * @return The number of continuous attribute types at {@link DataDefinition} list.
+     */
+    continuousAttributeCount(): number;
+    /**
+     * Returns the accumulated {@link String} of class labels of the {@link InstanceList}.
+     *
+     * @return The accumulated {@link String} of class labels of the {@link InstanceList}.
+     */
+    getClasses(): string;
+    /**
+     * Adds a new instance to the {@link InstanceList}.
+     *
+     * @param current {@link Instance} to add.
+     */
+    addInstance(current: Instance): void;
+    /**
+     * Adds all the instances of given instance list to the {@link InstanceList}.
+     *
+     * @param instanceList {@link InstanceList} to add instances from.
+     */
+    addInstanceList(instanceList: Array<Instance>): void;
+    /**
+     * Returns the instances of {@link InstanceList}.
+     *
+     * @return The instances of {@link InstanceList}.
+     */
+    getInstances(): Array<Instance>;
+    /**
+     * Returns instances of the items at the list of instance lists from the partitions.
+     *
+     * @return Instances of the items at the list of instance lists from the partitions.
+     */
+    getClassInstances(): Array<Array<Instance>>;
+    /**
+     * Accessor for the {@link InstanceList}.
+     *
+     * @return The {@link InstanceList}.
+     */
+    getInstanceList(): InstanceList;
+    /**
+     * Accessor for the data definition.
+     *
+     * @return The data definition.
+     */
+    getDataDefinition(): DataDefinition;
+    /**
+     * Return a subset generated via the given {@link FeatureSubSet}.
+     *
+     * @param featureSubSet {@link FeatureSubSet} input.
+     * @return Subset generated via the given {@link FeatureSubSet}.
+     */
+    getSubSetOfFeatures(featureSubSet: FeatureSubSet): DataSet;
+}

package/dist/DataSet/DataSet.js

@@ -0,0 +1,286 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../InstanceList/InstanceList", "./DataDefinition", "fs", "../Attribute/AttributeType", "../Instance/Instance", "../Instance/CompositeInstance", "../Attribute/ContinuousAttribute", "../Attribute/DiscreteAttribute", "../Attribute/BinaryAttribute", "../Attribute/DiscreteIndexedAttribute", "../InstanceList/Partition"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DataSet = void 0;
+    const InstanceList_1 = require("../InstanceList/InstanceList");
+    const DataDefinition_1 = require("./DataDefinition");
+    const fs = require("fs");
+    const AttributeType_1 = require("../Attribute/AttributeType");
+    const Instance_1 = require("../Instance/Instance");
+    const CompositeInstance_1 = require("../Instance/CompositeInstance");
+    const ContinuousAttribute_1 = require("../Attribute/ContinuousAttribute");
+    const DiscreteAttribute_1 = require("../Attribute/DiscreteAttribute");
+    const BinaryAttribute_1 = require("../Attribute/BinaryAttribute");
+    const DiscreteIndexedAttribute_1 = require("../Attribute/DiscreteIndexedAttribute");
+    const Partition_1 = require("../InstanceList/Partition");
+    class DataSet {
+        /**
+         * Constructor for generating a new {@link DataSet} with given {@link DataDefinition}.
+         *
+         * @param definition Data definition of the data set.
+         * @param separator  Separator character which separates the attribute values in the data file.
+         * @param fileName   Name of the data set file.
+         */
+        constructor(definition, separator, fileName) {
+            this.instances = new InstanceList_1.InstanceList();
+            this.definition = undefined;
+            if (definition != undefined) {
+                if (definition instanceof DataDefinition_1.DataDefinition) {
+                    this.definition = definition;
+                }
+                else {
+                    if (separator == undefined) {
+                        let data = fs.readFileSync(fileName, 'utf8');
+                        let i = 0;
+                        let lines = data.split("\n");
+                        for (let line of lines) {
+                            let attributes = line.split(",");
+                            if (i == 0) {
+                                for (let j = 0; j < attributes.length - 1; j++) {
+                                    if (Number.isNaN(attributes[j])) {
+                                        definition.addAttribute(AttributeType_1.AttributeType.DISCRETE);
+                                    }
+                                    else {
+                                        Number.parseFloat(attributes[j]);
+                                        definition.addAttribute(AttributeType_1.AttributeType.CONTINUOUS);
+                                    }
+                                }
+                            }
+                            else {
+                                if (attributes.length != definition.attributeCount() + 1) {
+                                    continue;
+                                }
+                            }
+                            let instance;
+                            if (!attributes[attributes.length - 1].includes(";")) {
+                                instance = new Instance_1.Instance(attributes[attributes.length - 1]);
+                            }
+                            else {
+                                let labels = attributes[attributes.length - 1].split(";");
+                                instance = new CompositeInstance_1.CompositeInstance(labels[0]);
+                                instance.setPossibleClassLabels(labels.slice(1));
+                            }
+                            for (let j = 0; j < attributes.length - 1; j++) {
+                                switch (definition.getAttributeType(j)) {
+                                    case AttributeType_1.AttributeType.CONTINUOUS:
+                                        instance.addAttribute(new ContinuousAttribute_1.ContinuousAttribute(Number.parseFloat(attributes[j])));
+                                        break;
+                                    case AttributeType_1.AttributeType.DISCRETE:
+                                        instance.addAttribute(new DiscreteAttribute_1.DiscreteAttribute(attributes[j]));
+                                        break;
+                                }
+                            }
+                            if (instance.attributeSize() == definition.attributeCount()) {
+                                this.instances.add(instance);
+                            }
+                            i++;
+                        }
+                    }
+                    else {
+                        this.definition = definition;
+                        this.instances = new InstanceList_1.InstanceList(definition, separator, fileName);
+                    }
+                }
+            }
+        }
+        /**
+         * Checks the correctness of the attribute type, for instance, if the attribute of given instance is a Binary attribute,
+         * and the attribute type of the corresponding item of the data definition is also a Binary attribute, it then
+         * returns true, and false otherwise.
+         *
+         * @param instance {@link Instance} to checks the attribute type.
+         * @return true if attribute types of given {@link Instance} and data definition matches.
+         */
+        checkDefinition(instance) {
+            for (let i = 0; i < instance.attributeSize(); i++) {
+                if (instance.getAttribute(i) instanceof BinaryAttribute_1.BinaryAttribute) {
+                    if (this.definition.getAttributeType(i) != AttributeType_1.AttributeType.BINARY)
+                        return false;
+                }
+                else {
+                    if (instance.getAttribute(i) instanceof DiscreteIndexedAttribute_1.DiscreteIndexedAttribute) {
+                        if (this.definition.getAttributeType(i) != AttributeType_1.AttributeType.DISCRETE_INDEXED)
+                            return false;
+                    }
+                    else {
+                        if (instance.getAttribute(i) instanceof DiscreteAttribute_1.DiscreteAttribute) {
+                            if (this.definition.getAttributeType(i) != AttributeType_1.AttributeType.DISCRETE)
+                                return false;
+                        }
+                        else {
+                            if (instance.getAttribute(i) instanceof ContinuousAttribute_1.ContinuousAttribute) {
+                                if (this.definition.getAttributeType(i) != AttributeType_1.AttributeType.CONTINUOUS)
+                                    return false;
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        /**
+         * Adds the attribute types according to given {@link Instance}. For instance, if the attribute type of given {@link Instance}
+         * is a Discrete type, it than adds a discrete attribute type to the list of attribute types.
+         *
+         * @param instance {@link Instance} input.
+         */
+        setDefinition(instance) {
+            let attributeTypes = new Array();
+            for (let i = 0; i < instance.attributeSize(); i++) {
+                if (instance.getAttribute(i) instanceof BinaryAttribute_1.BinaryAttribute) {
+                    attributeTypes.push(AttributeType_1.AttributeType.BINARY);
+                }
+                else {
+                    if (instance.getAttribute(i) instanceof DiscreteIndexedAttribute_1.DiscreteIndexedAttribute) {
+                        attributeTypes.push(AttributeType_1.AttributeType.DISCRETE_INDEXED);
+                    }
+                    else {
+                        if (instance.getAttribute(i) instanceof DiscreteAttribute_1.DiscreteAttribute) {
+                            attributeTypes.push(AttributeType_1.AttributeType.DISCRETE);
+                        }
+                        else {
+                            if (instance.getAttribute(i) instanceof ContinuousAttribute_1.ContinuousAttribute) {
+                                attributeTypes.push(AttributeType_1.AttributeType.CONTINUOUS);
+                            }
+                        }
+                    }
+                }
+            }
+            this.definition = new DataDefinition_1.DataDefinition(attributeTypes);
+        }
+        /**
+         * Returns the size of the {@link InstanceList}.
+         *
+         * @return Size of the {@link InstanceList}.
+         */
+        sampleSize() {
+            return this.instances.size();
+        }
+        /**
+         * Returns the size of the class label distribution of {@link InstanceList}.
+         *
+         * @return Size of the class label distribution of {@link InstanceList}.
+         */
+        classCount() {
+            return this.instances.classDistribution().size;
+        }
+        /**
+         * Returns the number of attribute types at {@link DataDefinition} list.
+         *
+         * @return The number of attribute types at {@link DataDefinition} list.
+         */
+        attributeCount() {
+            return this.definition.attributeCount();
+        }
+        /**
+         * Returns the number of discrete attribute types at {@link DataDefinition} list.
+         *
+         * @return The number of discrete attribute types at {@link DataDefinition} list.
+         */
+        discreteAttributeCount() {
+            return this.definition.discreteAttributeCount();
+        }
+        /**
+         * Returns the number of continuous attribute types at {@link DataDefinition} list.
+         *
+         * @return The number of continuous attribute types at {@link DataDefinition} list.
+         */
+        continuousAttributeCount() {
+            return this.definition.continuousAttributeCount();
+        }
+        /**
+         * Returns the accumulated {@link String} of class labels of the {@link InstanceList}.
+         *
+         * @return The accumulated {@link String} of class labels of the {@link InstanceList}.
+         */
+        getClasses() {
+            let classLabels = this.instances.getDistinctClassLabels();
+            let result = classLabels[0];
+            for (let i = 1; i < classLabels.length; i++) {
+                result = result + ";" + classLabels[i];
+            }
+            return result;
+        }
+        /**
+         * Adds a new instance to the {@link InstanceList}.
+         *
+         * @param current {@link Instance} to add.
+         */
+        addInstance(current) {
+            if (this.definition == undefined) {
+                this.setDefinition(current);
+                this.instances.add(current);
+            }
+            else {
+                if (this.checkDefinition(current)) {
+                    this.instances.add(current);
+                }
+            }
+        }
+        /**
+         * Adds all the instances of given instance list to the {@link InstanceList}.
+         *
+         * @param instanceList {@link InstanceList} to add instances from.
+         */
+        addInstanceList(instanceList) {
+            for (let instance of instanceList) {
+                this.addInstance(instance);
+            }
+        }
+        /**
+         * Returns the instances of {@link InstanceList}.
+         *
+         * @return The instances of {@link InstanceList}.
+         */
+        getInstances() {
+            return this.instances.getInstances();
+        }
+        /**
+         * Returns instances of the items at the list of instance lists from the partitions.
+         *
+         * @return Instances of the items at the list of instance lists from the partitions.
+         */
+        getClassInstances() {
+            return new Partition_1.Partition(this.instances).getLists();
+        }
+        /**
+         * Accessor for the {@link InstanceList}.
+         *
+         * @return The {@link InstanceList}.
+         */
+        getInstanceList() {
+            return this.instances;
+        }
+        /**
+         * Accessor for the data definition.
+         *
+         * @return The data definition.
+         */
+        getDataDefinition() {
+            return this.definition;
+        }
+        /**
+         * Return a subset generated via the given {@link FeatureSubSet}.
+         *
+         * @param featureSubSet {@link FeatureSubSet} input.
+         * @return Subset generated via the given {@link FeatureSubSet}.
+         */
+        getSubSetOfFeatures(featureSubSet) {
+            let result = new DataSet(this.definition.getSubSetOfFeatures(featureSubSet));
+            for (let i = 0; i < this.instances.size(); i++) {
+                result.addInstance(this.instances.get(i).getSubSetOfFeatures(featureSubSet));
+            }
+            return result;
+        }
+    }
+    exports.DataSet = DataSet;
+});
+//# sourceMappingURL=DataSet.js.map