most-queue 1.62__tar.gz → 1.63__tar.gz

{most_queue-1.62 → most_queue-1.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most_queue
-Version: 1.62
+Version: 1.63
 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>
@@ -104,15 +104,14 @@ Most_queue consists of two main parts:
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
 | 1.  | M/Ph/c/PR     |  Numerical calculation of QS M/Ph/c with 2 classes and PR - priority. Based on the approximation of busy periods            | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_m_ph_n_prty.py) | |
 | 2.  | M/M/c/PR           |  Numerical calculation of QS M/M/c with 2 classes, PR - priority by the Takahashi-Takami numerical method based on the approximation of the busy period by the Cox distribution      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mmn_prty_pnz_approx.py) | |
-| 3.  | M/M/c/PR           |  Numerical calculation of QS M/M/c with 3 classes, PR - priority by the Takahashi-Takami numerical method based on the approximation of busy period by the Cox distribution     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mmn3_pnz_cox_approx.py) | |
-| 4.  | M/G/1/PR           |  Calculating QS with preemtive priorities (single-channel).     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
-| 5.  | M/G/1/NP           |  Calculating QS with non-preemtive priorities (single-channel).     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
-| 6.  | M/G/c/Priority           | Calculating QS with NP and PR (multi-channel) by method of relation      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
+| 3.  | M/G/1/PR           |  Calculating QS with preemtive priorities (single-channel).     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
+| 4.  | M/G/1/NP           |  Calculating QS with non-preemtive priorities (single-channel).     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
+| 5.  | M/G/c/Priority           | Calculating QS with NP and PR (multi-channel) by method of relation      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
 
 ### Queueing Systems with Vacations
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
-| 1.  | M/H<SUB>2</SUB>/c          |  Numerical calculation of the M/H<SUB>2</SUB>/c system with H<SUB>2</SUB>-warming using the Takahasi-Takagi method.      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_m_h2_h2warm.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/m_h2_h2warm.ipynb)| |
+| 1.  | M/H<SUB>2</SUB>/c          |  Numerical calculation of the M/H<SUB>2</SUB>/c system with H<SUB>2</SUB>-warming using the Takahashi-Takami method.      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_m_h2_h2warm.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/m_h2_h2warm.ipynb)| |
 | 2.  | M/G/1           | Solving for QS M/G/1 with warm-up       |  | |
 | 3.  | M/Ph/c         |  Multichannel queuing system with H<SUB>2</SUB>-serving time, H<SUB>2</SUB>-warm-up, H<SUB>2</SUB>-cold delay and H<SUB>2</SUB>-cold (vacations). The system uses complex parameters, which allows you to calculate systems with arbitrary serving, warm-up, cold-delay and cold variation coefficients | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mgn_with_h2_delay_cold_warm.py) | |
 | 4.  | M/M/c          |  Multichannel queuing system with exp serving time, H<SUB>2</SUB>-warm-up and H<SUB>2</SUB>-cold (vacations). The system uses complex parameters, which allows to calculate systems with arbitrary warm-up and cold variation coefficients    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mmn_h2cold_h2warm.py) | |

{most_queue-1.62 → most_queue-1.63}/README.md

@@ -63,15 +63,14 @@ Most_queue consists of two main parts:
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
 | 1.  | M/Ph/c/PR     |  Numerical calculation of QS M/Ph/c with 2 classes and PR - priority. Based on the approximation of busy periods            | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_m_ph_n_prty.py) | |
 | 2.  | M/M/c/PR           |  Numerical calculation of QS M/M/c with 2 classes, PR - priority by the Takahashi-Takami numerical method based on the approximation of the busy period by the Cox distribution      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mmn_prty_pnz_approx.py) | |
