most-queue 1.26__tar.gz → 1.27__tar.gz

{most_queue-1.26 → most_queue-1.27}/PKG-INFO

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

{most_queue-1.26 → most_queue-1.27}/most_queue/sim/qs_sim.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-import rand_destribution as rd
+import most_queue.sim.rand_destribution as rd
 import math
 from tqdm import tqdm
 import time
@@ -39,6 +39,8 @@ class QueueingSystemSimulator:
         self.verbose = verbose  # выводить ли текстовые сообщения о работе
         self.cuda = cuda  # использование CUDA при ИМ для генерации ПСЧ
 
+        self.generator = np.random.default_rng()
+
         self.free_channels = self.n
         self.num_of_states = 100000
         self.load = 0  # коэффициент загрузки системы
@@ -104,6 +106,7 @@ class QueueingSystemSimulator:
         self.cold_delay_prob = 0
         self.cold_delay_starts_times = 0
 
+
     def set_warm(self, params, types):
         """
             Задает тип и параметры распределения времени обслуживания с разогревом
@@ -118,22 +121,23 @@ class QueueingSystemSimulator:
             Равномерное                         'Uniform'     [mean, half_interval]
             Нормальное                            'Norm'    [mean, standard_deviation]
         """
+
         if types == "M":
-            self.warm_dist = rd.Exp_dist(params)
+            self.warm_dist = rd.Exp_dist(params, generator=self.generator)
         elif types == "H":
-            self.warm_dist = rd.H2_dist(params)
+            self.warm_dist = rd.H2_dist(params, generator=self.generator)
         elif types == "E":
-            self.warm_dist = rd.Erlang_dist(params)
+            self.warm_dist = rd.Erlang_dist(params, generator=self.generator)
         elif types == "Gamma":
-            self.warm_dist = rd.Gamma(params)
+            self.warm_dist = rd.Gamma(params, generator=self.generator)
         elif types == "C":
-            self.warm_dist = rd.Cox_dist(params)
+            self.warm_dist = rd.Cox_dist(params, generator=self.generator)
         elif types == "Pa":
-            self.warm_dist = rd.Pareto_dist(params)
+            self.warm_dist = rd.Pareto_dist(params, generator=self.generator)
         elif types == "Unifrorm":
-            self.warm_dist = rd.Uniform_dist(params)
+            self.warm_dist = rd.Uniform_dist(params, generator=self.generator)
         elif types == "Norm":
-            self.warm_dist = rd.Normal_dist(params)
+            self.warm_dist = rd.Normal_dist(params, generator=self.generator)
         elif types == "D":
             self.warm_dist = rd.Det_dist(params)
         else:
