most-queue 1.63__py3-none-any.whl → 2.1__py3-none-any.whl

most_queue/general/distribution_fitting.py

@@ -8,10 +8,14 @@ from dataclasses import dataclass
 
 import numpy as np
 
-from most_queue.general.distribution_params import (Cox2Params, ErlangParams,
-                                                    GammaParams, H2Params,
-                                                    ParetoParams,
-                                                    WeibullParams)
+from most_queue.general.distribution_params import (
+    Cox2Params,
+    ErlangParams,
+    GammaParams,
+    H2Params,
+    ParetoParams,
+    WeibullParams,
+)
 
 
 @dataclass
@@ -117,8 +121,7 @@ def fit_h2_clx(moments: list[float], fitting_params: FittingParams | None = None
         if math.fabs(coev.real - 1.0 / math.sqrt(2.0)) < fitting_params.ee:
             if fitting_params.verbose:
                 print(
-                    f"H2 is close to E2. Multiply moments to (1+je)"
-                    f"coev = {coev:5.3f}, e = {fitting_params.e:5.3f}."
+                    f"H2 is close to E2. Multiply moments to (1+je)" f"coev = {coev:5.3f}, e = {fitting_params.e:5.3f}."
                 )
             f = []
             for i, mom in enumerate(moments):
@@ -151,10 +154,7 @@ def fit_cox(moments: list[float], fitting_params: FittingParams | None = None) -
         coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
         if abs(moments[1] - moments[0] * moments[0]) < fitting_params.ee:
             if fitting_params.verbose:
-                print(
-                    f"Cox special 1. Multiply moments to (1+je)"
-                    f"coev = {coev:5.3f}  e = {fitting_params.e:5.3f}."
-                )
+                print(f"Cox special 1. Multiply moments to (1+je)" f"coev = {coev:5.3f}  e = {fitting_params.e:5.3f}.")
             f = []
             for i, mom in enumerate(moments):
                 f.append(mom * complex(1, (i + 1) * fitting_params.e))
@@ -176,9 +176,7 @@ def fit_cox(moments: list[float], fitting_params: FittingParams | None = None) -
     for i in range(3):
         f[i] = moments[i] / math.factorial(i + 1)
 
-    d = np.power(f[2] - f[0] * f[1], 2) - 4.0 * (f[1] - np.power(f[0], 2)) * (
-        f[0] * f[2] - np.power(f[1], 2)
-    )
+    d = np.power(f[2] - f[0] * f[1], 2) - 4.0 * (f[1] - np.power(f[0], 2)) * (f[0] * f[2] - np.power(f[1], 2))
     mu2 = f[0] * f[1] - f[2] + cmath.sqrt(d)
     mu2 /= 2.0 * (np.power(f[1], 2) - f[0] * f[2])
     mu1 = (mu2 * f[0] - 1.0) / (mu2 * f[1] - f[0])
@@ -287,9 +285,7 @@ def fit_gamma(moments: list[float]) -> GammaParams:
             else:
                 B.append(moments[i - 1])
             for j in range(len(moments) + 1):
-                A[i].append(
-                    calc_gamma_func(alpha + i + j) / (pow(mu, i + j) * calc_gamma_func(alpha))
-                )
+                A[i].append(calc_gamma_func(alpha + i + j) / (pow(mu, i + j) * calc_gamma_func(alpha)))
         g = np.linalg.solve(A, B)
         return GammaParams(mu=mu, alpha=alpha, g=g)
 
@@ -311,14 +307,10 @@ def fit_weibull(moments: list[float]) -> WeibullParams:
     a = moments[1] / (moments[0] * moments[0])
     u0 = math.log(2 * a) / (2.0 * math.log(2))
     ee = 1e-6
-    u1 = (1.0 / (2 * math.log(2))) * math.log(
-        a * math.sqrt(math.pi) * math.gamma(u0 + 1) / math.gamma(u0 + 0.5)
-    )
+    u1 = (1.0 / (2 * math.log(2))) * math.log(a * math.sqrt(math.pi) * math.gamma(u0 + 1) / math.gamma(u0 + 0.5))
     delta = u1 - u0
     while math.fabs(delta) > ee:
-        u1 = (1.0 / (2 * math.log(2))) * math.log(
-            a * math.sqrt(math.pi) * math.gamma(u0 + 1) / math.gamma(u0 + 0.5)
-        )
+        u1 = (1.0 / (2 * math.log(2))) * math.log(a * math.sqrt(math.pi) * math.gamma(u0 + 1) / math.gamma(u0 + 0.5))
         delta = u1 - u0
         u0 = u1
     k = 1 / u1

most_queue/general/plots.py

@@ -26,7 +26,7 @@ def plot_sim_vs_calc_moments(
     is_errors=False,
     is_waiting_time=True,
     save_path=None,
-):
+):  # pylint: disable=too-many-positional-arguments, too-many-arguments
     """
     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).

most_queue/general/tables.py

@@ -16,7 +16,7 @@ def times_print(
     header=None,
     sim_header="Sim",
     calc_header="Num",
-):
+):  # pylint: disable=too-many-positional-arguments, too-many-arguments
     """
     Prints the initial moments of waiting or sojourn time in the system.
      Args:
