most-queue 1.55__tar.gz → 1.56__tar.gz

{most_queue-1.55 → most_queue-1.56}/.gitignore

@@ -161,3 +161,5 @@ cython_debug/
 #.idea/
 
 .vscode
+
+/works/results/

{most_queue-1.55 → most_queue-1.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most_queue
-Version: 1.55
+Version: 1.56
 Summary: Software package for calculation and simulation of queuing systems
 Project-URL: Homepage, https://github.com/xabarov/most-queue
 Author-email: Xabarov Roman <xabarov1985@gmail.com>

{most_queue-1.55 → most_queue-1.56}/most_queue/general/conditional.py

@@ -1,3 +1,6 @@
+"""
+Conditional moments of random variables.
+"""
 import math
 
 import numpy as np
@@ -5,7 +8,7 @@ import numpy as np
 from most_queue.general.distribution_params import H2Params
 
 
-def moments_H2_less_than_exp(gamma:float, h2_params:H2Params):
+def moments_h2_less_than_exp(gamma: float, h2_params: H2Params):
     """
     Compute the initial moments mean of Y given Y < X,
     where Y is a hyperexponential random variable with parameters p1, mu1, and mu2.
@@ -14,15 +17,16 @@ def moments_H2_less_than_exp(gamma:float, h2_params:H2Params):
     y = [h2_params.p1, 1-h2_params.p1]
     mu = [h2_params.mu1, h2_params.mu2]
     ps = [y[i]*mu[i] for i in range(2)]
-            
+
     coef = sum([y[i]*mu[i]/(mu[i]+gamma) for i in range(2)])
 
     b = [sum([math.factorial(k+1)*ps[i]/pow(mu[i]+gamma, k+2)
-                for i in range(2)])/coef for k in range(3)]
-    
+              for i in range(2)])/coef for k in range(3)]
+
     return np.array([mom.real for mom in b])
 
-def moments_exp_less_than_H2(gamma:float, h2_params:H2Params):
+
+def moments_exp_less_than_h2(gamma: float, h2_params: H2Params):
     """
     Compute the initial moments mean of X given X < Y,
     where X is exponentially distributed with rate gamma.
@@ -38,21 +42,11 @@ def moments_exp_less_than_H2(gamma:float, h2_params:H2Params):
     mu = [mu1, mu2]
     denominator = np.sum([y[i]/(mu[i]+gamma) for i in range(2)])
     b = []
-    
+
     # Step 2: Compute the Numerator
     for k in range(3):
-        numerator = math.factorial(k+1) * np.sum([y[i] / (mu[i]+gamma)**(k+2) for i in range(2)])
+        numerator = math.factorial(
+            k+1) * np.sum([y[i] / (mu[i]+gamma)**(k+2) for i in range(2)])
         b.append(numerator / denominator)
-    
-    return np.array([mom.real for mom in b])
-
-if __name__ == "__main__":
-        
-    # Example usage:
-    gamma = 1.0
-    p1 = 0.5
-    mu1 = 2.0
-    mu2 = 3.0
 
-    result = moments_exp_less_than_H2(gamma, H2Params(p1=p1, mu1=mu1, mu2=mu2))
-    print(f"The mean of Y given X < Y is: {result}")
+    return np.array([mom.real for mom in b])

most_queue-1.56/most_queue/general/plots.py

@@ -0,0 +1,65 @@
+from enum import Enum
+
+import matplotlib.pyplot as plt
+
+class DependsType(Enum):
+    """
+    Enum to specify the type of dependency for plotting.
+    """
+    NONE = 0
+    UTILIZATION_FACTOR = 1
+    CHANNELS_NUMBER = 2
+    COEFFICIENT_OF_VARIATION = 3
+
+
+def plot_sim_vs_calc_moments(xs: list[float], sim_results: list[float],
+                             calc_results: list[float],
+                             depends_on: DependsType = DependsType.CHANNELS_NUMBER,
+                             is_errors=False, is_waiting_time=True, save_path=None):
+    """
+    Plots the simulation and calculated moments for a given list of x values.
+    :param xs: A list of x values (e.g., utilization factors or number of channels).
+    :type xs: list[float]
+    :param sim_results: A list of simulated results.
+    :type sim_results: list[float]
+    :param calc_results: A list of calculated results using some analytical or numerical method.
+    :param depends_on: The type of dependency for plotting (utilization factor, number of channels, etc.).
+    :type depends_on: DependsType
+    :param is_errors: If True, plots the percentage error between simulation and calculation results.
+    :type is_errors: bool
+    :param is_waiting_time: If True, labels the y-axis as waiting time; otherwise, as soujourn time.
+    :type is_waiting_time: bool
+    :param save_path: The path where the plot should be saved. If None, the plot will not be saved.
+    :type save_path: str or NoneType
+    :return: None
+    """
+    _fig, ax = plt.subplots()
+    if is_errors:
+        errors = [100 * (w_sim - w_tt) / w_tt for w_sim,
+                  w_tt in zip(sim_results, calc_results)]
+
+        ax.plot(xs, errors)
+        ax.set_ylabel(r"$\varepsilon$, %")
+    else:
+        ax.plot(xs, sim_results, label="Sim")
+        ax.plot(xs, calc_results, label="Calc")
+        if is_waiting_time:
+            ax.set_ylabel(r"$\omega_{1}$")
+        else:
+            ax.set_ylabel(r"$\upsilon_{1}$")
+        plt.legend()
+
+    if depends_on == DependsType.UTILIZATION_FACTOR:
+        ax.set_xlabel(r"$\rho$")
+    elif depends_on == DependsType.COEFFICIENT_OF_VARIATION:
+        ax.set_xlabel(r"$\nu$")
+    else:
+        ax.set_xlabel("n")
+        plt.xticks(range(1, len(xs) + 1))
+
+    if save_path is not None:
+        plt.savefig(save_path, dpi=300)
+    else:
+        plt.show()
+
+    plt.close(_fig)

{most_queue-1.55 → most_queue-1.56}/most_queue/general/tables.py

@@ -25,8 +25,8 @@ def times_print(sim_moments, calc_moments, is_w=True, header=None):
             spec = 'soujorn'
         header = f'Initial moments of {spec} time in the system'
 
-    print(Fore.CYAN + f'\r{header}')
-
+    print(Fore.CYAN + f'\n{header:^45}')
+    print("-" * 45)
     print("{0:^15s}|{1:^15s}|{2:^15s}".format("#", "Num", "Sim"))
     print("-" * 45)
     if isinstance(sim_moments, list):

{most_queue-1.55 → most_queue-1.56}/most_queue/general/vacations_paper_utils.py

@@ -1,11 +1,8 @@
 import json
 import math
 
-import matplotlib
 import matplotlib.pyplot as plt
 
-matplotlib.use('TkAgg')
-
 
 def print_table(experiments_stat):
     """
@@ -84,7 +81,7 @@ def calc_moments_by_mean_and_coev(mean, coev):
 
 
 def make_plot(experiments_stat, w_moments_num=0,
-              param_name="ro", mode='error'):
+              param_name="ro", mode='error', save_path=None):
     """
     Build plot for wait times initial moments
     :param experiments_stat: list of experiment statistics
@@ -93,7 +90,7 @@ def make_plot(experiments_stat, w_moments_num=0,
     :param mode: 'error' or 'mass' - whether to plot errors or mass values
     :return: figure and axis objects
     """
-    fig, ax = plt.subplots()
+    _fig, ax = plt.subplots()
     w_sim_mass = []
     w_tt_mass = []
     xs = []
@@ -132,4 +129,7 @@ def make_plot(experiments_stat, w_moments_num=0,
     elif param_name == "delay_mean":
         ax.set_xlabel("t, с")
 
-    plt.show()
+    if save_path:
+        plt.savefig(save_path, dpi=300)
+    else:
+        plt.show()

{most_queue-1.55 → most_queue-1.56}/most_queue/misc/calc_v_pls.py

@@ -58,7 +58,7 @@ class MGnNegativeRCSCalc(MGnCalc):
             for i in range(3):
                 w[i] = derivative(self._calc_w_pls, 0,
                                   dx=1e-3 / self.b[0], n=i + 1, order=9)
-            return np.array([-w[0].real, w[1].real, -w[2].real])
+            return np.array([-w[0], w[1].real, -w[2]])
 
         for j in range(1, len(self.p) - self.n):
             w[0] += j * self.p[self.n + j]

{most_queue-1.55 → most_queue-1.56}/most_queue/misc/compare_fj_calc.py

@@ -1,29 +1,35 @@
-import matplotlib
+"""
+Test approximation for Fork-Join queues
+"""
 import matplotlib.pyplot as plt
 
 from most_queue.sim.queueing_systems.fork_join import ForkJoinSim
-from most_queue.theory.fork_join.m_m_n import (
-    get_v1_fj_nelson_tantawi,
-    get_v1_fj_varki_merchant,
-    get_v1_fj_varma,
-)
+from most_queue.theory.queueing_systems.fork_join.m_m_n import \
+    ForkJoinMarkovianCalc
 
-matplotlib.use('TkAgg')
+
+def calc_error(calc:float, sim:float)->float:
+    """
+    Вычисление относительной ошибки аппроксимации
+    :param calc: объект класса ForkJoinMarkovianCalc
+    :param sim: объект класса ForkJoinSim
+    :return:
+    """
+    return 100*(calc-sim)/calc
 
 
 def test_fj_calc():
     """
     Тестирование аппроксимаций для системы Fork-Join
-    В пакете theory.fj_calc модержатся следующие методы:
+        - R. D. Nelson and A. N. Tantawi, “Approximate analysis of fork/join
+            synchronization in parallel queues.” IEEE Trans. Computers, vol. 37, 
+            no. 6, pp. 739–743, 1988.
 
-        get_v1_fj_nelson_tantawi -  R. D. Nelson and A. N. Tantawi, “Approximate analysis of fork/join
-                                    synchronization in parallel queues.” IEEE Trans. Computers, vol. 37, no. 6, pp. 739–743, 1988.
+        - S. Varma and A. M. Makowski, “Interpolation approximations for
+            symmetric fork-join queues.” Perform. Eval., vol. 20, no. 1, pp. 245–265, 1994.
 
-        get_v1_fj_varma  -  S. Varma and A. M. Makowski, “Interpolation approximations for
-                            symmetric fork-join queues.” Perform. Eval., vol. 20, no. 1, pp. 245–265, 1994.
-
-        get_v1_fj_varki_merchant  -  E. Varki, “Response time analysis of parallel computer and storage
-                                     systems.” IEEE Trans. Parallel Distrib. Syst., 2001.
+        - E. Varki, “Response time analysis of parallel computer and storage
+            systems.” IEEE Trans. Parallel Distrib. Syst., 2001.
 
     Для верификации используем имитационное моделирование (ИМ).
 
@@ -56,10 +62,12 @@ def test_fj_calc():
 
         qs = ForkJoinSim(nn, nn, False)
 
-        # задаем входной поток. Методу нужно передать параметры распределения и тип распределения. М - экспоненциальное
+        # задаем входной поток. Методу нужно передать параметры распределения и тип распределения.
+        #  М - экспоненциальное
         qs.set_sources(l, 'M')
 
-        # задаем каналы обслуживания. Методу нужно передать параметры распределения и тип распределения. М - экспоненциальное
+        # задаем каналы обслуживания. Методу нужно передать параметры распределения и тип распределения.
+        #  М - экспоненциальное
         qs.set_servers(mu, 'M')
 
         # запускаем ИМ
@@ -73,15 +81,17 @@ def test_fj_calc():
         # расчет средних времен пребывания с помощью аппроксимаций. \
         # На вход каждого из методов - 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))
+        calcs = ForkJoinMarkovianCalc(l, mu, nn)
+
+        v_varki.append(calcs.get_v1_fj_varki_merchant())
+        v_varma.append(calcs.get_v1_fj_varma())
+        v_nelson.append(calcs.get_v1_fj_nelson_tantawi())
 
         print(str_f_v.format(v_sim[i], v_varki[i], v_varma[i], v_nelson[i]))
 
     # строим графики и сохраняем в текущую директорию:
 
-    fig, ax = plt.subplots()
+    _fig, ax = plt.subplots()
 
     linestyles = ["solid", "dotted", "dashed", "dashdot"]
 
@@ -94,19 +104,14 @@ def test_fj_calc():
     ax.set_xlabel("n")
 
     plt.legend()
-    plt.savefig("v1_from_n_with_ro = {0:^4.2f}.png".format(ro), dpi=300)
+    plt.savefig(f"v1_from_n_with_ro = {ro:^4.2f}.png", dpi=300)
 
     # errors
-    v_nelson_err = []
-    v_varma_err = []
-    v_varki_err = []
-
-    for i in range(len(v_sim)):
-        v_varma_err.append(100 * (v_varma[i] - v_sim[i]) / v_sim[i])
-        v_varki_err.append(100 * (v_varki[i] - v_sim[i]) / v_sim[i])
-        v_nelson_err.append(100 * (v_nelson[i] - v_sim[i]) / v_sim[i])
+    v_varma_err = [calc_error(v, s) for v, s in zip(v_varma, v_sim)]
+    v_varki_err = [calc_error(v, s) for v, s in zip(v_varki, v_sim)] 
+    v_nelson_err = [calc_error(v, s) for v, s in zip(v_nelson, v_sim)]
 
-    fig, ax = plt.subplots()
+    _fig, ax = plt.subplots()
     ax.plot(n, v_varki_err, label="Varki", linestyle=linestyles[0])
     ax.plot(n, v_varma_err, label="Varma", linestyle=linestyles[1])
     ax.plot(n, v_nelson_err, label="Nelson", linestyle=linestyles[2])
@@ -115,7 +120,7 @@ def test_fj_calc():
     ax.set_xlabel("n")
 
     plt.legend()
-    plt.savefig("error_from_n_with_ro = {0:^4.2f}.png".format(ro), dpi=300)
+    plt.savefig(f"error_from_n_with_ro = {ro:^4.2f}.png", dpi=300)
 
 
 if __name__ == "__main__":