nlptoolkit-classification 1.0.6 → 1.0.8

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "nlptoolkit-classification",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Classification Library",
-  "main": "index.js",
-  "types": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "test": "Mocha"
   },
@@ -24,9 +24,9 @@
     "typescript": "^4.5.4"
   },
   "dependencies": {
-    "nlptoolkit-datastructure": "^1.0.4",
-    "nlptoolkit-math": "^1.0.3",
-    "nlptoolkit-sampling": "^1.0.2",
-    "nlptoolkit-util": "^1.0.8"
+    "nlptoolkit-datastructure": "^1.0.8",
+    "nlptoolkit-math": "^1.0.5",
+    "nlptoolkit-sampling": "^1.0.4",
+    "nlptoolkit-util": "^1.0.11"
   }
 }

package/source/Attribute/DiscreteAttribute.ts

@@ -2,7 +2,7 @@ import {Attribute} from "./Attribute";
 
 export class DiscreteAttribute extends Attribute{
 
-    private value: string = "NULL"
+    private readonly value: string = "NULL"
 
     /**
      * Constructor for a discrete attribute.

package/source/Attribute/DiscreteIndexedAttribute.ts

@@ -2,8 +2,8 @@ import {DiscreteAttribute} from "./DiscreteAttribute";
 
 export class DiscreteIndexedAttribute extends DiscreteAttribute{
 
-    private index: number
-    private maxIndex: number
+    private readonly index: number
+    private readonly maxIndex: number
 
     /**
      * Constructor for a discrete attribute.

package/source/DataSet/DataDefinition.ts

@@ -21,10 +21,21 @@ export class DataDefinition {
         }
     }
 
+    /**
+     * Returns number of distinct values for a given discrete attribute with index attributeIndex.
+     * @param attributeIndex Index of the discrete attribute.
+     * @return Number of distinct values for a given discrete attribute
+     */
     numberOfValues(attributeIndex: number): number{
         return this.attributeValueList[attributeIndex].length
     }
 
+    /**
+     * Returns the index of the given value in the values list of the attributeIndex'th discrete attribute.
+     * @param attributeIndex Index of the discrete attribute.
+     * @param value Value of the discrete attribute
+     * @return Index of the given value in the values list of the discrete attribute.
+     */
     featureValueIndex(attributeIndex: number, value: String): number{
         for (let i = 0; i < this.attributeValueList[attributeIndex].length; i++){
             if (this.attributeValueList[attributeIndex][i] == value){

package/source/Experiment/BootstrapRun.ts

@@ -29,8 +29,8 @@ export class BootstrapRun implements MultipleRun{
         for (let i = 0; i < this.numberOfBootstraps; i++) {
             let bootstrap = new Bootstrap<Instance>(experiment.getDataSet().getInstances(), i + experiment.getParameter().getSeed());
             let bootstrapSample = new InstanceList(bootstrap.getSample());
-            experiment.getClassifier().train(bootstrapSample, experiment.getParameter());
-            result.add(experiment.getClassifier().test(experiment.getDataSet().getInstanceList()));
+            experiment.getmodel().train(bootstrapSample, experiment.getParameter());
+            result.add(experiment.getmodel().test(experiment.getDataSet().getInstanceList()));
         }
         return result;
     }

package/source/Experiment/Experiment.ts

@@ -1,22 +1,22 @@
-import {Classifier} from "../Classifier/Classifier";
 import {Parameter} from "../Parameter/Parameter";
 import {DataSet} from "../DataSet/DataSet";
 import {FeatureSubSet} from "../FeatureSelection/FeatureSubSet";
+import {Model} from "../Model/Model";
 
 export class Experiment {
 
-    private classifier: Classifier
-    private parameter: Parameter
-    private dataSet: DataSet
+    private readonly model: Model
+    private readonly parameter: Parameter
+    private readonly dataSet: DataSet
 
     /**
      * Constructor for a specific machine learning experiment
-     * @param classifier Classifier used in the machine learning experiment
+     * @param model Model used in the machine learning experiment
      * @param parameter Parameter(s) of the classifier.
      * @param dataSet DataSet on which the classifier is run.
      */
-    constructor(classifier: Classifier, parameter: Parameter, dataSet: DataSet) {
-        this.classifier = classifier
+    constructor(model: Model, parameter: Parameter, dataSet: DataSet) {
+        this.model = model
         this.parameter = parameter
         this.dataSet = dataSet
     }
@@ -25,8 +25,8 @@ export class Experiment {
      * Accessor for the classifier attribute.
      * @return Classifier attribute.
      */
-    getClassifier(): Classifier{
-        return this.classifier
+    getmodel(): Model{
+        return this.model
     }
 
     /**
@@ -51,7 +51,7 @@ export class Experiment {
      * @return Experiment constructed
      */
     featureSelectedExperiment(featureSubSet: FeatureSubSet): Experiment{
-        return new Experiment(this.classifier, this.parameter, this.dataSet.getSubSetOfFeatures(featureSubSet));
+        return new Experiment(this.model, this.parameter, this.dataSet.getSubSetOfFeatures(featureSubSet));
     }
 
 }

package/source/Experiment/KFoldRun.ts

@@ -1,30 +1,45 @@
 import {MultipleRun} from "./MultipleRun";
 import {Experiment} from "./Experiment";
 import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
-import {Classifier} from "../Classifier/Classifier";
 import {Parameter} from "../Parameter/Parameter";
 import {CrossValidation} from "nlptoolkit-sampling/dist/CrossValidation";
 import {Instance} from "../Instance/Instance";
 import {InstanceList} from "../InstanceList/InstanceList";
 import {KFoldCrossValidation} from "nlptoolkit-sampling/dist/KFoldCrossValidation";
+import {Model} from "../Model/Model";
 
 export class KFoldRun implements MultipleRun{
 
     protected K: number
 
+    /**
+     * Constructor for KFoldRun class. Basically sets K parameter of the K-fold cross-validation.
+     *
+     * @param K K of the K-fold cross-validation.
+     */
     constructor(K: number) {
         this.K = K
     }
 
-    protected runExperiment(classifier: Classifier,
+    /**
+     * Runs a K fold cross-validated experiment for the given classifier with the given parameters. The experiment
+     * results will be added to the experimentPerformance.
+     * @param model Model for the experiment
+     * @param parameter Hyperparameters of the classifier of the experiment
+     * @param experimentPerformance Storage to add experiment results
+     * @param crossValidation K-fold crossvalidated dataset.
+     * @throws DiscreteFeaturesNotAllowed If the classifier does not allow discrete features and the dataset contains
+     * discrete features, DiscreteFeaturesNotAllowed will be thrown.
+     */
+    protected runExperiment(model: Model,
                             parameter: Parameter,
                             experimentPerformance: ExperimentPerformance,
                             crossValidation: CrossValidation<Instance>){
         for (let i = 0; i < this.K; i++) {
             let trainSet = new InstanceList(crossValidation.getTrainFold(i));
             let testSet = new InstanceList(crossValidation.getTestFold(i));
-            classifier.train(trainSet, parameter);
-            experimentPerformance.add(classifier.test(testSet));
+            model.train(trainSet, parameter);
+            experimentPerformance.add(model.test(testSet));
         }
     }
 
@@ -37,7 +52,7 @@ export class KFoldRun implements MultipleRun{
     execute(experiment: Experiment): ExperimentPerformance {
         let result = new ExperimentPerformance();
         let crossValidation = new KFoldCrossValidation<Instance>(experiment.getDataSet().getInstances(), this.K, experiment.getParameter().getSeed());
-        this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation);
+        this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation);
         return result;
     }
 

package/source/Experiment/KFoldRunSeparateTest.ts

@@ -1,5 +1,4 @@
 import {KFoldRun} from "./KFoldRun";
-import {Classifier} from "../Classifier/Classifier";
 import {Parameter} from "../Parameter/Parameter";
 import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
 import {InstanceList} from "../InstanceList/InstanceList";
@@ -8,6 +7,7 @@ import {Instance} from "../Instance/Instance";
 import {Experiment} from "./Experiment";
 import {KFoldCrossValidation} from "nlptoolkit-sampling/dist/KFoldCrossValidation";
 import {Partition} from "../InstanceList/Partition";
+import {Model} from "../Model/Model";
 
 export class KFoldRunSeparateTest extends KFoldRun{
 
@@ -20,15 +20,26 @@ export class KFoldRunSeparateTest extends KFoldRun{
         super(K);
     }
 
-    protected runExperiment(classifier: Classifier,
+    /**
+     * Runs a K fold cross-validated experiment for the given classifier with the given parameters. Testing will be
+     * done on the separate test set. The experiment results will be added to the experimentPerformance.
+     * @param model Model for the experiment
+     * @param parameter Hyperparameters of the classifier of the experiment
+     * @param experimentPerformance Storage to add experiment results
+     * @param crossValidation K-fold crossvalidated dataset.
+     * @param testSet Test set on which experiment performance is calculated.
+     * @throws DiscreteFeaturesNotAllowed If the classifier does not allow discrete features and the dataset contains
+     * discrete features, DiscreteFeaturesNotAllowed will be thrown.
+     */
+    protected runExperiment(model: Model,
                             parameter: Parameter,
                             experimentPerformance: ExperimentPerformance,
                             crossValidation: CrossValidation<Instance>,
                             testSet?: InstanceList) {
         for (let i = 0; i < this.K; i++) {
             let trainSet = new InstanceList(crossValidation.getTrainFold(i));
-            classifier.train(trainSet, parameter);
-            experimentPerformance.add(classifier.test(testSet));
+            model.train(trainSet, parameter);
+            experimentPerformance.add(model.test(testSet));
         }
     }
 
@@ -43,7 +54,7 @@ export class KFoldRunSeparateTest extends KFoldRun{
         let instanceList = experiment.getDataSet().getInstanceList();
         let partition = new Partition(instanceList, 0.25, true);
         let crossValidation = new KFoldCrossValidation<Instance>(partition.get(1).getInstances(), this.K, experiment.getParameter().getSeed());
-        this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+        this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation, partition.get(0));
         return result;
     }
 

package/source/Experiment/MxKFoldRun.ts

@@ -29,7 +29,7 @@ export class MxKFoldRun extends KFoldRun{
         let result = new ExperimentPerformance();
         for (let j = 0; j < this.M; j++) {
             let crossValidation = new KFoldCrossValidation<Instance>(experiment.getDataSet().getInstances(), this.K, experiment.getParameter().getSeed());
-            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation);
+            this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation);
         }
         return result;
     }

package/source/Experiment/MxKFoldRunSeparateTest.ts

@@ -33,7 +33,7 @@ export class MxKFoldRunSeparateTest extends KFoldRunSeparateTest{
         let partition = new Partition(instanceList, 0.25, true);
         for (let j = 0; j < this.M; j++) {
             let crossValidation = new KFoldCrossValidation<Instance>(partition.get(1).getInstances(), this.K, experiment.getParameter().getSeed());
-            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+            this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation, partition.get(0));
         }
         return result;
     }

package/source/Experiment/SingleRunWithK.ts

@@ -4,24 +4,39 @@ import {KFoldCrossValidation} from "nlptoolkit-sampling/dist/KFoldCrossValidatio
 import {Instance} from "../Instance/Instance";
 import {Performance} from "../Performance/Performance";
 import {InstanceList} from "../InstanceList/InstanceList";
-import {Classifier} from "../Classifier/Classifier";
 import {Parameter} from "../Parameter/Parameter";
 import {CrossValidation} from "nlptoolkit-sampling/dist/CrossValidation";
+import {Model} from "../Model/Model";
 
 export class SingleRunWithK implements SingleRun{
 
-    private K: number
+    private readonly K: number
 
+    /**
+     * Constructor for SingleRunWithK class. Basically sets K parameter of the K-fold cross-validation.
+     *
+     * @param K K of the K-fold cross-validation.
+     */
     constructor(K: number) {
         this.K = K
     }
 
-    runExperiment(classifier: Classifier,
+    /**
+     * Runs first fold of a K fold cross-validated experiment for the given classifier with the given parameters.
+     * The experiment result will be returned.
+     * @param model Classifier for the experiment
+     * @param parameter Hyperparameters of the classifier of the experiment
+     * @param crossValidation K-fold crossvalidated dataset.
+     * @return The experiment result of the first fold of the K-fold cross-validated experiment.
+     * @throws DiscreteFeaturesNotAllowed If the classifier does not allow discrete features and the dataset contains
+     * discrete features, DiscreteFeaturesNotAllowed will be thrown.
+     */
+    runExperiment(model: Model,
                   parameter: Parameter,
                   crossValidation: CrossValidation<Instance>){
         let trainSet = new InstanceList(crossValidation.getTrainFold(0));
         let testSet = new InstanceList(crossValidation.getTestFold(0));
-        return classifier.singleRun(parameter, trainSet, testSet);
+        return model.singleRun(parameter, trainSet, testSet);
     }
 
     /**
@@ -33,7 +48,7 @@ export class SingleRunWithK implements SingleRun{
     execute(experiment: Experiment): Performance {
         let crossValidation = new KFoldCrossValidation<Instance>(experiment.getDataSet().getInstances(), this.K,
             experiment.getParameter().getSeed());
-        return this.runExperiment(experiment.getClassifier(), experiment.getParameter(), crossValidation);
+        return this.runExperiment(experiment.getmodel(), experiment.getParameter(), crossValidation);
     }
 
 }

package/source/Experiment/StratifiedKFoldRun.ts

@@ -23,7 +23,7 @@ export class StratifiedKFoldRun extends KFoldRun{
     execute(experiment: Experiment): ExperimentPerformance {
         let result = new ExperimentPerformance();
         let crossValidation = new StratifiedKFoldCrossValidation<Instance>(experiment.getDataSet().getClassInstances(), this.K, experiment.getParameter().getSeed());
-        this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation);
+        this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation);
         return result;
     }
 

package/source/Experiment/StratifiedKFoldRunSeparateTest.ts

@@ -27,7 +27,7 @@ export class StratifiedKFoldRunSeparateTest extends KFoldRunSeparateTest{
         let instanceList = experiment.getDataSet().getInstanceList();
         let partition = new Partition(instanceList, 0.25, true);
         let crossValidation = new StratifiedKFoldCrossValidation<Instance>(new Partition(partition.get(1)).getLists(), this.K, experiment.getParameter().getSeed());
-        this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+        this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation, partition.get(0));
         return result;
     }
 }

package/source/Experiment/StratifiedMxKFoldRun.ts

@@ -27,7 +27,7 @@ export class StratifiedMxKFoldRun extends MxKFoldRun{
         for (let j = 0; j < this.M; j++) {
             let crossValidation = new StratifiedKFoldCrossValidation<Instance>(experiment.getDataSet().getClassInstances(),
                 this.K, experiment.getParameter().getSeed());
-            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation);
+            this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation);
         }
         return result;
     }

package/source/Experiment/StratifiedMxKFoldRunSeparateTest.ts

@@ -28,12 +28,12 @@ export class StratifiedMxKFoldRunSeparateTest extends StratifiedKFoldRunSeparate
      */
     execute(experiment: Experiment): ExperimentPerformance {
         let result = new ExperimentPerformance();
+        let instanceList = experiment.getDataSet().getInstanceList();
+        let partition = new Partition(instanceList, 0.25, true);
         for (let j = 0; j < this.M; j++) {
-            let instanceList = experiment.getDataSet().getInstanceList();
-            let partition = new Partition(instanceList, 0.25, true);
             let crossValidation = new StratifiedKFoldCrossValidation<Instance>(new Partition(partition.get(1)).getLists(),
                 this.K, experiment.getParameter().getSeed());
-            this.runExperiment(experiment.getClassifier(), experiment.getParameter(), result, crossValidation, partition.get(0));
+            this.runExperiment(experiment.getmodel(), experiment.getParameter(), result, crossValidation, partition.get(0));
         }
         return result;
     }

package/source/Experiment/StratifiedSingleRunWithK.ts

@@ -28,6 +28,6 @@ export class StratifiedSingleRunWithK {
             this.K, experiment.getParameter().getSeed());
         let trainSet = new InstanceList(crossValidation.getTrainFold(0));
         let testSet = new InstanceList(crossValidation.getTestFold(0));
-        return experiment.getClassifier().singleRun(experiment.getParameter(), trainSet, testSet);
+        return experiment.getmodel().singleRun(experiment.getParameter(), trainSet, testSet);
     }
 }

package/source/Filter/LaryFilter.ts

@@ -10,7 +10,7 @@ export abstract class LaryFilter extends FeatureFilter{
     /**
      * Constructor that sets the dataSet and all the attributes distributions.
      *
-     * @param dataSet DataSet that will bu used.
+     * @param dataSet DataSet that will be used.
      */
     constructor(dataSet: DataSet) {
         super(dataSet);

package/source/Filter/TrainedFeatureFilter.ts

@@ -8,7 +8,7 @@ export abstract class TrainedFeatureFilter extends FeatureFilter{
     /**
      * Constructor that sets the dataSet.
      *
-     * @param dataSet DataSet that will bu used.
+     * @param dataSet DataSet that will be used.
      */
     constructor(dataSet: DataSet) {
         super(dataSet);

package/source/InstanceList/Partition.ts

@@ -10,81 +10,141 @@ export class Partition {
 
     private multiList: Array<InstanceList> = new Array<InstanceList>()
 
+    /**
+     * Divides the instances in the instance list into partitions so that all instances of a class are grouped in a
+     * single partition.
+     * @param instanceList Instance list for which partition will be created.
+     */
+    constructor1(instanceList: InstanceList){
+        let classLabels = instanceList.getDistinctClassLabels();
+        for (let classLabel of classLabels){
+            this.add(new InstanceListOfSameClass(classLabel));
+        }
+        for (let instance of instanceList.getInstances()) {
+            this.get(classLabels.indexOf(instance.getClassLabel())).add(instance);
+        }
+    }
+
+    /**
+     * Creates a partition depending on the distinct values of a discrete attribute. If the discrete attribute has 4
+     * distinct values, the resulting partition will have 4 groups, where each group contain instance whose
+     * values of that discrete attribute are the same.
+     *
+     * @param instanceList Instance list for which partition will be created.
+     * @param attributeIndex Index of the discrete attribute.
+     */
+    constructor2(instanceList: InstanceList, attributeIndex: number){
+        let valueList = instanceList.getAttributeValueList(attributeIndex);
+        for (let value of valueList) {
+            this.add(new InstanceList());
+        }
+        for (let instance of instanceList.getInstances()) {
+            this.get(valueList.indexOf((<DiscreteAttribute> instance.getAttribute(attributeIndex)).getValue())).add(instance);
+        }
+    }
+
+    /**
+     * Creates a stratified partition of the current instance list. In a stratified partition, the percentage of each
+     * class is preserved. For example, let's say there are three classes in the instance list, and let the percentages of
+     * these classes be %20, %30, and %50; then the percentages of these classes in the stratified partitions are the
+     * same, that is, %20, %30, and %50.
+     *
+     * @param instanceList Instance list for which partition will be created.
+     * @param ratio Ratio of the stratified partition. Ratio is between 0 and 1. If the ratio is 0.2, then 20 percent
+     *              of the instances are put in the first group, 80 percent of the instances are put in the second group.
+     * @param random random is used as a random number.
+     * @param stratified If true, stratified partition is obtained.
+     */
+    constructor3(instanceList: InstanceList, ratio: number, random: Random, stratified: boolean){
+        this.add(new InstanceList());
+        this.add(new InstanceList());
+        if (stratified){
+            let distribution = instanceList.classDistribution();
+            let counts = new Array<number>(distribution.size).fill(0)
+            let randomArray = new Array<number>()
+            for (let i = 0; i < instanceList.size(); i++){
+                randomArray.push(i);
+            }
+            if (random != undefined){
+                random.shuffle(randomArray)
+            }
+            for (let i = 0; i < instanceList.size(); i++) {
+                let instance = instanceList.get(randomArray[i]);
+                let classIndex = distribution.getIndex(instance.getClassLabel());
+                if (counts[classIndex] < instanceList.size() * ratio * distribution.getProbability(instance.getClassLabel())) {
+                    this.get(0).add(instance);
+                } else {
+                    this.get(1).add(instance);
+                }
+                counts[classIndex]++;
+            }
+        } else {
+            instanceList.shuffle(random)
+            for (let i = 0; i < instanceList.size(); i++) {
+                let instance = instanceList.get(i);
+                if (i < instanceList.size() * ratio) {
+                    this.get(0).add(instance);
+                } else {
+                    this.get(1).add(instance);
+                }
+            }
+        }
+    }
+
+    /**
+     * Creates a partition depending on the distinct values of a discrete indexed attribute.
+     *
+     * @param instanceList Instance list for which partition will be created.
+     * @param attributeIndex Index of the discrete indexed attribute.
+     * @param attributeValue Value of the attribute.
+     */
+    constructor4(instanceList: InstanceList, attributeIndex: number, attributeValue: number){
+        this.add(new InstanceList());
+        this.add(new InstanceList());
+        for (let instance of instanceList.getInstances()) {
+            if ((<DiscreteIndexedAttribute> instance.getAttribute(attributeIndex)).getIndex() == attributeValue) {
+                this.get(0).add(instance);
+            } else {
+                this.get(1).add(instance);
+            }
+        }
+    }
+
+    /**
+     * Creates a two group partition depending on the values of a continuous attribute. If the value of the attribute is
+     * less than splitValue, the instance is forwarded to the first group, else it is forwarded to the second group.
+     *
+     * @param instanceList Instance list for which partition will be created.
+     * @param attributeIndex Index of the continuous attribute
+     * @param splitValue     Threshold to divide instances
+     */
+    constructor5(instanceList: InstanceList, attributeIndex: number, splitValue: number){
+        this.add(new InstanceList());
+        this.add(new InstanceList());
+        for (let instance of instanceList.getInstances()) {
+            if ((<ContinuousAttribute> instance.getAttribute(attributeIndex)).getValue() <= splitValue) {
+                this.get(0).add(instance);
+            } else {
+                this.get(1).add(instance);
+            }
+        }
+    }
+
     constructor(instanceList?: InstanceList, attributeIndex?: number, stratifiedOrValue?: any, random?: Random) {
         if (instanceList != undefined){
             if (attributeIndex == undefined){
-                let classLabels = instanceList.getDistinctClassLabels();
-                for (let classLabel of classLabels){
-                    this.add(new InstanceListOfSameClass(classLabel));
-                }
-                for (let instance of instanceList.getInstances()) {
-                    this.get(classLabels.indexOf(instance.getClassLabel())).add(instance);
-                }
+                this.constructor1(instanceList);
             } else {
                 if (stratifiedOrValue == undefined){
-                    let valueList = instanceList.getAttributeValueList(attributeIndex);
-                    for (let value of valueList) {
-                        this.add(new InstanceList());
-                    }
-                    for (let instance of instanceList.getInstances()) {
-                        this.get(valueList.indexOf((<DiscreteAttribute> instance.getAttribute(attributeIndex)).getValue())).add(instance);
-                    }
+                    this.constructor2(instanceList, attributeIndex)
                 } else {
                     if (typeof stratifiedOrValue == "boolean"){
-                        this.add(new InstanceList());
-                        this.add(new InstanceList());
-                        if (stratifiedOrValue){
-                            let distribution = instanceList.classDistribution();
-                            let counts = new Array<number>(distribution.size).fill(0)
-                            let randomArray = new Array<number>()
-                            for (let i = 0; i < instanceList.size(); i++){
-                                randomArray.push(i);
-                            }
-                            if (random != undefined){
-                                random.shuffle(randomArray)
-                            }
-                            for (let i = 0; i < instanceList.size(); i++) {
-                                let instance = instanceList.get(randomArray[i]);
-                                let classIndex = distribution.getIndex(instance.getClassLabel());
-                                let ratio = attributeIndex
-                                if (counts[classIndex] < instanceList.size() * ratio * distribution.getProbability(instance.getClassLabel())) {
-                                    this.get(0).add(instance);
-                                } else {
-                                    this.get(1).add(instance);
-                                }
-                                counts[classIndex]++;
-                            }
-                        } else {
-                            instanceList.shuffle(random)
-                            for (let i = 0; i < instanceList.size(); i++) {
-                                let instance = instanceList.get(i);
-                                let ratio = attributeIndex
-                                if (i < instanceList.size() * ratio) {
-                                    this.get(0).add(instance);
-                                } else {
-                                    this.get(1).add(instance);
-                                }
-                            }
-                        }
+                        this.constructor3(instanceList, attributeIndex, random, stratifiedOrValue)
                     } else {
-                        this.add(new InstanceList());
-                        this.add(new InstanceList());
                         if (Number.isInteger(stratifiedOrValue)){
-                            for (let instance of instanceList.getInstances()) {
-                                if ((<DiscreteIndexedAttribute> instance.getAttribute(attributeIndex)).getIndex() == stratifiedOrValue) {
-                                    this.get(0).add(instance);
-                                } else {
-                                    this.get(1).add(instance);
-                                }
-                            }
+                            this.constructor4(instanceList, attributeIndex, stratifiedOrValue);
                         } else {
-                            for (let instance of instanceList.getInstances()) {
-                                if ((<ContinuousAttribute> instance.getAttribute(attributeIndex)).getValue() <= stratifiedOrValue) {
-                                    this.get(0).add(instance);
-                                } else {
-                                    this.get(1).add(instance);
-                                }
-                            }
+                            this.constructor5(instanceList, attributeIndex, stratifiedOrValue);
                         }
                     }
                 }

package/source/Model/DecisionTree/DecisionCondition.ts

@@ -23,10 +23,18 @@ export class DecisionCondition {
         this.value = value;
     }
 
+    /**
+     * Accessor for the attribute index.
+     * @return Attribute index.
+     */
     getAttributeIndex(): number{
         return this.attributeIndex
     }
 
+    /**
+     * Accessor for the value.
+     * @return Value.
+     */
     getValue(): Attribute{
         return this.value
     }