@@ -41,9 +41,7 @@ def times_print(
     print("-" * 45)
     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]
-            )
+            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
@@ -78,7 +76,7 @@ def times_print_with_two_numerical(
     is_w=True,
     num1_header="Num1",
     num2_header="Num2",
-):
+):  # pylint: disable=too-many-positional-arguments, too-many-arguments
     """
     Prints the initial moments of waiting or sojourn time in the system.
      Args:
@@ -103,12 +101,8 @@ def times_print_with_two_numerical(
     print("-" * 60)
     if isinstance(sim_moments, list):
         for j in range(min(len(sim_moments), len(calc_moments1), len(calc_moments2))):
-            calc_mom1 = (
-                calc_moments1[j].real if isinstance(calc_moments1[j], complex) else calc_moments1[j]
-            )
-            calc_mom2 = (
-                calc_moments2[j].real if isinstance(calc_moments2[j], complex) else calc_moments2[j]
-            )
+            calc_mom1 = calc_moments1[j].real if isinstance(calc_moments1[j], complex) else calc_moments1[j]
+            calc_mom2 = calc_moments2[j].real if isinstance(calc_moments2[j], complex) else calc_moments2[j]
             sim_mom = sim_moments[j].real if isinstance(sim_moments[j], complex) else sim_moments[j]
             print(
                 Fore.CYAN
@@ -167,11 +161,7 @@ def times_print_no_compare(wait_times=None, sojourn_times=None):
         if isinstance(wait_times, list):
             for j in range(min(len(wait_times), len(sojourn_times))):
                 w_mom = wait_times[j].real if isinstance(wait_times[j], complex) else wait_times[j]
-                v_mom = (
-                    sojourn_times[j].real
-                    if isinstance(sojourn_times[j], complex)
-                    else sojourn_times[j]
-                )
+                v_mom = sojourn_times[j].real if isinstance(sojourn_times[j], complex) else sojourn_times[j]
                 print(
                     Fore.CYAN
                     + f"{j + 1:^15d}|"
@@ -352,10 +342,6 @@ def print_mrx(mrx, is_short=False):
                 print(f"{color}{mrx[i, j].real:^4.2f} | ", end="")
             else:
                 print(f"{color}{mrx[i, j]:^5.3f} | ", end="")
-        print(
-            "\n" + "-------" * col
-            if is_short or mrx[i, j].imag == 0.0
-            else "\n" + "---------------" * col
-        )
+        print("\n" + "-------" * col if is_short or mrx[i, j].imag == 0.0 else "\n" + "---------------" * col)
 
     print(f"{Style.RESET_ALL}")

most_queue/misc/approx_cdf_make.py

@@ -55,11 +55,7 @@ if __name__ == "__main__":
     print("{0:^3s}|{1:^15s}|{2:^15s}|{3:^15s}".format("№", "Реал", "Gamma", "H2"))
     print("-" * 50)
     for i in range(3):
-        print(
-            "{0:^4d}|{1:^15.3g}|{2:^15.3g}|{3:^15.3g}".format(
-                i + 1, b[i], b_approx_gamma[i], b_approx_h2[i]
-            )
-        )
+        print("{0:^4d}|{1:^15.3g}|{2:^15.3g}|{3:^15.3g}".format(i + 1, b[i], b_approx_gamma[i], b_approx_h2[i]))
 
     dots_num = 10000
 

most_queue/misc/calc_v_pls.py

@@ -24,16 +24,11 @@ class MGnNegativeRCSCalc(MGnCalc):
     def __init__(
         self,
         n: int,
-        l_pos: float,
-        l_neg: float,
-        b: list[float],
         buffer: int | None = None,
         calc_params: TakahashiTakamiParams | None = None,
     ):
         """
         n: number of servers
