@datagrok/peptides 1.17.0 → 1.17.2

package/src/utils/algorithms.ts

@@ -2,59 +2,104 @@ import * as DG from 'datagrok-api/dg';
 import * as C from './constants';
 import * as type from './types';
 import {ParallelMutationCliffs} from './parallel-mutation-cliffs';
-import {CLUSTER_TYPE} from '../model';
+import {CLUSTER_TYPE} from '../viewers/logo-summary';
 import BitArray from '@datagrok-libraries/utils/src/bit-array';
-import {ClusterStats, ClusterTypeStats, MonomerPositionStats, PositionStats, Stats, SummaryStats, getStats} from './statistics';
-
-export type TargetOptions = {targetCol?: type.RawColumn | null, currentTarget?: string | null};
-
+import {
+  ClusterStats,
+  ClusterTypeStats,
+  getStats,
+  MonomerPositionStats,
+  PositionStats,
+  StatsItem,
+  SummaryStats,
+} from './statistics';
+
+export type MutationCliffsOptions = {
+  maxMutations?: number,
+  minActivityDelta?: number,
+  targetCol?: type.RawColumn | null,
+  currentTarget?: string | null
+};
+
+/**
+ * Finds mutation cliffs in the set of sequences.
+ * @param activityArray - Activity column raw data.
+ * @param monomerInfoArray - Split sequence raw columns.
+ * @param options - Options for the mutation cliffs algorithm.
+ * @return - Mutation cliffs map.
+ */
 export async function findMutations(activityArray: type.RawData, monomerInfoArray: type.RawColumn[],
-  settings: type.PeptidesSettings = {}, targetOptions: TargetOptions = {}): Promise<type.MutationCliffs> {
+  options: MutationCliffsOptions = {}): Promise<type.MutationCliffs> {
   const nCols = monomerInfoArray.length;
-  if (nCols === 0)
+  if (nCols === 0) {
     throw new Error(`PepAlgorithmError: Couldn't find any column of semType '${C.SEM_TYPES.MONOMER}'`);
+  }
+
 
-  settings.minActivityDelta ??= 0;
-  settings.maxMutations ??= 1;
-  const substitutionsInfo = await new ParallelMutationCliffs().calc(activityArray, monomerInfoArray, settings, targetOptions);
+  options.minActivityDelta ??= 0;
+  options.maxMutations ??= 1;
+  const mutationCliffsService = new ParallelMutationCliffs();
+  const substitutionsInfo = await mutationCliffsService.calc(activityArray, monomerInfoArray, options);
+  mutationCliffsService.terminate();
   return substitutionsInfo;
 }
 
