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

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: most_queue
-Version: 1.34
+Version: 1.36
 Summary: Software package for calculation and simulation of queuing systems
-Home-page: https://github.com/xabarov/mps
+Home-page: https://github.com/xabarov/most-queue
 Author: Xabarov Roman
 Author-email: Xabarov Roman <xabarov1985@gmail.com>
 License: Copyright (c) 2018 The Python Packaging Authority
@@ -24,7 +24,7 @@ License: Copyright (c) 2018 The Python Packaging Authority
         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.
-Project-URL: Homepage, https://github.com/xabarov/mps
+Project-URL: Homepage, https://github.com/xabarov/most-queue
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -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.36}/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.36}/most_queue.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: most_queue
-Version: 1.34
+Version: 1.36
 Summary: Software package for calculation and simulation of queuing systems
-Home-page: https://github.com/xabarov/mps
+Home-page: https://github.com/xabarov/most-queue
 Author: Xabarov Roman
 Author-email: Xabarov Roman <xabarov1985@gmail.com>
 License: Copyright (c) 2018 The Python Packaging Authority
@@ -24,7 +24,7 @@ License: Copyright (c) 2018 The Python Packaging Authority
         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.
-Project-URL: Homepage, https://github.com/xabarov/mps
+Project-URL: Homepage, https://github.com/xabarov/most-queue
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -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.36/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.36/most_queue.egg-info/top_level.txt

@@ -1 +1 @@
-
+

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

@@ -1,6 +1,6 @@
 [project]
 name = "most_queue"
-version = "1.34"
+version = "1.36"
 authors = [
   { name="Xabarov Roman", email="xabarov1985@gmail.com" },
 ]
@@ -15,4 +15,4 @@ classifiers = [
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/xabarov/mps"
+"Homepage" = "https://github.com/xabarov/most-queue"

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

@@ -1,11 +1,11 @@
 from setuptools import setup, find_packages
 
 setup(name='most-queue',
-      version='1.34',
+      version='1.36',
       description="Software package for calculation and simulation of queuing systems",
       author='Xabarov Roman',
       author_email='xabarov1985@gmail.com',
-      url='https://github.com/xabarov/mps',
+      url='https://github.com/xabarov/most-queue',
       classifiers=[
         'Development Status :: 3 - Alpha',
         'License :: OSI Approved :: MIT License',
@@ -16,16 +16,11 @@ setup(name='most-queue',
       packages=find_packages(),
       install_requires=[
             "matplotlib",
-            "matplotlib-inline",
-            "numba",
             "numpy",
             "pandas",
             "scipy",
             "tqdm",
-            "tqdm-stubs",
-            'networkx',
-            'graphviz',
-            'colorama'
+            "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
-
-