most-queue 1.39__tar.gz → 1.40__tar.gz

{most_queue-1.39 → most_queue-1.40}/PKG-INFO

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

{most_queue-1.39/most_queue/examples → most_queue-1.40/most_queue}/compare_fj_calc.py

@@ -1,4 +1,4 @@
-from theory import fj_calc
+from theory.fj_calc import get_v1_fj_varki_merchant, get_v1_fj_nelson_tantawi, get_v1_fj_varma
 from sim.fj_sim import ForkJoinSim
 import matplotlib.pyplot as plt
 
@@ -68,9 +68,9 @@ def test_fj_calc():
         # расчет средних времен пребывания с помощью аппроксимаций. \
         # На вход каждого из методов - l, mu, nn (число каналов СМО)
 
-        v_varki.append(fj_calc.get_v1_fj_varki_merchant(l, mu, nn))
-        v_varma.append(fj_calc.get_v1_fj_varma(l, mu, nn))
-        v_nelson.append(fj_calc.get_v1_fj_nelson_tantawi(l, mu, nn))
+        v_varki.append(get_v1_fj_varki_merchant(l, mu, nn))
+        v_varma.append(get_v1_fj_varma(l, mu, nn))
+        v_nelson.append(get_v1_fj_nelson_tantawi(l, mu, nn))
 
         print(str_f_v.format(v_sim[i], v_varki[i], v_varma[i], v_nelson[i]))
 
@@ -113,3 +113,6 @@ def test_fj_calc():
     plt.savefig("error_from_n_with_ro = {0:^4.2f}.png".format(ro), dpi=300)
 
 
+if __name__ == "__main__":
+    
+    test_fj_calc()

{most_queue-1.39/most_queue/examples → most_queue-1.40/most_queue}/flow_sum.py

@@ -1,8 +1,8 @@
 import matplotlib
 import matplotlib.pyplot as plt
-from sim import rand_destribution as rd
+from . import rand_distribution as rd
 from sim.flow_sum_sim import FlowSumSim
-from theory.flow_sum import SummatorNumeric
+from most_queue.theory.flow_sum import SummatorNumeric
 
 matplotlib.use('TkAgg')
 

{most_queue-1.39/most_queue/utils → most_queue-1.40/most_queue/general_utils}/approx_cdf_make.py

@@ -1,4 +1,4 @@
-import sim.rand_destribution as rd
+from most_queue.rand_distribution import H2_dist, Gamma
 import math
 from tqdm import tqdm
 import numpy as np
@@ -28,10 +28,10 @@ b[2] = a_s*pow(sigma, 3) + 3*b[1]*b[0] - 2*pow(b[0], 2)
 
 
 # Гамма-аппроксимация
-gamma_params = rd.Gamma.get_mu_alpha(b)
+gamma_params = Gamma.get_mu_alpha(b)
 
 # H2-аппроксимация
-h2_params = rd.H2_dist.get_params(b)
+h2_params = H2_dist.get_params(b)
 
 n = 100000
 
@@ -39,8 +39,8 @@ b_approx_gamma = [0, 0, 0]
 b_approx_h2 = [0, 0, 0]
 
 for i in tqdm(range(n)):
-    val_gamma = rd.Gamma.generate_static(gamma_params[0], gamma_params[1])
-    val_h2 = rd.H2_dist.generate_static(*h2_params)
+    val_gamma = Gamma.generate_static(gamma_params[0], gamma_params[1])
+    val_h2 = H2_dist.generate_static(*h2_params)
     for k in range(3):
         b_approx_gamma[k] += pow(val_gamma, k+1)
         b_approx_h2[k] += pow(val_h2, k + 1)
@@ -63,8 +63,8 @@ y_gamma = []
 y_h2 = []
 
 for i in range(dots_num):
-    y_gamma.append(rd.Gamma.get_pdf(gamma_params[0], gamma_params[1], x[i]))
-    y_h2.append(rd.H2_dist.get_pdf(h2_params, x[i]))
+    y_gamma.append(Gamma.get_pdf(gamma_params[0], gamma_params[1], x[i]))
+    y_h2.append(H2_dist.get_pdf(h2_params, x[i]))
 
 fig, ax = plt.subplots()
 linestyles = ["solid", "dotted", "dashed", "dashdot"]

