@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 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.3.0** — 23 dialectes, sélection par forme, `solvedBy`, `examples/` exécutables.
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
@@ -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 { LpSolution, MilpProblem, SolveOptions, SolverDialect } from '../types.js';
11
- /** Résout un PLNE/MIP par branch & bound (relaxation LP = simplexe). */
12
- export declare function branchAndBound(problem: MilpProblem, opts?: SolveOptions): LpSolution;
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, LpSolution>;
23
+ export declare const milpDialect: SolverDialect<MilpProblem, MilpSolution>;
15
24
  //# sourceMappingURL=milp.d.ts.map
@@ -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
- /** Résout un PLNE/MIP par branch & bound (relaxation LP = simplexe). */
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
- // Un nœud = contraintes de branchement supplémentaires (lignes ajoutées à A/b).
27
- const explore = (addA, addB, addRel) => {
28
- if (unbounded || nodes >= maxNodes)
29
- return;
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
- return;
62
+ continue;
41
63
  if (sol.status === 'unbounded') {
42
64
  unbounded = true;
43
- return;
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
- return;
71
+ continue;
50
72
  if (sense === 'min' && sol.objective >= best.objective - EPS)
51
- return;
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
- return;
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
- explore([...addA, row.slice()], [...addB, Math.floor(v)], [...addRel, '<=']);
76
- explore([...addA, row.slice()], [...addB, Math.ceil(v)], [...addRel, '>=']);
77
- };
78
- explore([], [], []);
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: 'infeasible', x: [], objective: NaN };
83
- return { status: 'optimal', x: best.x, objective: best.objective };
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
- /** Solution d'un PLNE — même structure qu'un LP (statut + x entiers + objectif). */
170
- export type MilpSolution = LpSolution;
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.3.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
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.3.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",