@@ -160,21 +164,21 @@ class QueueingSystemSimulator:
         """
 
         if types == "M":
-            self.cold_dist = rd.Exp_dist(params)
+            self.cold_dist = rd.Exp_dist(params, generator=self.generator)
         elif types == "H":
-            self.cold_dist = rd.H2_dist(params)
+            self.cold_dist = rd.H2_dist(params, generator=self.generator)
         elif types == "E":
-            self.cold_dist = rd.Erlang_dist(params)
+            self.cold_dist = rd.Erlang_dist(params, generator=self.generator)
         elif types == "Gamma":
-            self.cold_dist = rd.Gamma(params)
+            self.cold_dist = rd.Gamma(params, generator=self.generator)
         elif types == "C":
-            self.cold_dist = rd.Cox_dist(params)
+            self.cold_dist = rd.Cox_dist(params, generator=self.generator)
         elif types == "Pa":
-            self.cold_dist = rd.Pareto_dist(params)
+            self.cold_dist = rd.Pareto_dist(params, generator=self.generator)
         elif types == "Unifrorm":
-            self.cold_dist = rd.Uniform_dist(params)
+            self.cold_dist = rd.Uniform_dist(params, generator=self.generator)
         elif types == "Norm":
-            self.cold_dist = rd.Normal_dist(params)
+            self.cold_dist = rd.Normal_dist(params, generator=self.generator)
         elif types == "D":
             self.cold_dist = rd.Det_dist(params)
         else:
@@ -205,21 +209,21 @@ class QueueingSystemSimulator:
                 "Необходимо сперва задать время охлаждения. Используйте метод set_cold()")
 
         if types == "M":
-            self.cold_delay_dist = rd.Exp_dist(params)
+            self.cold_delay_dist = rd.Exp_dist(params, generator=self.generator)
         elif types == "H":
-            self.cold_delay_dist = rd.H2_dist(params)
+            self.cold_delay_dist = rd.H2_dist(params, generator=self.generator)
         elif types == "E":
-            self.cold_delay_dist = rd.Erlang_dist(params)
+            self.cold_delay_dist = rd.Erlang_dist(params, generator=self.generator)
         elif types == "Gamma":
-            self.cold_delay_dist = rd.Gamma(params)
+            self.cold_delay_dist = rd.Gamma(params, generator=self.generator)
         elif types == "C":
-            self.cold_delay_dist = rd.Cox_dist(params)
+            self.cold_delay_dist = rd.Cox_dist(params, generator=self.generator)
         elif types == "Pa":
-            self.cold_delay_dist = rd.Pareto_dist(params)
+            self.cold_delay_dist = rd.Pareto_dist(params, generator=self.generator)
         elif types == "Unifrorm":
-            self.cold_delay_dist = rd.Uniform_dist(params)
+            self.cold_delay_dist = rd.Uniform_dist(params, generator=self.generator)
         elif types == "Norm":
-            self.cold_delay_dist = rd.Normal_dist(params)
+            self.cold_delay_dist = rd.Normal_dist(params, generator=self.generator)
         elif types == "D":
             self.cold_delay_dist = rd.Det_dist(params)
         else:
@@ -249,21 +253,21 @@ class QueueingSystemSimulator:
         self.is_set_source_params = True
 
         if self.source_types == "M":
-            self.source = rd.Exp_dist(self.source_params)
+            self.source = rd.Exp_dist(self.source_params, generator=self.generator)
         elif self.source_types == "H":
-            self.source = rd.H2_dist(self.source_params)
+            self.source = rd.H2_dist(self.source_params, generator=self.generator)
         elif self.source_types == "E":
-            self.source = rd.Erlang_dist(self.source_params)
+            self.source = rd.Erlang_dist(self.source_params, generator=self.generator)
         elif self.source_types == "C":
-            self.source = rd.Cox_dist(self.source_params)
+            self.source = rd.Cox_dist(self.source_params, generator=self.generator)
         elif self.source_types == "Pa":
-            self.source = rd.Pareto_dist(self.source_params)
+            self.source = rd.Pareto_dist(self.source_params, generator=self.generator)
         elif self.source_types == "Gamma":
-            self.source = rd.Gamma(self.source_params)
+            self.source = rd.Gamma(self.source_params, generator=self.generator)
         elif self.source_types == "Uniform":
-            self.source = rd.Uniform_dist(self.source_params)
+            self.source = rd.Uniform_dist(self.source_params, generator=self.generator)
         elif self.source_types == "Norm":
-            self.source = rd.Normal_dist(self.source_params)
+            self.source = rd.Normal_dist(self.source_params, generator=self.generator)
         elif self.source_types == "D":
             self.source = rd.Det_dist(self.source_params)
         else:
@@ -291,7 +295,7 @@ class QueueingSystemSimulator:
         self.is_set_server_params = True
 
         for i in range(self.n):
-            self.servers.append(Server(self.server_params, self.server_types))
+            self.servers.append(Server(self.server_params, self.server_types, generator=self.generator))
 
     def calc_load(self):
 
@@ -472,7 +476,7 @@ class QueueingSystemSimulator:
                     self.send_task_to_queue()
                 else:
                     if self.free_channels == self.n:
-                        # 2. Она пустая и была выклюбчена после охлаждения. Запускаем разогрев
+                        # 2. Она пустая и была выключена после охлаждения. Запускаем разогрев
                         self.start_warm()
                         # Отправляем заявку в очередь
                         self.send_task_to_queue()
@@ -825,27 +829,27 @@ class Server:
     """
     id = 0
 
-    def __init__(self, params, types):
+    def __init__(self, params, types, generator=None):
         """
         params - параметры распределения
         types -  тип распределения
         """
         if types == "M":
-            self.dist = rd.Exp_dist(params)
+            self.dist = rd.Exp_dist(params, generator=generator)
         elif types == "H":
-            self.dist = rd.H2_dist(params)
+            self.dist = rd.H2_dist(params, generator=generator)
         elif types == "E":
