@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
package/CHANGELOG.md ADDED
@@ -0,0 +1,39 @@
1
+ # CHANGELOG
2
+
3
+ ## [0.2.0] — 2026-08-09
4
+
5
+ ### Ajouté — LOT 2 : douze dialectes (11 → 23)
6
+
7
+ Les deux `ProblemKind` **déclarés et vides** (`scheduling`, `multiobjective`) sont désormais servis.
8
+
9
+ - `stable-matching` — Gale-Shapley à capacités. Apparie des PRÉFÉRENCES classées, là où `hungarian`
10
+ minimise un coût chiffré. **Qui propose est une décision d'organisation** : le résultat est
11
+ optimal pour le proposant, le pire pour le disposant.
12
+ - `critical-path` — CPM/PERT : marges, cycles détectés, probabilité de tenir une échéance.
13
+ - `bin-packing` — FFD/BFD, contenants hétérogènes, `lowerBound` rendu.
14
+ - `pareto` — front, rangs, distance de peuplement, idéal/nadir. **Ne rend pas « la » solution** :
15
+ le compromis est proposé séparément, avec sa méthode.
16
+ - `list-scheduling` — ressources à capacité finie ; compose `critical-path` pour la priorité.
17
+ - `shortest-path` — Dijkstra + Bellman-Ford, bascule automatique sur poids négatif, cycle négatif
18
+ déclaré.
19
+ - `max-flow` — Dinic + **coupe minimale** : le goulot nommé, pas seulement chiffré.
20
+ - `matching` — Blossom, **graphe général**. L'algorithme naïf échoue en silence sur un triangle.
21
+ - `knapsack` — PD exacte 0/1 / bounded / unbounded, avec garde mémoire et refus motivé.
22
+ - `tabu` — recherche locale **avec mémoire** + critère d'aspiration.
23
+ - `genetic` — première métaheuristique **à population**, élitisme et diversité mesurée.
24
+ - `forecast` — lissage simple / Holt / Holt-Winters, **avec son erreur** (MAE/MAPE).
25
+
26
+ ### Principes tenus
27
+
28
+ Toute heuristique déclare `exact: false` **et** rend une borne ou une erreur : dire la distance à
29
+ l'optimum vaut mieux qu'une promesse invérifiable. Toute métaheuristique est **déterministe à
30
+ graine égale** — sans quoi `@mostajs/skill-library` ne pourrait juger aucune recette.
31
+
32
+ ### Corrigé pendant la mise au point
33
+
34
+ `forecast` **rétrogradait en silence** vers une méthode sans saison quand la série était trop
35
+ courte : l'appelant croyait tenir une prévision saisonnière. Refus motivé si la méthode est
36
+ demandée explicitement, `note` explicite en mode automatique.
37
+
38
+ 108 tests verts. Plan Dev+Test dans qatrax : 24 exigences, 24 réalisations, 49 tests.
39
+
@@ -0,0 +1,58 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « bin-packing » (FFD / BFD, boîtes hétérogènes)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * RANGER DES OBJETS DANS DES CONTENANTS DE CAPACITÉ LIMITÉE.
6
+ *
7
+ * Chez nous : affecter des séances et des soutenances à des SALLES. Un amphithéâtre de 200 places
8
+ * et une salle de 30 ne sont pas interchangeables — d'où des boîtes **hétérogènes**, chacune avec
9
+ * sa capacité propre, et non le bin-packing scolaire à boîtes identiques.
10
+ *
11
+ * PROBLÈME NP-DIFFICILE : on ne rend PAS l'optimum, et il faut le dire. `capabilities.exact` est
12
+ * donc `false`. Mais la borne inférieure (somme des tailles / capacité maximale) est calculée et
13
+ * rendue : l'appelant sait à quelle distance de l'optimum théorique il se trouve, ce qui vaut mieux
14
+ * qu'une promesse invérifiable.
15
+ *
16
+ * Deux heuristiques, parce qu'elles ne se valent pas selon les données :
17
+ * · **FFD** (first-fit decreasing) — rapide, garantie 11/9·OPT+6/9 sur boîtes identiques ;
18
+ * · **BFD** (best-fit decreasing) — remplit au plus juste, souvent meilleur quand les capacités
19
+ * sont très inégales.
20
+ * Le mode `both` les essaie et **rend la meilleure**, en disant laquelle a gagné.
21
+ */
22
+ import type { SolverDialect } from '../types.js';
23
+ export interface PackItem {
24
+ id: string;
25
+ size: number;
26
+ /** Ne peut aller que dans ces contenants (facultatif) — matériel, accessibilité… */
27
+ allowedBins?: string[];
28
+ label?: string;
29
+ }
30
+ export interface Bin {
31
+ id: string;
32
+ capacity: number;
33
+ label?: string;
34
+ }
35
+ export interface BinPackingProblem {
36
+ kind?: 'scheduling';
37
+ items: PackItem[];
38
+ bins: Bin[];
39
+ /** 'ffd' | 'bfd' | 'both' (défaut) */
40
+ strategy?: 'ffd' | 'bfd' | 'both';
41
+ }
42
+ export interface BinPackingSolution {
43
+ /** contenant → objets rangés */
44
+ packing: Record<string, string[]>;
45
+ /** charge par contenant */
46
+ load: Record<string, number>;
47
+ /** Objets qu'AUCUN contenant ne peut prendre — jamais tus. */
48
+ unplaced: string[];
49
+ binsUsed: number;
50
+ /** Borne inférieure du nombre de contenants : dit la distance à l'optimum. */
51
+ lowerBound: number;
52
+ strategyUsed: 'ffd' | 'bfd';
53
+ /** Taux de remplissage moyen des contenants utilisés. */
54
+ fillRate: number;
55
+ }
56
+ export declare function binPacking(problem: BinPackingProblem): BinPackingSolution;
57
+ export declare const binPackingDialect: SolverDialect<any, BinPackingSolution>;
58
+ //# sourceMappingURL=bin-packing.d.ts.map
@@ -0,0 +1,86 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « bin-packing » (FFD / BFD, boîtes hétérogènes)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * RANGER DES OBJETS DANS DES CONTENANTS DE CAPACITÉ LIMITÉE.
6
+ *
7
+ * Chez nous : affecter des séances et des soutenances à des SALLES. Un amphithéâtre de 200 places
8
+ * et une salle de 30 ne sont pas interchangeables — d'où des boîtes **hétérogènes**, chacune avec
9
+ * sa capacité propre, et non le bin-packing scolaire à boîtes identiques.
10
+ *
11
+ * PROBLÈME NP-DIFFICILE : on ne rend PAS l'optimum, et il faut le dire. `capabilities.exact` est
12
+ * donc `false`. Mais la borne inférieure (somme des tailles / capacité maximale) est calculée et
13
+ * rendue : l'appelant sait à quelle distance de l'optimum théorique il se trouve, ce qui vaut mieux
14
+ * qu'une promesse invérifiable.
15
+ *
16
+ * Deux heuristiques, parce qu'elles ne se valent pas selon les données :
17
+ * · **FFD** (first-fit decreasing) — rapide, garantie 11/9·OPT+6/9 sur boîtes identiques ;
18
+ * · **BFD** (best-fit decreasing) — remplit au plus juste, souvent meilleur quand les capacités
19
+ * sont très inégales.
20
+ * Le mode `both` les essaie et **rend la meilleure**, en disant laquelle a gagné.
21
+ */
22
+ function ranger(items, bins, best) {
23
+ const packing = Object.fromEntries(bins.map((b) => [b.id, []]));
24
+ const load = Object.fromEntries(bins.map((b) => [b.id, 0]));
25
+ const unplaced = [];
26
+ const capOf = new Map(bins.map((b) => [b.id, b.capacity]));
27
+ // Décroissant : ranger d'abord les gros. C'est ce « decreasing » qui fait toute la qualité —
28
+ // en ordre d'arrivée, l'heuristique se dégrade nettement.
29
+ const tries = [...items].sort((a, b) => b.size - a.size);
30
+ for (const it of tries) {
31
+ const candidats = bins.filter((b) => (!it.allowedBins || it.allowedBins.includes(b.id))
32
+ && (load[b.id] + it.size) <= (capOf.get(b.id) ?? 0));
33
+ if (!candidats.length) {
34
+ unplaced.push(it.id);
35
+ continue;
36
+ }
37
+ // FFD : le premier qui va. BFD : celui qui laissera le moins de place perdue.
38
+ const choisi = best
39
+ ? candidats.reduce((m, b) => (((capOf.get(b.id) ?? 0) - load[b.id] - it.size)
40
+ < ((capOf.get(m.id) ?? 0) - load[m.id] - it.size) ? b : m))
41
+ : candidats[0];
42
+ packing[choisi.id].push(it.id);
43
+ load[choisi.id] += it.size;
44
+ }
45
+ return { packing, load, unplaced };
46
+ }
47
+ export function binPacking(problem) {
48
+ const items = problem.items ?? [];
49
+ const bins = problem.bins ?? [];
50
+ const strategy = problem.strategy ?? 'both';
51
+ const capMax = Math.max(1, ...bins.map((b) => b.capacity));
52
+ const total = items.reduce((s, i) => s + i.size, 0);
53
+ const lowerBound = Math.ceil(total / capMax);
54
+ const essais = [];
55
+ if (strategy === 'ffd' || strategy === 'both')
56
+ essais.push({ nom: 'ffd', r: ranger(items, bins, false) });
57
+ if (strategy === 'bfd' || strategy === 'both')
58
+ essais.push({ nom: 'bfd', r: ranger(items, bins, true) });
59
+ // On choisit d'abord sur le nombre d'objets NON PLACÉS — laisser une soutenance sans salle est
60
+ // pire qu'occuper un amphithéâtre de plus.
61
+ const gagnant = essais.reduce((m, e) => {
62
+ const nonPlaces = e.r.unplaced.length - m.r.unplaced.length;
63
+ if (nonPlaces !== 0)
64
+ return nonPlaces < 0 ? e : m;
65
+ const used = (x) => Object.values(x.r.load).filter((l) => l > 0).length;
66
+ return used(e) < used(m) ? e : m;
67
+ });
68
+ const utilises = bins.filter((b) => gagnant.r.load[b.id] > 0);
69
+ const fillRate = utilises.length
70
+ ? utilises.reduce((s, b) => s + gagnant.r.load[b.id] / b.capacity, 0) / utilises.length
71
+ : 0;
72
+ return {
73
+ packing: gagnant.r.packing, load: gagnant.r.load, unplaced: gagnant.r.unplaced,
74
+ binsUsed: utilises.length, lowerBound, strategyUsed: gagnant.nom, fillRate,
75
+ };
76
+ }
77
+ export const binPackingDialect = {
78
+ name: 'bin-packing',
79
+ kind: 'scheduling',
80
+ // NP-difficile : heuristique assumée. La borne inférieure rendue dit la distance à l'optimum.
81
+ capabilities: { exact: false, online: false },
82
+ solve(problem) {
83
+ return binPacking(problem);
84
+ },
85
+ };
86
+ //# sourceMappingURL=bin-packing.js.map
@@ -0,0 +1,64 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « critical-path » (CPM / PERT)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * LE CHEMIN CRITIQUE D'UN RÉSEAU D'ACTIVITÉS.
6
+ *
7
+ * Un parcours à étapes conditionnées EST un réseau d'activités : chaque étape a une durée et des
8
+ * prédécesseurs. Le chemin critique répond à deux questions qu'aucun autre dialecte ne pose :
9
+ * · **quelle est la date au plus tôt de la fin** — donc : ce dossier peut-il être diplômé cette
10
+ * année, ou est-ce déjà arithmétiquement impossible ?
11
+ * · **où est la MARGE** — quelles activités peuvent glisser sans rien retarder, et lesquelles
12
+ * n'en ont aucune. Une activité de marge nulle est **critique** : tout retard s'y propage.
13
+ *
14
+ * C'est ce qui manque à un suivi de promotion : il dit *ce qui bloque maintenant*, pas *ce qui va
15
+ * bloquer*.
16
+ *
17
+ * PERT : si `optimistic`/`pessimistic` sont fournis, la durée retenue est l'espérance bêta
18
+ * (o + 4m + p)/6, et la variance ((p−o)/6)² permet de dire la probabilité de tenir une échéance.
19
+ */
20
+ import type { SolverDialect } from '../types.js';
21
+ export interface Activity {
22
+ id: string;
23
+ /** Durée la plus probable (ou durée certaine si o/p absents). */
24
+ duration: number;
25
+ predecessors?: string[];
26
+ /** PERT — durées optimiste et pessimiste. */
27
+ optimistic?: number;
28
+ pessimistic?: number;
29
+ label?: string;
30
+ }
31
+ export interface CriticalPathProblem {
32
+ kind?: 'scheduling';
33
+ activities: Activity[];
34
+ /** Échéance à tenir, pour calculer la probabilité PERT (facultatif). */
35
+ deadline?: number;
36
+ }
37
+ export interface ActivityTiming {
38
+ id: string;
39
+ duration: number;
40
+ earlyStart: number;
41
+ earlyFinish: number;
42
+ lateStart: number;
43
+ lateFinish: number;
44
+ /** Marge totale : de combien on peut glisser sans retarder la FIN. 0 = critique. */
45
+ slack: number;
46
+ critical: boolean;
47
+ variance: number;
48
+ }
49
+ export interface CriticalPathSolution {
50
+ /** Durée minimale du projet. */
51
+ makespan: number;
52
+ /** Les activités du chemin critique, dans l'ordre. */
53
+ criticalPath: string[];
54
+ timings: Record<string, ActivityTiming>;
55
+ /** Écart-type PERT du projet (somme des variances des activités critiques). */
56
+ stdDev: number;
57
+ /** P(fin ≤ deadline), si `deadline` est fourni — approximation normale. */
58
+ probability?: number;
59
+ /** Cycle détecté : le réseau est invalide, on le DIT au lieu de boucler. */
60
+ cycle?: string[];
61
+ }
62
+ export declare function criticalPath(problem: CriticalPathProblem): CriticalPathSolution;
63
+ export declare const criticalPathDialect: SolverDialect<any, CriticalPathSolution>;
64
+ //# sourceMappingURL=critical-path.d.ts.map
@@ -0,0 +1,113 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « critical-path » (CPM / PERT)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * LE CHEMIN CRITIQUE D'UN RÉSEAU D'ACTIVITÉS.
6
+ *
7
+ * Un parcours à étapes conditionnées EST un réseau d'activités : chaque étape a une durée et des
8
+ * prédécesseurs. Le chemin critique répond à deux questions qu'aucun autre dialecte ne pose :
9
+ * · **quelle est la date au plus tôt de la fin** — donc : ce dossier peut-il être diplômé cette
10
+ * année, ou est-ce déjà arithmétiquement impossible ?
11
+ * · **où est la MARGE** — quelles activités peuvent glisser sans rien retarder, et lesquelles
12
+ * n'en ont aucune. Une activité de marge nulle est **critique** : tout retard s'y propage.
13
+ *
14
+ * C'est ce qui manque à un suivi de promotion : il dit *ce qui bloque maintenant*, pas *ce qui va
15
+ * bloquer*.
16
+ *
17
+ * PERT : si `optimistic`/`pessimistic` sont fournis, la durée retenue est l'espérance bêta
18
+ * (o + 4m + p)/6, et la variance ((p−o)/6)² permet de dire la probabilité de tenir une échéance.
19
+ */
20
+ /** Loi normale centrée réduite — approximation d'Abramowitz-Stegun, suffisante ici. */
21
+ function phi(z) {
22
+ const t = 1 / (1 + 0.2316419 * Math.abs(z));
23
+ const d = 0.3989423 * Math.exp(-z * z / 2);
24
+ const p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))));
25
+ return z > 0 ? 1 - p : p;
26
+ }
27
+ export function criticalPath(problem) {
28
+ const acts = problem.activities ?? [];
29
+ const byId = new Map(acts.map((a) => [a.id, a]));
30
+ // Durée attendue : PERT si l'on a les trois estimations, sinon la durée donnée.
31
+ const duree = (a) => (a.optimistic != null && a.pessimistic != null
32
+ ? (a.optimistic + 4 * a.duration + a.pessimistic) / 6
33
+ : a.duration);
34
+ const variance = (a) => (a.optimistic != null && a.pessimistic != null
35
+ ? ((a.pessimistic - a.optimistic) / 6) ** 2 : 0);
36
+ // ─── TRI TOPOLOGIQUE — et détection de cycle ───────────────────────────────────────────────
37
+ // Un réseau d'activités cyclique n'a pas de chemin critique. Boucler serait le pire des
38
+ // comportements : on rend le cycle, l'appelant saura quoi corriger.
39
+ const entrants = new Map(acts.map((a) => [a.id, 0]));
40
+ const successeurs = new Map(acts.map((a) => [a.id, []]));
41
+ for (const a of acts) {
42
+ for (const p of a.predecessors ?? []) {
43
+ if (!byId.has(p))
44
+ continue; // prédécesseur inconnu : ignoré
45
+ entrants.set(a.id, (entrants.get(a.id) ?? 0) + 1);
46
+ successeurs.get(p).push(a.id);
47
+ }
48
+ }
49
+ const file = acts.filter((a) => (entrants.get(a.id) ?? 0) === 0).map((a) => a.id);
50
+ const ordre = [];
51
+ const restants = new Map(entrants);
52
+ while (file.length) {
53
+ const id = file.shift();
54
+ ordre.push(id);
55
+ for (const s of successeurs.get(id) ?? []) {
56
+ const n = (restants.get(s) ?? 0) - 1;
57
+ restants.set(s, n);
58
+ if (n === 0)
59
+ file.push(s);
60
+ }
61
+ }
62
+ if (ordre.length !== acts.length) {
63
+ const cycle = acts.filter((a) => !ordre.includes(a.id)).map((a) => a.id);
64
+ return { makespan: 0, criticalPath: [], timings: {}, stdDev: 0, cycle };
65
+ }
66
+ // Passe AVANT : dates au plus tôt.
67
+ const es = new Map();
68
+ const ef = new Map();
69
+ for (const id of ordre) {
70
+ const a = byId.get(id);
71
+ const debut = Math.max(0, ...(a.predecessors ?? []).filter((p) => byId.has(p)).map((p) => ef.get(p) ?? 0));
72
+ es.set(id, debut);
73
+ ef.set(id, debut + duree(a));
74
+ }
75
+ const makespan = Math.max(0, ...[...ef.values()]);
76
+ // Passe ARRIÈRE : dates au plus tard.
77
+ const lf = new Map();
78
+ const ls = new Map();
79
+ for (const id of [...ordre].reverse()) {
80
+ const a = byId.get(id);
81
+ const succ = successeurs.get(id) ?? [];
82
+ const fin = succ.length ? Math.min(...succ.map((s) => ls.get(s) ?? makespan)) : makespan;
83
+ lf.set(id, fin);
84
+ ls.set(id, fin - duree(a));
85
+ }
86
+ const timings = {};
87
+ for (const a of acts) {
88
+ const slack = (ls.get(a.id) ?? 0) - (es.get(a.id) ?? 0);
89
+ timings[a.id] = {
90
+ id: a.id, duration: duree(a),
91
+ earlyStart: es.get(a.id) ?? 0, earlyFinish: ef.get(a.id) ?? 0,
92
+ lateStart: ls.get(a.id) ?? 0, lateFinish: lf.get(a.id) ?? 0,
93
+ // Tolérance flottante : sans elle, une marge de 1e-15 rendrait une activité « non critique ».
94
+ slack, critical: Math.abs(slack) < 1e-9, variance: variance(a),
95
+ };
96
+ }
97
+ const criticalPath = ordre.filter((id) => timings[id].critical);
98
+ const varTotale = criticalPath.reduce((s, id) => s + timings[id].variance, 0);
99
+ const stdDev = Math.sqrt(varTotale);
100
+ const probability = problem.deadline != null && stdDev > 0
101
+ ? phi((problem.deadline - makespan) / stdDev)
102
+ : problem.deadline != null ? (problem.deadline >= makespan ? 1 : 0) : undefined;
103
+ return { makespan, criticalPath, timings, stdDev, probability };
104
+ }
105
+ export const criticalPathDialect = {
106
+ name: 'critical-path',
107
+ kind: 'scheduling',
108
+ capabilities: { exact: true, online: false },
109
+ solve(problem) {
110
+ return criticalPath(problem);
111
+ },
112
+ };
113
+ //# sourceMappingURL=critical-path.js.map
@@ -0,0 +1,61 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « forecast » (lissage exponentiel, Holt-Winters)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * PRÉVOIR UNE SÉRIE — sans dépendance, et sans prétendre à plus qu'elle ne peut.
6
+ *
7
+ * Le parc mesure : visites, dossiers déposés, présences, demandes de labellisation. Toutes ces
8
+ * séries servent à décider **à l'avance** — dimensionner une promotion, ouvrir une session
9
+ * supplémentaire — et rien dans `ro-pla` ne savait les prolonger.
10
+ *
11
+ * TROIS NIVEAUX, choisis automatiquement selon ce que la série contient :
12
+ * · **simple** — ni tendance ni saison : moyenne mobile pondérée (lissage α)
13
+ * · **holt** — tendance, pas de saison : deux lissages (α niveau, β tendance)
14
+ * · **holt-winters** — tendance ET saison de période `season` (γ saisonnalité)
15
+ *
16
+ * ─── CE QUE CE DIALECTE REFUSE DE FAIRE ─────────────────────────────────────────────────────
17
+ * Il ne prévoit PAS une série trop courte. Holt-Winters exige **au moins deux saisons complètes**
18
+ * pour distinguer une saison d'un accident ; avec moins, il retomberait sur du bruit et rendrait
19
+ * un chiffre d'apparence sérieuse. `refused` le dit, avec le nombre de points qu'il aurait fallu.
20
+ *
21
+ * Il rend aussi **l'erreur d'ajustement** (MAE et MAPE sur l'historique) : une prévision sans son
22
+ * erreur laisse croire à une précision qu'elle n'a pas.
23
+ *
24
+ * ⚠️ `exact: false` — une prévision n'est jamais exacte, et le dire est la moindre des choses.
25
+ */
26
+ import type { SolverDialect } from '../types.js';
27
+ export interface ForecastProblem {
28
+ kind?: 'simulation';
29
+ /** La série observée, dans l'ordre chronologique. */
30
+ series: number[];
31
+ /** Combien de points prévoir. */
32
+ horizon: number;
33
+ /** Période de la saison (12 mois, 7 jours…). 0 ou absent = pas de saison. */
34
+ season?: number;
35
+ alpha?: number;
36
+ beta?: number;
37
+ gamma?: number;
38
+ method?: 'auto' | 'simple' | 'holt' | 'holt-winters';
39
+ }
40
+ export interface ForecastSolution {
41
+ /** Les valeurs prévues. */
42
+ forecast: number[];
43
+ method: 'simple' | 'holt' | 'holt-winters';
44
+ /** Valeurs ajustées sur l'historique — pour tracer le modèle contre le réel. */
45
+ fitted: number[];
46
+ /** Erreur absolue moyenne. */
47
+ mae: number;
48
+ /** Erreur relative moyenne, en %. `null` si la série passe par zéro. */
49
+ mape: number | null;
50
+ /** Niveau, tendance et facteurs saisonniers finaux. */
51
+ level: number;
52
+ trend: number;
53
+ seasonal?: number[];
54
+ /** Refus motivé : série trop courte pour la méthode explicitement demandée. */
55
+ refused?: string;
56
+ /** RÉTROGRADATION SIGNALÉE : une saison était demandée, la série ne la portait pas. */
57
+ note?: string;
58
+ }
59
+ export declare function forecast(problem: ForecastProblem): ForecastSolution;
60
+ export declare const forecastDialect: SolverDialect<any, ForecastSolution>;
61
+ //# sourceMappingURL=forecast.d.ts.map
@@ -0,0 +1,116 @@
1
+ /**
2
+ * @mostajs/ro-pla — Dialecte « forecast » (lissage exponentiel, Holt-Winters)
3
+ * @author Dr Hamid MADANI <drmdh@msn.com>
4
+ *
5
+ * PRÉVOIR UNE SÉRIE — sans dépendance, et sans prétendre à plus qu'elle ne peut.
6
+ *
7
+ * Le parc mesure : visites, dossiers déposés, présences, demandes de labellisation. Toutes ces
8
+ * séries servent à décider **à l'avance** — dimensionner une promotion, ouvrir une session
9
+ * supplémentaire — et rien dans `ro-pla` ne savait les prolonger.
10
+ *
11
+ * TROIS NIVEAUX, choisis automatiquement selon ce que la série contient :
12
+ * · **simple** — ni tendance ni saison : moyenne mobile pondérée (lissage α)
13
+ * · **holt** — tendance, pas de saison : deux lissages (α niveau, β tendance)
14
+ * · **holt-winters** — tendance ET saison de période `season` (γ saisonnalité)
15
+ *
16
+ * ─── CE QUE CE DIALECTE REFUSE DE FAIRE ─────────────────────────────────────────────────────
17
+ * Il ne prévoit PAS une série trop courte. Holt-Winters exige **au moins deux saisons complètes**
18
+ * pour distinguer une saison d'un accident ; avec moins, il retomberait sur du bruit et rendrait
19
+ * un chiffre d'apparence sérieuse. `refused` le dit, avec le nombre de points qu'il aurait fallu.
20
+ *
21
+ * Il rend aussi **l'erreur d'ajustement** (MAE et MAPE sur l'historique) : une prévision sans son
22
+ * erreur laisse croire à une précision qu'elle n'a pas.
23
+ *
24
+ * ⚠️ `exact: false` — une prévision n'est jamais exacte, et le dire est la moindre des choses.
25
+ */
26
+ export function forecast(problem) {
27
+ const y = (problem.series ?? []).filter((v) => Number.isFinite(v));
28
+ const h = Math.max(0, Math.floor(problem.horizon ?? 0));
29
+ const m = Math.max(0, Math.floor(problem.season ?? 0));
30
+ const vide = { forecast: [], method: 'simple', fitted: [], mae: 0, mape: null, level: 0, trend: 0 };
31
+ if (y.length < 2)
32
+ return { ...vide, refused: 'série trop courte : au moins 2 points sont nécessaires' };
33
+ const demande = problem.method ?? 'auto';
34
+ let method;
35
+ let note;
36
+ // Une SAISON demandée que la série ne porte pas : on rétrograde, mais ON LE DIT. Rétrograder en
37
+ // silence rendrait un chiffre d'apparence sérieuse pour une question qu'on n'a pas traitée —
38
+ // l'appelant croirait avoir une prévision saisonnière.
39
+ const saisonPossible = m >= 2 && y.length >= 2 * m;
40
+ if (demande === 'holt-winters' && !saisonPossible) {
41
+ return { ...vide, refused: `Holt-Winters exige DEUX saisons complètes : ${2 * m} points pour une période de ${m}, or la série en compte ${y.length}` };
42
+ }
43
+ if (demande === 'auto') {
44
+ method = saisonPossible ? 'holt-winters' : (y.length >= 4 ? 'holt' : 'simple');
45
+ if (m >= 2 && !saisonPossible) {
46
+ note = `saison de ${m} DEMANDÉE mais non retenue : il faudrait ${2 * m} points, la série en compte ${y.length}. Méthode « ${method} » employée — la prévision n'est PAS saisonnière.`;
47
+ }
48
+ }
49
+ else {
50
+ method = demande;
51
+ }
52
+ const a = problem.alpha ?? 0.3;
53
+ const b = problem.beta ?? 0.1;
54
+ const g = problem.gamma ?? 0.1;
55
+ let niveau = y[0];
56
+ let tendance = method === 'simple' ? 0 : y[1] - y[0];
57
+ let saison = [];
58
+ const fitted = [];
59
+ if (method === 'holt-winters') {
60
+ // Initialisation saisonnière : moyenne de la première saison, puis écart relatif de chaque
61
+ // position. Une initialisation grossière fausse durablement la saison.
62
+ const moy1 = y.slice(0, m).reduce((s, v) => s + v, 0) / m;
63
+ niveau = moy1;
64
+ tendance = (y.slice(m, 2 * m).reduce((s, v) => s + v, 0) / m - moy1) / m;
65
+ saison = y.slice(0, m).map((v) => (moy1 !== 0 ? v / moy1 : 1));
66
+ }
67
+ for (let t = 0; t < y.length; t++) {
68
+ if (method === 'simple') {
69
+ fitted.push(niveau);
70
+ niveau = a * y[t] + (1 - a) * niveau;
71
+ }
72
+ else if (method === 'holt') {
73
+ fitted.push(niveau + tendance);
74
+ const prec = niveau;
75
+ niveau = a * y[t] + (1 - a) * (niveau + tendance);
76
+ tendance = b * (niveau - prec) + (1 - b) * tendance;
77
+ }
78
+ else {
79
+ const s = saison[t % m] || 1;
80
+ fitted.push((niveau + tendance) * s);
81
+ const prec = niveau;
82
+ niveau = a * (y[t] / (s || 1)) + (1 - a) * (niveau + tendance);
83
+ tendance = b * (niveau - prec) + (1 - b) * tendance;
84
+ saison[t % m] = g * (y[t] / (niveau || 1)) + (1 - g) * s;
85
+ }
86
+ }
87
+ const out = [];
88
+ for (let k = 1; k <= h; k++) {
89
+ if (method === 'simple')
90
+ out.push(niveau);
91
+ else if (method === 'holt')
92
+ out.push(niveau + k * tendance);
93
+ else
94
+ out.push((niveau + k * tendance) * (saison[(y.length + k - 1) % m] || 1));
95
+ }
96
+ // L'erreur se mesure APRÈS la première saison : les premiers points servent à initialiser, les
97
+ // compter comme des prévisions flatterait le modèle.
98
+ const depart = method === 'holt-winters' ? m : 1;
99
+ const ecarts = y.slice(depart).map((v, i) => Math.abs(v - fitted[i + depart]));
100
+ const mae = ecarts.length ? ecarts.reduce((s, v) => s + v, 0) / ecarts.length : 0;
101
+ const relatifs = y.slice(depart).map((v, i) => (v !== 0 ? Math.abs((v - fitted[i + depart]) / v) : null)).filter((x) => x !== null);
102
+ const mape = relatifs.length === y.length - depart && relatifs.length ? (relatifs.reduce((s, v) => s + v, 0) / relatifs.length) * 100 : null;
103
+ const res = { forecast: out, method, fitted, mae, mape, level: niveau, trend: tendance };
104
+ if (method === 'holt-winters')
105
+ res.seasonal = saison;
106
+ if (note)
107
+ res.note = note;
108
+ return res;
109
+ }
110
+ export const forecastDialect = {
111
+ name: 'forecast',
112
+ kind: 'simulation',
113
+ capabilities: { exact: false, online: true },
114
+ solve(problem) { return forecast(problem); },
115
+ };
116
+ //# sourceMappingURL=forecast.js.map
@@ -0,0 +1,59 @@
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 type { SolverDialect } from '../types.js';
28
+ export interface GeneticProblem<G = unknown> {
29
+ kind?: 'metaheuristic';
30
+ /** Population de départ — sa diversité conditionne tout le reste. */
31
+ population: G[];
32
+ /** Coût à MINIMISER (cohérent avec `anneal` et `tabu`). */
33
+ fitness: (g: G) => number;
34
+ crossover: (a: G, b: G, rng: () => number) => G;
35
+ mutate: (g: G, rng: () => number) => G;
36
+ generations?: number;
37
+ /** Probabilité de mutation d'un enfant (défaut 0.15). */
38
+ mutationRate?: number;
39
+ /** Nombre d'élites conservés tels quels (défaut 2). */
40
+ elite?: number;
41
+ /** Taille du tournoi de sélection (défaut 3). */
42
+ tournament?: number;
43
+ seed?: number;
44
+ /** Arrêt anticipé si le meilleur ne bouge pas pendant N générations. */
45
+ patience?: number;
46
+ }
47
+ export interface GeneticSolution<G = unknown> {
48
+ best: G;
49
+ bestFitness: number;
50
+ generations: number;
51
+ foundAt: number;
52
+ /** Génomes DISTINCTS dans la population finale — la diversité restante. */
53
+ diversity: number;
54
+ /** Meilleure valeur à chaque génération : dit si l'on progressait encore. */
55
+ history: number[];
56
+ }
57
+ export declare function genetic<G>(problem: GeneticProblem<G>): GeneticSolution<G>;
58
+ export declare const geneticDialect: SolverDialect<any, GeneticSolution>;
59
+ //# sourceMappingURL=genetic.d.ts.map