-| 3.  | M/M/c/PR           |  Numerical calculation of QS M/M/c with 3 classes, PR - priority by the Takahashi-Takami numerical method based on the approximation of busy period by the Cox distribution     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mmn3_pnz_cox_approx.py) | |
-| 4.  | M/G/1/PR           |  Calculating QS with preemtive priorities (single-channel).     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
-| 5.  | M/G/1/NP           |  Calculating QS with non-preemtive priorities (single-channel).     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
-| 6.  | M/G/c/Priority           | Calculating QS with NP and PR (multi-channel) by method of relation      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
+| 3.  | M/G/1/PR           |  Calculating QS with preemtive priorities (single-channel).     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
+| 4.  | M/G/1/NP           |  Calculating QS with non-preemtive priorities (single-channel).     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
+| 5.  | M/G/c/Priority           | Calculating QS with NP and PR (multi-channel) by method of relation      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_prty.py) |[link](https://github.com/xabarov/most-queue/blob/main/tutorials/priority_queue.ipynb)  |
 
 ### Queueing Systems with Vacations
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
-| 1.  | M/H<SUB>2</SUB>/c          |  Numerical calculation of the M/H<SUB>2</SUB>/c system with H<SUB>2</SUB>-warming using the Takahasi-Takagi method.      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_m_h2_h2warm.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/m_h2_h2warm.ipynb)| |
+| 1.  | M/H<SUB>2</SUB>/c          |  Numerical calculation of the M/H<SUB>2</SUB>/c system with H<SUB>2</SUB>-warming using the Takahashi-Takami method.      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_m_h2_h2warm.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/m_h2_h2warm.ipynb)| |
 | 2.  | M/G/1           | Solving for QS M/G/1 with warm-up       |  | |
 | 3.  | M/Ph/c         |  Multichannel queuing system with H<SUB>2</SUB>-serving time, H<SUB>2</SUB>-warm-up, H<SUB>2</SUB>-cold delay and H<SUB>2</SUB>-cold (vacations). The system uses complex parameters, which allows you to calculate systems with arbitrary serving, warm-up, cold-delay and cold variation coefficients | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mgn_with_h2_delay_cold_warm.py) | |
 | 4.  | M/M/c          |  Multichannel queuing system with exp serving time, H<SUB>2</SUB>-warm-up and H<SUB>2</SUB>-cold (vacations). The system uses complex parameters, which allows to calculate systems with arbitrary warm-up and cold variation coefficients    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mmn_h2cold_h2warm.py) | |

most_queue-1.63/doctest-output/QS.gv

@@ -0,0 +1,18 @@
+digraph QS {
+	graph [rankdir=LR]
+	0 [label=0 color=lightblue2 style=filled]
+	1 [label=1]
+	2 [label=2]
+	3 [label=3]
+	4 [label=4]
+	5 [label=5]
+	6 [label=6 color=lightblue2 style=filled]
+	0 -> 1 [label=1.0]
+	1 -> 2 [label=0.4]
+	1 -> 3 [label=0.6]
+	2 -> 4 [label=0.6]
+	2 -> 5 [label=0.4]
+	3 -> 5 [label=1.0]
+	4 -> 5 [label=1.0]
+	5 -> 6 [label=1.0]
+}

most_queue-1.63/most_queue/general/distribution_fitting.py

