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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: most_queue
-Version: 1.25
+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.25 → 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  # коэффициент загрузки системы
@@ -85,14 +87,25 @@ class QueueingSystemSimulator:
         self.is_set_warm = False
         self.is_start_warm = False
         self.end_warm_time = 1e16
+        self.warm_prob = 0
+        self.warm_start_mom = 0
+        self.warm_starts_times = 0
+        self.warm_after_cold_starts = 0
         # Cold
         self.is_set_cold = False
         self.is_start_cold = False
         self.end_cold_time = 1e16
+        self.cold_start_mom = 0
+        self.cold_prob = 0
+        self.cold_starts_times = 0
         # Delay
         self.is_set_cold_delay = False
         self.is_start_cold_delay = False
         self.end_cold_delay_time = 1e16
+        self.cold_delay_start_mom = 0
+        self.cold_delay_prob = 0
+        self.cold_delay_starts_times = 0
+
 
     def set_warm(self, params, types):
         """
@@ -108,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:
@@ -150,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:
@@ -195,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:
@@ -239,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:
@@ -281,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):
 
@@ -376,12 +390,13 @@ class QueueingSystemSimulator:
 
         return l * b1 / self.n
 
-    def send_task_to_channel(self, is_warm_start):
+    def send_task_to_channel(self, is_warm_start=False):
         # Отправляет заявку в канал обслуживания
         # is_warm_start- нужен ли разогрев
         for s in self.servers:
             if s.is_free:
                 self.taked += 1
+                self.refresh_w_stat(0)
 
                 s.start_service(Task(self.ttek), self.ttek, is_warm_start)
                 self.free_channels -= 1
@@ -443,7 +458,8 @@ class QueueingSystemSimulator:
                     # Заявка пришла раньше окончания времени задержки начала охлаждения
                     self.is_start_cold_delay = False
                     self.end_cold_delay_time = 1e16
-                    self.send_task_to_channel(False)
+                    self.cold_delay_prob += self.ttek - self.cold_delay_start_mom
+                    self.send_task_to_channel()
                     return
 
             if self.is_set_warm:
@@ -459,23 +475,37 @@ class QueueingSystemSimulator:
                     # 1. В режиме разогрева -> отправляем заявку в очередь
                     self.send_task_to_queue()
                 else:
-                    if len(self.queue) == 0 and self.free_channels == self.n:
-                        # 2. Она пустая и была выклюбчена после охлаждения. Запускаем разогрев
+                    if self.free_channels == self.n:
+                        # 2. Она пустая и была выключена после охлаждения. Запускаем разогрев
                         self.start_warm()
                         # Отправляем заявку в очередь
                         self.send_task_to_queue()
                     else:
                         # 3. Не пустая и разогретая -> тогда оправляем на обслуживание
-                        self.send_task_to_channel(False)
+                        self.send_task_to_channel()
 
             else:
                 # Без разогрева. Отправляем заявку в канал обслуживания
-                self.send_task_to_channel(False)
+                self.send_task_to_channel()
 
     def start_warm(self):
         self.is_start_warm = True
+        self.warm_start_mom = self.ttek
+        self.warm_starts_times += 1
         self.end_warm_time = self.ttek + self.warm_dist.generate()
 
+    def start_cold(self):
+        self.is_start_cold = True
+        self.cold_start_mom = self.ttek
+        self.cold_starts_times += 1
+        self.end_cold_time = self.ttek + self.cold_dist.generate()
+
+    def start_cold_delay(self):
+        self.is_start_cold_delay = True
+        self.cold_delay_start_mom = self.ttek
+        self.cold_delay_starts_times += 1
+        self.end_cold_delay_time = self.ttek + self.cold_delay_dist.generate()
+
     def serving(self, c):
         """
         Дейтсвия по поступлению заявки на обслуживание
@@ -492,26 +522,26 @@ class QueueingSystemSimulator:
         self.total += 1
         self.free_channels += 1
         self.refresh_v_stat(self.ttek - end_ts.arr_time)
-        self.refresh_w_stat(end_ts.wait_time)
+
         self.in_sys -= 1
 
+        # ПНЗ
         if len(self.queue) == 0 and self.free_channels == 1:
             if self.in_sys == self.n - 1:
                 # Конец ПНЗ
                 self.ppnz_moments += 1
                 self.refresh_ppnz_stat(self.ttek - self.start_ppnz)
 
+        # COLD
         if self.is_set_cold:
             if len(self.queue) == 0 and self.free_channels == self.n:
                 # Система стала пустой.
                 # 1. Если задана задержка начала охлаждения - разыгрываем время ее окончания
                 # 2. Если нет - запускаем охлаждение
                 if self.is_set_cold_delay:
-                    self.is_start_cold_delay = True
-                    self.end_cold_delay_time = self.ttek + self.cold_delay_dist.generate()
+                    self.start_cold_delay()
                 else:
-                    self.is_start_cold = True
-                    self.end_cold_time = self.ttek + self.cold_dist.generate()
+                    self.start_cold()
 
         if len(self.queue) != 0:
             self.send_head_of_queue_to_channel(c)
@@ -523,13 +553,16 @@ class QueueingSystemSimulator:
             self.start_ppnz = self.ttek
 
         self.taked += 1
+
         que_ts.wait_time += self.ttek - que_ts.start_waiting_time
+        self.refresh_w_stat(que_ts.wait_time)
+
         self.servers[channel_num].start_service(que_ts, self.ttek)
         self.free_channels -= 1
 
     def calc_next_event_time(self):
 
-        serv_earl = 1e10
+        serv_earl = 1e16
 
         for c in range(self.n):
             if self.servers[c].time_to_end_service < serv_earl:
@@ -547,6 +580,8 @@ class QueueingSystemSimulator:
         self.ttek = self.end_warm_time
         self.t_old = self.ttek
 
+        self.warm_prob += self.ttek - self.warm_start_mom
+
         self.is_start_warm = False
         self.end_warm_time = 1e16
 
@@ -561,13 +596,17 @@ class QueueingSystemSimulator:
         self.ttek = self.end_cold_time
         self.t_old = self.ttek
 
+        self.cold_prob += self.ttek - self.cold_start_mom
+
         self.is_start_cold = False
         self.end_cold_time = 1e16
 
         if self.is_set_warm:
             if len(self.queue) != 0:
                 # Запускаем разогрев только если в очереди скопились заявки.
+                self.warm_after_cold_starts += 1
                 self.start_warm()
+
         else:
             # Отправляем n заявок из очереди в каналы
             for i in range(self.n):
@@ -580,6 +619,8 @@ class QueueingSystemSimulator:
         self.ttek = self.end_cold_delay_time
         self.t_old = self.ttek
 
+        self.cold_delay_prob += self.ttek - self.cold_delay_start_mom
+
         self.is_start_cold_delay = False
         self.end_cold_delay_time = 1e16
 
@@ -671,15 +712,30 @@ class QueueingSystemSimulator:
 
         self.time_spent = time.process_time() - start
 
+    def get_warmup_prob(self):
+
+        return self.warm_prob/self.ttek
+
+    def get_cold_prob(self):
+
+        return self.cold_prob / self.ttek
+
+    def get_cold_delay_prob(self):
+
+        return self.cold_delay_prob / self.ttek
+
     def refresh_ppnz_stat(self, new_a):
+
         for i in range(3):
             self.ppnz[i] = self.ppnz[i] * (1.0 - (1.0 / self.ppnz_moments)) + math.pow(new_a, i + 1) / self.ppnz_moments
 
     def refresh_v_stat(self, new_a):
+
         for i in range(3):
             self.v[i] = self.v[i] * (1.0 - (1.0 / self.served)) + math.pow(new_a, i + 1) / self.served
 
     def refresh_w_stat(self, new_a):
+
         for i in range(3):
             self.w[i] = self.w[i] * (1.0 - (1.0 / self.taked)) + math.pow(new_a, i + 1) / self.taked
 
@@ -754,7 +810,7 @@ class Task:
         """
         self.arr_time = arr_time
 
-        self.start_waiting_time = -1
+        self.start_waiting_time = 0
 
         self.wait_time = 0
 
@@ -773,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:
@@ -809,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.25 → 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.25 → 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.25 → most_queue-1.27}/most_queue/theory/mmn_with_h2_cold_and_h2_warmup.py

@@ -593,9 +593,9 @@ if __name__ == "__main__":
     b1_cold = n * 0.0001 / l  # ср время охлаждения
     num_of_jobs = 1000000  # число обсл заявок ИМ
     b_coev_warm = 1.2  # коэфф вариации времени разогрева
-    b_coev_cold = 1.3  # коэфф вариации времени охлаждения
+    b_coev_cold = 1.2  # коэфф вариации времени охлаждения
     buff = None
-    verbose = True
+    verbose = False
 
     b_w = [0.0] * 3
     b_w[0] = b1_warm
@@ -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()
@@ -640,6 +640,10 @@ if __name__ == "__main__":
     tt_time = time.process_time() - tt_start
     num_of_iter = tt.num_of_iter_
 
+    print('warms starts', smo.warm_starts_times)
+    print('warms after cold starts', smo.warm_after_cold_starts)
+    print('cold starts', smo.cold_starts_times)
+
     print("\nСравнение результатов расчета методом Такахаси-Таками и ИМ.\n"
           "ИМ - M/Gamma/{0:^2d} с Gamma разогревом\nТакахаси-Таками - M/M/{0:^2d} c H2-разогревом и H2-охлаждением "
           "с комплексными параметрами\n"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: most-queue
-Version: 1.25
+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.25 → most_queue-1.27}/pyproject.toml

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

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

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