nlptoolkit-classification 1.0.0

package/dist/Attribute/Attribute.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class Attribute {
+    abstract continuousAttributeSize(): number;
+    abstract continuousAttributes(): Array<number>;
+}

package/dist/Attribute/Attribute.js

@@ -0,0 +1,17 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Attribute = void 0;
+    class Attribute {
+    }
+    exports.Attribute = Attribute;
+});
+//# sourceMappingURL=Attribute.js.map

package/dist/Attribute/Attribute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Attribute.js","sourceRoot":"","sources":["../../source/Attribute/Attribute.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAsB,SAAS;KAK9B;IALD,8BAKC"}

package/dist/Attribute/AttributeType.d.ts

@@ -0,0 +1,18 @@
+export declare enum AttributeType {
+    /**
+     * Continuous Attribute
+     */
+    CONTINUOUS = 0,
+    /**
+     * Discrete Attribute
+     */
+    DISCRETE = 1,
+    /**
+     * Binary Attribute
+     */
+    BINARY = 2,
+    /**
+     * Discrete Indexed Attribute is used to store the indices.
+     */
+    DISCRETE_INDEXED = 3
+}

package/dist/Attribute/AttributeType.js

@@ -0,0 +1,33 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AttributeType = void 0;
+    var AttributeType;
+    (function (AttributeType) {
+        /**
+         * Continuous Attribute
+         */
+        AttributeType[AttributeType["CONTINUOUS"] = 0] = "CONTINUOUS";
+        /**
+         * Discrete Attribute
+         */
+        AttributeType[AttributeType["DISCRETE"] = 1] = "DISCRETE";
+        /**
+         * Binary Attribute
+         */
+        AttributeType[AttributeType["BINARY"] = 2] = "BINARY";
+        /**
+         * Discrete Indexed Attribute is used to store the indices.
+         */
+        AttributeType[AttributeType["DISCRETE_INDEXED"] = 3] = "DISCRETE_INDEXED";
+    })(AttributeType = exports.AttributeType || (exports.AttributeType = {}));
+});
+//# sourceMappingURL=AttributeType.js.map

package/dist/Attribute/AttributeType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AttributeType.js","sourceRoot":"","sources":["../../source/Attribute/AttributeType.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,IAAY,aAiBX;IAjBD,WAAY,aAAa;QACrB;;WAEG;QACH,6DAAU,CAAA;QACV;;WAEG;QACH,yDAAQ,CAAA;QACR;;WAEG;QACH,qDAAM,CAAA;QACN;;WAEG;QACH,yEAAgB,CAAA;IACpB,CAAC,EAjBW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAiBxB"}

package/dist/Attribute/BinaryAttribute.d.ts

@@ -0,0 +1,9 @@
+import { DiscreteAttribute } from "./DiscreteAttribute";
+export declare class BinaryAttribute extends DiscreteAttribute {
+    /**
+     * Constructor for a binary discrete attribute. The attribute can take only two values "True" or "False".
+     *
+     * @param value Value of the attribute. Can be true or false.
+     */
+    constructor(value: boolean);
+}

package/dist/Attribute/BinaryAttribute.js

@@ -0,0 +1,26 @@
+(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", "./DiscreteAttribute"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BinaryAttribute = void 0;
+    const DiscreteAttribute_1 = require("./DiscreteAttribute");
+    class BinaryAttribute extends DiscreteAttribute_1.DiscreteAttribute {
+        /**
+         * Constructor for a binary discrete attribute. The attribute can take only two values "True" or "False".
+         *
+         * @param value Value of the attribute. Can be true or false.
+         */
+        constructor(value) {
+            super(value == true ? "1" : "0");
+        }
+    }
+    exports.BinaryAttribute = BinaryAttribute;
+});
+//# sourceMappingURL=BinaryAttribute.js.map