@@ -0,0 +1,340 @@
+"""
+Methods for fitting distributions to given initial moments.
+"""
+
+import cmath
+import math
+from dataclasses import dataclass
+
+import numpy as np
+
+from most_queue.general.distribution_params import (Cox2Params, ErlangParams,
+                                                    GammaParams, H2Params,
+                                                    ParetoParams,
+                                                    WeibullParams)
+
+
+@dataclass
+class FittingParams:
+    """
+    Parameters for distribution fitting.
+    """
+
+    verbose: bool = True
+    ee: float = 0.001
+    e: float = 0.02
+    e_percent: float = 0.15
+    is_fitting: bool = True
+
+
+def fit_h2(moments: list[float]) -> H2Params:
+    """
+    Aliev's method for calculating the parameters of H2 distribution by given initial moments.
+    Only real parameters are selected.
+    Returns a list with parameters [y1, mu1, mu2].
+    """
+
+    v = moments[1] - moments[0] * moments[0]
+    v = math.sqrt(v) / moments[0]
+    res = [0.0] * 3
+    if v < 1.0:
+        return H2Params(p1=0, mu1=0, mu2=0)
+
+    q_max = 2.0 / (1.0 + v * v)
+    t_min = 1.5 * ((1 + v * v) ** 2) * math.pow(moments[0], 3)
+    q_min = 0.0
+    tn = 0.0
+
+    if t_min > moments[2]:
+        # one phase distibution
+        q_new = q_max
+        mu1 = (1.0 - math.sqrt(q_new * (v * v - 1.0) / (2 * (1.0 - q_new)))) * moments[0]
+        if math.isclose(mu1, 0):
+            mu1 = 1e10
+        else:
+            mu1 = 1.0 / mu1
+        res = H2Params(p1=q_max, mu1=mu1, mu2=1e6)
+        return res
+
+    max_iteration = 10000
+    tec = 0
+    t1 = 0
+    t2 = 0
+    while abs(tn - moments[2]) > 1e-8 and tec < max_iteration:
+        tec += 1
+        q_new = (q_max + q_min) / 2.0
+        t1 = (1.0 + math.sqrt((1.0 - q_new) * (v * v - 1.0) / (2 * q_new))) * moments[0]
+        t2 = (1.0 - math.sqrt(q_new * (v * v - 1.0) / (2 * (1.0 - q_new)))) * moments[0]
+
+        tn = 6 * (q_new * math.pow(t1, 3) + (1.0 - q_new) * math.pow(t2, 3))
+
+        if tn - moments[2] > 0:
+            q_min = q_new
+        else:
+            q_max = q_new
+
+    res = H2Params(p1=q_max, mu1=1.0 / t1, mu2=1.0 / t2)
+    return res
+
+
+def fit_h2_clx(moments: list[float], fitting_params: FittingParams | None = None) -> H2Params:
+    """
+    Method of fitting H2 distribution parameters to given initial moments.
+    Uses the method of moments and optimization to fit the parameters.
+    Returns H2Params object with fitted parameters.
+    """
+
+    if fitting_params is None:
+        fitting_params = FittingParams()
+
+    f = [0.0] * 3
+    for i in range(3):
+        f[i] = complex(moments[i] / math.factorial(i + 1))
+    znam = f[1] - pow(f[0], 2)
+    c0 = (f[0] * f[2] - pow(f[1], 2)) / znam
+    c1 = (f[0] * f[1] - f[2]) / znam
+
+    d = pow(c1 / 2.0, 2.0) - c0
+
+    if fitting_params.is_fitting:
+        # проверка на близость распределения к экспоненциальному
+        coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+        if math.fabs(coev.real - 1.0) < fitting_params.ee:
+            if fitting_params.verbose:
+                print(
+                    f"H2 is close to Exp. Multiply moments to (1+je)"
+                    f"coev = {coev:5.3f}, e = {fitting_params.e:5.3f}."
+                )
+            f = []
+            for i, mom in enumerate(moments):
+                f.append(mom * complex(1, (i + 1) * fitting_params.e))
+
+            return fit_h2_clx(f, fitting_params=fitting_params)
+
+        coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+
+        # проверка на близость распределения к Эрланга 2-го порядка
+        if math.fabs(coev.real - 1.0 / math.sqrt(2.0)) < fitting_params.ee:
+            if fitting_params.verbose:
+                print(
+                    f"H2 is close to E2. Multiply moments to (1+je)"
+                    f"coev = {coev:5.3f}, e = {fitting_params.e:5.3f}."
+                )
+            f = []
+            for i, mom in enumerate(moments):
+                f.append(mom * complex(1, (i + 1) * fitting_params.e))
+            return fit_h2_clx(f, fitting_params=fitting_params)
+
+    res = [0, 0, 0]  # y1, mu1, mu2
+    c1 = complex(c1)
+    x1 = -c1 / 2 + cmath.sqrt(d)
+    x2 = -c1 / 2 - cmath.sqrt(d)
+    y1 = (f[0] - x2) / (x1 - x2)
+
+    res = H2Params(p1=y1, mu1=1.0 / x1, mu2=1.0 / x2)
+
+    return res
+
+
+def fit_cox(moments: list[float], fitting_params: FittingParams | None = None) -> Cox2Params:
+    """
+    Calculates Cox-2 distribution parameters by three given initial moments [moments].
+    """
+
+    if not fitting_params:
+        fitting_params = FittingParams()
+
+    f = [0.0] * 3
+
+    if fitting_params.is_fitting:
+        # проверка на близость распределения к экспоненциальному
+        coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+        if abs(moments[1] - moments[0] * moments[0]) < fitting_params.ee:
+            if fitting_params.verbose:
+                print(
+                    f"Cox special 1. Multiply moments to (1+je)"
+                    f"coev = {coev:5.3f}  e = {fitting_params.e:5.3f}."
+                )
+            f = []
+            for i, mom in enumerate(moments):
+                f.append(mom * complex(1, (i + 1) * fitting_params.e))
+
+            return fit_cox(f, fitting_params=fitting_params)
+
+        coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+
+        # проверка на близость распределения к Эрланга 2-го порядка
+        if abs(moments[1] - (3.0 / 4) * moments[0] * moments[0]) < fitting_params.ee:
+            if fitting_params.verbose:
+                print("Cox special 2. Multiply moments to (1+je)")
+                print(f"\tcoev = {coev:5.3f}, e = {fitting_params.e:5.3f}")
+            f = []
+            for i, mom in enumerate(moments):
+                f.append(mom * complex(1, (i + 1) * fitting_params.e))
+            return fit_cox(f, fitting_params=fitting_params)
+
+    for i in range(3):
+        f[i] = moments[i] / math.factorial(i + 1)
+
+    d = np.power(f[2] - f[0] * f[1], 2) - 4.0 * (f[1] - np.power(f[0], 2)) * (
+        f[0] * f[2] - np.power(f[1], 2)
+    )
+    mu2 = f[0] * f[1] - f[2] + cmath.sqrt(d)
+    mu2 /= 2.0 * (np.power(f[1], 2) - f[0] * f[2])
+    mu1 = (mu2 * f[0] - 1.0) / (mu2 * f[1] - f[0])
+    y1 = (mu1 * f[0] - 1.0) * mu2 / mu1
+
+    return Cox2Params(p1=y1, mu1=mu1, mu2=mu2)
+
+
+def fit_pareto_moments(moments: list[float]):
+    """
+    Calc parameters of the distribution.
+    :param moments: list of initial moments
+    """
+    d = moments[1] - moments[0] * moments[0]
+    c = moments[0] * moments[0] / d
+    disc = 4 * (1 + c)
+    a = (2 + math.sqrt(disc)) / 2
+    k = (a - 1) * moments[0] / a
+    return ParetoParams(alpha=a, K=k)
+
+
+def fit_pareto_by_mean_and_coev(f1: float, coev: float):
+    """
+    Get parameters of the distribution by mean and coefficient of variation.
+    :param f1: float, mean value of the distribution
+    :param coev: float, coefficient of variation (mean / std)
+    """
+    d = pow(f1 * coev, 2)
+    c = pow(f1, 2) / d
+    disc = 4 * (1 + c)
+    a = (2 + math.sqrt(disc)) / 2
+    k = (a - 1) * f1 / a
+    return ParetoParams(alpha=a, K=k)
+
+
+def fit_erlang(moments: list[float]) -> ErlangParams:
+    """
+    Calculates parameters of the Erlang distribution by initial moments.
+    """
+    r = int(math.floor(moments[0] * moments[0] / (moments[1] - moments[0] * moments[0]) + 0.5))
+    mu = r / moments[0]
+    return ErlangParams(r=r, mu=mu)
+
+
+def calc_gamma_func(x):
+    """
+    Gamma-function Г(x)
+    """
+    if (x > 0.0) & (x < 1.0):
+        return calc_gamma_func(x + 1.0) / x
+    if x > 2:
+        return (x - 1) * calc_gamma_func(x - 1)
+    if x <= 0:
+        return math.pi / (math.sin(math.pi * x) * calc_gamma_func(1 - x))
+    return gamma_approx(x)
+
+
+def gamma_approx(x):
+    """
+    Get approximation of Gamma function for x in [1,2]
+    """
+    p = [
+        -1.71618513886549492533811e0,
+        2.47656508055759199108314e1,
+        -3.79804256470945635097577e2,
+        6.29331155312818442661052e2,
+        8.66966202790413211295064e2,
+        -3.14512729688483657254357e4,
+        -3.61444134186911729807069e4,
+        6.6456143820240544627855e4,
+    ]
+    q = [
+        -3.08402300119738975254354e1,
+        3.15350626979604161529144e2,
+        -1.01515636749021914166146e3,
+        -3.10777167157231109440444e3,
+        2.253811842098015100330112e4,
+        4.75584667752788110767815e3,
+        -1.34659959864969306392456e5,
+        -1.15132259675553483497211e5,
+    ]
+    z = x - 1.0
+    a = 0.0
+    b = 1.0
+    for i in range(0, 8):
+        a = (a + p[i]) * z
+        b = b * z + q[i]
+    return a / b + 1.0
+
+
+def fit_gamma(moments: list[float]) -> GammaParams:
+    """
+    Get parameters of the Gamma distribution from theoretical moments.
+    """
+    d = moments[1] - moments[0] * moments[0]
+    mu = moments[0] / d
+    alpha = mu * moments[0]
+    if len(moments) > 2:
+        # подбор коэффициентов g
+        A = []
+        B = []
+        for i in range(len(moments) + 1):
+            A.append([])
+            if i == 0:
+                B.append(1)
+            else:
+                B.append(moments[i - 1])
+            for j in range(len(moments) + 1):
+                A[i].append(
+                    calc_gamma_func(alpha + i + j) / (pow(mu, i + j) * calc_gamma_func(alpha))
+                )
+        g = np.linalg.solve(A, B)
+        return GammaParams(mu=mu, alpha=alpha, g=g)
+
+    return GammaParams(mu=mu, alpha=alpha)
+
+
+def fit_weibull(moments: list[float]) -> WeibullParams:
+    """
+    Parameter selection for the distribution based
+    on initial moments of the distribution
+
+    params:
+        moments: initial moments of the random variable
+
+    return:
+            WeibullParams
+
+    """
+    a = moments[1] / (moments[0] * moments[0])
+    u0 = math.log(2 * a) / (2.0 * math.log(2))
+    ee = 1e-6
+    u1 = (1.0 / (2 * math.log(2))) * math.log(
+        a * math.sqrt(math.pi) * math.gamma(u0 + 1) / math.gamma(u0 + 0.5)
+    )
+    delta = u1 - u0
+    while math.fabs(delta) > ee:
+        u1 = (1.0 / (2 * math.log(2))) * math.log(
+            a * math.sqrt(math.pi) * math.gamma(u0 + 1) / math.gamma(u0 + 0.5)
+        )
+        delta = u1 - u0
+        u0 = u1
+    k = 1 / u1
+    big_w = math.pow(moments[0] / math.gamma(u1 + 1), k)
+
+    return WeibullParams(k=k, W=big_w)
+
+
+def gamma_moments_by_mean_and_coev(mean: float, coev: float) -> list[float]:
+    """
+    Calculate the first three moments of a gamma distribution
+    given the mean and coefficient of variation.
+    """
+    f = [0, 0, 0]
+    alpha = 1 / (coev**2)
+    f[0] = mean
+    f[1] = pow(f[0], 2) * (pow(coev, 2) + 1)
+    f[2] = f[1] * f[0] * (1.0 + 2 / alpha)
+    return f

