nlptoolkit-classification 1.0.0

package/source/Performance/ConfusionMatrix.ts

@@ -0,0 +1,175 @@
+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>
+
+    /**
+     * Constructor that sets the class labels {@link Array} and creates new {@link Map} matrix
+     *
+     * @param classLabels {@link ArrayList} of String.
+     */
+    constructor(classLabels: Array<string>) {
+        this.classLabels = classLabels
+    }
+
+    /**
+     * The classify method takes two Strings; actual class and predicted class as inputs. If the matrix {@link Map} contains
+     * given actual class String as a key, it then assigns the corresponding object of that key to a {@link CounterHashMap}, if not
+     * it creates a new {@link CounterHashMap}. Then, it puts the given predicted class String to the counterHashMap and
+     * also put this counterHashMap to the matrix {@link Map} together with the given actual class String.
+     *
+     * @param actualClass    String input actual class.
+     * @param predictedClass String input predicted class.
+     */
+    classify(actualClass: string, predictedClass: string){
+        let counterHashMap: CounterHashMap<string>
+        if (this.matrix.has(actualClass)){
+            counterHashMap = this.matrix.get(actualClass)
+        } else {
+            counterHashMap = new CounterHashMap<string>()
+        }
+        counterHashMap.put(predictedClass)
+        this.matrix.set(actualClass, counterHashMap)
+    }
+
+    /**
+     * The addConfusionMatrix method takes a {@link ConfusionMatrix} as an input and loops through actual classes of that {@link Map}
+     * and initially gets one row at a time. Then it puts the current row to the matrix {@link Map} together with the actual class string.
+     *
+     * @param confusionMatrix {@link ConfusionMatrix} input.
+     */
+    addConfusionMatrix(confusionMatrix: ConfusionMatrix){
+        for (let actualClass of confusionMatrix.matrix.keys()) {
+            let rowToBeAdded = confusionMatrix.matrix.get(actualClass);
+            if (this.matrix.has(actualClass)) {
+                let currentRow = this.matrix.get(actualClass);
+                currentRow.add(rowToBeAdded);
+                this.matrix.set(actualClass, currentRow);
+            } else {
+                this.matrix.set(actualClass, rowToBeAdded);
+            }
+        }
+    }
+
+    /**
+     * The sumOfElements method loops through the keys in matrix {@link Map} and returns the summation of all the values of the keys.
+     * I.e: TP+TN+FP+FN.
+     *
+     * @return The summation of values.
+     */
+    private sumOfElements(): number{
+        let result = 0;
+        for (let actualClass of this.matrix.keys()) {
+            result += this.matrix.get(actualClass).sumOfCounts();
+        }
+        return result;
+    }
+
+    /**
+     * The trace method loops through the keys in matrix {@link Map} and if the current key contains the actual key,
+     * it accumulates the corresponding values. I.e: TP+TN.
+     *
+     * @return Summation of values.
+     */
+    private trace(): number{
+        let result = 0;
+        for (let actualClass of this.matrix.keys()) {
+            if (this.matrix.get(actualClass).has(actualClass)) {
+                result += this.matrix.get(actualClass).get(actualClass);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * The columnSum method takes a String predicted class as input, and loops through the keys in matrix {@link HashMap}.
+     * If the current key contains the predicted class String, it accumulates the corresponding values. I.e: TP+FP.
+     *
+     * @param predictedClass String input predicted class.
+     * @return Summation of values.
+     */
+    private columnSum(predictedClass: string): number{
+        let result = 0;
+        for (let actualClass of this.matrix.keys()) {
+            if (this.matrix.get(actualClass).has(predictedClass)) {
+                result += this.matrix.get(actualClass).get(predictedClass);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * The getAccuracy method returns the result of  TP+TN / TP+TN+FP+FN
+     *
+     * @return the result of  TP+TN / TP+TN+FP+FN
+     */
+    getAccuracy(): number{
+        return this.trace() / this.sumOfElements()
+    }
+
+    /**
+     * The precision method loops through the class labels and returns the resulting Array which has the result of TP/FP+TP.
+     *
+     * @return The result of TP/FP+TP.
+     */
+    precision(): Array<number>{
+        let result = new Array<number>(this.classLabels.length).fill(0)
+        for (let i = 0; i < this.classLabels.length; i++) {
+            let actualClass = this.classLabels[i];
+            if (this.matrix.has(actualClass)) {
+                result[i] = this.matrix.get(actualClass).get(actualClass) / this.columnSum(actualClass);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * The recall method loops through the class labels and returns the resulting Array which has the result of TP/FN+TP.
+     *
+     * @return The result of TP/FN+TP.
+     */
+    recall(): Array<number>{
+        let result = new Array<number>(this.classLabels.length).fill(0)
+        for (let i = 0; i < this.classLabels.length; i++) {
+            let actualClass = this.classLabels[i];
+            if (this.matrix.has(actualClass)) {
+                result[i] = this.matrix.get(actualClass).get(actualClass) / this.matrix.get(actualClass).sumOfCounts();
+            }
+        }
+        return result;
+    }
+
+    /**
+     * The fMeasure method loops through the class labels and returns the resulting Array which has the average of
+     * recall and precision.
+     *
+     * @return The average of recall and precision.
+     */
+    fMeasure(): Array<number>{
+        let precision = this.precision();
+        let recall = this.recall();
+        let result = new Array<number>(this.classLabels.length).fill(0)
+        for (let i = 0; i < this.classLabels.length; i++) {
+            result[i] = 2 / (1 / precision[i] + 1 / recall[i]);
+        }
+        return result;
+    }
+
+    /**
+     * The weightedFMeasure method loops through the class labels and returns the resulting Array which has the weighted average of
+     * recall and precision.
+     *
+     * @return The weighted average of recall and precision.
+     */
+    weightedFMeasure(): number{
+        let fMeasure = this.fMeasure();
+        let sum = 0;
+        for (let i = 0; i < this.classLabels.length; i++) {
+            let actualClass = this.classLabels[i];
+            sum += fMeasure[i] * this.matrix.get(actualClass).sumOfCounts();
+        }
+        return sum / this.sumOfElements();
+    }
+}

package/source/Performance/DetailedClassificationPerformance.ts

@@ -0,0 +1,26 @@
+import {ClassificationPerformance} from "./ClassificationPerformance";
+import {ConfusionMatrix} from "./ConfusionMatrix";
+
+export class DetailedClassificationPerformance extends ClassificationPerformance{
+
+    private readonly confusionMatrix: ConfusionMatrix
+
+    /**
+     * A constructor that  sets the accuracy and errorRate as 1 - accuracy via given {@link ConfusionMatrix} and also sets the confusionMatrix.
+     *
+     * @param confusionMatrix {@link ConfusionMatrix} input.
+     */
+    constructor(confusionMatrix: ConfusionMatrix) {
+        super(confusionMatrix.getAccuracy());
+        this.confusionMatrix = confusionMatrix
+    }
+
+    /**
+     * Accessor for the confusionMatrix.
+     *
+     * @return ConfusionMatrix.
+     */
+    getConfusionMatrix(): ConfusionMatrix{
+        return this.confusionMatrix
+    }
+}

package/source/Performance/ExperimentPerformance.ts

@@ -0,0 +1,175 @@
+import {Performance} from "./Performance";
+import * as fs from "fs";
+import {DetailedClassificationPerformance} from "./DetailedClassificationPerformance";
+import {ClassificationPerformance} from "./ClassificationPerformance";
+
+export class ExperimentPerformance {
+
+    private results: Array<Performance> = new Array<Performance>()
+    private containsDetails: boolean = true
+    private classification: boolean = true
+
+    /**
+     * A constructor that takes a file name as an input and takes the inputs from that file assigns these inputs to the
+     * errorRate and adds them to the results {@link Array} as a new {@link Performance}.
+     *
+     * @param fileName String input.
+     */
+    constructor(fileName?: string) {
+        if (fileName != undefined){
+            let data = fs.readFileSync(fileName, 'utf8')
+            let lines = data.split("\n")
+            for (let line of lines){
+                this.results.push(new Performance(Number.parseFloat(line)))
+            }
+        }
+    }
+
+    /**
+     * The add method takes a {@link Performance} as an input and adds it to the results {@link Array}.
+     *
+     * @param performance {@link Performance} input.
+     */
+    add(performance: Performance){
+        if (!(performance instanceof DetailedClassificationPerformance)){
+            this.containsDetails = false
+        }
+        if (!(performance instanceof ClassificationPerformance)){
+            this.classification = false
+        }
+        this.results.push(performance)
+    }
+
+    /**
+     * The numberOfExperiments method returns the size of the results {@link Array}.
+     *
+     * @return The results {@link Array}.
+     */
+    numberOfExperiments(): number{
+        return this.results.length
+    }
+
+    /**
+     * The getErrorRate method takes an index as an input and returns the errorRate at given index of
+     * results {@link Array}.
+     *
+     * @param index Index of results {@link Array} to retrieve.
+     * @return The errorRate at given index of results {@link Array}.
+     */
+    getErrorRate(index: number): number{
+        return this.results[index].getErrorRate()
+    }
+
+    /**
+     * The getAccuracy method takes an index as an input. It returns the accuracy of a {@link Performance} at given
+     * index of results {@link Array}.
+     *
+     * @param index Index of results {@link Array} to retrieve.
+     * @return The accuracy of a {@link Performance} at given index of results {@link Array}.
+     */
+    getAccuracy(index: number): number{
+        if (this.results[index] instanceof ClassificationPerformance){
+            return (<ClassificationPerformance> this.results[index]).getAccuracy()
+        }
+    }
+
+    /**
+     * The meanPerformance method loops through the performances of results {@link Array} and sums up the errorRates
+     * of each then returns a new {@link Performance} with the mean of that summation.
+     *
+     * @return A new {@link Performance} with the mean of the summation of errorRates.
+     */
+    meanPerformance(): Performance{
+        let sumError = 0;
+        for (let performance of this.results) {
+            sumError += performance.getErrorRate();
+        }
+        return new Performance(sumError / this.results.length);
+    }
+
+    /**
+     * The meanClassificationPerformance method loops through the performances of results {@link Array} and sums up the
+     * accuracy of each classification performance, then returns a new classificationPerformance with the mean of that
+     * summation.
+     *
+     * @return A new classificationPerformance with the mean of that summation.
+     */
+    meanClassificationPerformance(): ClassificationPerformance{
+        if (this.results.length == 0 || !this.classification) {
+            return undefined;
+        }
+        let sumAccuracy = 0;
+        for (let performance of  this.results) {
+            let classificationPerformance = <ClassificationPerformance> performance;
+            sumAccuracy += classificationPerformance.getAccuracy();
+        }
+        return new ClassificationPerformance(sumAccuracy / this.results.length);
+    }
+
+    /**
+     * The meanDetailedPerformance method gets the first confusion matrix of results {@link Array}.
+     * Then, it adds new confusion matrices as the {@link DetailedClassificationPerformance} of
+     * other elements of results ArrayList' confusion matrices as a {@link DetailedClassificationPerformance}.
+     *
+     * @return A new {@link DetailedClassificationPerformance} with the {@link ConfusionMatrix} sum.
+     */
+    meanDetailedPerformance(): DetailedClassificationPerformance{
+        if (this.results.length == 0 || !this.containsDetails) {
+            return undefined;
+        }
+        let sum = (<DetailedClassificationPerformance> this.results[0]).getConfusionMatrix();
+        for (let i = 1; i < this.results.length; i++) {
+            sum.addConfusionMatrix((<DetailedClassificationPerformance> this.results[i]).getConfusionMatrix());
+        }
+        return new DetailedClassificationPerformance(sum);
+    }
+
+    /**
+     * The standardDeviationPerformance method loops through the {@link Performance}s of results {@link Array} and
+     * returns a new Performance with the standard deviation.
+     *
+     * @return A new Performance with the standard deviation.
+     */
+    standardDeviationPerformance(): Performance{
+        let sumErrorRate = 0;
+        let averagePerformance = this.meanPerformance();
+        for (let performance of this.results) {
+            sumErrorRate += Math.pow(performance.getErrorRate() - averagePerformance.getErrorRate(), 2);
+        }
+        return new Performance(Math.sqrt(sumErrorRate / (this.results.length - 1)));
+    }
+
+    /**
+     * The standardDeviationClassificationPerformance method loops through the {@link Performance}s of results {@link ArrayList} and
+     * returns a new {@link ClassificationPerformance} with standard deviation.
+     *
+     * @return A new {@link ClassificationPerformance} with standard deviation.
+     */
+    standardDeviationClassificationPerformance(): ClassificationPerformance{
+        if (this.results.length == 0 || !this.classification) {
+            return undefined;
+        }
+        let sumAccuracy = 0, sumErrorRate = 0;
+        let averageClassificationPerformance = this.meanClassificationPerformance();
+        for (let performance of this.results) {
+            let classificationPerformance = <ClassificationPerformance> performance;
+            sumAccuracy += Math.pow(classificationPerformance.getAccuracy() - averageClassificationPerformance.getAccuracy(), 2);
+            sumErrorRate += Math.pow(classificationPerformance.getErrorRate() - averageClassificationPerformance.getErrorRate(), 2);
+        }
+        return new ClassificationPerformance(Math.sqrt(sumAccuracy / (this.results.length - 1)),
+            Math.sqrt(sumErrorRate / (this.results.length - 1)));
+    }
+
+    /**
+     * The isBetter method  takes an {@link ExperimentPerformance} as an input and returns true if the result of compareTo method is positive
+     * and false otherwise.
+     *
+     * @param experimentPerformance {@link ExperimentPerformance} input.
+     * @return True if the result of compareTo method is positive and false otherwise.
+     */
+    isBetter(experimentPerformance: ExperimentPerformance): boolean{
+        let accuracy1 = this.meanClassificationPerformance().getAccuracy();
+        let accuracy2 = experimentPerformance.meanClassificationPerformance().getAccuracy();
+        return accuracy1 > accuracy2
+    }
+}

package/source/Performance/Performance.ts

@@ -0,0 +1,22 @@
+export class Performance {
+
+    protected errorRate: number
+
+    /**
+     * Constructor that sets the error rate.
+     *
+     * @param errorRate Double input.
+     */
+    constructor(errorRate: number) {
+        this.errorRate = errorRate
+    }
+
+    /**
+     * Accessor for the error rate.
+     *
+     * @return Double errorRate.
+     */
+    getErrorRate(): number{
+        return this.errorRate
+    }
+}

package/source/StatisticalTest/Combined5x2F.ts

@@ -0,0 +1,33 @@
+import {PairedTest} from "./PairedTest";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {StatisticalTestResult} from "./StatisticalTestResult";
+import {Distribution} from "nlptoolkit-math/dist/Distribution";
+
+export class Combined5x2F extends PairedTest{
+
+    private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
+        let difference = new Array<number>();
+        let numerator = 0
+        for (let i = 0; i < classifier1.numberOfExperiments(); i++){
+            difference.push(classifier1.getErrorRate(i) - classifier2.getErrorRate(i));
+            numerator += difference[i] * difference[i];
+        }
+        let denominator = 0;
+        for (let i = 0; i < classifier1.numberOfExperiments() / 2; i++){
+            let mean = (difference[2 * i] + difference[2 * i + 1]) / 2;
+            let variance = (difference[2 * i] - mean) * (difference[2 * i] - mean) +
+                (difference[2 * i + 1] - mean) * (difference[2 * i + 1] - mean);
+            denominator += variance;
+        }
+        denominator *= 2;
+        return numerator / denominator;
+    }
+
+    compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
+        let statistic = this.testStatistic(classifier1, classifier2);
+        let degreeOfFreedom1 = classifier1.numberOfExperiments();
+        let degreeOfFreedom2 = classifier1.numberOfExperiments() / 2;
+        return new StatisticalTestResult(Distribution.fDistribution(statistic, degreeOfFreedom1, degreeOfFreedom2), true);
+    }
+
+}

package/source/StatisticalTest/Combined5x2t.ts

@@ -0,0 +1,33 @@
+import {PairedTest} from "./PairedTest";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {StatisticalTestResult} from "./StatisticalTestResult";
+import {Distribution} from "nlptoolkit-math/dist/Distribution";
+
+export class Combined5x2t extends PairedTest{
+
+    private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
+        let difference = new Array<number>();
+        for (let i = 0; i < classifier1.numberOfExperiments(); i++){
+            difference.push(classifier1.getErrorRate(i) - classifier2.getErrorRate(i));
+        }
+        let denominator = 0;
+        let numerator = 0;
+        for (let i = 0; i < classifier1.numberOfExperiments() / 2; i++){
+            let mean = (difference[2 * i] + difference[2 * i + 1]) / 2;
+            numerator += mean;
+            let variance = (difference[2 * i] - mean) * (difference[2 * i] - mean) +
+                (difference[2 * i + 1] - mean) * (difference[2 * i + 1] - mean);
+            denominator += variance;
+        }
+        numerator = Math.sqrt(10) * numerator / 5;
+        denominator = Math.sqrt(denominator / 5);
+        return numerator / denominator;
+    }
+
+    compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
+        let statistic = this.testStatistic(classifier1, classifier2);
+        let degreeOfFreedom = classifier1.numberOfExperiments() / 2;
+        return new StatisticalTestResult(Distribution.tDistribution(statistic, degreeOfFreedom), false);
+    }
+
+}

package/source/StatisticalTest/Paired5x2t.ts

@@ -0,0 +1,32 @@
+import {PairedTest} from "./PairedTest";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {StatisticalTestResult} from "./StatisticalTestResult";
+import {Distribution} from "nlptoolkit-math/dist/Distribution";
+
+export class Paired5x2t extends PairedTest{
+
+    private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
+        let difference = new Array<number>();
+        let sum = 0.0;
+        for (let i = 0; i < classifier1.numberOfExperiments(); i++){
+            difference.push(classifier1.getErrorRate(i) - classifier2.getErrorRate(i));
+            sum += difference[i];
+        }
+        let denominator = 0;
+        for (let i = 0; i < classifier1.numberOfExperiments() / 2; i++){
+            let mean = (difference[2 * i] + difference[2 * i + 1]) / 2;
+            let variance = (difference[2 * i] - mean) * (difference[2 * i] - mean) +
+                (difference[2 * i + 1] - mean) * (difference[2 * i + 1] - mean);
+            denominator += variance;
+        }
+        denominator = Math.sqrt(denominator / 5);
+        return difference[0] / denominator;
+    }
+
+    compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
+        let statistic = this.testStatistic(classifier1, classifier2);
+        let degreeOfFreedom = classifier1.numberOfExperiments() / 2;
+        return new StatisticalTestResult(Distribution.tDistribution(statistic, degreeOfFreedom), false);
+    }
+
+}

package/source/StatisticalTest/PairedTest.ts

@@ -0,0 +1,24 @@
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {StatisticalTestResult} from "./StatisticalTestResult";
+import {StatisticalTestResultType} from "./StatisticalTestResultType";
+
+export abstract class PairedTest {
+
+    abstract compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult
+
+    compare(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance, alpha: number): number{
+        let testResult1 = this.compareClassifiers(classifier1, classifier2);
+        let testResult2 = this.compareClassifiers(classifier2, classifier1);
+        let testResultType1 = testResult1.oneTailed(alpha);
+        let testResultType2 = testResult2.oneTailed(alpha);
+        if (testResultType1 == StatisticalTestResultType.REJECT){
+            return 1;
+        } else {
+            if (testResultType2 == StatisticalTestResultType.REJECT){
+                return -1;
+            } else {
+                return 0;
+            }
+        }
+    }
+}

package/source/StatisticalTest/Pairedt.ts

@@ -0,0 +1,30 @@
+import {PairedTest} from "./PairedTest";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {StatisticalTestResult} from "./StatisticalTestResult";
+import {Distribution} from "nlptoolkit-math/dist/Distribution";
+
+export class Pairedt extends PairedTest{
+
+    private testStatistic(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): number{
+        let difference = new Array<number>();
+        let sum = 0.0;
+        for (let i = 0; i < classifier1.numberOfExperiments(); i++){
+            difference.push(classifier1.getErrorRate(i) - classifier2.getErrorRate(i));
+            sum += difference[i];
+        }
+        let mean = sum / classifier1.numberOfExperiments();
+        sum = 0.0;
+        for (let i = 0; i < classifier1.numberOfExperiments(); i++){
+            sum += (difference[i] - mean) * (difference[i] - mean);
+        }
+        let standardDeviation = Math.sqrt(sum / (classifier1.numberOfExperiments() - 1));
+        return Math.sqrt(classifier1.numberOfExperiments()) * mean / standardDeviation;
+    }
+
+    compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
+        let statistic = this.testStatistic(classifier1, classifier2);
+        let degreeOfFreedom = classifier1.numberOfExperiments() - 1;
+        return new StatisticalTestResult(Distribution.tDistribution(statistic, degreeOfFreedom), false);
+    }
+
+}

package/source/StatisticalTest/Sign.ts

@@ -0,0 +1,41 @@
+import {PairedTest} from "./PairedTest";
+import {ExperimentPerformance} from "../Performance/ExperimentPerformance";
+import {StatisticalTestResult} from "./StatisticalTestResult";
+
+export class Sign extends PairedTest{
+
+    private factorial(n: number): number{
+        let result = 1;
+        for (let i = 2; i <= n; i++)
+            result *= i;
+        return result;
+    }
+
+    private binomial(m: number, n: number): number{
+        if (n == 0 || m == n){
+            return 1;
+        } else {
+            return this.factorial(m) / (this.factorial(n) * this.factorial(m - n));
+        }
+    }
+
+    compareClassifiers(classifier1: ExperimentPerformance, classifier2: ExperimentPerformance): StatisticalTestResult {
+        let plus = 0, minus = 0;
+        for (let i = 0; i < classifier1.numberOfExperiments(); i++){
+            if (classifier1.getErrorRate(i) < classifier2.getErrorRate(i)){
+                plus++;
+            } else {
+                if (classifier1.getErrorRate(i) > classifier2.getErrorRate(i)){
+                    minus++;
+                }
+            }
+        }
+        let total = plus + minus;
+        let pValue = 0.0;
+        for (let i = 0; i <= plus; i++){
+            pValue += this.binomial(total, i) / Math.pow(2, total);
+        }
+        return new StatisticalTestResult(pValue, false);
+    }
+
+}

package/source/StatisticalTest/StatisticalTestResult.ts

@@ -0,0 +1,42 @@
+import {StatisticalTestResultType} from "./StatisticalTestResultType";
+
+export class StatisticalTestResult {
+
+    private readonly pValue: number
+    private readonly onlyTwoTailed: boolean
+
+    constructor(pValue: number, onlyTwoTailed: boolean) {
+        this.pValue = pValue
+        this.onlyTwoTailed = onlyTwoTailed
+    }
+
+    oneTailed(alpha: number): StatisticalTestResultType{
+        if (!this.onlyTwoTailed){
+            if (this.pValue < alpha){
+                return StatisticalTestResultType.REJECT;
+            } else {
+                return StatisticalTestResultType.FAILED_TO_REJECT;
+            }
+        }
+    }
+
+    twoTailed(alpha: number): StatisticalTestResultType{
+        if (this.onlyTwoTailed){
+            if (this.pValue < alpha){
+                return StatisticalTestResultType.REJECT;
+            } else {
+                return StatisticalTestResultType.FAILED_TO_REJECT;
+            }
+        } else {
+            if (this.pValue < alpha / 2 || this.pValue > 1 - alpha / 2){
+                return StatisticalTestResultType.REJECT;
+            } else {
+                return StatisticalTestResultType.FAILED_TO_REJECT;
+            }
+        }
+    }
+
+    getPValue(): number{
+        return this.pValue
+    }
+}

package/source/StatisticalTest/StatisticalTestResultType.ts

@@ -0,0 +1,6 @@
+/***
+ * Enumerator class for statistical test results.
+ */
+export enum StatisticalTestResultType {
+    FAILED_TO_REJECT, REJECT
+}

package/source/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "outDir": "../dist",
+    "module": "umd",
+    "target": "es6",
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "strictNullChecks": false,
+    "removeComments": false,
+    "moduleResolution": "node",
+    "declaration": true
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es6",
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "removeComments": false,
+    "moduleResolution": "node"
+  },
+  "exclude": [
+    "source",
+    "node_modules",
+    "dist"
+  ]
+}