most-queue 1.49__tar.gz → 1.50__tar.gz

most_queue-1.50/PKG-INFO

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: most_queue
+Version: 1.50
+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 and numerical methods of Queuing theory
+
+![Queue](assets/queue6.jpg)
+
+Python package for calculation and simulation of queueing systems (QS) and networks. 
+
+MOST (MOCT,  Массовое обслуживание стационарные задачи) stands for “Mass Service Steady-State Problems” and refers to tasks within queueing theory that involve large-scale service systems operating under steady-state conditions. 
+- [Рыжиков Ю. И. Вычислительные методы. – БХВ-Петербург, 2007.](https://www.litres.ru/book/uriy-ryzhikov/vychislitelnye-metody-uchebnoe-posobie-644835/)
+
+Queueing theory. Numerical methods. 
+
+
+## Authors
+- [xabarov](https://github.com/xabarov)
+
+## Installation
+Install most-queue with pip
+```bash
+  pip install most-queue
+```
+
+## DESCRIPTION
+Most_queue consists of two main parts:
+ - **.theory** contains programs that implement methods for calculating queuing theory models. 
+ - **.sim** contains simulation programs. 
+### Package .theory
+| #   | Package name                      | Description                                                                                                                                                                                                                                                |
+|-----|-----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| 1.  | batch_mm1                         |        Calculation of M/M/1 QS with batch arrival                                                                                                                                                                                              |
+| 2. | ek_d_n_calc  | Numerical calculation of a multi-channel system Ek/D/n |
+| 3. | engset_model |   Calculation of the Engset model for M/M/1 with a finite number of sources.    |
+| 4. | fj_calc    | Numerical calculation of the initial moments of the random variables maximum distribution    | 
+| 5.  | gi_m_1_calc                       | Numerical calculation of QS GI/M/1    |
+| 6.  | gi_m_n_calc                       | Numerical calculation of QS GI/M/n    |
+| 7. | impatience_calc                   | Calculation of M/M/1 with exponential impatience    |
+| 8.  | m_d_n_calc                        | Numerical calculation of QS M/D/n    |
+| 9.  | m_h2_h2_warm                        | Calculation of the M/H2/n system with H2-warming using the Takahasi-Takagi method.   |
+| 10.  | m_ph_n_prty   | Numerical calculation of QS M/Ph/n with 2 classes and PR - priority. Based on the approximation of busy periods    |
+| 11.  | mg1_calc                          | Numerical calculation of QS M/G/1    |
+| 12.  | mg1_warm_calc                     | Numerical calculation of QS M/G/1 with "warm-up"    |
+| 13. | mgn_tt                            | Numerical calculation of QS M/H2/n by the Takahashi-Takami method with complex parameters when approximating the serving time by the H2 distribution       |
+| 14. | mgn_with_h2_delay_cold_warm.py    | Multichannel queuing system with H2 serving time, H2 warm-up, H2 cold delay and H2 cold (vacations). The system uses complex parameters, which allows you to calculate systems with arbitrary serving, warm-up, cold-delay and cold variation coefficients |
+| 15. | mmn_prty_pnz_approx               | Calculation of QS M/M/2 with 2 classes, PR - priority by the Takahashi-Takami numerical method based on the approximation of the busy period by the Cox distribution  |
+| 16. | mmn_with_h2_cold_h2_warmup.py     | Multichannel queuing system with exp serving time, H2 warm-up and H2 cold (vacations). The system uses complex parameters, which allows to calculate systems with arbitrary warm-up and cold variation coefficients    |
+| 17. | mmn3_pnz_cox_approx               | Calculation of QS M/M/2 with 3 classes, PR - priority by the Takahashi-Takami numerical method based on the approximation of busy period by the Cox distribution      |
+| 18. | mmnr_calc                         | Calculation of QS M/M/n/r     |
+| 19. | network_calc                      | Calculation of queuing network with priorities in nodes     |
+| 20. | network_viewer.py                 | Utility to view network structure        |
+| 21. | priority_calc                     | A set of functions for calculating QS with priorities (single-channel, multi-channel). The multichannel calculation is carried out by the method of relation     |
+
+
+### Package .sim
+| #  | Package name               | Description |
+| ------------- |----------------------------|------------- |
+| 1. | batch_sim                   | Simulation of QS in a batch system |
+| 2.  | fj_delta_sim               | Simulation of QS fork-join with a delay in the start of processing between channels | 
+| 3.  | fj_sim                     | Simulation of QS with fork-join process |
+| 4.  | flow_sum_sim               | Simulation of flow summation | 
+| 5.  | impatient_sim.py           | Simulation of QS GI/G/m/n with impatience | 
+| 6.  | priority_network           | Simulation of queuing network with priorities in nodes | 
+| 7.  | priority_queue_sim         | Simulation of QS GI/G/m/n  with priorities  | 
+| 8.  | qs_sim                     | Simulation of QS GI/G/m/n  | 
+| 9.  | queue_finite_source_sim.py | Simulation of QS GI/G/m/n with finite sources | 
+
+## 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
+
+### Simple example: Calculate M/G/1 queueing system calculation with `most_queue` library. Run simulation and compare results with theory.
+
+```python
+import numpy as np
+
+from most_queue.general_utils.tables import probs_print, times_print
+from most_queue.rand_distribution import H2_dist
+from most_queue.sim.qs_sim import QueueingSystemSimulator
+from most_queue.theory.mg1_calc import get_p, get_v, get_w
+
+l = 1  # input flow intensity
+b1 = 0.7  # average service time
+coev = 1.2  # coefficient of variation of service time
+num_of_jobs = 1000000  # number of jobs for simulation
+
+# selecting parameters of the approximating H2-distribution for service time [y1, mu1, mu2]:
+params = H2_dist.get_params_by_mean_and_coev(b1, coev)
+b = H2_dist.calc_theory_moments(*params, 4)
+
+# calculation using numerical methods
+w_ch = get_w(l, b)
+p_ch = get_p(l, b, 100)
+v_ch = get_v(l, b)
+
+# running simulation for verification of results
+qs = QueueingSystemSimulator(1)
+qs.set_servers(params, "H")
+qs.set_sources(l, "M")
+qs.run(num_of_jobs)
+w_sim = qs.w
+p_sim = qs.get_p()
+v_sim = qs.v
+
+# outputting the results
+print("M/H2/1")
+
+times_print(w_sim, w_ch, True)
+times_print(v_sim, v_ch, False)
+probs_print(p_sim, p_ch, 10)
+```
+
+### Priority queue example.   For verification, comparing results with those calculated using the method of [invariant relations](https://cyberleninka.ru/article/n/raschet-mnogokanalnyh-sistem-obsluzhivaniya-s-absolyutnym-i-otnositelnym-prioritetami-na-osnove-invariantov-otnosheniya)
+
+```python
+n = 5  # number of servers
+k = 3  # number of classes of requests
+l = [0.2, 0.3, 0.4]  # service intensities by request classes
+lsum = sum(l)
+num_of_jobs = 300000  # number of jobs for the simulation
+
+# Set up the parameters for service times at initial moments.
+# Set average service times by class
+b1 = [0.45 * n, 0.9 * n, 1.35 * n]
+
+# Coefficient of variation of service time let's be the same for all classes
+coev = 0.577
+
+# second initial moments
+b2 = [0] * k
+for i in range(k):
+    b2[i] = (b1[i] ** 2) * (1 + coev ** 2)
+
+b_sr = sum(b1) / k
+
+# get the coefficient of load
+ro = lsum * b_sr / n
+
+# now, given the two initial moments, select parameters for the approximating Gamma distribution
+# and add them to the list of parameters params
+params = []
+for i in range(k):
+    params.append(Gamma.get_mu_alpha([b1[i], b2[i]]))
+
+b = []
+for j in range(k):
+    b.append(Gamma.calc_theory_moments(params[j][0], params[j][1], 4))
+
+print("\nComparison of data from the simulation and results calculated using the method of invariant relations (R) \n"
+      "time spent in a multi-channel queue with priorities")
+print("Number of servers: " + str(n) + "\nNumber of classes: " + str(k) + "\nCoefficient of load: {0:<1.2f}".format(ro) +
+      "\nCoefficient of variation of service time: " + str(coev) + "\n")
+print("PR (Preamptive) priority")
+
+# when creating the simulation, pass the number of servers, number of classes and type of priority.
+# PR - absolute with re-service of requests
+qs = PriorityQueueSimulator(n, k, "PR")
+
+# to set up sources of requests and service servers, we need to specify a set of dictionaries with fields
+# type - distribution type,
+# params - its parameters.
+# The number of such dictionaries in the lists sources and servers_params corresponds to the number of classes
+
+sources = []
+servers_params = []
+for j in range(k):
+    sources.append({'type': 'M', 'params': l[j]})
+    servers_params.append({'type': 'Gamma', 'params': params[j]})
+
+qs.set_sources(sources)
+qs.set_servers(servers_params)
+
+# start the simulation
+qs.run(num_of_jobs)
+
+# get the initial moments of time spent
+
+v_sim = qs.v
+
+# calculate them as well using the method of invariant relations (for comparison)
+v_teor = priority_calc.get_v_prty_invar(l, b, n, 'PR')
+
+assert abs(v_sim[0][0] - v_teor[0][0]) < 0.3
+
+times_print_with_classes(v_sim, v_teor, False)
+
+print("NP (Non-preamptive) priority")
+
+# The same for relative priority (NP)
+qs = PriorityQueueSimulator(n, k, "NP")
+sources = []
+servers_params = []
+for j in range(k):
+    sources.append({'type': 'M', 'params': l[j]})
+    servers_params.append({'type': 'Gamma', 'params': params[j]})
+
+qs.set_sources(sources)
+qs.set_servers(servers_params)
+
+qs.run(num_of_jobs)
+
+v_sim = qs.v
+
+v_teor = priority_calc.get_v_prty_invar(l, b, n, 'NP')
+
+times_print_with_classes(v_sim, v_teor, False)
+```
+
+
+
+
+
+

most_queue-1.50/README.md

@@ -0,0 +1,210 @@
+# Queueing systems. Simulation and numerical methods of Queuing theory
+
+![Queue](assets/queue6.jpg)
+
+Python package for calculation and simulation of queueing systems (QS) and networks. 
+
+MOST (MOCT,  Массовое обслуживание стационарные задачи) stands for “Mass Service Steady-State Problems” and refers to tasks within queueing theory that involve large-scale service systems operating under steady-state conditions. 
+- [Рыжиков Ю. И. Вычислительные методы. – БХВ-Петербург, 2007.](https://www.litres.ru/book/uriy-ryzhikov/vychislitelnye-metody-uchebnoe-posobie-644835/)
+
+Queueing theory. Numerical methods. 
+
+
+## Authors
+- [xabarov](https://github.com/xabarov)
+
+## Installation
+Install most-queue with pip
+```bash
+  pip install most-queue
+```
+
+## DESCRIPTION
+Most_queue consists of two main parts:
+ - **.theory** contains programs that implement methods for calculating queuing theory models. 
+ - **.sim** contains simulation programs. 
+### Package .theory
+| #   | Package name                      | Description                                                                                                                                                                                                                                                |
+|-----|-----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| 1.  | batch_mm1                         |        Calculation of M/M/1 QS with batch arrival                                                                                                                                                                                              |
+| 2. | ek_d_n_calc  | Numerical calculation of a multi-channel system Ek/D/n |
+| 3. | engset_model |   Calculation of the Engset model for M/M/1 with a finite number of sources.    |
+| 4. | fj_calc    | Numerical calculation of the initial moments of the random variables maximum distribution    | 
+| 5.  | gi_m_1_calc                       | Numerical calculation of QS GI/M/1    |
+| 6.  | gi_m_n_calc                       | Numerical calculation of QS GI/M/n    |
+| 7. | impatience_calc                   | Calculation of M/M/1 with exponential impatience    |
+| 8.  | m_d_n_calc                        | Numerical calculation of QS M/D/n    |
+| 9.  | m_h2_h2_warm                        | Calculation of the M/H2/n system with H2-warming using the Takahasi-Takagi method.   |
+| 10.  | m_ph_n_prty   | Numerical calculation of QS M/Ph/n with 2 classes and PR - priority. Based on the approximation of busy periods    |
+| 11.  | mg1_calc                          | Numerical calculation of QS M/G/1    |
+| 12.  | mg1_warm_calc                     | Numerical calculation of QS M/G/1 with "warm-up"    |
+| 13. | mgn_tt                            | Numerical calculation of QS M/H2/n by the Takahashi-Takami method with complex parameters when approximating the serving time by the H2 distribution       |
+| 14. | mgn_with_h2_delay_cold_warm.py    | Multichannel queuing system with H2 serving time, H2 warm-up, H2 cold delay and H2 cold (vacations). The system uses complex parameters, which allows you to calculate systems with arbitrary serving, warm-up, cold-delay and cold variation coefficients |
+| 15. | mmn_prty_pnz_approx               | Calculation of QS M/M/2 with 2 classes, PR - priority by the Takahashi-Takami numerical method based on the approximation of the busy period by the Cox distribution  |
+| 16. | mmn_with_h2_cold_h2_warmup.py     | Multichannel queuing system with exp serving time, H2 warm-up and H2 cold (vacations). The system uses complex parameters, which allows to calculate systems with arbitrary warm-up and cold variation coefficients    |
+| 17. | mmn3_pnz_cox_approx               | Calculation of QS M/M/2 with 3 classes, PR - priority by the Takahashi-Takami numerical method based on the approximation of busy period by the Cox distribution      |
+| 18. | mmnr_calc                         | Calculation of QS M/M/n/r     |
+| 19. | network_calc                      | Calculation of queuing network with priorities in nodes     |
+| 20. | network_viewer.py                 | Utility to view network structure        |
+| 21. | priority_calc                     | A set of functions for calculating QS with priorities (single-channel, multi-channel). The multichannel calculation is carried out by the method of relation     |
+
+
+### Package .sim
+| #  | Package name               | Description |
+| ------------- |----------------------------|------------- |
+| 1. | batch_sim                   | Simulation of QS in a batch system |
+| 2.  | fj_delta_sim               | Simulation of QS fork-join with a delay in the start of processing between channels | 
+| 3.  | fj_sim                     | Simulation of QS with fork-join process |
+| 4.  | flow_sum_sim               | Simulation of flow summation | 
+| 5.  | impatient_sim.py           | Simulation of QS GI/G/m/n with impatience | 
+| 6.  | priority_network           | Simulation of queuing network with priorities in nodes | 
+| 7.  | priority_queue_sim         | Simulation of QS GI/G/m/n  with priorities  | 
+| 8.  | qs_sim                     | Simulation of QS GI/G/m/n  | 
+| 9.  | queue_finite_source_sim.py | Simulation of QS GI/G/m/n with finite sources | 
+
+## 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
+
+### Simple example: Calculate M/G/1 queueing system calculation with `most_queue` library. Run simulation and compare results with theory.
+
+```python
+import numpy as np
+
+from most_queue.general_utils.tables import probs_print, times_print
+from most_queue.rand_distribution import H2_dist
+from most_queue.sim.qs_sim import QueueingSystemSimulator
+from most_queue.theory.mg1_calc import get_p, get_v, get_w
+
+l = 1  # input flow intensity
+b1 = 0.7  # average service time
+coev = 1.2  # coefficient of variation of service time
+num_of_jobs = 1000000  # number of jobs for simulation
+
+# selecting parameters of the approximating H2-distribution for service time [y1, mu1, mu2]:
+params = H2_dist.get_params_by_mean_and_coev(b1, coev)
+b = H2_dist.calc_theory_moments(*params, 4)
+
+# calculation using numerical methods
+w_ch = get_w(l, b)
+p_ch = get_p(l, b, 100)
+v_ch = get_v(l, b)
+
+# running simulation for verification of results
+qs = QueueingSystemSimulator(1)
+qs.set_servers(params, "H")
+qs.set_sources(l, "M")
+qs.run(num_of_jobs)
+w_sim = qs.w
+p_sim = qs.get_p()
+v_sim = qs.v
+
+# outputting the results
+print("M/H2/1")
+
+times_print(w_sim, w_ch, True)
+times_print(v_sim, v_ch, False)
+probs_print(p_sim, p_ch, 10)
+```
+
+### Priority queue example.   For verification, comparing results with those calculated using the method of [invariant relations](https://cyberleninka.ru/article/n/raschet-mnogokanalnyh-sistem-obsluzhivaniya-s-absolyutnym-i-otnositelnym-prioritetami-na-osnove-invariantov-otnosheniya)
+
+```python
+n = 5  # number of servers
+k = 3  # number of classes of requests
+l = [0.2, 0.3, 0.4]  # service intensities by request classes
+lsum = sum(l)
+num_of_jobs = 300000  # number of jobs for the simulation
+
+# Set up the parameters for service times at initial moments.
+# Set average service times by class
+b1 = [0.45 * n, 0.9 * n, 1.35 * n]
+
+# Coefficient of variation of service time let's be the same for all classes
+coev = 0.577
+
+# second initial moments
+b2 = [0] * k
+for i in range(k):
+    b2[i] = (b1[i] ** 2) * (1 + coev ** 2)
+
+b_sr = sum(b1) / k
+
+# get the coefficient of load
+ro = lsum * b_sr / n
+
+# now, given the two initial moments, select parameters for the approximating Gamma distribution
+# and add them to the list of parameters params
+params = []
+for i in range(k):
+    params.append(Gamma.get_mu_alpha([b1[i], b2[i]]))
+
+b = []
+for j in range(k):
+    b.append(Gamma.calc_theory_moments(params[j][0], params[j][1], 4))
+
+print("\nComparison of data from the simulation and results calculated using the method of invariant relations (R) \n"
+      "time spent in a multi-channel queue with priorities")
+print("Number of servers: " + str(n) + "\nNumber of classes: " + str(k) + "\nCoefficient of load: {0:<1.2f}".format(ro) +
+      "\nCoefficient of variation of service time: " + str(coev) + "\n")
+print("PR (Preamptive) priority")
+
+# when creating the simulation, pass the number of servers, number of classes and type of priority.
+# PR - absolute with re-service of requests
+qs = PriorityQueueSimulator(n, k, "PR")
+
+# to set up sources of requests and service servers, we need to specify a set of dictionaries with fields
+# type - distribution type,
+# params - its parameters.
+# The number of such dictionaries in the lists sources and servers_params corresponds to the number of classes
+
+sources = []
+servers_params = []
+for j in range(k):
+    sources.append({'type': 'M', 'params': l[j]})
+    servers_params.append({'type': 'Gamma', 'params': params[j]})
+
+qs.set_sources(sources)
+qs.set_servers(servers_params)
+
+# start the simulation
+qs.run(num_of_jobs)
+
+# get the initial moments of time spent
+
+v_sim = qs.v
+
+# calculate them as well using the method of invariant relations (for comparison)
+v_teor = priority_calc.get_v_prty_invar(l, b, n, 'PR')
+
+assert abs(v_sim[0][0] - v_teor[0][0]) < 0.3
+
+times_print_with_classes(v_sim, v_teor, False)
+
+print("NP (Non-preamptive) priority")
+
+# The same for relative priority (NP)
+qs = PriorityQueueSimulator(n, k, "NP")
+sources = []
+servers_params = []
+for j in range(k):
+    sources.append({'type': 'M', 'params': l[j]})
+    servers_params.append({'type': 'Gamma', 'params': params[j]})
+
+qs.set_sources(sources)
+qs.set_servers(servers_params)
+
+qs.run(num_of_jobs)
+
+v_sim = qs.v
+
+v_teor = priority_calc.get_v_prty_invar(l, b, n, 'NP')
+
+times_print_with_classes(v_sim, v_teor, False)
+```
+
+
+
+
+
+

most_queue-1.50/deploy.txt

@@ -0,0 +1,3 @@
+1. Change version in pyproject.toml and setup.py
+2. hatch build
+3. upload to PyPI: twine upload dist/*

{most_queue-1.49 → most_queue-1.50}/most_queue/general_utils/tables.py

@@ -1,19 +1,27 @@
-from colorama import Back, Fore, Style, init
+from colorama import Fore, Style, init
 
 init()
 
 
 def times_print(sim_moments, calc_moments, is_w=True):
+    """
+    Prints the initial moments of waiting or sojourn time in the system.
+     Args:
+         sim_moments (list): List of simulated moments.
+         calc_moments (list): List of calculated moments.
+         is_w (bool, optional): If True, prints waiting time moments. Otherwise, prints sojourn time moments. Defaults to True.
+
+    """
     if is_w:
-        spec = 'ожидания'
+        spec = 'waiting'
     else:
-        spec = 'пребывания'
+        spec = 'soujorn'
 
-    header = f'\rНачальные моменты времени {spec} заявок в системе:'
+    header = f'Initial moments of {spec} time in the system'
 
     print(Fore.CYAN + f'\r{header}')
 
-    print("{0:^15s}|{1:^15s}|{2:^15s}".format("№ момента", "Числ", "ИМ"))
+    print("{0:^15s}|{1:^15s}|{2:^15s}".format("#", "Num", "Sim"))
     print("-" * 45)
     if isinstance(sim_moments, list):
         for j in range(min(len(sim_moments), len(calc_moments))):
@@ -35,10 +43,17 @@ def times_print(sim_moments, calc_moments, is_w=True):
 
 
 def probs_print(p_sim, p_ch, size=10):
+    """
+    Prints the probabilities of states.
+    :param p_sim: Simulated probabilities
+    :param p_ch: Calculated probabilities
+    :param size: Number of states to print
+    :return: None
+    """
     print(Fore.CYAN + "-" * 36)
-    print("{0:^36s}".format("Вероятности состояний"))
+    print("{0:^36s}".format("Probabilities of states"))
     print("-" * 36)
-    print("{0:^4s}|{1:^15s}|{2:^15s}".format("№", "Числ", "ИМ"))
+    print("{0:^4s}|{1:^15s}|{2:^15s}".format("#", "Num", "Sim"))
     print("-" * 36)
     size = min(len(p_sim), len(p_ch), size)
     for i in range(size):
@@ -50,20 +65,29 @@ def probs_print(p_sim, p_ch, size=10):
 
 
 def times_print_with_classes(sim_moments, calc_moments, is_w=True):
+    """
+    Print moments with classes
+     :param sim_moments: Simulated moments
+     :param calc_moments: Calculated moments
+     :param is_w: If True, print waiting time, else print sojourn time
+      :return: None
+
+    """
     if is_w:
-        spec = 'ожидания'
+        spec = 'waiting'
     else:
-        spec = 'пребывания'
+        spec = 'soujorn'
+
+    header = f'Initial moments of {spec} time in the system'
 
-    header = f'Начальные моменты времени {spec} заявок в системе'
     k_num = len(sim_moments)
     size = len(sim_moments[0])
 
     print(Fore.CYAN + f'{header:^60s}')
 
     print("-" * 60)
-    print("{0:^11s}|{1:^47s}|".format('', 'Номер начального момента'))
-    print("{0:^11s}| ".format('№ кл'), end="")
+    print("{0:^11s}|{1:^47s}|".format('', 'Number of moment'))
+    print("{0:^11s}| ".format('Cls'), end="")
     print("-" * 45 + " |")
 
     print(" " * 11 + "|", end="")
@@ -75,7 +99,7 @@ def times_print_with_classes(sim_moments, calc_moments, is_w=True):
 
     for i in range(k_num):
         print(Fore.CYAN + " " * 5 + "|", end="")
-        print(Fore.CYAN + "{:^5s}|".format("ИМ"), end="")
+        print(Fore.CYAN + "{:^5s}|".format("Sim"), end="")
         for j in range(size):
             print(
                 Fore.YELLOW + "{:^15.3g}".format(sim_moments[i][j]) + Fore.CYAN + "|", end="")
@@ -83,7 +107,7 @@ def times_print_with_classes(sim_moments, calc_moments, is_w=True):
         print(Fore.CYAN + "{:^5s}".format(str(i + 1)) + "|" + "-" * 54)
 
         print(Fore.CYAN + " " * 5 + "|", end="")
-        print(Fore.CYAN + "{:^5s}|".format("Р"), end="")
+        print(Fore.CYAN + "{:^5s}|".format("Num"), end="")
         for j in range(size):
             print(
                 Fore.YELLOW + "{:^15.3g}".format(calc_moments[i][j]) + Fore.CYAN + "|", end="")

{most_queue-1.49 → most_queue-1.50}/most_queue/theory/engset_model.py

@@ -1,10 +1,13 @@
+"""
+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_utils.conv import get_moments
 
 
 class Engset:
     """
-    Расчет СМО М\М\1 с конечным числом источников m
+    Calculation of the Engset model for M/M/1 with a finite number of sources.
     """
 
     def __init__(self, lam, mu, m):

{most_queue-1.49 → most_queue-1.50}/most_queue/theory/m_h2_h2warm.py

@@ -10,9 +10,8 @@ from most_queue.theory.utils.binom_probs import calc_binom_probs
 
 class Mh2h2Warm:
     """
-    Расчет СМО M/H2/n с H2-разогревом численным методом Такахаси-Таками.
-    Используются комплексные параметры. Комплексные параметры позволяют аппроксимировать распределение времени обслуживания
-    с произвольными коэффициентами вариации (>1, <=1)
+    Calculation of the M/H2/n system with H2-warming using the Takahasi-Takagi method.
+    Use complex parameters. Complex parameters allow to approximate the service time distribution with arbitrary coefficients of variation (>1, <=1).
     """
 
     def __init__(self, l, b, b_warm, n, buffer=None, N=150, accuracy=1e-6, dtype="c16", verbose=False,