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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: most_queue
-Version: 1.42
+Version: 1.44
 Summary: Software package for calculation and simulation of queuing systems
 Home-page: https://github.com/xabarov/most-queue
 Author: Xabarov Roman

{most_queue-1.42 → most_queue-1.44}/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.42 → most_queue-1.44}/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.42 → most_queue-1.44}/most_queue/sim/fj_sim.py

@@ -170,9 +170,7 @@ class ForkJoinSim(QueueingSystemSimulator):
             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()
+                    print(f'\rStart simulation. Job served: {self.served}/{total_served}')
                 served_old = self.served
         else:
             print(Fore.GREEN + '\rStart simulation')

{most_queue-1.42 → most_queue-1.44}/most_queue/sim/priority_queue_sim.py

@@ -545,24 +545,26 @@ class PriorityQueueSimulator:
         if self.is_next_calc:
             self.calc_time_to_next_event()
 
-    def run(self, total_served, is_real_served=False):
-        if is_real_served:
+    def run(self, total_served, is_real_served=True):
 
+        print(Fore.GREEN + '\rStart simulation')
+        if is_real_served:
+            tek = 0
             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()
+                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}')
 
         else:
-            print(Fore.GREEN + '\rStart simulation')
-            print(Style.RESET_ALL)
-
             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):

{most_queue-1.42 → most_queue-1.44}/most_queue/sim/qs_sim.py

@@ -501,30 +501,28 @@ class QueueingSystemSimulator:
             # конец задержки начала охлаждения
             self.on_end_cold_delay()
 
-    def run(self, total_served, is_real_served=False):
+    def run(self, total_served, is_real_served=True):
         """
         Run simulation process
         """
         start = time.process_time()
+        
+        print(Fore.GREEN + '\rStart simulation')
 
         if is_real_served:
-            served_old = 0
+            tek = 0
             while self.served < total_served:
                 self.run_one_step()
-                if (self.served - served_old) % 5000 == 0:
-                    sys.stderr.write(
-                        f'\rStart simulation. Job served: {self.served}/{total_served}')
-                    sys.stderr.flush()
-                served_old = self.served
+                if tek % 5000 == 0:
+                    print(Fore.MAGENTA + '\rJob served: ' + Fore.YELLOW + f'{self.served}/{total_served}', end='')
+                tek += 1
+            print(Fore.MAGENTA + '\rJob served: ' + Fore.YELLOW + f'{self.served}/{total_served}')
         else:
-            print(Fore.GREEN + '\rStart simulation')
-            print(Style.RESET_ALL)
-
             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)
 
         self.time_spent = time.process_time() - start
 

most_queue-1.44/most_queue/tests/test_batch.py

@@ -0,0 +1,52 @@
+from most_queue.general_utils.tables import times_print
+from most_queue.sim.batch_sim import QueueingSystemBatchSim
+from most_queue.theory.batch_mm1 import BatchMM1
+
+
+def calc_mean_batch_size(batch_probs):
+    """
+    Calc mean batch size 
+    batch_probs - probs of batch size 1, 2, .. len(batch_probs)
+    """
+    mean = 0
+    for i, prob in enumerate(batch_probs):
+        mean += (i + 1)*prob
+    return mean
+
+
+def test_batch_mm1():
+    """
+    Test QS Mx/M/1/infinite with batch arrivals
+    """
+
+    # probs of batch size 1, 2, .. 5
+    batch_probs = [0.2, 0.3, 0.1, 0.2, 0.2]
+    mean_batch_size = calc_mean_batch_size(batch_probs)
+
+    n = 1   # one channel
+    lam = 0.7  # arrival intensity
+    ro = 0.7  # QS utilization factor
+    mu = lam * mean_batch_size / ro  # serving intensity
+    n_jobs = 500000  # jobs to serve in QS simulation
+
+    batch_calc = BatchMM1(lam, mu, batch_probs)
+
+    v1 = batch_calc.get_v1()
+
+    qs = QueueingSystemBatchSim(n, batch_probs)
+
+    qs.set_sources(lam, 'M')
+    qs.set_servers(mu, 'M')
+
+    qs.run(n_jobs, is_real_served=True)
+
+    v1_im = qs.v[0]
+    
+    times_print(v1_im, v1, False) # prints 2.6556 and approx 2.5-2.7
+
+    assert v1 - v1_im < 0.2
+
+
+if __name__ == "__main__":
+
+    test_batch_mm1()

