most-queue 2.6__py3-none-any.whl → 2.8__py3-none-any.whl

most_queue/__init__.py

@@ -5,7 +5,7 @@ This package provides both simulation and numerical calculation methods
 for various types of queueing systems and networks.
 """
 
-__version__ = "2.05"
+__version__ = "2.7"
 
 # Import main simulation and theory classes for easy access
 from most_queue.sim.base import QsSim

most_queue/io/plots.py

@@ -17,6 +17,7 @@ class DependsType(Enum):
     UTILIZATION_FACTOR = 1
     CHANNELS_NUMBER = 2
     COEFFICIENT_OF_VARIATION = 3
+    NEGATIVE_RATE = 4
 
 
 class Plotter:
@@ -43,12 +44,26 @@ class Plotter:
         ax.set_ylabel(ylabel)
         if self.depends_on == DependsType.UTILIZATION_FACTOR:
             ax.set_xlabel(r"$\rho$")
+        elif self.depends_on == DependsType.NEGATIVE_RATE:
+            ax.set_xlabel(r"$\delta$")
         elif self.depends_on == DependsType.COEFFICIENT_OF_VARIATION:
             ax.set_xlabel(r"$\nu$")
         else:
             ax.set_xlabel("n")
             plt.xticks(range(1, len(self.xs) + 1))
 
+    @staticmethod
+    def _series_style():
+        """
+        Centralized plot style for series used in figures.
+        Keeps line styles (solid/dashed) but uses distinct colors for readability in print/PDF.
+        """
+        return {
+            "sim": {"color": "tab:orange", "linestyle": "--", "linewidth": 2.0},
+            "calc": {"color": "tab:blue", "linestyle": "-", "linewidth": 2.0},
+            "err": {"color": "tab:red", "linestyle": "-", "linewidth": 2.0},
+        }
+
     def plot_errors(self, save_path: str = None):
         """
         Plots the simulation and calculated moments for a given list of x values.
@@ -56,7 +71,8 @@ class Plotter:
         _fig, ax = plt.subplots()
         errors = [100 * (w_sim - w_tt) / w_tt for w_sim, w_tt in zip(self.sim_results, self.calc_results)]
 
-        ax.plot(self.xs, errors, color="black")
+        style = self._series_style()
+        ax.plot(self.xs, errors, **style["err"])
         self._configure_plot(ax, r"$\varepsilon$, %")
 
         if save_path is not None:
@@ -71,8 +87,9 @@ class Plotter:
         Plots the simulation and calculated queue waiting times.
         """
         _fig, ax = plt.subplots()
-        ax.plot(self.xs, self.sim_results, label="Sim", color="black", linestyle="--")
-        ax.plot(self.xs, self.calc_results, label="Calc", color="black")
+        style = self._series_style()
+        ax.plot(self.xs, self.sim_results, label="ИМ", **style["sim"])
+        ax.plot(self.xs, self.calc_results, label="Числ", **style["calc"])
         ax.legend()
         self._configure_plot(ax, r"$\omega_{1}$")
 
@@ -88,8 +105,9 @@ class Plotter:
         Plots the simulation and calculated sojourn times.
         """
         _fig, ax = plt.subplots()
-        ax.plot(self.xs, self.sim_results, label="Sim", color="black", linestyle="--")
-        ax.plot(self.xs, self.calc_results, label="Calc", color="black")
+        style = self._series_style()
+        ax.plot(self.xs, self.sim_results, label="ИМ", **style["sim"])
+        ax.plot(self.xs, self.calc_results, label="Числ", **style["calc"])
         ax.legend()
         self._configure_plot(ax, r"$\upsilon_{1}$")
 
@@ -99,3 +117,21 @@ class Plotter:
             plt.show()
 
         plt.close(_fig)
+
+    def plot_series(self, ylabel: str, save_path: str = None):
+        """
+        Generic plot: two series (sim vs calc) with a custom y-label.
+        """
+        _fig, ax = plt.subplots()
+        style = self._series_style()
+        ax.plot(self.xs, self.sim_results, label="ИМ", **style["sim"])
+        ax.plot(self.xs, self.calc_results, label="Числ", **style["calc"])
+        ax.legend()
+        self._configure_plot(ax, ylabel)
+
+        if save_path is not None:
+            plt.savefig(save_path, dpi=300)
+        else:
+            plt.show()
+
+        plt.close(_fig)

most_queue/misc/calc_v_pls.py

@@ -7,11 +7,11 @@ import math
 from functools import lru_cache
 
 import numpy as np
-from scipy.misc import derivative
 
 from most_queue.random.distributions import H2Distribution, H2Params
 from most_queue.theory.fifo.mgn_takahasi import MGnCalc, TakahashiTakamiParams
 from most_queue.theory.utils.conv import conv_moments
+from most_queue.theory.utils.derivative import derivative
 from most_queue.theory.utils.transforms import lst_exp
 
 

most_queue/random/distributions.py

@@ -251,6 +251,24 @@ class NormalDistribution(Distribution):
         std_dev = cv * mean
         return GaussianParams(mean, std_dev)
 
+    @staticmethod
+    def get_pdf(params: GaussianParams, t: float) -> float:
+        """
+        PDF of the Gaussian distribution. Returns 0 for t < 0 (truncated at zero).
+        """
+        if t < 0:
+            return 0.0
+        return float(stats.norm.pdf(t, loc=params.mean, scale=params.std_dev))
+
+    @staticmethod
+    def get_cdf(params: GaussianParams, t: float) -> float:
+        """
+        CDF of the Gaussian distribution. Returns 0 for t < 0 (truncated at zero).
+        """
+        if t < 0:
+            return 0.0
+        return float(stats.norm.cdf(t, loc=params.mean, scale=params.std_dev))
+
 
 class UniformDistribution(Distribution):
     """
@@ -637,6 +655,26 @@ class DeterministicDistribution(Distribution):
         b = f1
         return b
 
+    @staticmethod
+    def get_pdf(_params, _t: float) -> float:
+        """
+        Deterministic distribution has no density function.
+
+        Raises ``ValueError`` unconditionally — size-based SRPT/SJF/PSJF
+        formulas require a continuous service distribution.
+        """
+        raise ValueError(
+            "Deterministic distribution ('D') has no density function; "
+            "SRPT/SJF/PSJF formulas require a continuous service distribution."
+        )
+
+    @staticmethod
+    def get_cdf(params, t: float) -> float:
+        """
+        CDF of D(b): Heaviside step at b.  *params* is the deterministic value b (float).
+        """
+        return 0.0 if t < float(params) else 1.0
+
 
 class ParetoDistribution(Distribution):
     """
@@ -802,6 +840,16 @@ class ErlangDistribution(Distribution):
         """
         return 1.0 - ErlangDistribution.get_cdf(params, t)
 
+    @staticmethod
+    def get_pdf(params: ErlangParams, t: float) -> float:
+        """
+        PDF of the Erlang(r, mu) distribution: f(t) = mu^r * t^(r-1) * exp(-mu*t) / (r-1)!
+        """
+        if t < 0:
+            return 0.0
+        r, mu = params.r, params.mu
+        return (mu**r) * (t ** (r - 1)) * math.exp(-mu * t) / math.factorial(r - 1)
+
     @staticmethod
     def calc_theory_moments(params: ErlangParams, num: int = 3) -> list[float]:
         """
@@ -891,6 +939,20 @@ class ExpDistribution(Distribution):
         """
         return 1 / f1
 
+    @staticmethod
+    def get_pdf(params: float, t: float) -> float:
+        """
+        PDF of the exponential distribution with rate *params* (= mu = 1/mean).
+        """
+        return ErlangDistribution.get_pdf(ErlangParams(r=1, mu=params), t)
+
+    @staticmethod
+    def get_cdf(params: float, t: float) -> float:
+        """
+        CDF of the exponential distribution with rate *params* (= mu = 1/mean).
+        """
+        return ErlangDistribution.get_cdf(ErlangParams(r=1, mu=params), t)
+
 
 class GammaDistribution(Distribution):
     """

most_queue/random/map_ph.py

