@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.
Files changed (59) hide show
  1. package/CHANGELOG.md +39 -0
  2. package/dist/dialects/bin-packing.d.ts +58 -0
  3. package/dist/dialects/bin-packing.js +86 -0
  4. package/dist/dialects/critical-path.d.ts +64 -0
  5. package/dist/dialects/critical-path.js +113 -0
  6. package/dist/dialects/forecast.d.ts +61 -0
  7. package/dist/dialects/forecast.js +116 -0
  8. package/dist/dialects/genetic.d.ts +59 -0
  9. package/dist/dialects/genetic.js +92 -0
  10. package/dist/dialects/knapsack.d.ts +56 -0
  11. package/dist/dialects/knapsack.js +103 -0
  12. package/dist/dialects/list-scheduling.d.ts +65 -0
  13. package/dist/dialects/list-scheduling.js +151 -0
  14. package/dist/dialects/matching.d.ts +48 -0
  15. package/dist/dialects/matching.js +149 -0
  16. package/dist/dialects/max-flow.d.ts +51 -0
  17. package/dist/dialects/max-flow.js +104 -0
  18. package/dist/dialects/pareto.d.ts +66 -0
  19. package/dist/dialects/pareto.js +129 -0
  20. package/dist/dialects/shortest-path.d.ts +57 -0
  21. package/dist/dialects/shortest-path.js +147 -0
  22. package/dist/dialects/stable-matching.d.ts +63 -0
  23. package/dist/dialects/stable-matching.js +109 -0
  24. package/dist/dialects/tabu.d.ts +56 -0
  25. package/dist/dialects/tabu.js +95 -0
  26. package/dist/index.d.ts +12 -0
  27. package/dist/index.js +40 -0
  28. package/llms.txt +92 -2
  29. package/package.json +11 -3
  30. package/dist/dialects/anneal.d.ts.map +0 -1
  31. package/dist/dialects/anneal.js.map +0 -1
  32. package/dist/dialects/csp.d.ts.map +0 -1
  33. package/dist/dialects/csp.js.map +0 -1
  34. package/dist/dialects/hungarian.d.ts.map +0 -1
  35. package/dist/dialects/hungarian.js.map +0 -1
  36. package/dist/dialects/lagrangian.d.ts.map +0 -1
  37. package/dist/dialects/lagrangian.js.map +0 -1
  38. package/dist/dialects/markov.d.ts.map +0 -1
  39. package/dist/dialects/markov.js.map +0 -1
  40. package/dist/dialects/mdp.d.ts.map +0 -1
  41. package/dist/dialects/mdp.js.map +0 -1
  42. package/dist/dialects/milp.d.ts.map +0 -1
  43. package/dist/dialects/milp.js.map +0 -1
  44. package/dist/dialects/min-cost-flow.d.ts.map +0 -1
  45. package/dist/dialects/min-cost-flow.js.map +0 -1
  46. package/dist/dialects/mmc.d.ts.map +0 -1
  47. package/dist/dialects/mmc.js.map +0 -1
  48. package/dist/dialects/monte-carlo.d.ts.map +0 -1
  49. package/dist/dialects/monte-carlo.js.map +0 -1
  50. package/dist/dialects/simplex.d.ts.map +0 -1
  51. package/dist/dialects/simplex.js.map +0 -1
  52. package/dist/index.d.ts.map +0 -1
  53. package/dist/index.js.map +0 -1
  54. package/dist/lib/rng.d.ts.map +0 -1
  55. package/dist/lib/rng.js.map +0 -1
  56. package/dist/registry.d.ts.map +0 -1
  57. package/dist/registry.js.map +0 -1
  58. package/dist/types.d.ts.map +0 -1
  59. package/dist/types.js.map +0 -1