package/dist/Attribute/BinaryAttribute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryAttribute.js","sourceRoot":"","sources":["../../source/Attribute/BinaryAttribute.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,2DAAsD;IAEtD,MAAa,eAAgB,SAAQ,qCAAiB;QAElD;;;;WAIG;QACH,YAAY,KAAc;YACtB,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACrC,CAAC;KAEJ;IAXD,0CAWC"}

package/dist/Attribute/ContinuousAttribute.d.ts

@@ -0,0 +1,30 @@
+import { Attribute } from "./Attribute";
+export declare class ContinuousAttribute extends Attribute {
+    private value;
+    /**
+     * Constructor for a continuous attribute.
+     *
+     * @param value Value of the attribute.
+     */
+    constructor(value: number);
+    /**
+     * Accessor method for value.
+     *
+     * @return value
+     */
+    getValue(): number;
+    /**
+     * Mutator method for value
+     *
+     * @param value New value of value.
+     */
+    setValue(value: number): void;
+    /**
+     * Converts value to {@link String}.
+     *
+     * @return String representation of value.
+     */
+    toString(): string;
+    continuousAttributeSize(): number;
+    continuousAttributes(): Array<number>;
+}

package/dist/Attribute/ContinuousAttribute.js

@@ -0,0 +1,59 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ContinuousAttribute = void 0;
+    const Attribute_1 = require("./Attribute");
+    class ContinuousAttribute extends Attribute_1.Attribute {
+        /**
+         * Constructor for a continuous attribute.
+         *
+         * @param value Value of the attribute.
+         */
+        constructor(value) {
+            super();
+            this.value = value;
+        }
+        /**
+         * Accessor method for value.
+         *
+         * @return value
+         */
+        getValue() {
+            return this.value;
+        }
+        /**
+         * Mutator method for value
+         *
+         * @param value New value of value.
+         */
+        setValue(value) {
+            this.value = value;
+        }
+        /**
+         * Converts value to {@link String}.
+         *
+         * @return String representation of value.
+         */
+        toString() {
+            return this.value.toString();
+        }
+        continuousAttributeSize() {
+            return 1;
+        }
+        continuousAttributes() {
+            let result = new Array();
+            result.push(this.value);
+            return result;
+        }
+    }
+    exports.ContinuousAttribute = ContinuousAttribute;
+});
+//# sourceMappingURL=ContinuousAttribute.js.map

package/dist/Attribute/ContinuousAttribute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContinuousAttribute.js","sourceRoot":"","sources":["../../source/Attribute/ContinuousAttribute.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,2CAAsC;IAEtC,MAAa,mBAAoB,SAAQ,qBAAS;QAI9C;;;;WAIG;QACH,YAAY,KAAa;YACrB,KAAK,EAAE,CAAC;YACR,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QACtB,CAAC;QAED;;;;WAIG;QACH,QAAQ;YACJ,OAAO,IAAI,CAAC,KAAK,CAAA;QACrB,CAAC;QAED;;;;WAIG;QACH,QAAQ,CAAC,KAAa;YAClB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QACtB,CAAC;QAED;;;;WAIG;QACH,QAAQ;YACJ,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAA;QAChC,CAAC;QAED,uBAAuB;YACnB,OAAO,CAAC,CAAC;QACb,CAAC;QAED,oBAAoB;YAChB,IAAI,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;YACjC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACvB,OAAO,MAAM,CAAA;QACjB,CAAC;KACJ;IAlDD,kDAkDC"}

package/dist/Attribute/DiscreteAttribute.d.ts

@@ -0,0 +1,24 @@
+import { Attribute } from "./Attribute";
+export declare class DiscreteAttribute extends Attribute {
+    private value;
+    /**
+     * Constructor for a discrete attribute.
+     *
+     * @param value Value of the attribute.
+     */
+    constructor(value: string);
+    /**
+     * Accessor method for value.
+     *
+     * @return value
+     */
+    getValue(): string;
+    /**
+     * Converts value to {@link String}.
+     *
+     * @return String representation of value.
+     */
+    toString(): string;
+    continuousAttributeSize(): number;
+    continuousAttributes(): Array<number>;
+}

