most-queue 1.52__tar.gz → 1.54__tar.gz

most_queue-1.54/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: most_queue
+Version: 1.54
+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>
+License: Copyright (c) 2018 The Python Packaging Authority
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: colorama
+Requires-Dist: graphviz
+Requires-Dist: matplotlib
+Requires-Dist: networkx
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy==1.13.0
+Requires-Dist: tqdm
+Description-Content-Type: text/markdown
+
+# Queueing Systems: Simulation & Numerical Methods
+
+![Queue](assets/queue_long.png)
+
+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)
+
+
+## About
+This repository focuses on solving steady-state problems in queueing theory.
+
+Key Features:
+- Simulate various types of queueing systems and networks.
+- Numerical methods for solving queueing theory problems.
+- Analyze system performance metrics such as waiting times, soujourn times, load factor and etc.
+
+
+## Use Cases
+- Modeling cloud computing infrastructure.
+- Designing efficient call centers.
+- Optimizing transportation systems.
+- Network traffic analysis.
+
+## Contributing
+Contributions are welcome! If you find any issues or have suggestions, please open an [issue](https://github.com/xabarov/most-queue/issues). Your pull requests are also appreciated. You can write me at [xabarov1985@gmail.com](mailto:xabarov1985@gmail.com) 
+
+---
+
+## Installation
+- install most-queue with pip
+```bash
+  pip install most-queue
+```
+
+- install most-queue from repository
+```bash
+  pip install -e .
+```
+
+--- 
+
+## Description of the Project
+
+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. 
+
+## See examples in the tests folder:
+
+### FIFO QS
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1. | Ek/D/c           |  Numerical calculation of a multi-channel system Ek/D/n   | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_ek_d_n.py) | |
+| 2.  | GI/M/1          |  Solving for QS GI/M/1     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_gi_m_1_calc.py) | |
+| 3.  | GI/M/c          |  Solving for QS GI/M/c      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_gi_m_n_calc.py) | |
+| 4.  | M/D/c           |  Solving for QS M/D/c        | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_m_d_n_calc.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/queue_sim.ipynb)  |
+| 5.  | M/G/1           |  Solving for QS M/G/1        | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mg1_calc.py) | |
+| 6.  | M/H<SUB>2</SUB>/c         |  Numerical calculation of QS M/H<SUB>2</SUB>/c by the Takahashi-Takami method with complex parameters when approximating the serving time by the H<SUB>2</SUB>-distribution    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mgn_tt.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/mgn_takahasi_takami.ipynb) |
+| 7.  | M/M/c/r         |  Solving for QS M/M/c/r        | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_test.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/queue_sim.ipynb) |
+
+
+### QS with priorities
+
+| #   | 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) | |
+| 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)  |
+
+
+### Fork-Join QS
+
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
+| 1. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
+
+
+### QS with Batch Arrival
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1.  | M<sup>x</sup>/M/1          |  Solving for the of M<sup>x</sup>/M/1 QS with batch arrival    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_batch.py) | |
+
+### QS 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)| |
+| 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) | |
+
+### QS with Impatience
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1.  | M/M/1/D         |  Solving for M/M/1 with exponential impatience     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_impatience.py) | |
+
+### Closed QS (with finite number of sources)
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1. | M/M/1/N          |  Solving for the Engset model for M/M/1 with a finite number of sources.     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_engset.py) | |
+
+### Queuing Networks
+
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1.  | General Network |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_im_prty.py) | |
+
+
+### Usage
+- 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
+
+
+
+

most_queue-1.54/README.md

