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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most_queue
-Version: 1.54
+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>
@@ -138,6 +138,14 @@ Most_queue consists of two main parts:
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
 | 1.  | M/M/1/D         |  Solving for M/M/1 with exponential impatience     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_impatience.py) | |
 
+
+### QS with Negative arrivals
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1.  | M/G/c RCS         |  Numerical calculation of M/G/c with RCS (remove customer from service) negative arrivals. Service time approximates by H<SUB>2</SUB> distribution     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mgn_rcs.py) | |
+| 2.  | M/G/c disaster         |  Numerical calculation of M/G/c with disaster (remove all customer from service and queue by negative arrival). Service time approximates by H<SUB>2</SUB> distribution     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mgn_disaster.py) | |
+
+
 ### Closed QS (with finite number of sources)
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|

{most_queue-1.54 → most_queue-1.56}/README.md

@@ -98,6 +98,14 @@ Most_queue consists of two main parts:
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
 | 1.  | M/M/1/D         |  Solving for M/M/1 with exponential impatience     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_impatience.py) | |
 
+
+### QS with Negative arrivals
+| #   | Kendall Notations |  Description      | Example | Tutorial |
+|-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
+| 1.  | M/G/c RCS         |  Numerical calculation of M/G/c with RCS (remove customer from service) negative arrivals. Service time approximates by H<SUB>2</SUB> distribution     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mgn_rcs.py) | |
+| 2.  | M/G/c disaster         |  Numerical calculation of M/G/c with disaster (remove all customer from service and queue by negative arrival). Service time approximates by H<SUB>2</SUB> distribution     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_mgn_disaster.py) | |
+
+
 ### Closed QS (with finite number of sources)
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|

most_queue-1.56/most_queue/general/conditional.py

@@ -0,0 +1,52 @@
+"""
+Conditional moments of random variables.
+"""
+import math
+
+import numpy as np
+
+from most_queue.general.distribution_params import 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.
+    X is exponentially distributed with rate gamma.
+    """
+    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)]
+
+    return np.array([mom.real for mom in b])
+
+
+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.
+    Y is a hyperexponential random variable with parameters p1, mu1, and mu2.
+
+    1. f_{X|X<Y}(x) = f_X(x) * P(Y > x) / P(X < Y)
+    2. P(Y > x) = ∫_{x}^{∞} [p1mu1exp(-mu1y) + (1-p1)mu2exp(-mu2y)] dy
+    3. P(X < Y) =  ∫_{0}^{∞} f_X(x) * P(Y > x) dx
+    4. f_{X|X<Y}(x) = gamma * exp(-gamma*x) * P(Y > x) / P(X < Y)
+    """
+    p1, mu1, mu2 = h2_params.p1, h2_params.mu1, h2_params.mu2
+    y = [p1, 1-p1]
+    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)])
+        b.append(numerator / denominator)
+
+    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.54 → most_queue-1.56}/most_queue/general/tables.py

@@ -8,7 +8,7 @@ from colorama import Fore, Style, init
 init()
 
 
-def times_print(sim_moments, calc_moments, is_w=True):
+def times_print(sim_moments, calc_moments, is_w=True, header=None):
     """
     Prints the initial moments of waiting or sojourn time in the system.
      Args:
@@ -17,15 +17,16 @@ def times_print(sim_moments, calc_moments, is_w=True):
          is_w (bool, optional): If True, prints waiting time moments. Otherwise, prints sojourn time moments. Defaults to True.
 
     """
-    if is_w:
-        spec = 'waiting'
-    else:
-        spec = 'soujorn'
 
-    header = f'Initial moments of {spec} time in the system'
-
-    print(Fore.CYAN + f'\r{header}')
+    if header is None:
+        if is_w:
+            spec = 'waiting'
+        else:
+            spec = 'soujorn'
+        header = f'Initial moments of {spec} time in the system'
 
+    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.54 → 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.56/most_queue/misc/calc_v_pls.py

