@datagrok/eda 1.4.13 → 1.5.0

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@datagrok/eda",
   "friendlyName": "EDA",
-  "version": "1.4.13",
+  "version": "1.5.0",
   "description": "Exploratory Data Analysis Tools",
   "dependencies": {
     "@datagrok-libraries/math": "^1.2.6",
-    "@datagrok-libraries/ml": "^6.10.8",
-    "@datagrok-libraries/statistics": "^1.10.0",
+    "@datagrok-libraries/ml": "^6.10.10",
+    "@datagrok-libraries/statistics": "^1.12.0",
     "@datagrok-libraries/tutorials": "^1.7.4",
-    "@datagrok-libraries/utils": "^4.6.5",
+    "@datagrok-libraries/utils": "^4.7.0",
     "@keckelt/tsne": "^1.0.2",
     "@webgpu/types": "^0.1.40",
     "cash-dom": "^8.1.1",
-    "datagrok-api": "^1.26.3",
+    "datagrok-api": "^1.27.0",
     "dayjs": "^1.11.9",
     "jstat": "^1.9.6",
     "mathjs": "^15.1.0",

package/src/package.ts

@@ -1027,8 +1027,9 @@ export class PackageFunctions {
     'outputs': [{name: 'Synthetic', type: 'dataframe'}],
   })
   static async generatePmpoDataset(@grok.decorators.param({'type': 'int'}) samples: number): Promise<DG.DataFrame> {
-    const df = await getSynteticPmpoData(samples);
+    const df = await getSynteticPmpoData(samples, false);
     df.name = 'Synthetic';
     return df;
   }
+
 }

package/src/pareto-optimization/pareto-optimizer.ts

@@ -19,7 +19,7 @@ export class ParetoOptimizer {
   private toUpdatePcCols = false;
   private paretoFrontViewer: DG.Viewer;
   private resultColName: string;
-  private intervalId: NodeJS.Timeout | null = null;
+  private intervalId: ReturnType<typeof setInterval> | null = null;
   private inputsMap = new Map<string, DG.InputBase>();
   private pcPlotNode: DG.DockNode | null = null;
   private inputFormNode: DG.DockNode | null = null;

package/src/pls/pls-constants.ts

@@ -17,8 +17,10 @@ export enum ERROR_MSG {
   ENOUGH = 'Not enough of features',
   COMP_LIN_PLS = 'Components count must be less than the number of features',
   COMP_QUA_PLS = 'Too large components count for the quadratic PLS regression',
-  COMPONENTS = 'Components count must be greater than 1',
+  COMP_ROWS = 'Components count must not exceed the number of rows',
+  COMPONENTS = 'Components count must be at least 1',
   INV_INP = 'Invalid inputs',
+  NULL_COMPS = 'Components count is not specified',
 }
 
 /** Widget titles */

package/src/pls/pls-tools.ts

@@ -36,6 +36,24 @@ export type PlsInput = {
 
 type TypedArray = Int32Array | Float32Array | Uint32Array | Float64Array;
 
+/** Set style for input element depending on the validity of the value */
+function setStyle(valid: boolean, element: HTMLElement, tooltip: string, errorMsg: string) {
+  if (valid) {
+    element.style.color = COLOR.VALID_TEXT;
+    element.style.borderBottomColor = COLOR.VALID_LINE;
+    ui.tooltip.bind(element, tooltip);
+  } else {
+    element.style.color = COLOR.INVALID;
+    element.style.borderBottomColor = COLOR.INVALID;
+    ui.tooltip.bind(element, () => {
+      const hint = ui.label(tooltip);
+      const err = ui.label(errorMsg);
+      err.style.color = COLOR.INVALID;
+      return ui.divV([hint, err]);
+    });
+  }
+};
+
 /** Return lines */
 export function getLines(names: string[]): DG.FormulaLine[] {
   const lines: DG.FormulaLine[] = [];
@@ -137,7 +155,7 @@ function getQuadraticPlsInput(input: PlsInput): PlsInput {
 
     for (let j = i; j < colsCount; ++j) {
       col2 = cols[j];
-      raw2 = col2.getRawData();      
+      raw2 = col2.getRawData();
       qaudrRaw = new Float32Array(rowsCount);
 
       for (let k = 0; k < rowsCount; ++k)
@@ -268,7 +286,7 @@ async function performMVA(input: PlsInput, analysisType: PLS_ANALYSIS): Promise<
   });
 
 
-  // 4.3) create lines & circles  
+  // 4.3) create lines & circles
   view.addViewer(scoresScatter);
   scoresScatter.meta.formulaLines.addAll(getLines(scoreNames));
 
@@ -321,7 +339,7 @@ async function performMVA(input: PlsInput, analysisType: PLS_ANALYSIS): Promise<
   }));
 
   // emphasize viewers in the demo case
