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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: most_queue
-Version: 1.44
+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.44 → 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.44 → most_queue-1.45}/most_queue/sim/fj_sim.py

@@ -163,15 +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:
-                    print(f'\rStart simulation. Job served: {self.served}/{total_served}')
-                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.44 → 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.44 → most_queue-1.45}/most_queue/sim/priority_queue_sim.py

@@ -549,15 +549,18 @@ class PriorityQueueSimulator:
 
         print(Fore.GREEN + '\rStart simulation')
         if is_real_served:
-            tek = 0
-            while sum(self.served) < total_served:
-                self.run_one_step()
-                if tek % 5000 == 0:
-                    print(Fore.MAGENTA + '\rJob served: ' + Fore.YELLOW +
-                          f'{sum(self.served)}/{total_served}', end='')
-                tek += 1
-            print(Fore.MAGENTA + '\rJob served: ' + Fore.YELLOW +
-                  f'{sum(self.served)}/{total_served}')
+
+            last_percent = 0
+
+            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)):