@mostajs/ro-pla 0.2.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.
package/CHANGELOG.md CHANGED
@@ -1,5 +1,55 @@
1
1
  # CHANGELOG
2
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
+
3
53
  ## [0.2.0] — 2026-08-09
4
54
 
5
55
  ### 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, 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.
@@ -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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@mostajs/ro-pla",
3
- "version": "0.2.0",
3
+ "version": "0.2.1",
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",