package/dist/Attribute/DiscreteAttribute.js

@@ -0,0 +1,53 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiscreteAttribute = void 0;
+    const Attribute_1 = require("./Attribute");
+    class DiscreteAttribute extends Attribute_1.Attribute {
+        /**
+         * Constructor for a discrete attribute.
+         *
+         * @param value Value of the attribute.
+         */
+        constructor(value) {
+            super();
+            this.value = "NULL";
+            this.value = value;
+        }
+        /**
+         * Accessor method for value.
+         *
+         * @return value
+         */
+        getValue() {
+            return this.value;
+        }
+        /**
+         * Converts value to {@link String}.
+         *
+         * @return String representation of value.
+         */
+        toString() {
+            if (this.value == ",") {
+                return "comma";
+            }
+            return this.value;
+        }
+        continuousAttributeSize() {
+            return 0;
+        }
+        continuousAttributes() {
+            return new Array();
+        }
+    }
+    exports.DiscreteAttribute = DiscreteAttribute;
+});
+//# sourceMappingURL=DiscreteAttribute.js.map

package/dist/Attribute/DiscreteAttribute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiscreteAttribute.js","sourceRoot":"","sources":["../../source/Attribute/DiscreteAttribute.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,2CAAsC;IAEtC,MAAa,iBAAkB,SAAQ,qBAAS;QAI5C;;;;WAIG;QACH,YAAY,KAAa;YACrB,KAAK,EAAE,CAAC;YARJ,UAAK,GAAW,MAAM,CAAA;YAS1B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QACtB,CAAC;QAED;;;;WAIG;QACH,QAAQ;YACJ,OAAO,IAAI,CAAC,KAAK,CAAA;QACrB,CAAC;QAED;;;;WAIG;QACH,QAAQ;YACJ,IAAI,IAAI,CAAC,KAAK,IAAI,GAAG,EAAC;gBAClB,OAAO,OAAO,CAAC;aAClB;YACD,OAAO,IAAI,CAAC,KAAK,CAAC;QACtB,CAAC;QAED,uBAAuB;YACnB,OAAO,CAAC,CAAC;QACb,CAAC;QAED,oBAAoB;YAChB,OAAO,IAAI,KAAK,EAAU,CAAC;QAC/B,CAAC;KAEJ;IA3CD,8CA2CC"}

package/dist/Attribute/DiscreteIndexedAttribute.d.ts

@@ -0,0 +1,27 @@
+import { DiscreteAttribute } from "./DiscreteAttribute";
+export declare class DiscreteIndexedAttribute extends DiscreteAttribute {
+    private index;
+    private maxIndex;
+    /**
+     * Constructor for a discrete attribute.
+     *
+     * @param value Value of the attribute.
+     * @param index Index of the attribute.
+     * @param maxIndex Maximum index of the attribute.
+     */
+    constructor(value: string, index: number, maxIndex: number);
+    /**
+     * Accessor method for index.
+     *
+     * @return index.
+     */
+    getIndex(): number;
+    /**
+     * Accessor method for maxIndex.
+     *
+     * @return maxIndex.
+     */
+    getMaxIndex(): number;
+    continuousAttributeSize(): number;
+    continuousAttributes(): Array<number>;
+}

package/dist/Attribute/DiscreteIndexedAttribute.js