most_queue-1.39/most_queue/theory/convolution_sum_calc.py → most_queue-1.40/most_queue/general_utils/conv.py

@@ -1,23 +1,24 @@
-def get_moments(a, b, num=3):
-    num = min(num, 3)
-    res = [0] * num
-    res[0] = a[0] + b[0]
-    res[1] = a[1] + b[1] + 2 * a[0] * b[0]
-    res[2] = a[2] + b[2] + 3 * a[1] * b[0] + 3 * a[0] * b[1]
-    return res
-
-
-def get_self_concolution(b, n_times, num=3):
-    num = min(num, 3)
-    res = [0] * num
-    for i in range(n_times):
-        res = get_moments(res, b, num)
-    return res
-
-def get_moments_minus(a, b, num=3):
-    num = min(num, 3)
-    res = [0] * num
-    res[0] = a[0] - b[0]
-    res[1] = a[1] - b[1] - 2 * a[0] * b[0]
-    res[2] = a[2] - b[2] - 3 * a[1] * b[0] - 3 * a[0] * b[1]
-    return res
+def get_moments(a, b, num=3):
+    num = min(num, 3)
+    res = [0] * num
+    res[0] = a[0] + b[0]
+    res[1] = a[1] + b[1] + 2 * a[0] * b[0]
+    res[2] = a[2] + b[2] + 3 * a[1] * b[0] + 3 * a[0] * b[1]
+    return res
+
+
+def get_self_conv_moments(b, n_times, num=3):
+    num = min(num, 3)
+    res = [0] * num
+    for i in range(n_times):
+        res = get_moments(res, b, num)
+    return res
+
+
+def get_moments_minus(a, b, num=3):
+    num = min(num, 3)
+    res = [0] * num
+    res[0] = a[0] - b[0]
+    res[1] = a[1] - b[1] - 2 * a[0] * b[0]
+    res[2] = a[2] - b[2] - 3 * a[1] * b[0] - 3 * a[0] * b[1]
+    return res

{most_queue-1.39/most_queue/utils → most_queue-1.40/most_queue/general_utils}/tables.py

@@ -17,8 +17,10 @@ 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]
         print(
-            Fore.CYAN + f"{j + 1:^15d}|" + Fore.YELLOW  + f"{calc_moments[j]:^15.5g}" + Fore.CYAN + "|" + Fore.YELLOW + f"{sim_moments[j]:^15.5g}")
+            Fore.CYAN + f"{j + 1:^15d}|" + Fore.YELLOW  + f"{calc_mom:^15.5g}" + Fore.CYAN + "|" + Fore.YELLOW + f"{sim_mom:^15.5g}")
 
     print(Style.RESET_ALL)
 

{most_queue-1.39/most_queue/utils → most_queue-1.40/most_queue/general_utils}/vacations_paper_utils.py

@@ -37,7 +37,9 @@ def print_table(experiments_stat):
         print("{0:^3s}|{1:^15s}|{2:^15s}".format("№", "Numerical", "Sim"))
         print("-" * 32)
         for i in range(3):
-            print("{0:^4d}|{1:^15.3g}|{2:^15.3g}".format(i + 1, stat["w_tt"][i], stat["w_sim"][i]))
+            calc_mom = stat["w_tt"][i].real if isinstance(stat["w_tt"][i], complex) else stat["w_tt"][i]
+            sim_mom =  stat["w_sim"][i].real if isinstance(stat["w_sim"][i], complex) else stat["w_sim"][i]
+            print(f"{i+1:^4d}|{calc_mom:^15.3g}|{sim_mom:^15.3g}")
 
 
 def dump_stat(experiments_stat, save_name='run_stat.json'):

most_queue-1.39/most_queue/sim/rand_destribution.py → most_queue-1.40/most_queue/rand_distribution.py