{most_queue-1.62 → most_queue-1.63}/most_queue/general/distribution_params.py

@@ -1,6 +1,7 @@
 """
 Distribution parameters classes.
 """
+
 from dataclasses import dataclass
 
 
@@ -9,6 +10,7 @@ class H2Params:
     """
     H2 distribution parameters.
     """
+
     mu1: float | complex  # Mean of the first phase
     mu2: float | complex  # Mean of the second phase
     p1: float | complex  # Probability of being in the first phase
@@ -19,6 +21,7 @@ class Cox2Params:
     """
     Coxian second order distribution parameters.
     """
+
     mu1: float | complex  # Mean of the first phase
     mu2: float | complex  # Mean of the second phase
     # probability for transition between phase 1 and phase 2.
@@ -30,6 +33,7 @@ class GammaParams:
     """
     Gamma distribution parameters.
     """
+
     mu: float  # 1/theta
     alpha: float
     g: list[float] | None = None
@@ -38,8 +42,9 @@ class GammaParams:
 @dataclass
 class WeibullParams:
     """
-     Weibull distribution parameters.
+    Weibull distribution parameters.
     """
+
     k: float  # Shape parameter
     W: float  # Scale parameter
 
@@ -49,6 +54,7 @@ class GaussianParams:
     """
     Normal distribution parameters.
     """