-        l: arrival rate of positive jobs
-        l_neg: arrival rate of negative jobs
         b: initial moments of service time distribution
         buffer: size of the buffer (optional)
         N: number of levels in the system (default is 150)
@@ -42,9 +37,29 @@ class MGnNegativeRCSCalc(MGnCalc):
         verbose: whether to print intermediate results (default is False)
         """
 
+        super().__init__(n=n, buffer=buffer, calc_params=calc_params)
+
+        self.l_pos = None
+        self.l_neg = None
+        self.b = None
+
+    def set_sources(self, l_pos: float, l_neg: float):  # pylint: disable=arguments-differ
+        """
+        Set the arrival rates of positive and negative jobs
+        :param l_pos: arrival rate of positive jobs
+        :param l_neg: arrival rate of negative jobs
+        """
+        self.l_pos = l_pos
         self.l_neg = l_neg
+        self.is_sources_set = True
 
-        super().__init__(n=n, l=l_pos, b=b, buffer=buffer, calc_params=calc_params)
+    def set_servers(self, b: list[float]):  # pylint: disable=arguments-differ
+        """
+        Set the initial moments of service time distribution
+        :param b: initial moments of service time distribution
+        """
+        self.b = b
+        self.is_servers_set = True
 
     def get_q(self) -> float:
         """
