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

most_queue-2.2/.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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most_queue
-Version: 1.63
+Version: 2.2
 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,10 +43,66 @@ 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)
 
+---
+### Most-Queue 2.0 Release Notes
+
+New unified API for both simulation and calculation classes:
+
+```python
+from most_queue.general.distribution_fitting import gamma_moments_by_mean_and_cv
+from most_queue.general.tables import probs_print, times_print
+from most_queue.rand_distribution import GammaDistribution
+from most_queue.sim.base import QsSim
+from most_queue.theory.fifo.mgn_takahasi import MGnCalc
+
+# initialize constatants
+NUM_OF_CHANNELS = 3
+
+ARRIVAL_RATE = 1.0
+SERVICE_TIME_CV = 1.2
+
+NUM_OF_JOBS = 300_000 # number of jobs to simulate
+
+UTILIZATION_FACTOR = 0.7
+
+# calc service time moments using gamma distribution fitting
+b1 = NUM_OF_CHANNELS * UTILIZATION_FACTOR / ARRIVAL_RATE  # average service time
+b = gamma_moments_by_mean_and_cv(b1, SERVICE_TIME_CV)
+gamma_params = GammaDistribution.get_params([b[0], b[1]]) # gamma distribution parameters
+
+# run Takahasi-Takami calc method
+tt = MGnCalc(n=NUM_OF_CHANNELS)
+
+tt.set_sources(l=ARRIVAL_RATE)
+tt.set_servers(b=b)
+
+calc_results = tt.run()
+
+# run simulation
+qs = QsSim(NUM_OF_CHANNELS)
+
+qs.set_sources(ARRIVAL_RATE, "M")
+qs.set_servers(gamma_params, "Gamma")
+
+sim_results = qs.run(NUM_OF_JOBS)
+
+print(f"Simulation duration: {sim_results.duration:.5f} sec")
+print(f"Calculation duration: {calc_results.duration:.5f} sec")
+
+probs_print(sim_results.p, calc_results.p, 10)
+times_print(sim_results.v, calc_results.v, False)
+times_print(sim_results.w, calc_results.w, True)
+
+```
+
+See more examples in [tests](https://github.com/xabarov/most-queue/blob/main/tests/) and [tutorials](https://github.com/xabarov/most-queue/tree/main/tutorials/) folders.
+
+
+
 ---
 
 ### 🔍 Key Features
@@ -76,13 +132,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 +159,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)  |
@@ -160,10 +216,10 @@ Most_queue consists of two main parts:
 ---
 
 ### 📁 Examples & Tutorials
