most-queue 1.43__tar.gz → 1.45__tar.gz

{most_queue-1.43 → most_queue-1.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: most_queue
-Version: 1.43
+Version: 1.45
 Summary: Software package for calculation and simulation of queuing systems
 Home-page: https://github.com/xabarov/most-queue
 Author: Xabarov Roman
@@ -32,8 +32,15 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# most_queue
-Python package for calculation and simulation of queuing systems (QS) and networks
+# MostQueue
+
+![Queue](assets/queue6.jpg)
+
+Python package for calculation and simulation of queueing systems (QS) and networks. 
+Queueing theory. Numerical methods. 
+
+Пакет python для расчета и моделирования систем массового обслуживания (СМО) и сетей (СеМО).
+Теория массового обслуживания. Численные методы.
 
 ## Authors
 - [xabarov](https://github.com/xabarov)
@@ -42,12 +49,15 @@ Python package for calculation and simulation of queuing systems (QS) and networ
 Install most-queue with pip
 ```bash
   pip install most-queue
+  pip install -r requirements.txt
 ```
 
 ## DESCRIPTION
 Most_queue consists of two main parts:
  - **.theory** contains programs that implement methods for calculating queuing theory models. 
  - **.sim** contains simulation programs. 
+ - **.tests** contains tests. 
+ - **.rand_distribution** - A set of functions and classes designed to generate a random values and select parameters for distributions like H2, C2, Ek, Pa, Gamma 
 
 ### Package .theory
 | #   | Package name                      | Description                                                                                                                                                                                                                                                |
@@ -85,16 +95,66 @@ Most_queue consists of two main parts:
 | 1.  | fj_delta_sim               | Simulation of QS fork-join with a delay in the start of processing between channels | 
 | 2.  | fj_sim                     | Simulation of QS with fork-join process | 
 | 3.  | priority_network           | Simulation of queuing network with priorities in nodes | 
-| 4.  | rand_distribution          | A set of functions and classes designed to generate a PRNG and select parameters for distributions H2, C2, Ek, Pa, Gamma | 
-| 5.  | qs_sim                     | Simulation of QS GI/G/m/n  | 
-| 6.  | priority_queue_sim         | Simulation of QS GI/G/m/n  with priorities  | 
-| 7.  | flow_sum_sim               | Simulation of flow summation | 
-| 8.  | impatient_sim.py           | Simulation of QS GI/G/m/n with impatience | 
-| 9.  | batch_sim.py               | Simulation of QS GI/G/m/n with batch arrival | 
-| 10.  | queue_finite_source_sim.py | Simulation of QS GI/G/m/n with finite sources | 
+| 4.  | qs_sim                     | Simulation of QS GI/G/m/n  | 
+| 5.  | priority_queue_sim         | Simulation of QS GI/G/m/n  with priorities  | 
+| 6.  | flow_sum_sim               | Simulation of flow summation | 
+| 7.  | impatient_sim.py           | Simulation of QS GI/G/m/n with impatience | 
+| 8.  | batch_sim.py               | Simulation of QS GI/G/m/n with batch arrival | 
+| 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/most_queue/pytests) for examples
+- Look [here](https://github.com/xabarov/most-queue/tree/main/most_queue/tests) for examples
+- Look [here](https://github.com/xabarov/most-queue/tree/main/most_queue/tutorials) for jupyter tutorials
+
+- Simple example: numeric calc for M/G/1 QS. Run simulation for verification
+
+```python
+
+import numpy as np
+
+from most_queue.general_utils.tables import probs_print, times_print
+from most_queue.rand_distribution import H2_dist, Pareto_dist, Uniform_dist
+from most_queue.sim.qs_sim import QueueingSystemSimulator
+from most_queue.theory.mg1_calc import get_p, get_v, get_w
+
+
+"""
+Test QS M/G/1
+"""
+arrival_lambda = 1  # arrival intensity
+b1 = 0.7  # mean serving time
+coev = 1.2  # standard deviation of serving time
+num_of_jobs = 1000000  # jobs num for simulation
+
+# get of 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)
+
+# get wait moments, sojourn time, probs by numeric calc
+w_ch = get_w(arrival_lambda, b)
+v_ch = get_v(arrival_lambda, b)
+p_ch = get_p(arrival_lambda, b, 100)
+
+# run simulation for verification
+qs = QueueingSystemSimulator(1)  # 1 - num of channels
+
+qs.set_servers(params, "H") 
+qs.set_sources(arrival_lambda, "M")
+
+qs.run(num_of_jobs)
+
+# get sim results
+w_sim = qs.w
+p_sim = qs.get_p()
+v_sim = qs.v
+
+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)
+
+```
 
 - As an example, we will provide the code for сomparison of calculation results by the Takahashi-Takami and Simulation.
 
@@ -102,10 +162,10 @@ Most_queue consists of two main parts:
 
     import math
     from most_queue.sim.qs_sim import QueueingSystemSimulator
-    from most_queue.sim import rand_destribution as rd
+    from most_queue.rand_distribution import Gamma
     import time
     from most_queue.theory.mgn_tt import MGnCalc
-    from most_queue.utils.tables import probs_print, times_print
+    from most_queue.general_utils.tables import probs_print, times_print
   
     n = 3  # number of channels
     l = 1.0  # input flow intensity
@@ -147,7 +207,7 @@ Most_queue consists of two main parts:
 
     # We set the parameters of the service channels using Gamma distribution.
     # Select the distribution parameters
-    gamma_params = rd.Gamma.get_mu_alpha([b[0], b[1]])
+    gamma_params = Gamma.get_mu_alpha([b[0], b[1]])
     qs.set_servers(gamma_params, 'Gamma')
 
     # Run simulation

{most_queue-1.43 → most_queue-1.45}/README.md

@@ -1,5 +1,12 @@
-# most_queue
-Python package for calculation and simulation of queuing systems (QS) and networks
+# MostQueue
+
+![Queue](assets/queue6.jpg)
+
+Python package for calculation and simulation of queueing systems (QS) and networks. 
+Queueing theory. Numerical methods. 
+
+Пакет python для расчета и моделирования систем массового обслуживания (СМО) и сетей (СеМО).
+Теория массового обслуживания. Численные методы.
 
 ## Authors
 - [xabarov](https://github.com/xabarov)
@@ -8,12 +15,15 @@ Python package for calculation and simulation of queuing systems (QS) and networ
 Install most-queue with pip
 ```bash
   pip install most-queue
+  pip install -r requirements.txt
 ```
 
 ## DESCRIPTION
 Most_queue consists of two main parts:
  - **.theory** contains programs that implement methods for calculating queuing theory models. 
  - **.sim** contains simulation programs. 
+ - **.tests** contains tests. 
+ - **.rand_distribution** - A set of functions and classes designed to generate a random values and select parameters for distributions like H2, C2, Ek, Pa, Gamma 
 
 ### Package .theory
 | #   | Package name                      | Description                                                                                                                                                                                                                                                |
@@ -51,16 +61,66 @@ Most_queue consists of two main parts:
 | 1.  | fj_delta_sim               | Simulation of QS fork-join with a delay in the start of processing between channels | 
 | 2.  | fj_sim                     | Simulation of QS with fork-join process | 
 | 3.  | priority_network           | Simulation of queuing network with priorities in nodes | 
-| 4.  | rand_distribution          | A set of functions and classes designed to generate a PRNG and select parameters for distributions H2, C2, Ek, Pa, Gamma | 
-| 5.  | qs_sim                     | Simulation of QS GI/G/m/n  | 
-| 6.  | priority_queue_sim         | Simulation of QS GI/G/m/n  with priorities  | 
-| 7.  | flow_sum_sim               | Simulation of flow summation | 
-| 8.  | impatient_sim.py           | Simulation of QS GI/G/m/n with impatience | 
-| 9.  | batch_sim.py               | Simulation of QS GI/G/m/n with batch arrival | 
-| 10.  | queue_finite_source_sim.py | Simulation of QS GI/G/m/n with finite sources | 
+| 4.  | qs_sim                     | Simulation of QS GI/G/m/n  | 
+| 5.  | priority_queue_sim         | Simulation of QS GI/G/m/n  with priorities  | 
+| 6.  | flow_sum_sim               | Simulation of flow summation | 
+| 7.  | impatient_sim.py           | Simulation of QS GI/G/m/n with impatience | 
+| 8.  | batch_sim.py               | Simulation of QS GI/G/m/n with batch arrival | 
+| 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/most_queue/pytests) for examples
+- Look [here](https://github.com/xabarov/most-queue/tree/main/most_queue/tests) for examples
+- Look [here](https://github.com/xabarov/most-queue/tree/main/most_queue/tutorials) for jupyter tutorials
+
+- Simple example: numeric calc for M/G/1 QS. Run simulation for verification
+
+```python
+
+import numpy as np
+
+from most_queue.general_utils.tables import probs_print, times_print
+from most_queue.rand_distribution import H2_dist, Pareto_dist, Uniform_dist
+from most_queue.sim.qs_sim import QueueingSystemSimulator
+from most_queue.theory.mg1_calc import get_p, get_v, get_w
+
+
+"""
+Test QS M/G/1
+"""
+arrival_lambda = 1  # arrival intensity
+b1 = 0.7  # mean serving time
+coev = 1.2  # standard deviation of serving time
+num_of_jobs = 1000000  # jobs num for simulation
+
+# get of 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)
+
+# get wait moments, sojourn time, probs by numeric calc
+w_ch = get_w(arrival_lambda, b)
+v_ch = get_v(arrival_lambda, b)
+p_ch = get_p(arrival_lambda, b, 100)
+
+# run simulation for verification
+qs = QueueingSystemSimulator(1)  # 1 - num of channels
+
+qs.set_servers(params, "H") 
+qs.set_sources(arrival_lambda, "M")
+
+qs.run(num_of_jobs)
+
+# get sim results
+w_sim = qs.w
+p_sim = qs.get_p()
+v_sim = qs.v
+
+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)
+
+```
 
 - As an example, we will provide the code for сomparison of calculation results by the Takahashi-Takami and Simulation.
 
@@ -68,10 +128,10 @@ Most_queue consists of two main parts:
 
     import math
     from most_queue.sim.qs_sim import QueueingSystemSimulator
-    from most_queue.sim import rand_destribution as rd
+    from most_queue.rand_distribution import Gamma
     import time
     from most_queue.theory.mgn_tt import MGnCalc
-    from most_queue.utils.tables import probs_print, times_print
+    from most_queue.general_utils.tables import probs_print, times_print
   
     n = 3  # number of channels
     l = 1.0  # input flow intensity
@@ -113,7 +173,7 @@ Most_queue consists of two main parts:
 
     # We set the parameters of the service channels using Gamma distribution.
     # Select the distribution parameters
-    gamma_params = rd.Gamma.get_mu_alpha([b[0], b[1]])
+    gamma_params = Gamma.get_mu_alpha([b[0], b[1]])
     qs.set_servers(gamma_params, 'Gamma')
 
     # Run simulation

{most_queue-1.43 → most_queue-1.45}/most_queue/general_utils/tables.py

@@ -1,5 +1,4 @@
-from colorama import init
-from colorama import Fore, Back, Style
+from colorama import Back, Fore, Style, init
 
 init()
 
@@ -16,11 +15,21 @@ def times_print(sim_moments, calc_moments, is_w=True):
 
     print("{0:^15s}|{1:^15s}|{2:^15s}".format("№ момента", "Числ", "ИМ"))
     print("-" * 45)
-    for j in range(min(len(sim_moments), len(calc_moments))):
-        calc_mom = calc_moments[j].real if isinstance(calc_moments[j], complex) else calc_moments[j]
-        sim_mom =  sim_moments[j].real if isinstance(sim_moments[j], complex) else sim_moments[j]
+    if isinstance(sim_moments, list):
+        for j in range(min(len(sim_moments), len(calc_moments))):
+            calc_mom = calc_moments[j].real if isinstance(
+                calc_moments[j], complex) else calc_moments[j]
+            sim_mom = sim_moments[j].real if isinstance(
+                sim_moments[j], complex) else sim_moments[j]
+            print(
+                Fore.CYAN + f"{j + 1:^15d}|" + Fore.YELLOW + f"{calc_mom:^15.5g}" + Fore.CYAN + "|" + Fore.YELLOW + f"{sim_mom:^15.5g}")
+    else:
+        calc_mom = calc_moments.real if isinstance(
+            calc_moments, complex) else calc_moments
+        sim_mom = sim_moments.real if isinstance(
+            sim_moments, complex) else sim_moments
         print(
-            Fore.CYAN + f"{j + 1:^15d}|" + Fore.YELLOW  + f"{calc_mom:^15.5g}" + Fore.CYAN + "|" + Fore.YELLOW + f"{sim_mom:^15.5g}")
+            Fore.CYAN + f"{1:^15d}|" + Fore.YELLOW + f"{calc_mom:^15.5g}" + Fore.CYAN + "|" + Fore.YELLOW + f"{sim_mom:^15.5g}")
 
     print(Style.RESET_ALL)
 
@@ -68,14 +77,16 @@ def times_print_with_classes(sim_moments, calc_moments, is_w=True):
         print(Fore.CYAN + " " * 5 + "|", end="")
         print(Fore.CYAN + "{:^5s}|".format("ИМ"), end="")
         for j in range(size):
-            print(Fore.YELLOW + "{:^15.3g}".format(sim_moments[i][j]) + Fore.CYAN + "|", end="")
+            print(
+                Fore.YELLOW + "{:^15.3g}".format(sim_moments[i][j]) + Fore.CYAN + "|", end="")
         print("")
         print(Fore.CYAN + "{:^5s}".format(str(i + 1)) + "|" + "-" * 54)
 
         print(Fore.CYAN + " " * 5 + "|", end="")
         print(Fore.CYAN + "{:^5s}|".format("Р"), end="")
         for j in range(size):
-            print(Fore.YELLOW + "{:^15.3g}".format(calc_moments[i][j]) + Fore.CYAN + "|", end="")
+            print(
+                Fore.YELLOW + "{:^15.3g}".format(calc_moments[i][j]) + Fore.CYAN + "|", end="")
         print("")
         print(Fore.CYAN + "-" * 60)
 

{most_queue-1.43 → most_queue-1.45}/most_queue/sim/batch_sim.py

@@ -8,15 +8,27 @@ from most_queue.sim.qs_sim import QueueingSystemSimulator, Task
 
 class QueueingSystemBatchSim(QueueingSystemSimulator):
     """
-    QS with batch arrival
+    QS with batch arrivals
     """
-    def __init__(self, num_of_channels, batch_prob, buffer=None, verbose=True):
+
+    def __init__(self, num_of_channels,
+                 batch_prob,
+                 buffer=None, verbose=True):
+        """
+        Args:
+            num_of_channels: 
+            batch_prob: list[float], probs of batch size 1, 2, .. len(batch_probs)
+            buffer: Optional(int, None) : length of queueu
+        """
         super().__init__(num_of_channels, buffer, verbose)
 
         self.batch_prob = batch_prob
         self.calc_cdf_prob()
 
     def calc_cdf_prob(self):
+        """
+        Calcs CDF of batch probs distribution
+        """
         summ = 0
         self.batch_cdf = []
         for p in self.batch_prob:
@@ -25,7 +37,7 @@ class QueueingSystemBatchSim(QueueingSystemSimulator):
 
     def arrival(self):
         """
-        Действия по прибытию заявки в СМО.
+        Actions upon arrival of job to QS
         """
 
         p = np.random.random()

{most_queue-1.43 → most_queue-1.45}/most_queue/sim/fj_sim.py

@@ -163,17 +163,22 @@ class ForkJoinSim(QueueingSystemSimulator):
         else:
             self.serving(num_of_server_earlier)
 
-    def run(self, total_served, is_real_served=False):
+    def run(self, total_served, is_real_served=True):
 
         if is_real_served:
-            served_old = 0
-            while self.served < total_served:
-                self.run_one_step()
-                if (self.served - served_old) % 5000 == 0:
-                    sys.stderr.write(
-                        '\rStart simulation. Job served: %d/%d' % (self.served, total_served))
-                    sys.stderr.flush()
-                served_old = self.served
+            
+            last_percent = 0
+
+            with tqdm(total=100, unit='jobs') 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:
             print(Fore.GREEN + '\rStart simulation')
             print(Style.RESET_ALL)

{most_queue-1.43 → most_queue-1.45}/most_queue/sim/priority_network.py

@@ -6,8 +6,8 @@ import numpy as np
 from colorama import Fore, Style, init
 from tqdm import tqdm
 
-from most_queue.sim.priority_queue_sim import PriorityQueueSimulator, Task
 from most_queue.rand_distribution import Exp_dist
+from most_queue.sim.priority_queue_sim import PriorityQueueSimulator, Task
 
 init()
 
@@ -139,15 +139,22 @@ class PriorityNetwork:
 
                 self.smos[next_node].arrival(next_node_class, self.ttek, ts)
 
-    def run(self, job_served, is_real_served=False):
+    def run(self, job_served, is_real_served=True):
         """
         Run simulation
         """
         if is_real_served:
-            while sum(self.served) < job_served:
-                self.run_one_step()
-                sys.stderr.write(f'\rStart simulation. Job served: {sum(self.served)}/{job_served}')
-                sys.stderr.flush()
+            last_percent = 0
+
+            with tqdm(total=100, unit='jobs') as pbar:
+                while sum(self.served) < job_served:
+                    self.run_one_step()
+                    percent = int(100*(sum(self.served)/job_served))
+                    if last_percent != percent:
+                        last_percent = percent
+                        pbar.update(1)
+                        pbar.set_description(Fore.MAGENTA + '\rJob served: ' +
+                                             Fore.YELLOW + f'{sum(self.served)}/{job_served}' + Fore.LIGHTGREEN_EX)
         else:
             print(Fore.GREEN + '\rStart simulation')
             print(Style.RESET_ALL)

{most_queue-1.43 → most_queue-1.45}/most_queue/sim/priority_queue_sim.py

@@ -545,24 +545,29 @@ class PriorityQueueSimulator:
         if self.is_next_calc:
             self.calc_time_to_next_event()
 
-    def run(self, total_served, is_real_served=False):
+    def run(self, total_served, is_real_served=True):
+
+        print(Fore.GREEN + '\rStart simulation')
         if is_real_served:
 
-            while sum(self.served) < total_served:
-                self.run_one_step()
-                sys.stderr.write('\rStart simulation. Job served: %d/%d' %
-                                 (sum(self.served), total_served))
-                sys.stderr.flush()
+            last_percent = 0
 
-        else:
-            print(Fore.GREEN + '\rStart simulation')
-            print(Style.RESET_ALL)
+            with tqdm(total=100, unit='jobs') as pbar:
+                while sum(self.served) < total_served:
+                    self.run_one_step()
+                    percent = int(100*(sum(self.served)/total_served))
+                    if last_percent != percent:
+                        last_percent = percent
+                        pbar.update(1)
+                        pbar.set_description(Fore.MAGENTA + '\rJob served: ' +
+                                             Fore.YELLOW + f'{sum(self.served)}/{total_served}' + Fore.LIGHTGREEN_EX)
 
+        else:
             for i in tqdm(range(total_served)):
                 self.run_one_step()
 
-            print(Fore.GREEN + '\rSimulation is finished')
-            print(Style.RESET_ALL)
+        print(Fore.GREEN + '\rSimulation is finished')
+        print(Style.RESET_ALL)
 
     def refresh_ppnz_stat(self, k, new_a):
         for i in range(3):