@@ -0,0 +1,282 @@
+"""
+Phase-type (PH) distributions and Markovian Arrival Processes (MAP).
+
+A PH distribution is the time to absorption of a CTMC with initial vector
+alpha and sub-generator T (absorption rates t0 = -T @ 1). A MAP is defined by
+matrices (D0, D1): D0 holds phase transitions without arrivals, D1 —
+transitions that generate an arrival; D0 + D1 is the generator of the phase
+process. MAPs model correlated (bursty) traffic; a renewal PH source and the
+MMPP are special cases.
+
+References:
+    Neuts M.F. Matrix-Geometric Solutions in Stochastic Models. Johns Hopkins
+        University Press, 1981.
+    Latouche G., Ramaswami V. Introduction to Matrix Analytic Methods in
+        Stochastic Modeling. SIAM, 1999. doi:10.1137/1.9780898719734.
+    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.
+"""
+
+import math
+from dataclasses import dataclass
+
+import numpy as np
+from scipy.linalg import expm
+
+from most_queue.random.utils.params import Cox2Params, ErlangParams, H2Params
+
+
+@dataclass
+class PHParams:
+    """Phase-type distribution parameters: initial vector and sub-generator."""
+
+    alpha: np.ndarray  # initial probability row vector, shape (m,)
+    T: np.ndarray  # sub-generator matrix, shape (m, m)
+
+
+@dataclass
+class MAPParams:
+    """Markovian Arrival Process parameters."""
+
+    D0: np.ndarray  # transitions without arrivals (sub-generator), shape (m, m)
+    D1: np.ndarray  # transitions generating an arrival, shape (m, 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")
+    if alpha.shape != (T.shape[0],):
+        raise ValueError(f"alpha shape {alpha.shape} does not match T {T.shape}")
+    if not math.isclose(float(np.sum(alpha)), 1.0, rel_tol=1e-9):
+        raise ValueError("alpha must sum to 1 (mass at zero is not supported)")
+    if np.any(np.diag(T) >= 0):
+        raise ValueError("diagonal of T must be negative")
+    exit_rates = -T @ np.ones(T.shape[0])
+    if np.any(exit_rates < -1e-12):
+        raise ValueError("row sums of T must be <= 0 (t0 = -T@1 must be non-negative)")
+
+
+class PHDistribution:
+    """
+    Phase-type distribution PH(alpha, T).
+
+    Follows the library's distribution interface: ``generate()`` draws a
+    sample by simulating the absorbing CTMC, static ``calc_theory_moments``
+    returns raw moments m_k = k! * alpha @ (-T)^{-k} @ 1.
+    """
+
+    def __init__(self, params: PHParams, generator=None):
+        self.params = params
+        self.alpha = np.asarray(params.alpha, dtype=float)
+        self.T = np.asarray(params.T, dtype=float)
+        _validate_ph(self.alpha, self.T)
+        self.t0 = -self.T @ np.ones(self.T.shape[0])
+        self.type = "PH"
+        self.generator = generator if generator is not None else np.random.default_rng()
+
+    # ------------------------------------------------------------- theory
+    @staticmethod
+    def calc_theory_moments(params: PHParams, num: int = 4) -> list[float]:
+        """
+        Raw moments of PH(alpha, T): m_k = k! * alpha @ (-T)^{-k} @ 1.
+        """
+        alpha = np.asarray(params.alpha, dtype=float)
+        T = np.asarray(params.T, dtype=float)
+        m_inv = np.linalg.inv(-T)
+        ones = np.ones(T.shape[0])
+        moments, vec = [], alpha.copy()
+        for k in range(1, num + 1):
+            vec = vec @ m_inv
+            moments.append(math.factorial(k) * float(vec @ ones))
+        return moments
+
+    @staticmethod
+    def get_pdf(params: PHParams, x: float) -> float:
+        """Probability density f(x) = alpha @ expm(T x) @ t0."""
+        alpha = np.asarray(params.alpha, dtype=float)
+        T = np.asarray(params.T, dtype=float)
+        t0 = -T @ np.ones(T.shape[0])
+        return float(alpha @ expm(T * x) @ t0) if x >= 0 else 0.0
+
+    @staticmethod
+    def get_cdf(params: PHParams, x: float) -> float:
+        """Cumulative distribution F(x) = 1 - alpha @ expm(T x) @ 1."""
+        alpha = np.asarray(params.alpha, dtype=float)
+        T = np.asarray(params.T, dtype=float)
+        return 1.0 - float(alpha @ expm(T * x) @ np.ones(T.shape[0])) if x >= 0 else 0.0
+
+    # ---------------------------------------------------------- converters
+    @staticmethod
+    def from_exp(mu: float) -> PHParams:
+        """Exponential(mu) as a single-phase PH."""
+        return PHParams(alpha=np.array([1.0]), T=np.array([[-mu]]))
+
+    @staticmethod
+    def from_erlang(params: ErlangParams) -> PHParams:
+        """Erlang-r as a chain of r exponential phases."""
+        r, mu = params.r, params.mu
+        T = -mu * np.eye(r) + mu * np.eye(r, k=1)
+        alpha = np.zeros(r)
+        alpha[0] = 1.0
+        return PHParams(alpha=alpha, T=T)
+
+    @staticmethod
+    def from_h2(params: H2Params) -> PHParams:
+        """Hyperexponential H2 (real parameters only) as a two-phase PH."""
+        p1, mu1, mu2 = float(params.p1.real), float(params.mu1.real), float(params.mu2.real)
+        return PHParams(alpha=np.array([p1, 1.0 - p1]), T=np.array([[-mu1, 0.0], [0.0, -mu2]]))
+
+    @staticmethod
+    def from_cox(params: Cox2Params) -> PHParams:
+        """Second-order Coxian as a two-phase PH."""
+        mu1, mu2, p1 = float(params.mu1.real), float(params.mu2.real), float(params.p1.real)
+        return PHParams(alpha=np.array([1.0, 0.0]), T=np.array([[-mu1, p1 * mu1], [0.0, -mu2]]))
+
+    # ------------------------------------------------------------ sampling
+    def generate(self) -> float:
+        """Draw one sample by simulating the absorbing phase process."""
+        rng = self.generator
+        m = self.T.shape[0]
+        phase = int(rng.choice(m, p=self.alpha))
+        elapsed = 0.0
+        while True:
+            rate = -self.T[phase, phase]
+            elapsed += rng.exponential(1.0 / rate)
+            # transition probabilities from `phase`: to other phases or absorb
+            probs = np.append(self.T[phase].copy(), self.t0[phase])
+            probs[phase] = 0.0
+            probs /= rate
+            nxt = int(rng.choice(m + 1, p=probs))
+            if nxt == m:
+                return elapsed
+            phase = nxt
+
+
+class MAP:
+    """
+    Markovian Arrival Process MAP(D0, D1).
+
+    ``generate()`` returns successive interarrival times (the phase is kept
+    between calls, starting from the arrival-stationary distribution).
+    """
+
+    def __init__(self, params: MAPParams, generator=None):
+        self.params = params
+        self.D0 = np.asarray(params.D0, dtype=float)
+        self.D1 = np.asarray(params.D1, dtype=float)
+        if self.D0.shape != self.D1.shape or self.D0.ndim != 2 or self.D0.shape[0] != self.D0.shape[1]:
+            raise ValueError("D0 and D1 must be square matrices of the same shape")
+        gen_row_sums = (self.D0 + self.D1) @ np.ones(self.D0.shape[0])
+        if not np.allclose(gen_row_sums, 0.0, atol=1e-9):
+            raise ValueError("D0 + D1 must be a generator (zero row sums)")
+        if np.any(self.D1 < -1e-12):
+            raise ValueError("D1 must be non-negative")
+        self.type = "MAP"
+        self.generator = generator if generator is not None else np.random.default_rng()
+        self._phase = int(self.generator.choice(self.D0.shape[0], p=MAP.arrival_stationary_phase(params)))
+
+    # ------------------------------------------------------------- theory
+    @staticmethod
+    def phase_stationary(params: MAPParams) -> np.ndarray:
+        """Stationary distribution pi of the phase generator D = D0 + D1."""
+        d = np.asarray(params.D0, dtype=float) + np.asarray(params.D1, dtype=float)
+        m = d.shape[0]
+        a = np.vstack([d.T, np.ones(m)])
+        b = np.zeros(m + 1)
+        b[-1] = 1.0
+        pi, *_ = np.linalg.lstsq(a, b, rcond=None)
+        return pi
+
+    @staticmethod
+    def arrival_rate(params: MAPParams) -> float:
+        """Fundamental arrival rate lambda = pi @ D1 @ 1."""
+        pi = MAP.phase_stationary(params)
+        return float(pi @ np.asarray(params.D1, dtype=float) @ np.ones(len(pi)))
+
+    @staticmethod
+    def arrival_stationary_phase(params: MAPParams) -> np.ndarray:
+        """Phase distribution just after an arrival: pi @ D1 / lambda."""
+        pi = MAP.phase_stationary(params)
+        d1 = np.asarray(params.D1, dtype=float)
+        vec = pi @ d1
+        return vec / vec.sum()
+
+    @staticmethod
+    def calc_theory_moments(params: MAPParams, num: int = 4) -> list[float]:
+        """
+        Raw moments of the stationary interarrival time:
+        m_k = k! * pi_a @ (-D0)^{-k} @ 1.
+        """
+        pi_a = MAP.arrival_stationary_phase(params)
+        m_inv = np.linalg.inv(-np.asarray(params.D0, dtype=float))
+        ones = np.ones(len(pi_a))
+        moments, vec = [], pi_a.copy()
+        for k in range(1, num + 1):
+            vec = vec @ m_inv
+            moments.append(math.factorial(k) * float(vec @ ones))
+        return moments
+
+    @staticmethod
+    def lag_correlation(params: MAPParams, k: int = 1) -> float:
+        """
+        Lag-k autocorrelation of interarrival times:
+        corr(X_0, X_k) with E[X_0 X_k] = pi_a @ M @ P^k @ M @ 1, M = (-D0)^{-1},
+        P = M @ D1 (phase transition matrix over one arrival).
+        """
+        if k < 1:
+            raise ValueError("lag k must be >= 1")
+        pi_a = MAP.arrival_stationary_phase(params)
+        m_inv = np.linalg.inv(-np.asarray(params.D0, dtype=float))
+        p = m_inv @ np.asarray(params.D1, dtype=float)
+        ones = np.ones(len(pi_a))
+        m1 = float(pi_a @ m_inv @ ones)
+        m2 = 2.0 * float(pi_a @ m_inv @ m_inv @ ones)
+        joint = float(pi_a @ m_inv @ np.linalg.matrix_power(p, k) @ m_inv @ ones)
+        var = m2 - m1 * m1
+        return (joint - m1 * m1) / var
+
+    # ---------------------------------------------------------- factories
+    @staticmethod
+    def poisson(rate: float) -> MAPParams:
+        """Poisson process as a trivial one-phase MAP."""
+        return MAPParams(D0=np.array([[-rate]]), D1=np.array([[rate]]))
+
+    @staticmethod
+    def from_ph_renewal(ph: PHParams) -> MAPParams:
+        """Renewal process with PH interarrival times: D0 = T, D1 = t0 @ alpha."""
+        alpha = np.asarray(ph.alpha, dtype=float)
+        T = np.asarray(ph.T, dtype=float)
+        t0 = -T @ np.ones(T.shape[0])
+        return MAPParams(D0=T, D1=np.outer(t0, alpha))
+
+    @staticmethod
+    def mmpp(rates: list[float], q: np.ndarray) -> MAPParams:
+        """
+        Markov-modulated Poisson process: Poisson rate rates[i] while the
+        modulating chain (generator q) is in state i.
+        """
+        rates_arr = np.asarray(rates, dtype=float)
+        q_arr = np.asarray(q, dtype=float)
+        if not np.allclose(q_arr @ np.ones(q_arr.shape[0]), 0.0, atol=1e-9):
+            raise ValueError("q must be a generator (zero row sums)")
+        return MAPParams(D0=q_arr - np.diag(rates_arr), D1=np.diag(rates_arr))
+
+    # ------------------------------------------------------------ sampling
+    def generate(self) -> float:
+        """Time until the next arrival (phase state persists between calls)."""
+        rng = self.generator
+        m = self.D0.shape[0]
+        elapsed = 0.0
+        while True:
+            rate = -self.D0[self._phase, self._phase]
+            elapsed += rng.exponential(1.0 / rate)
+            # competing transitions: D0 off-diagonal (no arrival) vs any D1 entry
+            probs = np.concatenate([self.D0[self._phase], self.D1[self._phase]])
+            probs[self._phase] = 0.0
+            probs = probs / rate
+            nxt = int(rng.choice(2 * m, p=probs))
+            if nxt >= m:
+                self._phase = nxt - m
+                return elapsed
+            self._phase = nxt