-            self.dist = rd.Erlang_dist(params)
+            self.dist = rd.Erlang_dist(params, generator=generator)
         elif types == "C":
-            self.dist = rd.Cox_dist(params)
+            self.dist = rd.Cox_dist(params, generator=generator)
         elif types == "Gamma":
-            self.dist = rd.Gamma(params)
+            self.dist = rd.Gamma(params, generator=generator)
         elif types == "Pa":
-            self.dist = rd.Pareto_dist(params)
+            self.dist = rd.Pareto_dist(params, generator=generator)
         elif types == "Uniform":
-            self.dist = rd.Uniform_dist(params)
+            self.dist = rd.Uniform_dist(params, generator=generator)
         elif types == "Norm":
-            self.dist = rd.Normal_dist(params)
+            self.dist = rd.Normal_dist(params, generator=generator)
         elif types == "D":
             self.dist = rd.Det_dist(params)
         else:
@@ -861,24 +865,24 @@ class Server:
         self.types_warm = None
         self.warm_dist = None
 
-    def set_warm(self, params, types):
+    def set_warm(self, params, types, generator=None):
 
         if types == "M":
-            self.warm_dist = rd.Exp_dist(params)
+            self.warm_dist = rd.Exp_dist(params, generator=generator)
         elif types == "H":
-            self.warm_dist = rd.H2_dist(params)
+            self.warm_dist = rd.H2_dist(params, generator=generator)
         elif types == "E":
-            self.warm_dist = rd.Erlang_dist(params)
+            self.warm_dist = rd.Erlang_dist(params, generator=generator)
         elif types == "Gamma":
-            self.warm_dist = rd.Gamma(params)
+            self.warm_dist = rd.Gamma(params, generator=generator)
         elif types == "C":
-            self.warm_dist = rd.Cox_dist(params)
+            self.warm_dist = rd.Cox_dist(params, generator=generator)
         elif types == "Pa":
-            self.warm_dist = rd.Pareto_dist(params)
+            self.warm_dist = rd.Pareto_dist(params, generator=generator)
         elif types == "Unifrorm":
-            self.warm_dist = rd.Uniform_dist(params)
+            self.warm_dist = rd.Uniform_dist(params, generator=generator)
         elif types == "Norm":
-            self.warm_dist = rd.Normal_dist(params)
+            self.warm_dist = rd.Normal_dist(params, generator=generator)
         elif types == "D":
             self.warm_dist = rd.Det_dist(params)
         else:

{most_queue-1.26 → most_queue-1.27}/most_queue/sim/rand_destribution.py

@@ -62,7 +62,7 @@ def generate_e_jit(rng_states, r, mu, out):
 
 
 class Normal_dist:
-    def __init__(self, params):
+    def __init__(self, params, generator=None):
         """
         Принимает список параметров в следующей последовательности:
         mean - среднее значение
@@ -72,26 +72,28 @@ class Normal_dist:
         self.mean = params[0]
         self.sko = params[1]
         self.type = 'Normal'
+        self.generator = generator
 
     def generate(self):
         """
         Генерация псевдо-случайных чисел
         """
 
-        return self.generate_static(self.mean, self.sko)
+        return self.generate_static(self.mean, self.sko, self.generator)
 
     @staticmethod
-    def generate_static(mean, sko):
+    def generate_static(mean, sko, generator=None):
         """
         Генерация псевдо-случайных чисел
         Статический метод
         """
-
+        if generator:
+            return generator.normal(mean, sko)
         return np.random.normal(mean, sko)
 
 
 class Uniform_dist:
-    def __init__(self, params):
+    def __init__(self, params, generator=None):
         """
         Принимает список параметров в следующей последовательности:
         mean - среднее значение
@@ -101,6 +103,7 @@ class Uniform_dist:
         self.mean = params[0]
         self.half_interval = params[1]
         self.type = 'Uniform'
+        self.generator = generator
 
     def generate(self):
         """
@@ -108,17 +111,17 @@ class Uniform_dist:
         Вызов из экземпляра класса
         """
 
-        return self.generate_static(self.mean, self.half_interval)
+        return self.generate_static(self.mean, self.half_interval, self.generator)
 
     @staticmethod
-    def generate_static(mean, half_interval):
+    def generate_static(mean, half_interval, generator=None):
         """
         Генерация псевдо-случайных чисел, подчиненных равномерному распределению
         Статический метод
         """
