@open3cl/engine 1.7.1 → 1.7.2

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);
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {
@@ -42,11 +42,8 @@
   "dependencies": {
     "dioma": "^0.4.6",
     "fast-xml-parser": "^5.11.1",
-    "http-server": "^14.1.1",
     "lodash-es": "^4.18.1",
-    "mathjs": "^15.2.0",
-    "winston": "^3.19.0",
-    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
+    "winston": "^3.19.0"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.1013.0",
@@ -71,13 +68,15 @@
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-promise": "^6.1.1",
     "fast-csv": "^5.0.2",
+    "http-server": "^14.1.1",
     "husky": "^9.0.11",
     "jscpd": "^3.5.10",
     "piscina": "^5.1.2",
     "prettier": "^3.2.5",
     "pretty-quick": "^4.0.0",
     "semantic-release": "^25.0.2",
-    "vitest": "3.2.7"
+    "vitest": "3.2.7",
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
   },
   "author": "Open3Cl",
   "license": "GPL-3.0",