@mostajs/ro-pla 0.2.1 → 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 +126 -4
- package/LICENSE +21 -0
- package/README.md +51 -30
- package/dist/dialects/anneal.js +2 -1
- package/dist/dialects/bin-packing.js +2 -1
- package/dist/dialects/critical-path.js +2 -1
- package/dist/dialects/csp.js +2 -1
- package/dist/dialects/forecast.js +2 -1
- package/dist/dialects/genetic.js +2 -1
- package/dist/dialects/hungarian.js +4 -0
- package/dist/dialects/knapsack.js +2 -1
- package/dist/dialects/lagrangian.js +2 -1
- package/dist/dialects/list-scheduling.js +2 -1
- package/dist/dialects/markov.js +4 -0
- package/dist/dialects/matching.js +2 -1
- package/dist/dialects/max-flow.js +2 -1
- package/dist/dialects/mdp.js +3 -0
- package/dist/dialects/milp.js +4 -0
- package/dist/dialects/min-cost-flow.js +3 -0
- package/dist/dialects/mmc.js +14 -2
- package/dist/dialects/monte-carlo.js +2 -1
- package/dist/dialects/pareto.js +2 -1
- package/dist/dialects/shortest-path.js +2 -1
- package/dist/dialects/simplex.js +4 -0
- package/dist/dialects/stable-matching.js +2 -1
- package/dist/dialects/tabu.js +2 -1
- package/dist/registry.d.ts +18 -3
- package/dist/registry.js +151 -11
- package/dist/types.d.ts +72 -2
- package/llms.txt +89 -76
- package/package.json +7 -2
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,130 @@
|
|
|
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
|
+
|
|
84
|
+
## [0.2.2] — 2026-09-06
|
|
85
|
+
|
|
86
|
+
### Corrigé — `llms.txt`, qui est PUBLIÉ, annonçait 11 dialectes et la version 0.1.0
|
|
87
|
+
|
|
88
|
+
`llms.txt` figure dans `files` : il part dans le paquet npm. La 0.2.1 publiée en portait un dont
|
|
89
|
+
l'en-tête disait « **Version: 0.1.0 · Statut: amorcé — 11 dialectes livrés et testés (59/59)** », et
|
|
90
|
+
dont le préambule annonçait « STADE PROPOSITION (0.0.1) — API PRÉVUE, non figée » plus
|
|
91
|
+
Dantzig-Wolfe et des réseaux de neurones qui n'existent pas. Le corps du fichier, lui, décrivait
|
|
92
|
+
bien les 23 dialectes — les 23 noms y sont, vérifié.
|
|
93
|
+
|
|
94
|
+
C'est le même défaut que le README corrigé la veille, avec une circonstance aggravante : **cette
|
|
95
|
+
fiche est écrite pour être lue par une machine**, qui n'a aucun moyen de flairer l'incohérence entre
|
|
96
|
+
un en-tête et un corps.
|
|
97
|
+
|
|
98
|
+
Corrigé, et deux avertissements ajoutés pour le lecteur-machine :
|
|
99
|
+
|
|
100
|
+
- **`maxSize` est déclarative et n'est PAS appliquée** — six dialectes en portent une, aucun ne la
|
|
101
|
+
fait respecter ; les 17 autres n'en déclarent aucune, ce qui ne veut dire ni « pas de limite » ni
|
|
102
|
+
« limite inconnue ».
|
|
103
|
+
- **`solve({kind})` ne dit pas quel dialecte a été retenu** — pour savoir si un résultat est prouvé,
|
|
104
|
+
il faut lire `getSolver(nom).capabilities.exact`.
|
|
105
|
+
|
|
106
|
+
### Nommé — quatre défauts, renvoyés à la 0.3.0
|
|
107
|
+
|
|
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.
|
|
110
|
+
|
|
111
|
+
- **A — `maxSize` déclarée, jamais appliquée.** Mesuré : `simplex` déclare 200 et rend `optimal` à
|
|
112
|
+
200, 300 et 600 variables, avec les mêmes champs, sans un mot. Le danger n'est pas le plantage,
|
|
113
|
+
c'est la réponse assurée hors du domaine garanti.
|
|
114
|
+
- **B — le commentaire de `pickBest` décrit ce que le code ne fait pas.** Il annonce un tri « puis le
|
|
115
|
+
plus petit `maxSize` couvrant » ; le code ne trie que sur `exact`. Sans conséquence aujourd'hui,
|
|
116
|
+
faux dès le premier `kind` servi par deux dialectes exacts de bornes différentes.
|
|
117
|
+
- **C — la sélection ne rend pas son motif.** `solve({kind})` ne dit pas quel dialecte a produit le
|
|
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.
|
|
127
|
+
|
|
3
128
|
## [0.2.1] — 2026-09-06
|
|
4
129
|
|
|
5
130
|
### Corrigé — `bin-packing` : deux défauts trouvés PAR L'USAGE
|
|
@@ -45,9 +170,6 @@ Dantzig-Wolfe, Benders, PSO, ACO, GRASP, NSGA-II en propre, réseaux de neurones
|
|
|
45
170
|
événements discrets, contraintes cumulative, dualité/sensibilité. Tous annoncés dans la feuille de
|
|
46
171
|
route d'origine, aucun présent. Un module qui laisse croire coûte plus cher qu'un module qui manque.
|
|
47
172
|
|
|
48
|
-
L'état des livrables DEVRULES §9 y est dit sans arrangement : **4 présents sur 17**, et l'article
|
|
49
|
-
existant attend une vérification de ses sources avant diffusion.
|
|
50
|
-
|
|
51
173
|
> Le paquet npm n'embarque ni `examples/` ni les sources : `files` reste limité à `dist/`.
|
|
52
174
|
|
|
53
175
|
## [0.2.0] — 2026-08-09
|
|
@@ -85,5 +207,5 @@ graine égale** — sans quoi `@mostajs/skill-library` ne pourrait juger aucune
|
|
|
85
207
|
courte : l'appelant croyait tenir une prévision saisonnière. Refus motivé si la méthode est
|
|
86
208
|
demandée explicitement, `note` explicite en mode automatique.
|
|
87
209
|
|
|
88
|
-
108 tests verts.
|
|
210
|
+
108 tests verts.
|
|
89
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.
|
|
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
|
|
8
|
-
|
|
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
|
|
14
|
-
solve({ kind: 'assignment', cost: [[4, 1], [2, 3]] });
|
|
15
|
-
|
|
16
|
-
|
|
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
|
-
|
|
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
|
|
22
|
-
getSolver('hungarian').capabilities;
|
|
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
|
-
|
|
28
|
-
|
|
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, tri par non-domination façon NSGA-II) |
|
|
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 #
|
|
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.
|
|
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
|
-
|
|
83
|
-
`docs/DEVTEST-PLAN.ro-pla.json` (#4), `docs/articles/17-ARTICLE-ALGOS-RO-FILE-ATTENTE.md` (#17).
|
|
106
|
+
## Licence
|
|
84
107
|
|
|
85
|
-
|
|
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`.
|
package/dist/dialects/anneal.js
CHANGED
|
@@ -37,7 +37,8 @@ export function anneal(problem) {
|
|
|
37
37
|
export const annealDialect = {
|
|
38
38
|
name: 'anneal',
|
|
39
39
|
kind: 'metaheuristic',
|
|
40
|
-
|
|
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
|
-
|
|
108
|
+
shape: { fields: ['activities'] },
|
|
109
|
+
capabilities: { exact: true, online: false, maxSize: null },
|
|
109
110
|
solve(problem) {
|
|
110
111
|
return criticalPath(problem);
|
|
111
112
|
},
|
package/dist/dialects/csp.js
CHANGED
|
@@ -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
|
-
|
|
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
|
-
|
|
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
|
package/dist/dialects/genetic.js
CHANGED
|
@@ -86,7 +86,8 @@ export function genetic(problem) {
|
|
|
86
86
|
export const geneticDialect = {
|
|
87
87
|
name: 'genetic',
|
|
88
88
|
kind: 'metaheuristic',
|
|
89
|
-
|
|
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
|
-
|
|
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
|
-
|
|
146
|
+
shape: { fields: ['tasks', 'capacities'] },
|
|
147
|
+
capabilities: { exact: false, online: false, maxSize: null },
|
|
147
148
|
solve(problem) {
|
|
148
149
|
return listScheduling(problem);
|
|
149
150
|
},
|
package/dist/dialects/markov.js
CHANGED
|
@@ -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
|
-
|
|
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
|
package/dist/dialects/mdp.js
CHANGED
|
@@ -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
|
},
|
package/dist/dialects/milp.js
CHANGED
|
@@ -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
|
},
|
package/dist/dialects/mmc.js
CHANGED
|
@@ -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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
30
|
+
shape: { fields: ['sample', 'trials'] },
|
|
31
|
+
capabilities: { exact: false, online: true, maxSize: null },
|
|
31
32
|
solve(problem) {
|
|
32
33
|
return monteCarlo(problem);
|
|
33
34
|
},
|
package/dist/dialects/pareto.js
CHANGED
|
@@ -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
|
-
|
|
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
|
package/dist/dialects/simplex.js
CHANGED
|
@@ -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
|
},
|
package/dist/dialects/tabu.js
CHANGED
|
@@ -89,7 +89,8 @@ export function tabuSearch(problem) {
|
|
|
89
89
|
export const tabuDialect = {
|
|
90
90
|
name: 'tabu',
|
|
91
91
|
kind: 'metaheuristic',
|
|
92
|
-
|
|
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
|
package/dist/registry.d.ts
CHANGED
|
@@ -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
|
-
*
|
|
16
|
-
* (
|
|
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
|
-
*
|
|
28
|
-
*
|
|
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
|
|
31
|
-
const
|
|
32
|
-
|
|
33
|
-
|
|
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
|
|
123
|
+
return { cmp: 0, by: null };
|
|
36
124
|
}
|
|
37
125
|
/**
|
|
38
|
-
*
|
|
39
|
-
*
|
|
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
|
|
43
|
-
|
|
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
|
-
/**
|
|
21
|
-
|
|
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,19 +1,83 @@
|
|
|
1
1
|
# @mostajs/ro-pla — fiche LLM
|
|
2
2
|
|
|
3
|
-
> Programmation linéaire & recherche opérationnelle
|
|
4
|
-
>
|
|
5
|
-
>
|
|
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
|
+
>
|
|
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é.
|
|
6
11
|
|
|
7
|
-
- Version: 0.
|
|
8
|
-
-
|
|
9
|
-
|
|
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.
|
|
10
80
|
|
|
11
|
-
## IMPLÉMENTÉ (réel, à jour) — architecture « un dialecte par algorithme » (façon ORM)
|
|
12
|
-
Le module n'expose PAS un builder fluide mais un REGISTRE de dialectes, sélectionnés
|
|
13
|
-
par nom ou auto par `kind` (comme `DB_DIALECT`). C'est l'architecture retenue (cf. IDEE).
|
|
14
|
-
- Contrat `SolverDialect<P,S> { name, kind, capabilities{exact,online,maxSize?,multiObjective?}, solve(problem,opts?) }`.
|
|
15
|
-
- Registre : `registerSolver(d)`, `getSolver(name)`, `listSolvers(kind?)`, `pickBest(kind)`,
|
|
16
|
-
`clearSolvers()`, et `solve(problem, opts?)` (nom explicite OU auto par `problem.kind`).
|
|
17
81
|
- Dialecte `hungarian` (kind 'assignment') : `hungarian(cost: number[][]) → { assignment, total }`
|
|
18
82
|
(Kuhn-Munkres O(n³), exact). Problème `AssignmentProblem { kind:'assignment', cost }`.
|
|
19
83
|
- Dialecte `simplex` (kind 'lp') : `simplex(problem: LpProblem) → LpSolution`
|
|
@@ -34,6 +98,9 @@ par nom ou auto par `kind` (comme `DB_DIALECT`). C'est l'architecture retenue (c
|
|
|
34
98
|
occupation, attente Wq/Lq) ; `mmcSizing(lambda, mu, target) → QueueSolution` (plus petit c stable
|
|
35
99
|
satisfaisant `{maxWait?, maxProbWait?}`). `QueueProblem { kind:'queue', lambda, mu, c?, target? }` :
|
|
36
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é).
|
|
37
104
|
- Dialecte `markov` (kind 'markov') : chaînes de Markov à temps discret. `markovStationary(P)` (π exact par
|
|
38
105
|
système linéaire), `markovStep(P, initial, steps)` (π₀Pᵏ), `markovAbsorbing(P)` (matrice fondamentale
|
|
39
106
|
N=(I−Q)⁻¹ : espérance du temps avant absorption + probas d'absorption). `MarkovProblem { kind:'markov',
|
|
@@ -136,70 +203,16 @@ par nom ou auto par `kind` (comme `DB_DIALECT`). C'est l'architecture retenue (c
|
|
|
136
203
|
rendrait un chiffre d'apparence sérieuse pour une question non traitée.
|
|
137
204
|
⚠️ L'erreur (MAE/MAPE) est TOUJOURS rendue : une prévision sans son erreur laisse croire à une
|
|
138
205
|
précision qu'elle n'a pas. Mesurée APRÈS la première saison (les premiers points initialisent).
|
|
139
|
-
- `registerBuiltinSolvers()` enregistre les 23 dialectes (hungarian, simplex, branch-and-bound, min-cost-flow,
|
|
140
|
-
mmc, markov, mdp, backtrack-csp, anneal, monte-carlo, lagrangian + stable-matching, critical-path,
|
|
141
|
-
bin-packing, pareto, list-scheduling, shortest-path, max-flow, matching, knapsack, tabu, genetic, forecast).
|
|
142
|
-
Les kinds 'scheduling' et 'multiobjective' étaient DÉCLARÉS et VIDES : les DEUX sont désormais servis
|
|
143
|
-
('scheduling' → critical-path, bin-packing, list-scheduling ; 'multiobjective' → pareto).
|
|
144
|
-
- Preuve de test : `npm run report` → `test-report.html` via le flag `--report` de @mostajs/mjs-unit 0.3.0.
|
|
145
|
-
- Diagnostic manuel : `npm run dbg` (test-scripts/dbg.mjs) — sondes à l'œil hors suite, dont la régression ≥.
|
|
146
|
-
|
|
147
|
-
## RÔLE
|
|
148
|
-
Modéliser et résoudre des problèmes d'optimisation, de satisfaction de contraintes
|
|
149
|
-
et de modélisation stochastique :
|
|
150
|
-
- PL : optimisation linéaire sous contraintes (simplexe).
|
|
151
|
-
- PLNE/MIP : variables entières/mixtes (branch & bound).
|
|
152
|
-
- Dantzig-Wolfe : PL structurées à grande échelle (blocs + contraintes liantes,
|
|
153
|
-
génération de colonnes).
|
|
154
|
-
- CSP : variables à domaines finis, contraintes, propagation AC-3 + backtracking.
|
|
155
|
-
- Chaînes de Markov : matrices de transition, distribution stationnaire, régime
|
|
156
|
-
transitoire → théorie des files (M/M/c, Erlang) pour estimer attente / dimensionner.
|
|
157
|
-
- Métaheuristiques : algorithme génétique, recuit simulé, tabou, PSO, ACO, NSGA-II
|
|
158
|
-
(multi-objectif) → gros problèmes combinatoires non linéaires, solutions « assez bonnes ».
|
|
159
|
-
- Apprentissage : réseaux de neurones (MLP), apprentissage par renforcement,
|
|
160
|
-
optimisation bayésienne → prévision d'affluence, politiques d'affectation apprises.
|
|
161
|
-
Usages : affectation (tickets↔guichets, agents↔tâches), ordonnancement/planning,
|
|
162
|
-
allocation de ressources, prévision d'attente et dimensionnement de guichets.
|
|
163
|
-
|
|
164
|
-
FAMILLES : (1) Exact PL/PLNE — simplexe, branch&bound/cut, Dantzig-Wolfe, Benders,
|
|
165
|
-
relaxation lagrangienne ; (2) Exact combinatoire — CSP, prog. dynamique, flots de
|
|
166
|
-
réseau (max-flow, min-cost flow), Hongrois (affectation), plus courts chemins ;
|
|
167
|
-
(3) Métaheuristiques — génétique, recuit simulé, tabou, PSO, ACO, NSGA-II ;
|
|
168
|
-
(4) Stochastique — Markov, MDP, M/M/c, simulation à événements discrets, Monte-Carlo ;
|
|
169
|
-
(5) Apprentissage — réseaux de neurones, RL, optimisation bayésienne.
|
|
170
|
-
NOTE : le ML (réseaux/RL) pourrait être extrait dans un module frère @mostajs/ml (à trancher avant 1.0).
|
|
171
|
-
|
|
172
|
-
NE FAIT PAS : évaluer des gardes/conditions (→ @mostajs/rules, inférence Prolog),
|
|
173
|
-
états/transitions applicatifs (→ @mostajs/statemachine), événements/actions (→ trigger).
|
|
174
|
-
Distinction : rules « est-ce vrai ? » ; ro-pla « quelle solution optimise / quel état stationnaire ? ».
|
|
175
|
-
|
|
176
|
-
## EXPORTS — FEUILLE DE ROUTE (prévus ; hungarian + lp DÉJÀ livrés, voir IMPLÉMENTÉ)
|
|
177
|
-
- lp() → LpBuilder { maximize(coeffs)/minimize(coeffs), subjectTo(constraints), solve() }
|
|
178
|
-
- model() → Model (CSP) : intVar, boolVar, allDifferent, linear, table, constraint, solve, solveAll, optimize
|
|
179
|
-
- markov(matrix) → Chain { stationary(), step(dist, n?), absorbingTimes() }
|
|
180
|
-
- mmc({ lambda, mu, c }) → { rho, pWait, avgWait, avgQueue } (file M/M/c, ≥ 0.2)
|
|
181
|
-
- genetic({ fitness, genome, popSize, generations, mutationRate }) → BestSolution (≥ 0.2)
|
|
182
|
-
- anneal({ energy, neighbor, schedule }) → BestSolution (recuit simulé, ≥ 0.2)
|
|
183
|
-
- neuralNet({ layers, activation }) → { predict(x), train(data, opts) } (MLP, ≥ 0.3)
|
|
184
|
-
- hungarian(costMatrix) → assignment (affectation optimale, ≥ 0.3)
|
|
185
|
-
- dantzigWolfe(blocks, linking) → Solution (≥ 0.4)
|
|
186
|
-
|
|
187
|
-
## API — SIGNATURES (prévues, à figer)
|
|
188
|
-
- lp().maximize(coeffs: Record<string,number>).subjectTo(rows).solve(): { vars, objective } | null
|
|
189
|
-
- model().intVar(name, domain:number[]): Var ; allDifferent(vars): void ; solve(opts?): Solution|null
|
|
190
|
-
- markov(P: number[][]).stationary(): number[] // vecteur π tel que πP = π
|
|
191
|
-
- Bornage obligatoire (timeoutMs/maxNodes) comme @mostajs/rules.
|
|
192
206
|
|
|
193
|
-
|
|
194
|
-
- LpBuilder, LpSolution, Model, Var, Constraint, Solution, Chain, MMCResult, SolveOptions
|
|
207
|
+
- Preuve de test : `npm run report` → `test-report.html`.
|
|
195
208
|
|
|
196
|
-
##
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
-
|
|
200
|
-
- 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 ? ».
|
|
201
213
|
|
|
202
|
-
##
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
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.
|
|
4
|
-
"description": "
|
|
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",
|
|
@@ -43,6 +43,11 @@
|
|
|
43
43
|
"mostajs"
|
|
44
44
|
],
|
|
45
45
|
"devDependencies": {
|
|
46
|
+
"@mostajs/doc-driver-chrome": "^0.1.0",
|
|
47
|
+
"@mostajs/doc-driver-pandoc": "^0.1.0",
|
|
48
|
+
"@mostajs/doc-export": "^0.2.1",
|
|
49
|
+
"@mostajs/doc-themes": "^0.1.1",
|
|
50
|
+
"@mostajs/markdown-html": "^0.1.2",
|
|
46
51
|
"@mostajs/mjs-unit": "^0.3.0",
|
|
47
52
|
"@types/node": "^22.0.0",
|
|
48
53
|
"typescript": "^5.6.0"
|