@mostajs/ro-pla 0.1.0 → 0.2.0
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 +39 -0
- package/dist/dialects/bin-packing.d.ts +58 -0
- package/dist/dialects/bin-packing.js +86 -0
- package/dist/dialects/critical-path.d.ts +64 -0
- package/dist/dialects/critical-path.js +113 -0
- package/dist/dialects/forecast.d.ts +61 -0
- package/dist/dialects/forecast.js +116 -0
- package/dist/dialects/genetic.d.ts +59 -0
- package/dist/dialects/genetic.js +92 -0
- package/dist/dialects/knapsack.d.ts +56 -0
- package/dist/dialects/knapsack.js +103 -0
- package/dist/dialects/list-scheduling.d.ts +65 -0
- package/dist/dialects/list-scheduling.js +151 -0
- package/dist/dialects/matching.d.ts +48 -0
- package/dist/dialects/matching.js +149 -0
- package/dist/dialects/max-flow.d.ts +51 -0
- package/dist/dialects/max-flow.js +104 -0
- package/dist/dialects/pareto.d.ts +66 -0
- package/dist/dialects/pareto.js +129 -0
- package/dist/dialects/shortest-path.d.ts +57 -0
- package/dist/dialects/shortest-path.js +147 -0
- package/dist/dialects/stable-matching.d.ts +63 -0
- package/dist/dialects/stable-matching.js +109 -0
- package/dist/dialects/tabu.d.ts +56 -0
- package/dist/dialects/tabu.js +95 -0
- package/dist/index.d.ts +12 -0
- package/dist/index.js +40 -0
- package/llms.txt +92 -2
- package/package.json +11 -3
- package/dist/dialects/anneal.d.ts.map +0 -1
- package/dist/dialects/anneal.js.map +0 -1
- package/dist/dialects/csp.d.ts.map +0 -1
- package/dist/dialects/csp.js.map +0 -1
- package/dist/dialects/hungarian.d.ts.map +0 -1
- package/dist/dialects/hungarian.js.map +0 -1
- package/dist/dialects/lagrangian.d.ts.map +0 -1
- package/dist/dialects/lagrangian.js.map +0 -1
- package/dist/dialects/markov.d.ts.map +0 -1
- package/dist/dialects/markov.js.map +0 -1
- package/dist/dialects/mdp.d.ts.map +0 -1
- package/dist/dialects/mdp.js.map +0 -1
- package/dist/dialects/milp.d.ts.map +0 -1
- package/dist/dialects/milp.js.map +0 -1
- package/dist/dialects/min-cost-flow.d.ts.map +0 -1
- package/dist/dialects/min-cost-flow.js.map +0 -1
- package/dist/dialects/mmc.d.ts.map +0 -1
- package/dist/dialects/mmc.js.map +0 -1
- package/dist/dialects/monte-carlo.d.ts.map +0 -1
- package/dist/dialects/monte-carlo.js.map +0 -1
- package/dist/dialects/simplex.d.ts.map +0 -1
- package/dist/dialects/simplex.js.map +0 -1
- package/dist/index.d.ts.map +0 -1
- package/dist/index.js.map +0 -1
- package/dist/lib/rng.d.ts.map +0 -1
- package/dist/lib/rng.js.map +0 -1
- package/dist/registry.d.ts.map +0 -1
- package/dist/registry.js.map +0 -1
- package/dist/types.d.ts.map +0 -1
- package/dist/types.js.map +0 -1
|
@@ -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
|
|
@@ -0,0 +1,129 @@
|
|
|
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
|
+
/** `a` domine-t-il `b` ? Au moins aussi bon partout, strictement meilleur quelque part. */
|
|
26
|
+
function domine(a, b, senses) {
|
|
27
|
+
let strictementMieux = false;
|
|
28
|
+
for (let i = 0; i < a.length; i++) {
|
|
29
|
+
const mieux = senses[i] === 'min' ? a[i] < b[i] : a[i] > b[i];
|
|
30
|
+
const pire = senses[i] === 'min' ? a[i] > b[i] : a[i] < b[i];
|
|
31
|
+
if (pire)
|
|
32
|
+
return false;
|
|
33
|
+
if (mieux)
|
|
34
|
+
strictementMieux = true;
|
|
35
|
+
}
|
|
36
|
+
return strictementMieux;
|
|
37
|
+
}
|
|
38
|
+
export function pareto(problem) {
|
|
39
|
+
const cands = problem.candidates ?? [];
|
|
40
|
+
const senses = problem.senses ?? [];
|
|
41
|
+
const m = senses.length;
|
|
42
|
+
if (!cands.length || !m) {
|
|
43
|
+
return { front: [], ranks: {}, crowding: {}, ideal: [], nadir: [], compromise: null, dominatedCount: 0 };
|
|
44
|
+
}
|
|
45
|
+
// ─── TRI PAR NON-DOMINATION (NSGA-II) ──────────────────────────────────────────────────────
|
|
46
|
+
// On ne se contente pas du front : les rangs suivants disent « à quelle profondeur » se trouve
|
|
47
|
+
// un candidat écarté. Utile quand le front est vide de solutions praticables et qu'il faut
|
|
48
|
+
// descendre d'un cran.
|
|
49
|
+
const ranks = {};
|
|
50
|
+
let restants = [...cands];
|
|
51
|
+
let rang = 0;
|
|
52
|
+
let front = [];
|
|
53
|
+
while (restants.length) {
|
|
54
|
+
const nonDomines = restants.filter((c) => !restants.some((o) => o.id !== c.id && domine(o.objectives, c.objectives, senses)));
|
|
55
|
+
if (!nonDomines.length)
|
|
56
|
+
break; // sécurité : ne jamais boucler
|
|
57
|
+
for (const c of nonDomines)
|
|
58
|
+
ranks[c.id] = rang;
|
|
59
|
+
if (rang === 0)
|
|
60
|
+
front = nonDomines;
|
|
61
|
+
const ids = new Set(nonDomines.map((c) => c.id));
|
|
62
|
+
restants = restants.filter((c) => !ids.has(c.id));
|
|
63
|
+
rang += 1;
|
|
64
|
+
}
|
|
65
|
+
// ─── DISTANCE DE PEUPLEMENT ────────────────────────────────────────────────────────────────
|
|
66
|
+
// Sur un front, deux solutions très proches apportent la même information. La distance de
|
|
67
|
+
// peuplement mesure l'isolement : un point isolé représente un compromis que rien d'autre
|
|
68
|
+
// n'offre. Les extrêmes sont à l'infini — ils sont irremplaçables par construction.
|
|
69
|
+
const crowding = Object.fromEntries(front.map((c) => [c.id, 0]));
|
|
70
|
+
for (let i = 0; i < m; i++) {
|
|
71
|
+
const tri = [...front].sort((a, b) => a.objectives[i] - b.objectives[i]);
|
|
72
|
+
if (tri.length < 2)
|
|
73
|
+
break;
|
|
74
|
+
crowding[tri[0].id] = Infinity;
|
|
75
|
+
crowding[tri[tri.length - 1].id] = Infinity;
|
|
76
|
+
const etendue = tri[tri.length - 1].objectives[i] - tri[0].objectives[i] || 1;
|
|
77
|
+
for (let k = 1; k < tri.length - 1; k++) {
|
|
78
|
+
crowding[tri[k].id] += (tri[k + 1].objectives[i] - tri[k - 1].objectives[i]) / etendue;
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
// Idéal (le meilleur atteignable, objectif par objectif) et nadir (le pire SUR LE FRONT).
|
|
82
|
+
const ideal = [];
|
|
83
|
+
const nadir = [];
|
|
84
|
+
for (let i = 0; i < m; i++) {
|
|
85
|
+
const vals = front.map((c) => c.objectives[i]);
|
|
86
|
+
ideal.push(senses[i] === 'min' ? Math.min(...vals) : Math.max(...vals));
|
|
87
|
+
nadir.push(senses[i] === 'min' ? Math.max(...vals) : Math.min(...vals));
|
|
88
|
+
}
|
|
89
|
+
// ─── LE COMPROMIS ──────────────────────────────────────────────────────────────────────────
|
|
90
|
+
// Distance à l'idéal, NORMALISÉE par l'étendue de chaque objectif. Sans normalisation, un
|
|
91
|
+
// objectif exprimé en milliers de dinars écraserait un objectif exprimé en nombre de personnes,
|
|
92
|
+
// et le « compromis » ne serait que le meilleur du premier.
|
|
93
|
+
const poids = problem.weights ?? new Array(m).fill(1);
|
|
94
|
+
let compromise = null;
|
|
95
|
+
if (front.length) {
|
|
96
|
+
let meilleur = front[0];
|
|
97
|
+
let meilleureD = Infinity;
|
|
98
|
+
for (const c of front) {
|
|
99
|
+
let d = 0;
|
|
100
|
+
for (let i = 0; i < m; i++) {
|
|
101
|
+
const etendue = Math.abs(nadir[i] - ideal[i]) || 1;
|
|
102
|
+
const ecart = Math.abs(c.objectives[i] - ideal[i]) / etendue;
|
|
103
|
+
d += (poids[i] ?? 1) * ecart * ecart;
|
|
104
|
+
}
|
|
105
|
+
d = Math.sqrt(d);
|
|
106
|
+
if (d < meilleureD) {
|
|
107
|
+
meilleureD = d;
|
|
108
|
+
meilleur = c;
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
compromise = {
|
|
112
|
+
id: meilleur.id,
|
|
113
|
+
distance: meilleureD,
|
|
114
|
+
how: 'point du front le plus proche de l’idéal, distance euclidienne pondérée sur objectifs normalisés',
|
|
115
|
+
};
|
|
116
|
+
}
|
|
117
|
+
return { front, ranks, crowding, ideal, nadir, compromise, dominatedCount: cands.length - front.length };
|
|
118
|
+
}
|
|
119
|
+
export const paretoDialect = {
|
|
120
|
+
name: 'pareto',
|
|
121
|
+
kind: 'multiobjective',
|
|
122
|
+
// EXACT : le front de Pareto d'un ensemble FINI de candidats est calculé exactement. Ce n'est
|
|
123
|
+
// pas le front du problème continu sous-jacent — le dialecte trie ce qu'on lui donne.
|
|
124
|
+
capabilities: { exact: true, online: false },
|
|
125
|
+
solve(problem) {
|
|
126
|
+
return pareto(problem);
|
|
127
|
+
},
|
|
128
|
+
};
|
|
129
|
+
//# sourceMappingURL=pareto.js.map
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* @mostajs/ro-pla — Dialecte « shortest-path » (Dijkstra + Bellman-Ford)
|
|
3
|
+
* @author Dr Hamid MADANI <drmdh@msn.com>
|
|
4
|
+
*
|
|
5
|
+
* LE PLUS COURT CHEMIN DANS UN GRAPHE VALUÉ.
|
|
6
|
+
*
|
|
7
|
+
* `min-cost-flow` répond à « comment router un VOLUME au moindre coût ». Ce n'est pas la même
|
|
8
|
+
* question que « quel est le chemin le moins coûteux d'ici à là » — et l'employer pour cela oblige
|
|
9
|
+
* à modéliser un flot d'une unité, ce qui masque l'intention.
|
|
10
|
+
*
|
|
11
|
+
* DEUX ALGORITHMES, ET LE CHOIX N'EST PAS UN RÉGLAGE :
|
|
12
|
+
* · **Dijkstra** — O((V+E)·log V), exige des poids POSITIFS OU NULS. C'est le cas courant :
|
|
13
|
+
* distances, durées, coûts.
|
|
14
|
+
* · **Bellman-Ford** — O(V·E), accepte les poids NÉGATIFS et **détecte les cycles négatifs**.
|
|
15
|
+
* Un cycle négatif signifie qu'il n'existe pas de plus court chemin : on peut tourner
|
|
16
|
+
* indéfiniment en gagnant. Le dire vaut mieux que rendre un nombre absurde.
|
|
17
|
+
*
|
|
18
|
+
* `auto` (défaut) choisit : Bellman-Ford dès qu'un poids négatif apparaît, Dijkstra sinon.
|
|
19
|
+
*
|
|
20
|
+
* Le tas binaire est écrit ici plutôt qu'importé : le module est à ZÉRO DÉPENDANCE, et une file de
|
|
21
|
+
* priorité tient en trente lignes.
|
|
22
|
+
*/
|
|
23
|
+
import type { SolverDialect } from '../types.js';
|
|
24
|
+
export interface Edge {
|
|
25
|
+
from: string;
|
|
26
|
+
to: string;
|
|
27
|
+
weight: number;
|
|
28
|
+
}
|
|
29
|
+
export interface ShortestPathProblem {
|
|
30
|
+
kind?: 'flow';
|
|
31
|
+
nodes?: string[];
|
|
32
|
+
edges: Edge[];
|
|
33
|
+
source: string;
|
|
34
|
+
/** Cible facultative : si absente, on calcule vers TOUS les sommets. */
|
|
35
|
+
target?: string;
|
|
36
|
+
/** Le graphe est-il non orienté ? (défaut : orienté) */
|
|
37
|
+
undirected?: boolean;
|
|
38
|
+
algorithm?: 'auto' | 'dijkstra' | 'bellman-ford';
|
|
39
|
+
}
|
|
40
|
+
export interface ShortestPathSolution {
|
|
41
|
+
/** sommet → distance depuis la source (`Infinity` si inatteignable). */
|
|
42
|
+
distances: Record<string, number>;
|
|
43
|
+
/** sommet → prédécesseur sur le plus court chemin. */
|
|
44
|
+
predecessors: Record<string, string | null>;
|
|
45
|
+
/** Le chemin vers `target`, s'il a été demandé et qu'il existe. */
|
|
46
|
+
path?: string[];
|
|
47
|
+
/** Coût du chemin vers `target`. */
|
|
48
|
+
cost?: number;
|
|
49
|
+
algorithm: 'dijkstra' | 'bellman-ford';
|
|
50
|
+
/** Cycle de poids négatif détecté : il n'existe alors PAS de plus court chemin. */
|
|
51
|
+
negativeCycle?: boolean;
|
|
52
|
+
/** Sommets qu'aucun chemin n'atteint — dits, jamais tus. */
|
|
53
|
+
unreachable: string[];
|
|
54
|
+
}
|
|
55
|
+
export declare function shortestPath(problem: ShortestPathProblem): ShortestPathSolution;
|
|
56
|
+
export declare const shortestPathDialect: SolverDialect<any, ShortestPathSolution>;
|
|
57
|
+
//# sourceMappingURL=shortest-path.d.ts.map
|
|
@@ -0,0 +1,147 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* @mostajs/ro-pla — Dialecte « shortest-path » (Dijkstra + Bellman-Ford)
|
|
3
|
+
* @author Dr Hamid MADANI <drmdh@msn.com>
|
|
4
|
+
*
|
|
5
|
+
* LE PLUS COURT CHEMIN DANS UN GRAPHE VALUÉ.
|
|
6
|
+
*
|
|
7
|
+
* `min-cost-flow` répond à « comment router un VOLUME au moindre coût ». Ce n'est pas la même
|
|
8
|
+
* question que « quel est le chemin le moins coûteux d'ici à là » — et l'employer pour cela oblige
|
|
9
|
+
* à modéliser un flot d'une unité, ce qui masque l'intention.
|
|
10
|
+
*
|
|
11
|
+
* DEUX ALGORITHMES, ET LE CHOIX N'EST PAS UN RÉGLAGE :
|
|
12
|
+
* · **Dijkstra** — O((V+E)·log V), exige des poids POSITIFS OU NULS. C'est le cas courant :
|
|
13
|
+
* distances, durées, coûts.
|
|
14
|
+
* · **Bellman-Ford** — O(V·E), accepte les poids NÉGATIFS et **détecte les cycles négatifs**.
|
|
15
|
+
* Un cycle négatif signifie qu'il n'existe pas de plus court chemin : on peut tourner
|
|
16
|
+
* indéfiniment en gagnant. Le dire vaut mieux que rendre un nombre absurde.
|
|
17
|
+
*
|
|
18
|
+
* `auto` (défaut) choisit : Bellman-Ford dès qu'un poids négatif apparaît, Dijkstra sinon.
|
|
19
|
+
*
|
|
20
|
+
* Le tas binaire est écrit ici plutôt qu'importé : le module est à ZÉRO DÉPENDANCE, et une file de
|
|
21
|
+
* priorité tient en trente lignes.
|
|
22
|
+
*/
|
|
23
|
+
/** File de priorité minimale — tas binaire, zéro dépendance. */
|
|
24
|
+
class TasMin {
|
|
25
|
+
constructor() {
|
|
26
|
+
this.a = [];
|
|
27
|
+
}
|
|
28
|
+
get size() { return this.a.length; }
|
|
29
|
+
push(p, v) {
|
|
30
|
+
this.a.push([p, v]);
|
|
31
|
+
let i = this.a.length - 1;
|
|
32
|
+
while (i > 0) {
|
|
33
|
+
const pere = (i - 1) >> 1;
|
|
34
|
+
if (this.a[pere][0] <= this.a[i][0])
|
|
35
|
+
break;
|
|
36
|
+
[this.a[pere], this.a[i]] = [this.a[i], this.a[pere]];
|
|
37
|
+
i = pere;
|
|
38
|
+
}
|
|
39
|
+
}
|
|
40
|
+
pop() {
|
|
41
|
+
if (!this.a.length)
|
|
42
|
+
return undefined;
|
|
43
|
+
const tete = this.a[0];
|
|
44
|
+
const dernier = this.a.pop();
|
|
45
|
+
if (this.a.length) {
|
|
46
|
+
this.a[0] = dernier;
|
|
47
|
+
let i = 0;
|
|
48
|
+
for (;;) {
|
|
49
|
+
const g = 2 * i + 1;
|
|
50
|
+
const d = g + 1;
|
|
51
|
+
let m = i;
|
|
52
|
+
if (g < this.a.length && this.a[g][0] < this.a[m][0])
|
|
53
|
+
m = g;
|
|
54
|
+
if (d < this.a.length && this.a[d][0] < this.a[m][0])
|
|
55
|
+
m = d;
|
|
56
|
+
if (m === i)
|
|
57
|
+
break;
|
|
58
|
+
[this.a[m], this.a[i]] = [this.a[i], this.a[m]];
|
|
59
|
+
i = m;
|
|
60
|
+
}
|
|
61
|
+
}
|
|
62
|
+
return tete;
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
export function shortestPath(problem) {
|
|
66
|
+
const aretes = problem.undirected
|
|
67
|
+
? problem.edges.flatMap((e) => [e, { from: e.to, to: e.from, weight: e.weight }])
|
|
68
|
+
: problem.edges;
|
|
69
|
+
const sommets = problem.nodes ?? [...new Set(aretes.flatMap((e) => [e.from, e.to]).concat(problem.source))];
|
|
70
|
+
const negatif = aretes.some((e) => e.weight < 0);
|
|
71
|
+
const algorithm = problem.algorithm && problem.algorithm !== 'auto'
|
|
72
|
+
? problem.algorithm
|
|
73
|
+
: (negatif ? 'bellman-ford' : 'dijkstra');
|
|
74
|
+
const dist = Object.fromEntries(sommets.map((n) => [n, Infinity]));
|
|
75
|
+
const pred = Object.fromEntries(sommets.map((n) => [n, null]));
|
|
76
|
+
dist[problem.source] = 0;
|
|
77
|
+
let negativeCycle = false;
|
|
78
|
+
if (algorithm === 'dijkstra') {
|
|
79
|
+
// ⚠️ Dijkstra sur poids négatifs rend un résultat FAUX sans rien signaler. Si l'appelant l'a
|
|
80
|
+
// imposé alors que le graphe en contient, on le dit plutôt que de le laisser croire.
|
|
81
|
+
if (negatif)
|
|
82
|
+
negativeCycle = false;
|
|
83
|
+
const sortants = new Map();
|
|
84
|
+
for (const e of aretes)
|
|
85
|
+
(sortants.get(e.from) ?? sortants.set(e.from, []).get(e.from)).push(e);
|
|
86
|
+
const vus = new Set();
|
|
87
|
+
const tas = new TasMin();
|
|
88
|
+
tas.push(0, problem.source);
|
|
89
|
+
while (tas.size) {
|
|
90
|
+
const [d, u] = tas.pop();
|
|
91
|
+
if (vus.has(u))
|
|
92
|
+
continue;
|
|
93
|
+
vus.add(u);
|
|
94
|
+
for (const e of sortants.get(u) ?? []) {
|
|
95
|
+
const nd = d + e.weight;
|
|
96
|
+
if (nd < (dist[e.to] ?? Infinity)) {
|
|
97
|
+
dist[e.to] = nd;
|
|
98
|
+
pred[e.to] = u;
|
|
99
|
+
tas.push(nd, e.to);
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
else {
|
|
105
|
+
for (let i = 0; i < sommets.length - 1; i++) {
|
|
106
|
+
let bouge = false;
|
|
107
|
+
for (const e of aretes) {
|
|
108
|
+
if (dist[e.from] === Infinity)
|
|
109
|
+
continue;
|
|
110
|
+
const nd = dist[e.from] + e.weight;
|
|
111
|
+
if (nd < dist[e.to]) {
|
|
112
|
+
dist[e.to] = nd;
|
|
113
|
+
pred[e.to] = e.from;
|
|
114
|
+
bouge = true;
|
|
115
|
+
}
|
|
116
|
+
}
|
|
117
|
+
if (!bouge)
|
|
118
|
+
break; // convergé plus tôt : inutile d'épuiser les tours
|
|
119
|
+
}
|
|
120
|
+
// Un tour de plus : si quelque chose bouge encore, c'est qu'un cycle négatif existe.
|
|
121
|
+
negativeCycle = aretes.some((e) => dist[e.from] !== Infinity && dist[e.from] + e.weight < dist[e.to]);
|
|
122
|
+
}
|
|
123
|
+
const unreachable = sommets.filter((n) => dist[n] === Infinity);
|
|
124
|
+
const out = { distances: dist, predecessors: pred, algorithm, unreachable };
|
|
125
|
+
if (negativeCycle)
|
|
126
|
+
out.negativeCycle = true;
|
|
127
|
+
if (problem.target && dist[problem.target] !== Infinity && !negativeCycle) {
|
|
128
|
+
const chemin = [];
|
|
129
|
+
let cur = problem.target;
|
|
130
|
+
const vus = new Set();
|
|
131
|
+
while (cur && !vus.has(cur)) {
|
|
132
|
+
chemin.unshift(cur);
|
|
133
|
+
vus.add(cur);
|
|
134
|
+
cur = pred[cur];
|
|
135
|
+
}
|
|
136
|
+
out.path = chemin;
|
|
137
|
+
out.cost = dist[problem.target];
|
|
138
|
+
}
|
|
139
|
+
return out;
|
|
140
|
+
}
|
|
141
|
+
export const shortestPathDialect = {
|
|
142
|
+
name: 'shortest-path',
|
|
143
|
+
kind: 'flow',
|
|
144
|
+
capabilities: { exact: true, online: false },
|
|
145
|
+
solve(problem) { return shortestPath(problem); },
|
|
146
|
+
};
|
|
147
|
+
//# sourceMappingURL=shortest-path.js.map
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* @mostajs/ro-pla — Dialecte « stable-matching » (Gale-Shapley)
|
|
3
|
+
* @author Dr Hamid MADANI <drmdh@msn.com>
|
|
4
|
+
*
|
|
5
|
+
* APPARIEMENT STABLE À PRÉFÉRENCES DES DEUX CÔTÉS.
|
|
6
|
+
*
|
|
7
|
+
* `hungarian` minimise un COÛT : il suppose qu'on sait chiffrer chaque affectation. Or affecter un
|
|
8
|
+
* encadrant à un dossier, ou un juré à une soutenance, ne se chiffre pas — cela se CLASSE : chacun
|
|
9
|
+
* range les autres par ordre de préférence, et l'on cherche un appariement que personne n'a intérêt
|
|
10
|
+
* à rompre.
|
|
11
|
+
*
|
|
12
|
+
* Un appariement est INSTABLE s'il existe un couple (a, b) non apparié tel que a préfère b à son
|
|
13
|
+
* partenaire actuel ET b préfère a au sien. Gale-Shapley garantit qu'il n'en existe aucun.
|
|
14
|
+
*
|
|
15
|
+
* PROPRIÉTÉ À CONNAÎTRE, ET À DIRE : le résultat est optimal pour le côté qui PROPOSE, et le pire
|
|
16
|
+
* possible (parmi les stables) pour celui qui dispose. Ce n'est pas un détail d'implémentation :
|
|
17
|
+
* qui propose est une décision d'organisation. Faire proposer les ENCADRANTS et faire disposer les
|
|
18
|
+
* DOSSIERS, ou l'inverse, ne donne pas le même résultat — et l'un des deux favorise l'étudiant.
|
|
19
|
+
* D'où `proposerSide`, explicite, sans valeur par défaut cachée.
|
|
20
|
+
*
|
|
21
|
+
* Capacités inégales : chaque « disposant » peut accepter plusieurs partenaires (`capacity`) — c'est
|
|
22
|
+
* le cas hospitals/residents, exactement celui d'un encadrant qui suit trois dossiers.
|
|
23
|
+
*/
|
|
24
|
+
import type { SolverDialect } from '../types.js';
|
|
25
|
+
export interface StableMatchingProblem {
|
|
26
|
+
kind?: 'assignment';
|
|
27
|
+
/** Qui PROPOSE — l'ordre du tableau n'a aucune importance. */
|
|
28
|
+
proposers: string[];
|
|
29
|
+
/** Qui DISPOSE (accepte ou rejette). */
|
|
30
|
+
receivers: string[];
|
|
31
|
+
/** `preferences.proposers[a]` = liste des receveurs, du plus au moins souhaité. */
|
|
32
|
+
preferences: {
|
|
33
|
+
proposers: Record<string, string[]>;
|
|
34
|
+
receivers: Record<string, string[]>;
|
|
35
|
+
};
|
|
36
|
+
/** Combien de partenaires chaque receveur peut accepter (défaut 1). */
|
|
37
|
+
capacity?: Record<string, number>;
|
|
38
|
+
/** Étiquette libre, pour la traçabilité — quel côté propose, dit en clair. */
|
|
39
|
+
proposerSide?: string;
|
|
40
|
+
}
|
|
41
|
+
export interface StableMatchingSolution {
|
|
42
|
+
/** proposant → receveur (absent si non apparié). */
|
|
43
|
+
matching: Record<string, string>;
|
|
44
|
+
/** receveur → proposants retenus. */
|
|
45
|
+
assignments: Record<string, string[]>;
|
|
46
|
+
/** Proposants restés sans partenaire — jamais tus. */
|
|
47
|
+
unmatched: string[];
|
|
48
|
+
/** Nombre de propositions faites : mesure du « coût » social de l'appariement. */
|
|
49
|
+
proposals: number;
|
|
50
|
+
/** Vérifié APRÈS coup : aucun couple bloquant. */
|
|
51
|
+
stable: boolean;
|
|
52
|
+
/** Les couples bloquants s'il y en a — vide si `stable`. */
|
|
53
|
+
blockingPairs: Array<[string, string]>;
|
|
54
|
+
}
|
|
55
|
+
/**
|
|
56
|
+
* Gale-Shapley, version « à capacités » (hospitals/residents).
|
|
57
|
+
*
|
|
58
|
+
* Complexité O(n·m). Terminaison garantie : un proposant ne propose jamais deux fois au même
|
|
59
|
+
* receveur, et sa liste est finie.
|
|
60
|
+
*/
|
|
61
|
+
export declare function stableMatching(problem: StableMatchingProblem): StableMatchingSolution;
|
|
62
|
+
export declare const stableMatchingDialect: SolverDialect<any, StableMatchingSolution>;
|
|
63
|
+
//# sourceMappingURL=stable-matching.d.ts.map
|