most-queue 2.8__tar.gz → 2.9__tar.gz

{most_queue-2.8 → most_queue-2.9}/.gitignore

@@ -198,4 +198,6 @@ docs/books/
 docs/статьи/
 works/queueing_systems_review/SRPT/pdf/
 works/experiments/rabbitmq_prefetch/
-works/reviews/
+works/reviews/
+# RDR paper PDF (external, not redistributed) — keep only COVERAGE.md audit
+works/articles/multichannel-pr/*.pdf

{most_queue-2.8 → most_queue-2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most_queue
-Version: 2.8
+Version: 2.9
 Summary: Software package for calculation and simulation of queuing systems
 Project-URL: Homepage, https://github.com/xabarov/most-queue
 Author-email: Xabarov Roman <xabarov1985@gmail.com>
@@ -43,7 +43,7 @@ Description-Content-Type: text/markdown
 
 # Most-Queue
 
-**Queueing theory in Python: exact analytical solvers paired with discrete-event simulation — for 40+ models from M/M/1 to SRPT scheduling, vacations, negative customers and queueing networks.**
+**Queueing theory in Python: exact analytical solvers paired with discrete-event simulation — for 50+ models from M/M/1 to multiserver-jobs, RDR priorities, SRPT scheduling, age of information, vacations and queueing networks.**
 
 [🇷🇺 Русская версия](README.ru.md)
 
@@ -52,6 +52,7 @@ Description-Content-Type: text/markdown
 [![Python versions](https://img.shields.io/pypi/pyversions/most-queue)](https://pypi.org/project/most-queue/)
 [![License](https://img.shields.io/pypi/l/most-queue)](https://github.com/xabarov/most-queue/blob/main/LICENSE)
 [![Downloads](https://static.pepy.tech/badge/most-queue)](https://pepy.tech/project/most-queue)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21268402.svg)](https://doi.org/10.5281/zenodo.21268402)
 [![GitHub commit activity](https://img.shields.io/github/commit-activity/m/xabarov/most-queue)](https://github.com/xabarov/most-queue/commits/main)
 
 <img src="https://raw.githubusercontent.com/xabarov/most-queue/main/assets/most-queue-nano1.jpeg" alt="Most-Queue banner" width="720"/>
@@ -106,7 +107,7 @@ print(f"Mean waiting time: theory {theory.w[0]:.3f} vs simulation {experiment.w[
 Computed by the library's own calculators — conditional slowdown `E[T(x)]/x` by job size
 for FCFS, PS, FB (blind) and SRPT (size-aware):
 
-<img src="https://raw.githubusercontent.com/xabarov/most-queue/main/docs/figures/slowdown_en.png" alt="Slowdown by job size for FCFS/PS/FB/SRPT" width="720"/>
+<img src="https://raw.githubusercontent.com/xabarov/most-queue/main/docs/figures/slowdown.png" alt="Slowdown by job size for FCFS/PS/FB/SRPT" width="720"/>
 
 See the executable comparison of **9 disciplines** in
 [`tutorials/disciplines_comparison.ipynb`](tutorials/disciplines_comparison.ipynb).
@@ -117,15 +118,19 @@ See the executable comparison of **9 disciplines** in
 |---|---|---|
 | Classic FIFO | M/M/c, M/M/c/r, Erlang B/C, M/G/1, GI/M/c, M/D/c, Eₖ/D/c, M/G/∞ | exact |
 | Multi-server phase-type | M/H₂/c, H₂/M/c, H₂/H₂/c (CV < 1 via complex fit) | Takahashi–Takami |
-| Size-based scheduling | M/G/1 SRPT, SJF, PSJF, SPJF (with size predictors), FB/LAS, PS, LCFS-PR | exact (Schrage–Miller, Mitzenmacher) |
-| Priorities | M/G/1 PR/NP multi-class, M/G/c PR/NP, M/Ph/c PR | exact / invariant approximation |
+| Size-based scheduling | M/G/1 SRPT, SJF, PSJF, SPJF (with size predictors + graceful-degradation curves), FB/LAS, PS, LCFS-PR | exact (Schrage–Miller, Mitzenmacher) |
+| Priorities | M/G/1 PR/NP multi-class, M/G/c PR/NP, M/Ph/c PR; **RDR** M/M/k & M/PH/k multi-class (exact + RDR-A), per-class response variance | exact / RDR / invariant approximation |
+| Multiserver-job (MSJ) | jobs holding several servers at once — FCFS response time, saturated-system stability/throughput | exact CTMC / saturated product-form |
+| Age of Information | M/M/1, M/G/1, preemptive-LCFS — average & peak AoI | closed-form + simulation |
 | Vacations & warm-up | M/G/1 multiple vacations, N-policy, warm-up/cooling/delay (M/Ph/c) | Fuhrmann–Cooper, Takahashi–Takami |
 | Negative customers | M/G/1 and M/G/c with RCS or disasters | exact / Takahashi–Takami |
 | Reliability | M/G/1 with breakdowns & repairs | Avi-Itzhak–Naor |
-| Matrix-analytic | MAP/PH/1, M/PH/1, PH/PH/1 — correlated (bursty) arrivals | QBD, logarithmic reduction |
+| Matrix-analytic (MAP/PH) | MAP/PH/1, M/PH/1, PH/PH/1, MAP/M/c, MAP/PH/c — correlated (bursty) arrivals, single- & multi-server; MMPP fitting | QBD, logarithmic reduction |
+| Batch Markovian arrivals | BMAP/M/1, BMAP/PH/1 — correlated batch traffic | level truncation |
 | Retrial & abandonment | M/M/1 and M/G/1 retrial (orbit), Erlang-A (M/M/n+M) with staffing | exact / Falin–Templeton |
 | GI/G approximations | GI/G/1, GI/G/m mean waiting time | Kingman, Krämer–Langenbach-Belz, Allen–Cunneen |
-| Batch, impatience, closed | Mˣ/M/1, M/M/1+M, Engset | exact |
+| Batch arrivals & bulk service | Mˣ/M/1 batch arrivals; M/M^[a,b]/1 bulk (batch) service — LLM inference batching | exact |
+| Impatience & closed | M/M/1+M, Engset | exact |
 | Parallel service | Fork-Join, Split-Join | Markovian / order statistics |
 | Networks | open networks, priority networks, networks with negative customers, routing optimization | decomposition |
 
@@ -136,7 +141,7 @@ Every model comes with a plain-language explanation and a diagram in the
 
 - 📖 [Documentation](docs/README.md) — concepts, calculation and simulation guides (English; Russian versions available via in-page switchers)
 - 🎓 [Jupyter tutorials](tutorials/) — from a first M/M/1 to Takahashi–Takami and SRPT
-- 🗺 [Development roadmaps](docs/epics/README.md) — what's next (matrix-analytic MAP/PH stack, retrial queues, Erlang-A)
+- 🗺 [Development roadmaps](docs/epics/README.md) — what's next (closed networks / MVA, multi-server retrial, polling)
 - 🧪 [Tests](tests/) — every model validated against simulation; run with `pytest -m "not slow"`
 
 ## Applications
@@ -147,10 +152,19 @@ scheduling research (SRPT/LAS with ML size predictions).
 
 ## Recent highlights
 
-- **2026** — **Matrix-analytic stack**: PH distributions and MAPs (`most_queue.random.map_ph`),
-  QBD solver with logarithmic reduction, exact MAP/PH/1 / M/PH/1 / PH/PH/1 calculators, MAP and
-  PH sources in the simulator; plus retrial queues (orbit) and Erlang-A abandonment with a
-  staffing helper. See [`tutorials/map_ph_correlation.ipynb`](tutorials/map_ph_correlation.ipynb).
+- **2026 (v2.9)** — **Datacenter & multi-priority wave**: **RDR** for multi-server multi-class
+  preemptive priorities (M/M/k and M/PH/k, exact + RDR-A, per-class response-time variance);
+  the **multiserver-job** model (jobs holding several servers at once — FCFS response time and
+  saturated-system stability, the first open-source implementation); **Age of Information**
+  (average & peak AoI); **bulk-service** queues for LLM inference batching; and
+  **graceful-degradation curves** for prediction-based scheduling. See the
+  [trends survey](docs/research/queueing-trends-2026.md).
+- **2026** — **Matrix-analytic MAP/PH stack**: PH distributions and MAPs
+  (`most_queue.random.map_ph`), a QBD solver with logarithmic reduction, and exact calculators
+  for MAP/PH/1, M/PH/1, PH/PH/1, **MAP/M/c**, **MAP/PH/c**, plus **BMAP/M/1** and **BMAP/PH/1**
+  for batch arrivals and **MMPP fitting** from data; MAP and PH sources in the simulator. Plus
+  retrial queues (orbit) and Erlang-A abandonment with a staffing helper.
+  See [`tutorials/map_ph_correlation.ipynb`](tutorials/map_ph_correlation.ipynb).
 - **2026** — Wave of exact classics: Erlang B/C, M/G/∞, GI/G approximations, M/G/1 vacation
   models (multiple vacations, N-policy), PS, LCFS-PR, FB/LAS, unreliable server — each with a
   paired simulator and tests. Illustrated model catalog with generated diagrams.
@@ -176,6 +190,7 @@ If you use Most-Queue in research, please cite it (see [`CITATION.cff`](CITATION
   author  = {Khabarov, Roman},
   title   = {Most-Queue: queueing theory calculations and simulation in Python},
   url     = {https://github.com/xabarov/most-queue},
+  doi     = {10.5281/zenodo.21268402},
   license = {MIT}
 }
 ```

{most_queue-2.8 → most_queue-2.9}/README.md

@@ -2,7 +2,7 @@
 
 # Most-Queue
 
-**Queueing theory in Python: exact analytical solvers paired with discrete-event simulation — for 40+ models from M/M/1 to SRPT scheduling, vacations, negative customers and queueing networks.**
+**Queueing theory in Python: exact analytical solvers paired with discrete-event simulation — for 50+ models from M/M/1 to multiserver-jobs, RDR priorities, SRPT scheduling, age of information, vacations and queueing networks.**
 
 [🇷🇺 Русская версия](README.ru.md)
 
@@ -11,6 +11,7 @@
 [![Python versions](https://img.shields.io/pypi/pyversions/most-queue)](https://pypi.org/project/most-queue/)
 [![License](https://img.shields.io/pypi/l/most-queue)](https://github.com/xabarov/most-queue/blob/main/LICENSE)
 [![Downloads](https://static.pepy.tech/badge/most-queue)](https://pepy.tech/project/most-queue)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21268402.svg)](https://doi.org/10.5281/zenodo.21268402)
 [![GitHub commit activity](https://img.shields.io/github/commit-activity/m/xabarov/most-queue)](https://github.com/xabarov/most-queue/commits/main)
 
 <img src="https://raw.githubusercontent.com/xabarov/most-queue/main/assets/most-queue-nano1.jpeg" alt="Most-Queue banner" width="720"/>
@@ -65,7 +66,7 @@ print(f"Mean waiting time: theory {theory.w[0]:.3f} vs simulation {experiment.w[
 Computed by the library's own calculators — conditional slowdown `E[T(x)]/x` by job size
 for FCFS, PS, FB (blind) and SRPT (size-aware):
 
-<img src="https://raw.githubusercontent.com/xabarov/most-queue/main/docs/figures/slowdown_en.png" alt="Slowdown by job size for FCFS/PS/FB/SRPT" width="720"/>
+<img src="https://raw.githubusercontent.com/xabarov/most-queue/main/docs/figures/slowdown.png" alt="Slowdown by job size for FCFS/PS/FB/SRPT" width="720"/>
 
 See the executable comparison of **9 disciplines** in
 [`tutorials/disciplines_comparison.ipynb`](tutorials/disciplines_comparison.ipynb).
@@ -76,15 +77,19 @@ See the executable comparison of **9 disciplines** in
 |---|---|---|
 | Classic FIFO | M/M/c, M/M/c/r, Erlang B/C, M/G/1, GI/M/c, M/D/c, Eₖ/D/c, M/G/∞ | exact |
 | Multi-server phase-type | M/H₂/c, H₂/M/c, H₂/H₂/c (CV < 1 via complex fit) | Takahashi–Takami |
-| Size-based scheduling | M/G/1 SRPT, SJF, PSJF, SPJF (with size predictors), FB/LAS, PS, LCFS-PR | exact (Schrage–Miller, Mitzenmacher) |
-| Priorities | M/G/1 PR/NP multi-class, M/G/c PR/NP, M/Ph/c PR | exact / invariant approximation |
+| Size-based scheduling | M/G/1 SRPT, SJF, PSJF, SPJF (with size predictors + graceful-degradation curves), FB/LAS, PS, LCFS-PR | exact (Schrage–Miller, Mitzenmacher) |
+| Priorities | M/G/1 PR/NP multi-class, M/G/c PR/NP, M/Ph/c PR; **RDR** M/M/k & M/PH/k multi-class (exact + RDR-A), per-class response variance | exact / RDR / invariant approximation |
+| Multiserver-job (MSJ) | jobs holding several servers at once — FCFS response time, saturated-system stability/throughput | exact CTMC / saturated product-form |
+| Age of Information | M/M/1, M/G/1, preemptive-LCFS — average & peak AoI | closed-form + simulation |
 | Vacations & warm-up | M/G/1 multiple vacations, N-policy, warm-up/cooling/delay (M/Ph/c) | Fuhrmann–Cooper, Takahashi–Takami |
 | Negative customers | M/G/1 and M/G/c with RCS or disasters | exact / Takahashi–Takami |
 | Reliability | M/G/1 with breakdowns & repairs | Avi-Itzhak–Naor |
-| Matrix-analytic | MAP/PH/1, M/PH/1, PH/PH/1 — correlated (bursty) arrivals | QBD, logarithmic reduction |
+| Matrix-analytic (MAP/PH) | MAP/PH/1, M/PH/1, PH/PH/1, MAP/M/c, MAP/PH/c — correlated (bursty) arrivals, single- & multi-server; MMPP fitting | QBD, logarithmic reduction |
+| Batch Markovian arrivals | BMAP/M/1, BMAP/PH/1 — correlated batch traffic | level truncation |
 | Retrial & abandonment | M/M/1 and M/G/1 retrial (orbit), Erlang-A (M/M/n+M) with staffing | exact / Falin–Templeton |
 | GI/G approximations | GI/G/1, GI/G/m mean waiting time | Kingman, Krämer–Langenbach-Belz, Allen–Cunneen |
-| Batch, impatience, closed | Mˣ/M/1, M/M/1+M, Engset | exact |
+| Batch arrivals & bulk service | Mˣ/M/1 batch arrivals; M/M^[a,b]/1 bulk (batch) service — LLM inference batching | exact |
+| Impatience & closed | M/M/1+M, Engset | exact |
 | Parallel service | Fork-Join, Split-Join | Markovian / order statistics |
 | Networks | open networks, priority networks, networks with negative customers, routing optimization | decomposition |
 
@@ -95,7 +100,7 @@ Every model comes with a plain-language explanation and a diagram in the
 
 - 📖 [Documentation](docs/README.md) — concepts, calculation and simulation guides (English; Russian versions available via in-page switchers)
 - 🎓 [Jupyter tutorials](tutorials/) — from a first M/M/1 to Takahashi–Takami and SRPT
-- 🗺 [Development roadmaps](docs/epics/README.md) — what's next (matrix-analytic MAP/PH stack, retrial queues, Erlang-A)
+- 🗺 [Development roadmaps](docs/epics/README.md) — what's next (closed networks / MVA, multi-server retrial, polling)
 - 🧪 [Tests](tests/) — every model validated against simulation; run with `pytest -m "not slow"`
 
 ## Applications
@@ -106,10 +111,19 @@ scheduling research (SRPT/LAS with ML size predictions).
 
 ## Recent highlights
 
-- **2026** — **Matrix-analytic stack**: PH distributions and MAPs (`most_queue.random.map_ph`),
-  QBD solver with logarithmic reduction, exact MAP/PH/1 / M/PH/1 / PH/PH/1 calculators, MAP and
-  PH sources in the simulator; plus retrial queues (orbit) and Erlang-A abandonment with a
-  staffing helper. See [`tutorials/map_ph_correlation.ipynb`](tutorials/map_ph_correlation.ipynb).
+- **2026 (v2.9)** — **Datacenter & multi-priority wave**: **RDR** for multi-server multi-class
+  preemptive priorities (M/M/k and M/PH/k, exact + RDR-A, per-class response-time variance);
+  the **multiserver-job** model (jobs holding several servers at once — FCFS response time and
+  saturated-system stability, the first open-source implementation); **Age of Information**
+  (average & peak AoI); **bulk-service** queues for LLM inference batching; and
+  **graceful-degradation curves** for prediction-based scheduling. See the
+  [trends survey](docs/research/queueing-trends-2026.md).
+- **2026** — **Matrix-analytic MAP/PH stack**: PH distributions and MAPs
+  (`most_queue.random.map_ph`), a QBD solver with logarithmic reduction, and exact calculators
+  for MAP/PH/1, M/PH/1, PH/PH/1, **MAP/M/c**, **MAP/PH/c**, plus **BMAP/M/1** and **BMAP/PH/1**
+  for batch arrivals and **MMPP fitting** from data; MAP and PH sources in the simulator. Plus
+  retrial queues (orbit) and Erlang-A abandonment with a staffing helper.
+  See [`tutorials/map_ph_correlation.ipynb`](tutorials/map_ph_correlation.ipynb).
 - **2026** — Wave of exact classics: Erlang B/C, M/G/∞, GI/G approximations, M/G/1 vacation
   models (multiple vacations, N-policy), PS, LCFS-PR, FB/LAS, unreliable server — each with a
   paired simulator and tests. Illustrated model catalog with generated diagrams.
@@ -135,6 +149,7 @@ If you use Most-Queue in research, please cite it (see [`CITATION.cff`](CITATION
   author  = {Khabarov, Roman},
   title   = {Most-Queue: queueing theory calculations and simulation in Python},
   url     = {https://github.com/xabarov/most-queue},
+  doi     = {10.5281/zenodo.21268402},
   license = {MIT}
 }
 ```

{most_queue-2.8 → most_queue-2.9}/docs/epics/README.md

@@ -46,3 +46,14 @@
 | [EPIC-003](EPIC-003-qbd-map-ph.md) | QBD/MAP/PH-стек (матрично-аналитические методы) | done |
 | [EPIC-004](EPIC-004-retrial-erlang-a.md) | Retrial-очереди и Erlang-A | done |
 | [EPIC-005](EPIC-005-illustrated-catalog.md) | Иллюстрированный каталог моделей (простые описания + схемы) | done |
+| [EPIC-006](EPIC-006-english-docs.md) | EN-центричная документация (перевод + двуязычные схемы) | done |
+| [EPIC-007](EPIC-007-map-phase2.md) | MAP-стек, фаза 2 (MAP/M/c, MAP/PH/c, фиттинг, BMAP/M/1) | done |
+| [EPIC-008](EPIC-008-map-phase3.md) | MAP-стек, фаза 3 (BMAP/PH/1 общего вида) | done |
+| [EPIC-009](EPIC-009-rdr-priority.md) | RDR: многоканальные многоприоритетные СМО (оптимизация G-матрицы + RDR-A + точная CTMC + фикс сходимости + аудит статьи) | done |
+| [EPIC-010](EPIC-010-age-of-information.md) | Age of Information (AoI/PAoI) — свежесть информации | done |
+| [EPIC-011](EPIC-011-multiserver-job.md) | Multiserver-job (MSJ): заявка занимает k серверов одновременно | done |
+| [EPIC-012](EPIC-012-bulk-service.md) | Bulk-service очереди (batching, LLM inference) | done |
+| [EPIC-013](EPIC-013-predictions-scheduling.md) | Планирование с предсказаниями (learning-augmented) | done |
+
+Направления EPIC-010…013 выбраны по обзору трендов сообщества:
+[../research/queueing-trends-2026.md](../research/queueing-trends-2026.md).

{most_queue-2.8 → most_queue-2.9}/most_queue/__init__.py

@@ -5,12 +5,18 @@ This package provides both simulation and numerical calculation methods
 for various types of queueing systems and networks.
 """
 
-__version__ = "2.7"
+from importlib.metadata import PackageNotFoundError, version
 
 # Import main simulation and theory classes for easy access
 from most_queue.sim.base import QsSim
 from most_queue.theory.base_queue import BaseQueue
 
+try:
+    # single source of truth for the version: the installed package metadata
+    __version__ = version("most-queue")
+except PackageNotFoundError:  # running from a source checkout that is not installed
+    __version__ = "0.0.0.dev0"
+
 __all__ = [
     "QsSim",
     "BaseQueue",

most_queue-2.9/most_queue/random/map_fit.py

@@ -0,0 +1,137 @@
+"""
+Fitting a Markovian Arrival Process (MAP) to data.
+
+The workhorse is the two-state MMPP (MMPP-2): a Poisson process whose rate
+switches between two levels driven by a two-state Markov chain. It is fitted
+by matching three interarrival statistics — the rate, the squared coefficient
+of variation (SCV) and the lag-1 autocorrelation — for which the MAP has
+closed-form expressions (see ``most_queue.random.map_ph``).
+
+An MMPP is always overdispersed and positively correlated: SCV >= 1 and
+lag-1 correlation >= 0. Targets outside this region cannot be represented by
+an MMPP-2 and raise a clear error.
+
+References:
+    Fischer W., Meier-Hellstern K. The Markov-modulated Poisson process (MMPP)
+        cookbook. Performance Evaluation, 18(2), 1993.
+        doi:10.1016/0166-5316(93)90035-s.
+    Heffes H., Lucantoni D. A Markov modulated characterization of packetized
+        voice and data traffic. IEEE JSAC, 4(6), 1986. doi:10.1109/JSAC.1986.1146428.
+"""
+
+import numpy as np
+from scipy.optimize import least_squares
+
+from most_queue.random.map_ph import MAP, MAPParams
+
+
+def map_statistics(params: MAPParams) -> tuple[float, float, float]:
+    """
+    Return (rate, scv, lag1) of a MAP: fundamental arrival rate, squared
+    coefficient of variation and lag-1 autocorrelation of interarrival times.
+    """
+    rate = MAP.arrival_rate(params)
+    moments = MAP.calc_theory_moments(params, 2)
+    m1, m2 = moments[0], moments[1]
+    scv = m2 / (m1 * m1) - 1.0
+    lag1 = MAP.lag_correlation(params, 1)
+    return rate, scv, lag1
+
+
+def _mmpp2_from_vector(x: np.ndarray) -> MAPParams:
+    """Build an MMPP-2 from log-parameters x = log([l1, l2, q12, q21])."""
+    l1, l2, q12, q21 = np.exp(x)
+    return MAP.mmpp([l1, l2], np.array([[-q12, q12], [q21, -q21]]))
+
+
+def fit_mmpp2(
+    rate: float,
+    scv: float,
+    lag1: float,
+    n_restarts: int = 6,
+    tol: float = 1e-9,
+) -> MAPParams:
+    """
+    Fit an MMPP-2 matching the given interarrival rate, SCV and lag-1
+    autocorrelation.
+
+    :param rate: target fundamental arrival rate (> 0)
+    :param scv: target squared coefficient of variation (>= 1 for an MMPP)
+    :param lag1: target lag-1 autocorrelation (>= 0 for an MMPP)
+    :param n_restarts: number of random restarts for the local optimizer
+    :param tol: acceptable residual norm to stop early
+    :return: MAPParams of the fitted MMPP-2
+    :raises ValueError: if the target is outside the MMPP-representable region
+    """
+    if rate <= 0:
+        raise ValueError(f"rate must be positive, got {rate}")
+    if scv < 1.0 - 1e-6:
+        raise ValueError(f"an MMPP-2 requires SCV >= 1 (overdispersed), got {scv:.4f}")
+    if lag1 < -1e-6:
+        raise ValueError(f"an MMPP-2 requires non-negative lag-1 correlation, got {lag1:.4f}")
+
+    target = np.array([rate, scv, lag1])
+    weights = np.array([1.0 / max(rate, 1e-9), 1.0, 1.0])
+
+    def residuals(x: np.ndarray) -> np.ndarray:
+        try:
+            stats = np.array(map_statistics(_mmpp2_from_vector(x)))
+        except (np.linalg.LinAlgError, ValueError):
+            return np.full(3, 1e3)
+        return (stats - target) * weights
+
+    rng = np.random.default_rng(12345)
+    best = np.log([rate, rate, 0.1 * rate + 1e-3, 0.1 * rate + 1e-3])
+    best_cost = np.inf
+    for k in range(max(1, n_restarts)):
+        if k == 0:
+            # deterministic heuristic start: rates spread by the overdispersion,
+            # slow switching to create the correlation
+            spread = 1.0 + np.sqrt(max(scv - 1.0, 0.0))
+            x0 = np.log([rate * spread, rate / spread, 0.1 * rate + 1e-3, 0.1 * rate + 1e-3])
+        else:
+            x0 = np.log(rate) + rng.uniform(-2.0, 2.0, size=4)
+        # trf (not lm): the 4-parameter MMPP-2 is under-determined by the
+        # 3 target statistics, so residuals < variables is expected
+        sol = least_squares(residuals, x0, method="trf", max_nfev=2000)
+        if sol.cost < best_cost:
+            best, best_cost = sol.x, sol.cost
+            if np.linalg.norm(sol.fun) < tol:
+                break
+
+    fitted = _mmpp2_from_vector(best)
+    achieved = map_statistics(fitted)
+    err = np.abs(np.array(achieved) - target) * weights
+    if np.max(err) > 1e-2:
+        raise ValueError(
+            f"failed to fit MMPP-2 to (rate={rate:.4f}, scv={scv:.4f}, lag1={lag1:.4f}); "
+            f"achieved (rate={achieved[0]:.4f}, scv={achieved[1]:.4f}, lag1={achieved[2]:.4f}). "
+            "The target may be near the boundary of the MMPP-representable region."
+        )
+    return fitted
+
+
+def trace_statistics(interarrivals) -> tuple[float, float, float]:
+    """
+    Empirical (rate, scv, lag1) of a sequence of interarrival times.
+    """
+    x = np.asarray(interarrivals, dtype=float)
+    if x.size < 3:
+        raise ValueError("need at least 3 interarrival samples")
+    mean = x.mean()
+    scv = x.var() / (mean * mean)
+    lag1 = float(np.corrcoef(x[:-1], x[1:])[0, 1])
+    return 1.0 / mean, scv, lag1
+
+
+def fit_map_from_trace(interarrivals, **kwargs) -> MAPParams:
+    """
+    Fit an MMPP-2 to a trace of interarrival times by matching its empirical
+    rate, SCV and lag-1 autocorrelation.
+
+    :param interarrivals: sequence of interarrival times
+    :param kwargs: forwarded to :func:`fit_mmpp2`
+    :return: MAPParams of the fitted MMPP-2
+    """
+    rate, scv, lag1 = trace_statistics(interarrivals)
+    return fit_mmpp2(rate, max(scv, 1.0), max(lag1, 0.0), **kwargs)

{most_queue-2.8 → most_queue-2.9}/most_queue/random/map_ph.py

@@ -43,6 +43,54 @@ class MAPParams:
     D1: np.ndarray  # transitions generating an arrival, shape (m, m)
 
 
+@dataclass
+class BMAPParams:
+    """
+    Batch Markovian Arrival Process parameters: a list of matrices
+    D[0], D[1], D[2], ... where D[0] holds phase transitions without arrivals
+    and D[k] (k >= 1) holds transitions that generate a batch of k arrivals.
+    sum_k D[k] is the generator of the phase process.
+    """
+
+    D: list  # [D0, D1, D2, ...], each an (m, m) matrix
+
+
+def bmap_poisson_batch(rate: float, batch_probs: list) -> BMAPParams:
+    """
+    Single-phase BMAP: batches arrive as a Poisson process of intensity
+    ``rate`` with batch-size probabilities ``batch_probs`` (batch_probs[k-1] is
+    P(batch size = k)). Equivalent to the M^[X]/... batch arrival stream.
+    """
+    p = np.asarray(batch_probs, dtype=float)
+    if abs(p.sum() - 1.0) > 1e-9 or np.any(p < 0):
+        raise ValueError("batch_probs must be a probability vector")
+    d = [np.array([[-rate]])]
+    for pk in p:
+        d.append(np.array([[rate * pk]]))
+    return BMAPParams(D=d)
+
+
+def bmap_from_map(params: MAPParams) -> BMAPParams:
+    """A MAP as a BMAP with only size-1 batches (D[1] = D1)."""
+    return BMAPParams(D=[np.asarray(params.D0, dtype=float), np.asarray(params.D1, dtype=float)])
+
+
+def bmap_arrival_rate(params: BMAPParams) -> float:
+    """
+    Fundamental arrival rate of a BMAP: pi @ (sum_k k * D[k]) @ 1, where pi is
+    the stationary distribution of the phase generator sum_k D[k].
+    """
+    mats = [np.asarray(x, dtype=float) for x in params.D]
+    gen = np.sum(mats, axis=0)
+    m = gen.shape[0]
+    a = np.vstack([gen.T, np.ones(m)])
+    b = np.zeros(m + 1)
+    b[-1] = 1.0
+    pi, *_ = np.linalg.lstsq(a, b, rcond=None)
+    batch_rate = np.sum([k * mats[k] for k in range(1, len(mats))], axis=0)
+    return float(pi @ batch_rate @ np.ones(m))
+
+
 def _validate_ph(alpha: np.ndarray, T: np.ndarray) -> None:
     if T.ndim != 2 or T.shape[0] != T.shape[1]:
         raise ValueError("T must be a square matrix")

most_queue-2.9/most_queue/sim/aoi.py

@@ -0,0 +1,133 @@
+"""
+Discrete-event simulator for Age of Information (AoI).
+
+Tracks the sawtooth age process Delta(t) = t - u(t), where u(t) is the
+generation time of the freshest *delivered* update, and reports the time-average
+AoI and the average peak AoI (PAoI). Supports FCFS, LCFS (non-preemptive) and
+LCFS-preemptive (a fresh arrival preempts and discards the in-service update)
+disciplines on one or more servers.
+"""
+
+from most_queue.random.utils.create import create_distribution
+from most_queue.sim.base_core import BaseSimulationCore
+from most_queue.structs import AoIResults
+
+
+class AoISim(BaseSimulationCore):
+    """
+    Age-of-Information simulator.
+
+    :param num_channels: number of servers.
+    :param discipline: "FCFS", "LCFS" (non-preemptive) or "LCFS-PR" (preemptive:
+        a new update preempts and discards the one in service).
+    :param seed: RNG seed for reproducible runs.
+    """
+
+    def __init__(self, num_channels: int = 1, discipline: str = "FCFS", seed: int | None = None):
+        super().__init__(seed=seed)
+        self.n = num_channels
+        self.discipline = discipline.upper()
+        if self.discipline == "LCFS-PR" and num_channels != 1:
+            raise ValueError("LCFS-PR is only supported for a single server")
+        self.source = None
+        self.server = None
+        self.is_sources_set = False
+        self.is_servers_set = False
+
+    def set_sources(self, params, kendall_notation: str = "M"):
+        """Set the arrival (update generation) process."""
+        self.source = create_distribution(params, kendall_notation, self.generator)
+        self.is_sources_set = True
+
+    def set_servers(self, params, kendall_notation: str = "M"):
+        """Set the service (update delivery) process."""
+        self.server = create_distribution(params, kendall_notation, self.generator)
+        self.is_servers_set = True
+
+    def run(self, num_updates: int, warmup_fraction: float = 0.05) -> AoIResults:
+        """
+        Run until `num_updates` fresh deliveries have been counted after warm-up.
+
+        :param warmup_fraction: initial fraction of deliveries discarded before
+            age accounting begins (removes transient bias).
+        """
+        if not (self.is_sources_set and self.is_servers_set):
+            raise RuntimeError("sources and servers must be set before run()")
+
+        INF = float("inf")
+        t = 0.0
+        next_arrival = self.source.generate()
+        server_done = [INF] * self.n  # completion time per server
+        server_gen = [0.0] * self.n  # generation time of the update in service
+        queue: list[float] = []  # generation times of waiting updates (arrival order)
+
+        freshest_gen = 0.0  # generation time of the freshest delivered update
+        area = 0.0  # integral of the age over the accounting window
+        peak_sum = 0.0
+        delivered = 0
+        counted = 0  # fresh deliveries counted after warm-up
+        accounting = False
+        acct_start_t = 0.0
+        last_t = 0.0
+        warmup = int(num_updates * warmup_fraction)
+        target = num_updates + warmup
+
+        def free_server():
+            for i in range(self.n):
+                if server_done[i] == INF:
+                    return i
+            return -1
+
+        def start(gen_time):
+            i = free_server()
+            server_gen[i] = gen_time
+            server_done[i] = t + self.server.generate()
+
+        while delivered < target:
+            done_idx = min(range(self.n), key=lambda i: server_done[i])
+            next_done = server_done[done_idx]
+
+            if next_arrival <= next_done:
+                # ---- arrival of a new update ----
+                t = next_arrival
+                next_arrival = t + self.source.generate()
+                gen = t
+                if self.discipline == "LCFS-PR":
+                    server_gen[0] = gen
+                    server_done[0] = t + self.server.generate()
+                elif free_server() != -1:
+                    start(gen)
+                else:
+                    queue.append(gen)
+            else:
+                # ---- delivery of an update ----
+                t = next_done
+                gen = server_gen[done_idx]
+                server_done[done_idx] = INF
+                delivered += 1
+                is_fresh = gen > freshest_gen
+
+                if accounting and is_fresh:
+                    # age grew as (t - freshest_gen) then resets: accumulate the
+                    # trapezoid and record the peak (age just before the reset)
+                    area += ((t - freshest_gen) ** 2 - (last_t - freshest_gen) ** 2) / 2.0
+                    peak_sum += t - freshest_gen
+                    last_t = t
+                    counted += 1
+                if is_fresh:
+                    freshest_gen = gen
+
+                if not accounting and delivered >= warmup:
+                    accounting = True
+                    acct_start_t = t
+                    last_t = t
+                    freshest_gen = gen
+
+                if queue:
+                    nxt = queue.pop() if self.discipline == "LCFS" else queue.pop(0)
+                    start(nxt)
+
+        # area is accumulated up to the last fresh delivery (last_t); the window
+        # is [acct_start_t, last_t]
+        window = max(last_t - acct_start_t, 1e-12)
+        return AoIResults(avg_aoi=area / window, peak_aoi=peak_sum / max(counted, 1))

{most_queue-2.8 → most_queue-2.9}/most_queue/sim/base.py

@@ -26,15 +26,16 @@ class QsSim(BaseSimulationCore):
     Base class for Queueing System Simulator
     """
 
-    def __init__(self, num_of_channels, buffer=None, verbose=True, buffer_type="list"):
+    def __init__(self, num_of_channels, buffer=None, verbose=True, buffer_type="list", seed=None):
         """
         Initialize the queueing system with GI/G/n/r or GI/G/n model.
         :param num_of_channels: int : number of channels in the system
         :param buffer: Optional(int, None) : maximum length of the queue, None if infinite
         :param verbose: bool : whether to print detailed information during simulation
         :param buffer_type: str : type of the buffer, "list" or "deque"
+        :param seed: Optional(int, None) : RNG seed for reproducible runs (None — non-deterministic)
         """
-        super().__init__()
+        super().__init__(seed=seed)
 
         self.n = num_of_channels
         self.buffer = buffer

{most_queue-2.8 → most_queue-2.9}/most_queue/sim/base_core.py

@@ -13,10 +13,14 @@ class BaseSimulationCore:
     Contains common attributes and methods shared across different simulator types.
     """
 
-    def __init__(self):
-        """Initialize the base simulation core."""
+    def __init__(self, seed: int | None = None):
+        """Initialize the base simulation core.
+
+        :param seed: optional RNG seed for reproducible simulation runs
+            (None — non-deterministic, as before).
+        """
         self.ttek = 0  # current simulation time
-        self.generator = np.random.default_rng()
+        self.generator = np.random.default_rng(seed)
         self.time_spent = 0
 
         # Statistics for busy periods