@datagrok/eda 1.1.9 → 1.1.10

package/src/svm.ts

@@ -5,7 +5,7 @@
 
    Least square support vector machine (LS-SVM) is implemented:
      [1] Suykens, J., Vandewalle, J. "Least Squares Support Vector Machine Classifiers",
-	       Neural Processing Letters 9, 293-300 (1999). https://doi.org/10.1023/A:1018628609742 
+       Neural Processing Letters 9, 293-300 (1999). https://doi.org/10.1023/A:1018628609742
 */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
@@ -67,7 +67,7 @@ const MODEL_PARAMS_NAME = 'alpha';
 const MODEL_WEIGHTS_NAME = 'weight';
 const GAMMA = 'gamma';
 const KERNEL = 'kernel';
-const KERNEL_PARAMS = 'kernel params'; 
+const KERNEL_PARAMS = 'kernel params';
 const KERNEL_PARAM_1 = 'kernel param 1';
 const KERNEL_PARAM_2 = 'kernel param 2';
 const FEATURES_COUNT_NAME = 'features count';
@@ -111,43 +111,42 @@ function checkHyperparameters(hyperparameters: any): void {
 
   // check kernel & its parameters
   switch (hyperparameters.kernel) {
-    case LINEAR: // the case of linear kernel
-      return;
-
-    case RBF: // the case of RBF kernel
-      if(hyperparameters.sigma <= RBF_SIGMA_INFIMUM_LIMIT)
-        throw new Error(WRONG_RBF_SIGMA_MESSAGE);
-      return;
-
-    case POLYNOMIAL: // the case of polynomial kernel
-      // check c
-      if(hyperparameters.cParam <= POLYNOMIAL_C_INFIMUM_LIMIT)         
-        throw new Error(WRONG_POLYNOMIAL_C_MESSAGE);
+  case LINEAR: // the case of linear kernel
+    return;
+
+  case RBF: // the case of RBF kernel
+    if (hyperparameters.sigma <= RBF_SIGMA_INFIMUM_LIMIT)
+      throw new Error(WRONG_RBF_SIGMA_MESSAGE);
+    return;
+
+  case POLYNOMIAL: // the case of polynomial kernel
+    // check c
+    if (hyperparameters.cParam <= POLYNOMIAL_C_INFIMUM_LIMIT)
+      throw new Error(WRONG_POLYNOMIAL_C_MESSAGE);
       // check d
-      if(hyperparameters.dParam <= POLYNOMIAL_D_INFIMUM_LIMIT)         
-        throw new Error(WRONG_POLYNOMIAL_D_MESSAGE);    
-      return;
-    
-    case SIGMOID: // the case of polynomial kernel
-      return;
-
-    default: // incorrect kernel
-      throw new Error(WRONG_KERNEL_MESSAGE);
-    } // switch    
+    if (hyperparameters.dParam <= POLYNOMIAL_D_INFIMUM_LIMIT)
+      throw new Error(WRONG_POLYNOMIAL_D_MESSAGE);
+    return;
+
+  case SIGMOID: // the case of polynomial kernel
+    return;
+
+  default: // incorrect kernel
+    throw new Error(WRONG_KERNEL_MESSAGE);
+  } // switch
 } // checkHyperparameters
 
 // Returnes labels predicted by the model specified