@@ -150,9 +165,7 @@ class MGnNegativeRCSCalc(MGnCalc):
             a = np.array(
                 [
                     lst_exp(
-                        key_numbers[j][0] * self.mu[0]
-                        + key_numbers[j][1] * self.mu[1]
-                        + self.l_neg,
+                        key_numbers[j][0] * self.mu[0] + key_numbers[j][1] * self.mu[1] + self.l_neg,
                         s,
                     )
                     for j in range(k + 2)
@@ -241,7 +254,8 @@ class MGnNegativeRCSCalc(MGnCalc):
         """
         w = self.get_w(derivate=False)
 
-        # serving = min(H2_b, exp(l_neg)) = H2(y1=y1, mu1 = mu1+l_neg, mu2=mu2+l_neg)
+        # serving = min(H2_b, exp(l_neg)) = H2(y1=y1, mu1 = mu1+l_neg,
+        # mu2=mu2+l_neg)
 
         params = H2Params(p1=self.y[0], mu1=self.mu[0], mu2=self.mu[1])
         #
@@ -249,9 +263,7 @@ class MGnNegativeRCSCalc(MGnCalc):
         for i in range(1, self.n):
             l_neg += self.p[i] * self.l_neg / i
 
-        b = H2Distribution.calc_theory_moments(
-            H2Params(p1=params.p1, mu1=l_neg + params.mu1, mu2=l_neg + params.mu2)
-        )
+        b = H2Distribution.calc_theory_moments(H2Params(p1=params.p1, mu1=l_neg + params.mu1, mu2=l_neg + params.mu2))
 
         return conv_moments(w, b)
 
@@ -300,9 +312,7 @@ class MGnNegativeRCSCalc(MGnCalc):
                 right = self.l_neg * i / (num - 1)
                 left_from_next = self.l_neg * (i + 1) / (num - 1)
 
-                output[i, i] = ((num - i - 1) * self.mu[0] + left) * self.y[0] + (
-                    i * self.mu[1] + right
-                ) * self.y[1]
+                output[i, i] = ((num - i - 1) * self.mu[0] + left) * self.y[0] + (i * self.mu[1] + right) * self.y[1]
 
                 if i != num - 1:
                     output[i, i + 1] = ((num - i - 1) * self.mu[0] + left) * self.y[1]

most_queue/misc/compare_fj_calc.py

@@ -81,7 +81,9 @@ def test_fj_calc():
         # расчет средних времен пребывания с помощью аппроксимаций. \
         # На вход каждого из методов - l, mu, nn (число каналов СМО)
 
-        calcs = ForkJoinMarkovianCalc(l, mu, nn)
+        calcs = ForkJoinMarkovianCalc(n=nn)
+        calcs.set_sources(l=l)
+        calcs.set_servers(mu=mu)
 
         v_varki.append(calcs.get_v1_fj_varki_merchant())
         v_varma.append(calcs.get_v1_fj_varma())

most_queue/misc/flow_sum.py

@@ -26,7 +26,8 @@ def test():
     # число суммируемых потоков
     ns = [x + 2 for x in range(n_nums - 1)]
 
-    # начальные моменты суммируемых потоков. В нашем случае все потоки одинаково распределены
+    # начальные моменты суммируемых потоков. В нашем случае все потоки
+    # одинаково распределены
     a = []
     for i in range(n_nums):
         params1 = GammaDistribution.get_params_by_mean_and_coev(mean, coev)
@@ -53,11 +54,7 @@ def test():
     errors_coev = []
 
     str_f = "{0:^18s}|{1:^10.3f}|{2:^10.3f}|{3:^10.3f}|{4:^10.3f}|{5:^10.3f}"
-    print(
-        "{0:^18s}|{1:^10s}|{2:^10s}|{3:^10s}|{4:^10s}|{5:^10s}".format(
-            "-", "a1", "a2", "a3", "a4", "coev"
-        )
-    )
+    print("{0:^18s}|{1:^10s}|{2:^10s}|{3:^10s}|{4:^10s}|{5:^10s}".format("-", "a1", "a2", "a3", "a4", "coev"))
     print("-" * 80)
 
     for i in range(n_nums - 1):

most_queue/misc/run_mgn_with_h2_delay_cold_warm.py

@@ -9,12 +9,18 @@ import time
 import numpy as np
 
 from most_queue.misc.vacations_paper_utils import (
-    calc_moments_by_mean_and_coev, dump_stat, load_stat, make_plot,
-    print_table)
+    calc_moments_by_mean_and_coev,
+    dump_stat,
+    load_stat,
+    make_plot,
+    print_table,
+)
 from most_queue.rand_distribution import GammaDistribution
 from most_queue.sim.vacations import VacationQueueingSystemSimulator
-from most_queue.theory.vacations.mgn_with_h2_delay_cold_warm import \
-    MGnH2ServingColdWarmDelay
+from most_queue.theory.vacations.mgn_with_h2_delay_cold_warm import (
+    MGnH2ServingColdWarmDelay,
+    TakahashiTakamiParams,
+)
 
 
 def get_sim_stat(stat, n, l, buff, b, b_c, b_w, b_d, num_of_jobs, p_limit, sim_ave):
@@ -113,18 +119,12 @@ def get_tt_stat(stat, n, l, buff, b, b_c, b_w, b_d, p_limit, w_pls_dt, stable_w_
     :return: None
     """
     tt_start = time.process_time()
-    tt = MGnH2ServingColdWarmDelay(
-        l,
-        b,
-        b_w,
-        b_c,
-        b_d,
-        n,
-        buffer=buff,
-        verbose=verbose,
-        w_pls_dt=w_pls_dt,
-        stable_w_pls=stable_w_pls,
-    )
+
+    tt_params = TakahashiTakamiParams(verbose=verbose, w_pls_dt=w_pls_dt, stable_w_pls=stable_w_pls)
+    tt = MGnH2ServingColdWarmDelay(n=n, buffer=buff, calc_params=tt_params)
+
+    tt.set_sources(l=l)
+    tt.set_servers(b=b, b_warm=b_w, b_cold=b_c, b_cold_delay=b_d)
 
     tt.run()
     p_tt = tt.get_p()

most_queue/misc/test_fj_delta.py

@@ -46,16 +46,16 @@ def test_fj_delta():
 
     b_params = GammaDistribution.get_params_by_mean_and_coev(SERVICE_TIME_AVERAGE, SERVICE_TIME_CV)
 
-    delta_params = GammaDistribution.get_params_by_mean_and_coev(
-        SERVICE_TIME_DELTA_AVERAGE, SERVICE_TIME_CV
-    )
+    delta_params = GammaDistribution.get_params_by_mean_and_coev(SERVICE_TIME_DELTA_AVERAGE, SERVICE_TIME_CV)
     b_delta = GammaDistribution.calc_theory_moments(delta_params)
     b = GammaDistribution.calc_theory_moments(b_params)
 
-    sj_delta = SplitJoinCalc(ARRIVAL_RATE, NUM_OF_CHANNELS, b, approximation="gamma")
+    sj_delta = SplitJoinCalc(n=NUM_OF_CHANNELS)
+    sj_delta.set_sources(l=ARRIVAL_RATE)
+    sj_delta.set_servers(b=b)
 
     v_num = sj_delta.get_v_delta(b_delta)
-    ro = sj_delta.get_ro()
+    utilization = sj_delta.get_utilization()
 
     qs = ForkJoinSimDelta(NUM_OF_CHANNELS, NUM_OF_CHANNELS, b_delta, True)
 
@@ -68,16 +68,14 @@ def test_fj_delta():
     print(f"{'Split-Join QS with service start delay':^60s}")
     print("-" * 60)
     print(f"Coefficient of variation of service time: {SERVICE_TIME_CV}")
-    print(f"Average delay before service start: {SERVICE_TIME_DELTA_AVERAGE:.3f}")
+    print(f"Average delay before service start: { SERVICE_TIME_DELTA_AVERAGE:.3f}")
     print(f"Coefficient of variation of delay: {SERVICE_TIME_CV:.3f}")
-    print(f"Utilization coefficient: {ro:.3f}")
+    print(f"Utilization coefficient: {utilization:.3f}")
 
     times_print(v_sim, v_num, is_w=False)
 
     assert len(v_sim) == len(v_num)
-    assert np.allclose(
-        np.array(v_sim), np.array(v_num), rtol=MOMENTS_RTOL, atol=MOMENTS_ATOL
-    ), ERROR_MSG
+    assert np.allclose(np.array(v_sim), np.array(v_num), rtol=MOMENTS_RTOL, atol=MOMENTS_ATOL), ERROR_MSG
 
 
 if __name__ == "__main__":

most_queue/misc/test_network_opt_approx.py

@@ -5,8 +5,8 @@ Test the NetworkOptimizerWithApprox class.
 import numpy as np
 
 from most_queue.rand_distribution import ExpDistribution
-from most_queue.theory.networks.opt.transition_approx import \
-    NetworkOptimizerWithApprox
+from most_queue.theory.networks.open_network import OpenNetworkCalc
+from most_queue.theory.networks.opt.transition_approx import NetworkOptimizerWithApprox
 
 
 def test_network_opt_approx():
@@ -34,11 +34,12 @@ def test_network_opt_approx():
         ExpDistribution.calc_theory_moments(1.0) for _m in range(num_of_nodes)
     ]  # List of service time moments for each node
 
+    network = OpenNetworkCalc()
+    network.set_sources(R=transition_mrx, arrival_rate=arrival_rate)
+    network.set_nodes(b=service_times, n=num_of_channels)
+
     optimizer = NetworkOptimizerWithApprox(
-        transition_matrix=transition_mrx,
-        arrival_rate=arrival_rate,
-        b=service_times,
-        num_channels=num_of_channels,
+        network=network,
         maximum_rates_to_end=max_ends,
         is_service_markovian=True,
         verbose=True,

most_queue/misc/test_network_opt_plus.py

@@ -5,8 +5,8 @@ Test the NetworkOptimizerPlus class.
 import numpy as np
 
 from most_queue.rand_distribution import ExpDistribution
-from most_queue.theory.networks.opt.transition_plus import (
-    NetworkOptimizerPlus, Strategy)
+from most_queue.theory.networks.open_network import OpenNetworkCalc
+from most_queue.theory.networks.opt.transition_plus import NetworkOptimizerPlus, Strategy
 
 
 def test_network_opt_plus():
@@ -42,11 +42,11 @@ def test_network_opt_plus():
         Strategy.TOP_K,
         Strategy.ALL,
     ]:
+        network = OpenNetworkCalc()
+        network.set_sources(R=transition_mrx, arrival_rate=arrival_rate)
+        network.set_nodes(b=service_times, n=num_of_channels)
         optimizer = NetworkOptimizerPlus(
-            transition_matrix=transition_mrx,
-            arrival_rate=arrival_rate,
-            b=service_times,
-            num_channels=num_of_channels,
+            network=network,
             maximum_rates_to_end=max_ends,
             is_service_markovian=True,
             verbose=False,

most_queue/rand_distribution.py

@@ -1,3 +1,4 @@
+# pylint: disable=too-many-lines
 """
 Random distributions for simulation.
 """
@@ -9,15 +10,28 @@ import scipy.special as sp
 from scipy import stats
 
 from most_queue.general.distribution_fitting import (
-    FittingParams, calc_gamma_func, fit_cox, fit_erlang, fit_gamma, fit_h2,
-    fit_h2_clx, fit_pareto_by_mean_and_coev, fit_pareto_moments, fit_weibull,
-    gamma_moments_by_mean_and_coev)
-from most_queue.general.distribution_params import (Cox2Params, ErlangParams,
-                                                    GammaParams,
-                                                    GaussianParams, H2Params,
-                                                    ParetoParams,
-                                                    UniformParams,
-                                                    WeibullParams)
+    FittingParams,
+    calc_gamma_func,
+    fit_cox,
+    fit_erlang,
+    fit_gamma,
+    fit_h2,
+    fit_h2_clx,
+    fit_pareto_by_mean_and_coev,
+    fit_pareto_moments,
+    fit_weibull,
+    gamma_moments_by_mean_and_coev,
+)
+from most_queue.general.distribution_params import (
+    Cox2Params,
+    ErlangParams,
+    GammaParams,
+    GaussianParams,
+    H2Params,
+    ParetoParams,
+    UniformParams,
+    WeibullParams,
+)
 from most_queue.general.interfaces import Distribution
 
 
@@ -246,9 +260,7 @@ class UniformDistribution(Distribution):
         mean, half_interval = params.mean, params.half_interval
         f = [0.0] * num
         for i in range(num):
-            f[i] = (pow(mean + half_interval, i + 2) - pow(mean - half_interval, i + 2)) / (
-                2 * half_interval * (i + 2)
-            )
+            f[i] = (pow(mean + half_interval, i + 2) - pow(mean - half_interval, i + 2)) / (2 * half_interval * (i + 2))
         return f
 
     @staticmethod
@@ -369,9 +381,7 @@ class H2Distribution(Distribution):
         y2 = 1.0 - params.p1
 
         for i in range(num):
-            f[i] = math.factorial(i + 1) * (
-                params.p1 / pow(params.mu1, i + 1) + y2 / pow(params.mu2, i + 1)
-            )
+            f[i] = math.factorial(i + 1) * (params.p1 / pow(params.mu1, i + 1) + y2 / pow(params.mu2, i + 1))
         return f
 
     @staticmethod
@@ -394,9 +404,7 @@ class H2Distribution(Distribution):
         return fit_h2(moments)
 
     @staticmethod
-    def get_params_clx(
-        moments: list[float], fitting_params: FittingParams | None = None
-    ) -> H2Params:
+    def get_params_clx(moments: list[float], fitting_params: FittingParams | None = None) -> H2Params:
         """
         Method of fitting H2 distribution parameters to given initial moments.
         Uses the method of moments and optimization to fit the parameters.
@@ -505,10 +513,7 @@ class CoxDistribution(Distribution):
         y2 = 1.0 - y1
         f = [0.0] * 3
         f[0] = y2 / m1 + y1 * (1.0 / m1 + 1.0 / m2)
-        f[1] = 2.0 * (
-            y2 / math.pow(m1, 2)
-            + y1 * (1.0 / math.pow(m1, 2) + 1.0 / (m1 * m2) + 1.0 / math.pow(m2, 2))
-        )
+        f[1] = 2.0 * (y2 / math.pow(m1, 2) + y1 * (1.0 / math.pow(m1, 2) + 1.0 / (m1 * m2) + 1.0 / math.pow(m2, 2)))
         f[2] = 6.0 * (
             y2 / (math.pow(m1, 3))
             + y1

most_queue/sim/base.py

@@ -8,13 +8,13 @@ import numpy as np
 from colorama import Fore, Style, init
 from tqdm import tqdm
 
-from most_queue.sim.utils.distribution_utils import (calc_qs_load,
-                                                     create_distribution)
+from most_queue.sim.utils.distribution_utils import calc_qs_load, create_distribution
 from most_queue.sim.utils.exceptions import QsWrongQueueTypeException
 from most_queue.sim.utils.qs_queue import QsQueueDeque, QsQueueList
 from most_queue.sim.utils.servers import Server
 from most_queue.sim.utils.stats_update import refresh_moments_stat
 from most_queue.sim.utils.tasks import Task
+from most_queue.structs import QueueResults
 
 init()
 
@@ -285,7 +285,7 @@ class QsSim:
             # Arrival
             self.arrival()
 
-    def run(self, total_served, is_real_served=True):
+    def run(self, total_served) -> QueueResults:
         """
         Run simulation process
         """
@@ -293,34 +293,34 @@ class QsSim:
 
         print(Fore.GREEN + "\rStart simulation")
 
-        if is_real_served:
-
-            last_percent = 0
-
-            with tqdm(total=100) as pbar:
-                while self.served < total_served:
-                    self.run_one_step()
-                    percent = int(100 * (self.served / total_served))
-                    if last_percent != percent:
-                        last_percent = percent
-                        pbar.update(1)
-                        pbar.set_description(
-                            Fore.MAGENTA
-                            + "\rJob served: "
-                            + Fore.YELLOW
-                            + f"{self.served}/{total_served}"
-                            + Fore.LIGHTGREEN_EX
-                        )
+        last_percent = 0
 
-        else:
-            for _ in tqdm(range(total_served)):
+        with tqdm(total=100) as pbar:
+            while self.served < total_served:
                 self.run_one_step()
+                percent = int(100 * (self.served / total_served))
+                if last_percent != percent:
+                    last_percent = percent
+                    pbar.update(1)
+                    pbar.set_description(
+                        Fore.MAGENTA
+                        + "\rJob served: "
+                        + Fore.YELLOW
+                        + f"{self.served}/{total_served}"
+                        + Fore.LIGHTGREEN_EX
+                    )
 
         print(Fore.GREEN + "\rSimulation is finished")
         print(Style.RESET_ALL)
 
+        v = self.get_v()
+        w = self.get_w()
+        p = self.get_p()
+
         self.time_spent = time.process_time() - start
 
+        return QueueResults(v=v, w=w, p=p, duration=self.time_spent, utilization=self.calc_load())
+
     def refresh_busy_stat(self, new_a):
         """
         Updating statistics of the busy period
@@ -366,14 +366,7 @@ class QsSim:
 
     def __str__(self, is_short=False):
 
-        res = (
-            "Queueing system "
-            + self.source_kendall_notation
-            + "/"
-            + self.server_kendall_notation
-            + "/"
-            + str(self.n)
-        )
+        res = "Queueing system " + self.source_kendall_notation + "/" + self.server_kendall_notation + "/" + str(self.n)
         if self.buffer is not None:
             res += "/" + str(self.buffer)
         res += f"\nLoad: {self.calc_load():4.3f}\n"

most_queue/sim/batch.py

@@ -13,7 +13,9 @@ class QueueingSystemBatchSim(QsSim):
 
     """
 
-    def __init__(self, num_of_channels, batch_prob, buffer=None, verbose=True, buffer_type="list"):
+    def __init__(
+        self, num_of_channels, batch_prob, buffer=None, verbose=True, buffer_type="list"
+    ):  # pylint: disable=too-many-positional-arguments, too-many-arguments
         """
         :param num_of_channels: int : number of channels (servers)
         :param batch_prob: list : probabilities for different batch sizes

most_queue/sim/finite_source.py

@@ -23,7 +23,7 @@ class QueueingFiniteSourceSim(QsSim):
         buffer=None,
         verbose=True,
         buffer_type="list",
-    ):
+    ):  # pylint: disable=too-many-positional-arguments, too-many-arguments
         """
         num_of_channels - number of channels in the system.
         number_of_sources - number of sources.