@@ -1,5 +1,6 @@
 import cmath
 import math
+
 import numpy as np
 import scipy.special as sp
 from scipy import stats
@@ -966,8 +967,8 @@ class Gamma:
 
 if __name__ == "__main__":
 
-    import matplotlib.pyplot as plt
     import matplotlib
+    import matplotlib.pyplot as plt
 
     matplotlib.use('TkAgg')
 

{most_queue-1.39 → most_queue-1.40}/most_queue/sim/batch_sim.py

@@ -3,7 +3,7 @@ QS with batch arrival
 """
 import numpy as np
 
-from .qs_sim import QueueingSystemSimulator, Task
+from most_queue.sim.qs_sim import QueueingSystemSimulator, Task
 
 
 class QueueingSystemBatchSim(QueueingSystemSimulator):

{most_queue-1.39 → most_queue-1.40}/most_queue/sim/fj_delta_sim.py

@@ -1,63 +1,10 @@
 """
 ForkJoin Queue with delta
 """
-from .rand_destribution import Cox_dist, Pareto_dist, Gamma, H2_dist, Exp_dist
-from .fj_sim import ForkJoinSim
-from .fj_sim import SubTask as SubTask
-from .fj_sim import Task as Task
-from .qs_sim import Server
-from .utils.sim_utils import get_conv_moments, get_self_concolution_moments
-
-
-class ServerWarmUp(Server):
-    """
-    Канал обслуживания
-    """
-    id = 0
-
-    def __init__(self, params, types, delta=None):
-        """
-        params - параметры распределения
-        types -  тип распределения
-        """
-        Server.__init__(self, params, types)
-        self.delta = delta
-
-    def start_service(self, ts, ttek, isWarmUp=False):
-
-        Server.start_service(self, ts, ttek)
-        if isWarmUp:
-            if not isinstance(self.delta, dict):
-                self.time_to_end_service = ttek + self.dist.generate() + self.delta
-            else:
-                b = [0, 0, 0]
-                if self.dist.type == 'M':
-                    b = Exp_dist.calc_theory_moments(self.dist.params)
-                elif self.dist.type == 'H':
-                    b = H2_dist.calc_theory_moments(*self.dist.params)
-                elif self.dist.type == 'C':
-                    b = Cox_dist.calc_theory_moments(*self.dist.params)
-                elif self.dist.type == 'Pa':
-                    b = Pareto_dist.calc_theory_moments(*self.dist.params)
-                elif self.dist.type == 'Gamma':
-                    b = Gamma.calc_theory_moments(*self.dist.params)
-
-                f_summ = get_conv_moments(b, self.delta)
-                # variance = f_summ[1] - math.pow(f_summ[0], 2)
-                # coev = math.sqrt(variance)/f_summ[0]
-                params = Gamma.get_mu_alpha(f_summ)
-                self.time_to_end_service = ttek + \
-                    Gamma.generate_static(*params)
-
-
-class SubTaskDelta(SubTask):
-    """
-    Позадача
-    """
-
-    def __init__(self, arr_time, task_id):
-        SubTask.__init__(self, arr_time, task_id)
-        self.future_arr_time = 0
+from most_queue.general_utils.conv import get_self_conv_moments
+from most_queue.rand_distribution import Gamma
+from most_queue.sim.fj_sim import ForkJoinSim
+from most_queue.sim.utils.tasks import ForkJoinTask
 
 
 class ForkJoinSimDelta(ForkJoinSim):
@@ -100,8 +47,8 @@ class ForkJoinSimDelta(ForkJoinSim):
                     is_dropped = True
 
         if not is_dropped:
-            self.served_subtask_in_task[Task.task_id] = 0
-            t = Task(self.k, self.ttek)
+            self.served_subtask_in_task[ForkJoinTask.task_id] = 0
+            t = ForkJoinTask(self.k, self.ttek)
             self.first_subtask_arr_time[t.id] = self.ttek
 
             self.in_sys += 1
@@ -131,7 +78,7 @@ class ForkJoinSimDelta(ForkJoinSim):
                 if not isinstance(self.delta, list):
                     t.subtasks[i].future_arr_time = self.ttek + i * self.delta
                 else:
-                    b_delta = get_self_concolution_moments(self.delta, i)
+                    b_delta = get_self_conv_moments(self.delta, i)
                     params_delta = Gamma.get_mu_alpha(b_delta)
                     t.subtasks[i].future_arr_time = self.ttek + \
                         Gamma.generate_static(*params_delta)

{most_queue-1.39 → most_queue-1.40}/most_queue/sim/fj_sim.py

@@ -7,51 +7,12 @@ import sys
 from colorama import Fore, Style, init
 from tqdm import tqdm
 
-from .qs_sim import QueueingSystemSimulator
+from most_queue.sim.qs_sim import QueueingSystemSimulator
+from most_queue.sim.utils.tasks import ForkJoinTask
 
 init()
 
 
-class SubTask:
-    """
-    Позадача
-    """
-    sub_task_id = 0
-
-    def __init__(self, arr_time, task_id):
-        self.arr_time = arr_time
-        self.task_id = task_id
-        self.id = SubTask.sub_task_id
-        SubTask.sub_task_id += 1
-
-    def __str__(self):
-        res = "\tSubTask #" + str(self.id) + \
-            " parent Task #" + str(self.task_id) + "\n"
-        res += "\t\tArrival time: " + str(self.arr_time) + "\n"
-        return res
-
-
-class Task:
-    """
-    Задача, состоящая из subtask_num подзадач
-    """
-    task_id = 0
-
-    def __init__(self, subtask_num, arr_time):
-        self.subtask_num = subtask_num
-        self.arr_time = arr_time
-        self.subtasks = []
-        for i in range(subtask_num):
-            self.subtasks.append(SubTask(arr_time, Task.task_id))
-        self.id = Task.task_id
-        Task.task_id += 1
-
-    def __str__(self):
-        res = "\tTask #" + str(self.id) + "\n"
-        res += "\t\tArrival time: " + str(self.arr_time) + "\n"
-        return res
-
-
 class ForkJoinSim(QueueingSystemSimulator):
     """
     Имитационная модель СМО Fork-Join, Split-Join
