@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
@@ -0,0 +1,151 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « list-scheduling » (ordonnancement sous ressources)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * PLACER DES TÂCHES DANS LE TEMPS QUAND LES RESSOURCES SONT LIMITÉES.
6
+ *
7
+ * `critical-path` répond « combien de temps au minimum ? » **en supposant les ressources
8
+ * infinies**. C'est utile, et c'est faux dès qu'on planifie pour de vrai : on n'a pas trois jurys
9
+ * disponibles le même matin, ni quatre salles.
10
+ *
11
+ * Ce dialecte prend le relais : mêmes tâches, mêmes précédences, **plus des ressources à capacité
12
+ * finie**. Il place chaque tâche au plus tôt compatible avec ses prédécesseurs ET la disponibilité
13
+ * des ressources qu'elle consomme.
14
+ *
15
+ * ─── LA RÈGLE DE PRIORITÉ CHANGE LE RÉSULTAT, ET C'EST UNE DÉCISION ─────────────────────────
16
+ * Quand plusieurs tâches sont prêtes et que la ressource ne suffit pas pour toutes, il faut
17
+ * choisir. Le choix n'est pas neutre :
18
+ * · `critical` — d'abord celles sans marge (défaut) : minimise le retard global ;
19
+ * · `lpt` — d'abord les longues : équilibre mieux la charge en fin de plan ;
20
+ * · `spt` — d'abord les courtes : libère vite, mais peut faire attendre l'essentiel ;
21
+ * · `order` — l'ordre donné : quand une règle administrative prime sur l'efficacité.
22
+ *
23
+ * Aucune ne domine les autres. Le dialecte rend `rule` employée, pour que la décision soit lisible.
24
+ *
25
+ * NP-DIFFICILE : `exact: false`. Le `lowerBound` rendu — le maximum entre le chemin critique et la
26
+ * charge totale divisée par la capacité — dit à quelle distance de l'optimum on se trouve.
27
+ */
28
+ import { criticalPath } from './critical-path.js';
29
+ export function listScheduling(problem) {
30
+ const tasks = problem.tasks ?? [];
31
+ const caps = problem.capacities ?? {};
32
+ const rule = problem.rule ?? 'critical';
33
+ const byId = new Map(tasks.map((t) => [t.id, t]));
34
+ // La priorité 'critical' se DÉRIVE du chemin critique — on compose le dialecte voisin plutôt
35
+ // que de recoder un calcul de marge. C'est exactement ce que la composition doit permettre.
36
+ let slack = {};
37
+ if (rule === 'critical') {
38
+ const cp = criticalPath({ activities: tasks.map((t) => ({ id: t.id, duration: t.duration, predecessors: t.predecessors })) });
39
+ slack = Object.fromEntries(Object.values(cp.timings).map((t) => [t.id, t.slack]));
40
+ }
41
+ const priorite = (t, i) => {
42
+ switch (rule) {
43
+ case 'lpt': return -t.duration;
44
+ case 'spt': return t.duration;
45
+ case 'order': return i;
46
+ default: return slack[t.id] ?? 0; // marge croissante : les critiques d'abord
47
+ }
48
+ };
49
+ const rang = new Map(tasks.map((t, i) => [t.id, priorite(t, i)]));
50
+ const fin = new Map();
51
+ const schedule = [];
52
+ // Profil de consommation : instant → ressource → quantité utilisée. Assez fin pour des durées
53
+ // entières, ce qui est le cas d'un planning de séances ou de soutenances.
54
+ const usage = new Map();
55
+ const dispo = (t, r) => (caps[r] ?? 0) - ((usage.get(t) ?? {})[r] ?? 0);
56
+ const horizon = problem.horizon ?? Math.max(1, tasks.reduce((s, t) => s + t.duration, 0) + 1);
57
+ const restantes = new Set(tasks.map((t) => t.id));
58
+ const unscheduled = [];
59
+ while (restantes.size) {
60
+ // Les prêtes : tous les prédécesseurs terminés.
61
+ const pretes = [...restantes].map((id) => byId.get(id))
62
+ .filter((t) => (t.predecessors ?? []).every((p) => !restantes.has(p) || !byId.has(p)))
63
+ .sort((a, b) => (rang.get(a.id) ?? 0) - (rang.get(b.id) ?? 0));
64
+ if (!pretes.length) {
65
+ unscheduled.push(...restantes);
66
+ break;
67
+ } // cycle ou dépendance absente
68
+ let placeeCeTour = false;
69
+ for (const t of pretes) {
70
+ const debutMin = Math.max(0, ...(t.predecessors ?? []).filter((p) => byId.has(p)).map((p) => fin.get(p) ?? 0));
71
+ const besoins = Object.entries(t.resources ?? {});
72
+ // Une tâche qui demande plus que la capacité TOTALE ne sera jamais plaçable : le dire tout
73
+ // de suite vaut mieux que balayer l'horizon en vain.
74
+ if (besoins.some(([r, q]) => q > (caps[r] ?? 0))) {
75
+ unscheduled.push(t.id);
76
+ restantes.delete(t.id);
77
+ placeeCeTour = true;
78
+ continue;
79
+ }
80
+ let debut = debutMin;
81
+ let place = false;
82
+ while (debut + t.duration <= horizon) {
83
+ let ok = true;
84
+ for (let x = debut; x < debut + t.duration && ok; x++) {
85
+ for (const [r, q] of besoins)
86
+ if (dispo(x, r) < q) {
87
+ ok = false;
88
+ break;
89
+ }
90
+ }
91
+ if (ok) {
92
+ place = true;
93
+ break;
94
+ }
95
+ debut += 1;
96
+ }
97
+ if (!place) {
98
+ unscheduled.push(t.id);
99
+ restantes.delete(t.id);
100
+ placeeCeTour = true;
101
+ continue;
102
+ }
103
+ for (let x = debut; x < debut + t.duration; x++) {
104
+ const u = usage.get(x) ?? {};
105
+ for (const [r, q] of besoins)
106
+ u[r] = (u[r] ?? 0) + q;
107
+ usage.set(x, u);
108
+ }
109
+ fin.set(t.id, debut + t.duration);
110
+ schedule.push({ id: t.id, start: debut, end: debut + t.duration });
111
+ restantes.delete(t.id);
112
+ placeeCeTour = true;
113
+ }
114
+ if (!placeeCeTour) {
115
+ unscheduled.push(...restantes);
116
+ break;
117
+ }
118
+ }
119
+ const makespan = Math.max(0, ...schedule.map((s) => s.end));
120
+ // Borne inférieure : ni le chemin critique ni la charge/capacité ne peuvent être battus.
121
+ const cp = criticalPath({ activities: tasks.map((t) => ({ id: t.id, duration: t.duration, predecessors: t.predecessors })) });
122
+ let borneCharge = 0;
123
+ for (const [r, cap] of Object.entries(caps)) {
124
+ if (!cap)
125
+ continue;
126
+ const charge = tasks.reduce((s, t) => s + (t.resources?.[r] ?? 0) * t.duration, 0);
127
+ borneCharge = Math.max(borneCharge, Math.ceil(charge / cap));
128
+ }
129
+ const lowerBound = Math.max(cp.makespan || 0, borneCharge);
130
+ const utilisation = {};
131
+ for (const [r, cap] of Object.entries(caps)) {
132
+ if (!cap || !makespan) {
133
+ utilisation[r] = 0;
134
+ continue;
135
+ }
136
+ let cumul = 0;
137
+ for (let x = 0; x < makespan; x++)
138
+ cumul += (usage.get(x) ?? {})[r] ?? 0;
139
+ utilisation[r] = cumul / (cap * makespan);
140
+ }
141
+ return { schedule: schedule.sort((a, b) => a.start - b.start), makespan, lowerBound, utilisation, rule, unscheduled };
142
+ }
143
+ export const listSchedulingDialect = {
144
+ name: 'list-scheduling',
145
+ kind: 'scheduling',
146
+ capabilities: { exact: false, online: false },
147
+ solve(problem) {
148
+ return listScheduling(problem);
149
+ },
150
+ };
151
+ //# sourceMappingURL=list-scheduling.js.map
@@ -0,0 +1,48 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « matching » (couplage maximal, GRAPHE GÉNÉRAL — Blossom)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * APPARIER DANS UN GRAPHE QUELCONQUE.
6
+ *
7
+ * `hungarian` ne traite que le **biparti** : deux ensembles disjoints, un coût pour chaque paire.
8
+ * Or beaucoup d'appariements ne se coupent pas en deux camps — apparier des étudiants entre eux
9
+ * pour un travail à deux, des jurés compatibles, des binômes de relecture. Le graphe y est
10
+ * quelconque, et il contient des **cycles impairs**.
11
+ *
12
+ * ─── POURQUOI LES CYCLES IMPAIRS CHANGENT TOUT ──────────────────────────────────────────────
13
+ * L'algorithme naïf par chemins augmentants — celui qui suffit en biparti — **échoue** sur un
14
+ * triangle : il ne trouve pas d'augmentation qui existe pourtant. Edmonds l'a résolu en
15
+ * CONTRACTANT chaque cycle impair (le « blossom ») en un sommet unique, puis en le développant à
16
+ * nouveau après augmentation.
17
+ *
18
+ * Écrire une version naïve et la déclarer « couplage général » serait un mensonge silencieux :
19
+ * elle rendrait un couplage sous-optimal sans jamais le signaler. D'où Blossom, en entier.
20
+ *
21
+ * Complexité O(V³). Couplage de CARDINALITÉ maximale (non pondéré) — pour un coût à minimiser sur
22
+ * un graphe biparti, `hungarian` reste le bon dialecte.
23
+ */
24
+ import type { SolverDialect } from '../types.js';
25
+ export interface MatchingProblem {
26
+ kind?: 'assignment';
27
+ nodes?: string[];
28
+ /** Arêtes NON ORIENTÉES. */
29
+ edges: Array<[string, string]> | Array<{
30
+ a: string;
31
+ b: string;
32
+ }>;
33
+ }
34
+ export interface MatchingSolution {
35
+ /** Les paires formées. */
36
+ pairs: Array<[string, string]>;
37
+ /** sommet → son partenaire. */
38
+ mate: Record<string, string | null>;
39
+ /** Nombre de paires. */
40
+ size: number;
41
+ /** Sommets restés seuls — jamais tus. */
42
+ unmatched: string[];
43
+ /** Le couplage est-il PARFAIT (tout le monde apparié) ? */
44
+ perfect: boolean;
45
+ }
46
+ export declare function matching(problem: MatchingProblem): MatchingSolution;
47
+ export declare const matchingDialect: SolverDialect<any, MatchingSolution>;
48
+ //# sourceMappingURL=matching.d.ts.map
@@ -0,0 +1,149 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « matching » (couplage maximal, GRAPHE GÉNÉRAL — Blossom)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * APPARIER DANS UN GRAPHE QUELCONQUE.
6
+ *
7
+ * `hungarian` ne traite que le **biparti** : deux ensembles disjoints, un coût pour chaque paire.
8
+ * Or beaucoup d'appariements ne se coupent pas en deux camps — apparier des étudiants entre eux
9
+ * pour un travail à deux, des jurés compatibles, des binômes de relecture. Le graphe y est
10
+ * quelconque, et il contient des **cycles impairs**.
11
+ *
12
+ * ─── POURQUOI LES CYCLES IMPAIRS CHANGENT TOUT ──────────────────────────────────────────────
13
+ * L'algorithme naïf par chemins augmentants — celui qui suffit en biparti — **échoue** sur un
14
+ * triangle : il ne trouve pas d'augmentation qui existe pourtant. Edmonds l'a résolu en
15
+ * CONTRACTANT chaque cycle impair (le « blossom ») en un sommet unique, puis en le développant à
16
+ * nouveau après augmentation.
17
+ *
18
+ * Écrire une version naïve et la déclarer « couplage général » serait un mensonge silencieux :
19
+ * elle rendrait un couplage sous-optimal sans jamais le signaler. D'où Blossom, en entier.
20
+ *
21
+ * Complexité O(V³). Couplage de CARDINALITÉ maximale (non pondéré) — pour un coût à minimiser sur
22
+ * un graphe biparti, `hungarian` reste le bon dialecte.
23
+ */
24
+ export function matching(problem) {
25
+ const brutes = (problem.edges ?? []);
26
+ const paires = brutes.map((e) => (Array.isArray(e) ? [e[0], e[1]] : [e.a, e.b]));
27
+ const noms = problem.nodes ?? [...new Set(paires.flat())];
28
+ const n = noms.length;
29
+ const idx = new Map(noms.map((x, i) => [x, i]));
30
+ const adj = noms.map(() => []);
31
+ for (const [a, b] of paires) {
32
+ const u = idx.get(a);
33
+ const v = idx.get(b);
34
+ if (u === undefined || v === undefined || u === v)
35
+ continue;
36
+ adj[u].push(v);
37
+ adj[v].push(u);
38
+ }
39
+ const mate = new Array(n).fill(-1);
40
+ const p = new Array(n).fill(-1); // parent dans l'arbre alternant
41
+ const base = new Array(n).fill(0); // base du blossom auquel appartient le sommet
42
+ const bloss = new Array(n).fill(false);
43
+ const used = new Array(n).fill(false);
44
+ /** Ancêtre commun le plus proche de a et b dans l'arbre alternant. */
45
+ function ancetreCommun(a, b) {
46
+ const vu = new Array(n).fill(false);
47
+ let x = a;
48
+ for (;;) {
49
+ x = base[x];
50
+ vu[x] = true;
51
+ if (mate[x] === -1)
52
+ break;
53
+ x = p[mate[x]];
54
+ }
55
+ let y = b;
56
+ for (;;) {
57
+ y = base[y];
58
+ if (vu[y])
59
+ return y;
60
+ y = p[mate[y]];
61
+ }
62
+ }
63
+ /** Marque tous les sommets du blossom entre `v` et la base `b`. */
64
+ function marquer(v, b, file) {
65
+ while (base[v] !== b) {
66
+ const m = mate[v];
67
+ bloss[base[v]] = true;
68
+ bloss[base[m]] = true;
69
+ const u = p[m];
70
+ if (base[u] !== b)
71
+ p[u] = m;
72
+ v = u;
73
+ }
74
+ }
75
+ /** Cherche un chemin augmentant depuis `racine`. Rend le sommet libre atteint, ou −1. */
76
+ function chercher(racine) {
77
+ used.fill(false);
78
+ p.fill(-1);
79
+ for (let i = 0; i < n; i++)
80
+ base[i] = i;
81
+ used[racine] = true;
82
+ const file = [racine];
83
+ for (let qi = 0; qi < file.length; qi++) {
84
+ const v = file[qi];
85
+ for (const to of adj[v]) {
86
+ if (base[v] === base[to] || mate[v] === to)
87
+ continue;
88
+ // ─── UN CYCLE IMPAIR : on le contracte ─────────────────────────────────────────────
89
+ if (to === racine || (mate[to] !== -1 && p[mate[to]] !== -1)) {
90
+ const b = ancetreCommun(v, to);
91
+ bloss.fill(false);
92
+ marquer(v, b, file);
93
+ marquer(to, b, file);
94
+ for (let i = 0; i < n; i++) {
95
+ if (bloss[base[i]]) {
96
+ base[i] = b;
97
+ if (!used[i]) {
98
+ used[i] = true;
99
+ file.push(i);
100
+ }
101
+ }
102
+ }
103
+ }
104
+ else if (p[to] === -1) {
105
+ p[to] = v;
106
+ if (mate[to] === -1)
107
+ return to; // sommet libre : chemin augmentant trouvé
108
+ const m = mate[to];
109
+ used[m] = true;
110
+ file.push(m);
111
+ }
112
+ }
113
+ }
114
+ return -1;
115
+ }
116
+ for (let v = 0; v < n; v++) {
117
+ if (mate[v] !== -1)
118
+ continue;
119
+ const u0 = chercher(v);
120
+ if (u0 === -1)
121
+ continue;
122
+ // Inversion le long du chemin augmentant : chaque arête couplée devient libre et l'inverse.
123
+ let u = u0;
124
+ while (u !== -1) {
125
+ const pv = p[u];
126
+ const ppv = mate[pv];
127
+ mate[u] = pv;
128
+ mate[pv] = u;
129
+ u = ppv;
130
+ }
131
+ }
132
+ const resPaires = [];
133
+ const mateOut = {};
134
+ for (let i = 0; i < n; i++) {
135
+ mateOut[noms[i]] = mate[i] === -1 ? null : noms[mate[i]];
136
+ if (mate[i] > i)
137
+ resPaires.push([noms[i], noms[mate[i]]]);
138
+ }
139
+ const unmatched = noms.filter((x, i) => mate[i] === -1);
140
+ return { pairs: resPaires, mate: mateOut, size: resPaires.length, unmatched, perfect: unmatched.length === 0 };
141
+ }
142
+ export const matchingDialect = {
143
+ name: 'matching',
144
+ kind: 'assignment',
145
+ // EXACT : Blossom rend un couplage de cardinalité MAXIMALE, y compris sur cycles impairs.
146
+ capabilities: { exact: true, online: false },
147
+ solve(problem) { return matching(problem); },
148
+ };
149
+ //# sourceMappingURL=matching.js.map
@@ -0,0 +1,51 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « max-flow » (Dinic) + coupe minimale
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * COMBIEN PEUT PASSER, ET OÙ ÇA COINCE.
6
+ *
7
+ * `min-cost-flow` route un volume DONNÉ au moindre coût. Ici la question est l'inverse : **quel
8
+ * volume maximal** le réseau peut-il écouler ? Et surtout — le théorème flot-max/coupe-min donne
9
+ * gratuitement la réponse à « **qu'est-ce qui limite** ? » : la coupe minimale est l'ensemble des
10
+ * arcs saturés qui, retirés, déconnectent la source du puits. C'est le goulot, nommé.
11
+ *
12
+ * C'est cette seconde réponse qui vaut : un chiffre de capacité n'aide pas, savoir QUELS arcs
13
+ * l'imposent permet d'agir.
14
+ *
15
+ * Dinic : O(V²·E) en général, O(E·√V) sur les réseaux unitaires — donc très rapide sur les
16
+ * problèmes d'affectation ramenés à un flot.
17
+ */
18
+ import type { SolverDialect } from '../types.js';
19
+ export interface FlowEdge {
20
+ from: string;
21
+ to: string;
22
+ capacity: number;
23
+ }
24
+ export interface MaxFlowProblem {
25
+ kind?: 'flow';
26
+ edges: FlowEdge[];
27
+ source: string;
28
+ sink: string;
29
+ }
30
+ export interface MaxFlowSolution {
31
+ maxFlow: number;
32
+ /** Flot effectivement poussé sur chaque arc d'origine. */
33
+ flows: Array<{
34
+ from: string;
35
+ to: string;
36
+ flow: number;
37
+ capacity: number;
38
+ saturated: boolean;
39
+ }>;
40
+ /** LA COUPE MINIMALE : les arcs qui limitent — c'est là qu'il faut investir. */
41
+ minCut: Array<{
42
+ from: string;
43
+ to: string;
44
+ capacity: number;
45
+ }>;
46
+ /** Côté source de la coupe. */
47
+ sourceSide: string[];
48
+ }
49
+ export declare function maxFlow(problem: MaxFlowProblem): MaxFlowSolution;
50
+ export declare const maxFlowDialect: SolverDialect<any, MaxFlowSolution>;
51
+ //# sourceMappingURL=max-flow.d.ts.map
@@ -0,0 +1,104 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « max-flow » (Dinic) + coupe minimale
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * COMBIEN PEUT PASSER, ET OÙ ÇA COINCE.
6
+ *
7
+ * `min-cost-flow` route un volume DONNÉ au moindre coût. Ici la question est l'inverse : **quel
8
+ * volume maximal** le réseau peut-il écouler ? Et surtout — le théorème flot-max/coupe-min donne
9
+ * gratuitement la réponse à « **qu'est-ce qui limite** ? » : la coupe minimale est l'ensemble des
10
+ * arcs saturés qui, retirés, déconnectent la source du puits. C'est le goulot, nommé.
11
+ *
12
+ * C'est cette seconde réponse qui vaut : un chiffre de capacité n'aide pas, savoir QUELS arcs
13
+ * l'imposent permet d'agir.
14
+ *
15
+ * Dinic : O(V²·E) en général, O(E·√V) sur les réseaux unitaires — donc très rapide sur les
16
+ * problèmes d'affectation ramenés à un flot.
17
+ */
18
+ export function maxFlow(problem) {
19
+ const noms = [...new Set(problem.edges.flatMap((e) => [e.from, e.to]).concat([problem.source, problem.sink]))];
20
+ const idx = new Map(noms.map((n, i) => [n, i]));
21
+ const g = noms.map(() => []);
22
+ // Chaque arc a son arc INVERSE de capacité 0 : c'est lui qui permet d'annuler un choix, et
23
+ // c'est ce qui rend l'algorithme exact plutôt que glouton.
24
+ problem.edges.forEach((e, k) => {
25
+ const u = idx.get(e.from);
26
+ const v = idx.get(e.to);
27
+ g[u].push({ to: v, cap: e.capacity, rev: g[v].length, orig: k });
28
+ g[v].push({ to: u, cap: 0, rev: g[u].length - 1, orig: -1 });
29
+ });
30
+ const s = idx.get(problem.source);
31
+ const t = idx.get(problem.sink);
32
+ let total = 0;
33
+ const niveau = new Array(noms.length).fill(-1);
34
+ const iter = new Array(noms.length).fill(0);
35
+ const bfs = () => {
36
+ niveau.fill(-1);
37
+ const file = [s];
38
+ niveau[s] = 0;
39
+ for (let i = 0; i < file.length; i++) {
40
+ const u = file[i];
41
+ for (const a of g[u])
42
+ if (a.cap > 0 && niveau[a.to] < 0) {
43
+ niveau[a.to] = niveau[u] + 1;
44
+ file.push(a.to);
45
+ }
46
+ }
47
+ return niveau[t] >= 0;
48
+ };
49
+ const dfs = (u, f) => {
50
+ if (u === t)
51
+ return f;
52
+ for (; iter[u] < g[u].length; iter[u]++) {
53
+ const a = g[u][iter[u]];
54
+ if (a.cap <= 0 || niveau[a.to] !== niveau[u] + 1)
55
+ continue;
56
+ const d = dfs(a.to, Math.min(f, a.cap));
57
+ if (d > 0) {
58
+ a.cap -= d;
59
+ g[a.to][a.rev].cap += d;
60
+ return d;
61
+ }
62
+ }
63
+ return 0;
64
+ };
65
+ while (bfs()) {
66
+ iter.fill(0);
67
+ for (;;) {
68
+ const f = dfs(s, Infinity);
69
+ if (f <= 0)
70
+ break;
71
+ total += f;
72
+ }
73
+ }
74
+ // Flot poussé = capacité initiale − capacité résiduelle.
75
+ const flows = problem.edges.map((e, k) => {
76
+ const u = idx.get(e.from);
77
+ const a = g[u].find((x) => x.orig === k);
78
+ const flow = e.capacity - a.cap;
79
+ return { from: e.from, to: e.to, flow, capacity: e.capacity, saturated: flow >= e.capacity && e.capacity > 0 };
80
+ });
81
+ // ─── LA COUPE MINIMALE ─────────────────────────────────────────────────────────────────────
82
+ // Les sommets encore atteignables depuis la source dans le graphe RÉSIDUEL forment le côté
83
+ // source. Les arcs qui en sortent vers l'autre côté sont saturés : ce sont eux le goulot.
84
+ const atteignable = new Array(noms.length).fill(false);
85
+ const file = [s];
86
+ atteignable[s] = true;
87
+ for (let i = 0; i < file.length; i++) {
88
+ for (const a of g[file[i]])
89
+ if (a.cap > 0 && !atteignable[a.to]) {
90
+ atteignable[a.to] = true;
91
+ file.push(a.to);
92
+ }
93
+ }
94
+ const minCut = problem.edges.filter((e) => atteignable[idx.get(e.from)] && !atteignable[idx.get(e.to)])
95
+ .map((e) => ({ from: e.from, to: e.to, capacity: e.capacity }));
96
+ return { maxFlow: total, flows, minCut, sourceSide: noms.filter((_, i) => atteignable[i]) };
97
+ }
98
+ export const maxFlowDialect = {
99
+ name: 'max-flow',
100
+ kind: 'flow',
101
+ capabilities: { exact: true, online: false },
102
+ solve(problem) { return maxFlow(problem); },
103
+ };
104
+ //# sourceMappingURL=max-flow.js.map
@@ -0,0 +1,66 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « pareto » (optimisation multi-objectif)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * PLUSIEURS OBJECTIFS QUI SE CONTREDISENT.
6
+ *
7
+ * Tous les autres dialectes optimisent UNE quantité. Or les décisions réelles en ont plusieurs, et
8
+ * elles s'opposent : apparier au mieux les encadrants **et** équilibrer leur charge ; remplir les
9
+ * salles **et** limiter les déplacements ; répartir les moyens entre universités **et** ne léser
10
+ * aucune.
11
+ *
12
+ * ─── CE QUE CE DIALECTE REFUSE DE FAIRE ─────────────────────────────────────────────────────
13
+ * Il ne rend PAS « la » solution. Il n'existe pas de meilleure solution quand les objectifs se
14
+ * contredisent : il existe un ENSEMBLE de compromis dont aucun n'est battu sur tous les tableaux à
15
+ * la fois — le front de Pareto. Choisir dedans est une décision politique, pas un calcul.
16
+ *
17
+ * Réduire d'emblée à une somme pondérée (« 60 % qualité, 40 % coût ») CACHE cette décision dans des
18
+ * coefficients que personne ne discute. Ici, on rend le front, et l'on propose un compromis
19
+ * SÉPARÉMENT, en disant comment il a été choisi.
20
+ *
21
+ * `compromise` est le point le plus proche de l'IDÉAL (le meilleur atteignable sur chaque objectif
22
+ * pris isolément, généralement inatteignable ensemble), après normalisation par l'étendue de chaque
23
+ * objectif — sans quoi un objectif exprimé en milliers écraserait un objectif exprimé en unités.
24
+ */
25
+ import type { SolverDialect } from '../types.js';
26
+ export interface ParetoCandidate {
27
+ id: string;
28
+ /** Une valeur par objectif, dans l'ordre de `senses`. */
29
+ objectives: number[];
30
+ label?: string;
31
+ /** Charge utile libre — l'appelant y remet ce qu'il veut retrouver. */
32
+ payload?: unknown;
33
+ }
34
+ export interface ParetoProblem {
35
+ kind?: 'multiobjective';
36
+ candidates: ParetoCandidate[];
37
+ /** 'min' ou 'max' pour CHAQUE objectif — obligatoire : il n'y a pas de défaut raisonnable. */
38
+ senses: Array<'min' | 'max'>;
39
+ /** Noms des objectifs, pour la lisibilité du résultat. */
40
+ names?: string[];
41
+ /** Poids facultatifs pour le compromis (défaut : égaux). */
42
+ weights?: number[];
43
+ }
44
+ export interface ParetoSolution {
45
+ /** Les non-dominés : le front. */
46
+ front: ParetoCandidate[];
47
+ /** Rang de non-domination (0 = front) — tri façon NSGA-II. */
48
+ ranks: Record<string, number>;
49
+ /** Distance de peuplement : grande = isolé, donc précieux pour la diversité. */
50
+ crowding: Record<string, number>;
51
+ /** Meilleure valeur atteignable sur chaque objectif, isolément. */
52
+ ideal: number[];
53
+ /** Pire valeur SUR LE FRONT — le point de référence du compromis. */
54
+ nadir: number[];
55
+ /** Le compromis proposé, et POURQUOI. */
56
+ compromise: {
57
+ id: string;
58
+ distance: number;
59
+ how: string;
60
+ } | null;
61
+ /** Combien de candidats sont dominés — dit si le problème était déjà tranché. */
62
+ dominatedCount: number;
63
+ }
64
+ export declare function pareto(problem: ParetoProblem): ParetoSolution;
65
+ export declare const paretoDialect: SolverDialect<any, ParetoSolution>;
66
+ //# sourceMappingURL=pareto.d.ts.map