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

most_queue-2.1/.pre-commit-config.yaml

@@ -0,0 +1,47 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.2.0
+    hooks:
+      - id: check-yaml
+      - id: check-added-large-files
+      - id: check-json
+      - id: check-toml
+
+  # - repo: https://github.com/pycqa/isort
+  #   rev: 6.0.1
+  #   hooks:
+  #     - id: isort
+  #       name: isort (python)
+  #       args: [ --profile, black ]
+
+  - repo: https://github.com/psf/black
+    rev: 25.1.0
+    hooks:
+      - id: black
+        language_version: python3.12
+
+  # - repo: local
+  #   hooks:
+  #     - id: pylint
+  #       name: pylint
+  #       entry: ./.venv/bin/pylint
+  #       language: system
+  #       types: [ python ]
+  #       require_serial: true
+  #       args:
+  #           [
+  #               "-rn", # Only display messages
+  #               "-sn"
+  #           ] # Don't display the score
+
+  # - repo: https://github.com/christophmeissner/pytest-pre-commit
+  #   rev: 1.0.0
+  #   hooks:
+  #   - id: pytest
+  #     entry: ./.venv/bin/pytest
+  #     pass_filenames: false
+  #     always_run: true
+  #     args:
+  #     - "tests"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most_queue
-Version: 1.63
+Version: 2.1
 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
 
 ![Queue](assets/3.gif)
 
-A Python package for simulating and analyzing queueing systems (QS) and networks. 
+A Python package for simulating and analyzing queueing systems (QS) and networks.
 
 ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/xabarov/most-queue)
 
@@ -76,13 +76,13 @@ Or install from the repository:
   pip install -e .
 ```
 
---- 
+---
 
 ## 📚 Project Overview
 
 Most_queue consists of two main parts:
- - **most_queue.theory** contains programs that implement methods for calculating queueing theory models. 
- - **most_queue.sim** contains simulation programs. 
+ - **most_queue.theory** contains programs that implement methods for calculating queueing theory models.
+ - **most_queue.sim** contains simulation programs.
 
 ## 🧪 Example Use Cases
 
@@ -103,7 +103,7 @@ Most_queue consists of two main parts:
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
 | 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) | |
+| 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_busy_approx.py) | |
 | 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)  |
@@ -163,7 +163,7 @@ Most_queue consists of two main parts:
 - Look [here](https://github.com/xabarov/most-queue/tree/main/tests) for examples
 - Look [here](https://github.com/xabarov/most-queue/tree/main/tutorials) for jupyter tutorials
 
---- 
+---
 
 ### 👥 Contributing
 
@@ -171,4 +171,4 @@ Contributions are welcome!
 
 - Open an [issue](https://github.com/xabarov/most-queue/issues) for bugs or suggestions.
 - Submit a pull request for feature enhancements.
-- Contact me at xabarov1985@gmail.com for questions.
+- Contact me at xabarov1985@gmail.com for questions.

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

@@ -2,7 +2,7 @@
 
 ![Queue](assets/3.gif)
 
-A Python package for simulating and analyzing queueing systems (QS) and networks. 
+A Python package for simulating and analyzing queueing systems (QS) and networks.
 
 ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/xabarov/most-queue)
 
@@ -35,13 +35,13 @@ Or install from the repository:
   pip install -e .
 ```
 
---- 
+---
 
 ## 📚 Project Overview
 
 Most_queue consists of two main parts:
- - **most_queue.theory** contains programs that implement methods for calculating queueing theory models. 
- - **most_queue.sim** contains simulation programs. 
+ - **most_queue.theory** contains programs that implement methods for calculating queueing theory models.
+ - **most_queue.sim** contains simulation programs.
 
 ## 🧪 Example Use Cases
 
@@ -62,7 +62,7 @@ Most_queue consists of two main parts:
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
 | 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) | |
+| 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_busy_approx.py) | |
 | 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)  |