-  if (analysisType === PLS_ANALYSIS.DEMO) {    
+  if (analysisType === PLS_ANALYSIS.DEMO) {
     grok.shell.windows.help.showHelp(ui.markdown(DEMO_RESULTS_MD));
 
     describeElements(
@@ -372,38 +390,32 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
     return;
   }
 
-  let features: DG.Column[] = numCols.slice(0, numCols.length - 1);
-  let predict = numCols[numCols.length - 1];
-  let components = min(numColNames.length - 1, COMPONENTS.DEFAULT as number);
-  let isQuadratic = false;
-
-  const isPredictValid = () => {
-    for (const col of features)
-      if (col.name === predict.name)
-        return false;
-    return true;
+  const doFeaturesIncludePredict = () => {
+    return featuresInput.value.some((col) => col.name === predictInput.value!.name);
   };
 
   const isCompConsistent = () => {
-    if (components < 1)
+    if (componentsInput.value! < 1)
       return false;
 
-    const n = features.length;
+    if (componentsInput.value! > table.rowCount)
+      return false;
 
-    if (isQuadratic)      
-      return components <= (n + 1) * n / 2 + n;
+    const n = featuresInput.value.length;
 
-    return components <= n;
-  }
+    if (isQuadraticInput.value)
+      return componentsInput.value! <= (n + 1) * n / 2 + n;
+
+    return componentsInput.value! <= n;
+  };
 
   // response (to predict)
   const predictInput = ui.input.column(TITLE.PREDICT, {
     table: table,
-    value: predict,
+    value: numCols[numCols.length - 1],
     nullable: false,
-    onValueChanged: (value) => {
-      predict = value;
-      updateIputs();
+    onValueChanged: (_) => {
+      updateInputStyles();
     },
     filter: (col: DG.Column) => isValidNumeric(col),
     tooltipText: HINT.PREDICT,
@@ -413,21 +425,21 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
   const featuresInput = ui.input.columns(TITLE.USING, {
     table: table,
     available: numColNames,
-    value: features,
-    onValueChanged: (val) => {
-      features = val;
-      updateIputs();      
+    value: numCols.slice(0, numCols.length - 1),
+    onValueChanged: (_) => {
+      updateInputStyles();
     },
     tooltipText: HINT.FEATURES,
+    nullable: false,
   });
 
   // components count
   const componentsInput = ui.input.int(TITLE.COMPONENTS, {
-    value: components,
+    value: min(numColNames.length - 1, COMPONENTS.DEFAULT as number),
     showPlusMinus: true,
-    onValueChanged: (val) => {
-      components = val;
-      updateIputs();
+    nullable: false,
+    onValueChanged: (_) => {
+      updateInputStyles();
     },
     tooltipText: HINT.COMPONENTS,
   });
@@ -446,28 +458,14 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
     dlgRunBtnTooltip = HINT.MVA;
   }
 
-  const setStyle = (valid: boolean, element: HTMLElement, tooltip: string, errorMsg: string) => {
-    if (valid) {
-      element.style.color = COLOR.VALID_TEXT;
-      element.style.borderBottomColor = COLOR.VALID_LINE;
-      ui.tooltip.bind(element, tooltip);
-    } else {
-      element.style.color = COLOR.INVALID;
-      element.style.borderBottomColor = COLOR.INVALID;
-      ui.tooltip.bind(element, () => {
-        const hint = ui.label(tooltip);
-        const err = ui.label(errorMsg);
-        err.style.color = COLOR.INVALID;
-        return ui.divV([hint, err]);
-      });
-    }    
-  };
-
-  const updateIputs = () => {
-    const predValid = isPredictValid();
+  const updateInputStyles = () => {
+    const featuresValid = featuresInput.value.length >= 1;
+    const predValid = featuresValid && !doFeaturesIncludePredict();
     let compValid: boolean;
 
-    if (predValid) {
+    if (!featuresValid)
+      setStyle(false, featuresInput.input, HINT.FEATURES, ERROR_MSG.ENOUGH);
+    else if (predValid) {
       setStyle(true, predictInput.input, HINT.PREDICT, '');
       setStyle(true, featuresInput.input, HINT.FEATURES, '');
     } else {
@@ -475,9 +473,12 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
       setStyle(false, featuresInput.input, HINT.FEATURES, ERROR_MSG.PREDICT);
     }
 
-    if (components < 1) {
+    if (componentsInput.value == null) {
+      setStyle(false, componentsInput.input, HINT.COMPONENTS, ERROR_MSG.NULL_COMPS);
+      compValid = false;
+    } else if (componentsInput.value < 1) {
       setStyle(false, componentsInput.input, HINT.COMPONENTS, ERROR_MSG.COMPONENTS);
-      compValid = false;  
+      compValid = false;
     } else {
       compValid = isCompConsistent();
 
@@ -486,7 +487,9 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
         if (predValid)
           setStyle(true, featuresInput.input, HINT.FEATURES, '');
       } else {
-        const errMsg = isQuadratic ? ERROR_MSG.COMP_QUA_PLS : ERROR_MSG.COMP_LIN_PLS;
+        const errMsg = componentsInput.value! > table.rowCount ?
+          ERROR_MSG.COMP_ROWS :
+          isQuadraticInput.value ? ERROR_MSG.COMP_QUA_PLS : ERROR_MSG.COMP_LIN_PLS;
         setStyle(false, componentsInput.input, HINT.COMPONENTS, errMsg);
         setStyle(false, featuresInput.input, HINT.FEATURES, ERROR_MSG.ENOUGH);
       }
@@ -497,10 +500,18 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
     dlg.getButton(TITLE.RUN).disabled = !isValid;
 
     return isValid;
+  }; // updateInputStyles
+
+  const getStrColWithUniqueVals = () => {
+    for (const col of strCols) {
+      if (col.stats.uniqueCount === table.rowCount)
+        return col;
+    }
+    return undefined;
   };
 
   // names of samples
-  let names = (strCols.length > 0) ? strCols[0] : undefined;
+  let names = getStrColWithUniqueVals();
   const namesInputs = ui.input.column(TITLE.NAMES, {
     table: table,
     value: names,
@@ -512,11 +523,10 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
 
   // quadratic/linear model
   const isQuadraticInput = ui.input.bool(TITLE.QUADRATIC, {
-    value: isQuadratic,
+    value: false,
     tooltipText: HINT.QUADRATIC,
-    onValueChanged: (val) => {
-      isQuadratic = val;
-      updateIputs();
+    onValueChanged: (_) => {
+      updateInputStyles();
     },
   });
 
@@ -527,21 +537,15 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
 
       await performMVA({
         table: table,
-        features: DG.DataFrame.fromColumns(features).columns,
-        predict: predict,
-        components: components,
-        isQuadratic: isQuadratic,
+        features: DG.DataFrame.fromColumns(featuresInput.value).columns,
+        predict: predictInput.value!,
+        components: componentsInput.value!,
+        isQuadratic: isQuadraticInput.value,
         names: names,
       }, analysisType);
     }, undefined, dlgRunBtnTooltip)
     .show({x: X_COORD, y: Y_COORD});
 
-  // the following delay provides correct styles (see https://reddata.atlassian.net/browse/GROK-15196)
-  setTimeout(() => {
-    featuresInput.value = numCols.filter((col) => col !== predict);
-    features = featuresInput.value;
-  }, TIMEOUT);
-
   grok.shell.v.append(dlg.root);
 } // runMVA
 

package/src/probabilistic-scoring/data-generator.ts

@@ -11,12 +11,57 @@ import * as jStat from 'jstat';
 /** Generates synthetic data for pMPO model training and testing
  * @param samplesCount Number of samples to generate
  * @returns DataFrame with generated data */
-export async function getSynteticPmpoData(samplesCount: number): Promise<DG.DataFrame> {
+export async function getSynteticPmpoData(samplesCount: number, isTest: boolean = true): Promise<DG.DataFrame> {
   const df = await grok.dapi.files.readCsv(SOURCE_PATH);
   const generator = new PmpoDataGenerator(df, 'Drug', 'CNS', 'Smiles');
+  const genTable = generator.getGenerated(samplesCount);
+
+  if (!isTest) {
+    genTable.columns.add(DG.Column.fromList(DG.COLUMN_TYPE.BOOL, 'Const bool', new Array(samplesCount).fill(true)));
+    genTable.columns.add(DG.Column.fromInt32Array('Const int', new Int32Array(samplesCount).fill(1)));
+
+    // Add a copy of the first numeric column with 5 missing values
+    const firstNumCol = genTable.columns.toList().find((col) => col.isNumerical);
+    if (firstNumCol) {
+      const colWithMissing = firstNumCol.clone();
+      colWithMissing.name = `${firstNumCol.name} (missing)`;
+      for (let i = 0; i < Math.min(5, colWithMissing.length); ++i)
+        colWithMissing.set(i, DG.FLOAT_NULL);
+      genTable.columns.add(colWithMissing);
+    }
+
+    // Add a column with all null values
+    genTable.columns.add(DG.Column.fromFloat32Array('Nulls', new Float32Array(samplesCount).fill(DG.FLOAT_NULL)));
+
+    // Add categorical columns
+    const categoricalCols = getCategoricalColumns(genTable.col('CNS')!, samplesCount);
+    for (const col of categoricalCols)
+      genTable.columns.add(col);
+  }
+
+  return genTable;
+} // getSynteticPmpoData
+
+/** Generates categorical columns based on a boolean source column
+ * @param sourceBoolCol Source boolean column to base the categorical columns on
+ * @param samplesCount Number of samples to generate
+ * @returns Array of generated categorical columns */
+function getCategoricalColumns(sourceBoolCol: DG.Column, samplesCount: number): DG.Column[] {
+  const source = sourceBoolCol.toList();
+  const stringLabels = new Array<string>(samplesCount);
+  const threeCats = new Array<string>(samplesCount);
+
+  for (let i = 0; i < samplesCount; ++i) {
+    stringLabels[i] = source[i] ? 'active' : 'non-active';
+    threeCats[i] = source[i] ? (Math.random() < 0.5 ? 'perfect' : 'good') : (Math.random() < 0.5 ? 'bad' : 'worst');
+  }
 
-  return generator.getGenerated(samplesCount);
-}
+  return [
+    DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'CNS (strings)', stringLabels),
+    DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'CNS (4 categories)', threeCats),
+    DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'Single category', new Array<string>(samplesCount).fill('Unknown')),
+  ];
+} // getCategoricalColumns
 
 /** Class for generating synthetic data for pMPO model training and testing */
 export class PmpoDataGenerator {

package/src/probabilistic-scoring/pmpo-defs.ts

@@ -1,5 +1,5 @@
 // Constants and type definitions for probabilistic scoring (pMPO)
-// Link: https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
+// Source paper https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
 
 /** Minimum number of samples required to compute pMPO */
 export const MIN_SAMPLES_COUNT = 10;
@@ -208,7 +208,8 @@ export type OptimalPoint = {
   pValTresh: number,
   r2Tresh: number,
   qCutoff: number,
-  success: boolean,
+  state: 'success' | 'canceled' | 'failed',
+  msg: string,
 };
 
 /** Minimum bounds for pMPO parameters during optimization */
@@ -216,3 +217,30 @@ export const LOW_PARAMS_BOUNDS = new Float32Array([0.5, Q_CUTOFF_MIN]);
 
 /** Maximum bounds for pMPO parameters during optimization */
 export const HIGH_PARAMS_BOUNDS = new Float32Array([R2_MAX, Q_CUTOFF_MAX]);
+
+export enum EQUALITY_SIGN {
+  GREATER = '>',
+  LESS = '<',
+  GREATER_OR_EQUAL = '≥',
+  LESS_OR_EQUAL = '≤',
+  DEFAULT = LESS_OR_EQUAL,
+};
+
+export const SIGN_OPTIONS = [
+  EQUALITY_SIGN.GREATER,
+  EQUALITY_SIGN.LESS,
+  EQUALITY_SIGN.GREATER_OR_EQUAL,
+  EQUALITY_SIGN.LESS_OR_EQUAL,
+];
+
+export const THRESHOLDED_DESIRABILITY_COL_NAME = 'Desirability';
+
+export const PREFERABLE_CATEGORIES = ['perfect', 'good', 'true', 't', 'g', 'active', 'a', 'yes', 'y'];
+
+export type PmpoInputId = 'descriptors' | 'desirability' | 'threshold' | 'categories';
+export type TooltipContent = string | (() => HTMLElement);
+
+export interface PmpoValidationResult {
+  valid: boolean;
+  errors: Map<PmpoInputId, TooltipContent>;
+}

package/src/probabilistic-scoring/pmpo-utils.ts

@@ -1,16 +1,18 @@
 // Utility functions for probabilistic scoring (pMPO)
-// Link: https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
+// Source paper https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
 
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import {generateMpoFileName, MPO_PROFILE_CHANGED_EVENT} from '@datagrok-libraries/statistics/src/mpo/utils';
 import '../../css/pmpo.css';
 
 import {COLORS, DESCR_TABLE_TITLE, DESCR_TITLE, DescriptorStatistics, DesirabilityProfileProperties,
   DESIRABILITY_COL_NAME, FOLDER, P_VAL, PMPO_COMPUTE_FAILED, PmpoParams, SCORES_TITLE,
   SELECTED_TITLE, STAT_TO_TITLE_MAP, TINY, WEIGHT_TITLE, CorrelationTriple,
-  BASIC_RANGE_SIGMA_COEFFS, EXTENDED_RANGE_SIGMA_COEFFS} from './pmpo-defs';
+  BASIC_RANGE_SIGMA_COEFFS, EXTENDED_RANGE_SIGMA_COEFFS, EQUALITY_SIGN,
+  PREFERABLE_CATEGORIES} from './pmpo-defs';
 import {computeSigmoidParamsFromX0, getCutoffs, gaussDesirabilityFunc, sigmoidS,
   solveNormalIntersection} from './stat-tools';
 import {getColorScaleDiv} from '../pareto-optimization/utils';
@@ -369,38 +371,13 @@ export function getDesirabilityProfileJson(params: Map<string, PmpoParams>, useS
  */
 export async function saveModel(params: Map<string, PmpoParams>, modelName: string,
   useSigmoidalCorrection: boolean): Promise<void> {
-  let fileName = modelName;
-  const nameInput = ui.input.string('File', {
-    value: fileName,
-    nullable: false,
-    onValueChanged: (val) => {
-      fileName = val;
-      dlg.getButton('Save').disabled = (fileName.length < 1) || (folderName.length < 1);
-    },
-  });
-
-  let folderName = FOLDER;
-  const folderInput = ui.input.string('Folder', {
-    value: folderName,
-    nullable: false,
-    onValueChanged: (val) => {
-      folderName = val;
-      dlg.getButton('Save').disabled = (fileName.length < 1) || (folderName.length < 1);
-    },
+  const nameInput = ui.input.string('Name', {value: modelName, nullable: false});
+  const descriptionInput = ui.input.textArea('Description', {value: ' ', nullable: true});
+  const typeInput = ui.input.bool('Desirability Profile', {
+    value: true,
+    tooltipText: 'Save the model as an MPO Desirability Profile. If disabled, the model is saved in the pMPO format.',
   });
 
-  const save = async () => {
-    const path = `${folderName}/${fileName}.json`;
-    try {
-      const jsonString = JSON.stringify(objectToSave(), null, 2);
-      await grok.dapi.files.writeAsText(path, jsonString);
-      grok.shell.info(`Saved to ${path}`);
-    } catch (err) {
-      grok.shell.error(`Failed to save: ${err instanceof Error ? err.message : 'the platform issue'}.`);
-    }
-    dlg.close();
-  };
-
   const objectToSave = () => {
     if (typeInput.value) {
       return getDesirabilityProfileJson(
@@ -420,34 +397,29 @@ export async function saveModel(params: Map<string, PmpoParams>, modelName: stri
     };
   };
 
-  const modelNameInput = ui.input.string('Name', {value: modelName, nullable: true});
-  const descriptionInput = ui.input.textArea('Description', {value: ' ', nullable: true});
-  const typeInput = ui.input.bool('Desirability Profile', {
-    value: true,
-    tooltipText: 'Save the model as an MPO Desirability Profile. If disabled, the model is saved in the pMPO format.',
-  });
-
   const dlg = ui.dialog({title: 'Save model'})
-    .add(ui.h2('Path'))
-    .add(folderInput)
     .add(nameInput)
-    .add(ui.h2('Model'))
-    .add(modelNameInput)
     .add(descriptionInput)
     .add(typeInput)
     .addButton('Save', async () => {
-      const exist = await grok.dapi.files.exists(`${folderName}/${fileName}.json`);
-      if (!exist)
-        await save();
-      else {
-        // Handle overwrite confirmation
-        ui.dialog({title: 'Warning'})
-          .add(ui.label('Overwrite existing file?'))
-          .onOK(async () => await save())
-          .show();
+      try {
+        const files = await grok.dapi.files.list(FOLDER);
+        const existingFileNames = new Set(files.map((f) => f.name));
+        const fileName = generateMpoFileName(nameInput.value, existingFileNames);
+        const path = `${FOLDER}/${fileName}`;
+        const jsonString = JSON.stringify(objectToSave(), null, 2);
+        await grok.dapi.files.writeAsText(path, jsonString);
+        grok.events.fireCustomEvent(MPO_PROFILE_CHANGED_EVENT, {});
+        grok.shell.info(`Saved to ${path}`);
+      } catch (err) {
+        grok.shell.error(`Failed to save: ${err instanceof Error ? err.message : 'the platform issue'}.`);
       }
+      dlg.close();
     })
     .show();
+
+  dlg.getButton('Save').disabled = !nameInput.validate();
+  nameInput.onInput.subscribe(() => dlg.getButton('Save').disabled = !nameInput.validate());
 } // saveModel
 
 /** Adds columns with correlation coefficients between descriptors.
@@ -601,3 +573,122 @@ export class PmpoError extends Error {
     this.name = 'PmpoError';
   }
 }
+
+/** Returns the initial column for the desirability input, preferring boolean columns.
+ * @param cols List of columns to choose from.
+ * @return The initial column for the desirability input.
+*/
+export function getInitCol(cols: DG.Column[]): DG.Column {
+  for (const col of cols) {
+    if ((col.type === DG.COLUMN_TYPE.BOOL) && (col.stats.stdev > 0))
+      return col;
+  }
+
+  for (const col of cols) {
+    if ((col.isNumerical) && (col.stats.stdev > 0))
+      return col;
+  }
+
+  return cols[0];
+}
+
+/** Returns a comparator function based on the given equality sign.
+ * @param sign Equality sign ('<', '<=', '>', '>=').
+ * @return Comparator function that takes two numbers and returns a boolean.
+*/
+function getComparator(sign: EQUALITY_SIGN): (a: number, b: number) => boolean {
+  switch (sign) {
+  case EQUALITY_SIGN.LESS: return (a, b) => a < b;
+  case EQUALITY_SIGN.LESS_OR_EQUAL: return (a, b) => a <= b;
+  case EQUALITY_SIGN.GREATER: return (a, b) => a > b;
+  case EQUALITY_SIGN.GREATER_OR_EQUAL: return (a, b) => a >= b;
+
+  default:
+    throw new Error(`Unsupported sign: ${sign}`);
+  }
+}
+
+/** Converts a numeric column to a boolean column based on the given threshold and equality sign.
+ * @param numericCol Numeric column to convert.
+ * @param threshold Threshold value for comparison.
+ * @param sign Equality sign for comparison ('<', '<=', '>', '>=').
+ * @return Boolean column resulting from the comparison.
+*/
+export function getBoolDesirabilityColData(numericCol: DG.Column,
+  threshold: number, sign: EQUALITY_SIGN): {column: DG.Column, tooltip: string} {
+  const boolArr = new Array<boolean>(numericCol.length);
+  const numericArr = numericCol.getRawData();
+
+  const comparator = getComparator(sign);
+
+  for (let i = 0; i < numericCol.length; ++i)
+    boolArr[i] = comparator(numericArr[i], threshold);
+
+  return {
+    column: DG.Column.fromList(DG.COLUMN_TYPE.BOOL, '', boolArr),
+    tooltip: `Desirability based on the condition:\n\n **${numericCol.name} ${sign} ${threshold}**`,
+  };
+}
+
+/** Checks whether the desirability column is valid based on the given threshold and equality sign.
+ * @param desCol Desirability column to check.
+ * @param threshold Threshold value for comparison.
+ * @param sign Equality sign for comparison ('<', '<=', '>', '>=').
+ * @return True if the desirability column is valid, false otherwise.
+*/
+export function isDesirabilityValid(desCol: DG.Column, threshold: number, sign: EQUALITY_SIGN): boolean {
+  const min = desCol.stats.min;
+  const max = desCol.stats.max;
+
+  switch (sign) {
+  case EQUALITY_SIGN.LESS:
+    return (max >= threshold) && (min < threshold);
+
+  case EQUALITY_SIGN.LESS_OR_EQUAL:
+    return (max > threshold) && (min <= threshold);
+
+  case EQUALITY_SIGN.GREATER:
+    return (min <= threshold) && (max > threshold);
+
+  default:
+    return (min < threshold) && (max >= threshold);
+  }
+}
+
+/** Converts a string column to a boolean column based on the given desirable categories.
+ * @param stringCol String column to convert.
+ * @param desirableCategories List of categories that should be considered as desirable.
+ * @return Boolean column resulting from the conversion and a tooltip describing the desirability.
+*/
+export function getDesirabilityColumnFromCategories(stringCol: DG.Column, desirableCategories: string[]):
+ {column: DG.Column, tooltip: string} {
+  const boolArr = new Array<boolean>(stringCol.length);
+  const raw = stringCol.getRawData();
+  const categories = stringCol.categories;
+
+  for (let i = 0; i < stringCol.length; ++i)
+    boolArr[i] = desirableCategories.includes(categories[raw[i]]);
+
+  const nonDesirableCategories = categories.filter((cat) => !desirableCategories.includes(cat));
+
+  const c = `\u2705 ${desirableCategories.join(', ')}`;
+  const unchecked = `\u274c ${nonDesirableCategories.join(', ')}`;
+
+  return {
+    column: DG.Column.fromList(DG.COLUMN_TYPE.BOOL, '', boolArr),
+    tooltip: `Desirability based on the selected categories:\n\n **${c}**\n\n **${unchecked}**`,
+  };
+} // getDesirabilityColumnFromCategories
+
+/** Returns a list of selected categories based on the given list of categories and preferable categories.
+ * @param categories List of categories to select from.
+ * @return List of selected categories.
+*/
+export function getSelectedCategories(categories: string[]): string[] {
+  const selected = categories.filter((cat) => PREFERABLE_CATEGORIES.includes(cat));
+
+  if (selected.length > 0)
+    return selected;
+
+  return [categories[0]];
+}