most-queue 1.34__tar.gz → 1.35__tar.gz

{most_queue-1.34 → most_queue-1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: most_queue
-Version: 1.34
+Version: 1.35
 Summary: Software package for calculation and simulation of queuing systems
 Home-page: https://github.com/xabarov/mps
 Author: Xabarov Roman
@@ -94,7 +94,81 @@ Most_queue consists of two main parts:
 | 10.  | 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/tests) for examples
+- Look [here](https://github.com/xabarov/most-queue/tree/main/most_queue/pytests) for examples
+
+- As an example, we will provide the code for сomparison of calculation results by the Takahashi-Takami and Simulation.
+
+```python
+
+    import math
+    from most_queue.sim.qs_sim import QueueingSystemSimulator
+    from most_queue.sim import rand_destribution as rd
+    import time
+    from most_queue.theory.mgn_tt import MGnCalc
+    from most_queue.utils.tables import probs_print, times_print
+  
+    n = 3  # number of channels
+    l = 1.0  # input flow intensity
+    ro = 0.8  # utilization
+    b1 = n * ro / l  # mean service time
+    num_of_jobs = 300000  # num of simulation jobs
+    b_coev = 1.5  # service time coefficient of variation
+
+
+    #  Calculation of initial moments of service time based on a given average and coefficient of variation
+    b = [0.0] * 3
+    alpha = 1 / (b_coev ** 2)
+    b[0] = b1
+    b[1] = math.pow(b[0], 2) * (math.pow(b_coev, 2) + 1)
+    b[2] = b[1] * b[0] * (1.0 + 2 / alpha)
+
+    tt_start = time.process_time()
+
+    #  Run of the Takahashi-Takami method
+    tt = MGnCalc(n, l, b)
+    tt.run()
+
+    # obtaining results of numerical calculations
+
+    p_tt = tt.get_p()
+    v_tt = tt.get_v()
+    tt_time = time.process_time() - tt_start
+
+    # You can also find out how many iterations were required
+    num_of_iter = tt.num_of_iter_
+
+    # Run simulation to verify results
+    im_start = time.process_time()
+
+    qs = QueueingSystemSimulator(n)
+
+    # we set the input flow of jobs. M is exponential with intensity l
+    qs.set_sources(l, 'M')
+
+    # 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]])
+    qs.set_servers(gamma_params, 'Gamma')
+
+    # Run simulation
+    qs.run(num_of_jobs)
+
+    # Get sim results
+    p = qs.get_p()
+    v_sim = qs.v
+    im_time = time.process_time() - im_start
+
+    print("\nComparison of calculation results by the Takahashi-Takami and simulation.\n"
+          "Sim- M/Gamma/{0:^2d}\nTT- M/H2/{0:^2d}"
+          "Utilization: {1:^1.2f}\nService time coef of variation: {2:^1.2f}\n".format(n, ro, b_coev))
+    print("T-T iterations num: {0:^4d}".format(num_of_iter))
+    print("TT run time: {0:^5.3f} c".format(tt_time))
+    print("Sim run time: {0:^5.3f} c".format(im_time))
+    probs_print(p, p_tt, 10)
+
+    times_print(v_sim, v_tt, False)
+      
+```
 
 
 

{most_queue-1.34 → most_queue-1.35}/README.md

@@ -60,7 +60,81 @@ Most_queue consists of two main parts:
 | 10.  | 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/tests) for examples