{most_queue-1.42 → most_queue-1.44}/most_queue/tests/test_ek_d_n.py

@@ -16,9 +16,9 @@ def test_EkDn():
 
     """
 
-    ro = 0.8  # коэффициент загрузки СМО
+    ro = 0.7  # коэффициент загрузки СМО
     num_of_jobs = 300000  # количество заявок для ИМ. Чем больше, тем выше точночть ИМ
-    n = 4  # число каналов
+    n = 2  # число каналов
 
     # при создании экземпляра класса Ek_D_n нужно передать 4 параметра:
     # - l , k - параметры распределения Эрланга вх потока
@@ -63,7 +63,9 @@ def test_EkDn():
     # выводим полученные значения:
     probs_print(p_sim, p_ch, 10)
 
-    assert np.allclose(np.array(p_sim[:10]), np.array(p_ch[:10]), atol=1e-2)
+    # probs of zero jobs in queue are 0.084411 | 0.084...
+    
+    assert abs(p_sim[0] - p_ch[0]) < 0.001
 
 
 if __name__ == "__main__":

{most_queue-1.42 → most_queue-1.44}/most_queue/tests/test_mg1_calc.py

@@ -3,7 +3,7 @@ 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_w, get_v, get_p
+from most_queue.theory.mg1_calc import get_p, get_v, get_w
 
 
 def test_mg1():

{most_queue-1.42 → most_queue-1.44}/most_queue/tests/test_qs_sim_prty.py

@@ -1,10 +1,9 @@
+import numpy as np
+
+from most_queue.general_utils.tables import probs_print, times_print_with_classes
+from most_queue.rand_distribution import Gamma
 from most_queue.sim.priority_queue_sim import PriorityQueueSimulator
 from most_queue.theory import priority_calc
-from most_queue.rand_distribution import Gamma
-from most_queue.general_utils.tables import probs_print, times_print_with_classes
-
-
-import numpy as np
 
 
 def test_sim():

{most_queue-1.42 → most_queue-1.44}/most_queue/theory/batch_mm1.py

@@ -1,16 +1,25 @@
 import math
 
 """
