@reicek/neataptic-ts 0.1.21 → 0.1.22

package/test/examples/flappy_bird/trainer/trainer.ts

@@ -1,37 +1,20 @@
 import { pathToFileURL } from 'node:url';
-import {
-  evaluateFlappyFitnessAcrossSeeds,
-  rolloutEpisode,
-  type FlappyRolloutOptions,
-  type FlappySeedBatchEvaluation,
-} from '../flappyEvaluation';
+import { rolloutEpisode } from '../flappyEvaluation';
 import type {
-  FlappyGenerationEvaluationPlan,
-  FlappyGenerationReport,
   FlappyTrainerNetwork,
   FlappyTrainerRuntimeState,
   FlappyTrainerSetup,
-  ScoredGenomeEntry,
 } from './trainer.types';
 import {
   FLAPPY_TRAINER_DEFAULT_RNG_SEED,
-  FLAPPY_TRAINER_DUMMY_FLAP_OUTPUT,
-  FLAPPY_TRAINER_DUMMY_NETWORK_ID,
-  FLAPPY_TRAINER_DUMMY_NO_FLAP_OUTPUT,
-  FLAPPY_TRAINER_FRAME_PRIMARY_BASE_SCORE,
-  FLAPPY_TRAINER_FRAME_PRIMARY_PIPE_WEIGHT,
-  FLAPPY_TRAINER_FRAME_PRIMARY_SURVIVAL_WEIGHT,
-  FLAPPY_TRAINER_FRAME_STABILITY_STDDEV_WEIGHT,
-  FLAPPY_TRAINER_FULL_PASS_ELITISM_MULTIPLIER,
-  FLAPPY_TRAINER_FULL_PASS_POPULATION_FRACTION,
-  FLAPPY_TRAINER_LOG_PARTS_DELIMITER,
-  FLAPPY_TRAINER_PIPE_FALLBACK_PIPE_WEIGHT,
-  FLAPPY_TRAINER_PIPE_FILTER_TOLERANCE,
-  FLAPPY_TRAINER_REEVALUATION_MIN_CANDIDATE_COUNT,
-  FLAPPY_TRAINER_SCORE_MEDIAN_PERCENTILE,
-  FLAPPY_TRAINER_SCORE_P90_PERCENTILE,
   FLAPPY_TRAINER_STOPPED_MESSAGE,
 } from './trainer.constants';