+
     mean: float  # Mean of the distribution
     std_dev: float  # Standard deviation of the distribution
 
@@ -58,6 +64,7 @@ class UniformParams:
     """
     Uniform  distribution parameters.
     """
+
     mean: float  # Mean of the distribution
     half_interval: float  # Half interval of the distribution
 
@@ -67,6 +74,7 @@ class ParetoParams:
     """
     Pareto  distribution parameters.
     """
+
     alpha: float  # alpha of the distribution
     K: float  # K of the distribution (or x_m, minimum value of x)
 
@@ -76,5 +84,6 @@ class ErlangParams:
     """
     Erlang distribution parameters.
     """
+
     r: int
     mu: float

{most_queue-1.62 → most_queue-1.63}/most_queue/general/interfaces.py

@@ -1,6 +1,7 @@
 """
 Abstract base class for all distributions.
 """
+
 from abc import ABC, abstractmethod
 
 
@@ -58,5 +59,6 @@ class Distribution(ABC):
         """
         :param f1: mean of the distribution.
         :param coev: coefficient of variation (std_dev / mean).
-        :return: Parameters for the distribution that correspond to the given mean and coefficient of variation.
+        :return: Parameters for the distribution that correspond
+        to the given mean and coefficient of variation.
         """

{most_queue-1.62 → most_queue-1.63}/most_queue/general/plots.py