-- 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
+- Look [tests](https://github.com/xabarov/most-queue/tree/main/tests) for examples with comparison of theoretical and simulation results.
+- Look [tutorials](https://github.com/xabarov/most-queue/tree/main/tutorials) for jupyter tutorials
 
---- 
+---
 
 ### 👥 Contributing
 
@@ -171,4 +227,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.2}/README.md

@@ -2,10 +2,66 @@
 
 ![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)
 
+---
+### Most-Queue 2.0 Release Notes
+
+New unified API for both simulation and calculation classes:
+
+```python
+from most_queue.general.distribution_fitting import gamma_moments_by_mean_and_cv
+from most_queue.general.tables import probs_print, times_print
+from most_queue.rand_distribution import GammaDistribution
+from most_queue.sim.base import QsSim
+from most_queue.theory.fifo.mgn_takahasi import MGnCalc
+
+# initialize constatants
+NUM_OF_CHANNELS = 3
+
+ARRIVAL_RATE = 1.0
+SERVICE_TIME_CV = 1.2
+
+NUM_OF_JOBS = 300_000 # number of jobs to simulate
+
+UTILIZATION_FACTOR = 0.7
+
+# calc service time moments using gamma distribution fitting
+b1 = NUM_OF_CHANNELS * UTILIZATION_FACTOR / ARRIVAL_RATE  # average service time
+b = gamma_moments_by_mean_and_cv(b1, SERVICE_TIME_CV)
+gamma_params = GammaDistribution.get_params([b[0], b[1]]) # gamma distribution parameters
+
+# run Takahasi-Takami calc method
+tt = MGnCalc(n=NUM_OF_CHANNELS)
+
+tt.set_sources(l=ARRIVAL_RATE)
+tt.set_servers(b=b)
+
+calc_results = tt.run()
+
+# run simulation
+qs = QsSim(NUM_OF_CHANNELS)
+
+qs.set_sources(ARRIVAL_RATE, "M")
+qs.set_servers(gamma_params, "Gamma")
+
+sim_results = qs.run(NUM_OF_JOBS)
+
+print(f"Simulation duration: {sim_results.duration:.5f} sec")
+print(f"Calculation duration: {calc_results.duration:.5f} sec")
+
+probs_print(sim_results.p, calc_results.p, 10)
+times_print(sim_results.v, calc_results.v, False)
+times_print(sim_results.w, calc_results.w, True)
+
+```
+
+See more examples in [tests](https://github.com/xabarov/most-queue/blob/main/tests/) and [tutorials](https://github.com/xabarov/most-queue/tree/main/tutorials/) folders.
+
+
+
 ---
 
 ### 🔍 Key Features
@@ -35,13 +91,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 +118,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)  |
@@ -119,10 +175,10 @@ Most_queue consists of two main parts:
 ---
 
 ### 📁 Examples & Tutorials
-- 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
+- Look [tests](https://github.com/xabarov/most-queue/tree/main/tests) for examples with comparison of theoretical and simulation results.
+- Look [tutorials](https://github.com/xabarov/most-queue/tree/main/tutorials) for jupyter tutorials
 
---- 
+---
 
 ### 👥 Contributing
 
@@ -130,4 +186,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.2}/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/general/interfaces.py → most_queue-2.2/most_queue/distr_utils/base_distribution.py

@@ -55,10 +55,10 @@ class Distribution(ABC):
 
     @staticmethod
     @abstractmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float):
+    def get_params_by_mean_and_cv(f1: float, cv: float):
         """
         :param f1: mean of the distribution.
-        :param coev: coefficient of variation (std_dev / mean).
+        :param cv: coefficient of variation (std_dev / mean).
         :return: Parameters for the distribution that correspond
         to the given mean and coefficient of variation.
         """

{most_queue-1.63/most_queue/general → most_queue-2.2/most_queue/distr_utils}/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.distr_utils.distribution_params import (
+    Cox2Params,
+    ErlangParams,
+    GammaParams,
+    H2Params,
+    ParetoParams,
+    WeibullParams,
+)
 
 
 @dataclass
@@ -98,28 +102,22 @@ def fit_h2_clx(moments: list[float], fitting_params: FittingParams | None = None
 
     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:
+        cv = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+        if math.fabs(cv.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}."
-                )
+                print(f"H2 is close to Exp. Multiply moments to (1+je)" f"cv = {cv: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]
+        cv = 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 math.fabs(cv.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}."
-                )
+                print(f"H2 is close to E2. Multiply moments to (1+je)" f"cv = {cv: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))
@@ -148,26 +146,23 @@ def fit_cox(moments: list[float], fitting_params: FittingParams | None = None) -
 
     if fitting_params.is_fitting:
         # проверка на близость распределения к экспоненциальному
-        coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+        cv = 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"cv = {cv: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]
+        cv = 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}")
+                print(f"\tcv = {cv: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 +171,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])
@@ -200,13 +193,13 @@ def fit_pareto_moments(moments: list[float]):
     return ParetoParams(alpha=a, K=k)
 
 
-def fit_pareto_by_mean_and_coev(f1: float, coev: float):
+def fit_pareto_by_mean_and_cv(f1: float, cv: 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)
+    :param cv: float, coefficient of variation (mean / std)
     """
-    d = pow(f1 * coev, 2)
+    d = pow(f1 * cv, 2)
     c = pow(f1, 2) / d
     disc = 4 * (1 + c)
     a = (2 + math.sqrt(disc)) / 2
@@ -287,9 +280,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 +302,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
@@ -327,14 +314,14 @@ def fit_weibull(moments: list[float]) -> WeibullParams:
     return WeibullParams(k=k, W=big_w)
 
 
-def gamma_moments_by_mean_and_coev(mean: float, coev: float) -> list[float]:
+def gamma_moments_by_mean_and_cv(mean: float, cv: 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)
+    alpha = 1 / (cv**2)
     f[0] = mean
-    f[1] = pow(f[0], 2) * (pow(coev, 2) + 1)
+    f[1] = pow(f[0], 2) * (pow(cv, 2) + 1)
     f[2] = f[1] * f[0] * (1.0 + 2 / alpha)
     return f