+- Look [here](https://github.com/xabarov/most-queue/tree/main/most_queue/pytests) for examples
+
+- As an example, we will provide the code for сomparison of calculation results by the Takahashi-Takami and Simulation.
+
+```python
+
+    import math
+    from most_queue.sim.qs_sim import QueueingSystemSimulator
+    from most_queue.sim import rand_destribution as rd
+    import time
+    from most_queue.theory.mgn_tt import MGnCalc
+    from most_queue.utils.tables import probs_print, times_print
+  
+    n = 3  # number of channels
+    l = 1.0  # input flow intensity
+    ro = 0.8  # utilization
+    b1 = n * ro / l  # mean service time
+    num_of_jobs = 300000  # num of simulation jobs
+    b_coev = 1.5  # service time coefficient of variation
+
+
+    #  Calculation of initial moments of service time based on a given average and coefficient of variation
+    b = [0.0] * 3
+    alpha = 1 / (b_coev ** 2)
+    b[0] = b1
+    b[1] = math.pow(b[0], 2) * (math.pow(b_coev, 2) + 1)
+    b[2] = b[1] * b[0] * (1.0 + 2 / alpha)
+
+    tt_start = time.process_time()
+
+    #  Run of the Takahashi-Takami method
+    tt = MGnCalc(n, l, b)
+    tt.run()
+
+    # obtaining results of numerical calculations
+
+    p_tt = tt.get_p()
+    v_tt = tt.get_v()
+    tt_time = time.process_time() - tt_start
+
+    # You can also find out how many iterations were required
+    num_of_iter = tt.num_of_iter_
+
+    # Run simulation to verify results
+    im_start = time.process_time()
+
+    qs = QueueingSystemSimulator(n)
+
+    # we set the input flow of jobs. M is exponential with intensity l
+    qs.set_sources(l, 'M')
+
+    # 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]])
+    qs.set_servers(gamma_params, 'Gamma')
+
+    # Run simulation
+    qs.run(num_of_jobs)
+
+    # Get sim results
+    p = qs.get_p()
+    v_sim = qs.v
+    im_time = time.process_time() - im_start
+
+    print("\nComparison of calculation results by the Takahashi-Takami and simulation.\n"
+          "Sim- M/Gamma/{0:^2d}\nTT- M/H2/{0:^2d}"
+          "Utilization: {1:^1.2f}\nService time coef of variation: {2:^1.2f}\n".format(n, ro, b_coev))
+    print("T-T iterations num: {0:^4d}".format(num_of_iter))
+    print("TT run time: {0:^5.3f} c".format(tt_time))
+    print("Sim run time: {0:^5.3f} c".format(im_time))
+    probs_print(p, p_tt, 10)
+
+    times_print(v_sim, v_tt, False)
+      
+```
 
 
 

{most_queue-1.34 → most_queue-1.35}/most_queue.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: most_queue
-Version: 1.34
+Version: 1.35
 Summary: Software package for calculation and simulation of queuing systems
 Home-page: https://github.com/xabarov/mps
 Author: Xabarov Roman
@@ -94,7 +94,81 @@ Most_queue consists of two main parts:
 | 10.  | 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/tests) for examples