@@ -1,6 +1,7 @@
 """
 Plotting utilities for simulation results.
 """
+
 from enum import Enum
 
 import matplotlib.pyplot as plt
@@ -10,16 +11,22 @@ class DependsType(Enum):
     """
     Enum to specify the type of dependency for plotting.
     """
+
     NONE = 0
     UTILIZATION_FACTOR = 1
     CHANNELS_NUMBER = 2
     COEFFICIENT_OF_VARIATION = 3
 
 
-def plot_sim_vs_calc_moments(xs: list[float], sim_results: list[float],
-                             calc_results: list[float],
-                             depends_on: DependsType = DependsType.CHANNELS_NUMBER,
-                             is_errors=False, is_waiting_time=True, save_path=None):
+def plot_sim_vs_calc_moments(
+    xs: list[float],
+    sim_results: list[float],
+    calc_results: list[float],
+    depends_on: DependsType = DependsType.CHANNELS_NUMBER,
+    is_errors=False,
+    is_waiting_time=True,
+    save_path=None,
+):
     """
     Plots the simulation and calculated moments for a given list of x values.
     :param xs: A list of x values (e.g., utilization factors or number of channels).
@@ -27,9 +34,11 @@ def plot_sim_vs_calc_moments(xs: list[float], sim_results: list[float],
     :param sim_results: A list of simulated results.
     :type sim_results: list[float]
     :param calc_results: A list of calculated results using some analytical or numerical method.
-    :param depends_on: The type of dependency for plotting (utilization factor, number of channels, etc.).
+    :param depends_on: The type of dependency for plotting
+    (utilization factor, number of channels, etc.).
     :type depends_on: DependsType
-    :param is_errors: If True, plots the percentage error between simulation and calculation results.
+    :param is_errors: If True, plots the percentage error between
+    simulation and calculation results.
     :type is_errors: bool
     :param is_waiting_time: If True, labels the y-axis as waiting time; otherwise, as sojourn time.
     :type is_waiting_time: bool
@@ -39,14 +48,13 @@ def plot_sim_vs_calc_moments(xs: list[float], sim_results: list[float],
     """
     _fig, ax = plt.subplots()
     if is_errors:
-        errors = [100 * (w_sim - w_tt) / w_tt for w_sim,
-                  w_tt in zip(sim_results, calc_results)]
+        errors = [100 * (w_sim - w_tt) / w_tt for w_sim, w_tt in zip(sim_results, calc_results)]
 
-        ax.plot(xs, errors, color='black')
+        ax.plot(xs, errors, color="black")
         ax.set_ylabel(r"$\varepsilon$, %")
     else:
-        ax.plot(xs, sim_results, label="Sim", color='black', linestyle='--')
-        ax.plot(xs, calc_results, label="Calc", color='black')
+        ax.plot(xs, sim_results, label="Sim", color="black", linestyle="--")
+        ax.plot(xs, calc_results, label="Calc", color="black")
         if is_waiting_time:
             ax.set_ylabel(r"$\omega_{1}$")
         else: