@mostajs/ro-pla 0.1.0 → 0.2.1

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.
Files changed (60) hide show
  1. package/CHANGELOG.md +89 -0
  2. package/README.md +77 -92
  3. package/dist/dialects/bin-packing.d.ts +79 -0
  4. package/dist/dialects/bin-packing.js +128 -0
  5. package/dist/dialects/critical-path.d.ts +64 -0
  6. package/dist/dialects/critical-path.js +113 -0
  7. package/dist/dialects/forecast.d.ts +61 -0
  8. package/dist/dialects/forecast.js +116 -0
  9. package/dist/dialects/genetic.d.ts +59 -0
  10. package/dist/dialects/genetic.js +92 -0
  11. package/dist/dialects/knapsack.d.ts +56 -0
  12. package/dist/dialects/knapsack.js +103 -0
  13. package/dist/dialects/list-scheduling.d.ts +65 -0
  14. package/dist/dialects/list-scheduling.js +151 -0
  15. package/dist/dialects/matching.d.ts +48 -0
  16. package/dist/dialects/matching.js +149 -0
  17. package/dist/dialects/max-flow.d.ts +51 -0
  18. package/dist/dialects/max-flow.js +104 -0
  19. package/dist/dialects/pareto.d.ts +66 -0
  20. package/dist/dialects/pareto.js +129 -0
  21. package/dist/dialects/shortest-path.d.ts +57 -0
  22. package/dist/dialects/shortest-path.js +147 -0
  23. package/dist/dialects/stable-matching.d.ts +63 -0
  24. package/dist/dialects/stable-matching.js +109 -0
  25. package/dist/dialects/tabu.d.ts +56 -0
  26. package/dist/dialects/tabu.js +95 -0
  27. package/dist/index.d.ts +12 -0
  28. package/dist/index.js +40 -0
  29. package/llms.txt +92 -2
  30. package/package.json +14 -4
  31. package/dist/dialects/anneal.d.ts.map +0 -1
  32. package/dist/dialects/anneal.js.map +0 -1
  33. package/dist/dialects/csp.d.ts.map +0 -1
  34. package/dist/dialects/csp.js.map +0 -1
  35. package/dist/dialects/hungarian.d.ts.map +0 -1
  36. package/dist/dialects/hungarian.js.map +0 -1
  37. package/dist/dialects/lagrangian.d.ts.map +0 -1
  38. package/dist/dialects/lagrangian.js.map +0 -1
  39. package/dist/dialects/markov.d.ts.map +0 -1
  40. package/dist/dialects/markov.js.map +0 -1
  41. package/dist/dialects/mdp.d.ts.map +0 -1
  42. package/dist/dialects/mdp.js.map +0 -1
  43. package/dist/dialects/milp.d.ts.map +0 -1
  44. package/dist/dialects/milp.js.map +0 -1
  45. package/dist/dialects/min-cost-flow.d.ts.map +0 -1
  46. package/dist/dialects/min-cost-flow.js.map +0 -1
  47. package/dist/dialects/mmc.d.ts.map +0 -1
  48. package/dist/dialects/mmc.js.map +0 -1
  49. package/dist/dialects/monte-carlo.d.ts.map +0 -1
  50. package/dist/dialects/monte-carlo.js.map +0 -1
  51. package/dist/dialects/simplex.d.ts.map +0 -1
  52. package/dist/dialects/simplex.js.map +0 -1
  53. package/dist/index.d.ts.map +0 -1
  54. package/dist/index.js.map +0 -1
  55. package/dist/lib/rng.d.ts.map +0 -1
  56. package/dist/lib/rng.js.map +0 -1
  57. package/dist/registry.d.ts.map +0 -1
  58. package/dist/registry.js.map +0 -1
  59. package/dist/types.d.ts.map +0 -1
  60. package/dist/types.js.map +0 -1
