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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: most_queue
-Version: 1.44
+Version: 1.46
 Summary: Software package for calculation and simulation of queuing systems
 Home-page: https://github.com/xabarov/most-queue
 Author: Xabarov Roman
@@ -31,9 +31,19 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
 
-# most_queue
-Python package for calculation and simulation of queuing systems (QS) and networks
+# 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. 
+Queueing theory. Numerical methods. 
+
+Пакет python для расчета и моделирования систем массового обслуживания (СМО) и сетей (СеМО).
+Теория массового обслуживания. Численные методы.
 
 ## Authors
 - [xabarov](https://github.com/xabarov)
@@ -42,12 +52,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 +98,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 +165,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 +210,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.46}/README.md

@@ -1,5 +1,12 @@
-# most_queue
-Python package for calculation and simulation of queuing systems (QS) and networks
+# 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. 
+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.46}/most_queue/sim/batch_sim.py

@@ -1,5 +1,5 @@
 """
-QS with batch arrival
+Queueing system with batch arrivals.
 """
 import numpy as np
 
@@ -8,17 +8,17 @@ from most_queue.sim.qs_sim import QueueingSystemSimulator, Task
 
 class QueueingSystemBatchSim(QueueingSystemSimulator):
     """
-    QS with batch arrivals
+    Queueing system with batch arrivals.
     """
 
     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
+        :param num_of_channels: int : number of channels (servers)
+        :param batch_prob: list : probabilities for different batch sizes
+        :param buffer: Optional(int, None) : length of queueu
+        :param verbose: bool : if True prints info about simulation process
         """
         super().__init__(num_of_channels, buffer, verbose)
 
@@ -52,7 +52,7 @@ class QueueingSystemBatchSim(QueueingSystemSimulator):
 
         self.arrival_time = self.ttek + self.source.generate()
 
-        for tsk in range(batch_size):
+        for _tsk in range(batch_size):
             self.arrived += 1
             self.p[self.in_sys] += self.arrival_time - self.t_old
 
@@ -89,5 +89,5 @@ class QueueingSystemBatchSim(QueueingSystemSimulator):
                         # Проверям, не наступил ли ПНЗ:
                         if self.free_channels == 0:
                             if self.in_sys == self.n:
-                                self.start_ppnz = self.ttek
+                                self.start_busy = self.ttek
                         break

{most_queue-1.44 → most_queue-1.46}/most_queue/sim/fj_delta_sim.py

@@ -12,13 +12,16 @@ class ForkJoinSimDelta(ForkJoinSim):
     Имитационная модель СМО Fork-Join, Split-Join
     """
 
-    def __init__(self, num_of_channels, num_of_parts, delta, is_SJ=False, buffer=None):
+    def __init__(self, num_of_channels, num_of_parts, delta, is_sj=False, buffer=None):
         """
-        num_of_channels - количество каналов СМО
-        buffer - максимальная длина очереди
+        :param num_of_channels: int : количество каналов СМО
+        :param num_of_parts: int : количество частей на которые разбивается задача
+        :param delta: float : параметр модели Fork-Join с дельта-разбиением
+        :param is_sj: bool : если True, то используется модель Split-Join, иначе - Fork-Join
+        :param buffer: Optional(int, None) : максимальная длина очереди
         """
         ForkJoinSim.__init__(self, num_of_channels,
-                             num_of_parts, is_SJ, buffer)
+                             num_of_parts, is_sj, buffer)
         self.delta = delta
         self.subtask_arr_queue = []
         self.serv_task_id = -1
@@ -26,7 +29,7 @@ class ForkJoinSimDelta(ForkJoinSim):
 
     def task_arrival(self):
         """
-            Действия по прибытию заявки в СМО.
+        Действия по прибытию заявки в СМО.
         """
 
         self.arrived += 1
@@ -37,7 +40,7 @@ class ForkJoinSimDelta(ForkJoinSim):
         is_dropped = False
 
         if self.buffer:  # ограниченная длина очереди
-            if not self.is_SJ:
+            if not self.is_sj:
                 if self.queue.size() + self.k - 1 > self.buffer + self.free_channels:
                     self.dropped += 1
                     is_dropped = True
@@ -54,7 +57,7 @@ class ForkJoinSimDelta(ForkJoinSim):
             self.in_sys += 1
             self.sub_task_in_sys += 1
 
-            if not self.is_SJ:  # Fork-Join discipline
+            if not self.is_sj:  # Fork-Join discipline
 
                 if self.free_channels == 0:
                     self.queue.append(t.subtasks[0])
@@ -85,6 +88,9 @@ class ForkJoinSimDelta(ForkJoinSim):
                 self.subtask_arr_queue.append(t.subtasks[i])
 
     def subtask_arrival(self, subtask_num):
+        """
+        Действия по прибытию подзадачи в СМО.
+        """
 
         subtsk = self.subtask_arr_queue.pop(subtask_num)
         self.p[self.in_sys] += subtsk.future_arr_time - self.t_old
@@ -99,7 +105,7 @@ class ForkJoinSimDelta(ForkJoinSim):
         if not is_dropped:
             self.sub_task_in_sys += 1
 
-            if not self.is_SJ:  # Fork-Join discipline
+            if not self.is_sj:  # Fork-Join discipline
 
                 if self.free_channels == 0:
                     self.queue.append(subtsk)
@@ -136,7 +142,7 @@ class ForkJoinSimDelta(ForkJoinSim):
         self.total += 1
         self.free_channels += 1
 
-        if not self.is_SJ:
+        if not self.is_sj:
 
             if self.served_subtask_in_task[end_ts.task_id] == self.k:
                 self.served += 1
@@ -186,6 +192,9 @@ class ForkJoinSimDelta(ForkJoinSim):
                         q for q in self.queue.queue if q.task_id != end_ts.task_id]
 
     def run_one_step(self):
+        """
+        Runs one step of simulation.
+        """
 
         num_of_server_earlier = -1
         serv_earl = 1e10
@@ -198,9 +207,9 @@ class ForkJoinSimDelta(ForkJoinSim):
         subtask_arr_time_earl = 1e10
         num_of_subtask_earl = -1
 
-        for c in range(len(self.subtask_arr_queue)):
-            if self.subtask_arr_queue[c].future_arr_time < subtask_arr_time_earl:
-                subtask_arr_time_earl = self.subtask_arr_queue[c].future_arr_time
+        for c, subtask in enumerate(self.subtask_arr_queue):
+            if subtask.future_arr_time < subtask_arr_time_earl:
+                subtask_arr_time_earl = subtask.future_arr_time
                 num_of_subtask_earl = c
 
         is_task_arr = False
@@ -219,37 +228,42 @@ class ForkJoinSimDelta(ForkJoinSim):
             self.serving(num_of_server_earlier)
 
     def __str__(self, is_short=False):
+        """
+        Returns string representation of the system
+         :param is_short: bool : if True returns short version of string
+         :return: str : string representation of the system
+        """
 
         res = "Queueing system " + self.source_types + \
             "/" + self.server_types + "/" + str(self.n)
-        if self.buffer != None:
+        if self.buffer is not None:
             res += "/" + str(self.buffer)
-        if self.is_SJ:
+        if self.is_sj:
             res += '| Split-Join'
         else:
             res += '| Fork-Join'
 
         res += "\n"
         # res += "Load: " + "{0:4.3f}".format(self.calc_load()) + "\n"
-        res += "Current Time " + "{0:8.3f}".format(self.ttek) + "\n"
-        res += "Arrival Time: " + "{0:8.3f}".format(self.arrival_time) + "\n"
+        res += f"Current Time {self.ttek:8.3f}\n"
+        res += f"Arrival Time: {self.arrival_time:8.3f}\n"
 
         res += "Sojourn moments:\n"
         for i in range(3):
-            res += "\t" + "{0:8.4f}".format(self.v[i])
+            res += f"\t{self.v[i]:8.4f}"
         res += "\n"
 
         if not is_short:
             res += "Stationary prob:\n"
             res += "\t"
             for i in range(10):
-                res += "{0:6.5f}".format(self.p[i] / self.ttek) + "   "
+                res += f"{self.p[i] / self.ttek:6.5f}   "
             res += "\n"
-            res += "Arrived: " + str(self.arrived) + "\n"
-            if self.buffer != None:
-                res += "Dropped: " + str(self.dropped) + "\n"
-            res += "Served: " + str(self.served) + "\n"
-            res += "In System:" + str(self.in_sys) + "\n"
+            res += f"Arrived: {self.arrived}\n"
+            if self.buffer is not None:
+                res += f"Dropped: {self.dropped}\n"
+            res += f"Served: {self.served}\n"
+            res += f"In System: {self.in_sys}\n"
 
             for c in range(self.n):
                 res += str(self.servers[c])