+- Look [here](https://github.com/xabarov/most-queue/tree/main/most_queue/pytests) for examples
+
+- As an example, we will provide the code for сomparison of calculation results by the Takahashi-Takami and Simulation.
+
+```python
+
+    import math
+    from most_queue.sim.qs_sim import QueueingSystemSimulator
+    from most_queue.sim import rand_destribution as rd
+    import time
+    from most_queue.theory.mgn_tt import MGnCalc
+    from most_queue.utils.tables import probs_print, times_print
+  
+    n = 3  # number of channels
+    l = 1.0  # input flow intensity
+    ro = 0.8  # utilization
+    b1 = n * ro / l  # mean service time
+    num_of_jobs = 300000  # num of simulation jobs
+    b_coev = 1.5  # service time coefficient of variation
+
+
+    #  Calculation of initial moments of service time based on a given average and coefficient of variation
+    b = [0.0] * 3
+    alpha = 1 / (b_coev ** 2)
+    b[0] = b1
+    b[1] = math.pow(b[0], 2) * (math.pow(b_coev, 2) + 1)
+    b[2] = b[1] * b[0] * (1.0 + 2 / alpha)
+
+    tt_start = time.process_time()
+
+    #  Run of the Takahashi-Takami method
+    tt = MGnCalc(n, l, b)
+    tt.run()
+
+    # obtaining results of numerical calculations
+
+    p_tt = tt.get_p()
+    v_tt = tt.get_v()
+    tt_time = time.process_time() - tt_start
+
+    # You can also find out how many iterations were required
+    num_of_iter = tt.num_of_iter_
+
+    # Run simulation to verify results
+    im_start = time.process_time()
+
+    qs = QueueingSystemSimulator(n)
+
+    # we set the input flow of jobs. M is exponential with intensity l
+    qs.set_sources(l, 'M')
+
+    # 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]])
+    qs.set_servers(gamma_params, 'Gamma')
+
+    # Run simulation
+    qs.run(num_of_jobs)
+
+    # Get sim results
+    p = qs.get_p()
+    v_sim = qs.v
+    im_time = time.process_time() - im_start
+
+    print("\nComparison of calculation results by the Takahashi-Takami and simulation.\n"
+          "Sim- M/Gamma/{0:^2d}\nTT- M/H2/{0:^2d}"
+          "Utilization: {1:^1.2f}\nService time coef of variation: {2:^1.2f}\n".format(n, ro, b_coev))
+    print("T-T iterations num: {0:^4d}".format(num_of_iter))
+    print("TT run time: {0:^5.3f} c".format(tt_time))
+    print("Sim run time: {0:^5.3f} c".format(im_time))
+    probs_print(p, p_tt, 10)
+
+    times_print(v_sim, v_tt, False)
+      
+```
 
 
 

most_queue-1.35/most_queue.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+most_queue.egg-info/PKG-INFO
+most_queue.egg-info/SOURCES.txt
+most_queue.egg-info/dependency_links.txt
+most_queue.egg-info/not-zip-safe
+most_queue.egg-info/top_level.txt

most_queue-1.34/most_queue.egg-info/not-zip-safe → most_queue-1.35/most_queue.egg-info/top_level.txt

@@ -1 +1 @@
-
+

{most_queue-1.34 → most_queue-1.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "most_queue"
-version = "1.34"
+version = "1.35"
 authors = [
   { name="Xabarov Roman", email="xabarov1985@gmail.com" },
 ]

{most_queue-1.34 → most_queue-1.35}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 setup(name='most-queue',
-      version='1.34',
+      version='1.35',
       description="Software package for calculation and simulation of queuing systems",
       author='Xabarov Roman',
       author_email='xabarov1985@gmail.com',
@@ -28,4 +28,4 @@ setup(name='most-queue',
             'colorama'
       ],
       include_package_data=True,
-      zip_safe=False)
+      zip_safe=False)

most_queue-1.34/most_queue/sim/__init__.py

@@ -1,3 +0,0 @@
-import os, sys
-
-sys.path.append(os.path.dirname(os.path.realpath(__file__)))

most_queue-1.34/most_queue/sim/batch_sim.py

@@ -1,83 +0,0 @@
-from qs_sim import QueueingSystemSimulator, Task
-
-import numpy as np
-
-
-class QueueingSystemBatchSim(QueueingSystemSimulator):
-    def __init__(self, num_of_channels, batch_prob, buffer=None, verbose=True):
-        super().__init__(num_of_channels, buffer, verbose)
-
-        self.batch_prob = batch_prob
-        self.calc_cdf_prob()
-
-    def calc_cdf_prob(self):
-        summ = 0
-        self.batch_cdf = []
-        for p in self.batch_prob:
-            summ += p
-            self.batch_cdf.append(summ)
-
-    def arrival(self):
-
-        """
-        Действия по прибытию заявки в СМО.
-        """
-
-        p = np.random.random()
-        batch_size = 0
-        for i, batch_prob in enumerate(self.batch_cdf):
-            if p < batch_prob:
-                batch_size = i + 1
-                break
-
-        self.ttek = self.arrival_time
-        self.t_old = self.ttek
-
-        if self.cuda:
-            self.arrival_time = self.ttek + self.source_random_vars[self.tek_source_num]
-            self.tek_source_num += 1
-            if self.tek_source_num == len(self.source_random_vars):
-                self.tek_source_num = 0
-        else:
-            self.arrival_time = self.ttek + self.source.generate()
-
-        for tsk in range(batch_size):
-            self.arrived += 1
-            self.p[self.in_sys] += self.arrival_time - self.t_old
-
-            self.in_sys += 1
-
-            if self.free_channels == 0:
-                if self.buffer == None:  # не задана длина очередиб т.е бесконечная очередь
-                    new_tsk = Task(self.ttek)
-                    new_tsk.start_waiting_time = self.ttek
-                    self.queue.append(new_tsk)
-                else:
-                    if len(self.queue) < self.buffer:
-                        new_tsk = Task(self.ttek)
-                        new_tsk.start_waiting_time = self.ttek
-                        self.queue.append(new_tsk)
-                    else:
-                        self.dropped += 1
-                        self.in_sys -= 1
-
-            else:  # there are free channels:
-
-                # check if its a warm phase:
-                is_warm_start = False
-                if len(self.queue) == 0 and self.free_channels == self.n and self.is_set_warm:
-                    is_warm_start = True
-
-                for s in self.servers:
-                    if s.is_free:
-                        self.taked += 1
-                        s.start_service(Task(self.ttek), self.ttek, is_warm_start)
-                        self.free_channels -= 1
-
-                        # Проверям, не наступил ли ПНЗ:
-                        if self.free_channels == 0:
-                            if self.in_sys == self.n:
-                                self.start_ppnz = self.ttek
-                        break
-
-