@@ -0,0 +1,92 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « genetic » (algorithme génétique)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * LA PREMIÈRE MÉTAHEURISTIQUE À POPULATION DU MODULE.
6
+ *
7
+ * `anneal` et `tabu` sont des recherches à **trajectoire unique** : un point se déplace. Elles
8
+ * explorent bien un bassin, mal un paysage à plusieurs vallées éloignées — le point n'est jamais
9
+ * qu'à un endroit.
10
+ *
11
+ * Un algorithme génétique tient **plusieurs points à la fois**, et les croise : deux solutions
12
+ * moyennes portant chacune une bonne moitié peuvent engendrer une bonne solution. C'est le
13
+ * croisement qui apporte ce qu'aucune trajectoire ne sait faire, pas la mutation.
14
+ *
15
+ * ─── TROIS GARDE-FOUS, ET CHACUN CORRIGE UN DÉFAUT CONNU ────────────────────────────────────
16
+ * · **ÉLITISME** — les `elite` meilleurs passent au tour suivant sans modification. Sans lui, un
17
+ * algorithme génétique PERD sa meilleure solution en cours de route : c'est le défaut classique,
18
+ * et il est silencieux.
19
+ * · **TOURNOI** plutôt que roulette proportionnelle — la roulette laisse un individu très bon
20
+ * écraser la population en deux générations (convergence prématurée), et devient absurde si les
21
+ * scores changent de signe.
22
+ * · **DIVERSITÉ MESURÉE** — le nombre de génomes distincts est rendu à chaque arrêt. Une population
23
+ * qui s'est effondrée sur un seul individu ne cherche plus rien, et rien d'autre ne le dirait.
24
+ *
25
+ * ⚠️ `exact: false`. RNG injecté (`seed`) pour la reproductibilité.
26
+ */
27
+ import { makeRng } from '../lib/rng.js';
28
+ export function genetic(problem) {
29
+ const rng = makeRng(problem.seed ?? 12345);
30
+ const generations = Math.max(1, problem.generations ?? 100);
31
+ const taux = problem.mutationRate ?? 0.15;
32
+ const elite = Math.max(0, problem.elite ?? 2);
33
+ const tournoi = Math.max(2, problem.tournament ?? 3);
34
+ const patience = problem.patience ?? generations;
35
+ let pop = [...(problem.population ?? [])];
36
+ if (!pop.length)
37
+ throw new Error('genetic : population initiale vide — rien à faire évoluer');
38
+ const n = pop.length;
39
+ const score = (g) => problem.fitness(g);
40
+ let best = pop[0];
41
+ let bestF = score(best);
42
+ let foundAt = 0;
43
+ const history = [];
44
+ let stagnation = 0;
45
+ /** Tournoi : on tire `k` individus et l'on garde le meilleur. Insensible à l'échelle des scores. */
46
+ const selectionner = (notes) => {
47
+ let gagnant = Math.floor(rng() * n);
48
+ for (let i = 1; i < tournoi; i++) {
49
+ const c = Math.floor(rng() * n);
50
+ if (notes[c] < notes[gagnant])
51
+ gagnant = c;
52
+ }
53
+ return pop[gagnant];
54
+ };
55
+ for (let g = 1; g <= generations; g++) {
56
+ const notes = pop.map(score);
57
+ for (let i = 0; i < n; i++) {
58
+ if (notes[i] < bestF) {
59
+ bestF = notes[i];
60
+ best = pop[i];
61
+ foundAt = g;
62
+ stagnation = -1;
63
+ }
64
+ }
65
+ stagnation += 1;
66
+ history.push(bestF);
67
+ if (stagnation >= patience)
68
+ break;
69
+ // Élitisme : les meilleurs traversent la génération sans être touchés.
70
+ const ordre = pop.map((_, i) => i).sort((a, b) => notes[a] - notes[b]);
71
+ const suivante = ordre.slice(0, Math.min(elite, n)).map((i) => pop[i]);
72
+ while (suivante.length < n) {
73
+ const a = selectionner(notes);
74
+ const b = selectionner(notes);
75
+ let enfant = problem.crossover(a, b, rng);
76
+ if (rng() < taux)
77
+ enfant = problem.mutate(enfant, rng);
78
+ suivante.push(enfant);
79
+ }
80
+ pop = suivante;
81
+ }
82
+ // Diversité : nombre de génomes distincts. Un effondrement à 1 signifie que la recherche est finie.
83
+ const vus = new Set(pop.map((g) => JSON.stringify(g)));
84
+ return { best, bestFitness: bestF, generations: history.length, foundAt, diversity: vus.size, history };
85
+ }
86
+ export const geneticDialect = {
87
+ name: 'genetic',
88
+ kind: 'metaheuristic',
89
+ capabilities: { exact: false, online: false },
90
+ solve(problem) { return genetic(problem); },
91
+ };
92
+ //# sourceMappingURL=genetic.js.map
@@ -0,0 +1,56 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « knapsack » (programmation dynamique exacte)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * CHOISIR SOUS CONTRAINTE DE BUDGET.
6
+ *
7
+ * Quelles formations ouvrir avec l'enveloppe de l'année ? Quels projets financer ? `milp` sait le
8
+ * faire — mais par séparation-évaluation, avec le coût et l'imprévisibilité que cela suppose. Pour
9
+ * la forme particulière « un seul budget, des objets indivisibles », la programmation dynamique
10
+ * rend l'optimum **exact**, en temps O(n·W), et de façon **prévisible**.
11
+ *
12
+ * TROIS VARIANTES, parce qu'elles ne modélisent pas la même chose :
13
+ * · `0/1` — chaque objet est pris **ou non** (le cas courant : une formation s'ouvre ou pas)
14
+ * · `bounded` — chaque objet a un nombre d'exemplaires **limité**
15
+ * · `unbounded` — nombre d'exemplaires **illimité** (acheter n licences identiques)
16
+ *
17
+ * ⚠️ LA LIMITE EST DANS LE BUDGET, PAS DANS LE NOMBRE D'OBJETS : le tableau fait `W+1` cases. Un
18
+ * budget exprimé en centimes sur un million d'euros ferait cent millions de cases. `maxCells`
19
+ * garde le calcul et le DIT plutôt que d'épuiser la mémoire en silence.
20
+ */
21
+ import type { SolverDialect } from '../types.js';
22
+ export interface KnapsackItem {
23
+ id: string;
24
+ /** Poids / coût — doit être un ENTIER : la PD indexe le budget. */
25
+ weight: number;
26
+ value: number;
27
+ /** Exemplaires disponibles (variante `bounded`). */
28
+ count?: number;
29
+ label?: string;
30
+ }
31
+ export interface KnapsackProblem {
32
+ kind?: 'milp';
33
+ items: KnapsackItem[];
34
+ capacity: number;
35
+ variant?: '0/1' | 'bounded' | 'unbounded';
36
+ /** Garde-fou mémoire : n × capacité. Défaut 20 millions de cases. */
37
+ maxCells?: number;
38
+ }
39
+ export interface KnapsackSolution {
40
+ /** Valeur optimale atteinte. */
41
+ value: number;
42
+ /** Objets retenus (avec leur multiplicité pour les variantes bounded/unbounded). */
43
+ chosen: Array<{
44
+ id: string;
45
+ qty: number;
46
+ }>;
47
+ weight: number;
48
+ /** Budget non consommé. */
49
+ slack: number;
50
+ variant: string;
51
+ /** Le calcul a-t-il été REFUSÉ faute de place ? On le dit, on ne rend pas un faux optimum. */
52
+ refused?: string;
53
+ }
54
+ export declare function knapsack(problem: KnapsackProblem): KnapsackSolution;
55
+ export declare const knapsackDialect: SolverDialect<any, KnapsackSolution>;
56
+ //# sourceMappingURL=knapsack.d.ts.map
@@ -0,0 +1,103 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « knapsack » (programmation dynamique exacte)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * CHOISIR SOUS CONTRAINTE DE BUDGET.
6
+ *
7
+ * Quelles formations ouvrir avec l'enveloppe de l'année ? Quels projets financer ? `milp` sait le
8
+ * faire — mais par séparation-évaluation, avec le coût et l'imprévisibilité que cela suppose. Pour
9
+ * la forme particulière « un seul budget, des objets indivisibles », la programmation dynamique
10
+ * rend l'optimum **exact**, en temps O(n·W), et de façon **prévisible**.
11
+ *
12
+ * TROIS VARIANTES, parce qu'elles ne modélisent pas la même chose :
13
+ * · `0/1` — chaque objet est pris **ou non** (le cas courant : une formation s'ouvre ou pas)
14
+ * · `bounded` — chaque objet a un nombre d'exemplaires **limité**
15
+ * · `unbounded` — nombre d'exemplaires **illimité** (acheter n licences identiques)
16
+ *
17
+ * ⚠️ LA LIMITE EST DANS LE BUDGET, PAS DANS LE NOMBRE D'OBJETS : le tableau fait `W+1` cases. Un
18
+ * budget exprimé en centimes sur un million d'euros ferait cent millions de cases. `maxCells`
19
+ * garde le calcul et le DIT plutôt que d'épuiser la mémoire en silence.
20
+ */
21
+ export function knapsack(problem) {
22
+ const variant = problem.variant ?? '0/1';
23
+ const W = Math.max(0, Math.floor(problem.capacity));
24
+ const items = (problem.items ?? []).filter((i) => i.weight > 0 && Number.isFinite(i.value));
25
+ const maxCells = problem.maxCells ?? 20_000_000;
26
+ if (!items.length || W === 0) {
27
+ return { value: 0, chosen: [], weight: 0, slack: W, variant };
28
+ }
29
+ if (items.some((i) => !Number.isInteger(i.weight))) {
30
+ return { value: 0, chosen: [], weight: 0, slack: W, variant,
31
+ refused: 'les poids doivent être ENTIERS : la programmation dynamique indexe le budget' };
32
+ }
33
+ if (items.length * (W + 1) > maxCells) {
34
+ return { value: 0, chosen: [], weight: 0, slack: W, variant,
35
+ refused: `${items.length} × ${W + 1} cases dépasse la garde (${maxCells}). Ramener le budget à une unité plus grossière, ou passer par le dialecte milp.` };
36
+ }
37
+ let lots = [];
38
+ if (variant === 'bounded') {
39
+ for (const it of items) {
40
+ let reste = Math.max(1, Math.floor(it.count ?? 1));
41
+ let k = 1;
42
+ while (reste > 0) {
43
+ const q = Math.min(k, reste);
44
+ lots.push({ id: it.id, weight: it.weight * q, value: it.value * q, qty: q });
45
+ reste -= q;
46
+ k *= 2;
47
+ }
48
+ }
49
+ }
50
+ else {
51
+ lots = items.map((it) => ({ id: it.id, weight: it.weight, value: it.value, qty: 1 }));
52
+ }
53
+ const dp = new Float64Array(W + 1);
54
+ // `pris[j]` retient, pour chaque budget, le dernier lot ajouté — c'est ce qui permet de
55
+ // RECONSTRUIRE le choix, et non seulement d'annoncer une valeur.
56
+ const pris = lots.map(() => new Int32Array(W + 1).fill(-1));
57
+ lots.forEach((lot, k) => {
58
+ if (variant === 'unbounded') {
59
+ // Budget croissant : on peut réutiliser le même objet dans le même tour.
60
+ for (let j = lot.weight; j <= W; j++) {
61
+ const v = dp[j - lot.weight] + lot.value;
62
+ if (v > dp[j]) {
63
+ dp[j] = v;
64
+ pris[k][j] = j - lot.weight;
65
+ }
66
+ }
67
+ }
68
+ else {
69
+ // Budget décroissant : chaque lot n'est utilisé qu'une fois.
70
+ for (let j = W; j >= lot.weight; j--) {
71
+ const v = dp[j - lot.weight] + lot.value;
72
+ if (v > dp[j]) {
73
+ dp[j] = v;
74
+ pris[k][j] = j - lot.weight;
75
+ }
76
+ }
77
+ }
78
+ });
79
+ // Reconstruction : on remonte les lots à l'envers.
80
+ const qty = new Map();
81
+ let j = W;
82
+ for (let k = lots.length - 1; k >= 0; k--) {
83
+ while (pris[k][j] >= 0) {
84
+ qty.set(lots[k].id, (qty.get(lots[k].id) ?? 0) + lots[k].qty);
85
+ j = pris[k][j];
86
+ if (variant !== 'unbounded')
87
+ break; // en 0/1 et bounded, un lot ne sert qu'une fois
88
+ }
89
+ }
90
+ const chosen = [...qty.entries()].map(([id, q]) => ({ id, qty: q }));
91
+ const poidsParId = new Map(items.map((i) => [i.id, i.weight]));
92
+ const weight = chosen.reduce((s, c) => s + (poidsParId.get(c.id) ?? 0) * c.qty, 0);
93
+ return { value: dp[W], chosen, weight, slack: W - weight, variant };
94
+ }
95
+ export const knapsackDialect = {
96
+ name: 'knapsack',
97
+ kind: 'milp',
98
+ // EXACT : la programmation dynamique rend l'optimum, contrairement à toute heuristique de
99
+ // remplissage. Le prix est la mémoire, gardée par `maxCells`.
100
+ capabilities: { exact: true, online: false },
101
+ solve(problem) { return knapsack(problem); },
102
+ };
103
+ //# sourceMappingURL=knapsack.js.map
@@ -0,0 +1,65 @@
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 type { SolverDialect } from '../types.js';
29
+ export interface SchedTask {
30
+ id: string;
31
+ duration: number;
32
+ predecessors?: string[];
33
+ /** Ressource → quantité consommée pendant toute la durée de la tâche. */
34
+ resources?: Record<string, number>;
35
+ label?: string;
36
+ }
37
+ export interface ListSchedulingProblem {
38
+ kind?: 'scheduling';
39
+ tasks: SchedTask[];
40
+ /** Ressource → capacité disponible à chaque instant. */
41
+ capacities: Record<string, number>;
42
+ /** Règle de priorité — voir l'en-tête. Défaut : 'critical'. */
43
+ rule?: 'critical' | 'lpt' | 'spt' | 'order';
44
+ /** Horizon maximal, garde-fou contre une donnée aberrante. */
45
+ horizon?: number;
46
+ }
47
+ export interface ScheduledTask {
48
+ id: string;
49
+ start: number;
50
+ end: number;
51
+ }
52
+ export interface ListSchedulingSolution {
53
+ schedule: ScheduledTask[];
54
+ makespan: number;
55
+ /** Borne inférieure : max(chemin critique, charge/capacité). */
56
+ lowerBound: number;
57
+ /** Taux d'occupation moyen de chaque ressource sur la durée du plan. */
58
+ utilisation: Record<string, number>;
59
+ rule: string;
60
+ /** Tâches non placées (précédence impossible, ressource insuffisante) — jamais tues. */
61
+ unscheduled: string[];
62
+ }
63
+ export declare function listScheduling(problem: ListSchedulingProblem): ListSchedulingSolution;
64
+ export declare const listSchedulingDialect: SolverDialect<any, ListSchedulingSolution>;
65
+ //# sourceMappingURL=list-scheduling.d.ts.map
@@ -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