@mostajs/ro-pla 0.2.0 → 0.2.2
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 +111 -0
- package/README.md +77 -92
- package/dist/dialects/bin-packing.d.ts +22 -1
- package/dist/dialects/bin-packing.js +47 -5
- package/llms.txt +18 -5
- package/package.json +9 -2
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,116 @@
|
|
|
1
1
|
# CHANGELOG
|
|
2
2
|
|
|
3
|
+
## [0.2.2] — 2026-09-06
|
|
4
|
+
|
|
5
|
+
### Corrigé — `llms.txt`, qui est PUBLIÉ, annonçait 11 dialectes et la version 0.1.0
|
|
6
|
+
|
|
7
|
+
`llms.txt` figure dans `files` : il part dans le paquet npm. La 0.2.1 publiée en portait un dont
|
|
8
|
+
l'en-tête disait « **Version: 0.1.0 · Statut: amorcé — 11 dialectes livrés et testés (59/59)** », et
|
|
9
|
+
dont le préambule annonçait « STADE PROPOSITION (0.0.1) — API PRÉVUE, non figée » plus
|
|
10
|
+
Dantzig-Wolfe et des réseaux de neurones qui n'existent pas. Le corps du fichier, lui, décrivait
|
|
11
|
+
bien les 23 dialectes — les 23 noms y sont, vérifié.
|
|
12
|
+
|
|
13
|
+
C'est le même défaut que le README corrigé la veille, avec une circonstance aggravante : **cette
|
|
14
|
+
fiche est écrite pour être lue par une machine**, qui n'a aucun moyen de flairer l'incohérence entre
|
|
15
|
+
un en-tête et un corps.
|
|
16
|
+
|
|
17
|
+
Corrigé, et deux avertissements ajoutés pour le lecteur-machine :
|
|
18
|
+
|
|
19
|
+
- **`maxSize` est déclarative et n'est PAS appliquée** — six dialectes en portent une, aucun ne la
|
|
20
|
+
fait respecter ; les 17 autres n'en déclarent aucune, ce qui ne veut dire ni « pas de limite » ni
|
|
21
|
+
« limite inconnue ».
|
|
22
|
+
- **`solve({kind})` ne dit pas quel dialecte a été retenu** — pour savoir si un résultat est prouvé,
|
|
23
|
+
il faut lire `getSolver(nom).capabilities.exact`.
|
|
24
|
+
|
|
25
|
+
### Ajouté — les 13 livrables §9 manquants (4 → 17)
|
|
26
|
+
|
|
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.
|
|
34
|
+
|
|
35
|
+
- **A — `maxSize` déclarée, jamais appliquée.** Mesuré : `simplex` déclare 200 et rend `optimal` à
|
|
36
|
+
200, 300 et 600 variables, avec les mêmes champs, sans un mot. Le danger n'est pas le plantage,
|
|
37
|
+
c'est la réponse assurée hors du domaine garanti.
|
|
38
|
+
- **B — le commentaire de `pickBest` décrit ce que le code ne fait pas.** Il annonce un tri « puis le
|
|
39
|
+
plus petit `maxSize` couvrant » ; le code ne trie que sur `exact`. Sans conséquence aujourd'hui,
|
|
40
|
+
faux dès le premier `kind` servi par deux dialectes exacts de bornes différentes.
|
|
41
|
+
- **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.
|
|
63
|
+
|
|
64
|
+
## [0.2.1] — 2026-09-06
|
|
65
|
+
|
|
66
|
+
### Corrigé — `bin-packing` : deux défauts trouvés PAR L'USAGE
|
|
67
|
+
|
|
68
|
+
Les deux sont sortis de l'écriture de `examples/restaurant/04-fournees-bin-packing.mjs`, pas d'une
|
|
69
|
+
relecture. Le test existant (T-RO-40) prouvait qu'une restriction `allowedBins` était *respectée* —
|
|
70
|
+
jamais qu'elle était *servie en concurrence*. C'est par là que le défaut est passé.
|
|
71
|
+
|
|
72
|
+
- **Le plus contraint d'abord.** Le tri était purement décroissant en taille. Un objet restreint à
|
|
73
|
+
un seul contenant perdait sa seule place au profit d'un objet plus gros qui en avait dix autres :
|
|
74
|
+
la restriction restait formellement honorée, et le plan devenait inutilisable — l'objet lésé
|
|
75
|
+
sortait en `unplaced` sans que rien n'indique qu'une place lui était due. Le tri se fait désormais
|
|
76
|
+
par liberté croissante, puis par taille décroissante. *(T-RO-40a)*
|
|
77
|
+
- **`lowerBound` tient compte des restrictions.** La borne valait `⌈charge totale / capacité max⌉`
|
|
78
|
+
et ignorait les groupes cantonnés : trois plats sans gluten de 3 plaques dans un seul four de 8
|
|
79
|
+
exigent deux fournées, quelle que soit la capacité globale de la cuisine. *(T-RO-40b)*
|
|
80
|
+
|
|
81
|
+
### Ajouté
|
|
82
|
+
|
|
83
|
+
- **`note`** sur `BinPackingSolution` : la CAUSE des objets non rangés quand elle est connue AVANT
|
|
84
|
+
toute heuristique — capacité totale insuffisante, ou groupe restreint plus lourd que ses
|
|
85
|
+
contenants autorisés. Sans elle, une liste d'`unplaced` laisse croire à une heuristique médiocre
|
|
86
|
+
alors qu'aucun plan n'existe. *(T-RO-40c)*
|
|
87
|
+
- **`examples/`** — 24 exemples exécutables (un par dialecte + une comparaison des trois
|
|
88
|
+
métaheuristiques), groupés par métier : restaurant, université, réseau, métaheuristiques. Chacun
|
|
89
|
+
se termine par des vérifications qui échouent bruyamment ; `bash examples/run-all.sh` en fait un
|
|
90
|
+
filet de régression. Plusieurs prouvent l'optimalité **par force brute** (120 permutations pour
|
|
91
|
+
`hungarian`, 180 affectations pour `min-cost-flow`, 40 320 tournées pour les métaheuristiques).
|
|
92
|
+
- **`examples/index.html`** — représentation graphique engendrée par `build-html.mjs`. Calculée et
|
|
93
|
+
non recopiée : chaque chiffre sort d'un appel réel au dialecte à la génération. Zéro dépendance,
|
|
94
|
+
palette validée pour la vision des couleurs dans les deux modes d'affichage.
|
|
95
|
+
|
|
96
|
+
### Corrigé — le README annonçait un module qui n'existait plus
|
|
97
|
+
|
|
98
|
+
L'en-tête portait encore « **proposition / scaffold (0.0.1) — non implémenté, périmètre à valider** »
|
|
99
|
+
alors que 23 dialectes tournaient et que 111 essais étaient verts. Trois sections décrivaient une
|
|
100
|
+
feuille de route — « API envisagée (à figer en 0.1.0) », « Périmètre prévu », « Reste à produire » —
|
|
101
|
+
dont l'essentiel était fait. C'est le défaut d'un écran qui mentirait sur ce qu'il sait faire, et il
|
|
102
|
+
coûte le même prix : celui qui lit renonce, ou bâtit sur une promesse.
|
|
103
|
+
|
|
104
|
+
Réécrit sur des faits relevés dans le code, avec une section **« Ce que ce module ne fait PAS »** —
|
|
105
|
+
Dantzig-Wolfe, Benders, PSO, ACO, GRASP, NSGA-II en propre, réseaux de neurones, simulation à
|
|
106
|
+
événements discrets, contraintes cumulative, dualité/sensibilité. Tous annoncés dans la feuille de
|
|
107
|
+
route d'origine, aucun présent. Un module qui laisse croire coûte plus cher qu'un module qui manque.
|
|
108
|
+
|
|
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
|
+
> Le paquet npm n'embarque ni `examples/` ni les sources : `files` reste limité à `dist/`.
|
|
113
|
+
|
|
3
114
|
## [0.2.0] — 2026-08-09
|
|
4
115
|
|
|
5
116
|
### Ajouté — LOT 2 : douze dialectes (11 → 23)
|
package/README.md
CHANGED
|
@@ -1,102 +1,87 @@
|
|
|
1
1
|
# @mostajs/ro-pla
|
|
2
2
|
|
|
3
3
|
**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
|
|
4
|
-
**Statut** :
|
|
5
|
-
|
|
6
|
-
**Programmation linéaire & recherche opérationnelle**
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
|
41
|
-
|
|
42
|
-
|
|
|
43
|
-
|
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
4
|
+
**Statut** : **0.2.1** — 23 dialectes, 111 essais verts, `examples/` exécutables.
|
|
5
|
+
|
|
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.
|
|
9
|
+
|
|
10
|
+
```js
|
|
11
|
+
import { solve, getSolver, binPacking } from '@mostajs/ro-pla';
|
|
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
|
|
17
|
+
|
|
18
|
+
// Ou l'on appelle un dialecte directement, quand on sait ce qu'on veut.
|
|
19
|
+
binPacking({ kind: 'scheduling', items, bins, strategy: 'both' });
|
|
20
|
+
|
|
21
|
+
// Les capacités d'un dialecte se LISENT avant de s'en servir.
|
|
22
|
+
getSolver('hungarian').capabilities; // { exact: true, online: true, maxSize: 1000 }
|
|
23
|
+
```
|
|
24
|
+
|
|
25
|
+
## Les 23 dialectes, par famille
|
|
26
|
+
|
|
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.**
|
|
29
|
+
|
|
30
|
+
| `kind` | dialectes |
|
|
31
|
+
|---|---|
|
|
32
|
+
| `assignment` | hungarian · stable-matching · matching |
|
|
33
|
+
| `lp` | simplex · lagrangian `~` |
|
|
34
|
+
| `milp` | branch-and-bound · knapsack |
|
|
35
|
+
| `flow` | min-cost-flow · shortest-path · max-flow |
|
|
36
|
+
| `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
|
+
| `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
|
+
| `simulation` | monte-carlo `~` · forecast `~` |
|
|
44
|
+
|
|
45
|
+
## Ce que ce module ne fait PAS
|
|
46
|
+
|
|
47
|
+
Écrit ici parce qu'un module qui laisse croire est plus coûteux qu'un module qui manque. Annoncés
|
|
48
|
+
dans la feuille de route d'origine, **absents du code** à ce jour :
|
|
49
|
+
|
|
50
|
+
- **décomposition de Dantzig-Wolfe** (génération de colonnes) et **Benders** ;
|
|
51
|
+
- **PSO** (essaims particulaires), **ACO** (colonies de fourmis), **GRASP** ;
|
|
52
|
+
- **NSGA-II** en propre — seul son *tri par non-domination* est repris dans `pareto` ;
|
|
53
|
+
- **réseaux de neurones / MLP** et apprentissage par renforcement. La note de conception d'origine
|
|
54
|
+
tient toujours : l'apprentissage relève d'un autre paradigme que la RO exacte, et s'il vient il
|
|
55
|
+
ira dans un module frère plutôt qu'ici ;
|
|
56
|
+
- **simulation à événements discrets**, contraintes globales **cumulative/scheduling**,
|
|
57
|
+
**dualité / analyse de sensibilité**.
|
|
47
58
|
|
|
48
59
|
## Positionnement (vs `@mostajs/rules`)
|
|
49
60
|
|
|
50
|
-
`@mostajs/rules` **évalue** des conditions
|
|
51
|
-
`@mostajs/ro-pla` **optimise
|
|
52
|
-
|
|
53
|
-
Responsabilités distinctes, complémentaires.
|
|
61
|
+
`@mostajs/rules` **évalue** des conditions et des gardes — « est-ce vrai ? ».
|
|
62
|
+
`@mostajs/ro-pla` **optimise, résout, modélise** — « quelle solution satisfait les contraintes et
|
|
63
|
+
optimise l'objectif ? », « quel est l'état stationnaire ? ». Responsabilités distinctes.
|
|
54
64
|
|
|
55
|
-
##
|
|
65
|
+
## Éprouver
|
|
56
66
|
|
|
57
|
-
```
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
.maximize({ x: 3, y: 2 })
|
|
63
|
-
.subjectTo([
|
|
64
|
-
{ x: 1, y: 1, "<=": 4 },
|
|
65
|
-
{ x: 1, y: 3, "<=": 6 },
|
|
66
|
-
])
|
|
67
|
-
.solve(); // { x, y, objective }
|
|
68
|
-
|
|
69
|
-
// CSP : affectation
|
|
70
|
-
const m = model();
|
|
71
|
-
const a = m.intVar("a", [1, 2, 3]);
|
|
72
|
-
const b = m.intVar("b", [1, 2, 3]);
|
|
73
|
-
m.allDifferent([a, b]);
|
|
74
|
-
const csp = m.solve(); // { assignment: { a, b } }
|
|
75
|
-
|
|
76
|
-
// Chaîne de Markov : distribution stationnaire
|
|
77
|
-
const chain = markov([
|
|
78
|
-
[0.9, 0.1],
|
|
79
|
-
[0.5, 0.5],
|
|
80
|
-
]);
|
|
81
|
-
const pi = chain.stationary(); // vecteur de probabilités stationnaires
|
|
67
|
+
```bash
|
|
68
|
+
npm run build # tsc → dist/ (non versionné)
|
|
69
|
+
npm test # 111 essais sur 17 fichiers, via @mostajs/mjs-unit
|
|
70
|
+
npm run report # preuve HTML
|
|
71
|
+
npm run examples # 24 exemples exécutables
|
|
82
72
|
```
|
|
83
73
|
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
Les 14 livrables (état de l'art — *simplex.js, javascript-lp-solver, MiniZinc,
|
|
100
|
-
OR-Tools, Choco ; théorie des files / Erlang* —, audit, plan dev/test, `llms.txt`
|
|
101
|
-
détaillé, CHANGELOG, doc technique, chapitre de livre…) sont **à rédiger** au
|
|
102
|
-
démarrage. Ce dépôt ne contient que le **squelette §5**.
|
|
74
|
+
`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)
|
|
81
|
+
|
|
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).
|
|
84
|
+
|
|
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.
|
|
@@ -18,6 +18,14 @@
|
|
|
18
18
|
* · **BFD** (best-fit decreasing) — remplit au plus juste, souvent meilleur quand les capacités
|
|
19
19
|
* sont très inégales.
|
|
20
20
|
* Le mode `both` les essaie et **rend la meilleure**, en disant laquelle a gagné.
|
|
21
|
+
*
|
|
22
|
+
* ─── LE PLUS CONTRAINT D'ABORD ──────────────────────────────────────────────────────────────
|
|
23
|
+
* Le tri n'est PAS seulement décroissant en taille. Un objet restreint par `allowedBins` passe
|
|
24
|
+
* AVANT les objets libres. Sans cette règle, un objet qui n'a qu'un seul contenant possible perd
|
|
25
|
+
* sa place au profit d'un objet plus gros qui en avait dix autres : la restriction reste
|
|
26
|
+
* formellement respectée, et le plan devient inutilisable. C'est le défaut classique du
|
|
27
|
+
* first-fit sur boîtes hétérogènes, et il est silencieux — l'objet lésé sort en `unplaced`
|
|
28
|
+
* sans que rien n'indique qu'une place lui était due.
|
|
21
29
|
*/
|
|
22
30
|
import type { SolverDialect } from '../types.js';
|
|
23
31
|
export interface PackItem {
|
|
@@ -47,11 +55,24 @@ export interface BinPackingSolution {
|
|
|
47
55
|
/** Objets qu'AUCUN contenant ne peut prendre — jamais tus. */
|
|
48
56
|
unplaced: string[];
|
|
49
57
|
binsUsed: number;
|
|
50
|
-
/**
|
|
58
|
+
/**
|
|
59
|
+
* Borne inférieure du nombre de contenants nécessaires pour TOUT ranger. Elle tient compte
|
|
60
|
+
* des restrictions `allowedBins` : un groupe cantonné à de petits contenants en exige plusieurs,
|
|
61
|
+
* même si la capacité globale semble suffire.
|
|
62
|
+
*
|
|
63
|
+
* ⚠️ Ne se compare à `binsUsed` QUE si `unplaced` est vide : un plan qui a laissé des objets
|
|
64
|
+
* dehors peut évidemment employer moins de contenants que le minimum d'un plan complet.
|
|
65
|
+
*/
|
|
51
66
|
lowerBound: number;
|
|
52
67
|
strategyUsed: 'ffd' | 'bfd';
|
|
53
68
|
/** Taux de remplissage moyen des contenants utilisés. */
|
|
54
69
|
fillRate: number;
|
|
70
|
+
/**
|
|
71
|
+
* CAUSE des objets non rangés, quand elle est connue AVANT toute heuristique — capacité
|
|
72
|
+
* totale insuffisante, ou groupe restreint plus lourd que ses contenants autorisés. Sans elle,
|
|
73
|
+
* une liste d'`unplaced` laisse croire à une heuristique médiocre alors qu'aucun plan n'existe.
|
|
74
|
+
*/
|
|
75
|
+
note?: string;
|
|
55
76
|
}
|
|
56
77
|
export declare function binPacking(problem: BinPackingProblem): BinPackingSolution;
|
|
57
78
|
export declare const binPackingDialect: SolverDialect<any, BinPackingSolution>;
|
|
@@ -18,15 +18,28 @@
|
|
|
18
18
|
* · **BFD** (best-fit decreasing) — remplit au plus juste, souvent meilleur quand les capacités
|
|
19
19
|
* sont très inégales.
|
|
20
20
|
* Le mode `both` les essaie et **rend la meilleure**, en disant laquelle a gagné.
|
|
21
|
+
*
|
|
22
|
+
* ─── LE PLUS CONTRAINT D'ABORD ──────────────────────────────────────────────────────────────
|
|
23
|
+
* Le tri n'est PAS seulement décroissant en taille. Un objet restreint par `allowedBins` passe
|
|
24
|
+
* AVANT les objets libres. Sans cette règle, un objet qui n'a qu'un seul contenant possible perd
|
|
25
|
+
* sa place au profit d'un objet plus gros qui en avait dix autres : la restriction reste
|
|
26
|
+
* formellement respectée, et le plan devient inutilisable. C'est le défaut classique du
|
|
27
|
+
* first-fit sur boîtes hétérogènes, et il est silencieux — l'objet lésé sort en `unplaced`
|
|
28
|
+
* sans que rien n'indique qu'une place lui était due.
|
|
21
29
|
*/
|
|
22
30
|
function ranger(items, bins, best) {
|
|
23
31
|
const packing = Object.fromEntries(bins.map((b) => [b.id, []]));
|
|
24
32
|
const load = Object.fromEntries(bins.map((b) => [b.id, 0]));
|
|
25
33
|
const unplaced = [];
|
|
26
34
|
const capOf = new Map(bins.map((b) => [b.id, b.capacity]));
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
35
|
+
/** Combien de contenants peuvent, en principe, accueillir cet objet (capacité ignorée). */
|
|
36
|
+
const liberte = (it) => bins.filter((b) => (!it.allowedBins || it.allowedBins.includes(b.id)) && b.capacity >= it.size).length;
|
|
37
|
+
// LE PLUS CONTRAINT D'ABORD, puis décroissant en taille.
|
|
38
|
+
// · la liberté d'abord : un objet qui n'a qu'un seul contenant possible doit choisir avant
|
|
39
|
+
// celui qui en a dix, sinon sa seule place lui est prise par quelqu'un qui avait le choix ;
|
|
40
|
+
// · le « decreasing » ensuite : à liberté égale, ranger les gros en premier fait toute la
|
|
41
|
+
// qualité de l'heuristique — en ordre d'arrivée, elle se dégrade nettement.
|
|
42
|
+
const tries = [...items].sort((a, b) => (liberte(a) - liberte(b)) || (b.size - a.size));
|
|
30
43
|
for (const it of tries) {
|
|
31
44
|
const candidats = bins.filter((b) => (!it.allowedBins || it.allowedBins.includes(b.id))
|
|
32
45
|
&& (load[b.id] + it.size) <= (capOf.get(b.id) ?? 0));
|
|
@@ -50,7 +63,33 @@ export function binPacking(problem) {
|
|
|
50
63
|
const strategy = problem.strategy ?? 'both';
|
|
51
64
|
const capMax = Math.max(1, ...bins.map((b) => b.capacity));
|
|
52
65
|
const total = items.reduce((s, i) => s + i.size, 0);
|
|
53
|
-
const
|
|
66
|
+
const capTotale = bins.reduce((s, b) => s + b.capacity, 0);
|
|
67
|
+
// ─── LA BORNE ─────────────────────────────────────────────────────────────────────────────
|
|
68
|
+
// Deux minorants valides ; on garde le plus fort. Le second est indispensable dès qu'une
|
|
69
|
+
// restriction existe : trois plats sans gluten de 3 plaques dans un seul four de 8 exigent
|
|
70
|
+
// deux fournées, quand bien même la capacité globale de la cuisine serait énorme.
|
|
71
|
+
const groupes = new Map();
|
|
72
|
+
for (const it of items) {
|
|
73
|
+
if (!it.allowedBins?.length)
|
|
74
|
+
continue;
|
|
75
|
+
const cle = [...it.allowedBins].sort().join('|');
|
|
76
|
+
const autorises = bins.filter((b) => it.allowedBins.includes(b.id));
|
|
77
|
+
const g = groupes.get(cle) ?? { taille: 0, capMax: Math.max(1, ...autorises.map((b) => b.capacity), 1) };
|
|
78
|
+
g.taille += it.size;
|
|
79
|
+
groupes.set(cle, g);
|
|
80
|
+
}
|
|
81
|
+
const borneRestreinte = [...groupes.values()].reduce((m, g) => Math.max(m, Math.ceil(g.taille / g.capMax)), 0);
|
|
82
|
+
const lowerBound = Math.max(Math.ceil(total / capMax), borneRestreinte);
|
|
83
|
+
// ─── LA CAUSE, DITE AVANT L'HEURISTIQUE ───────────────────────────────────────────────────
|
|
84
|
+
const causes = [];
|
|
85
|
+
if (total > capTotale)
|
|
86
|
+
causes.push(`capacité totale insuffisante : ${total} à ranger pour ${capTotale} disponible(s)`);
|
|
87
|
+
for (const [cle, g] of groupes) {
|
|
88
|
+
const capGroupe = bins.filter((b) => cle.split('|').includes(b.id)).reduce((s, b) => s + b.capacity, 0);
|
|
89
|
+
if (g.taille > capGroupe)
|
|
90
|
+
causes.push(`le groupe restreint à [${cle.split('|').join(', ')}] pèse ${g.taille} pour ${capGroupe} de capacité autorisée`);
|
|
91
|
+
}
|
|
92
|
+
const note = causes.length ? `aucun plan complet n’existe — ${causes.join(' ; ')}` : undefined;
|
|
54
93
|
const essais = [];
|
|
55
94
|
if (strategy === 'ffd' || strategy === 'both')
|
|
56
95
|
essais.push({ nom: 'ffd', r: ranger(items, bins, false) });
|
|
@@ -69,10 +108,13 @@ export function binPacking(problem) {
|
|
|
69
108
|
const fillRate = utilises.length
|
|
70
109
|
? utilises.reduce((s, b) => s + gagnant.r.load[b.id] / b.capacity, 0) / utilises.length
|
|
71
110
|
: 0;
|
|
72
|
-
|
|
111
|
+
const res = {
|
|
73
112
|
packing: gagnant.r.packing, load: gagnant.r.load, unplaced: gagnant.r.unplaced,
|
|
74
113
|
binsUsed: utilises.length, lowerBound, strategyUsed: gagnant.nom, fillRate,
|
|
75
114
|
};
|
|
115
|
+
if (note)
|
|
116
|
+
res.note = note;
|
|
117
|
+
return res;
|
|
76
118
|
}
|
|
77
119
|
export const binPackingDialect = {
|
|
78
120
|
name: 'bin-packing',
|
package/llms.txt
CHANGED
|
@@ -1,11 +1,24 @@
|
|
|
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 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.
|
|
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é.
|
|
6
12
|
|
|
7
|
-
- Version: 0.1
|
|
8
|
-
- Chemin: mostajs/mosta-ro-pla · Statut:
|
|
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).
|
|
9
22
|
- Renommé depuis « mosta-constraints » ; périmètre élargi PL + RO + stochastique.
|
|
10
23
|
|
|
11
24
|
## IMPLÉMENTÉ (réel, à jour) — architecture « un dialecte par algorithme » (façon ORM)
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@mostajs/ro-pla",
|
|
3
|
-
"version": "0.2.
|
|
3
|
+
"version": "0.2.2",
|
|
4
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).",
|
|
5
5
|
"author": "Dr Hamid MADANI <drmdh@msn.com>",
|
|
6
6
|
"license": "AGPL-3.0-or-later",
|
|
@@ -26,7 +26,9 @@
|
|
|
26
26
|
"build": "tsc -p tsconfig.json",
|
|
27
27
|
"test": "bash test-scripts/run-tests.sh",
|
|
28
28
|
"report": "npm run build && mjs-unit test-scripts/*.test.mjs --report=test-report.html --title=\"@mostajs/ro-pla — preuve de test\"",
|
|
29
|
-
"dbg": "npm run build && node --import ./node_modules/@mostajs/mjs-unit/register.mjs test-scripts/dbg.mjs"
|
|
29
|
+
"dbg": "npm run build && node --import ./node_modules/@mostajs/mjs-unit/register.mjs test-scripts/dbg.mjs",
|
|
30
|
+
"examples": "bash examples/run-all.sh",
|
|
31
|
+
"examples:html": "node examples/build-html.mjs"
|
|
30
32
|
},
|
|
31
33
|
"keywords": [
|
|
32
34
|
"operations-research",
|
|
@@ -41,6 +43,11 @@
|
|
|
41
43
|
"mostajs"
|
|
42
44
|
],
|
|
43
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",
|
|
44
51
|
"@mostajs/mjs-unit": "^0.3.0",
|
|
45
52
|
"@types/node": "^22.0.0",
|
|
46
53
|
"typescript": "^5.6.0"
|