@@ -0,0 +1,119 @@
+# Queueing Systems: Simulation & Numerical Methods
+
+![Queue](assets/queue_long.png)
+
+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)
+
+
+## About
+This repository focuses on solving steady-state problems in queueing theory.
+
+Key Features:
+- Simulate various types of queueing systems and networks.
+- Numerical methods for solving queueing theory problems.
+- Analyze system performance metrics such as waiting times, soujourn times, load factor and etc.
+
+
+## Use Cases
+- Modeling cloud computing infrastructure.
+- Designing efficient call centers.
+- Optimizing transportation systems.
+- Network traffic analysis.
+
+## Contributing
+Contributions are welcome! If you find any issues or have suggestions, please open an [issue](https://github.com/xabarov/most-queue/issues). Your pull requests are also appreciated. You can write me at [xabarov1985@gmail.com](mailto:xabarov1985@gmail.com) 
+
+---
+
+## Installation
+- install most-queue with pip
+```bash
+  pip install most-queue
+```
+
+- install most-queue from repository
+```bash
+  pip install -e .
+```
+
+--- 
+
+## Description of the Project
+
+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. 
+
+## See examples in the tests folder:
+
+### FIFO QS
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1. | Ek/D/c           |  Numerical calculation of a multi-channel system Ek/D/n   | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_ek_d_n.py) | |
+| 2.  | GI/M/1          |  Solving for QS GI/M/1     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_gi_m_1_calc.py) | |
+| 3.  | GI/M/c          |  Solving for QS GI/M/c      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_gi_m_n_calc.py) | |
+| 4.  | M/D/c           |  Solving for QS M/D/c        | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_m_d_n_calc.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/queue_sim.ipynb)  |
+| 5.  | M/G/1           |  Solving for QS M/G/1        | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mg1_calc.py) | |
+| 6.  | M/H<SUB>2</SUB>/c         |  Numerical calculation of QS M/H<SUB>2</SUB>/c by the Takahashi-Takami method with complex parameters when approximating the serving time by the H<SUB>2</SUB>-distribution    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mgn_tt.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/mgn_takahasi_takami.ipynb) |
+| 7.  | M/M/c/r         |  Solving for QS M/M/c/r        | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_qs_sim_test.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/queue_sim.ipynb) |
+
+
+### QS with priorities
+
+| #   | 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) | |
+| 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)  |
+
+
+### Fork-Join QS
+
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
+| 1. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
+
+
+### QS with Batch Arrival
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1.  | M<sup>x</sup>/M/1          |  Solving for the of M<sup>x</sup>/M/1 QS with batch arrival    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_batch.py) | |
+
+### QS 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)| |
+| 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) | |
+
+### QS with Impatience
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1.  | M/M/1/D         |  Solving for M/M/1 with exponential impatience     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_impatience.py) | |
+
+### Closed QS (with finite number of sources)
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1. | M/M/1/N          |  Solving for the Engset model for M/M/1 with a finite number of sources.     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_engset.py) | |
+
+### Queuing Networks
+
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1.  | General Network |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_im_prty.py) | |
+
+
+### Usage
+- 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
+
+
+
+

{most_queue-1.52 → most_queue-1.54}/most_queue/general/conv.py

@@ -1,9 +1,9 @@
 """
 Functions for calculating convolutions of distributions.
 """
+import numpy as np
 
-
-def get_moments(a: list[float], b: list[float], num: int = 3) -> list[float]:
+def conv_moments(a: list[float], b: list[float], num: int = 3) -> list[float]:
     """
     Calculates the moments of the convolution of two distributions.
     :param a: Moments of the first distribution.
@@ -14,9 +14,11 @@ def get_moments(a: list[float], b: list[float], num: int = 3) -> list[float]:
     num = min(num, 3)
     res = [0] * num
     res[0] = a[0] + b[0]
-    res[1] = a[1] + b[1] + 2 * a[0] * b[0]
-    res[2] = a[2] + b[2] + 3 * a[1] * b[0] + 3 * a[0] * b[1]
-    return res
+    if num > 1:
+        res[1] = a[1] + b[1] + 2 * a[0] * b[0]
+    if num > 2:
+        res[2] = a[2] + b[2] + 3 * a[1] * b[0] + 3 * a[0] * b[1]
+    return np.array(res)
 
 
 def get_self_conv_moments(b: list[float], n_times, num: int = 3) -> list[float]:
@@ -30,11 +32,11 @@ def get_self_conv_moments(b: list[float], n_times, num: int = 3) -> list[float]:
     num = min(num, 3)
     res = [0] * num
     for i in range(n_times):
-        res = get_moments(res, b, num)
+        res = conv_moments(res, b, num)
     return res
 
 
-def get_moments_minus(a: list[float], b: list[float], num: int = 3) -> list[float]:
+def conv_moments_minus(a: list[float], b: list[float], num: int = 3) -> list[float]:
     """
     b = conv(a, x)
     Calculates the moments of x from the moments of a and b.
@@ -46,6 +48,14 @@ def get_moments_minus(a: list[float], b: list[float], num: int = 3) -> list[floa
     num = min(num, 3)
     res = [0] * num
     res[0] = a[0] - b[0]
-    res[1] = a[1] - b[1] - 2 * a[0] * b[0]
-    res[2] = a[2] - b[2] - 3 * a[1] * b[0] - 3 * a[0] * b[1]
+    if num > 1:
+        res[1] = a[1] - b[1] - 2 * a[0] * b[0]
+    if num > 2:
+        res[2] = a[2] - b[2] - 3 * a[1] * b[0] - 3 * a[0] * b[1]
     return res
+
+def get_residual_distr_moments(a):
+    f = [0.0] * (len(a) - 1)
+    for i in range(len(f)):
+        f[i] = a[i + 1] / ((i + 2) * a[0])
+    return f

{most_queue-1.52 → most_queue-1.54}/most_queue/general/tables.py

@@ -226,11 +226,11 @@ def print_mrx(mrx, is_short=False):
                 color = Fore.RED
             else:
                 color = Fore.GREEN
-            if is_short:
+            if is_short or mrx[i, j].imag == 0.0:
                 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 else "\n" + "---------------" * col)