+import {
+  commitPopulationScores,
+  evaluatePopulationFullStage,
+  evaluatePopulationQuickStage,
+  evaluatePopulationReevaluationStage,
+} from './trainer.evaluation.service';
 import { formatTrainerErrorMessage } from './trainer.errors';
 import { resolveGenerationEvaluationPlan } from './trainer.evaluation-plan.utils';
 import {
@@ -40,14 +23,12 @@ import {
   createTrainerSetup,
 } from './trainer.setup.service';
 import { attachPopulationFitnessEvaluator } from './trainer.fitness.service';
-import { buildGenerationLogParts } from './trainer.reporting.utils';
 import { runTrainerEvolutionLoop } from './trainer.loop.service';
-import { registerTrainerStopSignals } from './trainer.signals.service';
 import {
-  computeMean,
-  computePercentile,
-  computePopulationStandardDeviation,
-} from './trainer.statistics.utils';
+  buildGenerationReport,
+  logGenerationSummary,
+} from './trainer.report.service';
+import { registerTrainerStopSignals } from './trainer.signals.service';
 
 /**
  * Flappy Bird neuroevolution demo.
@@ -90,529 +71,6 @@ export async function runTrainer(): Promise<void> {
   console.log(FLAPPY_TRAINER_STOPPED_MESSAGE);
 }
 
-/**
- * Executes quick evaluation stage over the full population.
- */
-function evaluatePopulationQuickStage(
-  population: readonly FlappyTrainerNetwork[],
-  generationEvaluationPlan: FlappyGenerationEvaluationPlan,
-  aggregateByGenome: Map<FlappyTrainerNetwork, FlappySeedBatchEvaluation>,
-  provisionalScoresByGenome: Map<FlappyTrainerNetwork, number>,
-): void {
-  evaluateSpecificGenomesAcrossSeeds(
-    population,
-    generationEvaluationPlan.quickSeeds,
-    generationEvaluationPlan.quickRolloutOptions,
-    aggregateByGenome,
-  );
-
-  assignFramePrimaryScores(
-    population,
-    aggregateByGenome,
-    provisionalScoresByGenome,
-  );
-}
-
-/**
- * Executes full evaluation stage over top provisional candidates.
- */
-function evaluatePopulationFullStage(
-  population: readonly FlappyTrainerNetwork[],
-  generationEvaluationPlan: FlappyGenerationEvaluationPlan,
-  aggregateByGenome: Map<FlappyTrainerNetwork, FlappySeedBatchEvaluation>,
-  provisionalScoresByGenome: Map<FlappyTrainerNetwork, number>,
-  elitismCount: number,
-): void {
-  const fullPassCandidateCount = resolveFullPassCandidateCount(
-    population.length,
-    elitismCount,
-  );
-  const fullPassCandidates = selectTopGenomesByScore(
-    population,
-    provisionalScoresByGenome,
-    fullPassCandidateCount,
-  );
-
-  evaluateSpecificGenomesAcrossSeeds(
-    fullPassCandidates,
-    generationEvaluationPlan.fullSeeds,
-    generationEvaluationPlan.fullRolloutOptions,
-    aggregateByGenome,
-  );
-
-  assignFramePrimaryScores(
-    population,
-    aggregateByGenome,
-    provisionalScoresByGenome,
-  );
-}
-
-/**
- * Executes large-seed reevaluation stage over top candidates.
- */
-function evaluatePopulationReevaluationStage(
-  population: readonly FlappyTrainerNetwork[],
-  generationEvaluationPlan: FlappyGenerationEvaluationPlan,
-  aggregateByGenome: Map<FlappyTrainerNetwork, FlappySeedBatchEvaluation>,
-  provisionalScoresByGenome: Map<FlappyTrainerNetwork, number>,
-  elitismCount: number,
-): void {
-  const reevaluationCount = Math.max(
-    elitismCount,
-    FLAPPY_TRAINER_REEVALUATION_MIN_CANDIDATE_COUNT,
-  );
-  const reevaluationCandidates = selectTopGenomesByScore(
-    population,
-    provisionalScoresByGenome,
-    reevaluationCount,
-  );
-
-  evaluateSpecificGenomesAcrossSeeds(
-    reevaluationCandidates,
-    generationEvaluationPlan.reevaluationSeeds,
-    generationEvaluationPlan.reevaluationRolloutOptions,
-    aggregateByGenome,
-  );
-
-  assignFramePrimaryScores(
-    population,
-    aggregateByGenome,
-    provisionalScoresByGenome,
-  );
-}
-
-/**
- * Evaluates a specific genome set across a shared seed batch.
- */
-function evaluateSpecificGenomesAcrossSeeds(
-  genomes: readonly FlappyTrainerNetwork[],
-  sharedSeeds: readonly number[],
-  rolloutOptions: FlappyRolloutOptions,
-  aggregateByGenome: Map<FlappyTrainerNetwork, FlappySeedBatchEvaluation>,
-): void {
-  for (const genome of genomes) {
-    const aggregate = evaluateFlappyFitnessAcrossSeeds(
-      genome,
-      sharedSeeds,
-      rolloutOptions,
-    );
-    aggregateByGenome.set(genome, aggregate);
-  }
-}
-
-/**
- * Commits provisional scores to genome `.score` fields.
- */
-function commitPopulationScores(
-  population: readonly FlappyTrainerNetwork[],
-  provisionalScoresByGenome: ReadonlyMap<FlappyTrainerNetwork, number>,
-): void {
-  for (const genome of population) {
-    genome.score =
-      provisionalScoresByGenome.get(genome) ?? Number.NEGATIVE_INFINITY;
-  }
-}
-
-/**
- * Builds compact report for current generation.
- */
-function buildGenerationReport(
-  population: readonly FlappyTrainerNetwork[],
-  aggregateByGenome: ReadonlyMap<
-    FlappyTrainerNetwork,
-    FlappySeedBatchEvaluation
-  >,
-  generationEvaluationPlan: FlappyGenerationEvaluationPlan,
-): FlappyGenerationReport {
-  const finalScores = collectFiniteGenomeScores(population);
-  const scoreMean = computeMean(finalScores);
-  const scoreStdDev = computePopulationStandardDeviation(
-    finalScores,
-    scoreMean,
-  );
-  const bestGenome = resolveBestGenomeByScore(population);
-  const bestAggregate = resolveBestAggregate(
-    population,
-    bestGenome,
-    aggregateByGenome,
-    generationEvaluationPlan.reevaluationSeeds,
-    generationEvaluationPlan.reevaluationRolloutOptions,
-  );
-  const bestEpisode = resolveBestEpisode(
-    population,
-    bestGenome,
-    generationEvaluationPlan.reevaluationSeeds,
-    generationEvaluationPlan.reevaluationRolloutOptions,
-  );
-
-  return {
-    generationIndex: generationEvaluationPlan.generationIndex,
-    difficultyScale: generationEvaluationPlan.difficultyScale,
-    mutationRate: generationEvaluationPlan.mutationRate,
-    mutationAmount: generationEvaluationPlan.mutationAmount,
-    quickSeedCount: generationEvaluationPlan.quickSeeds.length,
-    fullSeedCount: generationEvaluationPlan.fullSeeds.length,
-    reevaluationSeedCount: generationEvaluationPlan.reevaluationSeeds.length,
-    evaluatedPopulationSize: population.length,
-    scoreMean,
-    scoreMedian: computePercentile(
-      finalScores,
-      FLAPPY_TRAINER_SCORE_MEDIAN_PERCENTILE,
-    ),
-    scoreP90: computePercentile(
-      finalScores,
-      FLAPPY_TRAINER_SCORE_P90_PERCENTILE,
-    ),
-    scoreStdDev,
-    bestRobustFitness: bestGenome?.score ?? Number.NaN,
-    bestMeanFitness: bestAggregate.meanFitness,
-    bestPipesPassed: bestEpisode.pipesPassed,
-    bestFramesSurvived: bestEpisode.framesSurvived,
-  };
-}
-
-/**
- * Collects finite genome scores from population.
- */
-function collectFiniteGenomeScores(
-  population: readonly FlappyTrainerNetwork[],
-): number[] {
-  const finiteScores: number[] = [];
-
-  for (const genome of population) {
-    const genomeScore = genome.score ?? Number.NEGATIVE_INFINITY;
-    if (Number.isFinite(genomeScore)) {
-      finiteScores.push(genomeScore);
-    }
-  }
-
-  return finiteScores;
-}
-
-/**
- * Resolves the best genome by current score.
- */
-function resolveBestGenomeByScore(
-  population: readonly FlappyTrainerNetwork[],
-): FlappyTrainerNetwork | undefined {
-  const scoredGenomes = buildScoredGenomeEntries(population, undefined);
-  scoredGenomes.sort(compareScoredGenomeEntriesDescending);
-  return scoredGenomes[0]?.genome;
-}
-
-/**
- * Resolves aggregate for the selected best genome.
- */
-function resolveBestAggregate(
-  population: readonly FlappyTrainerNetwork[],
-  bestGenome: FlappyTrainerNetwork | undefined,
-  aggregateByGenome: ReadonlyMap<
-    FlappyTrainerNetwork,
-    FlappySeedBatchEvaluation
-  >,
-  fallbackSeeds: readonly number[],
-  fallbackRolloutOptions: FlappyRolloutOptions,
-): FlappySeedBatchEvaluation {
-  const fallbackGenome = resolveFallbackGenome(population, bestGenome);
-  if (!fallbackGenome) {
-    return buildEmptySeedBatchEvaluation();
-  }
-
-  const cachedAggregate = aggregateByGenome.get(fallbackGenome);
-  if (cachedAggregate) {
-    return cachedAggregate;
-  }
-
-  return evaluateFlappyFitnessAcrossSeeds(
-    fallbackGenome,
-    fallbackSeeds,
-    fallbackRolloutOptions,
-  );
-}
-
-/**
- * Resolves one representative episode for the selected best genome.
- */
-function resolveBestEpisode(
-  population: readonly FlappyTrainerNetwork[],
-  bestGenome: FlappyTrainerNetwork | undefined,
-  fallbackSeeds: readonly number[],
-  fallbackRolloutOptions: FlappyRolloutOptions,
-): ReturnType<typeof rolloutEpisode> {
-  const fallbackGenome = resolveFallbackGenome(population, bestGenome);
-  if (!fallbackGenome) {
-    return rolloutEpisode(resolveDummyNetwork(), fallbackRolloutOptions);
-  }
-
-  const episodeSeed = fallbackSeeds[0];
-  return rolloutEpisode(fallbackGenome, {
-    ...fallbackRolloutOptions,
-    seed: episodeSeed,
-  });
-}
-
-/**
- * Picks the best genome when available, else falls back to the first genome.
- */
-function resolveFallbackGenome(
-  population: readonly FlappyTrainerNetwork[],
-  bestGenome: FlappyTrainerNetwork | undefined,
-): FlappyTrainerNetwork | undefined {
-  return bestGenome ?? population[0];
-}
-
-/**
- * Builds empty aggregate object for defensive fallback paths.
- */
-function buildEmptySeedBatchEvaluation(): FlappySeedBatchEvaluation {
-  return {
-    seedCount: 0,
-    meanFitness: 0,
-    medianFitness: 0,
-    p90Fitness: 0,
-    fitnessStdDev: 0,
-    robustFitness: 0,
-    meanPipesPassed: 0,
-    meanFramesSurvived: 0,
-  };
-}
-
-/**
- * Builds a minimal dummy network used only by fallback episode path.
- */
-function resolveDummyNetwork(): FlappyTrainerNetwork {
-  return {
-    activate: activateWithoutFlap,
-    _id: FLAPPY_TRAINER_DUMMY_NETWORK_ID,
-  };
-}
-
-/**
- * Dummy network activation used by fallback code paths.
- */
-function activateWithoutFlap(): number[] {
-  return [
-    FLAPPY_TRAINER_DUMMY_NO_FLAP_OUTPUT,
-    FLAPPY_TRAINER_DUMMY_FLAP_OUTPUT,
-  ];
-}
-
-/**
- * Emits one compact generation log line.
- */
-function logGenerationSummary(
-  generationLabel: number,
-  mutationSchedule: { mutationRate: number; mutationAmount: number },
-  report: FlappyGenerationReport | undefined,
-  fittestGenome: FlappyTrainerNetwork,
-  fallbackEpisode: ReturnType<typeof rolloutEpisode>,
-): void {
-  const bestFitness =
-    report?.bestRobustFitness ??
-    (fittestGenome.score as number) ??
-    fallbackEpisode.fitness;
-  const bestPipesPassed =
-    report?.bestPipesPassed ?? fallbackEpisode.pipesPassed;
-  const bestFramesSurvived =
-    report?.bestFramesSurvived ?? fallbackEpisode.framesSurvived;
-
-  const logParts = buildGenerationLogParts(
-    generationLabel,
-    bestFitness,
-    bestPipesPassed,
-    bestFramesSurvived,
-    report,
-    mutationSchedule,
-  );
-
-  // eslint-disable-next-line no-console
-  console.log(logParts.join(FLAPPY_TRAINER_LOG_PARTS_DELIMITER));
-}
-
-/**
- * Rebuild provisional scores using frame-primary ranking with a pipe filter.
- */
-function assignFramePrimaryScores(
-  population: readonly FlappyTrainerNetwork[],
-  aggregateByGenome: ReadonlyMap<
-    FlappyTrainerNetwork,
-    FlappySeedBatchEvaluation
-  >,
-  provisionalScoresByGenome: Map<FlappyTrainerNetwork, number>,
-): void {
-  const aggregateValues = collectAggregateValues(population, aggregateByGenome);
-  const maxMeanPipesPassed = resolveMaxMeanPipesPassed(aggregateValues);
-
-  for (const genome of population) {
-    const aggregate = aggregateByGenome.get(genome);
-    if (!aggregate) {
-      provisionalScoresByGenome.set(genome, Number.NEGATIVE_INFINITY);
-      continue;
-    }
-
-    provisionalScoresByGenome.set(
-      genome,
-      scoreAggregateFramePrimary(aggregate, maxMeanPipesPassed),
-    );
-  }
-}
-
-/**
- * Collects present aggregate values in population order.
- */
-function collectAggregateValues(
-  population: readonly FlappyTrainerNetwork[],
-  aggregateByGenome: ReadonlyMap<
-    FlappyTrainerNetwork,
-    FlappySeedBatchEvaluation
-  >,
-): FlappySeedBatchEvaluation[] {
-  const aggregateValues: FlappySeedBatchEvaluation[] = [];
-
-  for (const genome of population) {
-    const aggregate = aggregateByGenome.get(genome);
-    if (aggregate) {
-      aggregateValues.push(aggregate);
-    }
-  }
-
-  return aggregateValues;
-}
-
-/**
- * Resolves best mean pipe progress across aggregates.
- */
-function resolveMaxMeanPipesPassed(
-  aggregateValues: readonly FlappySeedBatchEvaluation[],
-): number {
-  return aggregateValues.reduce(function resolveBest(
-    bestPipeProgress,
-    aggregate,
-  ): number {
-    return Math.max(bestPipeProgress, aggregate.meanPipesPassed);
-  }, 0);
-}
-
-/**
- * Score one aggregate with pipes as filter and frames as primary objective.
- */
-function scoreAggregateFramePrimary(
-  aggregate: FlappySeedBatchEvaluation,
-  maxMeanPipesPassed: number,
-): number {
-  const frameStabilityPenalty =
-    aggregate.fitnessStdDev * FLAPPY_TRAINER_FRAME_STABILITY_STDDEV_WEIGHT;
-  const passesPipeFilter =
-    aggregate.meanPipesPassed >=
-    maxMeanPipesPassed - FLAPPY_TRAINER_PIPE_FILTER_TOLERANCE;
-
-  if (passesPipeFilter) {
-    return (
-      FLAPPY_TRAINER_FRAME_PRIMARY_BASE_SCORE +
-      aggregate.meanFramesSurvived *
-        FLAPPY_TRAINER_FRAME_PRIMARY_SURVIVAL_WEIGHT +
-      aggregate.meanPipesPassed * FLAPPY_TRAINER_FRAME_PRIMARY_PIPE_WEIGHT -
-      frameStabilityPenalty
-    );
-  }
-
-  return (
-    aggregate.meanPipesPassed * FLAPPY_TRAINER_PIPE_FALLBACK_PIPE_WEIGHT +
-    aggregate.meanFramesSurvived -
-    frameStabilityPenalty
-  );
-}
-
-/**
- * Resolves full-stage candidate count from population and elitism.
- */
-function resolveFullPassCandidateCount(
-  populationSize: number,
-  elitismCount: number,
-): number {
-  return Math.max(
-    elitismCount * FLAPPY_TRAINER_FULL_PASS_ELITISM_MULTIPLIER,
-    Math.floor(populationSize * FLAPPY_TRAINER_FULL_PASS_POPULATION_FRACTION),
-  );
-}
-
-/**
- * Returns top genomes ordered by current provisional score.
- */
-function selectTopGenomesByScore(
-  population: readonly FlappyTrainerNetwork[],
-  provisionalScoresByGenome: ReadonlyMap<FlappyTrainerNetwork, number>,
-  targetCount: number,
-): FlappyTrainerNetwork[] {
-  const scoredEntries = buildScoredGenomeEntries(
-    population,
-    provisionalScoresByGenome,
-  );
-
-  scoredEntries.sort(compareScoredGenomeEntriesDescending);
-
-  const selectedGenomes: FlappyTrainerNetwork[] = [];
-  const maxSelectionCount = Math.max(
-    0,
-    Math.min(targetCount, scoredEntries.length),
-  );
-
-  let selectedIndex = 0;
-  while (selectedIndex < maxSelectionCount) {
-    const scoredEntry = scoredEntries[selectedIndex];
-    if (scoredEntry) {
-      selectedGenomes.push(scoredEntry.genome);
-    }
-    selectedIndex++;
-  }
-
-  return selectedGenomes;
-}
-
-/**
- * Builds sortable scored entries from genomes.
- */
-function buildScoredGenomeEntries(
-  population: readonly FlappyTrainerNetwork[],
-  provisionalScoresByGenome:
-    | ReadonlyMap<FlappyTrainerNetwork, number>
-    | undefined,
-): ScoredGenomeEntry[] {
-  const scoredEntries: ScoredGenomeEntry[] = [];
-
-  for (const genome of population) {
-    const score = resolveGenomeScore(genome, provisionalScoresByGenome);
-    scoredEntries.push({ genome, score });
-  }
-
-  return scoredEntries;
-}
-
-/**
- * Resolves genome score either from map or direct genome field.
- */
-function resolveGenomeScore(
-  genome: FlappyTrainerNetwork,
-  provisionalScoresByGenome:
-    | ReadonlyMap<FlappyTrainerNetwork, number>
-    | undefined,
-): number {
-  if (provisionalScoresByGenome) {
-    return provisionalScoresByGenome.get(genome) ?? Number.NEGATIVE_INFINITY;
-  }
-  return genome.score ?? Number.NEGATIVE_INFINITY;
-}
-
-/**
- * Sort comparator for scored genome entries (descending by score).
- */
-function compareScoredGenomeEntriesDescending(
-  leftEntry: ScoredGenomeEntry,
-  rightEntry: ScoredGenomeEntry,
-): number {
-  return rightEntry.score - leftEntry.score;
-}
-
 /**
  * Handles fatal `main` rejection path.
  */