@@ -105,8 +66,8 @@ class ForkJoinSim(QueueingSystemSimulator):
                     is_dropped = True
 
         if not is_dropped:
-            self.served_subtask_in_task[Task.task_id] = 0
-            t = Task(self.n, self.ttek)
+            self.served_subtask_in_task[ForkJoinTask.task_id] = 0
+            t = ForkJoinTask(self.n, self.ttek)
             self.in_sys += 1
             self.sub_task_in_sys += self.n
 
@@ -277,9 +238,3 @@ class ForkJoinSim(QueueingSystemSimulator):
             res += "\nQueue Count " + str(self.queue.size()) + "\n"
 
         return res
-
-
-class QueueingSystemException(Exception):
-
-    def __str__(self, text):
-        return text

{most_queue-1.39 → most_queue-1.40}/most_queue/sim/flow_sum_sim.py

@@ -1,10 +1,18 @@
-import rand_destribution as rd
-from tqdm import tqdm
+"""
+Input flows sum simulation
+"""
 import copy
 import math
 
+from tqdm import tqdm
+
+from most_queue.rand_distribution import Erlang_dist, Gamma, H2_dist, Pareto_dist
+
 
 class FlowSumSim:
+    """
+    Input flows sum simulation
+    """
 
     def __init__(self, a, distr="Gamma", verbose=True, num_of_moments=4, num_of_jobs=1000000):
         self.n = len(a)
@@ -80,10 +88,10 @@ class FlowSumSim:
         a2 - список из начальных моментов интервалов между соседникми заявками второго потока
         """
 
-        y1_mus = rd.H2_dist.get_params(a1)
-        arr1 = rd.H2_dist(y1_mus)
-        y2_mus = rd.H2_dist.get_params(a2)
-        arr2 = rd.H2_dist(y2_mus)
+        y1_mus = H2_dist.get_params(a1)
+        arr1 = H2_dist(y1_mus)
+        y2_mus = H2_dist.get_params(a2)
+        arr2 = H2_dist(y2_mus)
         arrivals = []
         time1 = arr1.generate()
         time2 = arr2.generate()
@@ -126,10 +134,10 @@ class FlowSumSim:
         a2 - список из начальных моментов интервалов между соседникми заявками второго потока
         """
 
