@datagrok/eda 1.4.12 → 1.4.13

package/src/package-api.ts

@@ -282,10 +282,14 @@ export namespace funcs {
     return await grok.functions.call('EDA:TrainPmpo', {});
   }
 
+  export async function getPmpoAppItems(view: DG.View ): Promise<any> {
+    return await grok.functions.call('EDA:GetPmpoAppItems', { view });
+  }
+
   /**
-  Apply trained probabilistic multi-parameter optimization (pMPO) model to score samples
+  Generates syntethetic dataset oriented on the pMPO modeling
   */
-  export async function applyPmpo(table: DG.DataFrame , file: DG.FileInfo ): Promise<void> {
-    return await grok.functions.call('EDA:ApplyPmpo', { table, file });
+  export async function generatePmpoDataset(samples: number ): Promise<DG.DataFrame> {
+    return await grok.functions.call('EDA:GeneratePmpoDataset', { samples });
   }
 }

package/src/package-test.ts

@@ -1,10 +1,13 @@
 import * as DG from 'datagrok-api/dg';
-import {runTests, tests, TestContext, initAutoTests as initTests} from '@datagrok-libraries/utils/src/test';
+import {runTests, tests, TestContext, initAutoTests as initTests} from '@datagrok-libraries/test/src/test';
 import './tests/dim-reduction-tests';
 import './tests/linear-methods-tests';
 import './tests/classifiers-tests';
 import './tests/mis-vals-imputation-tests';
 import './tests/anova-tests';
+import './tests/pmpo-tests';
+import './tests/pareto-tests';
+
 export const _package = new DG.Package();
 export {tests};
 

package/src/package.g.ts

@@ -7,6 +7,7 @@ export function info() : void {
 }
 
 //tags: init
+//meta.role: init
 export async function init() : Promise<void> {
   await PackageFunctions.init();
 }
@@ -37,34 +38,37 @@ export async function PCA(table: DG.DataFrame, features: DG.ColumnList, componen
 }
 
 //name: DBSCAN clustering
+//tags: dim-red-postprocessing-function
 //input: column col1 
 //input: column col2 
 //input: double epsilon = 0.01 { description: Minimum distance between two points to be considered as in the same neighborhood. }
 //input: int minimumPoints = 5 { description: Minimum number of points to form a dense region. }
 //meta.defaultPostProcessingFunction: true
-//meta.role: dimRedPostprocessingFunction
+//meta.role: dim-red-postprocessing-function
 export async function dbscanPostProcessingFunction(col1: DG.Column, col2: DG.Column, epsilon: number, minimumPoints: number) : Promise<void> {
   await PackageFunctions.dbscanPostProcessingFunction(col1, col2, epsilon, minimumPoints);
 }
 
 //name: None (number)
+//tags: dim-red-preprocessing-function
 //input: column col 
 //input: string _metric { optional: true }
 //output: object result
 //meta.supportedTypes: int,float,double,qnum
 //meta.supportedDistanceFunctions: Difference
-//meta.role: dimRedPreprocessingFunction
+//meta.role: dim-red-preprocessing-function
 export function numberPreprocessingFunction(col: DG.Column, _metric: string) {
   return PackageFunctions.numberPreprocessingFunction(col, _metric);
 }
 
 //name: None (string)
+//tags: dim-red-preprocessing-function
 //input: column col 
 //input: string _metric { optional: true }
 //output: object result
 //meta.supportedTypes: string
 //meta.supportedDistanceFunctions: One-Hot,Levenshtein,Hamming
-//meta.role: dimRedPreprocessingFunction
+//meta.role: dim-red-preprocessing-function
 export function stringPreprocessingFunction(col: DG.Column, _metric: string) {
   return PackageFunctions.stringPreprocessingFunction(col, _metric);
 }