most_queue/random/utils/create.py

@@ -63,6 +63,15 @@ def create_distribution(params, kendall_notation: str, generator):
         dist = NormalDistribution(params, generator=generator)
     elif kendall_notation == "D":
         dist = DeterministicDistribution(params)
+    elif kendall_notation == "PH":
+        # local import: map_ph pulls in scipy.linalg, keep base import light
+        from most_queue.random.map_ph import PHDistribution  # pylint: disable=import-outside-toplevel
+
+        dist = PHDistribution(params, generator=generator)
+    elif kendall_notation == "MAP":
+        from most_queue.random.map_ph import MAP  # pylint: disable=import-outside-toplevel
+
+        dist = MAP(params, generator=generator)
     else:
         raise ValueError(
             "Incorrect distribution type specified. See most_queue.random.distributions.print_supported_distributions() for list of supported distributions"

most_queue/sim/__init__.py

@@ -6,5 +6,6 @@ various types of queueing systems and networks.
 """
 
 from most_queue.sim.base import QsSim
+from most_queue.sim.size_based import PerfectSimPredictor, SizeBasedQsSim, SizePredictor
 
-__all__ = ["QsSim"]
+__all__ = ["QsSim", "SizeBasedQsSim", "SizePredictor", "PerfectSimPredictor"]