nlptoolkit-classification 1.0.6 → 1.0.8

package/source/Model/Parametric/KMeansModel.ts

@@ -0,0 +1,72 @@
+import {GaussianModel} from "./GaussianModel";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {DistanceMetric} from "../../DistanceMetric/DistanceMetric";
+import {Instance} from "../../Instance/Instance";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {EuclidianDistance} from "../../DistanceMetric/EuclidianDistance";
+import {Parameter} from "../../Parameter/Parameter";
+import {Partition} from "../../InstanceList/Partition";
+import {KMeansParameter} from "../../Parameter/KMeansParameter";
+
+export class KMeansModel extends GaussianModel{
+
+    private classMeans: InstanceList
+    private distanceMetric: DistanceMetric
+
+    /**
+     * Loads a K-means model from an input model file.
+     * @param fileName Model file name.
+     */
+    constructor2(fileName: string) {
+        this.distanceMetric = new EuclidianDistance()
+        let input = new FileContents(fileName)
+        this.loadPriorDistribution(input)
+        this.classMeans = this.loadInstanceList(input)
+    }
+
+    /**
+     * The calculateMetric method takes an {@link Instance} and a String as inputs. It loops through the class means, if
+     * the corresponding class label is same as the given String it returns the negated distance between given instance and the
+     * current item of class means. Otherwise it returns the smallest negative number.
+     *
+     * @param instance {@link Instance} input.
+     * @param Ci       String input.
+     * @return The negated distance between given instance and the current item of class means.
+     */
+    calculateMetric(instance: Instance, Ci: string): number {
+        for (let i = 0; i < this.classMeans.size(); i++) {
+            if (this.classMeans.get(i).getClassLabel() == Ci) {
+                return -this.distanceMetric.distance(instance, this.classMeans.get(i));
+            }
+        }
+        return Number.NEGATIVE_INFINITY;
+    }
+
+    saveTxt(fileName: string){
+    }
+
+    /**
+     * Training algorithm for K-Means classifier. K-Means finds the mean of each class for training.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters distanceMetric: distance metric used to calculate the distance between two instances.
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        this.priorDistribution = trainSet.classDistribution();
+        this.classMeans = new InstanceList();
+        let classLists = new Partition(trainSet);
+        for (let i = 0; i < classLists.size(); i++) {
+            this.classMeans.add(classLists.get(i).average());
+        }
+        this.distanceMetric = (<KMeansParameter> parameters).getDistanceMetric()
+    }
+
+    /**
+     * Loads the K-means model from an input file.
+     * @param fileName File name of the K-means model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
+}

package/source/Model/Parametric/LdaModel.ts

@@ -0,0 +1,98 @@
+import {GaussianModel} from "./GaussianModel";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {Instance} from "../../Instance/Instance";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {Parameter} from "../../Parameter/Parameter";
+import {Partition} from "../../InstanceList/Partition";
+import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {InstanceListOfSameClass} from "../../InstanceList/InstanceListOfSameClass";
+
+export class LdaModel extends GaussianModel{
+
+    protected w0: Map<string, number>
+    protected w: Map<string, Vector>
+
+    /**
+     * Loads a Linear Discriminant Analysis model from an input model file.
+     * @param fileName Model file name.
+     */
+    constructor2(fileName: string) {
+        let input = new FileContents(fileName)
+        let size = this.loadPriorDistribution(input)
+        this.loadWandW0(input, size)
+    }
+
+    /**
+     * The calculateMetric method takes an {@link Instance} and a String as inputs. It returns the dot product of given Instance
+     * and wi plus w0i.
+     *
+     * @param instance {@link Instance} input.
+     * @param Ci       String input.
+     * @return The dot product of given Instance and wi plus w0i.
+     */
+    calculateMetric(instance: Instance, Ci: string): number {
+        let xi = instance.toVector();
+        let wi = this.w.get(Ci);
+        let w0i = this.w0.get(Ci);
+        return wi.dotProduct(xi) + w0i;
+    }
+
+    /**
+     * Loads w0 and w hash maps from an input file. The number of items in the hash map is given by the parameter size.
+     * @param input Input file
+     * @param size Number of items in the hash map read.
+     * @throws IOException If the file can not be read, it throws IOException.
+     */
+    loadWandW0(input: FileContents, size: number){
+        this.w0 = new Map<string, number>()
+        for (let i = 0; i < size; i++){
+            let line = input.readLine()
+            let items = line.split(" ")
+            this.w0.set(items[0], parseFloat(items[1]))
+        }
+        this.w = this.loadVectors(input, size)
+    }
+
+    saveTxt(fileName: string){
+    }
+
+    /**
+     * Training algorithm for the linear discriminant analysis classifier (Introduction to Machine Learning, Alpaydin, 2015).
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        this.w0 = new Map<string, number>();
+        this.w = new Map<string, Vector>();
+        this.priorDistribution = trainSet.classDistribution();
+        let classLists = new Partition(trainSet);
+        let covariance = new Matrix(trainSet.get(0).continuousAttributeSize(), trainSet.get(0).continuousAttributeSize());
+        for (let i = 0; i < classLists.size(); i++) {
+            let averageVector = new Vector(classLists.get(i).continuousAttributeAverage());
+            let classCovariance = classLists.get(i).covariance(averageVector);
+            classCovariance.multiplyWithConstant(classLists.get(i).size() - 1);
+            covariance.add(classCovariance);
+        }
+        covariance.divideByConstant(trainSet.size() - classLists.size());
+        covariance.inverse();
+        for (let i = 0; i < classLists.size(); i++) {
+            let Ci = (<InstanceListOfSameClass> classLists.get(i)).getClassLabel();
+            let averageVector = new Vector(classLists.get(i).continuousAttributeAverage());
+            let wi = covariance.multiplyWithVectorFromRight(averageVector);
+            this.w.set(Ci, wi);
+            let w0i = -0.5 * wi.dotProduct(averageVector) + Math.log(this.priorDistribution.getProbability(Ci));
+            this.w0.set(Ci, w0i);
+        }
+    }
+
+    /**
+     * Loads the Lda model from an input file.
+     * @param fileName File name of the Lda model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
+}

package/source/Model/{NaiveBayesModel.ts → Parametric/NaiveBayesModel.ts}

@@ -1,40 +1,30 @@
 import {GaussianModel} from "./GaussianModel";
-import {Instance} from "../Instance/Instance";
+import {Instance} from "../../Instance/Instance";
 import {Vector} from "nlptoolkit-math/dist/Vector";
 import {DiscreteDistribution} from "nlptoolkit-math/dist/DiscreteDistribution";
-import {ContinuousAttribute} from "../Attribute/ContinuousAttribute";
-import {DiscreteAttribute} from "../Attribute/DiscreteAttribute";
+import {ContinuousAttribute} from "../../Attribute/ContinuousAttribute";
+import {DiscreteAttribute} from "../../Attribute/DiscreteAttribute";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {Partition} from "../../InstanceList/Partition";
+import {InstanceListOfSameClass} from "../../InstanceList/InstanceListOfSameClass";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {Parameter} from "../../Parameter/Parameter";
 
 export class NaiveBayesModel extends GaussianModel{
 
     private classMeans: Map<string, Vector> = undefined
     private classDeviations: Map<string, Vector> = undefined
-    private readonly classAttributeDistributions: Map<string, Array<DiscreteDistribution>> = undefined
+    private classAttributeDistributions: Map<string, Array<DiscreteDistribution>> = undefined
 
     /**
-     * A constructor that sets the priorDistribution, classMeans and classDeviations.
-     *
-     * @param priorDistribution {@link DiscreteDistribution} input.
-     * @param classMeans        A {@link Map} of String and {@link Vector}.
-     * @param classDeviations   A {@link Map} of String and {@link Vector}.
+     * Loads a naive Bayes model from an input model file.
+     * @param fileName Model file name.
      */
-    constructor(priorDistribution: DiscreteDistribution | string, classMeans?: any, classDeviations?: Map<string, Vector>) {
-        super()
-        if (priorDistribution instanceof DiscreteDistribution){
-            this.priorDistribution = priorDistribution
-            if (classDeviations != undefined){
-                this.classMeans = classMeans
-                this.classDeviations = classDeviations
-            } else {
-                this.classAttributeDistributions = classMeans
-            }
-        } else {
-            let input = new FileContents(priorDistribution)
-            let size = this.loadPriorDistribution(input)
-            this.classMeans = this.loadVectors(input, size)
-            this.classDeviations = this.loadVectors(input, size)
-        }
+    constructor3(fileName: string) {
+        let input = new FileContents(fileName)
+        let size = this.loadPriorDistribution(input)
+        this.classMeans = this.loadVectors(input, size)
+        this.classDeviations = this.loadVectors(input, size)
     }
 
     /**
@@ -98,4 +88,57 @@ export class NaiveBayesModel extends GaussianModel{
     saveTxt(fileName: string){
     }
 
+    /**
+     * Training algorithm for Naive Bayes algorithm with a continuous data set.
+     *
+     * @param classLists        Instances are divided into K lists, where each list contains only instances from a single class
+     */
+    private trainContinuousVersion(classLists: Partition){
+        this.classMeans = new Map<string, Vector>();
+        this.classDeviations = new Map<string, Vector>();
+        for (let i = 0; i < classLists.size(); i++){
+            let classLabel = (<InstanceListOfSameClass> classLists.get(i)).getClassLabel();
+            let averageVector = classLists.get(i).average().toVector();
+            this.classMeans.set(classLabel, averageVector);
+            let standardDeviationVector = classLists.get(i).standardDeviation().toVector();
+            this.classDeviations.set(classLabel, standardDeviationVector);
+        }
+    }
+
+    /**
+     * Training algorithm for Naive Bayes algorithm with a discrete data set.
+     * @param classLists Instances are divided into K lists, where each list contains only instances from a single class
+     */
+    private trainDiscreteVersion(classLists: Partition){
+        this.classAttributeDistributions = new Map<string, Array<DiscreteDistribution>>();
+        for (let i = 0; i < classLists.size(); i++){
+            this.classAttributeDistributions.set((<InstanceListOfSameClass> classLists.get(i)).getClassLabel(),
+                classLists.get(i).allAttributesDistribution());
+        }
+    }
+
+    /**
+     * Training algorithm for Naive Bayes algorithm. It basically calls trainContinuousVersion for continuous data sets,
+     * trainDiscreteVersion for discrete data sets.
+     * @param trainSet Training data given to the algorithm
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        this.priorDistribution = trainSet.classDistribution();
+        let classLists = new Partition(trainSet);
+        if (classLists.get(0).get(0).getAttribute(0) instanceof DiscreteAttribute){
+            this.trainDiscreteVersion(classLists);
+        } else {
+            this.trainContinuousVersion(classLists);
+        }
+    }
+
+    /**
+     * Loads the naive Bayes model from an input file.
+     * @param fileName File name of the naive Bayes model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor3(fileName)
+    }
+
 }

package/source/Model/Parametric/QdaModel.ts

@@ -0,0 +1,83 @@
+import {LdaModel} from "./LdaModel";
+import {Matrix} from "nlptoolkit-math/dist/Matrix";
+import {Vector} from "nlptoolkit-math/dist/Vector";
+import {Instance} from "../../Instance/Instance";
+import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {InstanceList} from "../../InstanceList/InstanceList";
+import {Parameter} from "../../Parameter/Parameter";
+import {Partition} from "../../InstanceList/Partition";
+import {InstanceListOfSameClass} from "../../InstanceList/InstanceListOfSameClass";
+
+export class QdaModel extends LdaModel{
+
+    private W: Map<string, Matrix>
+
+    constructor2(fileName: string) {
+        let input = new FileContents(fileName)
+        let size = this.loadPriorDistribution(input)
+        this.loadWandW0(input, size)
+        this.W = new Map<string, Matrix>()
+        for (let i = 0; i < size; i++){
+            let c = input.readLine()
+            let matrix = this.loadMatrix(input)
+            this.W.set(c, matrix)
+        }
+    }
+
+    /**
+     * The calculateMetric method takes an {@link Instance} and a String as inputs. It multiplies Matrix Wi with Vector xi
+     * then calculates the dot product of it with xi. Then, again it finds the dot product of wi and xi and returns the summation with w0i.
+     *
+     * @param instance {@link Instance} input.
+     * @param Ci       String input.
+     * @return The result of Wi.multiplyWithVectorFromLeft(xi).dotProduct(xi) + wi.dotProduct(xi) + w0i.
+     */
+    calculateMetric(instance: Instance, Ci: string): number {
+        let xi = instance.toVector();
+        let Wi = this.W.get(Ci);
+        let wi = this.w.get(Ci);
+        let w0i = this.w0.get(Ci);
+        return Wi.multiplyWithVectorFromLeft(xi).dotProduct(xi) + wi.dotProduct(xi) + w0i;
+    }
+
+    saveTxt(fileName: string){
+    }
+
+    /**
+     * Training algorithm for the quadratic discriminant analysis classifier (Introduction to Machine Learning, Alpaydin, 2015).
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter) {
+        let determinant = 0
+        this.w0 = new Map<string, number>();
+        this.w = new Map<string, Vector>();
+        this.W = new Map<string, Matrix>();
+        let classLists = new Partition(trainSet);
+        this.priorDistribution = trainSet.classDistribution();
+        for (let i = 0; i < classLists.size(); i++) {
+            let Ci = (<InstanceListOfSameClass> classLists.get(i)).getClassLabel();
+            let averageVector = new Vector(classLists.get(i).continuousAttributeAverage());
+            let classCovariance = classLists.get(i).covariance(averageVector);
+            determinant = classCovariance.determinant();
+            classCovariance.inverse();
+            let Wi = classCovariance.clone();
+            Wi.multiplyWithConstant(-0.5);
+            this.W.set(Ci, Wi);
+            let wi = classCovariance.multiplyWithVectorFromLeft(averageVector);
+            this.w.set(Ci, wi);
+            let w0i = -0.5 * (wi.dotProduct(averageVector) + Math.log(determinant)) + Math.log(this.priorDistribution.getProbability(Ci));
+            this.w0.set(Ci, w0i);
+        }
+    }
+
+    /**
+     * Loads the Qda model from an input file.
+     * @param fileName File name of the Qda model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
+}

package/source/Model/RandomModel.ts

@@ -3,28 +3,39 @@ import {Instance} from "../Instance/Instance";
 import {CompositeInstance} from "../Instance/CompositeInstance";
 import {Random} from "nlptoolkit-util/dist/Random";
 import {FileContents} from "nlptoolkit-util/dist/FileContents";
+import {InstanceList} from "../InstanceList/InstanceList";
+import {Parameter} from "../Parameter/Parameter";
 
 export class RandomModel extends Model{
 
-    private readonly classLabels: Array<string>
+    private classLabels: Array<string>
     private random: Random
     private seed: number
 
-    constructor(classLabelsOrFileName: Array<string> | string, seed?: number) {
-        super();
-        if (classLabelsOrFileName instanceof Array){
-            this.classLabels = classLabelsOrFileName
-            this.random = new Random(seed)
-            this.seed = seed
-        } else {
-            let input = new FileContents(classLabelsOrFileName)
-            seed = parseInt(input.readLine())
-            this.random = new Random(seed)
-            let size = parseInt(input.readLine())
-            this.classLabels = new Array<string>()
-            for (let i = 0; i < size; i++){
-                this.classLabels.push(input.readLine())
-            }
+    /**
+     * A constructor that sets the class labels.
+     *
+     * @param classLabels An ArrayList of class labels.
+     * @param seed Seed of the random function.
+     */
+    constructor1(classLabels: Array<string>, seed: number) {
+        this.classLabels = classLabels
+        this.random = new Random(seed)
+        this.seed = seed
+    }
+
+    /**
+     * Loads a random classifier model from an input model file.
+     * @param fileName Model file name.
+     */
+    constructor2(fileName: string) {
+        let input = new FileContents(fileName)
+        this.seed = parseInt(input.readLine())
+        this.random = new Random(this.seed)
+        let size = parseInt(input.readLine())
+        this.classLabels = new Array<string>()
+        for (let i = 0; i < size; i++){
+            this.classLabels.push(input.readLine())
         }
     }
 
@@ -48,6 +59,11 @@ export class RandomModel extends Model{
         }
     }
 
+    /**
+     * Calculates the posterior probability distribution for the given instance according to random model.
+     * @param instance Instance for which posterior probability distribution is calculated.
+     * @return Posterior probability distribution for the given instance.
+     */
     predictProbability(instance: Instance): Map<string, number> {
         let result = new Map<string, number>();
         for (let classLabel of this.classLabels){
@@ -59,4 +75,26 @@ export class RandomModel extends Model{
     saveTxt(fileName: string){
     }
 
+    /**
+     * Training algorithm for random classifier.
+     *
+     * @param trainSet   Training data given to the algorithm.
+     * @param parameters -
+     */
+    train(trainSet: InstanceList, parameters: Parameter): void {
+        let result = new Array<string>()
+        for (let s of trainSet.classDistribution().keys()){
+            result.push(s)
+        }
+        this.constructor1(result, parameters.getSeed());
+    }
+
+    /**
+     * Loads the random classifier model from an input file.
+     * @param fileName File name of the random classifier model.
+     */
+    loadModel(fileName: string): void{
+        this.constructor2(fileName)
+    }
+
 }

package/source/Parameter/C45Parameter.ts

@@ -2,8 +2,8 @@ import {Parameter} from "./Parameter";
 
 export class C45Parameter extends Parameter{
 
-    private prune: boolean
-    private crossValidationRatio: number
+    private readonly prune: boolean
+    private readonly crossValidationRatio: number
 
     /**
      * Parameters of the C4.5 univariate decision tree classifier.

package/source/Parameter/DeepNetworkParameter.ts

@@ -2,8 +2,8 @@ import {LinearPerceptronParameter} from "./LinearPerceptronParameter";
 import {ActivationFunction} from "./ActivationFunction";
 
 export class DeepNetworkParameter extends LinearPerceptronParameter{
-    private hiddenLayers: Array<number>
-    private activationFunction: ActivationFunction
+    private readonly hiddenLayers: Array<number>
+    private readonly activationFunction: ActivationFunction
 
     /**
      * Parameters of the deep network classifier.

package/source/Parameter/KnnParameter.ts

@@ -3,7 +3,7 @@ import {DistanceMetric} from "../DistanceMetric/DistanceMetric";
 
 export class KnnParameter extends KMeansParameter{
 
-    private k: number
+    private readonly k: number
 
     /**
      * Parameters of the K-nearest neighbor classifier.

package/source/Parameter/LinearPerceptronParameter.ts

@@ -2,10 +2,10 @@ import {Parameter} from "./Parameter";
 
 export class LinearPerceptronParameter extends Parameter{
 
-    private learningRate: number
-    private etaDecrease: number
-    private crossValidationRatio: number
-    private epoch: number
+    private readonly learningRate: number
+    private readonly etaDecrease: number
+    private readonly crossValidationRatio: number
+    private readonly epoch: number
 
     /**
      * Parameters of the linear perceptron algorithm.

package/source/Parameter/MultiLayerPerceptronParameter.ts

@@ -3,8 +3,8 @@ import {ActivationFunction} from "./ActivationFunction";
 
 export class MultiLayerPerceptronParameter extends LinearPerceptronParameter{
 
-    private hiddenNodes: number
-    private activationFunction: ActivationFunction
+    private readonly hiddenNodes: number
+    private readonly activationFunction: ActivationFunction
 
     /**
      * Parameters of the multi layer perceptron algorithm.

package/source/Parameter/Parameter.ts

@@ -1,6 +1,6 @@
 export class Parameter {
 
-    private seed: number
+    private readonly seed: number
 
     /**
      * Constructor of {@link Parameter} class which assigns given seed value to seed.

package/source/Performance/ConfusionMatrix.ts

@@ -3,7 +3,7 @@ import {CounterHashMap} from "nlptoolkit-datastructure/dist/CounterHashMap";
 export class ConfusionMatrix {
 
     private matrix: Map<string, CounterHashMap<string>> = new Map<string, CounterHashMap<string>>()
-    private classLabels: Array<string>
+    private readonly classLabels: Array<string>
 
     /**
      * Constructor that sets the class labels {@link Array} and creates new {@link Map} matrix

package/source/StatisticalTest/Combined5x2F.ts

@@ -5,6 +5,12 @@ import {Distribution} from "nlptoolkit-math/dist/Distribution";
 
 export class Combined5x2F extends PairedTest{
 
+    /**
+     * Calculates the test statistic of the combined 5x2 cv F test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Given the performances of two classifiers, the test statistic of the combined 5x2 cv F test.
+     */
     private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
         let difference = new Array<number>();
         let numerator = 0
@@ -23,6 +29,12 @@ export class Combined5x2F extends PairedTest{
         return numerator / denominator;
     }
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate) using combined 5x2 cv F test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Statistical test result of the comparison.
+     */
     compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
         let statistic = this.testStatistic(classifier1, classifier2);
         let degreeOfFreedom1 = classifier1.numberOfExperiments();

package/source/StatisticalTest/Combined5x2t.ts

@@ -5,6 +5,12 @@ import {Distribution} from "nlptoolkit-math/dist/Distribution";
 
 export class Combined5x2t extends PairedTest{
 
+    /**
+     * Calculates the test statistic of the combined 5x2 cv t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Given the performances of two classifiers, the test statistic of the combined 5x2 cv t test.
+     */
     private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
         let difference = new Array<number>();
         for (let i = 0; i < classifier1.numberOfExperiments(); i++){
@@ -24,6 +30,13 @@ export class Combined5x2t extends PairedTest{
         return numerator / denominator;
     }
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate) using combined 5x2
+     * cv t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Statistical test result of the comparison.
+     */
     compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
         let statistic = this.testStatistic(classifier1, classifier2);
         let degreeOfFreedom = classifier1.numberOfExperiments() / 2;

package/source/StatisticalTest/Paired5x2t.ts

@@ -5,6 +5,12 @@ import {Distribution} from "nlptoolkit-math/dist/Distribution";
 
 export class Paired5x2t extends PairedTest{
 
+    /**
+     * Calculates the test statistic of the 5x2 t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Given the performances of two classifiers, the test statistic of the 5x2 t test.
+     */
     private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
         let difference = new Array<number>();
         let sum = 0.0;
@@ -23,6 +29,12 @@ export class Paired5x2t extends PairedTest{
         return difference[0] / denominator;
     }
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate) using 5x2 t test.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @return Statistical test result of the comparison.
+     */
     compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
         let statistic = this.testStatistic(classifier1, classifier2);
         let degreeOfFreedom = classifier1.numberOfExperiments() / 2;

package/source/StatisticalTest/PairedTest.ts

@@ -6,6 +6,18 @@ export abstract class PairedTest {
 
     abstract compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult
 
+    /**
+     * Compares two classification algorithms based on their performances (accuracy or error rate). The method first
+     * checks the null hypothesis mu1 < mu2, if the test rejects this null hypothesis with alpha level of confidence, it
+     * decides mu1 > mu2. The algorithm then checks the null hypothesis mu1 > mu2, if the test rejects that null
+     * hypothesis with alpha level of confidence, if decides mu1 < mu2. If none of the two tests are rejected, it can not
+     * make a decision about the performances of algorithms.
+     * @param classifier1 Performance (error rate or accuracy) results of the first classifier.
+     * @param classifier2 Performance (error rate or accuracy) results of the second classifier.
+     * @param alpha Alpha level defined for the statistical test.
+     * @return 1 if the performance of the first algorithm is larger than the second algorithm, -1 if the performance of
+     * the second algorithm is larger than the first algorithm, 0 if they have similar performance.
+     */
     compare(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance, alpha: number): number{
         let testResult1 = this.compareClassifiers(classifier1, classifier2);
         let testResult2 = this.compareClassifiers(classifier2, classifier1);