@@ -77,6 +81,7 @@ export async function reduceDimensionality() : Promise<void> {
 
 //tags: editor
 //input: funccall call 
+//meta.role: editor
 export function GetMCLEditor(call: DG.FuncCall) : void {
   PackageFunctions.GetMCLEditor(call);
 }
@@ -102,6 +107,7 @@ export async function MCLClustering(df: DG.DataFrame, cols: DG.Column[], metrics
 
 //name: MCL
 //description: Markov clustering viewer
+//tags: viewer
 //output: viewer result
 //meta.showInGallery: false
 //meta.role: viewer
@@ -532,6 +538,7 @@ export function paretoFront() : void {
 
 //name: Pareto front
 //description: Pareto front viewer
+//tags: viewer
 //output: viewer result
 //meta.icon: icons/pareto-front-viewer.svg
 //meta.role: viewer
@@ -540,14 +547,19 @@ export function paretoFrontViewer() : any {
 }
 
 //description: Train probabilistic multi-parameter optimization (pMPO) model
-//top-menu: Chem | Calculate | Train pMPO...
 export function trainPmpo() : void {
   PackageFunctions.trainPmpo();
 }
 
-//description: Apply trained probabilistic multi-parameter optimization (pMPO) model to score samples
-//input: dataframe table 
-//input: file file 
-export async function applyPmpo(table: DG.DataFrame, file: DG.FileInfo) : Promise<void> {
-  await PackageFunctions.applyPmpo(table, file);
+//input: view view 
+//output: object result
+export function getPmpoAppItems(view: any) : any {
+  return PackageFunctions.getPmpoAppItems(view);
+}
+
+//description: Generates syntethetic dataset oriented on the pMPO modeling
+//input: int samples 
+//output: dataframe Synthetic
+export async function generatePmpoDataset(samples: number) : Promise<any> {
+  return await PackageFunctions.generatePmpoDataset(samples);
 }

package/src/package.ts

@@ -36,10 +36,12 @@ import {SoftmaxClassifier} from './softmax-classifier';
 
 import {initXgboost} from '../wasm/xgbooster';
 import {XGBooster} from './xgbooster';
+
 import {ParetoOptimizer} from './pareto-optimization/pareto-optimizer';
 import {ParetoFrontViewer} from './pareto-optimization/pareto-front-viewer';
+
 import {Pmpo} from './probabilistic-scoring/prob-scoring';
-import {loadPmpoParams} from './probabilistic-scoring/pmpo-utils';
+import {getSynteticPmpoData} from './probabilistic-scoring/data-generator';
 
 export const _package = new DG.Package();
 export * from './package.g';
@@ -53,7 +55,7 @@ export class PackageFunctions {
   }
 
 
-  @grok.decorators.init({})
+  @grok.decorators.init({tags: ['init']})
   static async init(): Promise<void> {
     await _initEDAAPI();
     await initXgboost();
@@ -115,8 +117,9 @@ export class PackageFunctions {
 
 
   @grok.decorators.func({
-    'meta': {'defaultPostProcessingFunction': 'true', role: 'dimRedPostprocessingFunction'},
+    'meta': {'defaultPostProcessingFunction': 'true', 'role': 'dim-red-postprocessing-function'},
     'name': 'DBSCAN clustering',
+    'tags': ['dim-red-postprocessing-function'],
   })
   static async dbscanPostProcessingFunction(
     col1: DG.Column,
@@ -145,9 +148,10 @@ export class PackageFunctions {
     'meta': {
       'supportedTypes': 'int,float,double,qnum',
       'supportedDistanceFunctions': 'Difference',
-      'role': 'dimRedPreprocessingFunction'
+      'role': 'dim-red-preprocessing-function',
     },
     'name': 'None (number)',
+    'tags': ['dim-red-preprocessing-function'],
     'outputs': [{name: 'result', type: 'object'}],
   })
   static numberPreprocessingFunction(
@@ -163,8 +167,9 @@ export class PackageFunctions {
     'meta': {
       'supportedTypes': 'string',
       'supportedDistanceFunctions': 'One-Hot,Levenshtein,Hamming',
-      'role': 'dimRedPreprocessingFunction'
+      'role': 'dim-red-preprocessing-function',
     },
+    'tags': ['dim-red-preprocessing-function'],
     'name': 'None (string)',
     'outputs': [{name: 'result', type: 'object'}],
   })
@@ -219,7 +224,7 @@ export class PackageFunctions {
   }
 
 
-  @grok.decorators.editor()
+  @grok.decorators.editor({tags: ['editor']})
   static GetMCLEditor(
     call: DG.FuncCall): void {
     try {
@@ -287,6 +292,7 @@ export class PackageFunctions {
   @grok.decorators.func({
     'outputs': [{'name': 'result', 'type': 'viewer'}],
     'meta': {showInGallery: 'false', role: 'viewer'},
+    'tags': ['viewer'],
     'name': 'MCL',
     'description': 'Markov clustering viewer',
   })
@@ -979,14 +985,14 @@ export class PackageFunctions {
     'name': 'Pareto front',
     'description': 'Pareto front viewer',
     'outputs': [{'name': 'result', 'type': 'viewer'}],
-    'meta': {'icon': 'icons/pareto-front-viewer.svg', role: 'viewer'},
+    'meta': {'icon': 'icons/pareto-front-viewer.svg', 'role': 'viewer'},
+    'tags': ['viewer'],
   })
   static paretoFrontViewer(): DG.Viewer {
     return new ParetoFrontViewer();
   }
 
   @grok.decorators.func({
-    'top-menu': 'Chem | Calculate | Train pMPO...',
     'name': 'trainPmpo',
     'description': 'Train probabilistic multi-parameter optimization (pMPO) model',
   })
@@ -1004,22 +1010,25 @@ export class PackageFunctions {
     pMPO.runTrainingApp();
   }
 
+  @grok.decorators.func({'name': 'getPmpoAppItems', 'outputs': [{name: 'result', type: 'object'}]})
+  static getPmpoAppItems(@grok.decorators.param({type: 'view'}) view: DG.TableView): any | null {
+    const df = view.dataFrame;
+    if (!Pmpo.isTableValid(df))
+      return null;
+
+    const pMPO = new Pmpo(df, view);
+
+    return pMPO.getPmpoAppItems();
+  }
+
   @grok.decorators.func({
-    //'top-menu': 'ML | Apply pMPO...',
-    'name': 'applyPmpo',
-    'description': 'Apply trained probabilistic multi-parameter optimization (pMPO) model to score samples',
+    'name': 'generatePmpoDataset',
+    'description': 'Generates syntethetic dataset oriented on the pMPO modeling',
+    'outputs': [{name: 'Synthetic', type: 'dataframe'}],
   })
-  static async applyPmpo(
-    @grok.decorators.param({'type': 'dataframe'}) table: DG.DataFrame,
-    @grok.decorators.param({'type': 'file'}) file: DG.FileInfo,
-  ): Promise<void> {
-    try {
-      const params = await loadPmpoParams(file);
-      const predName = table.columns.getUnusedName('pMPO score');
-      const prediction = Pmpo.predict(table, params, predName);
-      table.columns.add(prediction, true);
-    } catch (err) {
-      grok.shell.warning(`Failed to apply pMPO: ${err instanceof Error ? err.message : 'the platform issue.'}`);
-    }
+  static async generatePmpoDataset(@grok.decorators.param({'type': 'int'}) samples: number): Promise<DG.DataFrame> {
+    const df = await getSynteticPmpoData(samples);
+    df.name = 'Synthetic';
+    return df;
   }
 }

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

@@ -2,6 +2,12 @@
 
 import {NumericArray, OPT_TYPE} from './defs';
 
+/** Computes the Pareto front mask for a given dataset and optimization sense
+ * @param rawData Array of numeric arrays representing the dataset (each array corresponds to a feature/dimension)
+ * @param sense Array of optimization types (OPT_TYPE.MIN or OPT_TYPE.MAX) for each dimension
+ * @param nPoints Number of data points in the dataset
+ * @param nullIndices Optional set of indices corresponding to missing values (these points will be marked as non-optimal)
+ * @returns Boolean array where true indicates that the point is on the Pareto front */
 export function getParetoMask(rawData: NumericArray[], sense: OPT_TYPE[], nPoints: number,
   nullIndices?: Set<number>): boolean[] {
   if (nPoints === 0)

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

@@ -0,0 +1,157 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {DescriptorStatistics, SOURCE_PATH, SYNTHETIC_DRUG_NAME} from './pmpo-defs';
+import {getDescriptorStatistics, getDesiredTables} from './stat-tools';
+
+//@ts-ignore: no types
+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> {
+  const df = await grok.dapi.files.readCsv(SOURCE_PATH);
+  const generator = new PmpoDataGenerator(df, 'Drug', 'CNS', 'Smiles');
+
+  return generator.getGenerated(samplesCount);
+}
+
+/** Class for generating synthetic data for pMPO model training and testing */
+export class PmpoDataGenerator {
+  private sourceDf: DG.DataFrame;
+  private drugName: string;
+  private desirabilityColName: string;
+  private smilesColName: string;
+  private desiredProbability: number;
+  private descriptorStats: Map<string, DescriptorStatistics>;
+
+  constructor(df: DG.DataFrame, drugName: string, desirabilityColName: string, smilesColName: string) {
+    this.sourceDf = df;
+    this.drugName = drugName;
+    this.desirabilityColName = desirabilityColName;
+    this.smilesColName = smilesColName;
+
+    const descriptorNames = df.columns.toList().filter((col) => col.isNumerical).map((col) => col.name);
+    const {desired, nonDesired} = getDesiredTables(df, df.col(desirabilityColName)!);
+
+    // Compute descriptors' statistics
+    this.descriptorStats = new Map<string, DescriptorStatistics>();
+    descriptorNames.forEach((name) => {
+      this.descriptorStats.set(name, getDescriptorStatistics(desired.col(name)!, nonDesired.col(name)!));
+    });
+
+    // Probability of desired class
+    this.desiredProbability = desired.rowCount / df.rowCount;
+  } // constructor
+
+  /** Generates synthetic data for pMPO model training and testing
+   * @param samplesCount Number of samples to generate
+   * @returns DataFrame with generated data */
+  public getGenerated(samplesCount: number): DG.DataFrame {
+    if (samplesCount <= 1)
+      throw new Error('Failed to generate pMPO data: sample count must be greater than 1.');
+
+    let result: DG.DataFrame;
+
+    /* Use rows from the source dataframe if the requested sample count
+       is less than or equal to the source dataframe row count */
+    if (samplesCount <= this.sourceDf.rowCount) {
+      const rowMask = DG.BitSet.create(this.sourceDf.rowCount);
+
+      for (let i = 0; i < samplesCount; ++i)
+        rowMask.set(i, true);
+
+      result = this.sourceDf.clone(rowMask);
+    } else {
+      const cloneDf = this.getClonedSourceDfWithFloatNumericCols();
+      result = cloneDf.append(this.getSyntheticTable(samplesCount - this.sourceDf.rowCount));
+    }
+
+    // Check boolean columns and ensure non-zero stdev
+    for (const col of result.columns) {
+      if (col.type === DG.COLUMN_TYPE.BOOL && col.stats.stdev === 0) {
+        // All values are the same, flip the first value
+        let value = col.get(0);
+        col.set(0, !value);
+
+        value = col.get(1);
+        col.set(1, !value);
+      }
+    }
+
+    return result;
+  } // getGenerated
+
+  /** Generates a synthetic data table
+   * @param samplesCount Number of samples to generate
+   * @returns DataFrame with synthetic data */
+  private getSyntheticTable(samplesCount: number): DG.DataFrame {
+    const desirabilityRaw = new Array<boolean>(samplesCount);
+
+    for (let i = 0; i < samplesCount; ++i)
+      desirabilityRaw[i] = (Math.random() < this.desiredProbability);
+
+
+    const cols = [
+      this.getDrugColumn(samplesCount),
+      this.getSmilesColumn(samplesCount),
+      DG.Column.fromList(DG.COLUMN_TYPE.BOOL, this.desirabilityColName, desirabilityRaw),
+    ];
+
+    this.descriptorStats.forEach((stat, name) => {
+      const arr = new Float32Array(samplesCount);
+
+      for (let i = 0; i < samplesCount; ++i) {
+        if (desirabilityRaw[i])
+          arr[i] = jStat.normal.sample(stat.desAvg, stat.desStd);
+        else
+          arr[i] = jStat.normal.sample(stat.nonDesAvg, stat.nonDesStd);
+      }
+
+      // @ts-ignore
+      cols.push(DG.Column.fromFloat32Array(name, arr));
+    });
+
+    return DG.DataFrame.fromColumns(cols);
+  } // getSyntheticTable
+
+  /** Generates a column with synthetic drug names
+   * @param samplesCount Number of samples to generate
+   * @returns Column with synthetic drug names */
+  private getDrugColumn(samplesCount: number): DG.Column<string> {
+    return DG.Column.fromList(
+      DG.COLUMN_TYPE.STRING,
+      this.drugName,
+      Array.from({length: samplesCount}, (_, i) => `${SYNTHETIC_DRUG_NAME} ${i + 1}`));
+  }
+
+  /** Generates a column with synthetic SMILES strings
+   * @param samplesCount Number of samples to generate
+   * @returns Column with synthetic SMILES strings */
+  private getSmilesColumn(samplesCount: number): DG.Column<string> {
+    return DG.Column.fromList(
+      DG.COLUMN_TYPE.STRING,
+      this.smilesColName,
+      Array.from({length: samplesCount}, () => 'C'));
+  }
+
+  /** Clones the source dataframe converting numerical columns to Float type
+   * @returns Cloned dataframe */
+  private getClonedSourceDfWithFloatNumericCols(): DG.DataFrame {
+    const cols: DG.Column[] = [];
+
+    this.sourceDf.columns.toList().forEach((col) => {
+      if (col.isNumerical)
+        cols.push(col.clone().convertTo(DG.COLUMN_TYPE.FLOAT));
+      else
+        cols.push(col.clone());
+    });
+
+    const clone = DG.DataFrame.fromColumns(cols);
+    clone.name = this.sourceDf.name;
+
+    return clone;
+  }
+} // PmpoDataGenerator

package/src/probabilistic-scoring/nelder-mead.ts

@@ -0,0 +1,204 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+function getInitialParams(
+  objectiveFunc: (x: Float32Array) => number,
+  settings: Map<string, number>,
+  paramsInitial: Float32Array,
+  restrictionsBottom: Float32Array,
+  restrictionsTop: Float32Array): [Float32Array[], number[]] {
+  const dim = paramsInitial.length + 1;
+  const dimParams = paramsInitial.length;
+  const nonZeroParam = settings.get('nonZeroParam')!;
+  const initScale = settings.get('initialScale')!;
+
+  const optParams = new Array<Float32Array>(dim);
+  const pointObjectives = new Array<number>(dim);
+
+  for (let i = 0; i < dim; i++) {
+    optParams[i] = new Float32Array(dimParams);
+    for (let j = 0; j < dimParams; j++) {
+      optParams[i][j] = paramsInitial[j];
+      if (i != 0 && i - 1 === j) {
+        if (paramsInitial[j] == 0)
+          optParams[i][j] = nonZeroParam;
+        else
+          optParams[i][j] += initScale * paramsInitial[i - 1];
+
+        if (optParams[i][j] < restrictionsBottom[j])
+          optParams[i][j] = restrictionsBottom[j];
+        else if (optParams[i][j] > restrictionsTop[j])
+          optParams[i][j] = restrictionsTop[j];
+      }
+    }
+
+    pointObjectives[i] = objectiveFunc(optParams[i]);
+  }
+
+  return [optParams, pointObjectives];
+} // getInitialParams
+
+function fillCentroid(centroid: Float32Array, dimParams: number, lastIndex: number, optParams: Float32Array[]) {
+  for (let i = 0; i < dimParams; i++) {
+    let val = 0;
+    for (let j = 0; j < dimParams + 1; j++) {
+      if (j != lastIndex)
+        val += optParams[j][i];
+    }
+
+    centroid[i] = val / dimParams;
+  }
+} // fillCentroid
+
+function fillPoint(
+  centroid: Float32Array, point: Float32Array,
+  lastIndex: number, optParams: Float32Array[],
+  scale: number, dimParams: number,
+  restrictionsBottom: Float32Array,
+  restrictionsTop: Float32Array) {
+  for (let i = 0; i < dimParams; i++) {
+    point[i] = centroid[i];
+    point[i] += scale * (centroid[i] - optParams[lastIndex][i]);
+
+    if (point[i] < restrictionsBottom[i])
+      point[i] = restrictionsBottom[i];
+    else if (point[i] > restrictionsTop[i])
+      point[i] = restrictionsTop[i];
+  }
+} // fillPoint
+
+export async function optimizeNM(pi: DG.ProgressIndicator,
+  objectiveFunc: (x: Float32Array) => number, paramsInitial: Float32Array,
+  settings: Map<string, number>, restrictionsBottom: Float32Array, restrictionsTop: Float32Array) {
+  // Settings initialization
+  const tolerance = settings.get('tolerance')!;
+  const maxIter = settings.get('maxIter')!;
+  const scaleReflection = settings.get('scaleReflaction')!;
+  const scaleExpansion = settings.get('scaleExpansion')!;
+  const scaleContraction = settings.get('scaleContraction')!;
+
+  const dim = paramsInitial.length + 1;
+  const dimParams = paramsInitial.length;
+
+  const [optParams, pointObjectives] = getInitialParams(
+    objectiveFunc,
+    settings,
+    paramsInitial,
+    restrictionsBottom,
+    restrictionsTop,
+  );
+
+  const indexes = new Array<number>(dim);
+  for (let i = 0; i < dim; i++)
+    indexes[i] = i;
+
+  const lastIndex = indexes.length - 1;
+
+  let iteration = 0;
+  let best = 0;
+  let previousBest = 0;
+  let noImprovement = 0;
+
+  const centroid = new Float32Array(dimParams);
+  const reflectionPoint = new Float32Array(dimParams);
+  const expansionPoint = new Float32Array(dimParams);
+  const contractionPoint = new Float32Array(dimParams);
+  const costs = new Array<number>(maxIter);
+
+  if (dim > 1) {
+    let percentage = 0;
+
+    while (true) {
+      indexes.sort((a:number, b:number) => {
+        return pointObjectives[a] - pointObjectives[b];
+      });
+
+      percentage = Math.min(100, Math.floor(100 * (iteration) / maxIter));
+      pi.update(percentage, `Optimizing pMPO... (${percentage}%)`);
+      await new Promise((r) => setTimeout(r, 1));
+
+      if (pi.canceled)
+        break;
+
+      if (iteration > maxIter)
+        break;
+
+      if (iteration == 0) {
+        best = pointObjectives[0];
+        previousBest = 2*pointObjectives[indexes[0]];
+      }
+      costs[iteration] = best;
+
+      ++iteration;
+
+      best = pointObjectives[indexes[0]];
+      if (previousBest - best > tolerance)
+        noImprovement = 0;
+      else {
+        ++noImprovement;
+        if (noImprovement > 2 * dim)
+          break;
+      }
+
+      previousBest = best;
+
+      //centroid
+      fillCentroid(centroid, dimParams, indexes[lastIndex], optParams);
+
+      // reflection
+      fillPoint(centroid, reflectionPoint, indexes[lastIndex],
+        optParams, scaleReflection, dimParams, restrictionsBottom, restrictionsTop);
+      const reflectionScore = objectiveFunc(reflectionPoint);
+
+      // expansion
+      if (reflectionScore < pointObjectives[indexes[lastIndex]]) {
+        fillPoint(centroid, expansionPoint, indexes[lastIndex],
+          optParams, scaleExpansion, dimParams, restrictionsBottom, restrictionsTop);
+
+        const expansionScore = objectiveFunc(expansionPoint);
+
+        if (expansionScore < reflectionScore) {
+          pointObjectives[indexes[lastIndex]] = expansionScore;
+
+          for (let i = 0; i < dimParams; i++)
+            optParams[indexes[lastIndex]][i] = expansionPoint[i];
+
+          continue;
+        } else {
+          pointObjectives[indexes[lastIndex]] = reflectionScore;
+
+          for (let i = 0; i < dimParams; i++)
+            optParams[indexes[lastIndex]][i] = reflectionPoint[i];
+
+          continue;
+        }
+      }
+
+      // Contraction
+      fillPoint(centroid, contractionPoint, indexes[lastIndex],
+        optParams, scaleContraction, dimParams, restrictionsBottom, restrictionsTop);
+
+      const contractionScore = objectiveFunc(contractionPoint);
+
+      if (contractionScore < pointObjectives[indexes[lastIndex]]) {
+        pointObjectives[indexes[lastIndex]] = contractionScore;
+
+        for (let i = 0; i < dimParams; i++)
+          optParams[indexes[lastIndex]][i] = contractionPoint[i];
+
+        continue;
+      }
+
+      break;
+    } // while
+
+    for (let i = iteration; i < maxIter; i++)
+      costs[i] = pointObjectives[indexes[0]];
+  } // if
+
+  return {
+    optimalPoint: optParams[indexes[0]],
+    iterations: iteration,
+  };
+}; // optimizeNM