@datagrok/eda 1.1.8 → 1.1.10

package/src/package.ts

@@ -1,3 +1,5 @@
+/* eslint-disable camelcase */
+/* eslint-disable max-len */
 /* Do not change these import lines to match external modules in webpack configuration */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
@@ -6,23 +8,23 @@ import * as DG from 'datagrok-api/dg';
 import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 
 import {_initEDAAPI} from '../wasm/EDAAPI';
-import {computePCA, computePLS, computeUMAP, computeTSNE, computeSPE} from './eda-tools';
-import {addPrefixToEachColumnName, addPLSvisualization, regressionCoefficientsBarChart, 
+import {computePCA, computePLS} from './eda-tools';
+import {addPrefixToEachColumnName, addPLSvisualization, regressionCoefficientsBarChart,
   scoresScatterPlot, predictedVersusReferenceScatterPlot, addOneWayAnovaVizualization} from './eda-ui';
 import {carsDataframe, testDataForBinaryClassification} from './data-generators';
-import {LINEAR, RBF, POLYNOMIAL, SIGMOID, 
+import {LINEAR, RBF, POLYNOMIAL, SIGMOID,
   getTrainedModel, getPrediction, showTrainReport, getPackedModel} from './svm';
 
 import {oneWayAnova} from './stat-tools';
-import { getDbscanWorker } from '@datagrok-libraries/math';
+import {getDbscanWorker} from '@datagrok-libraries/math';
 
 import {DistanceAggregationMethods} from '@datagrok-libraries/ml/src/distance-matrix/types';
 import {MultiColumnDimReductionEditor} from
   '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reduction-editor';
 import {multiColReduceDimensionality} from
   '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/reduce-dimensionality';
-import { DimReductionMethods } from '@datagrok-libraries/ml/src/reduce-dimensionality';
-import { KnownMetrics } from '@datagrok-libraries/ml/src/typed-metrics';
+import {KnownMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 
 export const _package = new DG.Package();
 
@@ -63,8 +65,7 @@ export async function dbScan(df: DG.DataFrame, xCol: DG.Column, yCol: DG.Column,
 //input: bool scale = false [Indicating whether the variables should be scaled to have unit variance.]
 //output: dataframe result {action:join(table)}
 export async function PCA(table: DG.DataFrame, features: DG.ColumnList, components: number,
-  center: boolean, scale: boolean): Promise<DG.DataFrame> 
-{
+  center: boolean, scale: boolean): Promise<DG.DataFrame> {
   const pcaTable = await computePCA(table, features, components, center, scale);
   addPrefixToEachColumnName('PCA', pcaTable.columns);
   return pcaTable;
@@ -120,9 +121,8 @@ export async function reduceDimensionality(): Promise<void> {
 //input: column_list features {type: numerical}
 //input: column predict {type: numerical}
 //input: int components = 3
-export async function PLS(table: DG.DataFrame, names: DG.Column, features: DG.ColumnList, 
-  predict: DG.Column, components: number): Promise<void> 
-{
+export async function PLS(table: DG.DataFrame, names: DG.Column, features: DG.ColumnList,
+  predict: DG.Column, components: number): Promise<void> {
   const plsResults = await computePLS(table, features, predict, components);
   addPLSvisualization(table, names, features, predict, plsResults);
 }
@@ -131,17 +131,17 @@ export async function PLS(table: DG.DataFrame, names: DG.Column, features: DG.Co
 //description: Multidimensional data analysis using partial least squares (PLS) regression. It reduces the predictors to a smaller set of uncorrelated components and performs least squares regression on them.
 //meta.demoPath: Compute | Multivariate analysis
 //meta.isDemoScript: True
-export async function demoMultivariateAnalysis(): Promise<any>  {
-  const demoScript = new DemoScript('Partial least squares regression', 
-    'Analysis of multidimensional data.'); 
-  
+export async function demoMultivariateAnalysis(): Promise<any> {
+  const demoScript = new DemoScript('Partial least squares regression',
+    'Analysis of multidimensional data.');
+
   const cars = carsDataframe();
 
   const components = 3;
   const names = cars.columns.byName('model');
   const predict = cars.columns.byName('price');
   const features = cars.columns.remove('price').remove('model');
-  const plsOutput = await computePLS(cars, features, predict, components);  
+  const plsOutput = await computePLS(cars, features, predict, components);
 
   const sourceCars = carsDataframe();
   sourceCars.name = 'Cars';
@@ -154,7 +154,7 @@ export async function demoMultivariateAnalysis(): Promise<any>  {
       view = grok.shell.getTableView(sourceCars.name);
     }, {description: 'Each car has many features - patterns extraction is complicated.', delay: 0})
     .step('Model', async () => {
-      dialog = ui.dialog({title:'Multivariate Analysis (PLS)'})
+      dialog = ui.dialog({title: 'Multivariate Analysis (PLS)'})
         .add(ui.tableInput('Table', sourceCars))
         .add(ui.columnsInput('Features', cars, features.toList, {available: undefined, checked: features.names()}))
         .add(ui.columnInput('Names', cars, names, undefined))
@@ -165,16 +165,14 @@ export async function demoMultivariateAnalysis(): Promise<any>  {
         })
         .show({x: 400, y: 140});
     }, {description: 'Predict car price by its other features.', delay: 0})
-    .step('Regression coeffcicients', async () => 
-      {
-        dialog.close();
-        view.addViewer(regressionCoefficientsBarChart(features, plsOutput[1]))},
-      {description: 'The feature "diesel" affects the price the most.', delay: 0})
-    .step('Scores', async () => 
-      {view.addViewer(scoresScatterPlot(names, plsOutput[2], plsOutput[3]))}, 
+    .step('Regression coeffcicients', async () => {
+      dialog.close();
+      view.addViewer(regressionCoefficientsBarChart(features, plsOutput[1]));
+    },
+    {description: 'The feature "diesel" affects the price the most.', delay: 0})
+    .step('Scores', async () => {view.addViewer(scoresScatterPlot(names, plsOutput[2], plsOutput[3]));},
       {description: 'Similarities & dissimilarities: alfaromeo and mercedes are different.', delay: 0})
-    .step('Prediction', async () => 
-      {view.addViewer(predictedVersusReferenceScatterPlot(names, predict, plsOutput[0]))}, 
+    .step('Prediction', async () => {view.addViewer(predictedVersusReferenceScatterPlot(names, predict, plsOutput[0]));},
       {description: 'Closer to the line means better price prediction.', delay: 0})
     .start();
 }
@@ -188,9 +186,8 @@ export async function demoMultivariateAnalysis(): Promise<any>  {
 //input: double max = 173 {caption: max; category: Range}
 //input: double violatorsPercentage = 5 {caption: violators; units: %; category: Dataset}
 //output: dataframe df
-export async function testDataLinearSeparable(name: string, samplesCount: number, featuresCount: number, 
-  min: number, max: number, violatorsPercentage: number): Promise<DG.DataFrame> 
-{
+export async function testDataLinearSeparable(name: string, samplesCount: number, featuresCount: number,
+  min: number, max: number, violatorsPercentage: number): Promise<DG.DataFrame> {
   return await testDataForBinaryClassification(LINEAR, [0, 0], name, samplesCount, featuresCount,
     min, max, violatorsPercentage);
 }
@@ -205,9 +202,8 @@ export async function testDataLinearSeparable(name: string, samplesCount: number
 //input: double max = 173 {caption: max; category: Range}
 //input: double violatorsPercentage = 5 {caption: violators; units: %; category: Dataset}
 //output: dataframe df
-export async function testDataLinearNonSeparable(name: string, sigma: number, samplesCount: number, 
-  featuresCount: number, min: number, max: number, violatorsPercentage: number): Promise<DG.DataFrame> 
-{
+export async function testDataLinearNonSeparable(name: string, sigma: number, samplesCount: number,
+  featuresCount: number, min: number, max: number, violatorsPercentage: number): Promise<DG.DataFrame> {
   return await testDataForBinaryClassification(RBF, [sigma, 0], name, samplesCount, featuresCount,
     min, max, violatorsPercentage);
 }
@@ -220,10 +216,9 @@ export async function testDataLinearNonSeparable(name: string, sigma: number, sa
 //input: double gamma = 1.0 {category: Hyperparameters}
 //input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
-export async function trainLinearKernelSVM(df: DG.DataFrame, predict_column: string, 
-  gamma: number, toShowReport: boolean): Promise<any> 
-{    
-  const trainedModel = await getTrainedModel({gamma: gamma, kernel: LINEAR}, df, predict_column);   
+export async function trainLinearKernelSVM(df: DG.DataFrame, predict_column: string,
+  gamma: number, toShowReport: boolean): Promise<any> {
+  const trainedModel = await getTrainedModel({gamma: gamma, kernel: LINEAR}, df, predict_column);
 
   if (toShowReport)
     showTrainReport(df, trainedModel);
@@ -237,8 +232,8 @@ export async function trainLinearKernelSVM(df: DG.DataFrame, predict_column: str
 //input: dataframe df
 //input: dynamic model
 //output: dataframe table
-export async function applyLinearKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> { 
-  return await getPrediction(df, model); 
+export async function applyLinearKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> {
+  return await getPrediction(df, model);
 }
 
 //name: trainRBFkernelSVM
@@ -250,12 +245,11 @@ export async function applyLinearKernelSVM(df: DG.DataFrame, model: any): Promis
 //input: double sigma = 1.5 {category: Hyperparameters}
 //input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
-export async function trainRBFkernelSVM(df: DG.DataFrame, predict_column: string, 
-  gamma: number, sigma: number, toShowReport: boolean): Promise<any> 
-{  
+export async function trainRBFkernelSVM(df: DG.DataFrame, predict_column: string,
+  gamma: number, sigma: number, toShowReport: boolean): Promise<any> {
   const trainedModel = await getTrainedModel(
-    {gamma: gamma, kernel: RBF, sigma: sigma}, 
-    df, predict_column);   
+    {gamma: gamma, kernel: RBF, sigma: sigma},
+    df, predict_column);
 
   if (toShowReport)
     showTrainReport(df, trainedModel);
@@ -269,9 +263,9 @@ export async function trainRBFkernelSVM(df: DG.DataFrame, predict_column: string
 //input: dataframe df
 //input: dynamic model
 //output: dataframe table
-export async function applyRBFkernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> { 
-  return await getPrediction(df, model); 
-} 
+export async function applyRBFkernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> {
+  return await getPrediction(df, model);
+}
 
 //name: trainPolynomialKernelSVM
 //meta.mlname: polynomial kernel LS-SVM
@@ -283,12 +277,11 @@ export async function applyRBFkernelSVM(df: DG.DataFrame, model: any): Promise<D
 //input: double d = 2 {category: Hyperparameters}
 //input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
-export async function trainPolynomialKernelSVM(df: DG.DataFrame, predict_column: string, 
-  gamma: number, c: number, d: number, toShowReport: boolean): Promise<any> 
-{  
+export async function trainPolynomialKernelSVM(df: DG.DataFrame, predict_column: string,
+  gamma: number, c: number, d: number, toShowReport: boolean): Promise<any> {
   const trainedModel = await getTrainedModel(
-    {gamma: gamma, kernel: POLYNOMIAL, cParam: c, dParam: d}, 
-    df, predict_column);   
+    {gamma: gamma, kernel: POLYNOMIAL, cParam: c, dParam: d},
+    df, predict_column);
 
   if (toShowReport)
     showTrainReport(df, trainedModel);
@@ -302,8 +295,8 @@ export async function trainPolynomialKernelSVM(df: DG.DataFrame, predict_column:
 //input: dataframe df
 //input: dynamic model
 //output: dataframe table
-export async function applyPolynomialKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> { 
-  return await getPrediction(df, model); 
+export async function applyPolynomialKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> {
+  return await getPrediction(df, model);
 }
 
 //name: trainSigmoidKernelSVM
@@ -316,12 +309,11 @@ export async function applyPolynomialKernelSVM(df: DG.DataFrame, model: any): Pr
 //input: double theta = 1 {category: Hyperparameters}
 //input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
-export async function trainSigmoidKernelSVM(df: DG.DataFrame, predict_column: string, 
-  gamma: number, kappa: number, theta: number, toShowReport: boolean): Promise<any> 
-{  
+export async function trainSigmoidKernelSVM(df: DG.DataFrame, predict_column: string,
+  gamma: number, kappa: number, theta: number, toShowReport: boolean): Promise<any> {
   const trainedModel = await getTrainedModel(
-    {gamma: gamma, kernel: SIGMOID, kappa: kappa, theta: theta}, 
-    df, predict_column);   
+    {gamma: gamma, kernel: SIGMOID, kappa: kappa, theta: theta},
+    df, predict_column);
 
   if (toShowReport)
     showTrainReport(df, trainedModel);
@@ -335,8 +327,8 @@ export async function trainSigmoidKernelSVM(df: DG.DataFrame, predict_column: st
 //input: dataframe df
 //input: dynamic model
 //output: dataframe table
-export async function applySigmoidKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> { 
-  return await getPrediction(df, model); 
+export async function applySigmoidKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> {
+  return await getPrediction(df, model);
 }
 
 //top-menu: ML | Analyze | ANOVA...
@@ -349,5 +341,5 @@ export async function applySigmoidKernelSVM(df: DG.DataFrame, model: any): Promi
 //input: bool validate = false [Indicates whether the normality of distribution and an eqaulity of varainces should be checked.]
 export function anova(table: DG.DataFrame, factor: DG.Column, feature: DG.Column, significance: number, validate: boolean) {
   const res = oneWayAnova(factor, feature, significance, validate);
-  addOneWayAnovaVizualization(table, factor, feature, res);  
+  addOneWayAnovaVizualization(table, factor, feature, res);
 }

package/src/stat-tools.ts

@@ -1,11 +1,11 @@
 // Statistic tools
 
 /* REFERENCES
-   
+
      [1] One-way analysis of variance, https://en.wikipedia.org/wiki/One-way_analysis_of_variance
 
      [2] G.W. Heiman. Basic Statistics for the Behavioral Sciences, 6th ed. Wadsworth Publishing, 2010
-     
+
      [3] F-test of equality of variances, https://en.wikipedia.org/wiki/F-test_of_equality_of_variances
 
      [4] S. McKillup. Statistics Explained, Cambridge University Press, 2005
@@ -40,9 +40,9 @@ type SampleData = {
 type OneWayAnova = {
   /** sum of squares between groups, SSbn */
   ssBn: number,
-  /** sum of squares within groups, SSnn */ 
+  /** sum of squares within groups, SSnn */
   ssWn: number,
-  /** total sum of squares, SStot */ 
+  /** total sum of squares, SStot */
   ssTot: number,
   /** degrees of freedom between groups, DFbn */
   dfBn: number,
@@ -67,15 +67,21 @@ type CatCol = DG.Column<DG.COLUMN_TYPE.STRING>;
 type NumCol = DG.Column<DG.COLUMN_TYPE.FLOAT> | DG.Column<DG.COLUMN_TYPE.INT>;
 
 /** Create dataframe with one-way ANOVA results. */
-export function getOneWayAnovaDF(anova: OneWayAnova, alpha: number, fCritical: number, hypothesis: string, testResult: string): DG.DataFrame {
+export function getOneWayAnovaDF(
+  anova: OneWayAnova, alpha: number, fCritical: number, hypothesis: string, testResult: string,
+): DG.DataFrame {
   return DG.DataFrame.fromColumns([
-    DG.Column.fromStrings('Source of variance', ['Between groups', 'Within groups', 'Total', '', hypothesis, '', testResult]),
-    DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'Sum of squares', [anova.ssBn, anova.ssWn, anova.ssTot, null, null, null, null]),
-    DG.Column.fromList(DG.COLUMN_TYPE.INT, 'Degrees of freedom', [anova.dfBn, anova.dfWn, anova.dfTot, null, null, null, null]),
+    DG.Column.fromStrings('Source of variance',
+      ['Between groups', 'Within groups', 'Total', '', hypothesis, '', testResult]),
+    DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'Sum of squares',
+      [anova.ssBn, anova.ssWn, anova.ssTot, null, null, null, null]),
+    DG.Column.fromList(DG.COLUMN_TYPE.INT, 'Degrees of freedom',
+      [anova.dfBn, anova.dfWn, anova.dfTot, null, null, null, null]),
     DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'Mean square', [anova.msBn, anova.msWn, null, null, null, null, null]),
     DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'F-statistics', [anova.fStat, null, null, null, null, null, null]),
     DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, 'p-value', [anova.pValue, null, null, null, null, null, null]),
-    DG.Column.fromList(DG.COLUMN_TYPE.FLOAT, `${alpha}-critical value`, [fCritical, null, null, null, null, null, null]),
+    DG.Column.fromList(DG.COLUMN_TYPE.FLOAT,
+      `${alpha}-critical value`, [fCritical, null, null, null, null, null, null]),
   ]);
 } // getOneWayAnovaDF
 
@@ -95,7 +101,7 @@ export function getVariance(data: SampleData): number {
 
   if (size === 1)
     return 0;
-  
+
   return (data.sumOfSquares - (data.sum) ** 2 / size) / (size - 1);
 } // getVariance
 
@@ -103,7 +109,7 @@ export function getVariance(data: SampleData): number {
 function areVarsEqual(xData: SampleData, yData: SampleData, alpha: number = 0.05): boolean {
   // The applied approach can be found in [3]
   checkSignificanceLevel(alpha);
-  
+
   const xVar = getVariance(xData);
   const yVar = getVariance(yData);
 
@@ -118,7 +124,7 @@ function areVarsEqual(xData: SampleData, yData: SampleData, alpha: number = 0.05
 
 export class FactorizedData {
   private isNormDistrib: boolean | undefined = undefined;
-  private categories: string[] = [];  
+  private categories: string[] = [];
   private sums!: Float64Array;
   private sumsOfSquares!: Float64Array;
   private subSampleSizes!: Int32Array;
@@ -130,7 +136,7 @@ export class FactorizedData {
       throw new Error();
 
     if (categories.length !== values.length)
-      throw new Error(ERROR_MSG.NON_EQUAL_FACTORS_VALUES_SIZE);      
+      throw new Error(ERROR_MSG.NON_EQUAL_FACTORS_VALUES_SIZE);
 
     this.setStats(categories, values, checkNormality, alpha);
   }
@@ -148,11 +154,13 @@ export class FactorizedData {
 
     const first: SampleData = {sum: this.sums[0], sumOfSquares: this.sumsOfSquares[0], size: this.subSampleSizes[0]};
 
-    for (let i = 1; i < K; ++i)
-      if(!areVarsEqual(first, {sum: this.sums[i], sumOfSquares: this.sumsOfSquares[i], size: this.subSampleSizes[i]}, alpha))
+    for (let i = 1; i < K; ++i) {
+      if (!areVarsEqual(first, {sum: this.sums[i], sumOfSquares: this.sumsOfSquares[i],
+        size: this.subSampleSizes[i]}, alpha))
         return false;
+    }
 
-    return true;    
+    return true;
   } // areVarsEqual
 
   /** Perform one-way ANOVA computations. */
@@ -163,18 +171,18 @@ export class FactorizedData {
 
     if (K === 1)
       throw new Error(ERROR_MSG.ANOVA_FAILED_JUST_ONE_CAT);
-  
+
     let sum = 0;
     let sumOfSquares = 0;
-    let N = this.size;
+    const N = this.size;
     let buf = 0;
 
     for (let i = 0; i < K; ++i) {
       sum += this.sums[i];
       sumOfSquares += this.sumsOfSquares[i];
-      buf += this.sums[i] ** 2 / this.subSampleSizes[i];      
+      buf += this.sums[i] ** 2 / this.subSampleSizes[i];
     }
-  
+
     const ssTot = sumOfSquares - sum ** 2 / N;
     const ssBn = buf - sum ** 2 / N;
     const ssWn = ssTot - ssBn;
@@ -182,12 +190,12 @@ export class FactorizedData {
     const dfBn = K - 1;
     const dfWn = N - K;
     const dfTot = N - 1;
-    
+
     const msBn = ssBn / dfBn;
     const msWn = ssWn / dfWn;
 
     const fStat = msBn / msWn;
-  
+
     return {
       ssBn: ssBn,
       ssWn: ssWn,
@@ -197,61 +205,63 @@ export class FactorizedData {
       dfTot: dfTot,
       msBn: msBn,
       msWn: msWn,
-     fStat: fStat,
-      pValue: 1 - jStat.centralF.cdf(fStat, dfBn, dfWn)
+      fStat: fStat,
+      pValue: 1 - jStat.centralF.cdf(fStat, dfBn, dfWn),
     };
   } // getOneWayAnova
 
   /** Compute sum & sums of squares with respect to factor levels. */
-  private setStats(categories: CatCol, values: NumCol, checkNormality: boolean = false, alpha: number = 0.05): void {
-    // TODO: provide check normality feature    
+  private setStats(categories: CatCol, values: NumCol, _checkNormality: boolean = false, _alpha: number = 0.05): void {
+    // TODO: provide check normality feature
     const type = values.type;
     const size = values.length;
 
     switch (type) {
-      case DG.COLUMN_TYPE.INT:
-      case DG.COLUMN_TYPE.FLOAT:
-        this.categories = categories.categories;
-        const catCount = this.categories.length;
-        this.catCount = catCount;
-        this.size = size;
-
-        const vals = values.getRawData();
-        const cats = categories.getRawData();
-
-        const sums = new Float64Array(catCount).fill(0);
-        const sumsOfSquares = new Float64Array(catCount).fill(0);
-        const subSampleSizes = new Int32Array(catCount).fill(0);
-        
-        for (let i = 0; i < size; ++i) {
-          const c = cats[i];    
-          sums[c] += vals[i];
-          sumsOfSquares[c] += vals[i] ** 2;
-          ++subSampleSizes[c];
-        }
-
-        this.sums = sums;
-        this.sumsOfSquares = sumsOfSquares;
-        this.subSampleSizes = subSampleSizes;
-
-        break;
-
-      default:
-        throw new Error(ERROR_MSG.UNSUPPORTED_COLUMN_TYPE);
-    }    
+    case DG.COLUMN_TYPE.INT:
+    case DG.COLUMN_TYPE.FLOAT:
+      this.categories = categories.categories;
+      const catCount = this.categories.length;
+      this.catCount = catCount;
+      this.size = size;
+
+      const vals = values.getRawData();
+      const cats = categories.getRawData();
+
+      const sums = new Float64Array(catCount).fill(0);
+      const sumsOfSquares = new Float64Array(catCount).fill(0);
+      const subSampleSizes = new Int32Array(catCount).fill(0);
+
+      for (let i = 0; i < size; ++i) {
+        const c = cats[i];
+        sums[c] += vals[i];
+        sumsOfSquares[c] += vals[i] ** 2;
+        ++subSampleSizes[c];
+      }
+
+      this.sums = sums;
+      this.sumsOfSquares = sumsOfSquares;
+      this.subSampleSizes = subSampleSizes;
+
+      break;
+
+    default:
+      throw new Error(ERROR_MSG.UNSUPPORTED_COLUMN_TYPE);
+    }
   } // setStats
 } // FactorizedData
 
 /** Perform one-way analysis of variances. */
-export function oneWayAnova(categores: CatCol, values: NumCol, alpha: number = 0.05, validate: boolean = false): DG.DataFrame {
-  checkSignificanceLevel(alpha);  
+export function oneWayAnova(
+  categores: CatCol, values: NumCol, alpha: number = 0.05, validate: boolean = false,
+): DG.DataFrame {
+  checkSignificanceLevel(alpha);
 
   const factorized = new FactorizedData(categores, values, validate, alpha);
 
   if (validate) {
-    if(!factorized.areVarsEqual(alpha))
+    if (!factorized.areVarsEqual(alpha))
       throw new Error(ERROR_MSG.NON_EQUAL_VARIANCES);
-  
+
     if (!factorized.isNormal())
       throw new Error(ERROR_MSG.NON_NORMAL_DISTRIB);
   }
@@ -259,7 +269,8 @@ export function oneWayAnova(categores: CatCol, values: NumCol, alpha: number = 0
   const anova = factorized.getOneWayAnova();
   const fCrit = jStat.centralF.inv(1 - alpha, anova.dfBn, anova.dfWn);
 
-  const hypothesis = `THE NULL HYPOTHESIS: the "${categores.name}" factor does not produce a significant difference in the "${values.name}" feature.`;
+  const hypothesis = `THE NULL HYPOTHESIS: the "${categores.name}" 
+    factor does not produce a significant difference in the "${values.name}" feature.`;
   const testResult = `Test result: ${(anova.fStat > fCrit) ? 'REJECTED.' : 'FAILED TO REJECT.'}`;
 
   return getOneWayAnovaDF(anova, alpha, fCrit, hypothesis, testResult);