@@ -0,0 +1,61 @@
+(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", "./DiscreteAttribute"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DiscreteIndexedAttribute = void 0;
+    const DiscreteAttribute_1 = require("./DiscreteAttribute");
+    class DiscreteIndexedAttribute extends DiscreteAttribute_1.DiscreteAttribute {
+        /**
+         * Constructor for a discrete attribute.
+         *
+         * @param value Value of the attribute.
+         * @param index Index of the attribute.
+         * @param maxIndex Maximum index of the attribute.
+         */
+        constructor(value, index, maxIndex) {
+            super(value);
+            this.index = index;
+            this.maxIndex = maxIndex;
+        }
+        /**
+         * Accessor method for index.
+         *
+         * @return index.
+         */
+        getIndex() {
+            return this.index;
+        }
+        /**
+         * Accessor method for maxIndex.
+         *
+         * @return maxIndex.
+         */
+        getMaxIndex() {
+            return this.maxIndex;
+        }
+        continuousAttributeSize() {
+            return this.maxIndex;
+        }
+        continuousAttributes() {
+            let result = new Array();
+            for (let i = 0; i < this.maxIndex; i++) {
+                if (i != this.index) {
+                    result.push(0.0);
+                }
+                else {
+                    result.push(1.0);
+                }
+            }
+            return result;
+        }
+    }
+    exports.DiscreteIndexedAttribute = DiscreteIndexedAttribute;
+});
+//# sourceMappingURL=DiscreteIndexedAttribute.js.map

package/dist/Attribute/DiscreteIndexedAttribute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiscreteIndexedAttribute.js","sourceRoot":"","sources":["../../source/Attribute/DiscreteIndexedAttribute.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,2DAAsD;IAEtD,MAAa,wBAAyB,SAAQ,qCAAiB;QAK3D;;;;;;WAMG;QACH,YAAY,KAAa,EAAE,KAAa,EAAE,QAAgB;YACtD,KAAK,CAAC,KAAK,CAAC,CAAC;YACb,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;YAClB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QAC5B,CAAC;QAED;;;;WAIG;QACH,QAAQ;YACJ,OAAO,IAAI,CAAC,KAAK,CAAA;QACrB,CAAC;QAED;;;;WAIG;QACH,WAAW;YACP,OAAO,IAAI,CAAC,QAAQ,CAAA;QACxB,CAAC;QAED,uBAAuB;YACnB,OAAO,IAAI,CAAC,QAAQ,CAAA;QACxB,CAAC;QAED,oBAAoB;YAChB,IAAI,MAAM,GAAG,IAAI,KAAK,EAAU,CAAA;YAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE;gBACpC,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE;oBACjB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;iBACpB;qBAAM;oBACH,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;iBACpB;aACJ;YACD,OAAO,MAAM,CAAA;QACjB,CAAC;KACJ;IAnDD,4DAmDC"}

package/dist/Classifier/Bagging.d.ts

