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

most_queue-1.53/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: most_queue
+Version: 1.53
+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
+```
+
+--- 
+
+## 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.53/README.md

@@ -0,0 +1,114 @@
+# 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
+```
+
+--- 
+
+## 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.53}/most_queue/general/conv.py

@@ -3,7 +3,7 @@ Functions for calculating convolutions of distributions.
 """
 
 
-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,8 +14,10 @@ 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]
+    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
 
 
@@ -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.

{most_queue-1.52 → most_queue-1.53}/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.53}/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/sim → most_queue-1.53/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.53/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.53/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.53/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.53/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.53/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
 

{most_queue-1.52 → most_queue-1.53}/most_queue/sim/utils/qs_queue.py

@@ -55,6 +55,9 @@ class QsQueueList:
         Get size of queue
         """
         return len(self.queue)
+    
+    def __len__(self):
+        return len(self.queue)
 
 
 class QsQueueDeque:

{most_queue-1.52 → most_queue-1.53}/most_queue/sim/utils/servers.py

@@ -3,7 +3,7 @@ QS channels or servers
 """
 from colorama import Fore, Style
 
-from most_queue.general.conv import get_moments
+from most_queue.general.conv import conv_moments
 from most_queue.rand_distribution import (
     CoxDistribution,
     ExpDistribution,
@@ -132,7 +132,7 @@ class ServerWarmUp(Server):
                 else:
                     raise ValueError("Unknown distribution type")
 
-                f_summ = get_moments(b, self.delta)
+                f_summ = conv_moments(b, self.delta)
                 # variance = f_summ[1] - math.pow(f_summ[0], 2)
                 # coev = math.sqrt(variance)/f_summ[0]
                 params = GammaDistribution.get_params(f_summ)
@@ -232,6 +232,5 @@ class ServerPriority:
             res += f"{Fore.GREEN}\tFree\n{Style.RESET_ALL}"
         else:
             res += f"{Fore.YELLOW}\tServing...\n{Style.RESET_ALL}"
-            res += "\tTask on service:\n"
-            res += f"\t\t{self.tsk_on_service.__str__('\t')}"
+            res += f"\tTask on service:\t{self.tsk_on_service}\n"
         return res

{most_queue-1.52 → most_queue-1.53}/most_queue/theory/networks/open_network.py

@@ -4,7 +4,7 @@ Calculates queueing network.
 import numpy as np
 
 from most_queue.rand_distribution import GammaDistribution
-from most_queue.theory.priority.priority_calc import get_v_prty_invar
+from most_queue.theory.priority.mgn_invar_approx import MGnInvarApproximation
 from most_queue.theory.utils.diff5dots import diff5dots
 
 
@@ -115,8 +115,8 @@ class OpenNetworkCalc:
             b_sr = np.mean(b_order[i], axis=0)
 
             res['loads'][i] = l_sum * b_sr[0] / self.n[i]
-            res['v_node'].append(get_v_prty_invar(
-                l_order[i], b_order[i], self.n[i], self.prty[i]))
+            invar_calc = MGnInvarApproximation(l_order[i], b_order[i], self.n[i])
+            res['v_node'].append(invar_calc.get_v(priority=self.prty[i]))
             for k in range(k_num):
                 res['v_node'][i][self.nodes_prty[i][k]] = res['v_node'][i][k]
 

most_queue-1.52/most_queue/theory/closed/engset_model.py → most_queue-1.53/most_queue/theory/queueing_systems/closed/engset.py

@@ -2,7 +2,7 @@
 Calculation of the Engset model for M/M/1 with a finite number of sources.
 """
 from most_queue.theory.utils.diff5dots import diff5dots
-from most_queue.general.conv import get_moments
+from most_queue.general.conv import conv_moments
 
 
 class Engset:
@@ -115,7 +115,7 @@ class Engset:
         """
         w = self.get_w()
         b = [1.0 / self.mu, 2.0 / pow(self.mu, 2), 6.0 / pow(self.mu, 3)]
-        return get_moments(w, b)
+        return conv_moments(w, b)
 
     def _calc_m_i(self):
         m_i = []

most_queue-1.52/most_queue/theory/fifo/gi_m_1_calc.py → most_queue-1.53/most_queue/theory/queueing_systems/fifo/gi_m_1.py

@@ -3,7 +3,7 @@ Calculation of the GI/M/1 queueing system
 """
 import math
 
-from most_queue.general.conv import get_moments_minus
+from most_queue.general.conv import conv_moments_minus
 from most_queue.rand_distribution import GammaDistribution, ParetoDistribution
 from most_queue.theory.utils.q_poisson_arrival_calc import get_q_Gamma
 
@@ -74,7 +74,7 @@ class GiM1:
 
         b = [1.0 / self.mu, 2.0 /
              pow(self.mu, 2), 6.0 / pow(self.mu, 3), 24.0 / pow(self.mu, 4)]
-        w = get_moments_minus(self.v, b, num)
+        w = conv_moments_minus(self.v, b, num)
 
         return w
 

most_queue-1.52/most_queue/theory/fifo/gi_m_n_calc.py → most_queue-1.53/most_queue/theory/queueing_systems/fifo/gi_m_n.py

@@ -5,7 +5,7 @@ import math
 
 import numpy as np
 
-from most_queue.general.conv import get_moments
+from most_queue.general.conv import conv_moments
 from most_queue.rand_distribution import GammaDistribution, ParetoDistribution
 from most_queue.theory.utils.diff5dots import diff5dots
 
@@ -47,7 +47,7 @@ class GiMn:
 
         b = [1 / self.mu, 2 / pow(self.mu, 2), 6 /
              pow(self.mu, 3), 24 / pow(self.mu, 4)]
-        v = get_moments(w, b, len(w))
+        v = conv_moments(w, b, len(w))
         return v
 
     def get_w(self) -> list[float]: