@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 +50 -0
- package/README.md +77 -92
- package/dist/dialects/bin-packing.d.ts +22 -1
- package/dist/dialects/bin-packing.js +47 -5
- package/package.json +4 -2
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** :
|
|
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, 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
|
|
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/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@mostajs/ro-pla",
|
|
3
|
-
"version": "0.2.
|
|
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",
|