package/CHANGELOG.md ADDED
@@ -0,0 +1,89 @@
1
+ # CHANGELOG
2
+
3
+ ## [0.2.1] — 2026-09-06
4
+
5
+ ### Corrigé — `bin-packing` : deux défauts trouvés PAR L'USAGE
6
+
7
+ Les deux sont sortis de l'écriture de `examples/restaurant/04-fournees-bin-packing.mjs`, pas d'une
8
+ relecture. Le test existant (T-RO-40) prouvait qu'une restriction `allowedBins` était *respectée* —
9
+ jamais qu'elle était *servie en concurrence*. C'est par là que le défaut est passé.
10
+
11
+ - **Le plus contraint d'abord.** Le tri était purement décroissant en taille. Un objet restreint à
12
+ un seul contenant perdait sa seule place au profit d'un objet plus gros qui en avait dix autres :
13
+ la restriction restait formellement honorée, et le plan devenait inutilisable — l'objet lésé
14
+ sortait en `unplaced` sans que rien n'indique qu'une place lui était due. Le tri se fait désormais
15
+ par liberté croissante, puis par taille décroissante. *(T-RO-40a)*
16
+ - **`lowerBound` tient compte des restrictions.** La borne valait `⌈charge totale / capacité max⌉`
17
+ et ignorait les groupes cantonnés : trois plats sans gluten de 3 plaques dans un seul four de 8
18
+ exigent deux fournées, quelle que soit la capacité globale de la cuisine. *(T-RO-40b)*
19
+
20
+ ### Ajouté
21
+
22
+ - **`note`** sur `BinPackingSolution` : la CAUSE des objets non rangés quand elle est connue AVANT
23
+ toute heuristique — capacité totale insuffisante, ou groupe restreint plus lourd que ses
24
+ contenants autorisés. Sans elle, une liste d'`unplaced` laisse croire à une heuristique médiocre
25
+ alors qu'aucun plan n'existe. *(T-RO-40c)*
26
+ - **`examples/`** — 24 exemples exécutables (un par dialecte + une comparaison des trois
27
+ métaheuristiques), groupés par métier : restaurant, université, réseau, métaheuristiques. Chacun
28
+ se termine par des vérifications qui échouent bruyamment ; `bash examples/run-all.sh` en fait un
29
+ filet de régression. Plusieurs prouvent l'optimalité **par force brute** (120 permutations pour
30
+ `hungarian`, 180 affectations pour `min-cost-flow`, 40 320 tournées pour les métaheuristiques).
31
+ - **`examples/index.html`** — représentation graphique engendrée par `build-html.mjs`. Calculée et
32
+ non recopiée : chaque chiffre sort d'un appel réel au dialecte à la génération. Zéro dépendance,
33
+ palette validée pour la vision des couleurs dans les deux modes d'affichage.
34
+
35
+ ### Corrigé — le README annonçait un module qui n'existait plus
36
+
37
+ L'en-tête portait encore « **proposition / scaffold (0.0.1) — non implémenté, périmètre à valider** »
38
+ alors que 23 dialectes tournaient et que 111 essais étaient verts. Trois sections décrivaient une
39
+ feuille de route — « API envisagée (à figer en 0.1.0) », « Périmètre prévu », « Reste à produire » —
40
+ dont l'essentiel était fait. C'est le défaut d'un écran qui mentirait sur ce qu'il sait faire, et il
41
+ coûte le même prix : celui qui lit renonce, ou bâtit sur une promesse.
42
+
43
+ Réécrit sur des faits relevés dans le code, avec une section **« Ce que ce module ne fait PAS »** —
44
+ Dantzig-Wolfe, Benders, PSO, ACO, GRASP, NSGA-II en propre, réseaux de neurones, simulation à
45
+ événements discrets, contraintes cumulative, dualité/sensibilité. Tous annoncés dans la feuille de
46
+ route d'origine, aucun présent. Un module qui laisse croire coûte plus cher qu'un module qui manque.
47
+
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
+ > Le paquet npm n'embarque ni `examples/` ni les sources : `files` reste limité à `dist/`.
52
+
53
+ ## [0.2.0] — 2026-08-09
54
+
55
+ ### Ajouté — LOT 2 : douze dialectes (11 → 23)
56
+
57
+ Les deux `ProblemKind` **déclarés et vides** (`scheduling`, `multiobjective`) sont désormais servis.
58
+
59
+ - `stable-matching` — Gale-Shapley à capacités. Apparie des PRÉFÉRENCES classées, là où `hungarian`
60
+ minimise un coût chiffré. **Qui propose est une décision d'organisation** : le résultat est
61
+ optimal pour le proposant, le pire pour le disposant.
62
+ - `critical-path` — CPM/PERT : marges, cycles détectés, probabilité de tenir une échéance.
63
+ - `bin-packing` — FFD/BFD, contenants hétérogènes, `lowerBound` rendu.
64
+ - `pareto` — front, rangs, distance de peuplement, idéal/nadir. **Ne rend pas « la » solution** :
65
+ le compromis est proposé séparément, avec sa méthode.
66
+ - `list-scheduling` — ressources à capacité finie ; compose `critical-path` pour la priorité.
67
+ - `shortest-path` — Dijkstra + Bellman-Ford, bascule automatique sur poids négatif, cycle négatif
68
+ déclaré.
69
+ - `max-flow` — Dinic + **coupe minimale** : le goulot nommé, pas seulement chiffré.
70
+ - `matching` — Blossom, **graphe général**. L'algorithme naïf échoue en silence sur un triangle.
71
+ - `knapsack` — PD exacte 0/1 / bounded / unbounded, avec garde mémoire et refus motivé.
72
+ - `tabu` — recherche locale **avec mémoire** + critère d'aspiration.
73
+ - `genetic` — première métaheuristique **à population**, élitisme et diversité mesurée.
74
+ - `forecast` — lissage simple / Holt / Holt-Winters, **avec son erreur** (MAE/MAPE).
75
+
76
+ ### Principes tenus
77
+
78
+ Toute heuristique déclare `exact: false` **et** rend une borne ou une erreur : dire la distance à
79
+ l'optimum vaut mieux qu'une promesse invérifiable. Toute métaheuristique est **déterministe à
80
+ graine égale** — sans quoi `@mostajs/skill-library` ne pourrait juger aucune recette.
81
+
82
+ ### Corrigé pendant la mise au point
83
+
84
+ `forecast` **rétrogradait en silence** vers une méthode sans saison quand la série était trop
85
+ courte : l'appelant croyait tenir une prévision saisonnière. Refus motivé si la méthode est
86
+ demandée explicitement, `note` explicite en mode automatique.
87
+
88
+ 108 tests verts. Plan Dev+Test dans qatrax : 24 exigences, 24 réalisations, 49 tests.
89
+
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, tri par non-domination façon NSGA-II) |
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.
@@ -0,0 +1,79 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « bin-packing » (FFD / BFD, boîtes hétérogènes)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * RANGER DES OBJETS DANS DES CONTENANTS DE CAPACITÉ LIMITÉE.
6
+ *
7
+ * Chez nous : affecter des séances et des soutenances à des SALLES. Un amphithéâtre de 200 places
8
+ * et une salle de 30 ne sont pas interchangeables — d'où des boîtes **hétérogènes**, chacune avec
9
+ * sa capacité propre, et non le bin-packing scolaire à boîtes identiques.
10
+ *
11
+ * PROBLÈME NP-DIFFICILE : on ne rend PAS l'optimum, et il faut le dire. `capabilities.exact` est
12
+ * donc `false`. Mais la borne inférieure (somme des tailles / capacité maximale) est calculée et
13
+ * rendue : l'appelant sait à quelle distance de l'optimum théorique il se trouve, ce qui vaut mieux
14
+ * qu'une promesse invérifiable.
15
+ *
16
+ * Deux heuristiques, parce qu'elles ne se valent pas selon les données :
17
+ * · **FFD** (first-fit decreasing) — rapide, garantie 11/9·OPT+6/9 sur boîtes identiques ;
18
+ * · **BFD** (best-fit decreasing) — remplit au plus juste, souvent meilleur quand les capacités
19
+ * sont très inégales.
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.
29
+ */
30
+ import type { SolverDialect } from '../types.js';
31
+ export interface PackItem {
32
+ id: string;
33
+ size: number;
34
+ /** Ne peut aller que dans ces contenants (facultatif) — matériel, accessibilité… */
35
+ allowedBins?: string[];
36
+ label?: string;
37
+ }
38
+ export interface Bin {
39
+ id: string;
40
+ capacity: number;
41
+ label?: string;
42
+ }
43
+ export interface BinPackingProblem {
44
+ kind?: 'scheduling';
45
+ items: PackItem[];
46
+ bins: Bin[];
47
+ /** 'ffd' | 'bfd' | 'both' (défaut) */
48
+ strategy?: 'ffd' | 'bfd' | 'both';
49
+ }
50
+ export interface BinPackingSolution {
51
+ /** contenant → objets rangés */
52
+ packing: Record<string, string[]>;
53
+ /** charge par contenant */
54
+ load: Record<string, number>;
55
+ /** Objets qu'AUCUN contenant ne peut prendre — jamais tus. */
56
+ unplaced: string[];
57
+ binsUsed: number;
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
+ */
66
+ lowerBound: number;
67
+ strategyUsed: 'ffd' | 'bfd';
68
+ /** Taux de remplissage moyen des contenants utilisés. */
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;
76
+ }
77
+ export declare function binPacking(problem: BinPackingProblem): BinPackingSolution;
78
+ export declare const binPackingDialect: SolverDialect<any, BinPackingSolution>;
79
+ //# sourceMappingURL=bin-packing.d.ts.map
@@ -0,0 +1,128 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « bin-packing » (FFD / BFD, boîtes hétérogènes)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * RANGER DES OBJETS DANS DES CONTENANTS DE CAPACITÉ LIMITÉE.
6
+ *
7
+ * Chez nous : affecter des séances et des soutenances à des SALLES. Un amphithéâtre de 200 places
8
+ * et une salle de 30 ne sont pas interchangeables — d'où des boîtes **hétérogènes**, chacune avec
9
+ * sa capacité propre, et non le bin-packing scolaire à boîtes identiques.
10
+ *
11
+ * PROBLÈME NP-DIFFICILE : on ne rend PAS l'optimum, et il faut le dire. `capabilities.exact` est
12
+ * donc `false`. Mais la borne inférieure (somme des tailles / capacité maximale) est calculée et
13
+ * rendue : l'appelant sait à quelle distance de l'optimum théorique il se trouve, ce qui vaut mieux
14
+ * qu'une promesse invérifiable.
15
+ *
16
+ * Deux heuristiques, parce qu'elles ne se valent pas selon les données :
17
+ * · **FFD** (first-fit decreasing) — rapide, garantie 11/9·OPT+6/9 sur boîtes identiques ;
18
+ * · **BFD** (best-fit decreasing) — remplit au plus juste, souvent meilleur quand les capacités
19
+ * sont très inégales.
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.
29
+ */
30
+ function ranger(items, bins, best) {
31
+ const packing = Object.fromEntries(bins.map((b) => [b.id, []]));
32
+ const load = Object.fromEntries(bins.map((b) => [b.id, 0]));
33
+ const unplaced = [];
34
+ const capOf = new Map(bins.map((b) => [b.id, b.capacity]));
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));
43
+ for (const it of tries) {
44
+ const candidats = bins.filter((b) => (!it.allowedBins || it.allowedBins.includes(b.id))
45
+ && (load[b.id] + it.size) <= (capOf.get(b.id) ?? 0));
46
+ if (!candidats.length) {
47
+ unplaced.push(it.id);
48
+ continue;
49
+ }
50
+ // FFD : le premier qui va. BFD : celui qui laissera le moins de place perdue.
51
+ const choisi = best
52
+ ? candidats.reduce((m, b) => (((capOf.get(b.id) ?? 0) - load[b.id] - it.size)
53
+ < ((capOf.get(m.id) ?? 0) - load[m.id] - it.size) ? b : m))
54
+ : candidats[0];
55
+ packing[choisi.id].push(it.id);
56
+ load[choisi.id] += it.size;
57
+ }
58
+ return { packing, load, unplaced };
59
+ }
60
+ export function binPacking(problem) {
61
+ const items = problem.items ?? [];
62
+ const bins = problem.bins ?? [];
63
+ const strategy = problem.strategy ?? 'both';
64
+ const capMax = Math.max(1, ...bins.map((b) => b.capacity));
65
+ const total = items.reduce((s, i) => s + i.size, 0);
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;
93
+ const essais = [];
94
+ if (strategy === 'ffd' || strategy === 'both')
95
+ essais.push({ nom: 'ffd', r: ranger(items, bins, false) });
96
+ if (strategy === 'bfd' || strategy === 'both')
97
+ essais.push({ nom: 'bfd', r: ranger(items, bins, true) });
98
+ // On choisit d'abord sur le nombre d'objets NON PLACÉS — laisser une soutenance sans salle est
99
+ // pire qu'occuper un amphithéâtre de plus.
100
+ const gagnant = essais.reduce((m, e) => {
101
+ const nonPlaces = e.r.unplaced.length - m.r.unplaced.length;
102
+ if (nonPlaces !== 0)
103
+ return nonPlaces < 0 ? e : m;
104
+ const used = (x) => Object.values(x.r.load).filter((l) => l > 0).length;
105
+ return used(e) < used(m) ? e : m;
106
+ });
107
+ const utilises = bins.filter((b) => gagnant.r.load[b.id] > 0);
108
+ const fillRate = utilises.length
109
+ ? utilises.reduce((s, b) => s + gagnant.r.load[b.id] / b.capacity, 0) / utilises.length
110
+ : 0;
111
+ const res = {
112
+ packing: gagnant.r.packing, load: gagnant.r.load, unplaced: gagnant.r.unplaced,
113
+ binsUsed: utilises.length, lowerBound, strategyUsed: gagnant.nom, fillRate,
114
+ };
115
+ if (note)
116
+ res.note = note;
117
+ return res;
118
+ }
119
+ export const binPackingDialect = {
120
+ name: 'bin-packing',
121
+ kind: 'scheduling',
122
+ // NP-difficile : heuristique assumée. La borne inférieure rendue dit la distance à l'optimum.
123
+ capabilities: { exact: false, online: false },
124
+ solve(problem) {
125
+ return binPacking(problem);
126
+ },
127
+ };
128
+ //# sourceMappingURL=bin-packing.js.map
@@ -0,0 +1,64 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « critical-path » (CPM / PERT)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * LE CHEMIN CRITIQUE D'UN RÉSEAU D'ACTIVITÉS.
6
+ *
7
+ * Un parcours à étapes conditionnées EST un réseau d'activités : chaque étape a une durée et des
8
+ * prédécesseurs. Le chemin critique répond à deux questions qu'aucun autre dialecte ne pose :
9
+ * · **quelle est la date au plus tôt de la fin** — donc : ce dossier peut-il être diplômé cette
10
+ * année, ou est-ce déjà arithmétiquement impossible ?
11
+ * · **où est la MARGE** — quelles activités peuvent glisser sans rien retarder, et lesquelles
12
+ * n'en ont aucune. Une activité de marge nulle est **critique** : tout retard s'y propage.
13
+ *
14
+ * C'est ce qui manque à un suivi de promotion : il dit *ce qui bloque maintenant*, pas *ce qui va
15
+ * bloquer*.
16
+ *
17
+ * PERT : si `optimistic`/`pessimistic` sont fournis, la durée retenue est l'espérance bêta
18
+ * (o + 4m + p)/6, et la variance ((p−o)/6)² permet de dire la probabilité de tenir une échéance.
19
+ */
20
+ import type { SolverDialect } from '../types.js';
21
+ export interface Activity {
22
+ id: string;
23
+ /** Durée la plus probable (ou durée certaine si o/p absents). */
24
+ duration: number;
25
+ predecessors?: string[];
26
+ /** PERT — durées optimiste et pessimiste. */
27
+ optimistic?: number;
28
+ pessimistic?: number;
29
+ label?: string;
30
+ }
31
+ export interface CriticalPathProblem {
32
+ kind?: 'scheduling';
33
+ activities: Activity[];
34
+ /** Échéance à tenir, pour calculer la probabilité PERT (facultatif). */
35
+ deadline?: number;
36
+ }
37
+ export interface ActivityTiming {
38
+ id: string;
39
+ duration: number;
40
+ earlyStart: number;
41
+ earlyFinish: number;
42
+ lateStart: number;
43
+ lateFinish: number;
44
+ /** Marge totale : de combien on peut glisser sans retarder la FIN. 0 = critique. */
45
+ slack: number;
46
+ critical: boolean;
47
+ variance: number;
48
+ }
49
+ export interface CriticalPathSolution {
50
+ /** Durée minimale du projet. */
51
+ makespan: number;
52
+ /** Les activités du chemin critique, dans l'ordre. */
53
+ criticalPath: string[];
54
+ timings: Record<string, ActivityTiming>;
55
+ /** Écart-type PERT du projet (somme des variances des activités critiques). */
56
+ stdDev: number;
57
+ /** P(fin ≤ deadline), si `deadline` est fourni — approximation normale. */
58
+ probability?: number;
59
+ /** Cycle détecté : le réseau est invalide, on le DIT au lieu de boucler. */
60
+ cycle?: string[];
61
+ }
62
+ export declare function criticalPath(problem: CriticalPathProblem): CriticalPathSolution;
63
+ export declare const criticalPathDialect: SolverDialect<any, CriticalPathSolution>;
64
+ //# sourceMappingURL=critical-path.d.ts.map