-export function calculateMonomerPositionStatistics(df: DG.DataFrame, positionColumns: DG.Column<string>[],
-  options: {isFiltered?: boolean, columns?: string[]} = {}): MonomerPositionStats {
+/**
+ * Calculates statistics for each monomer position.
+ * @param activityCol - Activity column.
+ * @param filter - Dataframe filter to consider.
+ * @param positionColumns - Position columns containing monomers.
+ * @param [options] - Options for the algorithm.
+ * @param [options.isFiltered] - Whether the dataframe is filtered.
+ * @param [options.columns] - Columns to consider when calculating statistics.
+ * @return - Statistics for each monomer position.
+ */
+export function calculateMonomerPositionStatistics(activityCol: DG.Column<number>, filter: DG.BitSet,
+  positionColumns: DG.Column<string>[], options: {
+    isFiltered?: boolean,
+    columns?: string[]
+  } = {}): MonomerPositionStats {
   options.isFiltered ??= false;
-  const monomerPositionObject = {general: {}} as MonomerPositionStats & {general: SummaryStats};
-  const activityCol = df.getCol(C.COLUMNS_NAMES.ACTIVITY);
+  const monomerPositionObject = {general: {}} as MonomerPositionStats & { general: SummaryStats };
   let activityColData: Float64Array = activityCol.getRawData() as Float64Array;
-  let sourceDfLen = df.rowCount;
+  let sourceDfLen = activityCol.length;
 
   if (options.isFiltered) {
-    sourceDfLen = df.filter.trueCount;
+    sourceDfLen = filter.trueCount;
     const tempActivityData = new Float64Array(sourceDfLen);
-    const selectedIndexes = df.filter.getSelectedIndexes();
-    for (let i = 0; i < sourceDfLen; ++i)
+    const selectedIndexes = filter.getSelectedIndexes();
+    for (let i = 0; i < sourceDfLen; ++i) {
       tempActivityData[i] = activityColData[selectedIndexes[i]];
+    }
+
+
     activityColData = tempActivityData;
-    positionColumns = DG.DataFrame.fromColumns(positionColumns).clone(df.filter).columns.toList();
+    positionColumns = DG.DataFrame.fromColumns(positionColumns).clone(filter).columns.toList();
   }
   options.columns ??= positionColumns.map((col) => col.name);
 
   for (const posCol of positionColumns) {
-    if (!options.columns.includes(posCol.name))
+    if (!options.columns.includes(posCol.name)) {
       continue;
+    }
+
+
     const posColData = posCol.getRawData();
     const posColCateogries = posCol.categories;
-    const currentPositionObject = {general: {}} as PositionStats & {general: SummaryStats};
+    const currentPositionObject = {general: {}} as PositionStats & { general: SummaryStats };
 
     for (let categoryIndex = 0; categoryIndex < posColCateogries.length; ++categoryIndex) {
       const monomer = posColCateogries[categoryIndex];
-      if (monomer === '')
+      if (monomer === '') {
         continue;
+      }
+
 
       const boolArray: boolean[] = new Array(sourceDfLen).fill(false);
       for (let i = 0; i < sourceDfLen; ++i) {
-        if (posColData[i] === categoryIndex)
+        if (posColData[i] === categoryIndex) {
           boolArray[i] = true;
+        }
       }
       const bitArray = BitArray.fromValues(boolArray);
       const stats = bitArray.allFalse || bitArray.allTrue ?
@@ -69,69 +114,102 @@ export function calculateMonomerPositionStatistics(df: DG.DataFrame, positionCol
   return monomerPositionObject;
 }
 
-export function getSummaryStats(genObj: SummaryStats, stats: Stats | null = null, summaryStats: SummaryStats | null = null): void {
-  if (stats === null && summaryStats === null)
+/**
+ * Calculates summary statistics for the monomer position statistics such as maximum and minimum values for each
+ * statistic in general and on each position.
+ * @param genObj - Object to store the summary statistics to.
+ * @param stats - Statistics for a single monomer position.
+ * @param summaryStats - Summary statistics for all monomer positions.
+ */
+export function getSummaryStats(genObj: SummaryStats, stats: StatsItem | null = null,
+  summaryStats: SummaryStats | null = null): void {
+  if (stats === null && summaryStats === null) {
     throw new Error(`MonomerPositionStatsError: either stats or summaryStats must be present`);
+  }
+
 
   const possibleMaxCount = stats?.count ?? summaryStats!.maxCount;
   genObj.maxCount ??= possibleMaxCount;
-  if (genObj.maxCount < possibleMaxCount)
+  if (genObj.maxCount < possibleMaxCount) {
     genObj.maxCount = possibleMaxCount;
+  }
+
 
   const possibleMinCount = stats?.count ?? summaryStats!.minCount;
   genObj.minCount ??= possibleMinCount;
-  if (genObj.minCount > possibleMinCount)
+  if (genObj.minCount > possibleMinCount) {
     genObj.minCount = possibleMinCount;
+  }
+
 
   const possibleMaxMeanDifference = stats?.meanDifference ?? summaryStats!.maxMeanDifference;
   genObj.maxMeanDifference ??= possibleMaxMeanDifference;
-  if (genObj.maxMeanDifference < possibleMaxMeanDifference)
+  if (genObj.maxMeanDifference < possibleMaxMeanDifference) {
     genObj.maxMeanDifference = possibleMaxMeanDifference;
+  }
+
 
   const possibleMinMeanDifference = stats?.meanDifference ?? summaryStats!.minMeanDifference;
   genObj.minMeanDifference ??= possibleMinMeanDifference;
-  if (genObj.minMeanDifference > possibleMinMeanDifference)
+  if (genObj.minMeanDifference > possibleMinMeanDifference) {
     genObj.minMeanDifference = possibleMinMeanDifference;
+  }
+
 
   if (!isNaN(stats?.pValue ?? NaN)) {
     const possibleMaxPValue = stats?.pValue ?? summaryStats!.maxPValue;
     genObj.maxPValue ??= possibleMaxPValue;
-    if (genObj.maxPValue < possibleMaxPValue)
+    if (genObj.maxPValue < possibleMaxPValue) {
       genObj.maxPValue = possibleMaxPValue;
+    }
+
 
     const possibleMinPValue = stats?.pValue ?? summaryStats!.minPValue;
     genObj.minPValue ??= possibleMinPValue;
-    if (genObj.minPValue > possibleMinPValue)
+    if (genObj.minPValue > possibleMinPValue) {
       genObj.minPValue = possibleMinPValue;
+    }
   }
 
   const possibleMaxRatio = stats?.ratio ?? summaryStats!.maxRatio;
   genObj.maxRatio ??= possibleMaxRatio;
-  if (genObj.maxRatio < possibleMaxRatio)
+  if (genObj.maxRatio < possibleMaxRatio) {
     genObj.maxRatio = possibleMaxRatio;
+  }
+
 
   const possibleMinRatio = stats?.ratio ?? summaryStats!.minRatio;
   genObj.minRatio ??= possibleMinRatio;
-  if (genObj.minRatio > possibleMinRatio)
+  if (genObj.minRatio > possibleMinRatio) {
     genObj.minRatio = possibleMinRatio;
+  }
 }
 
+/**
+ * Calculates statistics for each cluster type.
+ * @param df - Dataframe containing the clusters column.
+ * @param clustersColumnName - Name of the original clusters column.
+ * @param customClusters - Array of custom clusters columns names.
+ * @param activityCol - Activity column.
+ * @return - Statistics for each cluster type.
+ */
 export function calculateClusterStatistics(df: DG.DataFrame, clustersColumnName: string,
-  customClusters: DG.Column<boolean>[]): ClusterTypeStats {
+  customClusters: DG.Column<boolean>[], activityCol: DG.Column<number>): ClusterTypeStats {
   const rowCount = df.rowCount;
   const origClustCol = df.getCol(clustersColumnName);
   const origClustColData = origClustCol.getRawData();
   const origClustColCat = origClustCol.categories;
   const origClustMasks: BitArray[] = Array.from({length: origClustColCat.length},
     () => new BitArray(rowCount, false));
-  for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx)
+  for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx) {
     origClustMasks[origClustColData[rowIdx]].setTrue(rowIdx);
+  }
+
 
   const customClustMasks = customClusters.map(
     (v) => BitArray.fromUint32Array(rowCount, v.getRawData() as Uint32Array));
   const customClustColNamesList = customClusters.map((v) => v.name);
 
-  const activityCol = df.getCol(C.COLUMNS_NAMES.ACTIVITY);
   const activityColData = activityCol.getRawData() as Float64Array;
 
   const origClustStats: ClusterStats = {};
@@ -143,10 +221,9 @@ export function calculateClusterStatistics(df: DG.DataFrame, clustersColumnName:
     const resultStats = clustType === CLUSTER_TYPE.ORIGINAL ? origClustStats : customClustStats;
     for (let maskIdx = 0; maskIdx < masks.length; ++maskIdx) {
       const mask = masks[maskIdx];
-      const stats = mask.allTrue || mask.allFalse ?
+      resultStats[clustNames[maskIdx]] = mask.allTrue || mask.allFalse ?
         {count: mask.length, meanDifference: 0, ratio: 1.0, pValue: null, mask: mask, mean: activityCol.stats.avg} :
         getStats(activityColData, mask);
-      resultStats[clustNames[maskIdx]] = stats;
     }
   }