@anonympins/fingerprint 0.0.1 → 0.0.2

package/library.js

@@ -13,749 +13,6 @@
 
 import { Worker } from "worker_threads";
 import os from "os";
-/**
- * @namespace Dichotomy
- * @description Un ensemble d'outils de recherche puissants pour les tableaux triés.
- */
-const Dichotomy = {
-  /**
-   * Comparateur par défaut pour les types primitifs (nombres, chaînes).
-   * @private
-   */
-  _defaultComparator(a, b) {
-    if (a < b) return -1;
-    if (a > b) return 1;
-    return 0;
-  },
-
-  /**
-   * L'algorithme de base de la recherche dichotomique.
-   * Trouve l'index d'une valeur cible dans un tableau trié.
-   * Si plusieurs occurrences existent, l'index retourné n'est pas garanti (peut être n'importe laquelle des occurrences).
-   * @template T
-   * @param {Array<T>} arr - Le tableau trié dans lequel chercher.
-   * @param {any} target - La valeur à trouver.
-   * @param {Comparator<T>} [comparator] - Fonction de comparaison.
-   * @returns {number} L'index de la cible si elle est trouvée, sinon -1.
-   */
-  search(arr, target, comparator = this._defaultComparator) {
-    let low = 0;
-    let high = arr.length - 1;
-
-    while (low <= high) {
-      // Utiliser Math.floor pour éviter les problèmes avec les nombres flottants
-      // et pour s'assurer que mid est un entier.
-      const mid = Math.floor(low + (high - low) / 2);
-      const comparison = comparator(arr[mid], target);
-
-      if (comparison === 0) {
-        return mid; // Cible trouvée
-      } else if (comparison < 0) {
-        low = mid + 1; // La cible est dans la moitié droite
-      } else {
-        high = mid - 1; // La cible est dans la moitié gauche
-      }
-    }
-
-    return -1; // Cible non trouvée
-  },
-
-  /**
-   * Trouve l'index de la PREMIÈRE occurrence d'une valeur cible.
-   * Utile quand le tableau contient des doublons.
-   * @template T
-   * @param {Array<T>} arr - Le tableau trié.
-   * @param {any} target - La valeur à trouver.
-   * @param {Comparator<T>} [comparator] - Fonction de comparaison.
-   * @returns {number} L'index de la première occurrence, sinon -1.
-   */
-  findFirst(arr, target, comparator = this._defaultComparator) {
-    let low = 0;
-    let high = arr.length - 1;
-    let result = -1;
-
-    while (low <= high) {
-      const mid = Math.floor(low + (high - low) / 2);
-      const comparison = comparator(arr[mid], target);
-
-      if (comparison === 0) {
-        result = mid;
-        high = mid - 1; // Continuer à chercher à gauche
-      } else if (comparison < 0) {
-        low = mid + 1;
-      } else {
-        high = mid - 1; // On continue de chercher à gauche
-      }
-    }
-
-    return result;
-  },
-
-  /**
-   * Trouve l'index de la DERNIÈRE occurrence d'une valeur cible.
-   * Utile quand le tableau contient des doublons.
-   * @template T
-   * @param {Array<T>} arr - Le tableau trié.
-   * @param {any} target - La valeur à trouver.
-   * @param {Comparator<T>} [comparator] - Fonction de comparaison.
-   * @returns {number} L'index de la dernière occurrence, sinon -1.
-   */
-  findLast(arr, target, comparator = this._defaultComparator) {
-    let low = 0;
-    let high = arr.length - 1;
-    let result = -1;
-
-    while (low <= high) {
-      const mid = Math.floor(low + (high - low) / 2);
-      const comparison = comparator(arr[mid], target);
-
-      if (comparison === 0) {
-        result = mid;
-        low = mid + 1; // Continuer à chercher à droite
-      } else if (comparison < 0) {
-        low = mid + 1; // On continue de chercher à droite
-      } else {
-        high = mid - 1;
-      }
-    }
-
-    return result;
-  },
-
-  /**
-   * Compte le nombre total d'occurrences d'une valeur cible.
-   * Combine findFirst et findLast pour une efficacité maximale.
-   * @template T
-   * @param {Array<T>} arr - Le tableau trié.
-   * @param {any} target - La valeur à compter.
-   * @param {Comparator<T>} [comparator] - Fonction de comparaison.
-   * @returns {number} Le nombre d'occurrences de la cible.
-   */
-  countOccurrences(arr, target, comparator = this._defaultComparator) {
-    const firstIndex = this.findFirst(arr, target, comparator);
-
-    if (firstIndex === -1) {
-      return 0; // Si la première n'existe pas, il n'y en a aucune.
-    }
-
-    // On peut passer `firstIndex` comme point de départ à `findLast` pour optimiser, mais restons simple.
-    const lastIndex = this.findLast(arr, target, comparator);
-    return lastIndex - firstIndex + 1;
-  },
-
-  /**
-   * Trouve l'index où la cible devrait être insérée pour maintenir l'ordre du tableau.
-   * C'est l'équivalent de la fonction `lower_bound` en C++.
-   * @template T
-   * @param {Array<T>} arr - Le tableau trié.
-   * @param {any} target - La valeur à insérer.
-   * @param {Comparator<T>} [comparator] - Fonction de comparaison.
-   * @returns {number} L'index d'insertion approprié.
-   */
-  findInsertionPoint(arr, target, comparator = this._defaultComparator) {
-    let low = 0;
-    let high = arr.length; // Note: high est la longueur du tableau, pas length - 1
-
-    while (low < high) {
-      const mid = Math.floor(low + (high - low) / 2);
-      if (comparator(arr[mid], target) < 0) {
-        low = mid + 1;
-      } else {
-        high = mid;
-      }
-    }
-
-    return low; // ou high, ils sont égaux à la fin de la boucle
-  },
-
-  /**
-   * Vérifie si une valeur cible est présente dans le tableau.
-   * Plus sémantique que `search(arr, target) !== -1`.
-   * @template T
-   * @param {Array<T>} arr - Le tableau trié.
-   * @param {any} target - La valeur à vérifier.
-   * @param {Comparator<T>} [comparator] - Fonction de comparaison.
-   * @returns {boolean} `true` si la cible est présente, sinon `false`.
-   */
-  contains(arr, target, comparator = this._defaultComparator) {
-    return this.search(arr, target, comparator) !== -1;
-  },
-
-  // --- NOUVEAUX ALGORITHMES PUISSANTS ---
-
-  /**
-   * Trouve tous les éléments dans un intervalle [minTarget, maxTarget].
-   * @template T
-   * @param {Array<T>} arr - Le tableau trié.
-   * @param {any} minTarget - La borne inférieure de l'intervalle (inclusive).
-   * @param {any} maxTarget - La borne supérieure de l'intervalle (inclusive).
-   * @param {Comparator<T>} [comparator] - Fonction de comparaison.
-   * @returns {Array<T>} Un sous-tableau contenant les éléments de l'intervalle.
-   */
-  findRange(arr, minTarget, maxTarget, comparator = this._defaultComparator) {
-    // Trouve l'index du premier élément >= minTarget
-    const startIndex = this.findInsertionPoint(arr, minTarget, comparator);
-
-    // Trouve l'index du premier élément > maxTarget
-    let endIndex = this.findInsertionPoint(arr, maxTarget, comparator);
-
-    // Il faut aussi trouver le dernier élément ÉGAL à maxTarget
-    const lastElement = this.findLast(arr, maxTarget, comparator);
-    if (lastElement !== -1) {
-      endIndex = lastElement + 1;
-    }
-
-    return arr.slice(startIndex, endIndex);
-  },
-
-  /**
-   * Trouve l'index de l'élément le plus proche de la cible dans le tableau.
-   * @template T
-   * @param {Array<T>} arr - Le tableau trié.
-   * @param {any} target - La valeur numérique cible.
-   * @param {function(T, any): number} distanceMetric - Une fonction qui retourne la "distance" (un nombre) entre un élément et la cible.
-   * @returns {number} L'index de l'élément le plus proche, ou -1 si le tableau est vide.
-   */
-  findClosest(arr, target, distanceMetric) {
-    if (arr.length === 0) {
-      return -1;
-    }
-
-    let low = 0;
-    let high = arr.length - 1;
-
-    while (low <= high) {
-      const mid = Math.floor(low + (high - low) / 2);
-      const midValue = arr[mid];
-
-      if (distanceMetric(midValue, target) === 0) {
-        return mid;
-      } else if (distanceMetric(midValue, target) < 0) {
-        low = mid + 1;
-      } else {
-        high = mid - 1;
-      }
-    }
-
-    // À la fin de la boucle, `low` et `high` encadrent la position où `target` serait insérée.
-    // L'élément le plus proche est soit à `high`, soit à `low`.
-    if (high < 0) high = 0; // S'assurer que high est un index valide
-    if (low >= arr.length) low = arr.length - 1; // S'assurer que low est un index valide
-    const diffHigh = Math.abs(distanceMetric(arr[high], target));
-    const diffLow = Math.abs(distanceMetric(arr[low], target));
-
-    return diffLow <= diffHigh ? low : high;
-  },
-
-  /**
-   * Trouve la "frontière" dans un tableau où une condition (prédicat) passe de false à true.
-   * C'est une généralisation de findInsertionPoint et findFirst.
-   * @template T
-   * @param {Array<T>} arr - Le tableau où chaque élément peut être évalué par le prédicat.
-   * @param {function(T): boolean} predicate - Une fonction qui retourne true ou false pour un élément.
-   * Le tableau doit être "trié" selon ce prédicat (tous les false avant tous les true).
-   * @returns {number} L'index du premier élément pour lequel le prédicat est true. Retourne arr.length si non trouvé.
-   */
-  findBoundary(arr, predicate) {
-    let low = 0;
-    let high = arr.length;
-    while (low < high) {
-      const mid = Math.floor(low + (high - low) / 2);
-      if (predicate(arr[mid])) {
-        high = mid; // On a trouvé un 'true', la frontière est peut-être avant
-      } else {
-        low = mid + 1; // C'est 'false', la frontière est forcément après
-      }
-    }
-    return low;
-  },
-
-  /**
-   * Effectue une recherche dichotomique sur une fonction pour trouver la plus petite valeur d'entrée
-   * qui satisfait une condition. (Recherche sur la réponse).
-   * @param {number} low - La borne inférieure de l'espace de recherche.
-   * @param {number} high - La borne supérieure de l'espace de recherche.
-   * @param {function(number): boolean} predicate - La fonction de test. Doit être monotone (false...false, true...true).
-   * @param {number} [precision=1e-9] - La précision requise pour la réponse (pour les nombres flottants).
-   * @returns {number} La plus petite valeur (approximative) qui rend le prédicat 'true'.
-   */
-  searchOnAnswer(low, high, predicate, precision = 1e-9) {
-    // Si on travaille avec des entiers, la boucle s'arrête quand low == high
-    const isIntegerSearch =
-      Number.isInteger(low) && Number.isInteger(high) && precision === 1;
-
-    while (high - low > precision) {
-      const mid = isIntegerSearch
-        ? Math.floor(low + (high - low) / 2)
-        : low + (high - low) / 2;
-      if (predicate(mid)) {
-        high = mid; // Cette réponse est possible, essayons plus petit
-      } else {
-        low = mid; // Cette réponse n'est pas possible, il faut viser plus haut
-      }
-    }
-    // Pour les entiers, 'high' est la première bonne réponse. Pour les flottants, c'est une approximation.
-    return high;
-  },
-
-  /**
-   * Trouve la valeur d'entrée qui maximise le résultat d'une fonction unimodale (avec un seul pic).
-   * C'est l'outil adapté pour les problèmes d'optimisation non-monotones.
-   * @param {number} low - La borne inférieure de l'espace de recherche.
-   * @param {number} high - La borne supérieure de l'espace de recherche.
-   * @param {function(number): number} evaluator - Une fonction qui prend une valeur et retourne son "score" ou "altitude".
-   * @param {number} [precision=1e-9] - La précision requise pour la réponse.
-   * @returns {number} La valeur (approximative) qui maximise le résultat de l'évaluateur.
-   */
-  findPeak(low, high, evaluator, precision = 1e-9) {
-    while (high - low > precision) {
-      // On divise l'intervalle restant en trois.
-      const mid1 = low + (high - low) / 3;
-      const mid2 = high - (high - low) / 3;
-
-      const eval1 = evaluator(mid1);
-      const eval2 = evaluator(mid2);
-
-      if (eval1 < eval2) {
-        // Le pic est dans la partie droite (incluant mid2).
-        // On peut éliminer le premier tiers.
-        low = mid1;
-      } else {
-        // Le pic est dans la partie gauche (incluant mid1).
-        // On peut éliminer le troisième tiers.
-        high = mid2;
-      }
-    }
-
-    // low et high sont maintenant très proches. Le pic est entre les deux.
-    // On retourne le milieu de l'intervalle final pour une meilleure approximation.
-    return (low + high) / 2;
-  },
-};
-
-/**
- * @namespace Dichotomy.Operators
- * @description Une bibliothèque de "fabriques de prédicats" pour des problèmes complexes,
- * à utiliser avec `Dichotomy.searchOnAnswer`.
- * Ces opérateurs sont conçus pour des problèmes où la réponse peut être trouvée en testant
- * une seule variable (monodimensionnel).
- * ---
- * @namespace Optimization
- * @description Une bibliothèque d'algorithmes d'optimisation pour des problèmes complexes (multimodaux, multidimensionnels).
- */
-Dichotomy.Operators = {
-  /**
-   * Crée un prédicat pour trouver le niveau de financement de base le plus élevé possible.
-   * @param {object} config - L'objet de configuration.
-   * @param {Array<number>} config.baseNeeds - Tableau des besoins de base de chaque entité.
-   * @param {number} config.totalBudget - Le budget total disponible.
-   * @returns {function(number): boolean} Un prédicat qui prend un `guaranteedLevel` et retourne `true` si le budget est suffisant.
-   */
-  createFairResourceAllocator({ baseNeeds, totalBudget }) {
-    return function isFeasible(guaranteedLevel) {
-      let requiredBudget = 0;
-      for (const need of baseNeeds) {
-        // Chaque entité reçoit AU MOINS le niveau garanti, ou son besoin de base si celui-ci est plus élevé.
-        requiredBudget += Math.max(need, guaranteedLevel);
-      }
-      return requiredBudget <= totalBudget;
-    };
-  },
-
-  /**
-   * Crée un prédicat pour déterminer le taux de vaccination nécessaire pour l'immunité collective.
-   * @param {object} config - L'objet de configuration.
-   * @param {number} config.r0 - Le taux de reproduction de base du virus.
-   * @returns {function(number): boolean} Un prédicat qui prend un `vaccinationRate` (entre 0 et 1) et retourne `true` si l'immunité est atteinte.
-   */
-  createHerdImmunityValidator({ r0 }) {
-    // La formule de base est R_effectif = R0 * (1 - taux_immunité)
-    // On veut R_effectif < 1
-    return function achievesHerdImmunity(immunityRate) {
-      const rEffective = r0 * (1 - immunityRate);
-      return rEffective < 1;
-    };
-  },
-
-  /**
-   * Crée un prédicat pour trouver le bonus de score minimal pour atteindre un objectif d'équité.
-   * @param {object} config - L'objet de configuration.
-   * @param {Array<number>} config.scoresGroupA - Les scores du groupe de référence.
-   * @param {Array<number>} config.scoresGroupB - Les scores du groupe désavantagé.
-   * @param {number} config.maxAllowedDisparity - L'écart de score moyen maximal toléré (ex: 0.05 pour 5%).
-   * @returns {function(number): boolean} Un prédicat qui prend un `bonus` et retourne `true` si l'équité est atteinte.
-   */
-  createFairnessThresholdValidator({
-    scoresGroupA,
-    scoresGroupB,
-    maxAllowedDisparity,
-  }) {
-    const avgA = scoresGroupA.reduce((a, b) => a + b, 0) / scoresGroupA.length;
-
-    return function isFairEnough(bonus) {
-      const avgB_corrected =
-        scoresGroupB.reduce((a, b) => a + b, 0) / scoresGroupB.length + bonus;
-      const newDisparity = Math.abs(avgA - avgB_corrected) / avgA;
-      return newDisparity <= maxAllowedDisparity;
-    };
-  },
-
-  /**
-   * Crée un prédicat pour résoudre le "problème du chargeur de paquets" (Packer Problem).
-   * Le prédicat généré vérifie s'il est possible de transporter une liste d'objets
-   * en un nombre de voyages donné, avec une certaine capacité par voyage.
-   *
-   * @param {object} config - L'objet de configuration.
-   * @param {Array<number>} config.itemSizes - Un tableau des "tailles" de chaque objet (poids, volume, etc.).
-   * @param {number} config.maxTrips - Le nombre maximum de "conteneurs" ou de voyages disponibles.
-   * @returns {function(number): boolean} Un prédicat qui prend une `capacity` et retourne `true` si l'opération est possible.
-   */
-  createShippingValidator({ itemSizes, maxTrips }) {
-    // On pré-calcule le plus gros objet pour une optimisation.
-    const maxItemSize = Math.max(0, ...itemSizes);
-
-    return function isSufficient(capacity) {
-      if (capacity < maxItemSize) {
-        return false; // Impossible si un objet est plus gros que la capacité.
-      }
-
-      let trips = 1;
-      let currentLoad = 0;
-      for (const size of itemSizes) {
-        if (currentLoad + size <= capacity) {
-          currentLoad += size;
-        } else {
-          trips++;
-          currentLoad = size;
-        }
-      }
-      return trips <= maxTrips;
-    };
-  },
-
-  // On pourrait ajouter d'autres opérateurs ici :
-  // - createLoadBalancingValidator(...)
-  // - createRateLimiterValidator(...)
-  // - etc.
-
-  /**
-   * Crée un prédicat pour modéliser l'impact d'une taxe carbone.
-   * @param {object} config - L'objet de configuration.
-   * @param {function(number): number} config.emissionModel - Une fonction qui prend un prix de taxe et retourne les émissions totales (ex: en millions de tonnes).
-   * @param {number} config.targetEmissions - Le niveau d'émission à ne pas dépasser.
-   * @returns {function(number): boolean} Un prédicat qui prend un `taxPrice` et retourne `true` si l'objectif est atteint.
-   */
-  createCarbonTaxValidator({ emissionModel, targetEmissions }) {
-    return function isEffective(taxPrice) {
-      const currentEmissions = emissionModel(taxPrice);
-      return currentEmissions <= targetEmissions;
-    };
-  },
-
-  /**
-   * Crée un prédicat pour évaluer l'impact d'une augmentation du salaire minimum.
-   * @param {object} config - L'objet de configuration.
-   * @param {function(number): number} config.jobLossModel - Une fonction qui prend un salaire horaire et retourne le % de perte d'emploi estimé.
-   * @param {number} config.maxAcceptableJobLoss - Le seuil de perte d'emploi à ne pas dépasser (ex: 0.01 pour 1%).
-   * @returns {function(number): boolean} Un prédicat qui prend un `hourlyWage` et retourne `true` si l'impact est jugé acceptable.
-   */
-  createMinimumWageValidator({ jobLossModel, maxAcceptableJobLoss }) {
-    // Attention : ici, un salaire plus élevé est "moins bon" pour le prédicat.
-    // La fonction `searchOnAnswer` cherche la première valeur qui retourne `true`.
-    // On doit donc inverser la logique. On cherche le premier salaire qui est "inacceptable".
-    return function isUnacceptable(hourlyWage) {
-      const estimatedJobLoss = jobLossModel(hourlyWage);
-      return estimatedJobLoss > maxAcceptableJobLoss;
-    };
-  },
-
-  /**
-   * Crée un prédicat pour un système de quota d'admission universitaire.
-   * @param {object} config - L'objet de configuration.
-   * @param {Array<number>} config.highSchoolSizes - Un tableau avec le nombre de diplômés par lycée.
-   * @param {number} config.universityCapacity - Le nombre total de places disponibles.
-   * @returns {function(number): boolean} Un prédicat qui prend un `quotaPercentage` (0 à 1) et retourne `true` si la capacité n'est pas dépassée.
-   */
-  createAdmissionQuotaValidator({ highSchoolSizes, universityCapacity }) {
-    return function isWithinCapacity(quotaPercentage) {
-      let admittedStudents = 0;
-      for (const size of highSchoolSizes) {
-        admittedStudents += Math.ceil(size * quotaPercentage);
-      }
-      return admittedStudents <= universityCapacity;
-    };
-  },
-
-  /**
-   * Crée un prédicat pour trouver un quota de récolte durable.
-   * @param {object} config - L'objet de configuration.
-   * @param {function(number): number} config.populationModel - Fonction qui prend le quota de l'année N et retourne la population de l'année N+1.
-   * @param {number} config.initialPopulation - La population actuelle.
-   * @returns {function(number): boolean} Un prédicat qui prend un `harvestQuota` et retourne `true` si la population reste stable ou augmente.
-   */
-  createSustainableHarvestValidator({ populationModel, initialPopulation }) {
-    return function isSustainable(harvestQuota) {
-      const nextYearPopulation = populationModel(harvestQuota);
-      return nextYearPopulation >= initialPopulation;
-    };
-  },
-
-  /**
-   * Crée un prédicat pour une politique de libération anticipée.
-   * @param {object} config - L'objet de configuration.
-   * @param {Array<{sentenceLength: number, timeServed: number, riskScore: number}>} config.inmates - Données sur les détenus.
-   * @param {number} config.targetPopulation - La population carcérale cible.
-   * @param {number} config.maxAverageRisk - Le score de risque moyen acceptable pour le groupe libéré.
-   * @param {number} config.currentPopulation - La population carcérale actuelle.
-   * @returns {function(number): boolean} Un prédicat qui prend un `minSentenceServedPercentage` et retourne `true` si les conditions sont remplies.
-   */
-  createEarlyReleaseValidator({
-    inmates,
-    targetPopulation,
-    maxAverageRisk,
-    currentPopulation,
-  }) {
-    return function isViable(minSentenceServedPercentage) {
-      const eligibleInmates = inmates.filter(
-        (p) => p.timeServed / p.sentenceLength >= minSentenceServedPercentage,
-      );
-
-      if (eligibleInmates.length === 0) {
-        // Si personne n'est éligible, la population ne baisse pas.
-        return currentPopulation <= targetPopulation;
-      }
-
-      const finalPopulation = currentPopulation - eligibleInmates.length;
-      if (finalPopulation > targetPopulation) {
-        return false; // Pas assez de libérations pour atteindre l'objectif.
-      }
-
-      const totalRisk = eligibleInmates.reduce(
-        (sum, p) => sum + p.riskScore,
-        0,
-      );
-      const averageRisk = totalRisk / eligibleInmates.length;
-
-      return averageRisk <= maxAverageRisk;
-    };
-  },
-
-  /**
-   * Crée un prédicat pour équilibrer la modération de contenu.
-   * @param {object} config - L'objet de configuration.
-   * @param {function(number): {workloadReduction: number, falsePositiveRate: number}} config.moderationModel - Modèle qui simule l'impact d'un seuil.
-   * @param {number} config.minWorkloadReduction - L'objectif de réduction de charge de travail (ex: 0.9).
-   * @param {number} config.maxFalsePositiveRate - Le taux de faux positifs à ne pas dépasser (ex: 0.001).
-   * @returns {function(number): boolean} Un prédicat qui prend un `toxicityThreshold` et retourne `true` si les objectifs sont atteints.
-   */
-  createContentModerationValidator({
-    moderationModel,
-    minWorkloadReduction,
-    maxFalsePositiveRate,
-  }) {
-    return function isBalanced(toxicityThreshold) {
-      const { workloadReduction, falsePositiveRate } =
-        moderationModel(toxicityThreshold);
-      return (
-        workloadReduction >= minWorkloadReduction &&
-        falsePositiveRate <= maxFalsePositiveRate
-      );
-    };
-  },
-
-  /**
-   * Crée un évaluateur pour trouver le prix qui maximise le revenu.
-   * @param {object} config - L'objet de configuration.
-   * @param {function(number): number} config.demandModel - Fonction qui prend un prix et retourne le nombre d'unités vendues.
-   * @returns {function(number): number} Un évaluateur qui prend un `price` et retourne le revenu total.
-   */
-  createOptimalPricingModel({ demandModel }) {
-    return function revenueEvaluator(price) {
-      if (price < 0) return 0;
-      const unitsSold = demandModel(price);
-      return price * unitsSold;
-    };
-  },
-
-  /**
-   * Crée un évaluateur pour trouver le taux de commission qui maximise le revenu de la plateforme.
-   * @param {object} config - L'objet de configuration.
-   * @param {number} config.totalAdvertiserCredits - Le total des crédits disponibles chez les annonceurs.
-   * @param {number} config.totalWebsites - Le nombre total de sites monétisés.
-   * @returns {function(number): number} Un évaluateur qui prend un `commissionRate` et retourne le revenu estimé.
-   */
-  createPlatformRevenueEvaluator({ totalAdvertiserCredits, totalWebsites }) {
-    // Modèle de la demande (Annonceurs)
-    // Plus la commission est basse, plus ils sont prêts à acheter de clics.
-    const advertiserDemandModel = (commissionRate) => {
-      // Le nombre de clics "demandés" diminue à mesure que la commission augmente.
-      // La demande est aussi proportionnelle au total des crédits disponibles.
-      // --- SOLUTION : Ajout d'une demande de base pour éviter un taux de 0% ---
-      // Représente l'intérêt potentiel même sans crédits existants.
-      const baseDemand = (totalAdvertiserCredits || 100) * 10; // On simule 100 crédits de base.
-      // La demande diminue avec la racine carrée de la commission, ce qui la rend moins sensible au début.
-      return baseDemand * (1 - Math.pow(commissionRate, 0.5));
-    };
-
-    // Modèle de l'offre (Webmasters)
-    // Plus leur rémunération est haute (commission basse), plus ils offrent d'espaces.
-    const webmasterSupplyModel = (commissionRate) => {
-      // L'offre de clics augmente quand la commission baisse (et donc que leur gain augmente).
-      const baseSupply = totalWebsites * 500; // Ex: 500 clics potentiels par site
-      // L'offre est un peu moins sensible à la commission que la demande.
-      return baseSupply * (1 - commissionRate * 0.8);
-    };
-
-    return function platformRevenueEvaluator(commissionRate) {
-      if (commissionRate < 0 || commissionRate > 1) return 0;
-      const demand = advertiserDemandModel(commissionRate);
-      const supply = webmasterSupplyModel(commissionRate);
-      const clicks = Math.min(demand, supply);
-      return clicks * commissionRate; // Le revenu est le nombre de clics * la commission
-    };
-  },
-
-  /**
-   * Crée un évaluateur N-Dimensionnel pour le rendement d'une culture en fonction de multiples facteurs.
-   * @param {object} config - L'objet de configuration.
-   * @param {Array<{name: string, optimalAmount: number, weight: number, sensitivity: number}>} config.factors - Chaque facteur a une quantité optimale, un poids, et une sensibilité.
-   * @param {number} config.baseYield - Le rendement de base sans aucun apport.
-   * @returns {function(Array<number>): number} Un évaluateur qui prend un tableau de quantités (`amounts`) et retourne le rendement total. Le but est de MAXIMISER ce rendement.
-   */
-  createMultiFactorCropYieldModel({ factors, baseYield }) {
-    return function multiFactorYieldEvaluator(amounts) {
-      if (amounts.length !== factors.length) {
-        throw new Error(
-          "Le nombre de quantités doit correspondre au nombre de facteurs.",
-        );
-      }
-
-      let totalYield = baseYield;
-      for (let i = 0; i < factors.length; i++) {
-        const factor = factors[i];
-        const amount = amounts[i];
-        if (amount < 0) return -Infinity; // Pénalité forte pour les valeurs impossibles
-
-        const deviation = amount - factor.optimalAmount;
-        // La sensibilité contrôle la "largeur" de la parabole. Une sensibilité élevée rend le rendement plus sensible aux écarts.
-        totalYield +=
-          factor.weight -
-          (factor.sensitivity * deviation * deviation) /
-            (factor.optimalAmount + 1e-6);
-      }
-      return totalYield;
-    };
-  },
-
-  /**
-   * Crée un évaluateur pour le rendement d'une culture en fonction de la quantité d'engrais.
-   * @param {object} config - L'objet de configuration.
-   * @param {number} config.optimalAmount - La quantité d'engrais qui produit le rendement maximal.
-   * @param {number} config.maxYield - Le rendement maximal possible.
-   * @returns {function(number): number} Un évaluateur qui prend une `fertilizerAmount` et retourne le rendement.
-   */
-  createCropYieldModel({ optimalAmount, maxYield }) {
-    // Modèle quadratique simple : le rendement diminue symétriquement autour de l'optimum.
-    return function yieldEvaluator(fertilizerAmount) {
-      if (fertilizerAmount < 0) return 0;
-      const deviation = fertilizerAmount - optimalAmount;
-      // La formule est une parabole inversée.
-      const yieldValue = maxYield - (deviation * deviation) / optimalAmount;
-      return Math.max(0, yieldValue); // Le rendement ne peut pas être négatif.
-    };
-  },
-
-  /**
-   * Crée un évaluateur pour la satisfaction utilisateur d'une durée d'animation.
-   * @param {object} config - L'objet de configuration.
-   * @param {number} config.idealDuration - La durée perçue comme parfaite (ex: 250ms).
-   * @returns {function(number): number} Un évaluateur qui prend une `duration` et retourne un score de satisfaction.
-   */
-  createAnimationTimingModel({ idealDuration }) {
-    // Modèle basé sur une fonction de Gauss. Le score est maximal à la durée idéale et chute rapidement.
-    return function satisfactionEvaluator(duration) {
-      if (duration <= 0) return 0;
-      const deviation = duration - idealDuration;
-      const sigma = idealDuration / 2; // L'écart-type contrôle la "tolérance" autour de l'idéal.
-      return Math.exp(-(deviation * deviation) / (2 * sigma * sigma));
-    };
-  },
-
-  /**
-   * Crée un évaluateur pour le problème de la brachistochrone (toboggan le plus rapide).
-   * @param {object} config - L'objet de configuration.
-   * @param {{x: number, y: number}} config.startPoint - Le point de départ.
-   * @param {{x: number, y: number}} config.endPoint - Le point d'arrivée.
-   * @param {number} config.numPoints - Le nombre de points intermédiaires pour discrétiser la courbe.
-   * @returns {function(Array<number>): number} Un évaluateur qui prend un tableau de hauteurs `y` et retourne le temps de descente.
-   */
-  createBrachistochroneEvaluator({ startPoint, endPoint, numPoints }) {
-    const g = 9.81; // Accélération gravitationnelle
-    const segmentLengthX = endPoint.x / (numPoints + 1);
-    const epsilon = 1e-6; // Pour éviter la division par zéro au départ
-
-    return function evaluateSlideTime(slideShape) {
-      const points = [
-        startPoint,
-        ...slideShape.map((y, i) => ({ x: (i + 1) * segmentLengthX, y })),
-        endPoint,
-      ];
-
-      let totalTime = 0;
-      for (let i = 0; i < points.length - 1; i++) {
-        const p1 = points[i];
-        const p2 = points[i + 1];
-
-        const deltaX = p2.x - p1.x;
-        const deltaY = p2.y - p1.y;
-        const segmentDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
-
-        // Vitesse basée sur la conservation de l'énergie: v = sqrt(2*g*h)
-        const v1 = Math.sqrt(2 * g * (startPoint.y - p1.y + epsilon));
-        const v2 = Math.sqrt(2 * g * (startPoint.y - p2.y + epsilon));
-        const avgVelocity = (v1 + v2) / 2;
-
-        if (avgVelocity > 0) {
-          totalTime += segmentDistance / avgVelocity;
-        }
-      }
-      return totalTime;
-    };
-  },
-
-  /**
-   * Crée une fonction qui calcule le gradient pour le problème de la brachistochrone.
-   * @param {object} config - L'objet de configuration.
-   * @param {{x: number, y: number}} config.startPoint - Le point de départ.
-   * @param {{x: number, y: number}} config.endPoint - Le point d'arrivée.
-   * @param {number} config.numPoints - Le nombre de points intermédiaires.
-   * @returns {function(Array<number>): Array<number>} Une fonction qui retourne le gradient du temps de descente par rapport aux hauteurs `y`.
-   */
-  createBrachistochroneGradient({ startPoint, endPoint, numPoints }) {
-    const evaluator = this.createBrachistochroneEvaluator({
-      startPoint,
-      endPoint,
-      numPoints,
-    });
-    const h = 1e-5; // Petit pas pour la différenciation numérique
-
-    return function calculateGradient(slideShape) {
-      const gradient = [];
-      const baseTime = evaluator(slideShape);
-
-      for (let i = 0; i < slideShape.length; i++) {
-        const newShape = [...slideShape];
-        newShape[i] += h;
-        const newTime = evaluator(newShape);
-
-        // Dérivée partielle par différence finie
-        const derivative = (newTime - baseTime) / h;
-        gradient.push(derivative);
-      }
-      return gradient;
-    };
-  },
-};
 
 const Optimization = {
   // eslint-disable-line no-unused-vars
@@ -1463,87 +720,6 @@ Optimization.cmaes = function(fitnessFunction, initialSolution, initialStepSize,
     return { solution: bestSolution, fitness: bestFitness };
 };
 
-/**
- * @class BinarySearchTree
- * @description Implémentation d'un Arbre Binaire de Recherche.
- * Chaque noeud a une valeur, et des sous-arbres gauche/droit.
- */
-Dichotomy.BinarySearchTree = class {
-  constructor(comparator = Dichotomy._defaultComparator) {
-    this.root = null;
-    this.comparator = comparator;
-  }
-
-  /**
-   * Insère une nouvelle valeur dans l'arbre.
-   * @param {*} value
-   */
-  insert(value) {
-    const newNode = { value, left: null, right: null };
-    if (!this.root) {
-      this.root = newNode;
-      return;
-    }
-
-    let current = this.root;
-    while (true) {
-      const comparison = this.comparator(value, current.value);
-      if (comparison < 0) {
-        // Aller à gauche
-        if (!current.left) {
-          current.left = newNode;
-          return;
-        }
-        current = current.left;
-      } else {
-        // Aller à droite (ou si égal, pour permettre les doublons)
-        if (!current.right) {
-          current.right = newNode;
-          return;
-        }
-        current = current.right;
-      }
-    }
-  }
-
-  /**
-   * Vérifie si une valeur est présente dans l'arbre.
-   * @param {*} value
-   * @returns {boolean}
-   */
-  contains(value) {
-    let current = this.root;
-    while (current) {
-      const comparison = this.comparator(value, current.value);
-      if (comparison === 0) {
-        return true;
-      } else if (comparison < 0) {
-        current = current.left;
-      } else {
-        current = current.right;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Effectue un parcours In-Order (gauche, racine, droite) qui retourne les éléments triés.
-   * @returns {Array<*>}
-   */
-  inOrderTraversal() {
-    const result = [];
-    function traverse(node) {
-      if (node) {
-        traverse(node.left);
-        result.push(node.value);
-        traverse(node.right);
-      }
-    }
-    traverse(this.root);
-    return result;
-  }
-};
-
 /**
  * @namespace Optimization.Operators
  * @description Une bibliothèque de "fabriques d'évaluateurs" pour des problèmes d'optimisation complexes,