@open3cl/engine 1.7.1 → 1.7.3

package/features/engine/domain/enveloppe/mur/deperdition-mur.service.js

@@ -129,20 +129,29 @@ export class DeperditionMurService extends DeperditionService {
     }
 
     /**
-     * Pour l’ensemble des parois, la présence d’un doublage apporte une résistance thermique supplémentaire
+     * Pour l’ensemble des parois, la présence d’un doublage apporte une résistance thermique supplémentaire.
+     * Cependant, lorsqu'une isolation ITE ou ITI est présente, le doublage NE doit PAS être cumulé.
+     * Le doublage n'est pris en compte que si aucune isolation ITE/ITI n'est appliquée.
+     * Types d'isolation avec ITE ou ITI : 3 (iti), 4 (ite), 6 (iti+ite), 7 (iti+itr), 8 (ite+itr)
+     * @see https://github.com/Open3CL/engine/issues/146
      */
-    switch (murDE.enum_type_doublage_id) {
-      case '3':
-        // doublage indéterminé ou lame d'air inf 15 mm
-        umur0 = 1 / (1 / umur0 + 0.1);
-        break;
-      case '4': // doublage indéterminé ou lame d'air sup 15 mm
-      case '5': // doublage connu (plâtre brique bois)
-        umur0 = 1 / (1 / umur0 + 0.21);
-        break;
-      default:
-        // absence de doublage ou inconnu
-        break;
+    const typeIsolation = parseInt(murDE.enum_type_isolation_id) || 1;
+    const hasIteOrIti = [3, 4, 6, 7, 8].includes(typeIsolation);
+
+    if (!hasIteOrIti) {
+      switch (murDE.enum_type_doublage_id) {
+        case '3':
+          // doublage indéterminé ou lame d'air inf 15 mm
+          umur0 = 1 / (1 / umur0 + 0.1);
+          break;
+        case '4': // doublage indéterminé ou lame d'air sup 15 mm
+        case '5': // doublage connu (plâtre brique bois)
+          umur0 = 1 / (1 / umur0 + 0.21);
+          break;
+        default:
+          // absence de doublage ou inconnu
+          break;
+      }
     }
 
     /**

package/ficheTechnique.js

@@ -1,3 +1,85 @@
+/**
+ * Recherche dans les fiches techniques d'un DPE.
+ *
+ * L'implémentation précédente rebalayait la totalité des fiches à chaque appel, concaténait les
+ * sous-fiches dans un `reduce` (`acc.concat(...)` recopie l'accumulateur à chaque itération) et
+ * remettait en minuscules des valeurs qui ne changent jamais. Le coût par appel croissait en
+ * `fiches^1,3`.
+ *
+ * Sur un DPE de logement individuel, une poignée de fiches : invisible. Sur un DPE collectif,
+ * les fiches suivent les installations — un DPE mesuré comptait 235 fiches et 1597 sous-fiches
+ * pour 73 générateurs — et la fonction représentait alors **54 % du temps de `calcul_3cl`**,
+ * le ramasse-miettes des concaténations comptant pour 10 % de plus.
+ *
+ * Les fiches techniques ne sont jamais modifiées pendant un calcul : elles sont donc indexées
+ * une fois par DPE, par catégorie, avec les minuscules pré-calculées. L'index est mémorisé dans
+ * une `WeakMap` sur le DPE lui-même, donc libéré avec lui — rien à vider, aucune fuite possible
+ * sur un process qui enchaîne les calculs.
+ */
+
+/** @type {WeakMap<object, Map<string, {sousFiches: any[], valeursMinuscules: (string|null)[], champsMinuscules: Map<string, (string|null)[]>}[]>>} */
+const indexParDpe = new WeakMap();
+
+/**
+ * Regroupe les sous-fiches par catégorie, en conservant l'ordre du document — l'ordre détermine
+ * quelle correspondance est retournée en premier.
+ *
+ * @param dpe {FullDpe}
+ */
+function indexerFichesTechniques(dpe) {
+  const parCategorie = new Map();
+
+  /** @type {FicheTechniqueItem[]} */
+  let fichesTechniques = dpe.fiche_technique_collection?.fiche_technique || [];
+  if (!Array.isArray(fichesTechniques)) {
+    fichesTechniques = [fichesTechniques];
+  }
+
+  for (const ficheTechnique of fichesTechniques) {
+    if (!ficheTechnique) continue;
+
+    const categorie = ficheTechnique.enum_categorie_fiche_technique_id;
+    let groupes = parCategorie.get(categorie);
+    if (!groupes) {
+      groupes = [];
+      parCategorie.set(categorie, groupes);
+    }
+
+    const brut = ficheTechnique.sous_fiche_technique_collection?.sous_fiche_technique;
+    const sousFiches = brut === undefined ? [] : Array.isArray(brut) ? brut : [brut];
+
+    groupes.push({
+      sousFiches,
+      // `valeur` en minuscules, calculée une fois ; null quand ce n'est pas une chaîne, auquel
+      // cas la comparaison se fait par identité stricte comme avant.
+      valeursMinuscules: sousFiches.map((sousFiche) =>
+        typeof sousFiche?.valeur === 'string' ? sousFiche.valeur.toLowerCase() : null
+      ),
+      // Les autres champs sont mis en minuscules à la demande : seuls `description` et `valeur`
+      // sont interrogés en pratique, inutile de préparer le reste.
+      champsMinuscules: new Map()
+    });
+  }
+
+  return parCategorie;
+}
+
+/**
+ * @param groupe {{sousFiches: any[], champsMinuscules: Map<string, (string|null)[]>}}
+ * @param field {string}
+ * @returns {(string|null)[]}
+ */
+function champEnMinuscules(groupe, field) {
+  let valeurs = groupe.champsMinuscules.get(field);
+  if (valeurs === undefined) {
+    valeurs = groupe.sousFiches.map((sousFiche) =>
+      sousFiche && sousFiche[field] ? sousFiche[field].toString().toLowerCase() : null
+    );
+    groupe.champsMinuscules.set(field, valeurs);
+  }
+  return valeurs;
+}
+
 /**
  * Retourne si elle existe la fiche technique contenant le texte description et
  * présente dans la catégorie de fiches techniques ayant pour catégorie categoryFicheTechiqueId
@@ -15,72 +97,70 @@ export default function getFicheTechnique(
   classifications = [],
   field = 'description'
 ) {
-  /** @type {FicheTechniqueItem[]} */
-  let fichesTechniques = dpe.fiche_technique_collection?.fiche_technique || [];
+  let index = indexParDpe.get(dpe);
+  if (index === undefined) {
+    index = indexerFichesTechniques(dpe);
+    indexParDpe.set(dpe, index);
+  }
 
-  if (!Array.isArray(fichesTechniques)) {
-    fichesTechniques = [fichesTechniques];
+  const groupes = index.get(categoryFicheTechiqueId);
+  if (!groupes) {
+    return null;
   }
 
   classifications = classifications.filter((classification) => classification);
+  const aiguilles = classifications.map((classification) =>
+    classification.toString().toLowerCase()
+  );
+  const descriptionMinuscule = description.toLowerCase();
 
-  fichesTechniques = fichesTechniques
-    .filter((ficheTechnique) => ficheTechnique)
-    .reduce((acc, ficheTechnique) => {
-      if (ficheTechnique.enum_categorie_fiche_technique_id === categoryFicheTechiqueId) {
-        /**
-         * Plusieurs collections de fiches techniques peuvent exister pour la même catégorie (pour 2 systèmes ECS par exemple)
-         * Le champs classification permet de trouver la collection qui convient en filtrant sur une seconde donnée
-         */
-        if (classifications.length) {
-          /** @type {SousFicheTechniqueItem[]} */
-          let sousFichesTechniques =
-            ficheTechnique.sous_fiche_technique_collection.sous_fiche_technique;
-
-          if (!Array.isArray(sousFichesTechniques)) {
-            sousFichesTechniques = [sousFichesTechniques];
-          }
-
-          const allContained = classifications.every((classification) =>
-            sousFichesTechniques.some((ficheTechnique) => {
-              const valeur = ficheTechnique?.valeur;
-
-              if (typeof valeur === 'string') {
-                return (
-                  ficheTechnique.valeur
-                    .toLowerCase()
-                    .indexOf(classification.toString().toLowerCase()) !== -1
-                );
-              }
+  for (const groupe of groupes) {
+    /**
+     * Plusieurs collections de fiches techniques peuvent exister pour la même catégorie (pour 2
+     * systèmes ECS par exemple). Le champ classification permet de trouver la collection qui
+     * convient en filtrant sur une seconde donnée.
+     */
+    if (classifications.length) {
+      let toutesPresentes = true;
 
-              return ficheTechnique.valeur === classification;
-            })
-          );
+      for (let i = 0; i < classifications.length; i++) {
+        const aiguille = aiguilles[i];
+        let presente = false;
 
-          if (!allContained) {
-            return acc;
+        for (let j = 0; j < groupe.sousFiches.length; j++) {
+          const valeurMinuscule = groupe.valeursMinuscules[j];
+          if (valeurMinuscule !== null) {
+            if (valeurMinuscule.indexOf(aiguille) !== -1) {
+              presente = true;
+              break;
+            }
+          } else if (groupe.sousFiches[j].valeur === classifications[i]) {
+            presente = true;
+            break;
           }
         }
 
-        return acc.concat(ficheTechnique.sous_fiche_technique_collection.sous_fiche_technique);
+        if (!presente) {
+          toutesPresentes = false;
+          break;
+        }
       }
-      return acc;
-    }, []);
-
-  if (!fichesTechniques.length) {
-    return null;
-  }
 
-  const firstFiche = fichesTechniques.filter(
-    (ficheTechnique) =>
-      ficheTechnique &&
-      ficheTechnique[field] &&
-      ficheTechnique[field].toString().toLowerCase().indexOf(description.toLowerCase()) !== -1
-  );
+      if (!toutesPresentes) continue;
+    }
 
-  if (!firstFiche.length) {
-    return null;
+    // L'ancienne implémentation aplatissait toutes les catégories correspondantes avant de
+    // filtrer : la première correspondance du tableau aplati est la première correspondance du
+    // premier groupe qui en contient une. Parcourir les groupes dans l'ordre donne le même
+    // résultat, sans construire le tableau intermédiaire.
+    const champs = champEnMinuscules(groupe, field);
+    for (let j = 0; j < groupe.sousFiches.length; j++) {
+      const champ = champs[j];
+      if (champ !== null && champ.indexOf(descriptionMinuscule) !== -1) {
+        return groupe.sousFiches[j];
+      }
+    }
   }
 
-  return firstFiche[0];
+  return null;
 }

package/ficheTechnique.spec.js

@@ -188,21 +188,53 @@ describe('FicheTechnique service tests', () => {
 
     fiche = getFicheTechnique(dpe, '10', 'non existing');
     expect(fiche).toBeNull();
+  });
 
-    dpe.fiche_technique_collection.fiche_technique[0].sous_fiche_technique_collection.sous_fiche_technique =
-      null;
-
-    fiche = getFicheTechnique(dpe, '11', 'non existing');
-    expect(fiche).toBeNull();
-
-    dpe.fiche_technique_collection.fiche_technique[0].sous_fiche_technique_collection = null;
-
-    fiche = getFicheTechnique(dpe, '11', 'non existing');
-    expect(fiche).toBeNull();
-
-    dpe.fiche_technique_collection.fiche_technique = null;
+  /**
+   * Les fiches techniques sont indexées une fois par objet DPE : chaque cas utilise donc un DPE
+   * neuf, muter un DPE déjà interrogé n'aurait aucun effet.
+   */
+  describe('fiches techniques absentes ou incomplètes', () => {
+    const buildDpe = (ficheTechnique) => ({
+      fiche_technique_collection: { fiche_technique: ficheTechnique }
+    });
+
+    test.each([
+      ['sans fiche_technique_collection', {}],
+      ['avec fiche_technique null', buildDpe(null)],
+      ['avec une fiche technique null', buildDpe([null])],
+      [
+        'sans sous_fiche_technique_collection',
+        buildDpe([
+          { enum_categorie_fiche_technique_id: '10', sous_fiche_technique_collection: null }
+        ])
+      ],
+      [
+        'avec des sous-fiches null ou sans description',
+        buildDpe([
+          {
+            enum_categorie_fiche_technique_id: '10',
+            sous_fiche_technique_collection: {
+              sous_fiche_technique: [null, { valeur: 'plusieurs' }]
+            }
+          }
+        ])
+      ]
+    ])('retourne null %s', (_, dpeIncomplet) => {
+      expect(getFicheTechnique(dpeIncomplet, '10', 'exposées')).toBeNull();
+    });
+
+    test('ignore les fiches techniques null au milieu des autres', () => {
+      const fiche = { description: 'Façades exposées: plusieurs', valeur: 'plusieurs' };
+      const dpeAvecTrou = buildDpe([
+        null,
+        {
+          enum_categorie_fiche_technique_id: '10',
+          sous_fiche_technique_collection: { sous_fiche_technique: [fiche] }
+        }
+      ]);
 
-    fiche = getFicheTechnique(dpe, '10', 'non existing');
-    expect(fiche).toBeNull();
+      expect(getFicheTechnique(dpeAvecTrou, '10', 'exposées')).toBe(fiche);
+    });
   });
 });

package/formula.js

@@ -0,0 +1,251 @@
+/**
+ * Évaluation des formules tableur présentes dans les tables de valeurs.
+ *
+ * Remplace `mathjs` — dont seul `evaluate()` était utilisé, pour une grammaire très réduite —
+ * par un analyseur dédié. mathjs tirait 113 modules (mathjs, decimal.js, fraction.js,
+ * typed-function, seedrandom, @babel/runtime) et ~500 ms d'initialisation, et re-parsait la
+ * chaîne de la formule à chaque appel.
+ *
+ * Grammaire supportée, alignée sur ce que mathjs acceptait pour ces formules :
+ *   - nombres décimaux, séparateur `.` ou `,` (`0,085` ≡ `0.085`)
+ *   - pourcentages : `0.6%` vaut 0.006
+ *   - variables : `Pn`, `logPn`, `E`, `F`
+ *   - fonction : `log10(x)`
+ *   - opérateurs : `+` `-` `*` `/` `^` et parenthèses
+ *   - multiplication implicite : `2 logPn` ≡ `2 * logPn`
+ *
+ * `^` est associatif à droite et lie plus fort que le moins unaire (`-2^2` vaut -4,
+ * `2^-1` vaut 0.5), comme dans mathjs.
+ *
+ * Chaque formule n'est analysée qu'une fois : le résultat est une fermeture mise en cache.
+ */
+
+const VARIABLES = ['Pn', 'logPn', 'E', 'F'];
+const FUNCTIONS = { log10: Math.log10 };
+
+/* --------------------------------------------------------------------------------------- */
+/* Analyse lexicale                                                                          */
+/* --------------------------------------------------------------------------------------- */
+
+/**
+ * @param source {string}
+ * @returns {{type: string, value: *}[]}
+ */
+function tokenize(source) {
+  const tokens = [];
+  let i = 0;
+
+  while (i < source.length) {
+    const c = source[i];
+
+    if (c === ' ' || c === '\t' || c === '\n' || c === '\r') {
+      i += 1;
+      continue;
+    }
+
+    if (c >= '0' && c <= '9') {
+      let j = i;
+      while (j < source.length && source[j] >= '0' && source[j] <= '9') j += 1;
+      if (source[j] === '.' || source[j] === ',') {
+        j += 1;
+        while (j < source.length && source[j] >= '0' && source[j] <= '9') j += 1;
+      }
+      let value = Number(source.slice(i, j).replace(',', '.'));
+      i = j;
+      // Un `%` suffixant un nombre en fait une fraction : `0.6%` → 0.006.
+      while (i < source.length && (source[i] === ' ' || source[i] === '\t')) i += 1;
+      if (source[i] === '%') {
+        value /= 100;
+        i += 1;
+      }
+      tokens.push({ type: 'number', value });
+      continue;
+    }
+
+    if (/[A-Za-z_]/.test(c)) {
+      let j = i;
+      while (j < source.length && /[A-Za-z0-9_]/.test(source[j])) j += 1;
+      tokens.push({ type: 'name', value: source.slice(i, j) });
+      i = j;
+      continue;
+    }
+
+    if ('+-*/^()'.includes(c)) {
+      tokens.push({ type: c, value: c });
+      i += 1;
+      continue;
+    }
+
+    throw new SyntaxError(`caractère inattendu \`${c}\` dans la formule \`${source}\``);
+  }
+
+  return tokens;
+}
+
+/* --------------------------------------------------------------------------------------- */
+/* Analyse syntaxique — descente récursive, produit une fermeture (scope) => number           */
+/* --------------------------------------------------------------------------------------- */
+
+/**
+ * @param source {string}
+ * @returns {(scope: {Pn: number, logPn: number, E: number, F: number}) => number}
+ */
+function parse(source) {
+  const tokens = tokenize(source);
+  let pos = 0;
+
+  const peek = () => tokens[pos];
+  const eat = (type) => {
+    if (!tokens[pos] || tokens[pos].type !== type) {
+      throw new SyntaxError(`\`${type}\` attendu dans la formule \`${source}\``);
+    }
+    return tokens[pos++];
+  };
+
+  /** Un jeton qui peut démarrer un facteur — sert à détecter la multiplication implicite. */
+  const startsFactor = () => {
+    const t = peek();
+    return !!t && (t.type === 'number' || t.type === 'name' || t.type === '(');
+  };
+
+  function parseExpression() {
+    let left = parseTerm();
+    while (peek() && (peek().type === '+' || peek().type === '-')) {
+      const op = tokens[pos++].type;
+      const right = parseTerm();
+      const l = left;
+      left = op === '+' ? (s) => l(s) + right(s) : (s) => l(s) - right(s);
+    }
+    return left;
+  }
+
+  function parseTerm() {
+    let left = parseUnary();
+    for (;;) {
+      const t = peek();
+      if (t && (t.type === '*' || t.type === '/')) {
+        const op = tokens[pos++].type;
+        const right = parseUnary();
+        const l = left;
+        left = op === '*' ? (s) => l(s) * right(s) : (s) => l(s) / right(s);
+      } else if (startsFactor()) {
+        // multiplication implicite : `2 logPn`
+        const right = parseUnary();
+        const l = left;
+        left = (s) => l(s) * right(s);
+      } else {
+        return left;
+      }
+    }
+  }
+
+  function parseUnary() {
+    const t = peek();
+    if (t && (t.type === '+' || t.type === '-')) {
+      pos += 1;
+      const operand = parseUnary();
+      return t.type === '-' ? (s) => -operand(s) : operand;
+    }
+    return parsePower();
+  }
+
+  function parsePower() {
+    const base = parsePrimary();
+    if (peek() && peek().type === '^') {
+      pos += 1;
+      // associatif à droite, et l'exposant peut être signé : `(Pn)^-0.4`
+      const exponent = parseUnary();
+      return (s) => base(s) ** exponent(s);
+    }
+    return base;
+  }
+
+  function parsePrimary() {
+    const t = peek();
+    if (!t) throw new SyntaxError(`formule incomplète : \`${source}\``);
+
+    if (t.type === 'number') {
+      pos += 1;
+      const { value } = t;
+      return () => value;
+    }
+
+    if (t.type === '(') {
+      pos += 1;
+      const inner = parseExpression();
+      eat(')');
+      return inner;
+    }
+
+    if (t.type === 'name') {
+      pos += 1;
+      const name = t.value;
+
+      if (peek() && peek().type === '(') {
+        const fn = FUNCTIONS[name];
+        if (!fn) throw new SyntaxError(`fonction inconnue \`${name}\` dans \`${source}\``);
+        pos += 1;
+        const arg = parseExpression();
+        eat(')');
+        return (s) => fn(arg(s));
+      }
+
+      if (!VARIABLES.includes(name)) {
+        throw new SyntaxError(`variable inconnue \`${name}\` dans \`${source}\``);
+      }
+      return (s) => s[name];
+    }
+
+    throw new SyntaxError(`jeton inattendu \`${t.value}\` dans \`${source}\``);
+  }
+
+  const compiled = parseExpression();
+  if (pos !== tokens.length) {
+    throw new SyntaxError(`fin de formule inattendue dans \`${source}\``);
+  }
+  return compiled;
+}
+
+/* --------------------------------------------------------------------------------------- */
+/* API                                                                                       */
+/* --------------------------------------------------------------------------------------- */
+
+const compiledFormulas = new Map();
+
+/**
+ * Compile une formule (ou la récupère depuis le cache).
+ *
+ * @param formula {string}
+ * @returns {(scope: {Pn: number, logPn: number, E: number, F: number}) => number}
+ */
+export function compileFormula(formula) {
+  let compiled = compiledFormulas.get(formula);
+  if (compiled === undefined) {
+    compiled = parse(formula);
+    compiledFormulas.set(formula, compiled);
+  }
+  return compiled;
+}
+
+/**
+ * Évalue une formule tableur, ou retourne la valeur telle quelle si c'en est déjà une.
+ *
+ * @param formulaOrValue {string|number} Formule tableur ou valeur numérique.
+ * @param pn {number} Puissance nominale en W (exposée à la formule sous `Pn`, en kW).
+ * @param E {number} [Coefficient forfaitaire E]
+ * @param F {number} [Coefficient forfaitaire F]
+ * @returns {number}
+ */
+export function evaluateFormula(formulaOrValue, pn, E, F) {
+  const formula =
+    typeof formulaOrValue === 'string'
+      ? formulaOrValue.replace(/(\d),(\d)/g, '$1.$2')
+      : formulaOrValue;
+
+  if (!isNaN(formula)) {
+    return Number(formula);
+  }
+
+  const Pn = pn / 1000;
+  return compileFormula(formula)({ Pn, logPn: Math.log10(Pn), E, F });
+}

package/formula.spec.js

@@ -0,0 +1,99 @@
+import { describe, expect, test } from 'vitest';
+import { compileFormula, evaluateFormula } from './formula.js';
+
+describe('formula', () => {
+  describe('evaluateFormula', () => {
+    test.each([
+      [42, 42],
+      ['42', 42],
+      ['0.5', 0.5],
+      ['12,5', 12.5]
+    ])('retourne la valeur numérique telle quelle : %s → %s', (input, expected) => {
+      expect(evaluateFormula(input, 24000)).toBe(expected);
+    });
+
+    test('expose Pn en kW à partir de pn en W', () => {
+      expect(evaluateFormula('Pn', 24000)).toBe(24);
+    });
+
+    test('expose logPn = log10(Pn)', () => {
+      expect(evaluateFormula('logPn', 100000)).toBeCloseTo(2, 10);
+    });
+
+    test('expose les coefficients E et F', () => {
+      expect(evaluateFormula('E + F * logPn', 100000, 3, 1.5)).toBeCloseTo(6, 10);
+    });
+
+    test('accepte la virgule comme séparateur décimal', () => {
+      expect(evaluateFormula('0,085 * Pn', 10000)).toBeCloseTo(0.85, 10);
+      expect(evaluateFormula('84,5 + 2 logPn', 100000)).toBeCloseTo(88.5, 10);
+    });
+
+    test('évalue des formules représentatives des tables de valeurs', () => {
+      // rendement à pleine charge d'une chaudière : 84 + 2 logPn
+      expect(evaluateFormula('84 + 2 logPn', 100000)).toBeCloseTo(88, 10);
+      // pertes à l'arrêt : exposant négatif signé
+      expect(evaluateFormula('2.5 * (Pn)^-0.4', 32000)).toBeCloseTo(2.5 * 32 ** -0.4, 10);
+      // pourcentage
+      expect(evaluateFormula('0.6% * Pn', 50000)).toBeCloseTo(0.3, 10);
+    });
+  });
+
+  describe('compileFormula', () => {
+    const evaluate = (formula, scope = {}) => compileFormula(formula)(scope);
+
+    test.each([
+      ['2 + 3 * 4', 14],
+      ['(2 + 3) * 4', 20],
+      ['10 / 4', 2.5],
+      ['8 - 3 - 2', 3],
+      ['16 / 4 / 2', 2],
+      ['2^3^2', 512],
+      ['-2^2', -4],
+      ['2^-1', 0.5],
+      ['-(3 - 5)', 2],
+      ['+3', 3],
+      ['--3', 3],
+      ['log10(1000)', 3],
+      ['log10(10 * 10)', 2],
+      ['2(3 + 1)', 8],
+      ['2 log10(100)', 4],
+      ['0.6%', 0.006],
+      ['50 %', 0.5],
+      ['0,5 + 1', 1.5],
+      ['  1 +\t2\n', 3]
+    ])('%s → %s', (formula, expected) => {
+      expect(evaluate(formula)).toBeCloseTo(expected, 10);
+    });
+
+    test('lit les variables dans le scope', () => {
+      const scope = { Pn: 20, logPn: Math.log10(20), E: 2, F: 3 };
+      expect(evaluate('Pn', scope)).toBe(20);
+      expect(evaluate('E F', scope)).toBe(6);
+      expect(evaluate('E + F Pn', scope)).toBe(62);
+      expect(evaluate('logPn', scope)).toBeCloseTo(Math.log10(20), 10);
+    });
+
+    test('met en cache la formule compilée', () => {
+      const first = compileFormula('Pn * 2 + 1');
+      expect(compileFormula('Pn * 2 + 1')).toBe(first);
+      expect(first({ Pn: 3 })).toBe(7);
+      expect(first({ Pn: 5 })).toBe(11);
+    });
+
+    test.each([
+      ['2 $ 3', /caractère inattendu `\$`/],
+      ['foo + 1', /variable inconnue `foo`/],
+      ['sqrt(4)', /fonction inconnue `sqrt`/],
+      ['(2 + 3', /`\)` attendu/],
+      ['log10(2', /`\)` attendu/],
+      ['2 +', /formule incomplète/],
+      ['', /formule incomplète/],
+      ['2 )', /fin de formule inattendue/],
+      ['* 2', /jeton inattendu `\*`/]
+    ])('rejette la formule invalide `%s`', (formula, message) => {
+      expect(() => compileFormula(formula)).toThrow(SyntaxError);
+      expect(() => compileFormula(formula)).toThrow(message);
+    });
+  });
+});