package/test/examples/flappy_bird/browser-entry/browser-entry.utils.ts

@@ -1,12 +0,0 @@
-export * from './browser-entry.math.utils';
-export * from './browser-entry.host.utils';
-export * from './browser-entry.network-view.utils';
-export * from './browser-entry.observation.utils';
-export * from './browser-entry.playback.utils';
-export * from './browser-entry.spawn.utils';
-export * from './browser-entry.stats.utils';
-export * from './browser-entry.telemetry.utils';
-export * from './browser-entry.text-frame.utils';
-export * from './browser-entry.viewport.utils';
-export * from './browser-entry.visualization.utils';
-export * from './browser-entry.worker-channel.utils';

package/test/examples/flappy_bird/environment/environment.ts

@@ -1,7 +0,0 @@
-/**
- * Environment domain public entry.
- *
- * This compatibility façade re-exports the current environment implementation
- * while `flappyEnvironment.ts` is decomposed into focused environment modules.
- */
-export * from '../flappyEnvironment';

package/test/examples/flappy_bird/evaluation/evaluation.ts

@@ -1,7 +0,0 @@
-/**
- * Evaluation domain public entry.
- *
- * This compatibility façade re-exports the current evaluation implementation
- * while `flappyEvaluation.ts` is decomposed into focused evaluation modules.
- */
-export * from '../flappyEvaluation';

