@mostajs/ro-pla 0.2.2 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -1,5 +1,86 @@
1
1
  # CHANGELOG
2
2
 
3
+ ## [0.3.0] — 2026-11-15
4
+
5
+ ### Corrigé — la famille seule ne suffisait pas à choisir le dialecte
6
+
7
+ Dans sept familles sur douze, plusieurs dialectes partagent un `kind` sans résoudre un problème de
8
+ même forme. `solve({kind})` retenait toujours le premier exact enregistré : onze dialectes étaient
9
+ inatteignables sans être nommés, et la plupart des formes « étrangères » plantaient. **Deux rendaient
10
+ une réponse fausse et muette** : une forme `forecast` servie par `monte-carlo` (moyenne 0, variance
11
+ 0) et une forme `bin-packing` ou `list-scheduling` servie par `critical-path` (durée 0, chemin
12
+ critique vide).
13
+
14
+ Désormais chaque dialecte déclare sa **forme** (`shape` : champs obligatoires, contrôle
15
+ complémentaire facultatif) et `solve` sans dialecte nommé ne garde que les dialectes dont la forme
16
+ correspond. Appels qui **changent de comportement** :
17
+
18
+ | appel sans dialecte nommé | 0.2.2 | 0.3.0 |
19
+ |---|---|---|
20
+ | `flow`, forme `shortest-path` ou `max-flow` | plantage dans `min-cost-flow` | le bon dialecte |
21
+ | `assignment`, forme `matching` ou `stable-matching` | plantage dans `hungarian` | le bon dialecte |
22
+ | `milp`, forme `knapsack` | plantage dans `branch-and-bound` | `knapsack` |
23
+ | `lp`, forme `lagrangian` | plantage dans `simplex` | `lagrangian` |
24
+ | `metaheuristic`, forme `tabu` ou `genetic` | plantage dans `anneal` | le bon dialecte |
25
+ | `simulation`, forme `forecast` | **réponse fausse** de `monte-carlo` | `forecast` |
26
+ | `scheduling`, forme `bin-packing` ou `list-scheduling` | **réponse fausse** de `critical-path` | le bon dialecte |
27
+ | problème sans `kind` | plantage dans `hungarian` | erreur `RO_PLA_NO_KIND` |
28
+ | forme inconnue de la famille | plantage | erreur `RO_PLA_NO_SHAPE` (candidats, champs attendus) |
29
+ | forme ambiguë (ex. arêtes à `weight` ET `capacity`, avec `sink`) | plantage ou réponse au hasard | erreur `RO_PLA_AMBIGUOUS_SHAPE` |
30
+
31
+ **Aucun appel qui fonctionnait ne change de dialecte** : la forme historique de chaque famille va
32
+ au dialecte historique. Un dialecte **nommé** est servi comme avant, sans contrôle de forme. Un
33
+ dialecte tiers sans forme déclarée est réputé accepter toute sa famille.
34
+
35
+ ### Corrigé — le tri de sélection fait ce que son commentaire annonce
36
+
37
+ Il ne triait que sur l'exactitude. Ordre codé et écrit : forme acceptée ; exact d'abord ; plus petite
38
+ `maxSize` qui couvre la taille mesurée ; bornes « à établir » ; bornes dépassées ; ordre
39
+ d'enregistrement. Aucun choix d'aujourd'hui ne change (aucune famille intégrée n'a deux exacts de
40
+ même forme). La fonction de tri reste interne et n'est pas exportée.
41
+
42
+ ### Corrigé — `mmc`
43
+
44
+ - λ = 0 : attente moyenne 0, et non `NaN`.
45
+ - Nombre de serveurs non entier : refusé (`RangeError`), au lieu de métriques sans avertissement.
46
+ - `solve` sans `c` ni `target` : évalue toujours c = 1, mais le dit dans `solvedBy.notes`.
47
+
48
+ ### Ajouté
49
+
50
+ - **`solvedBy`** sur le résultat de `solve` (dialecte nommé ou non), un seul champ :
51
+ `{ dialect, kind, exact, online, reason, criterion, size, maxSize, beyondDeclaredSize, notes }`.
52
+ Le résultat est une copie ; la solution du dialecte n'est pas modifiée. Un dialecte synchrone
53
+ reste synchrone. **Les fonctions directes (`hungarian`, `simplex`, `mmc`…) ne changent pas.**
54
+ Une solution produite avant la 0.3.0 et rejouée depuis une mémoire n'a pas ce champ.
55
+ - **`beyondDeclaredSize`** : vrai, faux, ou `null` (« à établir »). Mesure de taille déclarée par
56
+ `hungarian` (ordre de la matrice), `simplex` (variables), `branch-and-bound` (variables entières),
57
+ `markov` (états) ; « à établir » pour `min-cost-flow` et `mdp`. Rien n'est refusé : simplex à 600
58
+ variables reste `optimal`, et le dit.
59
+ - **`checkSize(dialecte | nom, problème)`** : taille, borne, dépassement, sans résoudre.
60
+ - **`maxSize: null`** explicite sur les 17 dialectes sans borne ; le type admet `null`.
61
+ - **`acceptsShape`**, **`SolverSelectionError`** (champ `code`), types `ProblemShape`, `SolvedBy`,
62
+ `SolvedByReason`, `SolvedByCriterion`, `SizeCheck` ; contrat `shape`, `size`, `sizeUnit`, `notes`.
63
+ - **`LICENSE`** (AGPL-3.0-or-later) : cité dans `files`, il manquait au paquet.
64
+ - Tables de dialectes du README et de `llms.txt` **engendrées depuis le registre**, et comparées à
65
+ lui par un essai.
66
+ - Essai du **paquet packé** : installé dans un projet vierge, importé en Node brut sans chargeur,
67
+ exports égaux au barrel, aucun import relatif sans `.js`, `LICENSE` présent.
68
+
69
+ ### Modifié
70
+
71
+ - `tsconfig` : `module` et `moduleResolution` en `NodeNext`. Le compilateur refuse désormais tout
72
+ import relatif sans extension. `dist/` émis identique à l'octet.
73
+ - `llms.txt` : version juste, `pickBest` retiré (il n'a jamais été exporté), sélection par forme,
74
+ `solvedBy`, condition `import` seule, feuille de route périmée retirée.
75
+
76
+ ### Non fait, et dit
77
+
78
+ - **Les bornes `maxSize` ne sont pas mesurées** : la 0.3.0 les rend opposables, elle ne les valide pas.
79
+ - **Erlang C n'est pas confrontée à une table publiée.** L'essai sourcé existe et se déclare EN
80
+ ATTENTE tant que la source manque ; la formule est vérifiée par la récurrence d'Erlang B et la loi
81
+ de Little (cohérence interne, pas conformité).
82
+ - Mesure de taille de `min-cost-flow` et `mdp` : à établir.
83
+
3
84
  ## [0.2.2] — 2026-09-06
4
85
 
5
86
  ### Corrigé — `llms.txt`, qui est PUBLIÉ, annonçait 11 dialectes et la version 0.1.0
@@ -22,15 +103,10 @@ Corrigé, et deux avertissements ajoutés pour le lecteur-machine :
22
103
  - **`solve({kind})` ne dit pas quel dialecte a été retenu** — pour savoir si un résultat est prouvé,
23
104
  il faut lire `getSolver(nom).capabilities.exact`.
24
105
 
25
- ### Ajouté — les 13 livrables §9 manquants (4 → 17)
106
+ ### Nommé — quatre défauts, renvoyés à la 0.3.0
26
107
 
27
- `#1` état de l'art · `#2` audit · `#3` plan de développement · `#3.bis` image OBJECTIF · `#5` plan de
28
- suivi · `#8` SEO et article · `#9` plan de publication · `#10` présentation · `#11` diapositives
29
- commerciales · `#12` documentation technique · `#13` diapositives développement · `#14` image
30
- RÉSULTAT · `#15` revue de sécurité · `#16` DPIA. Rendus PDF et PPTX par `@mostajs/doc-export`.
31
-
32
- **Aucune ligne de code du module n'a été modifiée.** Ce lot NOMME et MESURE quatre défauts, il ne les
33
- corrige pas — ils entrent au jalon 0.3.0, et rien ne sera codé avant validation.
108
+ **Aucune ligne de code du module n'a été modifiée.** Quatre défauts ont été nommés et mesurés, sans
109
+ être corrigés — ils entrent au jalon 0.3.0.
34
110
 
35
111
  - **A — `maxSize` déclarée, jamais appliquée.** Mesuré : `simplex` déclare 200 et rend `optimal` à
36
112
  200, 300 et 600 variables, avec les mêmes champs, sans un mot. Le danger n'est pas le plantage,
@@ -39,27 +115,15 @@ corrige pas — ils entrent au jalon 0.3.0, et rien ne sera codé avant validati
39
115
  plus petit `maxSize` couvrant » ; le code ne trie que sur `exact`. Sans conséquence aujourd'hui,
40
116
  faux dès le premier `kind` servi par deux dialectes exacts de bornes différentes.
41
117
  - **C — la sélection ne rend pas son motif.** `solve({kind})` ne dit pas quel dialecte a produit le
42
- résultat. Ce n'est pas qu'un défaut d'ergonomie : le port modeleur d'`assistant-pilote` ne peut
43
- déclarer ni `probleme` ni `explication` sur ce module, et c'est aussi une pièce de conformité —
44
- face à « pourquoi moi », l'appelant ne peut pas nommer l'algorithme employé.
45
- - **D — `00-CATALOGUE-ALGOS.md` se disait « source unique de vérité » et donnait 4 dialectes sur 23.**
46
- Vérifié une fois le 13/06, cru trois mois sur la foi de son titre. Sa §1 est désormais engendrée
47
- depuis `listSolvers()`, et le poste 5 du jalon 0.3.0 la fera engendrer automatiquement.
48
-
49
- ### Suspendu — la diffusion de l'article #17
50
-
51
- `docs/articles/17bis-VERIFICATION-SOURCES.md` établit, source par source, ce qui est vérifié. Bilan :
52
- **deux références internes fausses sur trois** — « les 11 dialectes » et un chemin qui pointe vers
53
- `mosta-ro-pla/docs/` alors que le fichier est dans `mosta-ro-pla-eca/docs/` — et **aucune référence
54
- externe vérifiée**, dont un nom d'auteur douteux et onze outils nommés sans qu'aucun n'ait été
55
- essayé.
56
-
57
- ⚠️ Le plus grave n'est pas la bibliographie : **la formule d'Erlang C du dialecte `mmc` n'a jamais
58
- été confrontée à une source externe.** Les essais vérifient sa cohérence interne, pas sa conformité
59
- à la théorie. Un article qui enseigne le dimensionnement de guichets sur une formule non validée fait
60
- plus de dégâts qu'une bibliographie approximative — le lecteur applique le résultat.
61
- `ARTICLE-SEO-RO-PLA.md` peut être diffusé : il ne cite aucune source externe et ne s'appuie que sur
62
- des mesures reproductibles.
118
+ résultat. Ce n'est pas qu'un défaut d'ergonomie : c'est aussi une pièce de conformité — face à
119
+ « pourquoi moi », l'appelant ne peut pas nommer l'algorithme employé.
120
+ - **D — le catalogue des algorithmes se disait « source unique de vérité » et donnait 4 dialectes
121
+ sur 23.** Recopié à la main, il s'était périmé sans bruit ; la 0.3.0 le fait engendrer.
122
+
123
+ ### Signalé — Erlang C
124
+
125
+ ⚠️ **La formule d'Erlang C du dialecte `mmc` n'a jamais été confrontée à une source externe.** Les
126
+ essais vérifient sa cohérence interne, pas sa conformité à la théorie.
63
127
 
64
128
  ## [0.2.1] — 2026-09-06
65
129
 
@@ -106,9 +170,6 @@ Dantzig-Wolfe, Benders, PSO, ACO, GRASP, NSGA-II en propre, réseaux de neurones
106
170
  événements discrets, contraintes cumulative, dualité/sensibilité. Tous annoncés dans la feuille de
107
171
  route d'origine, aucun présent. Un module qui laisse croire coûte plus cher qu'un module qui manque.
108
172
 
109
- L'état des livrables DEVRULES §9 y est dit sans arrangement : **4 présents sur 17**, et l'article
110
- existant attend une vérification de ses sources avant diffusion.
111
-
112
173
  > Le paquet npm n'embarque ni `examples/` ni les sources : `files` reste limité à `dist/`.
113
174
 
114
175
  ## [0.2.0] — 2026-08-09
@@ -146,5 +207,5 @@ graine égale** — sans quoi `@mostajs/skill-library` ne pourrait juger aucune
146
207
  courte : l'appelant croyait tenir une prévision saisonnière. Refus motivé si la méthode est
147
208
  demandée explicitement, `note` explicite en mode automatique.
148
209
 
149
- 108 tests verts. Plan Dev+Test dans qatrax : 24 exigences, 24 réalisations, 49 tests.
210
+ 108 tests verts.
150
211
 
package/LICENSE ADDED
@@ -0,0 +1,21 @@
1
+ @mostajs/ro-pla
2
+ Copyright (C) 2026 Dr Hamid MADANI <drmdh@msn.com>
3
+
4
+ SPDX-License-Identifier: AGPL-3.0-or-later
5
+
6
+ This program is free software: you can redistribute it and/or modify
7
+ it under the terms of the GNU Affero General Public License as published by
8
+ the Free Software Foundation, either version 3 of the License, or
9
+ (at your option) any later version.
10
+
11
+ This program is distributed in the hope that it will be useful,
12
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
13
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
+ GNU Affero General Public License for more details.
15
+
16
+ You should have received a copy of the GNU Affero General Public License
17
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
18
+
19
+ The complete text of the GNU Affero General Public License version 3 is
20
+ available at the URL above and must accompany any distribution of this
21
+ software.
package/README.md CHANGED
@@ -1,31 +1,40 @@
1
1
  # @mostajs/ro-pla
2
2
 
3
3
  **Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
4
- **Statut** : **0.2.1** — 23 dialectes, 111 essais verts, `examples/` exécutables.
4
+ **Statut** : **0.3.0** — 23 dialectes, sélection par forme, `solvedBy`, `examples/` exécutables.
5
5
 
6
6
  **Programmation linéaire & recherche opérationnelle** pour l'écosystème `@mostajs/*`. Une question
7
- métier se pose à un **registre**, qui choisit le dialecte : on nomme une **famille** de problèmes,
8
- jamais un algorithme.
7
+ métier se pose à un **registre**, qui choisit le dialecte dans la **famille** du problème (`kind`),
8
+ d'après la **forme** du problème ; ou l'on nomme l'algorithme.
9
9
 
10
10
  ```js
11
- import { solve, getSolver, binPacking } from '@mostajs/ro-pla';
11
+ import { solve, getSolver, checkSize, binPacking } from '@mostajs/ro-pla';
12
12
 
13
- // La question nomme la FAMILLE — le registre choisit l'algorithme.
14
- solve({ kind: 'assignment', cost: [[4, 1], [2, 3]] }); // → hongrois, { total: 3 }
15
- solve({ kind: 'csp', variables: ['X', 'Y'], domains: [[1, 2], [1, 2]],
16
- constraints: [{ type: 'allDifferent', vars: [0, 1] }] }); // → backtracking
13
+ // La question nomme la FAMILLE ; la FORME du problème désigne le dialecte.
14
+ const r = solve({ kind: 'assignment', cost: [[4, 1], [2, 3]] }); // → hongrois, total 3
15
+ r.solvedBy; // { dialect: 'hungarian', kind: 'assignment', exact: true, reason: 'only-shape-match',
16
+ // size: 2, maxSize: 1000, beyondDeclaredSize: false, … }
17
17
 
18
- // Ou l'on appelle un dialecte directement, quand on sait ce qu'on veut.
18
+ solve({ kind: 'flow', edges: [{ from: 'a', to: 'b', weight: 2 }], source: 'a' }); // → shortest-path
19
+
20
+ // Nommer le dialecte reste la voie sûre : aucun contrôle de forme.
21
+ solve(probleme, { dialect: 'max-flow' });
22
+
23
+ // Ou l'on appelle un dialecte directement (sans `solvedBy`, forme inchangée).
19
24
  binPacking({ kind: 'scheduling', items, bins, strategy: 'both' });
20
25
 
21
- // Les capacités d'un dialecte se LISENT avant de s'en servir.
22
- getSolver('hungarian').capabilities; // { exact: true, online: true, maxSize: 1000 }
26
+ // Les capacités et la borne se LISENT avant de s'en servir.
27
+ getSolver('hungarian').capabilities; // { exact: true, online: true, maxSize: 1000 }
28
+ checkSize('simplex', { kind: 'lp', c, A, b }); // { size, maxSize: 200, beyondDeclaredSize }
23
29
  ```
24
30
 
25
31
  ## Les 23 dialectes, par famille
26
32
 
27
- `~` marque un dialecte **approché** : il ne prétend pas à l'optimum, et rend de quoi juger sur
28
- pièces (borne inférieure, écart, cause d'échec). **15 exacts, 8 approchés.**
33
+ Table engendrée depuis le registre (`node scripts/catalogue.mjs --write`) ; un essai échoue si elle
34
+ diverge du code.
35
+
36
+ <!-- engendre:familles:debut -->
37
+ **23 dialectes, 12 familles : 15 exacts, 8 approchés.** `~` marque un dialecte approché.
29
38
 
30
39
  | `kind` | dialectes |
31
40
  |---|---|
@@ -33,14 +42,33 @@ pièces (borne inférieure, écart, cause d'échec). **15 exacts, 8 approchés.*
33
42
  | `lp` | simplex · lagrangian `~` |
34
43
  | `milp` | branch-and-bound · knapsack |
35
44
  | `flow` | min-cost-flow · shortest-path · max-flow |
45
+ | `queue` | mmc |
46
+ | `markov` | markov |
47
+ | `decision` | mdp |
36
48
  | `csp` | backtrack-csp |
37
- | `scheduling` | critical-path · bin-packing `~` · list-scheduling `~` |
38
- | `queue` | mmc (files M/M/c, formules d'Erlang, dimensionnement) |
39
- | `markov` | markov (stationnaire, régime transitoire, absorption) |
40
- | `decision` | mdp (itération de la valeur) |
41
49
  | `metaheuristic` | anneal `~` · tabu `~` · genetic `~` |
42
- | `multiobjective` | pareto (fronts, rangs, tri par non-domination façon NSGA-II — **exact** : il énumère le front, il ne le devine pas) |
43
50
  | `simulation` | monte-carlo `~` · forecast `~` |
51
+ | `scheduling` | critical-path · bin-packing `~` · list-scheduling `~` |
52
+ | `multiobjective` | pareto |
53
+ <!-- engendre:familles:fin -->
54
+
55
+ ## Sélection : famille, puis forme (0.3.0)
56
+
57
+ - Sans dialecte nommé, `solve` garde dans la famille les dialectes dont la **forme** correspond :
58
+ chacun déclare ses champs obligatoires (`shape.fields`) et parfois un contrôle complémentaire
59
+ (arêtes à `weight` → `shortest-path`, à `capacity` → `max-flow`).
60
+ - Plusieurs candidats : **exact** d'abord, puis la plus petite borne qui **couvre** la taille, puis
61
+ les bornes « à établir », puis les bornes dépassées ; l'ordre d'enregistrement départage.
62
+ - Aucune forme reconnue, forme ambiguë, problème sans `kind` : **erreur explicite**
63
+ (`SolverSelectionError`, champ `code`), qui nomme les candidats et les champs attendus. En 0.2.x,
64
+ ces appels plantaient — ou rendaient une réponse fausse sans le dire.
65
+ - `solvedBy` dit **qui** a répondu et **pourquoi** (`reason`, `criterion`). Il peut manquer sur une
66
+ solution produite avant la 0.3.0 et rejouée depuis une mémoire.
67
+ - **Les bornes `maxSize` ne sont pas mesurées.** Elles sont déclaratives : un problème au-delà est
68
+ résolu quand même, et `solvedBy.beyondDeclaredSize` le dit. `null` = « à établir ».
69
+ - **Erlang C (`mmc`) n'est pas encore confrontée à une table publiée** : elle est vérifiée par la
70
+ récurrence d'Erlang B et la loi de Little, ce qui établit sa cohérence, pas sa conformité.
71
+ - Paquet ESM seul (condition `import`).
44
72
 
45
73
  ## Ce que ce module ne fait PAS
46
74
 
@@ -66,22 +94,15 @@ optimise l'objectif ? », « quel est l'état stationnaire ? ». Responsabilité
66
94
 
67
95
  ```bash
68
96
  npm run build # tsc → dist/ (non versionné)
69
- npm test # 111 essais sur 17 fichiers, via @mostajs/mjs-unit
97
+ npm test # suite @mostajs/mjs-unit, dont le paquet packé chargé en Node brut
70
98
  npm run report # preuve HTML
71
99
  npm run examples # 24 exemples exécutables
100
+ node scripts/catalogue.mjs --write # réengendre les tables de dialectes
72
101
  ```
73
102
 
74
103
  `examples/` est groupé par métier — restaurant, université, réseau, métaheuristiques — et chaque
75
- exemple **se vérifie lui-même** : il se termine par des assertions qui échouent bruyamment. Ce n'est
76
- pas de la décoration : les deux derniers défauts de `bin-packing` sont sortis de l'écriture d'un
77
- exemple, pas d'une relecture. Le test qui existait prouvait qu'une restriction `allowedBins` était
78
- *respectée* — jamais qu'elle était servie **en concurrence**, et c'est par là que le défaut passait.
79
-
80
- ## Livrables (DEVRULES §9)
104
+ exemple **se vérifie lui-même** : il se termine par des assertions qui échouent bruyamment.
81
105
 
82
- **Présents** : `docs/00-CATALOGUE-ALGOS.md`, `docs/03-PLAN-DEV-DIALECTES-LOT-2.md`,
83
- `docs/DEVTEST-PLAN.ro-pla.json` (#4), `docs/articles/17-ARTICLE-ALGOS-RO-FILE-ATTENTE.md` (#17).
106
+ ## Licence
84
107
 
85
- **Manquants** : les treize autres, dont l'état de l'art (#1) et l'audit (#2). Ce module a été bâti
86
- avant que les 17 livrables ne soient tenus systématiquement ; ils restent à rédiger, et l'article
87
- existant attend une vérification de ses sources avant diffusion.
108
+ AGPL-3.0-or-later — voir `LICENSE`.
@@ -37,7 +37,8 @@ export function anneal(problem) {
37
37
  export const annealDialect = {
38
38
  name: 'anneal',
39
39
  kind: 'metaheuristic',
40
- capabilities: { exact: false, online: false },
40
+ shape: { fields: ['initial', 'energy', 'neighbor'] },
41
+ capabilities: { exact: false, online: false, maxSize: null },
41
42
  solve(problem) {
42
43
  return anneal(problem);
43
44
  },
@@ -119,8 +119,9 @@ export function binPacking(problem) {
119
119
  export const binPackingDialect = {
120
120
  name: 'bin-packing',
121
121
  kind: 'scheduling',
122
+ shape: { fields: ['items', 'bins'] },
122
123
  // NP-difficile : heuristique assumée. La borne inférieure rendue dit la distance à l'optimum.
123
- capabilities: { exact: false, online: false },
124
+ capabilities: { exact: false, online: false, maxSize: null },
124
125
  solve(problem) {
125
126
  return binPacking(problem);
126
127
  },
@@ -105,7 +105,8 @@ export function criticalPath(problem) {
105
105
  export const criticalPathDialect = {
106
106
  name: 'critical-path',
107
107
  kind: 'scheduling',
108
- capabilities: { exact: true, online: false },
108
+ shape: { fields: ['activities'] },
109
+ capabilities: { exact: true, online: false, maxSize: null },
109
110
  solve(problem) {
110
111
  return criticalPath(problem);
111
112
  },
@@ -39,7 +39,8 @@ export function solveCsp(variables, domains, constraints) {
39
39
  export const cspDialect = {
40
40
  name: 'backtrack-csp',
41
41
  kind: 'csp',
42
- capabilities: { exact: true, online: false },
42
+ shape: { fields: ['variables', 'domains', 'constraints'] },
43
+ capabilities: { exact: true, online: false, maxSize: null },
43
44
  solve(problem) {
44
45
  return solveCsp(problem.variables, problem.domains, problem.constraints);
45
46
  },
@@ -110,7 +110,8 @@ export function forecast(problem) {
110
110
  export const forecastDialect = {
111
111
  name: 'forecast',
112
112
  kind: 'simulation',
113
- capabilities: { exact: false, online: true },
113
+ shape: { fields: ['series', 'horizon'] },
114
+ capabilities: { exact: false, online: true, maxSize: null },
114
115
  solve(problem) { return forecast(problem); },
115
116
  };
116
117
  //# sourceMappingURL=forecast.js.map
@@ -86,7 +86,8 @@ export function genetic(problem) {
86
86
  export const geneticDialect = {
87
87
  name: 'genetic',
88
88
  kind: 'metaheuristic',
89
- capabilities: { exact: false, online: false },
89
+ shape: { fields: ['population', 'fitness', 'crossover', 'mutate'] },
90
+ capabilities: { exact: false, online: false, maxSize: null },
90
91
  solve(problem) { return genetic(problem); },
91
92
  };
92
93
  //# sourceMappingURL=genetic.js.map
@@ -71,7 +71,11 @@ export function hungarian(cost) {
71
71
  export const hungarianDialect = {
72
72
  name: 'hungarian',
73
73
  kind: 'assignment',
74
+ shape: { fields: ['cost'] },
74
75
  capabilities: { exact: true, online: true, maxSize: 1000 },
76
+ // Taille : ordre de la matrice des coûts (unité de `maxSize`).
77
+ size: (p) => (Array.isArray(p?.cost) ? p.cost.length : null),
78
+ sizeUnit: "ordre de la matrice des coûts",
75
79
  solve(problem) {
76
80
  return hungarian(problem.cost);
77
81
  },
@@ -95,9 +95,10 @@ export function knapsack(problem) {
95
95
  export const knapsackDialect = {
96
96
  name: 'knapsack',
97
97
  kind: 'milp',
98
+ shape: { fields: ['items', 'capacity'] },
98
99
  // EXACT : la programmation dynamique rend l'optimum, contrairement à toute heuristique de
99
100
  // remplissage. Le prix est la mémoire, gardée par `maxCells`.
100
- capabilities: { exact: true, online: false },
101
+ capabilities: { exact: true, online: false, maxSize: null },
101
102
  solve(problem) { return knapsack(problem); },
102
103
  };
103
104
  //# sourceMappingURL=knapsack.js.map
@@ -43,7 +43,8 @@ export function lagrangian(problem) {
43
43
  export const lagrangianDialect = {
44
44
  name: 'lagrangian',
45
45
  kind: 'lp',
46
- capabilities: { exact: false, online: false },
46
+ shape: { fields: ['c', 'linkingA', 'linkingB', 'subA', 'subB'] },
47
+ capabilities: { exact: false, online: false, maxSize: null },
47
48
  solve(problem) {
48
49
  return lagrangian(problem);
49
50
  },
@@ -143,7 +143,8 @@ export function listScheduling(problem) {
143
143
  export const listSchedulingDialect = {
144
144
  name: 'list-scheduling',
145
145
  kind: 'scheduling',
146
- capabilities: { exact: false, online: false },
146
+ shape: { fields: ['tasks', 'capacities'] },
147
+ capabilities: { exact: false, online: false, maxSize: null },
147
148
  solve(problem) {
148
149
  return listScheduling(problem);
149
150
  },
@@ -111,7 +111,11 @@ export function markovAbsorbing(P) {
111
111
  export const markovDialect = {
112
112
  name: 'markov',
113
113
  kind: 'markov',
114
+ shape: { fields: ['P'] },
114
115
  capabilities: { exact: true, online: true, maxSize: 500 },
116
+ // Taille : nombre d'états (unité de `maxSize`).
117
+ size: (p) => (Array.isArray(p?.P) ? p.P.length : null),
118
+ sizeUnit: "nombre d'états",
115
119
  solve(problem) {
116
120
  const P = problem.P;
117
121
  const query = problem.query ?? 'stationary';
@@ -142,8 +142,9 @@ export function matching(problem) {
142
142
  export const matchingDialect = {
143
143
  name: 'matching',
144
144
  kind: 'assignment',
145
+ shape: { fields: ['edges'], test: (p) => Array.isArray(p.edges) && p.edges.every((e) => Array.isArray(e) || (e != null && 'a' in e && 'b' in e)), testLabel: 'arêtes non orientées [a, b] ou { a, b }' },
145
146
  // EXACT : Blossom rend un couplage de cardinalité MAXIMALE, y compris sur cycles impairs.
146
- capabilities: { exact: true, online: false },
147
+ capabilities: { exact: true, online: false, maxSize: null },
147
148
  solve(problem) { return matching(problem); },
148
149
  };
149
150
  //# sourceMappingURL=matching.js.map
@@ -98,7 +98,8 @@ export function maxFlow(problem) {
98
98
  export const maxFlowDialect = {
99
99
  name: 'max-flow',
100
100
  kind: 'flow',
101
- capabilities: { exact: true, online: false },
101
+ shape: { fields: ['edges', 'source', 'sink'], test: (p) => Array.isArray(p.edges) && p.edges.every((e) => e != null && typeof e.capacity === 'number'), testLabel: 'chaque arête porte une `capacity` numérique' },
102
+ capabilities: { exact: true, online: false, maxSize: null },
102
103
  solve(problem) { return maxFlow(problem); },
103
104
  };
104
105
  //# sourceMappingURL=max-flow.js.map
@@ -51,7 +51,10 @@ export function valueIteration(transition, reward, gamma, epsilon = 1e-9, maxIte
51
51
  export const mdpDialect = {
52
52
  name: 'mdp',
53
53
  kind: 'decision',
54
+ shape: { fields: ['transition', 'reward', 'gamma'] },
54
55
  capabilities: { exact: true, online: false, maxSize: 10000 },
56
+ // Mesure de taille « à établir » (états, ou états × actions ?) : la borne reste déclarée, son
57
+ // dépassement n'est pas jugé tant que l'unité n'est pas fixée.
55
58
  solve(problem) {
56
59
  return valueIteration(problem.transition, problem.reward, problem.gamma, problem.epsilon, problem.maxIter);
57
60
  },
@@ -86,7 +86,11 @@ export function branchAndBound(problem, opts) {
86
86
  export const milpDialect = {
87
87
  name: 'branch-and-bound',
88
88
  kind: 'milp',
89
+ shape: { fields: ['c', 'A', 'b'] },
89
90
  capabilities: { exact: true, online: false, maxSize: 50 },
91
+ // Taille : nombre de variables ENTIÈRES (défaut : toutes), unité de `maxSize`.
92
+ size: (p) => (Array.isArray(p?.integers) ? p.integers.length : Array.isArray(p?.c) ? p.c.length : null),
93
+ sizeUnit: "nombre de variables entières",
90
94
  solve(problem, opts) {
91
95
  return branchAndBound(problem, opts);
92
96
  },
@@ -86,7 +86,10 @@ export function minCostFlow(problem) {
86
86
  export const minCostFlowDialect = {
87
87
  name: 'min-cost-flow',
88
88
  kind: 'flow',
89
+ shape: { fields: ['arcs', 'source', 'sink'] },
89
90
  capabilities: { exact: true, online: true, maxSize: 5000 },
91
+ // Mesure de taille « à établir » (nœuds ou arcs ?) : la borne reste déclarée, son dépassement
92
+ // n'est pas jugé tant que l'unité n'est pas fixée.
90
93
  solve(problem) {
91
94
  return minCostFlow(problem);
92
95
  },
@@ -9,6 +9,11 @@
9
9
  */
10
10
  /** Métriques M/M/c pour λ, μ et c serveurs (formules d'Erlang). */
11
11
  export function mmc(lambda, mu, c) {
12
+ // Un nombre de serveurs non entier n'a pas de sens pour M/M/c : refus explicite (0.3.0),
13
+ // au lieu de métriques calculées sans avertissement.
14
+ if (!Number.isInteger(c)) {
15
+ throw new RangeError(`mmc : le nombre de serveurs c doit être un entier (reçu ${c}).`);
16
+ }
12
17
  const offered = lambda / mu; // a = λ/μ (Erlangs)
13
18
  const rho = offered / c; // taux d'occupation
14
19
  const base = { c, offered, rho };
@@ -27,7 +32,8 @@ export function mmc(lambda, mu, c) {
27
32
  const p0 = 1 / (sum + erlangCnum);
28
33
  const probWait = erlangCnum * p0; // C(c, a) = P(attente)
29
34
  const avgQueue = (probWait * rho) / (1 - rho); // Lq
30
- const avgWait = avgQueue / lambda; // Wq
35
+ // Wq = Lq / λ ; sans arrivée (λ = 0), personne n'attend : 0, et non 0/0 = NaN (0.3.0).
36
+ const avgWait = lambda > 0 ? avgQueue / lambda : 0; // Wq
31
37
  const avgSystem = avgQueue + offered; // L
32
38
  const avgTime = avgWait + 1 / mu; // W
33
39
  return { ...base, stable: true, probWait, avgQueue, avgWait, avgSystem, avgTime };
@@ -52,7 +58,13 @@ export function mmcSizing(lambda, mu, target) {
52
58
  export const mmcDialect = {
53
59
  name: 'mmc',
54
60
  kind: 'queue',
55
- capabilities: { exact: true, online: true },
61
+ shape: { fields: ['lambda', 'mu'] },
62
+ capabilities: { exact: true, online: true, maxSize: null },
63
+ notes(problem) {
64
+ return problem?.c == null && !problem?.target
65
+ ? ['mmc : ni `c` ni `target` fournis — évaluation avec c = 1 serveur par défaut.']
66
+ : [];
67
+ },
56
68
  solve(problem) {
57
69
  if (problem.target && problem.c == null)
58
70
  return mmcSizing(problem.lambda, problem.mu, problem.target);
@@ -27,7 +27,8 @@ export function monteCarlo(problem) {
27
27
  export const monteCarloDialect = {
28
28
  name: 'monte-carlo',
29
29
  kind: 'simulation',
30
- capabilities: { exact: false, online: true },
30
+ shape: { fields: ['sample', 'trials'] },
31
+ capabilities: { exact: false, online: true, maxSize: null },
31
32
  solve(problem) {
32
33
  return monteCarlo(problem);
33
34
  },
@@ -119,9 +119,10 @@ export function pareto(problem) {
119
119
  export const paretoDialect = {
120
120
  name: 'pareto',
121
121
  kind: 'multiobjective',
122
+ shape: { fields: ['candidates', 'senses'] },
122
123
  // EXACT : le front de Pareto d'un ensemble FINI de candidats est calculé exactement. Ce n'est
123
124
  // pas le front du problème continu sous-jacent — le dialecte trie ce qu'on lui donne.
124
- capabilities: { exact: true, online: false },
125
+ capabilities: { exact: true, online: false, maxSize: null },
125
126
  solve(problem) {
126
127
  return pareto(problem);
127
128
  },
@@ -141,7 +141,8 @@ export function shortestPath(problem) {
141
141
  export const shortestPathDialect = {
142
142
  name: 'shortest-path',
143
143
  kind: 'flow',
144
- capabilities: { exact: true, online: false },
144
+ shape: { fields: ['edges', 'source'], test: (p) => Array.isArray(p.edges) && p.edges.every((e) => e != null && typeof e.weight === 'number'), testLabel: 'chaque arête porte un `weight` numérique' },
145
+ capabilities: { exact: true, online: false, maxSize: null },
145
146
  solve(problem) { return shortestPath(problem); },
146
147
  };
147
148
  //# sourceMappingURL=shortest-path.js.map
@@ -197,7 +197,11 @@ export function simplex(problem) {
197
197
  export const simplexDialect = {
198
198
  name: 'simplex',
199
199
  kind: 'lp',
200
+ shape: { fields: ['c', 'A', 'b'] },
200
201
  capabilities: { exact: true, online: true, maxSize: 200 },
202
+ // Taille : nombre de variables (unité de `maxSize`, celle que l'audit a mesurée).
203
+ size: (p) => (Array.isArray(p?.c) ? p.c.length : null),
204
+ sizeUnit: "nombre de variables",
201
205
  solve(problem) {
202
206
  return simplex(problem);
203
207
  },
@@ -98,10 +98,11 @@ export function stableMatching(problem) {
98
98
  export const stableMatchingDialect = {
99
99
  name: 'stable-matching',
100
100
  kind: 'assignment',
101
+ shape: { fields: ['proposers', 'receivers', 'preferences'] },
101
102
  // EXACT : Gale-Shapley rend une solution stable, pas une approximation. Mais « stable » n'est
102
103
  // pas « optimal au sens d'un coût » — ce sont deux notions différentes, et c'est pourquoi ce
103
104
  // dialecte ne remplace pas `hungarian` : il répond à une autre question.
104
- capabilities: { exact: true, online: false },
105
+ capabilities: { exact: true, online: false, maxSize: null },
105
106
  solve(problem) {
106
107
  return stableMatching(problem);
107
108
  },
@@ -89,7 +89,8 @@ export function tabuSearch(problem) {
89
89
  export const tabuDialect = {
90
90
  name: 'tabu',
91
91
  kind: 'metaheuristic',
92
- capabilities: { exact: false, online: false },
92
+ shape: { fields: ['initial', 'energy', 'neighbors'] },
93
+ capabilities: { exact: false, online: false, maxSize: null },
93
94
  solve(problem) { return tabuSearch(problem); },
94
95
  };
95
96
  //# sourceMappingURL=tabu.js.map
@@ -2,7 +2,7 @@
2
2
  * @mostajs/ro-pla — Registre de dialectes + sélection (façon ORM)
3
3
  * @author Dr Hamid MADANI <drmdh@msn.com>
4
4
  */
5
- import type { Problem, ProblemKind, SolveOptions, SolverDialect } from './types.js';
5
+ import type { Problem, ProblemKind, SizeCheck, SolveOptions, SolverDialect } from './types.js';
6
6
  /** Enregistre un dialecte de solveur (un par algorithme). */
7
7
  export declare function registerSolver(dialect: SolverDialect<any, any>): void;
8
8
  /** Récupère un dialecte par nom (lève s'il est absent). */
@@ -11,9 +11,24 @@ export declare function getSolver(name: string): SolverDialect<any, any>;
11
11
  export declare function listSolvers(kind?: ProblemKind): SolverDialect<any, any>[];
12
12
  /** Vide le registre (tests). */
13
13
  export declare function clearSolvers(): void;
14
+ /** Erreur de sélection de dialecte, avec un `code` stable lisible par une machine. */
15
+ export declare class SolverSelectionError extends Error {
16
+ readonly code: 'RO_PLA_NO_KIND' | 'RO_PLA_NO_DIALECT' | 'RO_PLA_NO_SHAPE' | 'RO_PLA_AMBIGUOUS_SHAPE';
17
+ constructor(code: SolverSelectionError['code'], message: string);
18
+ }
19
+ /** Le dialecte accepte-t-il la forme du problème ? (sans forme déclarée : oui, toute la famille) */
20
+ export declare function acceptsShape(dialect: SolverDialect<any, any>, problem: unknown): boolean;
14
21
  /**
15
- * Résout un problème : par dialecte nommé, sinon auto-sélection par `kind`
16
- * (analogue à `getDialect()` piloté par `DB_DIALECT` côté ORM).
22
+ * Dit si un problème dépasse la borne déclarée d'un dialecte, sans le résoudre (0.3.0).
23
+ * `beyondDeclaredSize` : vrai, faux, ou `null` (« à établir ») si la borne ou la mesure manque.
24
+ * La borne est déclarative : un dépassement n'empêche jamais `solve` de répondre.
25
+ */
26
+ export declare function checkSize(dialect: string | SolverDialect<any, any>, problem: unknown): SizeCheck;
27
+ /**
28
+ * Résout un problème : par dialecte nommé (sans contrôle de forme), sinon sélection dans la
29
+ * famille `problem.kind` par la forme du problème, puis par l'ordre de `pickBest`.
30
+ * Le résultat est une copie de la solution, plus le champ `solvedBy` (qui a répondu, pourquoi).
31
+ * Un dialecte synchrone reste synchrone ; un dialecte asynchrone reçoit le champ après résolution.
17
32
  */
18
33
  export declare function solve<P extends Problem, S>(problem: P, opts?: SolveOptions & {
19
34
  dialect?: string;
package/dist/registry.js CHANGED
@@ -23,23 +23,163 @@ export function listSolvers(kind) {
23
23
  export function clearSolvers() {
24
24
  registry.clear();
25
25
  }
26
+ /** Erreur de sélection de dialecte, avec un `code` stable lisible par une machine. */
27
+ export class SolverSelectionError extends Error {
28
+ constructor(code, message) {
29
+ super(message);
30
+ this.name = 'SolverSelectionError';
31
+ this.code = code;
32
+ }
33
+ }
34
+ /** Le dialecte accepte-t-il la forme du problème ? (sans forme déclarée : oui, toute la famille) */
35
+ export function acceptsShape(dialect, problem) {
36
+ const shape = dialect.shape;
37
+ if (!shape)
38
+ return true;
39
+ if (problem == null || typeof problem !== 'object')
40
+ return false;
41
+ const p = problem;
42
+ if (!shape.fields.every((f) => p[f] !== undefined))
43
+ return false;
44
+ return shape.test ? Boolean(shape.test(p)) : true;
45
+ }
46
+ const describeShape = (d) => d.shape
47
+ ? `${d.name} { ${d.shape.fields.join(', ')} }${d.shape.testLabel ? ` (${d.shape.testLabel})` : ''}`
48
+ : `${d.name} (forme non déclarée)`;
49
+ /**
50
+ * Garde, dans la famille, les dialectes qui acceptent la forme du problème. Famille d'un seul
51
+ * dialecte : il est retenu tel quel (comportement 0.2.x). Lève, avec un message qui nomme les
52
+ * candidats et les champs attendus, si aucune forme ne correspond ou si plusieurs formes
53
+ * DIFFÉRENTES correspondent (il faut alors nommer le dialecte).
54
+ */
55
+ function candidatesFor(problem) {
56
+ const kind = problem?.kind;
57
+ if (kind == null) {
58
+ throw new SolverSelectionError('RO_PLA_NO_KIND', 'Problème sans `kind` et sans dialecte nommé : indiquez la famille (`kind`) ou nommez le dialecte (`solve(problème, { dialect })`).');
59
+ }
60
+ const family = listSolvers(kind);
61
+ if (family.length === 0) {
62
+ throw new SolverSelectionError('RO_PLA_NO_DIALECT', `Aucun dialecte enregistré pour le type « ${kind} »`);
63
+ }
64
+ if (family.length === 1)
65
+ return family;
66
+ const accepted = family.filter((d) => acceptsShape(d, problem));
67
+ if (accepted.length === 0) {
68
+ throw new SolverSelectionError('RO_PLA_NO_SHAPE', `Aucun dialecte de la famille « ${kind} » ne reconnaît la forme du problème. Candidats et champs attendus : ` +
69
+ family.map(describeShape).join(' ; ') + '.');
70
+ }
71
+ const signatures = new Set(accepted.filter((d) => d.shape).map((d) => [...d.shape.fields].sort().join(',')));
72
+ if (signatures.size > 1) {
73
+ throw new SolverSelectionError('RO_PLA_AMBIGUOUS_SHAPE', `Forme ambiguë dans la famille « ${kind} » : elle correspond à ${accepted.map((d) => d.name).join(', ')}. ` +
74
+ `Nommez le dialecte : solve(problème, { dialect: '${accepted[0].name}' }). Formes : ` +
75
+ accepted.map(describeShape).join(' ; ') + '.');
76
+ }
77
+ return accepted;
78
+ }
79
+ /** Taille mesurée par le dialecte, ou `null` (« à établir ») s'il ne sait pas la mesurer. */
80
+ function measure(dialect, problem) {
81
+ if (!dialect.size)
82
+ return null;
83
+ const n = dialect.size(problem);
84
+ return typeof n === 'number' && Number.isFinite(n) ? n : null;
85
+ }
26
86
  /**
27
- * Choisit le meilleur dialecte pour un `kind` : on préfère l'EXACT, puis le plus
28
- * petit `maxSize` couvrant (heuristique simple, extensible).
87
+ * Dit si un problème dépasse la borne déclarée d'un dialecte, sans le résoudre (0.3.0).
88
+ * `beyondDeclaredSize` : vrai, faux, ou `null` (« à établir ») si la borne ou la mesure manque.
89
+ * La borne est déclarative : un dépassement n'empêche jamais `solve` de répondre.
29
90
  */
30
- function pickBest(kind) {
31
- const candidates = listSolvers(kind);
32
- if (candidates.length === 0) {
33
- throw new Error(`Aucun dialecte enregistré pour le type « ${kind} »`);
91
+ export function checkSize(dialect, problem) {
92
+ const d = typeof dialect === 'string' ? getSolver(dialect) : dialect;
93
+ const maxSize = d.capabilities.maxSize ?? null;
94
+ const size = measure(d, problem);
95
+ return { dialect: d.name, size, maxSize, beyondDeclaredSize: maxSize == null || size == null ? null : size > maxSize };
96
+ }
97
+ /**
98
+ * Palier de taille : 0 = la borne déclarée couvre la taille ; 1 = « à établir » (borne ou taille
99
+ * inconnue) ; 2 = borne dépassée.
100
+ */
101
+ function sizeTier(dialect, problem) {
102
+ const bound = dialect.capabilities.maxSize ?? null;
103
+ const size = measure(dialect, problem);
104
+ if (bound == null || size == null)
105
+ return 1;
106
+ return size <= bound ? 0 : 2;
107
+ }
108
+ function compareDialects(a, b, problem) {
109
+ const ea = Number(Boolean(a.capabilities.exact));
110
+ const eb = Number(Boolean(b.capabilities.exact));
111
+ if (ea !== eb)
112
+ return { cmp: eb - ea, by: 'exact' };
113
+ const ta = sizeTier(a, problem);
114
+ const tb = sizeTier(b, problem);
115
+ if (ta !== tb)
116
+ return { cmp: ta - tb, by: 'size' };
117
+ if (ta === 0) {
118
+ const ba = a.capabilities.maxSize;
119
+ const bb = b.capabilities.maxSize;
120
+ if (ba !== bb)
121
+ return { cmp: ba - bb, by: 'size' };
34
122
  }
35
- return candidates.sort((a, b) => Number(b.capabilities.exact) - Number(a.capabilities.exact))[0];
123
+ return { cmp: 0, by: null };
36
124
  }
37
125
  /**
38
- * Résout un problème : par dialecte nommé, sinon auto-sélection par `kind`
39
- * (analogue à `getDialect()` piloté par `DB_DIALECT` côté ORM).
126
+ * Choisit le meilleur dialecte pour un problème, dans cet ordre :
127
+ * 1. forme acceptée (voir `candidatesFor`) ;
128
+ * 2. EXACT d'abord ;
129
+ * 3. puis la plus petite `maxSize` qui COUVRE la taille mesurée, puis les bornes « à établir »
130
+ * (borne ou mesure inconnue), puis les bornes dépassées ;
131
+ * 4. l'ordre d'enregistrement départage le reste (tri stable).
132
+ */
133
+ function pickBest(problem) {
134
+ const kind = problem?.kind;
135
+ const familySize = kind == null ? 0 : listSolvers(kind).length;
136
+ const candidates = candidatesFor(problem);
137
+ if (candidates.length === 1) {
138
+ return { dialect: candidates[0], reason: familySize === 1 ? 'only-in-kind' : 'only-shape-match', criterion: null };
139
+ }
140
+ const sorted = [...candidates].sort((a, b) => compareDialects(a, b, problem).cmp);
141
+ const decisive = compareDialects(sorted[0], sorted[1], problem).by ?? 'registration-order';
142
+ return { dialect: sorted[0], reason: 'ranked', criterion: decisive };
143
+ }
144
+ function explain(sel, problem) {
145
+ const d = sel.dialect;
146
+ const sc = checkSize(d, problem);
147
+ return {
148
+ dialect: d.name,
149
+ kind: d.kind,
150
+ exact: Boolean(d.capabilities.exact),
151
+ online: Boolean(d.capabilities.online),
152
+ reason: sel.reason,
153
+ criterion: sel.criterion,
154
+ size: sc.size,
155
+ maxSize: sc.maxSize,
156
+ beyondDeclaredSize: sc.beyondDeclaredSize,
157
+ notes: d.notes ? d.notes(problem) : [],
158
+ };
159
+ }
160
+ /** Copie de la solution plus `solvedBy` ; la solution du dialecte n'est pas modifiée en place. */
161
+ function attach(solution, solvedBy) {
162
+ if (solution == null || typeof solution !== 'object')
163
+ return solution;
164
+ if (Array.isArray(solution))
165
+ return Object.assign([...solution], { solvedBy });
166
+ return { ...solution, solvedBy };
167
+ }
168
+ /**
169
+ * Résout un problème : par dialecte nommé (sans contrôle de forme), sinon sélection dans la
170
+ * famille `problem.kind` par la forme du problème, puis par l'ordre de `pickBest`.
171
+ * Le résultat est une copie de la solution, plus le champ `solvedBy` (qui a répondu, pourquoi).
172
+ * Un dialecte synchrone reste synchrone ; un dialecte asynchrone reçoit le champ après résolution.
40
173
  */
41
174
  export function solve(problem, opts) {
42
- const dialect = opts?.dialect ? getSolver(opts.dialect) : pickBest(problem.kind);
43
- return dialect.solve(problem, opts);
175
+ const sel = opts?.dialect
176
+ ? { dialect: getSolver(opts.dialect), reason: 'named', criterion: null }
177
+ : pickBest(problem);
178
+ const out = sel.dialect.solve(problem, opts);
179
+ const solvedBy = explain(sel, problem);
180
+ if (out != null && typeof out.then === 'function') {
181
+ return out.then((s) => attach(s, solvedBy));
182
+ }
183
+ return attach(out, solvedBy);
44
184
  }
45
185
  //# sourceMappingURL=registry.js.map
package/dist/types.d.ts CHANGED
@@ -17,8 +17,12 @@ export interface SolverCapabilities {
17
17
  exact: boolean;
18
18
  /** Utilisable en « réflexe » temps réel (ms) ? */
19
19
  online: boolean;
20
- /** Borne pratique de taille (ex. n d'une matrice). */
21
- maxSize?: number;
20
+ /**
21
+ * Borne pratique de taille, dans l'unité de `SolverDialect.size` (ex. ordre d'une matrice).
22
+ * `null` = « à établir » : déclarée explicitement comme non connue. Absente : traitée de même.
23
+ * Déclarative : jamais mesurée, jamais appliquée ; `solve` signale son dépassement.
24
+ */
25
+ maxSize?: number | null;
22
26
  /** Sait gérer plusieurs objectifs (Pareto) ? */
23
27
  multiObjective?: boolean;
24
28
  }
@@ -31,6 +35,58 @@ export interface SolveOptions {
31
35
  export interface Problem {
32
36
  kind: ProblemKind;
33
37
  }
38
+ /**
39
+ * Forme du problème qu'un dialecte sait résoudre (0.3.0). Dans une famille servie par plusieurs
40
+ * dialectes, `solve` sans dialecte nommé ne retient que ceux dont la forme correspond.
41
+ */
42
+ export interface ProblemShape {
43
+ /** Champs obligatoires qui caractérisent la forme (présents et définis). */
44
+ fields: string[];
45
+ /** Contrôle complémentaire facultatif (ex. nature des arêtes : `weight` ou `capacity`). */
46
+ test?: (problem: any) => boolean;
47
+ /** Ce que `test` vérifie, dit en clair (repris dans les messages d'erreur). */
48
+ testLabel?: string;
49
+ }
50
+ /** Réponse de `checkSize` : taille mesurée, borne déclarée, dépassement. */
51
+ export interface SizeCheck {
52
+ dialect: string;
53
+ size: number | null;
54
+ maxSize: number | null;
55
+ beyondDeclaredSize: boolean | null;
56
+ }
57
+ /** Pourquoi `solve` a retenu ce dialecte. */
58
+ export type SolvedByReason =
59
+ /** nommé par l'appelant (`opts.dialect`) */
60
+ 'named'
61
+ /** seul dialecte de sa famille */
62
+ | 'only-in-kind'
63
+ /** seul de sa famille à accepter la forme du problème */
64
+ | 'only-shape-match'
65
+ /** choisi au tri parmi plusieurs (voir `criterion`) */
66
+ | 'ranked';
67
+ /** Critère décisif du tri, quand `reason` vaut `'ranked'`. */
68
+ export type SolvedByCriterion = 'exact' | 'size' | 'registration-order';
69
+ /**
70
+ * Ce que `solve` ajoute à la solution (0.3.0) : qui a répondu, et pourquoi. Absent d'une
71
+ * solution produite avant la 0.3.0 (rejouée depuis une mémoire, par exemple) : ne pas le supposer.
72
+ */
73
+ export interface SolvedBy {
74
+ dialect: string;
75
+ kind: ProblemKind;
76
+ exact: boolean;
77
+ online: boolean;
78
+ reason: SolvedByReason;
79
+ /** Critère décisif du tri (`reason === 'ranked'`), sinon `null`. */
80
+ criterion: SolvedByCriterion | null;
81
+ /** Taille mesurée par le dialecte (unité de `maxSize`), `null` si « à établir ». */
82
+ size: number | null;
83
+ /** Borne déclarée, `null` si « à établir ». */
84
+ maxSize: number | null;
85
+ /** La taille dépasse-t-elle la borne ? `null` : « à établir » (borne ou mesure manquante). */
86
+ beyondDeclaredSize: boolean | null;
87
+ /** Remarques du dialecte sur ce problème (hypothèse par défaut appliquée, etc.). */
88
+ notes: string[];
89
+ }
34
90
  /** Contrat d'un dialecte de solveur — une implémentation par algorithme. */
35
91
  export interface SolverDialect<P extends Problem = Problem, S = unknown> {
36
92
  /** Nom unique du dialecte (ex. 'hungarian', 'highs', 'mdp'). */
@@ -39,6 +95,20 @@ export interface SolverDialect<P extends Problem = Problem, S = unknown> {
39
95
  kind: ProblemKind;
40
96
  /** Capacités (auto-sélection). */
41
97
  capabilities: SolverCapabilities;
98
+ /**
99
+ * Forme acceptée (0.3.0). Absente : le dialecte est réputé accepter toute sa famille
100
+ * (comportement de la 0.2.x, conservé pour les dialectes tiers).
101
+ */
102
+ shape?: ProblemShape;
103
+ /**
104
+ * Mesure de taille du problème, dans l'unité de `capabilities.maxSize` (0.3.0). Absente, ou
105
+ * rendant `null` : taille « à établir », le dépassement ne peut pas être jugé.
106
+ */
107
+ size?: (problem: any) => number | null;
108
+ /** Ce que mesure `size`, dit en clair (catalogue, messages). */
109
+ sizeUnit?: string;
110
+ /** Remarques sur ce problème, reprises dans `solvedBy.notes` (facultatif). */
111
+ notes?: (problem: any) => string[];
42
112
  /** Résout le problème. */
43
113
  solve(problem: P, opts?: SolveOptions): S | Promise<S>;
44
114
  }
package/llms.txt CHANGED
@@ -1,32 +1,83 @@
1
1
  # @mostajs/ro-pla — fiche LLM
2
2
 
3
- > Programmation linéaire & recherche opérationnelle : 23 dialectes sélectionnés par FAMILLE de
4
- > problème (`kind`), pas par nom d'algorithme. Simplexe, PLNE (branch & bound), flots, CSP, chaînes
5
- > de Markov, MDP, files M/M/c, ordonnancement, Pareto, trois métaheuristiques, prévision.
6
- > API en service depuis la 0.1.0 ; 0.2.1 en production. Zéro dépendance, aucune E/S.
3
+ > Programmation linéaire & recherche opérationnelle : 23 dialectes sous un REGISTRE. Simplexe, PLNE
4
+ > (branch & bound), flots, CSP, chaînes de Markov, MDP, files M/M/c, ordonnancement, Pareto, trois
5
+ > métaheuristiques, prévision. Zéro dépendance, aucune E/S. ESM seul (condition `import`) : pas de
6
+ > chargement CommonJS (require).
7
7
  >
8
- > NE CONTIENT PAS, malgré ce qu'annonçaient les versions antérieures de cette fiche :
9
- > Dantzig-Wolfe, Benders, réseaux de neurones, PSO, ACO, GRASP, NSGA-II en propre (seul son tri par
10
- > non-domination est repris dans `pareto`), simulation à événements discrets, contraintes globales
11
- > cumulative, dualité / analyse de sensibilité.
8
+ > NE CONTIENT PAS : Dantzig-Wolfe, Benders, réseaux de neurones, PSO, ACO, GRASP, NSGA-II en propre
9
+ > (seul son tri par non-domination est repris dans `pareto`), simulation à événements discrets,
10
+ > contraintes globales cumulative, dualité / analyse de sensibilité.
12
11
 
13
- - Version: 0.2.1 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
14
- - Chemin: mostajs/mosta-ro-pla · Statut: 23 dialectes, 12 familles, 15 exacts / 8 approches, 111 essais verts.
15
- - ATTENTION maxSize est DECLARATIVE et n'est PAS appliquee. Six dialectes en portent une (hungarian
16
- 1000, simplex 200, branch-and-bound 50, min-cost-flow 5000, markov 500, mdp 10000) ; un appel
17
- au-dela rend un resultat SANS AVERTISSEMENT (mesure : simplex rend `optimal` a 200, 300 et 600
18
- variables). Les 17 autres n'en declarent aucune, ce qui ne veut dire NI « pas de limite » NI
19
- « limite inconnue ». Ne traitez maxSize que comme une indication d'auteur : jamais mesuree.
20
- - ATTENTION solve({kind}) ne dit PAS quel dialecte a ete retenu. Pour savoir si un resultat est
21
- prouve, lire getSolver(nom).capabilities.exact — le registre ne le rend pas encore (jalon 0.3.0).
22
- - Renommé depuis « mosta-constraints » ; périmètre élargi PL + RO + stochastique.
12
+ - Version: 0.3.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
13
+ - Statut: 23 dialectes, 12 familles, 15 exacts / 8 approches.
14
+
15
+ ## SÉLECTION (0.3.0) — À LIRE AVANT D'APPELER `solve`
16
+ - NOMMER LE DIALECTE RESTE LA VOIE SÛRE : `solve(problème, { dialect: 'shortest-path' })` — aucun
17
+ contrôle de forme, résultat de l'algorithme nommé.
18
+ - Sans dialecte nommé, `solve` choisit dans la famille `problem.kind` PAR LA FORME du problème : chaque
19
+ dialecte déclare `shape.fields` (champs obligatoires) et parfois `shape.test` (ex. arêtes à `weight`
20
+ → shortest-path, à `capacity` → max-flow). `acceptsShape(dialecte, problème)` rend ce verdict.
21
+ - Puis, s'il reste plusieurs candidats : exact d'abord ; plus petite `maxSize` qui couvre la taille ;
22
+ bornes « à établir » ; bornes dépassées ; ordre d'enregistrement.
23
+ - Erreurs explicites, `SolverSelectionError` avec `code` : `RO_PLA_NO_KIND` (ni `kind` ni dialecte),
24
+ `RO_PLA_NO_DIALECT` (famille sans dialecte), `RO_PLA_NO_SHAPE` (aucune forme reconnue ; le message
25
+ nomme famille, candidats et champs attendus), `RO_PLA_AMBIGUOUS_SHAPE` (plusieurs formes : nommer le
26
+ dialecte). En 0.2.x ces cas plantaient — ou, pour `forecast` et `bin-packing`/`list-scheduling`,
27
+ rendaient une réponse fausse sans le dire.
28
+ - Le résultat de `solve` est une COPIE de la solution plus `solvedBy` :
29
+ `{ dialect, kind, exact, online, reason, criterion, size, maxSize, beyondDeclaredSize, notes }`.
30
+ reason ∈ 'named' | 'only-in-kind' | 'only-shape-match' | 'ranked' ; criterion ∈ 'exact' | 'size' |
31
+ 'registration-order' | null. Les fonctions directes (`hungarian`, `simplex`, `mmc`…) ne portent PAS
32
+ `solvedBy` et n'ont pas changé de forme.
33
+ - ATTENTION `solvedBy` peut MANQUER sur une solution produite avant la 0.3.0 et rejouée depuis une
34
+ mémoire (cache de recettes, par exemple) : ne pas en supposer la présence.
35
+ - ATTENTION `maxSize` est DÉCLARATIVE et JAMAIS MESURÉE. Elle n'est pas appliquée : un problème
36
+ au-delà est résolu quand même, et `solvedBy.beyondDeclaredSize` vaut `true`. `null` = « à établir »
37
+ (borne ou mesure de taille inconnue) : ni « pas de limite » ni « limite respectée ».
38
+ `checkSize(dialecte | nom, problème) → { dialect, size, maxSize, beyondDeclaredSize }` le dit sans
39
+ résoudre. Bornes : hungarian 1000 (ordre de la matrice), simplex 200 (variables), branch-and-bound
40
+ 50 (variables entières), markov 500 (états), min-cost-flow 5000 et mdp 10000 (mesure à établir :
41
+ dépassement jamais jugé) ; les 17 autres : `maxSize: null`.
42
+
43
+ <!-- engendre:dialectes:debut -->
44
+ Dialectes (23, 12 familles, 15 exacts / 8 approches) — nom | kind | exact | maxSize | champs de forme :
45
+ - hungarian | assignment | exact | 1000 (ordre de la matrice des coûts) | cost
46
+ - simplex | lp | exact | 200 (nombre de variables) | c, A, b
47
+ - branch-and-bound | milp | exact | 50 (nombre de variables entières) | c, A, b
48
+ - min-cost-flow | flow | exact | 5000 | arcs, source, sink
49
+ - mmc | queue | exact | à établir | lambda, mu
50
+ - markov | markov | exact | 500 (nombre d'états) | P
51
+ - mdp | decision | exact | 10000 | transition, reward, gamma
52
+ - backtrack-csp | csp | exact | à établir | variables, domains, constraints
53
+ - anneal | metaheuristic | approche | à établir | initial, energy, neighbor
54
+ - monte-carlo | simulation | approche | à établir | sample, trials
55
+ - lagrangian | lp | approche | à établir | c, linkingA, linkingB, subA, subB
56
+ - stable-matching | assignment | exact | à établir | proposers, receivers, preferences
57
+ - critical-path | scheduling | exact | à établir | activities
58
+ - bin-packing | scheduling | approche | à établir | items, bins
59
+ - pareto | multiobjective | exact | à établir | candidates, senses
60
+ - list-scheduling | scheduling | approche | à établir | tasks, capacities
61
+ - shortest-path | flow | exact | à établir | edges, source
62
+ - max-flow | flow | exact | à établir | edges, source, sink
63
+ - matching | assignment | exact | à établir | edges
64
+ - knapsack | milp | exact | à établir | items, capacity
65
+ - tabu | metaheuristic | approche | à établir | initial, energy, neighbors
66
+ - genetic | metaheuristic | approche | à établir | population, fitness, crossover, mutate
67
+ - forecast | simulation | approche | à établir | series, horizon
68
+ <!-- engendre:dialectes:fin -->
69
+
70
+ ## IMPLÉMENTÉ — architecture « un dialecte par algorithme » (façon ORM)
71
+ Le module n'expose PAS un builder fluide mais un REGISTRE de dialectes, sélectionnés par nom ou par
72
+ famille et forme (comme `DB_DIALECT` pour un ORM).
73
+ - Contrat `SolverDialect<P,S> { name, kind, capabilities{exact,online,maxSize?:number|null,multiObjective?},
74
+ shape?{fields,test?,testLabel?}, size?(problem), sizeUnit?, notes?(problem), solve(problem,opts?) }`.
75
+ - Registre : `registerSolver(d)`, `getSolver(name)`, `listSolvers(kind?)`, `clearSolvers()`,
76
+ `registerBuiltinSolvers()`, `solve(problem, opts?)`, `checkSize(d, problem)`, `acceptsShape(d, problem)`.
77
+ La fonction interne de tri n'est PAS exportée.
78
+ - Un dialecte tiers sans `shape` est réputé accepter toute sa famille ; sans `maxSize`, il est traité
79
+ « à établir ». Aucun refus à l'enregistrement.
23
80
 
24
- ## IMPLÉMENTÉ (réel, à jour) — architecture « un dialecte par algorithme » (façon ORM)
25
- Le module n'expose PAS un builder fluide mais un REGISTRE de dialectes, sélectionnés
26
- par nom ou auto par `kind` (comme `DB_DIALECT`). C'est l'architecture retenue (cf. IDEE).
27
- - Contrat `SolverDialect<P,S> { name, kind, capabilities{exact,online,maxSize?,multiObjective?}, solve(problem,opts?) }`.
28
- - Registre : `registerSolver(d)`, `getSolver(name)`, `listSolvers(kind?)`, `pickBest(kind)`,
29
- `clearSolvers()`, et `solve(problem, opts?)` (nom explicite OU auto par `problem.kind`).
30
81
  - Dialecte `hungarian` (kind 'assignment') : `hungarian(cost: number[][]) → { assignment, total }`
31
82
  (Kuhn-Munkres O(n³), exact). Problème `AssignmentProblem { kind:'assignment', cost }`.
32
83
  - Dialecte `simplex` (kind 'lp') : `simplex(problem: LpProblem) → LpSolution`
@@ -47,6 +98,9 @@ par nom ou auto par `kind` (comme `DB_DIALECT`). C'est l'architecture retenue (c
47
98
  occupation, attente Wq/Lq) ; `mmcSizing(lambda, mu, target) → QueueSolution` (plus petit c stable
48
99
  satisfaisant `{maxWait?, maxProbWait?}`). `QueueProblem { kind:'queue', lambda, mu, c?, target? }` :
49
100
  `c` → évaluation ; `target` (sans `c`) → dimensionnement. Usage : estimer l'attente / dimensionner des guichets.
101
+ 0.3.0 : λ = 0 → attente 0 (plus de NaN) ; `c` non entier → RangeError ; sans `c` ni `target`, c = 1
102
+ est évalué ET signalé dans `solvedBy.notes`. ATTENTION Erlang C n'est PAS encore confrontée à une
103
+ table publiée : seulement à la récurrence d'Erlang B et à la loi de Little (cohérence, pas conformité).
50
104
  - Dialecte `markov` (kind 'markov') : chaînes de Markov à temps discret. `markovStationary(P)` (π exact par
51
105
  système linéaire), `markovStep(P, initial, steps)` (π₀Pᵏ), `markovAbsorbing(P)` (matrice fondamentale
52
106
  N=(I−Q)⁻¹ : espérance du temps avant absorption + probas d'absorption). `MarkovProblem { kind:'markov',
@@ -149,70 +203,16 @@ par nom ou auto par `kind` (comme `DB_DIALECT`). C'est l'architecture retenue (c
149
203
  rendrait un chiffre d'apparence sérieuse pour une question non traitée.
150
204
  ⚠️ L'erreur (MAE/MAPE) est TOUJOURS rendue : une prévision sans son erreur laisse croire à une
151
205
  précision qu'elle n'a pas. Mesurée APRÈS la première saison (les premiers points initialisent).
152
- - `registerBuiltinSolvers()` enregistre les 23 dialectes (hungarian, simplex, branch-and-bound, min-cost-flow,
153
- mmc, markov, mdp, backtrack-csp, anneal, monte-carlo, lagrangian + stable-matching, critical-path,
154
- bin-packing, pareto, list-scheduling, shortest-path, max-flow, matching, knapsack, tabu, genetic, forecast).
155
- Les kinds 'scheduling' et 'multiobjective' étaient DÉCLARÉS et VIDES : les DEUX sont désormais servis
156
- ('scheduling' → critical-path, bin-packing, list-scheduling ; 'multiobjective' → pareto).
157
- - Preuve de test : `npm run report` → `test-report.html` via le flag `--report` de @mostajs/mjs-unit 0.3.0.
158
- - Diagnostic manuel : `npm run dbg` (test-scripts/dbg.mjs) — sondes à l'œil hors suite, dont la régression ≥.
159
-
160
- ## RÔLE
161
- Modéliser et résoudre des problèmes d'optimisation, de satisfaction de contraintes
162
- et de modélisation stochastique :
163
- - PL : optimisation linéaire sous contraintes (simplexe).
164
- - PLNE/MIP : variables entières/mixtes (branch & bound).
165
- - Dantzig-Wolfe : PL structurées à grande échelle (blocs + contraintes liantes,
166
- génération de colonnes).
167
- - CSP : variables à domaines finis, contraintes, propagation AC-3 + backtracking.
168
- - Chaînes de Markov : matrices de transition, distribution stationnaire, régime
169
- transitoire → théorie des files (M/M/c, Erlang) pour estimer attente / dimensionner.
170
- - Métaheuristiques : algorithme génétique, recuit simulé, tabou, PSO, ACO, NSGA-II
171
- (multi-objectif) → gros problèmes combinatoires non linéaires, solutions « assez bonnes ».
172
- - Apprentissage : réseaux de neurones (MLP), apprentissage par renforcement,
173
- optimisation bayésienne → prévision d'affluence, politiques d'affectation apprises.
174
- Usages : affectation (tickets↔guichets, agents↔tâches), ordonnancement/planning,
175
- allocation de ressources, prévision d'attente et dimensionnement de guichets.
176
-
177
- FAMILLES : (1) Exact PL/PLNE — simplexe, branch&bound/cut, Dantzig-Wolfe, Benders,
178
- relaxation lagrangienne ; (2) Exact combinatoire — CSP, prog. dynamique, flots de
179
- réseau (max-flow, min-cost flow), Hongrois (affectation), plus courts chemins ;
180
- (3) Métaheuristiques — génétique, recuit simulé, tabou, PSO, ACO, NSGA-II ;
181
- (4) Stochastique — Markov, MDP, M/M/c, simulation à événements discrets, Monte-Carlo ;
182
- (5) Apprentissage — réseaux de neurones, RL, optimisation bayésienne.
183
- NOTE : le ML (réseaux/RL) pourrait être extrait dans un module frère @mostajs/ml (à trancher avant 1.0).
184
-
185
- NE FAIT PAS : évaluer des gardes/conditions (→ @mostajs/rules, inférence Prolog),
186
- états/transitions applicatifs (→ @mostajs/statemachine), événements/actions (→ trigger).
187
- Distinction : rules « est-ce vrai ? » ; ro-pla « quelle solution optimise / quel état stationnaire ? ».
188
-
189
- ## EXPORTS — FEUILLE DE ROUTE (prévus ; hungarian + lp DÉJÀ livrés, voir IMPLÉMENTÉ)
190
- - lp() → LpBuilder { maximize(coeffs)/minimize(coeffs), subjectTo(constraints), solve() }
191
- - model() → Model (CSP) : intVar, boolVar, allDifferent, linear, table, constraint, solve, solveAll, optimize
192
- - markov(matrix) → Chain { stationary(), step(dist, n?), absorbingTimes() }
193
- - mmc({ lambda, mu, c }) → { rho, pWait, avgWait, avgQueue } (file M/M/c, ≥ 0.2)
194
- - genetic({ fitness, genome, popSize, generations, mutationRate }) → BestSolution (≥ 0.2)
195
- - anneal({ energy, neighbor, schedule }) → BestSolution (recuit simulé, ≥ 0.2)
196
- - neuralNet({ layers, activation }) → { predict(x), train(data, opts) } (MLP, ≥ 0.3)
197
- - hungarian(costMatrix) → assignment (affectation optimale, ≥ 0.3)
198
- - dantzigWolfe(blocks, linking) → Solution (≥ 0.4)
199
-
200
- ## API — SIGNATURES (prévues, à figer)
201
- - lp().maximize(coeffs: Record<string,number>).subjectTo(rows).solve(): { vars, objective } | null
202
- - model().intVar(name, domain:number[]): Var ; allDifferent(vars): void ; solve(opts?): Solution|null
203
- - markov(P: number[][]).stationary(): number[] // vecteur π tel que πP = π
204
- - Bornage obligatoire (timeoutMs/maxNodes) comme @mostajs/rules.
205
206
 
206
- ## TYPES CLÉS (prévus)
207
- - LpBuilder, LpSolution, Model, Var, Constraint, Solution, Chain, MMCResult, SolveOptions
207
+ - Preuve de test : `npm run report` → `test-report.html`.
208
208
 
209
- ## PIÈGES (anticipés)
210
- - Explosion combinatoire (CSP/MIP) → timeouts/maxNodes obligatoires.
211
- - Simplexe : dégénérescence/cyclage → règle de Bland ; précision flottante.
212
- - Markov : vérifier irréductibilité/apériodicité avant distribution stationnaire.
213
- - Zéro-dépendance visé (solveurs maison) ; sinon backend (javascript-lp-solver) en peer optionnelle.
209
+ ## NE FAIT PAS
210
+ Évaluer des gardes/conditions (→ @mostajs/rules), états/transitions applicatifs
211
+ (→ @mostajs/statemachine), événements/actions. Distinction : rules « est-ce vrai ? » ;
212
+ ro-pla « quelle solution optimise / quel état stationnaire ? ».
214
213
 
215
- ## À PRODUIRE (DEVRULES §4/§14)
216
- État de l'art (simplex.js, javascript-lp-solver, MiniZinc, OR-Tools, Choco ; files/Erlang),
217
- audit (vs rules/statemachine/workflow), plan dev/test, CHANGELOG, doc technique, slides,
218
- chapitre de livre. Pas de publication avant les 14 livrables + tests verts.
214
+ ## PIÈGES
215
+ - Explosion combinatoire (CSP, MILP) : borner par `opts.maxNodes`.
216
+ - Simplexe : règle de Bland contre le cyclage ; précision flottante.
217
+ - Markov : vérifier irréductibilité et apériodicité avant la distribution stationnaire.
218
+ - Métaheuristiques : déterministes à graine égale (`seed`) ; `exact: false`.
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@mostajs/ro-pla",
3
- "version": "0.2.2",
4
- "description": "Programmation linéaire & recherche opérationnelle pour l'écosystème @mostajs/* : programmation linéaire (simplexe), variables entières/mixtes (branch & bound), contraintes (CSP : alldifferent, linéaires, table), optimisation min/max. Affectation, ordonnancement, planning, allocation de ressources. STADE PROPOSITION (0.0.1).",
3
+ "version": "0.3.0",
4
+ "description": "Recherche opérationnelle pour l'écosystème @mostajs/* : 23 dialectes (simplexe, branch & bound, flots, affectation, CSP, Markov, MDP, files M/M/c, ordonnancement, Pareto, métaheuristiques, prévision) sous un registre qui choisit par famille et forme du problème et dit qui a répondu (solvedBy). Zéro dépendance.",
5
5
  "author": "Dr Hamid MADANI <drmdh@msn.com>",
6
6
  "license": "AGPL-3.0-or-later",
7
7
  "type": "module",