-Расчет СМО М/M/1 с групповым прибытием заявок
+Calculation of M/M/1 QS with batch arrival 
 """
 
 
 class BatchMM1:
-
-    def __init__(self, lam, mu, ls, p_num=100000, tol=1e-12):
+    """
+    Calculation of M/M/1 QS with batch arrival 
+    """
+    def __init__(self, lam, mu, batch_probs, p_num=100000, tol=1e-12):
+        """_
+            lam: (float): arrival Exp distribution param
+            mu (float): serving Exp distribution param
+            batch_probs (list[float]): batch probs 
+            p_num (int, optional): size of probs to calc. Defaults to 100000.
+            tol (float, optional): tol, precision of calcs. Defaults to 1e-12.
+        """
         self.lam = lam
         self.mu = mu
-        self.ls = ls
+        self.ls = list(batch_probs)
         self.p_num = p_num
         self.tol = tol
         moments = self.calc_l_moments()
@@ -18,26 +27,39 @@ class BatchMM1:
         self.l2 = moments[1]
 
     def calc_l(self):
+        """
+        Mean batch size
+        """
         return sum(self.ls) / len(self.ls)
 
     def calc_l_moments(self):
+        """
+        Initial moments of the number of jobs in the batch
+        """
         moments = [0.0, 0.0]
-        for j in range(len(moments)):
-            for i in range(len(self.ls)):
-                moments[j] += pow(i + 1, j + 1)*self.ls[i]
+        for j, mom in enumerate(moments):
+            for i, prob in enumerate(self.ls):
+                moments[j] += pow(i + 1, j + 1)*prob
         return moments
 
     def calc_L(self):
+        """
+        Returns list of probabilities
+        of arrival more than i applications in a group
+        """
         Ls = []
         Ls.append(1)
         summ = 0
-        for i in range(len(self.ls)):
-            summ += self.ls[i]
+        for i, prob in enumerate(self.ls):
+            summ += prob
             Ls.append(1.0 - summ)
 
         return Ls
 
     def get_p(self):
+        """
+        Probs of QS states
+        """
         ro = self.lam / self.mu
         p0 = 1.0 - self.l * ro
         Ls = self.calc_L()
@@ -64,18 +86,30 @@ class BatchMM1:
         return ps
 
     def get_N(self):
+        """
+        Mean jobs in QS
+        """
         ro = self.l * self.lam / self.mu
         ro_tilda = self.lam / self.mu
         return (self.l2 + self.l) * ro_tilda / (2 * (1.0 - ro))
 
     def get_Q(self):
+        """
+        Mean queue length
+        """
         N = self.get_N()
         ro = self.l * self.lam / self.mu
         return N - ro
 
     def get_w1(self):
+        """
+        Mean wait time
+        """
         return self.get_Q() / (self.l * self.lam)
 
     def get_v1(self):
+        """
+        Mean sojourn time
+        """
         return self.get_N() / (self.l * self.lam)
 

{most_queue-1.42 → most_queue-1.44}/most_queue.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: most_queue
-Version: 1.42
+Version: 1.44
 Summary: Software package for calculation and simulation of queuing systems
 Home-page: https://github.com/xabarov/most-queue
 Author: Xabarov Roman

{most_queue-1.42 → most_queue-1.44}/pyproject.toml

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

{most_queue-1.42 → most_queue-1.44}/setup.py

@@ -1,26 +1,26 @@
 from setuptools import setup, find_packages
 
 setup(name='most-queue',
-      version='1.42',
+      version='1.44',
       description='Software package for calculation and simulation of queuing systems',
       author='Xabarov Roman',
       author_email='xabarov1985@gmail.com',
       url='https://github.com/xabarov/most-queue',
       classifiers=[
-        'Development Status :: 3 - Alpha',
-        'License :: OSI Approved :: MIT License',
-        'Programming Language :: Python :: 3.9',
-        'Topic :: Text Processing :: Linguistic',
+          'Development Status :: 3 - Alpha',
+          'License :: OSI Approved :: MIT License',
+          'Programming Language :: Python :: 3.9',
+          'Topic :: Text Processing :: Linguistic',
       ],
       license='MIT',
       packages=find_packages(),
       install_requires=[
-            'matplotlib',
-            'numpy',
-            'pandas',
-            'scipy',
-            'tqdm',
-            'colorama'
+          'matplotlib',
+          'numpy',
+          'pandas',
+          'scipy',
+          'tqdm',
+          'colorama',
       ],
       include_package_data=True,
       zip_safe=False)

most_queue-1.42/most_queue/tests/test_batch.py

@@ -1,43 +0,0 @@
-from most_queue.sim.batch_sim import QueueingSystemBatchSim
-from most_queue.theory.batch_mm1 import BatchMM1
-
-
-def test_batch_mm1():
-    ls = [0.2, 0.3, 0.1, 0.2, 0.2]
-    moments = [0.0, 0.0]
-    for j in range(len(moments)):
-        for i in range(len(ls)):
-            moments[j] += pow(i + 1, j + 1)
-        moments[j] /= len(ls)
-
-    n = 1
-    lam = 0.7
-    ro = 0.8
-    mu = lam * moments[0] / ro
-    n_jobs = 300000
-
-    batch_calc = BatchMM1(lam, mu, ls)
-
-    v1 = batch_calc.get_v1()
-
-    qs = QueueingSystemBatchSim(n, ls)
-
-    qs.set_sources(lam, 'M')
-    qs.set_servers(mu, 'M')
-
-    qs.run(n_jobs)
-
-    v1_im = qs.v[0]
-
-    print("\nЗначения среднего времени пребывания заявок в системе:\n")
-
-    print("{0:^15s}|{1:^15s}|{2:^15s}".format("№ момента", "Числ", "ИМ"))
-    print("-" * 45)
-    print("{0:^16d}|{1:^15.5g}|{2:^15.5g}".format(1, v1, v1_im))
-
-    assert 100*abs(v1 - v1_im)/max(v1, v1_im) < 5.0
-
-
-if __name__ == "__main__":
-
-    test_batch_mm1()