-        a_K = rd.Pareto_dist.get_a_k(a1)
-        arr1 = rd.Pareto_dist(a_K)
-        b_M = rd.Pareto_dist.get_a_k(a2)
-        arr2 = rd.Pareto_dist(b_M)
+        a_K = Pareto_dist.get_a_k(a1)
+        arr1 = Pareto_dist(a_K)
+        b_M = Pareto_dist.get_a_k(a2)
+        arr2 = Pareto_dist(b_M)
         arrivals = []
         time1 = arr1.generate()
         time2 = arr2.generate()
@@ -160,10 +168,10 @@ class FlowSumSim:
     @staticmethod
     def sum_2_Erlang_flows(a1, a2, num_of_moments=4, num_of_sim=1000000):
 
-        params1 = rd.Erlang_dist.get_params(a1)
-        arr1 = rd.Erlang_dist(params1)
-        params2 = rd.Erlang_dist.get_params(a2)
-        arr2 = rd.Erlang_dist(params2)
+        params1 = Erlang_dist.get_params(a1)
+        arr1 = Erlang_dist(params1)
+        params2 = Erlang_dist.get_params(a2)
+        arr2 = Erlang_dist(params2)
         arrivals = []
         time1 = arr1.generate()
         time2 = arr2.generate()
@@ -200,10 +208,10 @@ class FlowSumSim:
         a2 - список из начальных моментов интервалов между соседникми заявками второго потока
         """
 
-        params1 = rd.Gamma.get_mu_alpha(a1)
-        arr1 = rd.Gamma(params1)
-        params2 = rd.Gamma.get_mu_alpha(a2)
-        arr2 = rd.Gamma(params2)
+        params1 = Gamma.get_mu_alpha(a1)
+        arr1 = Gamma(params1)
+        params2 = Gamma.get_mu_alpha(a2)
+        arr2 = Gamma(params2)
         arrivals = []
         time1 = arr1.generate()
         time2 = arr2.generate()

{most_queue-1.39 → most_queue-1.40}/most_queue/sim/impatient_queue_sim.py

@@ -1,6 +1,5 @@
-from .distribution_utils import create_distribution
-from .qs_sim import QueueingSystemSimulator, Task
-from .utils.exceptions import QsSourseSettingException
+from most_queue.sim.utils.distribution_utils import create_distribution
+from most_queue.sim.qs_sim import QueueingSystemSimulator, Task
 
 
 class ImpatientTask(Task):
@@ -20,6 +19,7 @@ class ImpatientQueueSim(QueueingSystemSimulator):
         self.impatience_types = None
         
         self.impatience = None
+        self.is_set_impatience_params = False
 
     def set_impatiens(self, params, types):
         """

{most_queue-1.39 → most_queue-1.40}/most_queue/sim/priority_network.py

@@ -1,16 +1,13 @@
-import numpy as np
 import math
-import time
 import sys
+import time
 
+import numpy as np
+from colorama import Fore, Style, init
 from tqdm import tqdm
 
-from .priority_queue_sim import PriorityQueueSimulator
-from .rand_destribution import Exp_dist
-from .priority_queue_sim import Task
-
-from colorama import init
-from colorama import Fore, Style
+from most_queue.sim.priority_queue_sim import PriorityQueueSimulator, Task
+from most_queue.rand_distribution import Exp_dist
 
 init()
 
@@ -143,11 +140,13 @@ class PriorityNetwork:
                 self.smos[next_node].arrival(next_node_class, self.ttek, ts)
 
     def run(self, job_served, is_real_served=False):
+        """
+        Run simulation
+        """
         if is_real_served:
             while sum(self.served) < job_served:
                 self.run_one_step()