@@ -122,7 +122,7 @@ Most_queue consists of two main parts:
 - Look [here](https://github.com/xabarov/most-queue/tree/main/tests) for examples
 - Look [here](https://github.com/xabarov/most-queue/tree/main/tutorials) for jupyter tutorials
 
---- 
+---
 
 ### 👥 Contributing
 
@@ -130,4 +130,4 @@ Contributions are welcome!
 
 - Open an [issue](https://github.com/xabarov/most-queue/issues) for bugs or suggestions.
 - Submit a pull request for feature enhancements.
-- Contact me at xabarov1985@gmail.com for questions.
+- Contact me at xabarov1985@gmail.com for questions.

{most_queue-1.63 → most_queue-2.1}/docs/source/conf.py

@@ -9,27 +9,24 @@ import os
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 import sys
 
-project = 'most-queue'
-copyright = '2025, xabarov'
-author = 'xabarov'
-release = '1.51'
+project = "most-queue"
+copyright = "2025, xabarov"
+author = "xabarov"
+release = "1.51"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
-sys.path.insert(0,  os.path.abspath('../most_queue'))
+sys.path.insert(0, os.path.abspath("../most_queue"))
 
-extensions = ['sphinx.ext.autodoc',
-              'sphinx.ext.napoleon',
-              'autodocsumm',
-              'sphinx.ext.coverage']
+extensions = ["sphinx.ext.autodoc", "sphinx.ext.napoleon", "autodocsumm", "sphinx.ext.coverage"]
 
-auto_doc_default_options = {'autosummary': True}
-templates_path = ['_templates']
+auto_doc_default_options = {"autosummary": True}
+templates_path = ["_templates"]
 exclude_patterns = []
 
 
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
-html_theme = 'sphinx_book_theme'
-html_static_path = ['_static']
+html_theme = "sphinx_book_theme"
+html_static_path = ["_static"]

{most_queue-1.63 → most_queue-2.1}/most_queue/general/distribution_fitting.py

@@ -8,10 +8,14 @@ from dataclasses import dataclass
 
 import numpy as np
 
-from most_queue.general.distribution_params import (Cox2Params, ErlangParams,
-                                                    GammaParams, H2Params,
-                                                    ParetoParams,
-                                                    WeibullParams)
+from most_queue.general.distribution_params import (
+    Cox2Params,
+    ErlangParams,
+    GammaParams,
+    H2Params,
+    ParetoParams,
+    WeibullParams,
+)
 
 
 @dataclass
@@ -117,8 +121,7 @@ def fit_h2_clx(moments: list[float], fitting_params: FittingParams | None = None
         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"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):
@@ -151,10 +154,7 @@ def fit_cox(moments: list[float], fitting_params: FittingParams | None = None) -
         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}."
-                )
+                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))
@@ -176,9 +176,7 @@ def fit_cox(moments: list[float], fitting_params: FittingParams | None = None) -
     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)
-    )
+    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])
@@ -287,9 +285,7 @@ def fit_gamma(moments: list[float]) -> GammaParams:
             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))
-                )
+                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)
 
@@ -311,14 +307,10 @@ def fit_weibull(moments: list[float]) -> 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)
-    )
+    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)
-        )
+        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

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

@@ -26,7 +26,7 @@ def plot_sim_vs_calc_moments(
     is_errors=False,
     is_waiting_time=True,
     save_path=None,
-):
+):  # pylint: disable=too-many-positional-arguments, too-many-arguments
     """
     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).

{most_queue-1.63 → most_queue-2.1}/most_queue/general/tables.py

@@ -16,7 +16,7 @@ def times_print(
     header=None,
     sim_header="Sim",
     calc_header="Num",
-):
+):  # pylint: disable=too-many-positional-arguments, too-many-arguments
     """
     Prints the initial moments of waiting or sojourn time in the system.
      Args:
@@ -41,9 +41,7 @@ def times_print(
     print("-" * 45)
     if isinstance(sim_moments, list):
         for j in range(min(len(sim_moments), len(calc_moments))):
-            calc_mom = (
-                calc_moments[j].real if isinstance(calc_moments[j], complex) else calc_moments[j]
-            )
+            calc_mom = calc_moments[j].real if isinstance(calc_moments[j], complex) else calc_moments[j]
             sim_mom = sim_moments[j].real if isinstance(sim_moments[j], complex) else sim_moments[j]
             print(
                 Fore.CYAN
@@ -78,7 +76,7 @@ def times_print_with_two_numerical(
     is_w=True,
     num1_header="Num1",
     num2_header="Num2",
-):
+):  # pylint: disable=too-many-positional-arguments, too-many-arguments
     """
     Prints the initial moments of waiting or sojourn time in the system.
      Args:
@@ -103,12 +101,8 @@ def times_print_with_two_numerical(
     print("-" * 60)
     if isinstance(sim_moments, list):
         for j in range(min(len(sim_moments), len(calc_moments1), len(calc_moments2))):
-            calc_mom1 = (
-                calc_moments1[j].real if isinstance(calc_moments1[j], complex) else calc_moments1[j]
-            )
-            calc_mom2 = (
-                calc_moments2[j].real if isinstance(calc_moments2[j], complex) else calc_moments2[j]
-            )
+            calc_mom1 = calc_moments1[j].real if isinstance(calc_moments1[j], complex) else calc_moments1[j]
+            calc_mom2 = calc_moments2[j].real if isinstance(calc_moments2[j], complex) else calc_moments2[j]
             sim_mom = sim_moments[j].real if isinstance(sim_moments[j], complex) else sim_moments[j]
             print(
                 Fore.CYAN
@@ -167,11 +161,7 @@ def times_print_no_compare(wait_times=None, sojourn_times=None):
         if isinstance(wait_times, list):
             for j in range(min(len(wait_times), len(sojourn_times))):
                 w_mom = wait_times[j].real if isinstance(wait_times[j], complex) else wait_times[j]
-                v_mom = (
-                    sojourn_times[j].real
-                    if isinstance(sojourn_times[j], complex)
-                    else sojourn_times[j]
-                )
+                v_mom = sojourn_times[j].real if isinstance(sojourn_times[j], complex) else sojourn_times[j]
                 print(
                     Fore.CYAN
                     + f"{j + 1:^15d}|"
@@ -352,10 +342,6 @@ def print_mrx(mrx, is_short=False):
                 print(f"{color}{mrx[i, j].real:^4.2f} | ", end="")
             else:
                 print(f"{color}{mrx[i, j]:^5.3f} | ", end="")
-        print(
-            "\n" + "-------" * col
-            if is_short or mrx[i, j].imag == 0.0
-            else "\n" + "---------------" * col
-        )
+        print("\n" + "-------" * col if is_short or mrx[i, j].imag == 0.0 else "\n" + "---------------" * col)
 
     print(f"{Style.RESET_ALL}")

{most_queue-1.63 → most_queue-2.1}/most_queue/misc/approx_cdf_make.py

@@ -55,11 +55,7 @@ if __name__ == "__main__":
     print("{0:^3s}|{1:^15s}|{2:^15s}|{3:^15s}".format("№", "Реал", "Gamma", "H2"))
     print("-" * 50)
     for i in range(3):
-        print(
-            "{0:^4d}|{1:^15.3g}|{2:^15.3g}|{3:^15.3g}".format(
-                i + 1, b[i], b_approx_gamma[i], b_approx_h2[i]
-            )
-        )
+        print("{0:^4d}|{1:^15.3g}|{2:^15.3g}|{3:^15.3g}".format(i + 1, b[i], b_approx_gamma[i], b_approx_h2[i]))
 
     dots_num = 10000
 

{most_queue-1.63 → most_queue-2.1}/most_queue/misc/calc_v_pls.py

@@ -24,16 +24,11 @@ class MGnNegativeRCSCalc(MGnCalc):
     def __init__(
         self,
         n: int,
-        l_pos: float,
-        l_neg: float,
-        b: list[float],
         buffer: int | None = None,
         calc_params: TakahashiTakamiParams | None = None,
     ):
         """
         n: number of servers
-        l: arrival rate of positive jobs
-        l_neg: arrival rate of negative jobs
         b: initial moments of service time distribution
         buffer: size of the buffer (optional)
         N: number of levels in the system (default is 150)
@@ -42,9 +37,29 @@ class MGnNegativeRCSCalc(MGnCalc):
         verbose: whether to print intermediate results (default is False)
         """
 
+        super().__init__(n=n, buffer=buffer, calc_params=calc_params)
+
+        self.l_pos = None
+        self.l_neg = None
+        self.b = None
+
+    def set_sources(self, l_pos: float, l_neg: float):  # pylint: disable=arguments-differ
+        """
+        Set the arrival rates of positive and negative jobs
+        :param l_pos: arrival rate of positive jobs
+        :param l_neg: arrival rate of negative jobs
+        """
+        self.l_pos = l_pos
         self.l_neg = l_neg
+        self.is_sources_set = True
 
-        super().__init__(n=n, l=l_pos, b=b, buffer=buffer, calc_params=calc_params)
+    def set_servers(self, b: list[float]):  # pylint: disable=arguments-differ
+        """
+        Set the initial moments of service time distribution
+        :param b: initial moments of service time distribution
+        """
+        self.b = b
+        self.is_servers_set = True
 
     def get_q(self) -> float:
         """
@@ -150,9 +165,7 @@ class MGnNegativeRCSCalc(MGnCalc):
             a = np.array(
                 [
                     lst_exp(
-                        key_numbers[j][0] * self.mu[0]
-                        + key_numbers[j][1] * self.mu[1]
-                        + self.l_neg,
+                        key_numbers[j][0] * self.mu[0] + key_numbers[j][1] * self.mu[1] + self.l_neg,
                         s,
                     )
                     for j in range(k + 2)
@@ -241,7 +254,8 @@ class MGnNegativeRCSCalc(MGnCalc):
         """
         w = self.get_w(derivate=False)
 
-        # serving = min(H2_b, exp(l_neg)) = H2(y1=y1, mu1 = mu1+l_neg, mu2=mu2+l_neg)
+        # serving = min(H2_b, exp(l_neg)) = H2(y1=y1, mu1 = mu1+l_neg,
+        # mu2=mu2+l_neg)
 
         params = H2Params(p1=self.y[0], mu1=self.mu[0], mu2=self.mu[1])
         #
@@ -249,9 +263,7 @@ class MGnNegativeRCSCalc(MGnCalc):
         for i in range(1, self.n):
             l_neg += self.p[i] * self.l_neg / i
 
-        b = H2Distribution.calc_theory_moments(
-            H2Params(p1=params.p1, mu1=l_neg + params.mu1, mu2=l_neg + params.mu2)
-        )
+        b = H2Distribution.calc_theory_moments(H2Params(p1=params.p1, mu1=l_neg + params.mu1, mu2=l_neg + params.mu2))
 
         return conv_moments(w, b)
 
@@ -300,9 +312,7 @@ class MGnNegativeRCSCalc(MGnCalc):
                 right = self.l_neg * i / (num - 1)
                 left_from_next = self.l_neg * (i + 1) / (num - 1)
 
-                output[i, i] = ((num - i - 1) * self.mu[0] + left) * self.y[0] + (
-                    i * self.mu[1] + right
-                ) * self.y[1]
+                output[i, i] = ((num - i - 1) * self.mu[0] + left) * self.y[0] + (i * self.mu[1] + right) * self.y[1]
 
                 if i != num - 1:
                     output[i, i + 1] = ((num - i - 1) * self.mu[0] + left) * self.y[1]

{most_queue-1.63 → most_queue-2.1}/most_queue/misc/compare_fj_calc.py

@@ -81,7 +81,9 @@ def test_fj_calc():
         # расчет средних времен пребывания с помощью аппроксимаций. \
         # На вход каждого из методов - l, mu, nn (число каналов СМО)
 
-        calcs = ForkJoinMarkovianCalc(l, mu, nn)
+        calcs = ForkJoinMarkovianCalc(n=nn)
+        calcs.set_sources(l=l)
+        calcs.set_servers(mu=mu)
 
         v_varki.append(calcs.get_v1_fj_varki_merchant())
         v_varma.append(calcs.get_v1_fj_varma())

{most_queue-1.63 → most_queue-2.1}/most_queue/misc/flow_sum.py

@@ -26,7 +26,8 @@ def test():
     # число суммируемых потоков
     ns = [x + 2 for x in range(n_nums - 1)]
 
-    # начальные моменты суммируемых потоков. В нашем случае все потоки одинаково распределены
+    # начальные моменты суммируемых потоков. В нашем случае все потоки
+    # одинаково распределены
     a = []
     for i in range(n_nums):
         params1 = GammaDistribution.get_params_by_mean_and_coev(mean, coev)
@@ -53,11 +54,7 @@ def test():
     errors_coev = []
 
     str_f = "{0:^18s}|{1:^10.3f}|{2:^10.3f}|{3:^10.3f}|{4:^10.3f}|{5:^10.3f}"
-    print(
-        "{0:^18s}|{1:^10s}|{2:^10s}|{3:^10s}|{4:^10s}|{5:^10s}".format(
-            "-", "a1", "a2", "a3", "a4", "coev"
-        )
-    )
+    print("{0:^18s}|{1:^10s}|{2:^10s}|{3:^10s}|{4:^10s}|{5:^10s}".format("-", "a1", "a2", "a3", "a4", "coev"))
     print("-" * 80)
 
     for i in range(n_nums - 1):

{most_queue-1.63 → most_queue-2.1}/most_queue/misc/run_mgn_with_h2_delay_cold_warm.py

@@ -9,12 +9,18 @@ import time
 import numpy as np
 
 from most_queue.misc.vacations_paper_utils import (
-    calc_moments_by_mean_and_coev, dump_stat, load_stat, make_plot,
-    print_table)
+    calc_moments_by_mean_and_coev,
+    dump_stat,
+    load_stat,
+    make_plot,
+    print_table,
+)
 from most_queue.rand_distribution import GammaDistribution
 from most_queue.sim.vacations import VacationQueueingSystemSimulator
-from most_queue.theory.vacations.mgn_with_h2_delay_cold_warm import \
-    MGnH2ServingColdWarmDelay
+from most_queue.theory.vacations.mgn_with_h2_delay_cold_warm import (
+    MGnH2ServingColdWarmDelay,
+    TakahashiTakamiParams,
+)
 
 
 def get_sim_stat(stat, n, l, buff, b, b_c, b_w, b_d, num_of_jobs, p_limit, sim_ave):
@@ -113,18 +119,12 @@ def get_tt_stat(stat, n, l, buff, b, b_c, b_w, b_d, p_limit, w_pls_dt, stable_w_
     :return: None
     """
     tt_start = time.process_time()
-    tt = MGnH2ServingColdWarmDelay(
-        l,
-        b,
-        b_w,
-        b_c,
-        b_d,
-        n,
-        buffer=buff,
-        verbose=verbose,
-        w_pls_dt=w_pls_dt,
-        stable_w_pls=stable_w_pls,
-    )
+
+    tt_params = TakahashiTakamiParams(verbose=verbose, w_pls_dt=w_pls_dt, stable_w_pls=stable_w_pls)
+    tt = MGnH2ServingColdWarmDelay(n=n, buffer=buff, calc_params=tt_params)
+
+    tt.set_sources(l=l)
+    tt.set_servers(b=b, b_warm=b_w, b_cold=b_c, b_cold_delay=b_d)
 
     tt.run()
     p_tt = tt.get_p()

{most_queue-1.63 → most_queue-2.1}/most_queue/misc/test_fj_delta.py

@@ -46,16 +46,16 @@ def test_fj_delta():
 
     b_params = GammaDistribution.get_params_by_mean_and_coev(SERVICE_TIME_AVERAGE, SERVICE_TIME_CV)
 
-    delta_params = GammaDistribution.get_params_by_mean_and_coev(
-        SERVICE_TIME_DELTA_AVERAGE, SERVICE_TIME_CV
-    )
+    delta_params = GammaDistribution.get_params_by_mean_and_coev(SERVICE_TIME_DELTA_AVERAGE, SERVICE_TIME_CV)
     b_delta = GammaDistribution.calc_theory_moments(delta_params)
     b = GammaDistribution.calc_theory_moments(b_params)
 
-    sj_delta = SplitJoinCalc(ARRIVAL_RATE, NUM_OF_CHANNELS, b, approximation="gamma")
+    sj_delta = SplitJoinCalc(n=NUM_OF_CHANNELS)
+    sj_delta.set_sources(l=ARRIVAL_RATE)
+    sj_delta.set_servers(b=b)
 
     v_num = sj_delta.get_v_delta(b_delta)
-    ro = sj_delta.get_ro()
+    utilization = sj_delta.get_utilization()
 
     qs = ForkJoinSimDelta(NUM_OF_CHANNELS, NUM_OF_CHANNELS, b_delta, True)
 
@@ -68,16 +68,14 @@ def test_fj_delta():
     print(f"{'Split-Join QS with service start delay':^60s}")
     print("-" * 60)
     print(f"Coefficient of variation of service time: {SERVICE_TIME_CV}")
-    print(f"Average delay before service start: {SERVICE_TIME_DELTA_AVERAGE:.3f}")
+    print(f"Average delay before service start: { SERVICE_TIME_DELTA_AVERAGE:.3f}")
     print(f"Coefficient of variation of delay: {SERVICE_TIME_CV:.3f}")
-    print(f"Utilization coefficient: {ro:.3f}")
+    print(f"Utilization coefficient: {utilization:.3f}")
 
     times_print(v_sim, v_num, is_w=False)
 
     assert len(v_sim) == len(v_num)
-    assert np.allclose(
-        np.array(v_sim), np.array(v_num), rtol=MOMENTS_RTOL, atol=MOMENTS_ATOL
-    ), ERROR_MSG
+    assert np.allclose(np.array(v_sim), np.array(v_num), rtol=MOMENTS_RTOL, atol=MOMENTS_ATOL), ERROR_MSG
 
 
 if __name__ == "__main__":

{most_queue-1.63 → most_queue-2.1}/most_queue/misc/test_network_opt_approx.py

@@ -5,8 +5,8 @@ Test the NetworkOptimizerWithApprox class.
 import numpy as np
 
 from most_queue.rand_distribution import ExpDistribution
-from most_queue.theory.networks.opt.transition_approx import \
-    NetworkOptimizerWithApprox
+from most_queue.theory.networks.open_network import OpenNetworkCalc
+from most_queue.theory.networks.opt.transition_approx import NetworkOptimizerWithApprox
 
 
 def test_network_opt_approx():
@@ -34,11 +34,12 @@ def test_network_opt_approx():
         ExpDistribution.calc_theory_moments(1.0) for _m in range(num_of_nodes)
     ]  # List of service time moments for each node
 
+    network = OpenNetworkCalc()
+    network.set_sources(R=transition_mrx, arrival_rate=arrival_rate)
+    network.set_nodes(b=service_times, n=num_of_channels)
+
     optimizer = NetworkOptimizerWithApprox(
-        transition_matrix=transition_mrx,
-        arrival_rate=arrival_rate,
-        b=service_times,
-        num_channels=num_of_channels,
+        network=network,
         maximum_rates_to_end=max_ends,
         is_service_markovian=True,
         verbose=True,

{most_queue-1.63 → most_queue-2.1}/most_queue/misc/test_network_opt_plus.py

@@ -5,8 +5,8 @@ Test the NetworkOptimizerPlus class.
 import numpy as np
 
 from most_queue.rand_distribution import ExpDistribution
-from most_queue.theory.networks.opt.transition_plus import (
-    NetworkOptimizerPlus, Strategy)
+from most_queue.theory.networks.open_network import OpenNetworkCalc
+from most_queue.theory.networks.opt.transition_plus import NetworkOptimizerPlus, Strategy
 
 
 def test_network_opt_plus():
@@ -42,11 +42,11 @@ def test_network_opt_plus():
         Strategy.TOP_K,
         Strategy.ALL,
     ]:
+        network = OpenNetworkCalc()
+        network.set_sources(R=transition_mrx, arrival_rate=arrival_rate)
+        network.set_nodes(b=service_times, n=num_of_channels)
         optimizer = NetworkOptimizerPlus(
-            transition_matrix=transition_mrx,
-            arrival_rate=arrival_rate,
-            b=service_times,
-            num_channels=num_of_channels,
+            network=network,
             maximum_rates_to_end=max_ends,
             is_service_markovian=True,
             verbose=False,