@@ -0,0 +1,16 @@
+import { Classifier } from "./Classifier";
+import { InstanceList } from "../InstanceList/InstanceList";
+import { Parameter } from "../Parameter/Parameter";
+export declare class Bagging extends Classifier {
+    /**
+     * Bagging bootstrap ensemble method that creates individuals for its ensemble by training each classifier on a random
+     * redistribution of the training set.
+     * This training method is for a bagged decision tree classifier. 20 percent of the instances are left aside for pruning of the trees
+     * 80 percent of the instances are used for training the trees. The number of trees (forestSize) is a parameter, and basically
+     * the method will learn an ensemble of trees as a model.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters Parameters of the bagging trees algorithm. ensembleSize returns the number of trees in the bagged forest.
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void;
+}

package/dist/Classifier/Bagging.js

@@ -0,0 +1,42 @@
+(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.Bagging = 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 Bagging extends Classifier_1.Classifier {
+        /**
+         * Bagging bootstrap ensemble method that creates individuals for its ensemble by training each classifier on a random
+         * redistribution of the training set.
+         * This training method is for a bagged decision tree classifier. 20 percent of the instances are left aside for pruning of the trees
+         * 80 percent of the instances are used for training the trees. The number of trees (forestSize) is a parameter, and basically
+         * the method will learn an ensemble of trees as a model.
+         *
+         * @param trainSet   Training data given to the algorithm.
+         * @param parameters Parameters of the bagging trees algorithm. ensembleSize returns the number of trees in the bagged 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, undefined, false));
+                forest.push(tree);
+            }
+            this.model = new TreeEnsembleModel_1.TreeEnsembleModel(forest);
+        }
+    }
+    exports.Bagging = Bagging;
+});
+//# sourceMappingURL=Bagging.js.map

package/dist/Classifier/Bagging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bagging.js","sourceRoot":"","sources":["../../source/Classifier/Bagging.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,6CAAwC;IACxC,+DAA0D;IAG1D,qEAAgE;IAChE,qEAAgE;IAChE,kEAA6D;IAE7D,MAAa,OAAQ,SAAQ,uBAAU;QAEnC;;;;;;;;;WASG;QACH,KAAK,CAAC,QAAsB,EAAE,UAAqB;YAC/C,IAAI,UAAU,GAAuB,UAAW,CAAC,eAAe,EAAE,CAAC;YACnE,IAAI,MAAM,GAAG,IAAI,KAAK,EAAgB,CAAC;YACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE;gBACjC,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,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;gBACpH,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACrB;YACD,IAAI,CAAC,KAAK,GAAG,IAAI,qCAAiB,CAAC,MAAM,CAAC,CAAC;QAC/C,CAAC;KAEJ;IAvBD,0BAuBC"}

package/dist/Classifier/C45.d.ts

@@ -0,0 +1,13 @@
+import { Classifier } from "./Classifier";
+import { InstanceList } from "../InstanceList/InstanceList";
+import { Parameter } from "../Parameter/Parameter";
+export declare class C45 extends Classifier {
+    /**
+     * Training algorithm for C4.5 univariate decision tree classifier. 20 percent of the data are left aside for pruning
+     * 80 percent of the data is used for constructing the tree.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void;
+}

package/dist/Classifier/C45.js

@@ -0,0 +1,40 @@
+(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/Partition", "../Model/DecisionTree/DecisionTree", "../Model/DecisionTree/DecisionNode"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.C45 = void 0;
+    const Classifier_1 = require("./Classifier");
+    const Partition_1 = require("../InstanceList/Partition");
+    const DecisionTree_1 = require("../Model/DecisionTree/DecisionTree");
+    const DecisionNode_1 = require("../Model/DecisionTree/DecisionNode");
+    class C45 extends Classifier_1.Classifier {
+        /**
+         * Training algorithm for C4.5 univariate decision tree classifier. 20 percent of the data are left aside for pruning
+         * 80 percent of the data is used for constructing the tree.
+         *
+         * @param trainSet   Training data given to the algorithm.
+         * @param parameters -
+         */
+        train(trainSet, parameters) {
+            let tree;
+            if (parameters.isPrune()) {
+                let partition = new Partition_1.Partition(trainSet, parameters.getCrossValidationRatio(), true);
+                tree = new DecisionTree_1.DecisionTree(new DecisionNode_1.DecisionNode(partition.get(1), undefined, undefined, false));
+                tree.prune(partition.get(0));
+            }
+            else {
+                tree = new DecisionTree_1.DecisionTree(new DecisionNode_1.DecisionNode(trainSet, undefined, undefined, false));
+            }
+            this.model = tree;
+        }
+    }
+    exports.C45 = C45;
+});
+//# sourceMappingURL=C45.js.map

package/dist/Classifier/C45.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"C45.js","sourceRoot":"","sources":["../../source/Classifier/C45.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,6CAAwC;IAIxC,yDAAoD;IACpD,qEAAgE;IAChE,qEAAgE;IAEhE,MAAa,GAAI,SAAQ,uBAAU;QAE/B;;;;;;WAMG;QACH,KAAK,CAAC,QAAsB,EAAE,UAAqB;YAC/C,IAAI,IAAkB,CAAA;YACtB,IAAoB,UAAW,CAAC,OAAO,EAAE,EAAE;gBACvC,IAAI,SAAS,GAAG,IAAI,qBAAS,CAAC,QAAQ,EAAkB,UAAW,CAAC,uBAAuB,EAAE,EAAE,IAAI,CAAC,CAAC;gBACrG,IAAI,GAAG,IAAI,2BAAY,CAAC,IAAI,2BAAY,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;gBACzF,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;aAChC;iBAAM;gBACH,IAAI,GAAG,IAAI,2BAAY,CAAC,IAAI,2BAAY,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;aACpF;YACD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QACtB,CAAC;KAEJ;IArBD,kBAqBC"}

package/dist/Classifier/C45Stump.d.ts

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

package/dist/Classifier/C45Stump.js

@@ -0,0 +1,29 @@
+(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/DecisionTree/DecisionTree", "../Model/DecisionTree/DecisionNode"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.C45Stump = void 0;
+    const Classifier_1 = require("./Classifier");
+    const DecisionTree_1 = require("../Model/DecisionTree/DecisionTree");
+    const DecisionNode_1 = require("../Model/DecisionTree/DecisionNode");
+    class C45Stump extends Classifier_1.Classifier {
+        /**
+         * Training algorithm for C4.5 Stump univariate decision tree classifier.
+         *
+         * @param trainSet   Training data given to the algorithm.
+         * @param parameters -
+         */
+        train(trainSet, parameters) {
+            this.model = new DecisionTree_1.DecisionTree(new DecisionNode_1.DecisionNode(trainSet, undefined, undefined, true));
+        }
+    }
+    exports.C45Stump = C45Stump;
+});
+//# sourceMappingURL=C45Stump.js.map

package/dist/Classifier/C45Stump.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"C45Stump.js","sourceRoot":"","sources":["../../source/Classifier/C45Stump.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,6CAAwC;IAGxC,qEAAgE;IAChE,qEAAgE;IAEhE,MAAa,QAAS,SAAQ,uBAAU;QAEpC;;;;;WAKG;QACH,KAAK,CAAC,QAAsB,EAAE,UAAqB;YAC/C,IAAI,CAAC,KAAK,GAAG,IAAI,2BAAY,CAAC,IAAI,2BAAY,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,CAAC;QAC1F,CAAC;KAEJ;IAZD,4BAYC"}

package/dist/Classifier/Classifier.d.ts

@@ -0,0 +1,39 @@
+import { Model } from "../Model/Model";
+import { InstanceList } from "../InstanceList/InstanceList";
+import { Parameter } from "../Parameter/Parameter";
+import { Instance } from "../Instance/Instance";
+import { Performance } from "../Performance/Performance";
+export declare abstract class Classifier {
+    protected model: Model;
+    abstract train(trainSet: InstanceList, parameters: Parameter): void;
+    /**
+     * Checks given instance's attribute and returns true if it is a discrete indexed attribute, false otherwise.
+     *
+     * @param instance Instance to check.
+     * @return True if instance is a discrete indexed attribute, false otherwise.
+     */
+    discreteCheck(instance: Instance): boolean;
+    /**
+     * TestClassification an instance list with the current model.
+     *
+     * @param testSet Test data (list of instances) to be tested.
+     * @return The accuracy (and error) of the model as an instance of Performance class.
+     */
+    test(testSet: InstanceList): Performance;
+    /**
+     * Runs current classifier with the given train and test data.
+     *
+     * @param parameter Parameter of the classifier to be trained.
+     * @param trainSet  Training data to be used in training the classifier.
+     * @param testSet   Test data to be tested after training the model.
+     * @return The accuracy (and error) of the trained model as an instance of Performance class.
+     * @throws DiscreteFeaturesNotAllowed Exception for discrete features.
+     */
+    singleRun(parameter: Parameter, trainSet: InstanceList, testSet: InstanceList): Performance;
+    /**
+     * Accessor for the model.
+     *
+     * @return Model.
+     */
+    getModel(): Model;
+}