@mostajs/ro-pla 0.1.0 → 0.2.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +89 -0
- package/README.md +77 -92
- package/dist/dialects/bin-packing.d.ts +79 -0
- package/dist/dialects/bin-packing.js +128 -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 +14 -4
- 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,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
|
|
@@ -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
|