@mostajs/ro-pla 0.3.0 → 0.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +35 -0
- package/README.md +23 -1
- package/dist/dialects/milp.d.ts +14 -5
- package/dist/dialects/milp.js +73 -22
- package/dist/types.d.ts +47 -2
- package/llms.txt +17 -2
- package/package.json +2 -2
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,40 @@
|
|
|
1
1
|
# CHANGELOG
|
|
2
2
|
|
|
3
|
+
## [0.4.0] — 2026-11-22
|
|
4
|
+
|
|
5
|
+
### Ajouté — délai de calcul du branch & bound
|
|
6
|
+
|
|
7
|
+
Sur un PLNE dont la borne ne se referme pas (un besoin non couvrable : une équipe trop courte),
|
|
8
|
+
le branch & bound explorait tout son budget de nœuds — des minutes — et l'appelant n'avait que le
|
|
9
|
+
choix de l'arrêter de l'extérieur en perdant ce qui avait été trouvé. Il accepte désormais un délai
|
|
10
|
+
et rend la meilleure solution trouvée, son statut et l'écart à la borne (contrat inspiré de CP-SAT,
|
|
11
|
+
HiGHS, CBC et Gurobi).
|
|
12
|
+
|
|
13
|
+
- **`timeoutMs`** (déclaré dans `SolveOptions` depuis la 0.1, jamais lu jusqu'ici) : honoré par
|
|
14
|
+
`branch-and-bound`, contrôlé entre deux nœuds (dépassement ≤ une relaxation).
|
|
15
|
+
- **`anytime: true`** : le même contrat pour le seul budget `maxNodes`.
|
|
16
|
+
- **`now`** : horloge injectable (ms, défaut `Date.now`).
|
|
17
|
+
- Dans ce mode « au fil de l'eau », `status` vaut `optimal` (prouvé), **`feasible`** (meilleure
|
|
18
|
+
solution trouvée à la limite, non prouvée), **`unknown`** (limite atteinte sans solution entière,
|
|
19
|
+
rien de prouvé), `infeasible` ou `unbounded` (prouvés) ; et le champ **`search`** donne
|
|
20
|
+
`{ complete, stoppedBy: 'time' | 'nodes' | null, nodes, elapsedMs, bound, gap }`, avec
|
|
21
|
+
`gap` = |bound − objective| / |objective|.
|
|
22
|
+
- Types : `MilpStatus`, `MilpSearch` ; `MilpSolution` devient une interface (statut élargi,
|
|
23
|
+
`search?`). `LpSolution` et les autres dialectes ne changent pas.
|
|
24
|
+
|
|
25
|
+
### Inchangé — sans délai
|
|
26
|
+
|
|
27
|
+
Sans `timeoutMs` ni `anytime`, le résultat est celui de la 0.3.0 au champ près (essai T-RO-112,
|
|
28
|
+
sur des résultats enregistrés avec la 0.3.0). Cela comprend un **défaut connu, conservé pour la
|
|
29
|
+
compatibilité** : budget `maxNodes` atteint, la 0.3.0 répond `optimal` si un entier a été trouvé,
|
|
30
|
+
`infeasible` sinon — sans preuve dans les deux cas. Passer `anytime: true` pour un statut honnête.
|
|
31
|
+
|
|
32
|
+
### Interne
|
|
33
|
+
|
|
34
|
+
Le parcours en profondeur passe d'une récursion à une pile explicite, dans le même ordre (branche
|
|
35
|
+
`x ≤ ⌊v⌋` d'abord) : plus de limite de profondeur de pile, et la borne des nœuds ouverts se lit à
|
|
36
|
+
l'arrêt.
|
|
37
|
+
|
|
3
38
|
## [0.3.0] — 2026-11-15
|
|
4
39
|
|
|
5
40
|
### Corrigé — la famille seule ne suffisait pas à choisir le dialecte
|
package/README.md
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
# @mostajs/ro-pla
|
|
2
2
|
|
|
3
3
|
**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · **Licence** : AGPL-3.0-or-later
|
|
4
|
-
**Statut** : **0.
|
|
4
|
+
**Statut** : **0.4.0** — 23 dialectes, sélection par forme, `solvedBy`, branch & bound à délai de calcul, `examples/` exécutables.
|
|
5
5
|
|
|
6
6
|
**Programmation linéaire & recherche opérationnelle** pour l'écosystème `@mostajs/*`. Une question
|
|
7
7
|
métier se pose à un **registre**, qui choisit le dialecte dans la **famille** du problème (`kind`),
|
|
@@ -70,6 +70,28 @@ diverge du code.
|
|
|
70
70
|
récurrence d'Erlang B et la loi de Little, ce qui établit sa cohérence, pas sa conformité.
|
|
71
71
|
- Paquet ESM seul (condition `import`).
|
|
72
72
|
|
|
73
|
+
## Délai de calcul du branch & bound (0.4.0)
|
|
74
|
+
|
|
75
|
+
Un PLNE peut ne jamais refermer sa borne (besoin non couvrable : une équipe trop courte, un
|
|
76
|
+
entrepôt trop petit). Plutôt que de couper le calcul de l'extérieur et de tout perdre, on donne un
|
|
77
|
+
délai : le solveur rend la **meilleure solution trouvée**, dit si elle est **prouvée**, pourquoi il
|
|
78
|
+
s'est arrêté, et **l'écart à la borne** — comme CP-SAT, HiGHS, CBC ou Gurobi.
|
|
79
|
+
|
|
80
|
+
```js
|
|
81
|
+
const r = solve(probleme, { dialect: 'branch-and-bound', timeoutMs: 20_000 });
|
|
82
|
+
r.status; // 'optimal' (prouvé) | 'feasible' (meilleure trouvée) | 'unknown' (aucune) | 'infeasible' | 'unbounded'
|
|
83
|
+
r.search; // { complete: false, stoppedBy: 'time', nodes: 571, elapsedMs: 20012, bound: 15, gap: 0.0714 }
|
|
84
|
+
```
|
|
85
|
+
|
|
86
|
+
- `timeoutMs` (ms) : contrôlé entre deux nœuds ; le dépassement réel vaut au plus une relaxation.
|
|
87
|
+
- `anytime: true` : même contrat pour le seul budget `maxNodes` (statut honnête, champ `search`).
|
|
88
|
+
- `now` : horloge injectable (ms, défaut `Date.now`) — essais déterministes.
|
|
89
|
+
- `search.bound` : meilleure valeur encore possible (≥ objectif en max, ≤ en min) ; `search.gap` =
|
|
90
|
+
\|bound − objective\| / \|objective\| ; 0 si prouvé ; `null` sans solution.
|
|
91
|
+
- **Sans `timeoutMs` ni `anytime`, rien ne change** par rapport à la 0.3.0 (pas de `search`) — y
|
|
92
|
+
compris le défaut historique : budget `maxNodes` atteint, la 0.3.0 répond `optimal` sans preuve.
|
|
93
|
+
Pour un statut honnête, passer `anytime: true`.
|
|
94
|
+
|
|
73
95
|
## Ce que ce module ne fait PAS
|
|
74
96
|
|
|
75
97
|
Écrit ici parce qu'un module qui laisse croire est plus coûteux qu'un module qui manque. Annoncés
|
package/dist/dialects/milp.d.ts
CHANGED
|
@@ -5,11 +5,20 @@
|
|
|
5
5
|
* Programmation linéaire en nombres entiers (mixte) par SÉPARATION & ÉVALUATION :
|
|
6
6
|
* on résout la relaxation continue via le dialecte `simplex`, puis on BRANCHE sur
|
|
7
7
|
* une variable fractionnaire (x ≤ ⌊v⌋ | x ≥ ⌈v⌉) en élaguant les nœuds dont la
|
|
8
|
-
* borne ne peut battre l'incumbent. Exact ; bornable par `maxNodes` (anti-explosion)
|
|
8
|
+
* borne ne peut battre l'incumbent. Exact ; bornable par `maxNodes` (anti-explosion) et, depuis la
|
|
9
|
+
* 0.4.0, par un délai `timeoutMs` qui rend la meilleure solution trouvée et l'écart à la borne.
|
|
9
10
|
*/
|
|
10
|
-
import type {
|
|
11
|
-
/**
|
|
12
|
-
|
|
11
|
+
import type { MilpProblem, MilpSolution, SolveOptions, SolverDialect } from '../types.js';
|
|
12
|
+
/**
|
|
13
|
+
* Résout un PLNE/MIP par branch & bound (relaxation LP = simplexe), en profondeur d'abord
|
|
14
|
+
* (branche `x ≤ ⌊v⌋` avant `x ≥ ⌈v⌉`).
|
|
15
|
+
*
|
|
16
|
+
* Mode « au fil de l'eau » (0.4.0), dès que `opts.timeoutMs` est donné ou `opts.anytime` vrai :
|
|
17
|
+
* arrêt au délai ou au budget de nœuds avec la MEILLEURE solution trouvée, statut honnête
|
|
18
|
+
* (`optimal` prouvé, `feasible`, `unknown`, `infeasible`, `unbounded`) et compte rendu `search`
|
|
19
|
+
* (nœuds, durée, borne, écart). Sinon : le résultat de la 0.3.0, au champ près.
|
|
20
|
+
*/
|
|
21
|
+
export declare function branchAndBound(problem: MilpProblem, opts?: SolveOptions): MilpSolution;
|
|
13
22
|
/** Dialecte de solveur exposant le branch & bound (PLNE/MIP). */
|
|
14
|
-
export declare const milpDialect: SolverDialect<MilpProblem,
|
|
23
|
+
export declare const milpDialect: SolverDialect<MilpProblem, MilpSolution>;
|
|
15
24
|
//# sourceMappingURL=milp.d.ts.map
|
package/dist/dialects/milp.js
CHANGED
|
@@ -5,50 +5,72 @@
|
|
|
5
5
|
* Programmation linéaire en nombres entiers (mixte) par SÉPARATION & ÉVALUATION :
|
|
6
6
|
* on résout la relaxation continue via le dialecte `simplex`, puis on BRANCHE sur
|
|
7
7
|
* une variable fractionnaire (x ≤ ⌊v⌋ | x ≥ ⌈v⌉) en élaguant les nœuds dont la
|
|
8
|
-
* borne ne peut battre l'incumbent. Exact ; bornable par `maxNodes` (anti-explosion)
|
|
8
|
+
* borne ne peut battre l'incumbent. Exact ; bornable par `maxNodes` (anti-explosion) et, depuis la
|
|
9
|
+
* 0.4.0, par un délai `timeoutMs` qui rend la meilleure solution trouvée et l'écart à la borne.
|
|
9
10
|
*/
|
|
10
11
|
import { simplex } from './simplex.js';
|
|
11
12
|
const EPS = 1e-6;
|
|
12
13
|
const isInt = (v) => Math.abs(v - Math.round(v)) <= EPS;
|
|
13
|
-
/**
|
|
14
|
+
/**
|
|
15
|
+
* Résout un PLNE/MIP par branch & bound (relaxation LP = simplexe), en profondeur d'abord
|
|
16
|
+
* (branche `x ≤ ⌊v⌋` avant `x ≥ ⌈v⌉`).
|
|
17
|
+
*
|
|
18
|
+
* Mode « au fil de l'eau » (0.4.0), dès que `opts.timeoutMs` est donné ou `opts.anytime` vrai :
|
|
19
|
+
* arrêt au délai ou au budget de nœuds avec la MEILLEURE solution trouvée, statut honnête
|
|
20
|
+
* (`optimal` prouvé, `feasible`, `unknown`, `infeasible`, `unbounded`) et compte rendu `search`
|
|
21
|
+
* (nœuds, durée, borne, écart). Sinon : le résultat de la 0.3.0, au champ près.
|
|
22
|
+
*/
|
|
14
23
|
export function branchAndBound(problem, opts) {
|
|
15
24
|
const sense = problem.objective ?? 'max';
|
|
16
25
|
const n = problem.c.length;
|
|
17
26
|
const intIdx = problem.integers ?? Array.from({ length: n }, (_, j) => j);
|
|
18
27
|
const baseRel = problem.relations ?? problem.A.map(() => '<=');
|
|
19
28
|
const maxNodes = opts?.maxNodes ?? 100_000;
|
|
29
|
+
const timeoutMs = typeof opts?.timeoutMs === 'number' ? opts.timeoutMs : null;
|
|
30
|
+
const anytime = timeoutMs !== null || opts?.anytime === true;
|
|
31
|
+
const now = opts?.now ?? Date.now;
|
|
32
|
+
const t0 = anytime ? now() : 0;
|
|
20
33
|
// Incumbent : initialisé à une borne « pire que tout » ; `found` distingue
|
|
21
34
|
// l'absence de solution entière de la valeur sentinelle (évite un type `| null`).
|
|
22
35
|
let best = { x: [], objective: sense === 'max' ? -Infinity : Infinity };
|
|
23
36
|
let found = false;
|
|
24
37
|
let unbounded = false;
|
|
25
38
|
let nodes = 0;
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
39
|
+
let stoppedBy = null;
|
|
40
|
+
// Pile explicite : même ordre que la récursion de la 0.3.0 (le fils gauche est dépilé d'abord).
|
|
41
|
+
const open = [{ addA: [], addB: [], addRel: [], parentBound: sense === 'max' ? Infinity : -Infinity }];
|
|
42
|
+
while (open.length > 0) {
|
|
43
|
+
if (nodes >= maxNodes) {
|
|
44
|
+
stoppedBy = 'nodes';
|
|
45
|
+
break;
|
|
46
|
+
}
|
|
47
|
+
if (timeoutMs !== null && now() - t0 >= timeoutMs) {
|
|
48
|
+
stoppedBy = 'time';
|
|
49
|
+
break;
|
|
50
|
+
}
|
|
51
|
+
const node = open.pop();
|
|
30
52
|
nodes++;
|
|
31
53
|
const sol = simplex({
|
|
32
54
|
kind: 'lp',
|
|
33
55
|
c: problem.c,
|
|
34
|
-
A: [...problem.A, ...addA],
|
|
35
|
-
b: [...problem.b, ...addB],
|
|
36
|
-
relations: [...baseRel, ...addRel],
|
|
56
|
+
A: [...problem.A, ...node.addA],
|
|
57
|
+
b: [...problem.b, ...node.addB],
|
|
58
|
+
relations: [...baseRel, ...node.addRel],
|
|
37
59
|
objective: sense,
|
|
38
60
|
});
|
|
39
61
|
if (sol.status === 'infeasible')
|
|
40
|
-
|
|
62
|
+
continue;
|
|
41
63
|
if (sol.status === 'unbounded') {
|
|
42
64
|
unbounded = true;
|
|
43
|
-
|
|
65
|
+
break;
|
|
44
66
|
}
|
|
45
67
|
// Élagage par borne : la relaxation borne le sous-arbre ; si elle ne peut
|
|
46
68
|
// pas dépasser l'incumbent, inutile de descendre.
|
|
47
69
|
if (found) {
|
|
48
70
|
if (sense === 'max' && sol.objective <= best.objective + EPS)
|
|
49
|
-
|
|
71
|
+
continue;
|
|
50
72
|
if (sense === 'min' && sol.objective >= best.objective - EPS)
|
|
51
|
-
|
|
73
|
+
continue;
|
|
52
74
|
}
|
|
53
75
|
// Première variable entière encore fractionnaire ?
|
|
54
76
|
let frac = -1;
|
|
@@ -66,21 +88,50 @@ export function branchAndBound(problem, opts) {
|
|
|
66
88
|
best = { x, objective: sol.objective };
|
|
67
89
|
found = true;
|
|
68
90
|
}
|
|
69
|
-
|
|
91
|
+
continue;
|
|
70
92
|
}
|
|
71
|
-
// Branchement : x_frac ≤ ⌊v⌋ puis x_frac ≥ ⌈v
|
|
93
|
+
// Branchement : x_frac ≤ ⌊v⌋ puis x_frac ≥ ⌈v⌉ (empilé en second, dépilé en premier).
|
|
72
94
|
const v = sol.x[frac];
|
|
73
95
|
const row = new Array(n).fill(0);
|
|
74
96
|
row[frac] = 1;
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
}
|
|
78
|
-
|
|
97
|
+
open.push({ addA: [...node.addA, row.slice()], addB: [...node.addB, Math.ceil(v)], addRel: [...node.addRel, '>='], parentBound: sol.objective });
|
|
98
|
+
open.push({ addA: [...node.addA, row.slice()], addB: [...node.addB, Math.floor(v)], addRel: [...node.addRel, '<='], parentBound: sol.objective });
|
|
99
|
+
}
|
|
100
|
+
if (!anytime) {
|
|
101
|
+
// Contrat 0.3.0 : budget de nœuds atteint ⇒ `optimal` si un entier a été trouvé (sans preuve).
|
|
102
|
+
if (unbounded)
|
|
103
|
+
return { status: 'unbounded', x: [], objective: NaN };
|
|
104
|
+
if (!found)
|
|
105
|
+
return { status: 'infeasible', x: [], objective: NaN };
|
|
106
|
+
return { status: 'optimal', x: best.x, objective: best.objective };
|
|
107
|
+
}
|
|
108
|
+
const complete = stoppedBy === null;
|
|
109
|
+
const search = (bound, gap) => ({ complete, stoppedBy, nodes, elapsedMs: now() - t0, bound, gap });
|
|
79
110
|
if (unbounded)
|
|
80
|
-
return { status: 'unbounded', x: [], objective: NaN };
|
|
111
|
+
return { status: 'unbounded', x: [], objective: NaN, search: search(null, null) };
|
|
112
|
+
if (complete) {
|
|
113
|
+
if (!found)
|
|
114
|
+
return { status: 'infeasible', x: [], objective: NaN, search: search(null, null) };
|
|
115
|
+
return { status: 'optimal', x: best.x, objective: best.objective, search: search(best.objective, 0) };
|
|
116
|
+
}
|
|
117
|
+
// Arrêt avant la fin : la borne est la meilleure des relaxations parentes encore ouvertes,
|
|
118
|
+
// et l'incumbent (un nœud ouvert qui ne peut le battre serait élagué).
|
|
119
|
+
let bound = found ? best.objective : null;
|
|
120
|
+
for (const o of open) {
|
|
121
|
+
if (bound === null)
|
|
122
|
+
bound = o.parentBound;
|
|
123
|
+
else
|
|
124
|
+
bound = sense === 'max' ? Math.max(bound, o.parentBound) : Math.min(bound, o.parentBound);
|
|
125
|
+
}
|
|
126
|
+
if (bound !== null && !Number.isFinite(bound))
|
|
127
|
+
bound = null;
|
|
81
128
|
if (!found)
|
|
82
|
-
return { status: '
|
|
83
|
-
|
|
129
|
+
return { status: 'unknown', x: [], objective: NaN, search: search(bound, null) };
|
|
130
|
+
const gap = bound === null ? null
|
|
131
|
+
: Math.abs(bound - best.objective) <= EPS ? 0
|
|
132
|
+
: Math.abs(best.objective) <= EPS ? Infinity
|
|
133
|
+
: Math.abs(bound - best.objective) / Math.abs(best.objective);
|
|
134
|
+
return { status: 'feasible', x: best.x, objective: best.objective, search: search(bound, gap) };
|
|
84
135
|
}
|
|
85
136
|
/** Dialecte de solveur exposant le branch & bound (PLNE/MIP). */
|
|
86
137
|
export const milpDialect = {
|
package/dist/types.d.ts
CHANGED
|
@@ -28,8 +28,20 @@ export interface SolverCapabilities {
|
|
|
28
28
|
}
|
|
29
29
|
/** Options communes à `solve`. */
|
|
30
30
|
export interface SolveOptions {
|
|
31
|
+
/**
|
|
32
|
+
* Délai de calcul en millisecondes (0.4.0 : honoré par `branch-and-bound`). Contrôlé entre deux
|
|
33
|
+
* nœuds : le dépassement réel vaut au plus une relaxation. Active le mode « au fil de l'eau ».
|
|
34
|
+
*/
|
|
31
35
|
timeoutMs?: number;
|
|
36
|
+
/** Budget de nœuds (`branch-and-bound`, défaut 100 000). */
|
|
32
37
|
maxNodes?: number;
|
|
38
|
+
/**
|
|
39
|
+
* Mode « au fil de l'eau » (0.4.0, `branch-and-bound`) : statut honnête à la limite (`feasible`,
|
|
40
|
+
* `unknown`) et champ `search`. Implicite dès que `timeoutMs` est donné. Absent : comportement 0.3.0.
|
|
41
|
+
*/
|
|
42
|
+
anytime?: boolean;
|
|
43
|
+
/** Horloge en millisecondes (défaut `Date.now`) — injectable pour des essais déterministes. */
|
|
44
|
+
now?: () => number;
|
|
33
45
|
}
|
|
34
46
|
/** Un problème porte son `kind` (sert à choisir le dialecte). */
|
|
35
47
|
export interface Problem {
|
|
@@ -166,8 +178,41 @@ export interface MilpProblem extends Problem {
|
|
|
166
178
|
/** Indices des variables devant être entières (défaut : toutes). */
|
|
167
179
|
integers?: number[];
|
|
168
180
|
}
|
|
169
|
-
/**
|
|
170
|
-
|
|
181
|
+
/**
|
|
182
|
+
* Statut d'un PLNE. En mode « au fil de l'eau » (`timeoutMs` ou `anytime`) s'ajoutent :
|
|
183
|
+
* `feasible` — meilleure solution trouvée à la limite, non prouvée optimale ;
|
|
184
|
+
* `unknown` — limite atteinte sans solution entière, et rien de prouvé (ni optimum, ni infaisabilité).
|
|
185
|
+
* `optimal`, `infeasible`, `unbounded` restent des PREUVES (exploration complète).
|
|
186
|
+
*/
|
|
187
|
+
export type MilpStatus = LpStatus | 'feasible' | 'unknown';
|
|
188
|
+
/** Compte rendu de la recherche d'un PLNE en mode « au fil de l'eau » (0.4.0). */
|
|
189
|
+
export interface MilpSearch {
|
|
190
|
+
/** Exploration complète : le statut est prouvé. */
|
|
191
|
+
complete: boolean;
|
|
192
|
+
/** Cause de l'arrêt avant la fin : délai (`time`), budget de nœuds (`nodes`) ; `null` si complète. */
|
|
193
|
+
stoppedBy: 'time' | 'nodes' | null;
|
|
194
|
+
/** Nœuds explorés (relaxations résolues). */
|
|
195
|
+
nodes: number;
|
|
196
|
+
/** Durée mesurée par l'horloge (ms). */
|
|
197
|
+
elapsedMs: number;
|
|
198
|
+
/**
|
|
199
|
+
* Meilleure borne de l'objectif encore possible (borne duale) : ≥ objectif en max, ≤ en min.
|
|
200
|
+
* `null` si inconnue (aucune relaxation résolue, infaisable, non borné).
|
|
201
|
+
*/
|
|
202
|
+
bound: number | null;
|
|
203
|
+
/** Écart relatif |bound − objective| / |objective| (formule Gurobi/HiGHS) ; 0 si prouvé ; `null` sans solution. */
|
|
204
|
+
gap: number | null;
|
|
205
|
+
}
|
|
206
|
+
/** Solution d'un PLNE — un LP (statut + x entiers + objectif), plus `search` en mode « au fil de l'eau ». */
|
|
207
|
+
export interface MilpSolution {
|
|
208
|
+
status: MilpStatus;
|
|
209
|
+
/** Valeurs des variables ; `[]` sans solution. En `feasible` : la meilleure trouvée. */
|
|
210
|
+
x: number[];
|
|
211
|
+
/** Valeur de l'objectif ; `NaN` sans solution. */
|
|
212
|
+
objective: number;
|
|
213
|
+
/** Présent seulement si `timeoutMs` ou `anytime` a été donné. */
|
|
214
|
+
search?: MilpSearch;
|
|
215
|
+
}
|
|
171
216
|
/** Arc orienté capacité/coût d'un réseau de flot. */
|
|
172
217
|
export interface FlowArc {
|
|
173
218
|
from: number;
|
package/llms.txt
CHANGED
|
@@ -9,7 +9,7 @@
|
|
|
9
9
|
> (seul son tri par non-domination est repris dans `pareto`), simulation à événements discrets,
|
|
10
10
|
> contraintes globales cumulative, dualité / analyse de sensibilité.
|
|
11
11
|
|
|
12
|
-
- Version: 0.
|
|
12
|
+
- Version: 0.4.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
|
|
13
13
|
- Statut: 23 dialectes, 12 familles, 15 exacts / 8 approches.
|
|
14
14
|
|
|
15
15
|
## SÉLECTION (0.3.0) — À LIRE AVANT D'APPELER `solve`
|
|
@@ -90,6 +90,18 @@ famille et forme (comme `DB_DIALECT` pour un ORM).
|
|
|
90
90
|
(séparation & évaluation ; relaxation LP = `simplex` ; branche x≤⌊v⌋ | x≥⌈v⌉ ; élague par borne ;
|
|
91
91
|
bornable par `opts.maxNodes`). `MilpProblem` = LpProblem + `kind:'milp'` + `integers?:number[]`
|
|
92
92
|
(indices entiers, défaut toutes). Capacités `online:false` (combinatoire).
|
|
93
|
+
DÉLAI (0.4.0) — mode « au fil de l'eau », activé par `opts.timeoutMs` (ms) ou `opts.anytime: true` :
|
|
94
|
+
arrêt entre deux nœuds au délai ou au budget `maxNodes`, la MEILLEURE solution trouvée est rendue.
|
|
95
|
+
`status` : 'optimal' (PROUVÉ, exploration complète) | 'feasible' (meilleure trouvée, NON prouvée) |
|
|
96
|
+
'unknown' (limite atteinte sans solution entière, rien de prouvé) | 'infeasible' | 'unbounded' (prouvés).
|
|
97
|
+
+ `search { complete, stoppedBy:'time'|'nodes'|null, nodes, elapsedMs, bound, gap }` :
|
|
98
|
+
`bound` = meilleure borne encore possible (≥ objectif en max, ≤ en min ; null si inconnue),
|
|
99
|
+
`gap` = |bound − objective| / |objective| (0 si prouvé, null sans solution). `opts.now` : horloge
|
|
100
|
+
injectable (ms, défaut Date.now) pour des essais déterministes.
|
|
101
|
+
SANS `timeoutMs` ni `anytime` : résultat 0.3.0 au champ près (pas de `search`) — y compris le défaut
|
|
102
|
+
historique : budget `maxNodes` atteint ⇒ 'optimal' (ou 'infeasible') SANS preuve.
|
|
103
|
+
Exemple : `solve(p, { dialect:'branch-and-bound', timeoutMs: 20000 })` → accepter 'optimal' OU
|
|
104
|
+
'feasible' (lire `search.gap`), traiter 'unknown' comme « pas de réponse » (repli de l'appelant).
|
|
93
105
|
- Dialecte `min-cost-flow` (kind 'flow') : `minCostFlow(problem: FlowProblem) → FlowSolution`
|
|
94
106
|
(plus courts chemins successifs / Bellman-Ford-SPFA ; sans `value` → flot MAXIMAL au moindre
|
|
95
107
|
coût ; généralise le hongrois). `FlowProblem { kind:'flow', arcs:{from,to,capacity,cost}[],
|
|
@@ -212,7 +224,10 @@ famille et forme (comme `DB_DIALECT` pour un ORM).
|
|
|
212
224
|
ro-pla « quelle solution optimise / quel état stationnaire ? ».
|
|
213
225
|
|
|
214
226
|
## PIÈGES
|
|
215
|
-
- Explosion combinatoire (CSP, MILP) : borner par `opts.maxNodes
|
|
227
|
+
- Explosion combinatoire (CSP, MILP) : borner par `opts.maxNodes` ; MILP : `opts.timeoutMs` (0.4.0).
|
|
228
|
+
- MILP sous délai : exiger `status === 'optimal'` refuse une bonne solution `feasible` ; et sans
|
|
229
|
+
`timeoutMs`/`anytime`, un 'optimal' au budget `maxNodes` atteint n'est PAS prouvé (passer `anytime: true`).
|
|
230
|
+
- MILP sous délai : le temps est contrôlé ENTRE deux nœuds ; dépassement ≤ une relaxation (simplexe).
|
|
216
231
|
- Simplexe : règle de Bland contre le cyclage ; précision flottante.
|
|
217
232
|
- Markov : vérifier irréductibilité et apériodicité avant la distribution stationnaire.
|
|
218
233
|
- Métaheuristiques : déterministes à graine égale (`seed`) ; `exact: false`.
|
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@mostajs/ro-pla",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"description": "Recherche opérationnelle pour l'écosystème @mostajs/* : 23 dialectes (simplexe, branch & bound, flots, affectation, CSP, Markov, MDP, files M/M/c, ordonnancement, Pareto, métaheuristiques, prévision) sous un registre qui choisit par famille et forme du problème et dit qui a répondu (solvedBy). Zéro dépendance.",
|
|
3
|
+
"version": "0.4.0",
|
|
4
|
+
"description": "Recherche opérationnelle pour l'écosystème @mostajs/* : 23 dialectes (simplexe, branch & bound, flots, affectation, CSP, Markov, MDP, files M/M/c, ordonnancement, Pareto, métaheuristiques, prévision) sous un registre qui choisit par famille et forme du problème et dit qui a répondu (solvedBy) ; branch & bound à délai de calcul (meilleure solution, statut prouvé ou non, écart à la borne). Zéro dépendance.",
|
|
5
5
|
"author": "Dr Hamid MADANI <drmdh@msn.com>",
|
|
6
6
|
"license": "AGPL-3.0-or-later",
|
|
7
7
|
"type": "module",
|