@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 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** : ⚠️ **proposition / scaffold (0.0.1)** — non implémenté, périmètre à valider.
5
-
6
- **Programmation linéaire & recherche opérationnelle** (PL/RO) pour l'écosystème
7
- `@mostajs/*`. Modélise et résout des problèmes d'**optimisation**, de **satisfaction
8
- de contraintes** et de **modélisation stochastique** :
9
-
10
- - **Programmation linéaire (PL)** : optimiser une fonction objectif linéaire sous
11
- contraintes linéaires (**simplexe**).
12
- - **Programmation en nombres entiers / mixte (PLNE/MIP)** : variables entières,
13
- **branch & bound**.
14
- - **Décomposition de Dantzig-Wolfe** : résolution de **PL structurées à grande
15
- échelle** (blocs + contraintes liantes) par génération de colonnes.
16
- - **Programmation par contraintes (CSP)** : variables à domaines finis, contraintes
17
- (`allDifferent`, linéaires, `table`), **propagation + backtracking**.
18
- - **Chaînes de Markov** : matrices de transition, distribution stationnaire,
19
- régime transitoire — base de la **théorie des files d'attente** (M/M/c) pour
20
- estimer attentes et dimensionner les guichets.
21
- - **Métaheuristiques** (optimisation approchée de gros problèmes non linéaires /
22
- combinatoires) : **algorithme génétique**, recuit simulé, recherche tabou,
23
- essaims particulaires, colonies de fourmis.
24
- - **Apprentissage** (modèles prédictifs / surrogates / contrôle) : **réseaux de
25
- neurones** (perceptron multicouche), et — proposé — apprentissage par
26
- renforcement pour les politiques d'affectation/ordonnancement.
27
-
28
- Usages : **affectation** (tickets ↔ guichets, agents ↔ tâches), **ordonnancement /
29
- planning**, **allocation de ressources** (capacité, exclusion, précédence),
30
- **dimensionnement** et prévision d'attente (files M/M/c), **prévision d'affluence**
31
- (réseau de neurones sur l'historique des tickets).
32
-
33
- > ⚠️ **Note de conception** : les réseaux de neurones / apprentissage relèvent d'un
34
- > paradigme distinct (ML) de la RO exacte ; ils sont regroupés ici pour l'instant
35
- > mais pourraient être extraits dans un module frère (`@mostajs/ml`) si le périmètre
36
- > grossit. À trancher avant le 1.0.0.
37
-
38
- ## Familles de méthodes (carte)
39
-
40
- | Famille | Méthodes | Pour quoi |
41
- |---|---|---|
42
- | **Exact — PL/PLNE** | simplexe, branch & bound, branch & cut, **Dantzig-Wolfe** (génération de colonnes), Benders, relaxation lagrangienne | optimum prouvé, problèmes structurés |
43
- | **Exact — combinatoire** | CSP (propagation + backtracking), programmation dynamique, **flots de réseau** (max-flow, min-cost flow), **Hongrois** (affectation), plus courts chemins | affectation, routage, ordonnancement |
44
- | **Métaheuristiques** | **génétique**, recuit simulé, tabou, PSO, ACO, GRASP, **NSGA-II** (multi-objectif) | gros problèmes, bon « assez vite » |
45
- | **Stochastique** | **chaînes de Markov**, MDP, files M/M/c (Erlang), **simulation à événements discrets**, Monte-Carlo | incertitude, files, dimensionnement |
46
- | **Apprentissage** | **réseaux de neurones** (MLP), apprentissage par renforcement, optimisation bayésienne | prévision, politiques apprises |
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/gardes (inférence : « est-ce vrai ? »).
51
- `@mostajs/ro-pla` **optimise / résout / modélise** (« quelle solution satisfait les
52
- contraintes et optimise l'objectif ? », « quel est l'état stationnaire ? »).
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
- ## API envisagée (à figer en 0.1.0)
65
+ ## Éprouver
56
66
 
57
- ```js
58
- import { lp, model, markov } from "@mostajs/ro-pla";
59
-
60
- // Programmation linéaire : maximiser 3x + 2y
61
- const sol = lp()
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
- ## Périmètre prévu
85
-
86
- - **0.1.0** : PL (simplexe primal), CSP domaines finis (`allDifferent`, linéaires,
87
- `table`), propagation AC-3 + backtracking, chaînes de Markov (stationnaire,
88
- régime transitoire), `solve` / `solveAll`.
89
- - **0.2.0** : PLNE/MIP (branch & bound), optimisation CSP, heuristiques (MRV/LCV),
90
- files M/M/c (formules d'Erlang), **algorithme génétique** + recuit simulé.
91
- - **0.3.0** : **réseaux de neurones** (MLP : forward, rétropropagation), affectation
92
- par **algorithme hongrois** / flots de coût minimal.
93
- - **≥ 0.4.0** : **décomposition de Dantzig-Wolfe** (génération de colonnes),
94
- recherche tabou / PSO, **NSGA-II** (multi-objectif), simulation à événements
95
- discrets, contraintes globales (cumulative/scheduling), dualité / sensibilité.
96
-
97
- ## Reste à produire (DEVRULES §4 / §14)
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
- /** Borne inférieure du nombre de contenants : dit la distance à l'optimum. */
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
- // Décroissant : ranger d'abord les gros. C'est ce « decreasing » qui fait toute la qualité —
28
- // en ordre d'arrivée, l'heuristique se dégrade nettement.
29
- const tries = [...items].sort((a, b) => b.size - a.size);
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 lowerBound = Math.ceil(total / capMax);
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
- return {
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 + métaheuristiques + apprentissage :
4
- > simplexe, PLNE (branch & bound), Dantzig-Wolfe, CSP, chaînes de Markov / files M/M/c,
5
- > algorithme génétique, réseaux de neurones. STADE PROPOSITION (0.0.1) — API PRÉVUE, non figée.
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.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
8
- - Chemin: mostajs/mosta-ro-pla · Statut: amorcé — 11 dialectes livrés et testés (59/59).
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.0",
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"