-
-        r = np.random.uniform(mean - half_interval, mean + half_interval)
-        return r
+        if generator:
+            return generator.uniform(mean - half_interval, mean + half_interval)
+        return np.random.uniform(mean - half_interval, mean + half_interval)
 
     @staticmethod
     def calc_theory_moments(mean, half_interval, num=3):
@@ -193,7 +196,7 @@ class Uniform_dist:
 
 
 class H2_dist:
-    def __init__(self, params):
+    def __init__(self, params, generator=None):
         """
         Принимает список параметров в следующей последовательности - y1, mu1, mu2
         """
@@ -203,6 +206,7 @@ class H2_dist:
         self.m2 = params[2]
         self.params = params
         self.type = 'H'
+        self.generator = generator
 
     def generate(self):
         """
@@ -210,17 +214,22 @@ class H2_dist:
         Вызов из экземпляра класса
         """
 
-        return self.generate_static(self.y1, self.m1, self.m2)
+        return self.generate_static(self.y1, self.m1, self.m2, self.generator)
 
     @staticmethod
-    def generate_static(y1, m1, m2):
+    def generate_static(y1, m1, m2, generator=None):
         """
         Генерация псевдо-случайных чисел, подчиненных гиперэкспоненциальному распределению 2-го порядка.
         Статический метод
         """
 
-        r = np.random.rand()
-        res = -np.log(np.random.rand())
+        if generator:
+            r = generator.random()
+            res = -np.log(generator.random())
+        else:
+            r = np.random.rand()
+            res = -np.log(np.random.rand())
+
         if r < y1:
             if m1 != 0:
                 res = res / m1
@@ -429,7 +438,7 @@ class Cox_dist:
     Распределение Кокса 2-го порядка
     """
 
-    def __init__(self, params):
+    def __init__(self, params, generator=None):
         """
         Принимает список параметров в следующей последовательности - y1, mu1, mu2
         """
@@ -438,22 +447,30 @@ class Cox_dist:
         self.m2 = params[2]
         self.params = params
         self.type = 'C'
+        self.generator = generator
 
     def generate(self):
         """
         Генерация псевдо-случайных чисел, подчиненных распределению Кокса 2-го порядка. Вызов из экземпляра класса
         """
-        return self.generate_static(self.y1, self.m1, self.m2)
+        return self.generate_static(self.y1, self.m1, self.m2, self.generator)
 
     @staticmethod
-    def generate_static(y1, m1, m2):
+    def generate_static(y1, m1, m2, generator):
         """
         Генерация псевдо-случайных чисел, подчиненных распределению Кокса 2-го порядка. Статический метод
         """
-        r = np.random.rand()
-        res = (-1.0 / m1) * np.log(np.random.rand())
+        if generator:
+            r = generator.random()
+            res = (-1.0 / m1) * np.log(generator.random())
+        else:
+            r = np.random.rand()
+            res = (-1.0 / m1) * np.log(np.random.rand())
         if r < y1:
-            res = res + (-1.0 / m2) * np.log(np.random.rand())
+            if generator:
+                res = res + (-1.0 / m2) * np.log(generator.random())
+            else:
+                res = res + (-1.0 / m2) * np.log(np.random.rand())
         return res
 
     @staticmethod
@@ -566,7 +583,7 @@ class Det_dist:
 class Pareto_dist:
     "Распределение Парето"
 
-    def __init__(self, params):
+    def __init__(self, params, generator=None):
         """
         Принимает список параметров в следующей последовательности - alpha, K
         """
@@ -574,9 +591,10 @@ class Pareto_dist:
         self.k = params[1]
         self.params = params
         self.type = 'Pa'
+        self.generator = generator
 
     def generate(self):
-        return Pareto_dist.generate_static(self.a, self.k)
+        return Pareto_dist.generate_static(self.a, self.k, self.generator)
 
     @staticmethod
     def get_pdf(t, a, k):
@@ -621,7 +639,9 @@ class Pareto_dist:
         return f
 
     @staticmethod
-    def generate_static(a, k):
+    def generate_static(a, k, generator=None):
+        if generator:
+            return k * math.pow(generator.random(), -1 / a)
         return k * math.pow(np.random.rand(), -1 / a)
 
     @staticmethod
@@ -662,7 +682,7 @@ class Erlang_dist:
     Распределение Эрланга r-го порядка
     """
 