-async function predict(model: any, dataset: DG.ColumnList): Promise<DG.Column>
-{
+async function predict(model: any, dataset: DG.ColumnList): Promise<DG.Column> {
   let _output: any;
 
-  let _promise = _predictByLSSVMInWebWorker(model.kernelType, model.kernelParams,
-    model.normalizedTrainData.columns, model.trainLabels, model.means, model.stdDevs, 
+  const _promise = _predictByLSSVMInWebWorker(model.kernelType, model.kernelParams,
+    model.normalizedTrainData.columns, model.trainLabels, model.means, model.stdDevs,
     model.modelParams, model.modelWeights, dataset);
 
   await _promise.then(
-    _result => { _output = _result; },
-    _error => {  throw new Error (`Error: ${_error}`); }
+    (_result) => {_output = _result;},
+    (_error) => {throw new Error(`Error: ${_error}`);},
   );
 
   return _output;
@@ -155,26 +154,26 @@ async function predict(model: any, dataset: DG.ColumnList): Promise<DG.Column>
 
 // Evaluate accuracy of the model
 function evaluateAccuracy(model: any): void {
-  let data = model.confusionMatrix.getRawData();
+  const data = model.confusionMatrix.getRawData();
 
   // here, the classic notation is used (see https://en.wikipedia.org/wiki/Sensitivity_and_specificity)
 
-  let TP = data[TRUE_POSITIVE_INDEX]; // true positive
-  let TN = data[TRUE_NEGATIVE_INDEX]; // true negative
-  let FP = data[FALSE_POSITIVE_INDEX]; // false positive
-  let FN = data[FALSE_NEGATIVE_INDEX]; // false negative
+  const TP = data[TRUE_POSITIVE_INDEX]; // true positive
+  const TN = data[TRUE_NEGATIVE_INDEX]; // true negative
+  const FP = data[FALSE_POSITIVE_INDEX]; // false positive
+  const FN = data[FALSE_NEGATIVE_INDEX]; // false negative
 
-  let P = TP + FN; // positive
-  let N = FP + TN; // negative
+  const P = TP + FN; // positive
+  const N = FP + TN; // negative
 
-  let TPR = TP / P; // true positive rate
-  let TNR = TN / N; // true negative rate
+  const TPR = TP / P; // true positive rate
+  const TNR = TN / N; // true negative rate
 
-  let PPV = TP / (TP + FP); // positive predicitve value
-  let NPV = TN / (TN + FN); // negative predicitve value
+  const PPV = TP / (TP + FP); // positive predicitve value
+  const NPV = TN / (TN + FN); // negative predicitve value
 
-  let ACC = (TP + TN) / (P + N); // accuracy
-  let BA = (TPR + TNR) / 2; // balanced accuracy
+  const ACC = (TP + TN) / (P + N); // accuracy
+  const BA = (TPR + TNR) / 2; // balanced accuracy
 
   model.sensitivity = TPR;
   model.specificity = TNR;
@@ -185,59 +184,57 @@ function evaluateAccuracy(model: any): void {
 } // evaluateAccuracy
 
 // Returns trained LS-SVM model.
-async function trainAndAnalyzeModel(hyperparameters: any, dataset: DG.ColumnList, 
-  labels: DG.Column): Promise<any> 
-{ 
+async function trainAndAnalyzeModel(hyperparameters: any, dataset: DG.ColumnList,
+  labels: DG.Column): Promise<any> {
   // check correctness of hyperparameter gamma
-  checkHyperparameters(hyperparameters)
+  checkHyperparameters(hyperparameters);
 
   // create default kernel params array
   const kernelParamsArray = [INIT_VALUE, INIT_VALUE];
 
   // fill kernelParams
-  switch (hyperparameters.kernel)
-  {
-    case LINEAR: // no kernel parameters in the case of linear kernel
-      break;
-
-    case RBF: // sigma parameter in the case of RBF-kernel
-      kernelParamsArray[RBF_SIGMA_INDEX] = hyperparameters.sigma;      
-      break;
-
-    case POLYNOMIAL: // sigma parameter in the case of polynomial kernel
-      kernelParamsArray[POLYNOMIAL_C_INDEX] = hyperparameters.cParam;
-      kernelParamsArray[POLYNOMIAL_D_INDEX] = hyperparameters.dParam;
-      break;
-
-    case SIGMOID: // sigma parameter in the case of sigmoid kernel
-      kernelParamsArray[SIGMOID_KAPPA_INDEX] = hyperparameters.kappa;
-      kernelParamsArray[SIGMOID_THETA_INDEX] = hyperparameters.theta;
-      break;
-
-    default: // incorrect kernel 
-      throw new Error(WRONG_KERNEL_MESSAGE);
+  switch (hyperparameters.kernel) {
+  case LINEAR: // no kernel parameters in the case of linear kernel
+    break;
+
+  case RBF: // sigma parameter in the case of RBF-kernel
+    kernelParamsArray[RBF_SIGMA_INDEX] = hyperparameters.sigma;
+    break;
+
+  case POLYNOMIAL: // sigma parameter in the case of polynomial kernel
+    kernelParamsArray[POLYNOMIAL_C_INDEX] = hyperparameters.cParam;
+    kernelParamsArray[POLYNOMIAL_D_INDEX] = hyperparameters.dParam;
+    break;
+
+  case SIGMOID: // sigma parameter in the case of sigmoid kernel
+    kernelParamsArray[SIGMOID_KAPPA_INDEX] = hyperparameters.kappa;
+    kernelParamsArray[SIGMOID_THETA_INDEX] = hyperparameters.theta;
+    break;
+
+  default: // incorrect kernel
+    throw new Error(WRONG_KERNEL_MESSAGE);
   };
 
   // create kernel params column
-  let kernelParams = DG.Column.fromList('double', KERNEL_PARAMS, kernelParamsArray);
+  const kernelParams = DG.Column.fromList('double', KERNEL_PARAMS, kernelParamsArray);
 
   // compute size of model params & precomputed weigths
-  let trainCols = dataset.toList();  
-  let modelParamsCount = trainCols[0].length + LS_SVM_ADD_CONST;
-  let precomputedWeightsCount = trainCols.length + LS_SVM_ADD_CONST;
-  let confusionMatrixElementsCount = CONFUSION_MATR_SIZE;
+  const trainCols = dataset.toList();
+  const modelParamsCount = trainCols[0].length + LS_SVM_ADD_CONST;
+  const precomputedWeightsCount = trainCols.length + LS_SVM_ADD_CONST;
+  const confusionMatrixElementsCount = CONFUSION_MATR_SIZE;
 
   // call webassembly training function
 
   let output: any;
-  let _promise = _trainAndAnalyzeLSSVMInWebWorker(hyperparameters.gamma, hyperparameters.kernel, 
-    kernelParams, modelParamsCount, precomputedWeightsCount, confusionMatrixElementsCount, 
+  const _promise = _trainAndAnalyzeLSSVMInWebWorker(hyperparameters.gamma, hyperparameters.kernel,
+    kernelParams, modelParamsCount, precomputedWeightsCount, confusionMatrixElementsCount,
     dataset, labels);
-   
+
   await _promise.then(
-    _result => { output = _result; },
-    _error => {  throw new Error (`Error: ${_error}`); }
-  );  
+    (_result) => {output = _result;},
+    (_error) => {throw new Error(`Error: ${_error}`);},
+  );
 
   // rename output columns
   output[MEANS_INDEX].name = MEAN;
@@ -250,7 +247,7 @@ async function trainAndAnalyzeModel(hyperparameters: any, dataset: DG.ColumnList
   output[CONFUSION_MATRIX_INDEX].name = CONFUSION_MATRIX_NAME;
 
   // complete model
-  let model = {
+  const model = {
     trainGamma: hyperparameters.gamma,
     kernelType: hyperparameters.kernel,
     kernelParams: kernelParams,
@@ -265,7 +262,7 @@ async function trainAndAnalyzeModel(hyperparameters: any, dataset: DG.ColumnList
     confusionMatrix: output[CONFUSION_MATRIX_INDEX],
     trainError: undefined,
     featuresCount: trainCols.length,
-    trainSamplesCount: trainCols[0].length 
+    trainSamplesCount: trainCols[0].length,
   };
 
   evaluateAccuracy(model);
@@ -274,17 +271,17 @@ async function trainAndAnalyzeModel(hyperparameters: any, dataset: DG.ColumnList
 } // trainAndAnalyzeModel
 
 // Wrapper for combining the function "trainAndAnalyzeModel" with Datagrok predicitve tools
-export async function getTrainedModel(hyperparameters: any, df: DG.DataFrame, predict_column: string): Promise<any> {
-  let columns = df.columns;
-  let labels = columns.byName(predict_column);
-  columns.remove(predict_column);    
+export async function getTrainedModel(hyperparameters: any, df: DG.DataFrame, predictColumn: string): Promise<any> {
+  const columns = df.columns;
+  const labels = columns.byName(predictColumn);
+  columns.remove(predictColumn);
 
-  return await trainAndAnalyzeModel(hyperparameters, columns, labels); 
+  return await trainAndAnalyzeModel(hyperparameters, columns, labels);
 }
 
 // Returns dataframe with short info about model
 function getModelInfo(model: any): DG.DataFrame {
-  let kernelParams = model.kernelParams.getRawData();
+  const kernelParams = model.kernelParams.getRawData();
 
   return DG.DataFrame.fromColumns([
     DG.Column.fromList('double', GAMMA, [model.trainGamma]),
@@ -296,72 +293,70 @@ function getModelInfo(model: any): DG.DataFrame {
     DG.Column.fromList('double', TRAIN_ERROR, [model.trainError]),
     DG.Column.fromList('double', BALANCED_ACCURACY, [model.balancedAccuracy]),
     DG.Column.fromList('double', SENSITIVITY, [model.sensitivity]),
-    DG.Column.fromList('double', SPECIFICITY, [model.specificity]),    
-    DG.Column.fromList('double', POSITIVE_PREDICTIVE_VALUE, [model.positivePredicitveValue]), 
-    DG.Column.fromList('double', NEGATIVE_PREDICTIVE_VALUE, [model.negativePredicitveValue])
-  ]);     
-} 
+    DG.Column.fromList('double', SPECIFICITY, [model.specificity]),
+    DG.Column.fromList('double', POSITIVE_PREDICTIVE_VALUE, [model.positivePredicitveValue]),
+    DG.Column.fromList('double', NEGATIVE_PREDICTIVE_VALUE, [model.negativePredicitveValue]),
+  ]);
+}
 
 // Get dataframe with confusion matrix
-function getConfusionMatrixDF(model: any): DG.DataFrame
-{
-  let data = model.confusionMatrix.getRawData();
+function getConfusionMatrixDF(model: any): DG.DataFrame {
+  const data = model.confusionMatrix.getRawData();
 
   return DG.DataFrame.fromColumns([
     DG.Column.fromStrings('', [POSITIVE_NAME, NEGATIVE_NAME]),
-    DG.Column.fromList('int', PREDICTED_POSITIVE_NAME, 
+    DG.Column.fromList('int', PREDICTED_POSITIVE_NAME,
       [data[TRUE_POSITIVE_INDEX], data[FALSE_POSITIVE_INDEX]]),
-    DG.Column.fromList('int', PREDICTED_NEGATIVE_NAME, 
-      [data[FALSE_NEGATIVE_INDEX], data[TRUE_NEGATIVE_INDEX]]) 
+    DG.Column.fromList('int', PREDICTED_NEGATIVE_NAME,
+      [data[FALSE_NEGATIVE_INDEX], data[TRUE_NEGATIVE_INDEX]]),
   ]);
 }
 
 // Show training report
 export function showTrainReport(df: DG.DataFrame, model: any): void {
   df.name = ML_REPORT;
-  df.columns.add(model.trainLabels);        
-  df.columns.add(model.predictedLabels);        
-  df.columns.add(model.correctness);    
-  let dfView = grok.shell.addTableView(df);    
+  df.columns.add(model.trainLabels);
+  df.columns.add(model.predictedLabels);
+  df.columns.add(model.correctness);
+  const dfView = grok.shell.addTableView(df);
   dfView.addViewer(DG.Viewer.form(getModelInfo(model)));
-  dfView.addViewer(DG.Viewer.scatterPlot(df, 
-    { title: ML_REPORT_PREDICTED_LABELS,
-      color: model.predictedLabels.name
-    }));       
-  dfView.addViewer(DG.Viewer.scatterPlot(df, 
-    { title: ML_REPORT_TRAIN_LABELS,
-      color: model.trainLabels.name
+  dfView.addViewer(DG.Viewer.scatterPlot(df,
+    {title: ML_REPORT_PREDICTED_LABELS,
+      color: model.predictedLabels.name,
+    }));
+  dfView.addViewer(DG.Viewer.scatterPlot(df,
+    {title: ML_REPORT_TRAIN_LABELS,
+      color: model.trainLabels.name,
     }));
-  dfView.addViewer(DG.Viewer.grid(getConfusionMatrixDF(model))); 
-  dfView.addViewer(DG.Viewer.scatterPlot(df, 
-    { title: ML_REPORT_CORRECTNESS,
-      color: model.correctness.name
+  dfView.addViewer(DG.Viewer.grid(getConfusionMatrixDF(model)));
+  dfView.addViewer(DG.Viewer.scatterPlot(df,
+    {title: ML_REPORT_CORRECTNESS,
+      color: model.correctness.name,
     }));
 } // showTrainReport
 
 // Returns trained model packed into UInt8Array
 export function getPackedModel(model: any): any {
-
   // get principal data
-  let dataCols = model.normalizedTrainData.columns;  
-  let samplesCount = model.trainSamplesCount;
-  let featuresCount = model.featuresCount;
+  const dataCols = model.normalizedTrainData.columns;
+  const samplesCount = model.trainSamplesCount;
+  const featuresCount = model.featuresCount;
 
-  /*let bufferSize = BYTES * (7 + featuresCount * samplesCount 
+  /*let bufferSize = BYTES * (7 + featuresCount * samplesCount
     + 3 * featuresCount + 2 * samplesCount);*/
 
   // compute size of packed model
-  let bufferSize = BYTES * (INTS_COUNT + KER_PARAMS_COUNT + 
-    samplesCount + featuresCount + featuresCount + samplesCount + LS_SVM_ADD_CONST
-    + featuresCount + LS_SVM_ADD_CONST + featuresCount * samplesCount);
+  const bufferSize = BYTES * (INTS_COUNT + KER_PARAMS_COUNT +
+    samplesCount + featuresCount + featuresCount + samplesCount + LS_SVM_ADD_CONST +
+    featuresCount + LS_SVM_ADD_CONST + featuresCount * samplesCount);
 
   // packed model
-  let result = new Uint8Array(bufferSize);  
-  let buffer = result.buffer;
+  const result = new Uint8Array(bufferSize);
+  const buffer = result.buffer;
   let offset = 0;
 
   // pack kernel type and sizes
-  let ints = new Int32Array(buffer, offset, INTS_COUNT);
+  const ints = new Int32Array(buffer, offset, INTS_COUNT);
   ints[MODEL_KERNEL_INDEX] = model.kernelType;
   ints[SAMPLES_COUNT_INDEX] = samplesCount;
   ints[FEATURES_COUNT_INDEX] = featuresCount;
@@ -379,7 +374,7 @@ export function getPackedModel(model: any): any {
 
   // pack mean values of training data
   floats = new Float32Array(buffer, offset, featuresCount);
-  floats.set(model.means.getRawData());  
+  floats.set(model.means.getRawData());
   offset += featuresCount * BYTES;
 
   // pack standard deviations of training data
@@ -389,7 +384,7 @@ export function getPackedModel(model: any): any {
 
   // pack model paramters
   floats = new Float32Array(buffer, offset, samplesCount + LS_SVM_ADD_CONST);
-  floats.set(model.modelParams.getRawData());  
+  floats.set(model.modelParams.getRawData());
   offset += (samplesCount + LS_SVM_ADD_CONST) * BYTES;
 
   // pack model's precomputed weights
@@ -403,40 +398,39 @@ export function getPackedModel(model: any): any {
     floats.set(col.getRawData());
     offset += featuresCount * BYTES;
   }
-  
-  return result;  
+
+  return result;
 } // getPackedModel
 
 // Returns unpacked model
 function getUnpackedModel(packedModel: any): any {
-
-  let modelBytes = packedModel.buffer;
+  const modelBytes = packedModel.buffer;
   let offset = 0;
 
   // extract kernel type and sizes
-  let header = new Int32Array(modelBytes, offset, INTS_COUNT);  
+  const header = new Int32Array(modelBytes, offset, INTS_COUNT);
   offset += INTS_COUNT * BYTES;
-  let samplesCount = header[SAMPLES_COUNT_INDEX];
-  let featuresCount = header[FEATURES_COUNT_INDEX];     
-  
+  const samplesCount = header[SAMPLES_COUNT_INDEX];
+  const featuresCount = header[FEATURES_COUNT_INDEX];
+
   // extract parameters of kernel
-  const kernelParams = DG.Column.fromFloat32Array(KERNEL_PARAMS, 
+  const kernelParams = DG.Column.fromFloat32Array(KERNEL_PARAMS,
     new Float32Array(modelBytes, offset, KER_PARAMS_COUNT));
   offset += KER_PARAMS_COUNT * BYTES;
 
   // extract training labels
   const trainLabels = DG.Column.fromFloat32Array(LABELS,
-    new Float32Array(modelBytes, offset, samplesCount));  
-  offset += samplesCount * BYTES;  
+    new Float32Array(modelBytes, offset, samplesCount));
+  offset += samplesCount * BYTES;
 
   // extract mean values of training data
-  const means = DG.Column.fromFloat32Array( MEAN, 
-   new Float32Array(modelBytes, offset, featuresCount));  
+  const means = DG.Column.fromFloat32Array( MEAN,
+    new Float32Array(modelBytes, offset, featuresCount));
   offset += featuresCount * BYTES;
 
   // extract standard deviations of training data
   const stdDevs = DG.Column.fromFloat32Array( STD_DEV,
-    new Float32Array(modelBytes, offset, featuresCount));  
+    new Float32Array(modelBytes, offset, featuresCount));
   offset += featuresCount * BYTES;
 
   // extract parameters of model
@@ -446,11 +440,11 @@ function getUnpackedModel(packedModel: any): any {
 
   // extract model's precomputed weights
   const modelWeights = DG.Column.fromFloat32Array( MODEL_WEIGHTS_NAME,
-    new Float32Array(modelBytes, offset, featuresCount + LS_SVM_ADD_CONST));  
+    new Float32Array(modelBytes, offset, featuresCount + LS_SVM_ADD_CONST));
   offset += (featuresCount + LS_SVM_ADD_CONST) * BYTES;
 
   // extract training data columns
-  let dataCols = [];
+  const dataCols = [];
 
   for (let i = 0; i < samplesCount; i++) {
     dataCols.push( DG.Column.fromFloat32Array( i.toString(),
@@ -458,28 +452,27 @@ function getUnpackedModel(packedModel: any): any {
     offset += featuresCount * BYTES;
   }
 
-  const normalizedTrainData = DG.DataFrame.fromColumns(dataCols);  
+  const normalizedTrainData = DG.DataFrame.fromColumns(dataCols);
 
-  let model = { kernelType: header[MODEL_KERNEL_INDEX],
+  const model = {kernelType: header[MODEL_KERNEL_INDEX],
     kernelParams: kernelParams,
     trainLabels: trainLabels,
     means: means,
     stdDevs: stdDevs,
     modelParams: modelParams,
     modelWeights: modelWeights,
-    normalizedTrainData: normalizedTrainData
+    normalizedTrainData: normalizedTrainData,
   };
 
-  return model;  
+  return model;
 } // getUnpackedModel
 
 // Wrapper for combining the function "predict" with Datagrok predicitve tools
-export async function getPrediction(df: DG.DataFrame, packedModel: any): Promise<DG.DataFrame> { 
-
-  let model = getUnpackedModel(new Uint8Array(packedModel));
+export async function getPrediction(df: DG.DataFrame, packedModel: any): Promise<DG.DataFrame> {
+  const model = getUnpackedModel(new Uint8Array(packedModel));
 
-  let res = await predict(model, df.columns);
-  res.name = PREDICTION;  
+  const res = await predict(model, df.columns);
+  res.name = PREDICTION;
 
   return DG.DataFrame.fromColumns([res]);
 } // getPrediction

package/src/utils.ts

@@ -30,7 +30,7 @@ const INCORRECT_LEARNING_RATE_MES = 'learning rate must be positive.';
 const INCORRECT_PERPLEXITY_MES = 'perplexity must be at least 2 and not greater than samples count.';
 const INCORRECT_STEPS_MES = 'steps must be non-negative.';
 const INCORRECT_CYCLES_MES = 'cycles must be positive.';
-const INCORRECT_CUTOFF_MES = 'cutoff must be non-negative.'
+const INCORRECT_CUTOFF_MES = 'cutoff must be non-negative.';
 
 // Check column type
 export function checkColumnType(col: DG.Column): void {
@@ -52,8 +52,7 @@ export function checkDimensionReducerInputs(features: DG.ColumnList, components:
 
 // Check UMAP inputs
 export function checkUMAPinputs(features: DG.ColumnList, components: number, epochs: number,
-  neighbors: number, minDist: number, spread: number): void 
-{
+  neighbors: number, minDist: number, spread: number): void {
   // General dim reducer checks
   checkDimensionReducerInputs(features, components);
 
@@ -73,13 +72,12 @@ export function checkUMAPinputs(features: DG.ColumnList, components: number, epo
     throw new Error(INCORRECT_EPOCH_MES);
 
   if ((neighbors < 2) || (neighbors > features.byIndex(0).length))
-    throw new Error(INCORRECT_NEIBORS_MES);  
+    throw new Error(INCORRECT_NEIBORS_MES);
 }
 
 // Check t-SNE inputs
-export function checkTSNEinputs(features: DG.ColumnList, components: number, 
-  learningRate: number, perplexity: number, iterations: number): void 
-{
+export function checkTSNEinputs(features: DG.ColumnList, components: number,
+  learningRate: number, perplexity: number, iterations: number): void {
   // General dim reducer checks
   checkDimensionReducerInputs(features, components);
 
@@ -96,13 +94,12 @@ export function checkTSNEinputs(features: DG.ColumnList, components: number,
     throw new Error(INCORRECT_ITERATIONS_MES);
 
   if ((perplexity < 2) || (perplexity > features.byIndex(0).length))
-    throw new Error(INCORRECT_PERPLEXITY_MES);  
+    throw new Error(INCORRECT_PERPLEXITY_MES);
 }
 
 // Check SPE inputs
 export function checkSPEinputs(features: DG.ColumnList, dimension: number,
-  steps: number, cycles: number, cutoff: number, lambda: number): void 
-{
+  steps: number, cycles: number, cutoff: number, lambda: number): void {
   // General dim reducer checks
   checkDimensionReducerInputs(features, dimension);
 
@@ -136,16 +133,15 @@ export function checkWasmDimensionReducerInputs(features: DG.ColumnList, compone
 }
 
 // Check inputs of data for SVM testing generator
-export function checkGeneratorSVMinputs(samplesCount: number, featuresCount: number, 
-  min: number, max: number, violatorsPercentage: number): void 
-{
+export function checkGeneratorSVMinputs(samplesCount: number, featuresCount: number,
+  min: number, max: number, violatorsPercentage: number): void {
   if (min >= max)
     throw new Error(INCORERRECT_MIN_MAX_MES);
-  
-  if (featuresCount < FEATURES_COUNT_MIN) 
+
+  if (featuresCount < FEATURES_COUNT_MIN)
     throw new Error(INCORERRECT_FEATURES_MES);
 
-  if (samplesCount < SAMPLES_COUNT_MIN) 
+  if (samplesCount < SAMPLES_COUNT_MIN)
     throw new Error(INCORERRECT_SAMPLES_MES);
 
   if ((violatorsPercentage < PERCENTAGE_MIN) || (violatorsPercentage > PERCENTAGE_MAX))
@@ -156,7 +152,7 @@ export function checkGeneratorSVMinputs(samplesCount: number, featuresCount: num
 export function getRowsOfNumericalColumnns(columnList: DG.ColumnList): any[][] {
   const columns = columnList.toList();
   const rowCount = columns[0].length;
-  const colCount = columns.length;  
+  const colCount = columns.length;
 
   const output = [] as any[][];
 

package/src/workers/tsne-worker.ts

@@ -2,19 +2,19 @@
 
 import {TSNE} from '@keckelt/tsne';
 
-onmessage = async function (evt) {
+onmessage = async function(evt) {
   const tsne = new TSNE({
     epsilon: evt.data.options.learningRate,
     perplexity: evt.data.options.perplexity,
-    dim: evt.data.options.components
+    dim: evt.data.options.components,
   });
-      
+
   tsne.initDataRaw(evt.data.data);
 
   const iterCount = evt.data.options.iterations;
-      
-  for(let i = 0; i < iterCount; ++i)
+
+  for (let i = 0; i < iterCount; ++i)
     tsne.step();
 
   postMessage({'embeddings': tsne.getSolution()});
-}
+};

package/src/workers/umap-worker.ts

@@ -1,9 +1,9 @@
 // Worker for the method UMAP
 
-import { UMAP } from 'umap-js';
+import {UMAP} from 'umap-js';
 
-onmessage = async function (evt) {
+onmessage = async function(evt) {
   const umap = new UMAP(evt.data.options);
   const embeddings = umap.fit(evt.data.data);
   postMessage({'embeddings': embeddings});
-}
+};