+        print("\n" + "-------" * col if is_short or mrx[i, j].imag == 0.0 else "\n" + "---------------" * col)
         Fore.RESET  # Reset colors after each row
 
 

{most_queue-1.52 → most_queue-1.54}/most_queue/misc/compare_fj_calc.py

@@ -1,8 +1,8 @@
 import matplotlib
 import matplotlib.pyplot as plt
 
-from most_queue.sim.fj_sim import ForkJoinSim
-from most_queue.theory.fork_join.fj_calc import (
+from most_queue.sim.queueing_systems.fork_join import ForkJoinSim
+from most_queue.theory.fork_join.m_m_n import (
     get_v1_fj_nelson_tantawi,
     get_v1_fj_varki_merchant,
     get_v1_fj_varma,

{most_queue-1.52 → most_queue-1.54}/most_queue/misc/flow_sum.py

@@ -3,7 +3,7 @@ import matplotlib.pyplot as plt
 
 from most_queue.theory.utils.flow_sum import SummatorNumeric
 from most_queue.rand_distribution import GammaDistribution
-from most_queue.sim.flow_sum_sim import FlowSumSim
+from most_queue.sim.flow_sum import FlowSumSim
 
 matplotlib.use('TkAgg')
 

{most_queue-1.52 → most_queue-1.54}/most_queue/rand_distribution.py

@@ -572,21 +572,21 @@ class DeterministicDistribution(Distribution):
         return DeterministicDistribution.generate_static(self.b)
 
     @staticmethod
-    def generate_static(b):
+    def generate_static(params, generator=None):
         """
         Generate a constant value b. Static method for use without creating an instance of the class.
         """
-        return b
+        return params
 
     @staticmethod
-    def calc_theory_moments(b, num: int) -> list[float]:
+    def calc_theory_moments(params, num: int) -> list[float]:
         """
         Calculates theoretical moments of the distribution up to the specified order.
-        :param b: constant value.
+        :param params = b: constant value.
         :param num: number of moments to calculate.
         :return: list[float]
         """
-        moments = [b**i for i in range(1, num+1)]
+        moments = [params**i for i in range(1, num+1)]
         return moments
 
     @staticmethod

{most_queue-1.52/most_queue/sim → most_queue-1.54/most_queue/sim/networks}/priority_network.py

@@ -8,7 +8,7 @@ from colorama import Fore, Style, init
 from tqdm import tqdm
 
 from most_queue.rand_distribution import ExpDistribution
-from most_queue.sim.priority_queue_sim import PriorityQueueSimulator
+from most_queue.sim.queueing_systems.priority import PriorityQueueSimulator
 from most_queue.sim.utils.tasks import TaskPriority
 
 init()

most_queue-1.52/most_queue/sim/batch_sim.py → most_queue-1.54/most_queue/sim/queueing_systems/batch.py

@@ -3,7 +3,7 @@ Queueing system with batch arrivals.
 """
 import numpy as np
 
-from most_queue.sim.qs_sim import QueueingSystemSimulator, Task
+from most_queue.sim.queueing_systems.fifo import QueueingSystemSimulator, Task
 
 
 class QueueingSystemBatchSim(QueueingSystemSimulator):

most_queue-1.52/most_queue/sim/queue_finite_source_sim.py → most_queue-1.54/most_queue/sim/queueing_systems/finite_source.py

@@ -1,9 +1,13 @@
 """
 Simulating a queueing system with finite number of sources.
 """
+import time
+
+import numpy as np
 from colorama import Fore, Style, init
+from tqdm import tqdm
 
-from most_queue.sim.qs_sim import QueueingSystemSimulator, Task
+from most_queue.sim.queueing_systems.fifo import QueueingSystemSimulator, Task
 from most_queue.sim.utils.distribution_utils import create_distribution
 
 init()
@@ -13,7 +17,7 @@ class QueueingFiniteSourceSim(QueueingSystemSimulator):
     Simulating a queueing system with finite number of sources.
     """
 
-    def __init__(self, num_of_channels, m, buffer=None, verbose=True):
+    def __init__(self, num_of_channels: int, m: int, buffer=None, verbose=True):
         """
         num_of_channels - number of channels in the system.
         m - number of sources.
@@ -35,7 +39,7 @@ class QueueingFiniteSourceSim(QueueingSystemSimulator):
             
         """
         self.m = m
-        self.sources_left = m  # сколько источников готовы посылать заявки
+        self.sources_left = m  # how many sources are ready to send requests
 
         super().__init__(num_of_channels, buffer=buffer, verbose=verbose)
 
@@ -80,7 +84,8 @@ class QueueingFiniteSourceSim(QueueingSystemSimulator):
         self.arrival_times[self.arrived_num] = 1e10
 
         if self.free_channels == 0:
-            if self.buffer == None:  # не задана длина очереди, т.е бесконечная очередь
+            if self.buffer is None:  # infinite queue
+
                 new_tsk = Task(self.ttek)
                 new_tsk.start_waiting_time = self.ttek
                 self.queue.append(new_tsk)
@@ -160,32 +165,73 @@ class QueueingFiniteSourceSim(QueueingSystemSimulator):
 
     def run_one_step(self):
         """
-        Run one step of the simulation.
-         This method is called repeatedly until the end of the simulation.
+        Run Open step of simulation
         """
 
         num_of_server_earlier = -1
-        serv_earl = 1e10
-        arr_earl = 1e10
-        self.arrived_num = -1
-
-        if self.sources_left != 0:
-            for i, a in enumerate(self.arrival_times):
-                if a < arr_earl:
-                    arr_earl = a
-                    self.arrived_num = i
+        serv_earl = 1e16
 
         for c in range(self.n):
             if self.servers[c].time_to_end_service < serv_earl:
                 serv_earl = self.servers[c].time_to_end_service
                 num_of_server_earlier = c
 
-        # Key moment:
+        # Global warm-up is set. Need to track
+        # including the moment of warm-up end
+        times = [serv_earl, self.warm_phase.end_time,
+                 self.cold_phase.end_time, self.cold_delay_phase.end_time]
+        for t in self.arrival_times:  # Arrival times
+            times.append(t)
 
-        if arr_earl < serv_earl:
+        min_time_num = np.argmin(times)
+        if min_time_num == 0:
+            # Serving
+            self.serving(num_of_server_earlier)
+        elif min_time_num == 1:
+            # Warm-up ends
+            self.on_end_warming()
+        elif min_time_num == 2:
+            # Cold ends
+            self.on_end_cold()
+        elif min_time_num == 3:
+            # Cold delay ends
+            self.on_end_cold_delay()
+        else:
+            self.arrived_num = min_time_num - 4
+            # Arrival of a new customer
             self.arrival()
+
+    def run(self, total_served, is_real_served=True):
+        """
+        Run simulation process
+        """
+        start = time.process_time()
+
+        print(Fore.GREEN + '\rStart simulation')
+
+        if is_real_served:
+
+            last_percent = 0
+
+            with tqdm(total=100) as pbar:
+                while self.served < total_served:
+                    self.run_one_step()
+                    percent = int(100*(self.served/total_served))
+                    if last_percent != percent:
+                        last_percent = percent
+                        pbar.update(1)
+                        pbar.set_description(Fore.MAGENTA + '\rJob served: ' +
+                                             Fore.YELLOW + f'{self.served}/{total_served}' +
+                                             Fore.LIGHTGREEN_EX)
+
         else:
-            self.serving(num_of_server_earlier)
+            for _ in tqdm(range(total_served)):
+                self.run_one_step()
+
+        print(Fore.GREEN + '\rSimulation is finished')
+        print(Style.RESET_ALL)
+
+        self.time_spent = time.process_time() - start
 
     def get_p(self):
         """

most_queue-1.52/most_queue/sim/fj_sim.py → most_queue-1.54/most_queue/sim/queueing_systems/fork_join.py

@@ -6,7 +6,7 @@ import math
 from colorama import Fore, Style, init
 from tqdm import tqdm
 
-from most_queue.sim.qs_sim import QueueingSystemSimulator
+from most_queue.sim.queueing_systems.fifo import QueueingSystemSimulator
 from most_queue.sim.utils.tasks import ForkJoinTask
 
 init()

most_queue-1.52/most_queue/sim/fj_delta_sim.py → most_queue-1.54/most_queue/sim/queueing_systems/fork_join_delta.py

@@ -5,7 +5,7 @@ from colorama import Fore, Style, init
 
 from most_queue.general.conv import get_self_conv_moments
 from most_queue.rand_distribution import GammaDistribution
-from most_queue.sim.fj_sim import ForkJoinSim
+from most_queue.sim.queueing_systems.fork_join import ForkJoinSim
 from most_queue.sim.utils.tasks import ForkJoinTask
 
 init()

most_queue-1.52/most_queue/sim/impatient_queue_sim.py → most_queue-1.54/most_queue/sim/queueing_systems/impatient.py

@@ -3,7 +3,7 @@ Simulation model for queueing systems with impatient tasks
 """
 from colorama import Fore, Style, init
 
-from most_queue.sim.qs_sim import QueueingSystemSimulator
+from most_queue.sim.queueing_systems.fifo import QueueingSystemSimulator
 from most_queue.sim.utils.distribution_utils import create_distribution
 from most_queue.sim.utils.tasks import ImpatientTask