-                sys.stderr.write('\rStart simulation. Job served: %d/%d' %
-                                 (sum(self.served), job_served))
+                sys.stderr.write(f'\rStart simulation. Job served: {sum(self.served)}/{job_served}')
                 sys.stderr.flush()
         else:
             print(Fore.GREEN + '\rStart simulation')

{most_queue-1.39 → most_queue-1.40}/most_queue/sim/priority_queue_sim.py

@@ -1,11 +1,12 @@
 import math
 import sys
 import time
+
 import numpy as np
 from colorama import Fore, Style, init
 from tqdm import tqdm
 
-from .distribution_utils import create_distribution
+from most_queue.sim.utils.distribution_utils import create_distribution
 
 init()
 

{most_queue-1.39 → most_queue-1.40}/most_queue/sim/qs_sim.py

@@ -9,10 +9,12 @@ import numpy as np
 from colorama import Fore, Style, init
 from tqdm import tqdm
 
-from .distribution_utils import calc_qs_load, create_distribution
-from .utils.exceptions import QsSourseSettingException, QsWrongQueueTypeException
-from .utils.phase import QsPhase
-from .utils.qs_queue import QsQueueList, QsQueueDeque
+from most_queue.sim.utils.distribution_utils import calc_qs_load, create_distribution
+from most_queue.sim.utils.exceptions import QsSourseSettingException, QsWrongQueueTypeException
+from most_queue.sim.utils.phase import QsPhase
+from most_queue.sim.utils.qs_queue import QsQueueDeque, QsQueueList
+from most_queue.sim.utils.servers import Server
+from most_queue.sim.utils.tasks import Task
 
 init()
 
@@ -625,92 +627,3 @@ class QueueingSystemSimulator:
             res += f"\nQueue Count {self.queue.size()}\n"
 
         return res
-
-
-class Task:
-    """
-    Заявка
-    """
-    id = 0
-
-    def __init__(self, arr_time):
-        """
-        :param arr_time: Момент прибытия в СМО
-        """
-        self.arr_time = arr_time
-
-        self.start_waiting_time = 0
-
-        self.wait_time = 0
-
-        Task.id += 1
-        self.id = Task.id
-
-    def __str__(self):
-        res = f"Task #{self.id}\n"
-        res += f"\tArrival moment: {self.arr_time:8.3f}"
-        return res
-
-
-class Server:
-    """
-    Канал обслуживания
-    """
-    id = 0
-
-    def __init__(self, params, types, generator=None):
-        """
-        params - параметры распределения
-        types -  тип распределения
-        """
-        self.dist = create_distribution(params, types, generator)
-        self.time_to_end_service = 1e10
-        self.is_free = True
-        self.tsk_on_service = None
-        Server.id += 1
-        self.id = Server.id
-
-        self.params_warm = None
-        self.types_warm = None
-        self.warm_phase = QsPhase("WarmUp", None)
-
-    def set_warm(self, params, types, generator=None):
-        """
-        Set local warmup period distrubution on server
-        """
-
-        self.warm_phase.set_dist(create_distribution(params, types, generator))
-
-    def start_service(self, ts: Task, ttek, is_warm=False):
-        """
-        Starts serving
-        ttek - current time 
-        is_warm - if warmUp needed
-        """
-
-        self.tsk_on_service = ts
-        self.is_free = False
-        if not is_warm:
-            self.time_to_end_service = ttek + self.dist.generate()
-        else:
-            self.time_to_end_service = ttek + self.warm_phase.dist.generate()
-
-    def end_service(self):
-        """
-        End service
-        """
-        self.time_to_end_service = 1e10
-        self.is_free = True
-        ts = self.tsk_on_service
-        self.tsk_on_service = None
-        return ts
-
-    def __str__(self):
-        res = f"\nServer # {self.id}\n"
-        if self.is_free:
-            res += "\tFree"
-        else:
-            res += "\tServing.. Time to end " + \
-                f"{self.time_to_end_service:8.3f}\n"
-            res += f"\tTask on service:\n\t{self.tsk_on_service}"
-        return res