@@ -0,0 +1,314 @@
+"""
+Calculate M/H2/n queue with negative jobs with RCS discipline,
+(remove customer from service)
+"""
+import math
+from functools import lru_cache
+
+import numpy as np
+from scipy.misc import derivative
+
+from most_queue.general.conv import conv_moments
+from most_queue.theory.queueing_systems.fifo.mgn_takahasi import MGnCalc
+from most_queue.theory.utils.transforms import (
+    laplace_stieltjes_exp_transform as lst_exp,
+)
+from most_queue.rand_distribution import H2Distribution, H2Params
+
+class MGnNegativeRCSCalc(MGnCalc):
+    """
+    Calculate M/H2/n queue with negative jobs with RCS discipline,
+    (remove customer from service)
+    """
+
+    def __init__(self, n: int, l_pos: float, l_neg: float, b: list[float],
+                 buffer: int | None = None, N: int = 150,
+                 accuracy: float = 1e-6, dtype="c16", verbose: bool = False):
+        """
+        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)
+        accuracy: accuracy parameter for stopping the iteration
+        dtype: data type for calculations (default is complex double precision)
+        verbose: whether to print intermediate results (default is False)
+        """
+
+        self.l_neg = l_neg
+
+        super().__init__(n=n, l=l_pos, b=b, buffer=buffer, N=N,
+                         accuracy=accuracy, dtype=dtype, verbose=verbose)
+
+    def get_q(self) -> float:
+        """
+        Calculation of the conditional probability of successful service completion at a node
+        """
+        return 1.0 - (self.l_neg/self.l)*(1.0-self.p[0].real)
+
+    def get_w(self, derivate=False) -> list[float]:
+        """
+        Get the waiting time moments
+        """
+
+        w = [0.0] * 3
+
+        if derivate:
+            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], w[1].real, -w[2]])
+
+        for j in range(1, len(self.p) - self.n):
+            w[0] += j * self.p[self.n + j]
+        for j in range(2, len(self.p) - self.n):
+            w[1] += j * (j - 1) * self.p[self.n + j]
+        for j in range(3, len(self.p) - self.n):
+            w[2] += j * (j - 1) * (j - 2) * self.p[self.n + j]
+
+        for j in range(3):
+            w[j] /= math.pow(self.l, j + 1)
+            w[j] = w[j].real
+
+        return np.array(w)
+
+    def _get_key_numbers(self, level):
+        key_numbers = []
+        if level >= self.n:
+            for i in range(level + 1):
+                key_numbers.append((self.n - i, i))
+        else:
+            for i in range(level + 1):
+                key_numbers.append((level - i, i))
+        return np.array(key_numbers, dtype=self.dt)
+
+    def _calc_up_probs(self, from_level):
+        if from_level == self.n:
+            return np.eye(self.n + 1)
+        b_matrix = self.B[from_level]
+        probs = []
+        for i in range(self.cols[from_level - 1]):
+            probs_on_level = []
+            for j in range(self.cols[from_level - 1]):
+                if from_level != 1:
+                    probs_on_level.append(b_matrix[i, j] / sum(b_matrix[i, :]))
+                else:
+                    probs_on_level.append(b_matrix[i, 0] / sum(b_matrix[i, :]))
+            probs.append(probs_on_level)
+        return np.array(probs, dtype=self.dt)
+
+    def _matrix_pow(self, matrix, k):
+        res = np.eye(self.n + 1, dtype=self.dt)
+        for i in range(k):
+            res = np.dot(res, matrix)
+        return res
+
+    @lru_cache
+    def _build_probs_down(self, num):
+        """
+        Create matrix with transition down probs by the given level number.
+        """
+        if num < self.n:
+            col = self.cols[num + 1]
+            row = self.cols[num]
+        else:
+            col = self.cols[self.n]
+            row = self.cols[self.n]
+
+        output = np.zeros((row, col), dtype=self.dt)
+
+        if num > self.n:
+            output = self._build_probs_down(self.n)
+            return output
+
+        for i in range(row):
+            if num < self.n:
+                output[i, i] = self.y[0]
+                output[i, i + 1] = self.y[1]
+            else:
+                output[i, i] = 1.0
+
+        return output
+
+    def _calc_v_pls(self, s) -> float:
+
+        v = 0
+
+        for k in range(self.n):
+            # When arrived, job see current state, move to next and need to serve on it
+            # so, we work with next levels (for example, k + 1 instead k)
+
+            # for k=1, [(2,0), (1,1), (0, 2)]
+            key_numbers = self._get_key_numbers(k+1)
+
+            # LST for serving in next state, for k=1, size=(1, 3)
+            a = np.array(
+                [lst_exp(key_numbers[j][0] * self.mu[0] + key_numbers[j][1] * self.mu[1] + self.l_neg, s) for j in
+                 range(k + 2)])
+
+            # P - down transition matrix, for k=1 size = (2, 3)
+            # for 1 state y1 y2 0
+            #             0  y1 y2
+            P = self._build_probs_down(k)
+            # current state, for k=1 size = (1, 2)
+            Ys = np.array([self.Y[k][0, i] for i in range(k + 1)])
+
+            v_tek = np.dot(Ys, P.dot(a.T))
+
+            v += v_tek
+
+        key_numbers = self._get_key_numbers(self.n)
+
+        a_n = np.array(
+            [lst_exp(key_numbers[j][0] * self.mu[0] + key_numbers[j][1] * self.mu[1] + self.l_neg, s) for j in
+             range(self.n + 1)])
+
+        Pn_plus = self._calc_up_probs(self.n + 1)  # size=(4, 4)
+
+        Pa = Pn_plus*a_n  # 4,4
+
+        PdotaT = Pn_plus.dot(a_n.T)  # 4,1
+
+        prod = np.eye(self.n+1)
+
+        for k in range(self.n, self.N):
+
+            Ys = np.array([self.Y[k][0, i]
+                          for i in range(self.n + 1)])  # (1, 4)
+
+            ya = Ys*a_n  # 1,4
+
+            v += np.dot(ya, prod.dot(PdotaT))
+
+            prod = prod.dot(Pa)
+
+        return v
+
+    def _calc_w_pls(self, s) -> float:
+        """
+        Calculate Laplace-Stietjes transform of the waiting time distribution.
+        :param s: Laplace variable
+        :return: Laplace-Stieltjes transform of the waiting time distribution
+        """
+        w = 0
+
+        key_numbers = self._get_key_numbers(self.n)
+
+        a = np.array(
+            [lst_exp(key_numbers[j][0] * self.mu[0] + key_numbers[j][1] * self.mu[1] + self.l_neg, s) for j in
+             range(self.n + 1)])
+
+        Pn_plus = self._calc_up_probs(self.n+1)
+
+        for k in range(self.n, self.N):
+
+            Pa = np.transpose(self._matrix_pow(
+                Pn_plus * a, k - self.n))  # n+1 x n+1
+
+            Ys = [self.Y[k][0, i] for i in range(self.n + 1)]
+            aPa = np.dot(a, Pa)
+            for i in range(self.n + 1):
+                w += Ys[i] * aPa[i]
+
+        return w
+
+    def get_v(self) -> list[float]:
+        """
+        Get the sojourn time moments
+        """
+        w = self.get_w(derivate=False)
+        
+        # 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])
+        #
+        l_neg = 0
+        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))
+
+        return conv_moments(w, b)
+
+    def _build_big_b_matrix(self, num):
+        """
+        Create matrix B by the given level number.
+        """
+        if num == 0:
+            return np.zeros((1, 1), dtype=self.dt)
+
+        if num <= self.n:
+            col = self.cols[num - 1]
+            row = self.cols[num]
+        else:
+            col = self.cols[self.n + 1]
+            row = self.cols[self.n + 1]
+
+        output = np.zeros((row, col), dtype=self.dt)
+
+        if num > self.n + 1:
+            output = self.B[self.n + 1]
+            return output
+
+        for i in range(col):
+            if num <= self.n:
+                # key has two parts: left and right, like 21
+                # fill B matrix by pattern of 2 elements:
+                # up arrow, arrow from next to current key
+                #  x 0
+                #  x y
+                #  0 y
+                first_neg, second_neg = self.l_neg * \
+                    (num-i)/num, self.l_neg*(i+1)/num
+                output[i, i] = (num - i) * self.mu[0] + first_neg
+                output[i + 1, i] = (i + 1) * self.mu[1] + second_neg
+            else:
+                # key has two parts: left and right, like 21
+                # fill B matrix by pattern of 3 elements:
+                # up arrow, right arrow, arrow from next to current key
+                #  x x 0
+                #  x y y
+                #  0 y 0
+                left = self.l_neg * (num-i-1)/(num-1)
+                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]
+
+                if i != num - 1:
+                    output[i, i + 1] = ((num - i - 1) * self.mu[0] +
+                                        left) * self.y[1]
+
+                    output[i + 1, i] = ((i + 1) * self.mu[1] +
+                                        left_from_next) * self.y[0]
+        return output
+
+    def _build_big_d_matrix(self, num):
+        """
+        Create matrix D by the given level number.
+        """
+        if num < self.n:
+            col = self.cols[num]
+            row = col
+        else:
+            col = self.cols[self.n]
+            row = col
+
+        output = np.zeros((row, col), dtype=self.dt)
+
+        if num > self.n:
+            output = self.D[self.n]
+            return output
+
+        for i in range(row):
+            output[i, i] = self.l + self.l_neg + \
+                (num - i) * self.mu[0] + i * self.mu[1]
+
+        return output

{most_queue-1.54 → 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__":