-    def __init__(self, params):
+    def __init__(self, params, generator=None):
         """"
         Принимает список параметров в следующей последовательности - r, mu
         """
@@ -670,21 +690,25 @@ class Erlang_dist:
         self.mu = params[1]
         self.params = params
         self.type = 'E'
+        self.generator = generator
 
     def generate(self):
         """
         Генератор псевдо-случайных чисел
         """
-        return self.generate_static(self.r, self.mu)
+        return self.generate_static(self.r, self.mu, self.generator)
 
     @staticmethod
-    def generate_static(r, mu):
+    def generate_static(r, mu, generator=None):
         """
         Генератор псевдо-случайных чисел. Статический метод
         """
         prod = 1
         for i in range(r):
-            prod *= np.random.rand()
+            if generator:
+                prod *= generator.random()
+            else:
+                prod *= np.random.rand()
 
         return -(1.0 / mu) * np.log(prod)
 
@@ -750,17 +774,18 @@ class Exp_dist:
         Экспоненциальное распределение
     """
 
-    def __init__(self, mu):
+    def __init__(self, mu, generator=None):
         self.erl = Erlang_dist([1, mu])
         self.params = mu
         self.type = 'M'
+        self.generator = generator
 
     def generate(self):
         return self.erl.generate()
 
     @staticmethod
-    def generate_static(mu):
-        return Erlang_dist.generate_static(1, mu)
+    def generate_static(mu, generator=None):
+        return Erlang_dist.generate_static(1, mu, generator)
 
     @staticmethod
     def calc_theory_moments(mu, count=3):
@@ -776,7 +801,7 @@ class Gamma:
     Гамма-распределение
     """
 
-    def __init__(self, params):
+    def __init__(self, params, generator=None):
         self.mu = params[0]
         self.alpha = params[1]
         self.is_corrective = False
@@ -787,6 +812,7 @@ class Gamma:
                 self.g.append(params[i])
         self.params = params
         self.type = 'Gamma'
+        self.generator = generator
 
     @staticmethod
     def get_mu_alpha(b):
@@ -839,11 +865,13 @@ class Gamma:
         return mu, alpha
 
     def generate(self):
-        return self.generate_static(self.mu, self.alpha)
+        return self.generate_static(self.mu, self.alpha, self.generator)
 
     @staticmethod
-    def generate_static(mu, alpha):
+    def generate_static(mu, alpha, generator=None):
         theta = 1 / mu
+        if generator:
+            return generator.gamma(alpha, theta)
         return np.random.gamma(alpha, theta)
 
     @staticmethod

{most_queue-1.26 → most_queue-1.27}/most_queue/theory/mg1_warm_calc.py

@@ -32,8 +32,9 @@ if __name__ == '__main__':
     from most_queue.utils.tables import times_print, probs_print
 
     l = 1
-    b1 = 0.8
-    b1_warm = 0.9
+    ro = 0.2  # коэфф загрузки
+    b1 = n * ro / l  # ср время обслуживания
+    b1_warm = n * 0.3 / l  # ср время разогрева
     coev = 1.3
     b_params = rd.H2_dist.get_params_by_mean_and_coev(b1, coev)
     b = rd.H2_dist.calc_theory_moments(*b_params, 4)

{most_queue-1.26 → most_queue-1.27}/most_queue/theory/mmn_with_h2_cold_and_h2_warmup.py

@@ -618,7 +618,7 @@ if __name__ == "__main__":
 
     smo.set_servers(mu, 'M')
     smo.set_warm(gamma_params_warm, 'Gamma')
-    smo.set_cold(gamma_params_cold, 'Gamma')
+    # smo.set_cold(gamma_params_cold, 'Gamma')
 
     smo.run(num_of_jobs)
     p = smo.get_p()

{most_queue-1.26 → most_queue-1.27}/most_queue.egg-info/PKG-INFO

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

{most_queue-1.26 → most_queue-1.27}/pyproject.toml

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

{most_queue-1.26 → most_queue-1.27}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 setup(name='most-queue',
-      version='1.26',
+      version='1.27',
       description="Software package for calculation and simulation of queuing systems",
       author='Xabarov Roman',
       author_email='xabarov1985@gmail.com',