package/test/examples/flappy_bird/simulation-shared/simulation-shared.ts

@@ -1,15 +0,0 @@
-/**
- * Shared simulation public entry.
- *
- * This compatibility façade re-exports shared simulation utilities while
- * `flappy.simulation.shared.utils.ts` is decomposed into focused modules.
- */
-export * from './simulation-shared.constants';
-export * from './simulation-shared.control.utils';
-export * from './simulation-shared.difficulty.utils';
-export * from './simulation-shared.errors';
-export * from './simulation-shared.math.utils';
-export * from './simulation-shared.memory.utils';
-export * from './simulation-shared.observation.utils';
-export * from './simulation-shared.spawn.utils';
-export * from './simulation-shared.types';

package/test/examples/flappy_bird/trainer/trainer.statistics.utils.ts

@@ -1,78 +0,0 @@
-import { clampValue } from '../flappy.simulation.shared.utils';
-
-/**
- * Computes the arithmetic mean of numeric samples.
- *
- * @param values - Numeric samples.
- * @returns Arithmetic mean.
- */
-export function computeMean(values: readonly number[]): number {
-  if (values.length === 0) return 0;
-  return (
-    values.reduce(function accumulate(sumValue, currentValue): number {
-      return sumValue + currentValue;
-    }, 0) / values.length
-  );
-}
-
-/**
- * Computes population standard deviation from numeric samples.
- *
- * @param values - Numeric samples.
- * @param meanValue - Precomputed mean.
- * @returns Population standard deviation.
- */
-export function computePopulationStandardDeviation(
-  values: readonly number[],
-  meanValue: number,
-): number {
-  if (values.length === 0) return 0;
-
-  const variance =
-    values.reduce(function accumulateVariance(sumValue, currentValue): number {
-      const deltaFromMean = currentValue - meanValue;
-      return sumValue + deltaFromMean * deltaFromMean;
-    }, 0) / values.length;
-
-  return Math.sqrt(Math.max(0, variance));
-}
-
-/**
- * Computes an interpolated percentile value.
- *
- * @param values - Numeric samples.
- * @param percentile - Percentile in [0, 1].
- * @returns Interpolated percentile value.
- */
-export function computePercentile(
-  values: readonly number[],
-  percentile: number,
-): number {
-  if (values.length === 0) return Number.NaN;
-
-  const sortedValues = values.toSorted(compareNumbersAscending);
-
-  const clampedPercentile = clampValue(percentile, 0, 1);
-  const percentileIndex = clampedPercentile * (sortedValues.length - 1);
-  const lowerIndex = Math.floor(percentileIndex);
-  const upperIndex = Math.ceil(percentileIndex);
-  const interpolationWeight = percentileIndex - lowerIndex;
-
-  const lowerValue = sortedValues[lowerIndex] ?? sortedValues[0] ?? Number.NaN;
-  const upperValue = sortedValues[upperIndex] ?? lowerValue;
-  return lowerValue + (upperValue - lowerValue) * interpolationWeight;
-}
-
-/**
- * Numeric ascending comparator.
- *
- * @param leftValue - Left numeric value.
- * @param rightValue - Right numeric value.
- * @returns Ascending comparator delta.
- */
-export function compareNumbersAscending(
-  leftValue: number,
-  rightValue: number,
-): number {
-  return leftValue - rightValue;
-}