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

most_queue/{general/interfaces.py → distr_utils/base_distribution.py}

@@ -55,10 +55,10 @@ class Distribution(ABC):
 
     @staticmethod
     @abstractmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float):
+    def get_params_by_mean_and_cv(f1: float, cv: float):
         """
         :param f1: mean of the distribution.
-        :param coev: coefficient of variation (std_dev / mean).
+        :param cv: coefficient of variation (std_dev / mean).
         :return: Parameters for the distribution that correspond
         to the given mean and coefficient of variation.
         """

most_queue/{general → distr_utils}/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.distr_utils.distribution_params import (
+    Cox2Params,
+    ErlangParams,
+    GammaParams,
+    H2Params,
+    ParetoParams,
+    WeibullParams,
+)
 
 
 @dataclass
@@ -98,28 +102,22 @@ def fit_h2_clx(moments: list[float], fitting_params: FittingParams | None = None
 
     if fitting_params.is_fitting:
         # проверка на близость распределения к экспоненциальному
-        coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
-        if math.fabs(coev.real - 1.0) < fitting_params.ee:
+        cv = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+        if math.fabs(cv.real - 1.0) < fitting_params.ee:
             if fitting_params.verbose:
-                print(
-                    f"H2 is close to Exp. Multiply moments to (1+je)"
-                    f"coev = {coev:5.3f}, e = {fitting_params.e:5.3f}."
-                )
+                print(f"H2 is close to Exp. Multiply moments to (1+je)" f"cv = {cv: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))
 
             return fit_h2_clx(f, fitting_params=fitting_params)
 
-        coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+        cv = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
 
         # проверка на близость распределения к Эрланга 2-го порядка
-        if math.fabs(coev.real - 1.0 / math.sqrt(2.0)) < fitting_params.ee:
+        if math.fabs(cv.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}."
-                )
+                print(f"H2 is close to E2. Multiply moments to (1+je)" f"cv = {cv: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))
@@ -148,26 +146,23 @@ def fit_cox(moments: list[float], fitting_params: FittingParams | None = None) -
 
     if fitting_params.is_fitting:
         # проверка на близость распределения к экспоненциальному
-        coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+        cv = 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"cv = {cv: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))
 
             return fit_cox(f, fitting_params=fitting_params)
 
-        coev = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
+        cv = cmath.sqrt(moments[1] - moments[0] ** 2) / moments[0]
 
         # проверка на близость распределения к Эрланга 2-го порядка
         if abs(moments[1] - (3.0 / 4) * moments[0] * moments[0]) < fitting_params.ee:
             if fitting_params.verbose:
                 print("Cox special 2. Multiply moments to (1+je)")
-                print(f"\tcoev = {coev:5.3f}, e = {fitting_params.e:5.3f}")
+                print(f"\tcv = {cv: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 +171,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])
@@ -200,13 +193,13 @@ def fit_pareto_moments(moments: list[float]):
     return ParetoParams(alpha=a, K=k)
 
 
-def fit_pareto_by_mean_and_coev(f1: float, coev: float):
+def fit_pareto_by_mean_and_cv(f1: float, cv: float):
     """
     Get parameters of the distribution by mean and coefficient of variation.
     :param f1: float, mean value of the distribution
-    :param coev: float, coefficient of variation (mean / std)
+    :param cv: float, coefficient of variation (mean / std)
     """
-    d = pow(f1 * coev, 2)
+    d = pow(f1 * cv, 2)
     c = pow(f1, 2) / d
     disc = 4 * (1 + c)
     a = (2 + math.sqrt(disc)) / 2
@@ -287,9 +280,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 +302,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
@@ -327,14 +314,14 @@ def fit_weibull(moments: list[float]) -> WeibullParams:
     return WeibullParams(k=k, W=big_w)
 
 
-def gamma_moments_by_mean_and_coev(mean: float, coev: float) -> list[float]:
+def gamma_moments_by_mean_and_cv(mean: float, cv: float) -> list[float]:
     """
     Calculate the first three moments of a gamma distribution
     given the mean and coefficient of variation.
     """
     f = [0, 0, 0]
-    alpha = 1 / (coev**2)
+    alpha = 1 / (cv**2)
     f[0] = mean
-    f[1] = pow(f[0], 2) * (pow(coev, 2) + 1)
+    f[1] = pow(f[0], 2) * (pow(cv, 2) + 1)
     f[2] = f[1] * f[0] * (1.0 + 2 / alpha)
     return f

most_queue/{rand_distribution.py → distributions.py}

@@ -1,3 +1,4 @@
+# pylint: disable=too-many-lines
 """
 Random distributions for simulation.
 """
@@ -8,17 +9,30 @@ import numpy as np
 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)
-from most_queue.general.interfaces import Distribution
+from most_queue.distr_utils.base_distribution import Distribution
+from most_queue.distr_utils.distribution_fitting import (
+    FittingParams,
+    calc_gamma_func,
+    fit_cox,
+    fit_erlang,
+    fit_gamma,
+    fit_h2,
+    fit_h2_clx,
+    fit_pareto_by_mean_and_cv,
+    fit_pareto_moments,
+    fit_weibull,
+    gamma_moments_by_mean_and_cv,
+)
+from most_queue.distr_utils.distribution_params import (
+    Cox2Params,
+    ErlangParams,
+    GammaParams,
+    GaussianParams,
+    H2Params,
+    ParetoParams,
+    UniformParams,
+    WeibullParams,
+)
 
 
 class Weibull(Distribution):
@@ -85,17 +99,17 @@ class Weibull(Distribution):
         return fit_weibull(moments)
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float) -> WeibullParams:
+    def get_params_by_mean_and_cv(f1: float, cv: float) -> WeibullParams:
         """
         Subselect parameters of Weibull distribution by the given mean and coefficient of variation.
          Args:
              f1 (float): The first parameter of the Weibull distribution.
-             coev (float): The coefficient of variation.
+             cv (float): The coefficient of variation.
          Returns:
              WeibullParams
         """
 
-        f = gamma_moments_by_mean_and_coev(f1, coev)
+        f = gamma_moments_by_mean_and_cv(f1, cv)
 
         return Weibull.get_params(f)
 
@@ -188,15 +202,15 @@ class NormalDistribution(Distribution):
         return GaussianParams(mean, std_dev)
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float):
+    def get_params_by_mean_and_cv(f1: float, cv: float):
         """
         :param f1: mean of the distribution.
-        :param coev: coefficient of variation (std_dev / mean).
+        :param cv: coefficient of variation (std_dev / mean).
         :return: Parameters for the distribution that correspond
         to the given mean and coefficient of variation.
         """
         mean = f1
-        std_dev = coev * mean
+        std_dev = cv * mean
         return GaussianParams(mean, std_dev)
 
 
@@ -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
@@ -264,13 +276,13 @@ class UniformDistribution(Distribution):
         return UniformParams(mean=mean, half_interval=half_interval)
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float) -> UniformParams:
+    def get_params_by_mean_and_cv(f1: float, cv: float) -> UniformParams:
         """
         Get parameters of the uniform distribution by mean and coefficient of variation.
         Returns mean and half interval.
         """
 
-        D = pow(coev * f1, 2)
+        D = pow(cv * f1, 2)
         half_interval = math.sqrt(3 * D)
 
         return UniformParams(mean=f1, half_interval=half_interval)
@@ -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.
@@ -406,12 +414,12 @@ class H2Distribution(Distribution):
         return fit_h2_clx(moments, fitting_params=fitting_params)
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float, is_clx=False) -> H2Params:
+    def get_params_by_mean_and_cv(f1: float, cv: float, is_clx=False) -> H2Params:
         """
         Get parameters of the H2 distribution by mean and coefficient of variation.
         """
 
-        f = gamma_moments_by_mean_and_coev(f1, coev)
+        f = gamma_moments_by_mean_and_cv(f1, cv)
 
         if is_clx:
             return H2Distribution.get_params_clx(f)
@@ -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
@@ -530,12 +535,12 @@ class CoxDistribution(Distribution):
         return fit_cox(moments, fitting_params=fitting_params)
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float) -> Cox2Params:
+    def get_params_by_mean_and_cv(f1: float, cv: float) -> Cox2Params:
         """
         Get parameters of C2 distribution by mean and coefficient of variation
         """
 
-        f = gamma_moments_by_mean_and_coev(f1, coev)
+        f = gamma_moments_by_mean_and_cv(f1, cv)
 
         return CoxDistribution.get_params(f)
 
@@ -584,10 +589,10 @@ class DeterministicDistribution(Distribution):
         return moments[0]
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float):
+    def get_params_by_mean_and_cv(f1: float, cv: float):
         """
         :param f1: mean of the distribution.
-        :param coev: coefficient of variation (std_dev / mean).
+        :param cv: coefficient of variation (std_dev / mean).
         :return: Parameters for the distribution that correspond
         to the given mean and coefficient of variation.
         """
@@ -689,14 +694,14 @@ class ParetoDistribution(Distribution):
         return fit_pareto_moments(moments)
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float):
+    def get_params_by_mean_and_cv(f1: float, cv: float):
         """
         Get parameters of the distribution by mean and coefficient of variation.
         :param f1: float, mean value of the distribution
-        :param coev: float, coefficient of variation (mean / std)
+        :param cv: float, coefficient of variation (mean / std)
         """
 
-        return fit_pareto_by_mean_and_coev(f1, coev)
+        return fit_pareto_by_mean_and_cv(f1, cv)
 
 
 class ErlangDistribution(Distribution):
@@ -782,14 +787,14 @@ class ErlangDistribution(Distribution):
         return fit_erlang(moments)
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float) -> ErlangParams:
+    def get_params_by_mean_and_cv(f1: float, cv: float) -> ErlangParams:
         """
         Method selects the parameters of the Erlang distribution
         by mean and coefficient of variation.
         """
         f = [0, 0]
         f[0] = f1
-        f[1] = (math.pow(coev, 2) + 1) * math.pow(f[0], 2)
+        f[1] = (math.pow(cv, 2) + 1) * math.pow(f[0], 2)
         return ErlangDistribution.get_params(f)
 
 
@@ -840,11 +845,11 @@ class ExpDistribution(Distribution):
         return ErlangDistribution.get_params(moments).mu
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float) -> float:
+    def get_params_by_mean_and_cv(f1: float, cv: float) -> float:
         """
         Get parameters of the exponential distribution from mean and coefficient of variation.
         :param f1: mean value
-        :param coev: coefficient of variation (coefficient of dispersion)
+        :param cv: coefficient of variation (coefficient of dispersion)
         """
         return 1 / f1
 
@@ -872,11 +877,11 @@ class GammaDistribution(Distribution):
         return fit_gamma(moments)
 
     @staticmethod
-    def get_params_by_mean_and_coev(f1: float, coev: float) -> GammaParams:
+    def get_params_by_mean_and_cv(f1: float, cv: float) -> GammaParams:
         """
         Get parameters of gamma distribution by mean and coefficient of variation.
         """
-        d = pow(f1 * coev, 2)
+        d = pow(f1 * cv, 2)
         mu = f1 / d
         alpha = mu * f1
         return GammaParams(mu=mu, alpha=alpha)

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/results_structs.py

@@ -0,0 +1,163 @@
+"""
+Structures for queueing systems.
+"""
+
+import json
+from dataclasses import asdict, dataclass, is_dataclass
+
+
+@dataclass
+class QueueResults:
+    """
+    Result of calculation for queueing system.
+    """
+
+    v: list[float] | None = None  # sojourn time initial moments
+    w: list[float] | None = None  # waiting time initial moments
+    p: list[float] | None = None  # probabilities of states
+    pi: list[float] | None = None  # probabilities of states before arrival
+    utilization: float | None = None  # utilization factor
+
+    duration: float = 0.0  # calculation or simulation duration in seconds
+
+
+@dataclass
+class PriorityResults:
+    """
+    Results of priority queue calculation
+    """
+
+    v: list[list[float]] | None = None  # sojourn time moments for each class
+    w: list[list[float]] | None = None  # waiting time moments for each class
+    p: list[float] | None = None  # probabilities of states (low priority jobs)
+
+    h: list[list[float]] | None = None  # initial moments of active time
+    busy: list[list[float]] | None = None  # initial moments of busy period
+    w_with_pr: list[list[float]] | None = None  # initial moments of waiting for service with interruptions
+
+    utilization: float | None = None  # utilization factor
+
+    duration: float = 0.0  # calculation or simulation duration in seconds
+
+
+@dataclass
+class VacationResults(QueueResults):
+    """
+    Result of queue with vacations.
+    """
+
+    warmup_prob: float = 0
+    cold_prob: float = 0
+    cold_delay_prob: float = 0
+    servers_busy_probs: list[float] | None = None
+
+
+@dataclass
+class NetworkResults:
+    """
+    Data class to store network results.
+    """
+
+    v: list[float] | None = None  # initial moments of sojourn time distribution
+    intensities: list[float] | None = None  # intensities of arrivals into nodes
+    loads: list[float] | None = None  # nodes utilizations
+
+    duration: float = 0.0  # calculation or simulation duration in seconds
+
+    arrived: int = 0  # number of arrived jobs (for simulation)
+    served: int = 0  # number of served jobs (for simulation)
+
+
+@dataclass
+class NetworkResultsPriority:
+    """
+    Data class to store results for network with priority discipline in nodes.
+    """
+
+    v: list[list[float]] | None = None  # initial moments of sojourn time distribution for each class
+    intensities: list[list[float]] | None = None  # intensities of arrivals into nodes  for each class
+    loads: list[float] | None = None  # nodes utilizations
+
+    duration: float = 0.0  # calculation or simulation duration in seconds
+
+    arrived: int = 0  # number of arrived jobs (for simulation)
+    served: int = 0  # number of served jobs (for simulation)
+
+
+@dataclass
+class NegativeArrivalsResults(QueueResults):
+    """
+    Class for storing results related to negative arrivals in a queueing system.
+     Contains lists of waiting times (w), sojourn times  (v),
+     sojourn times of served jobs (v_served), sojourn times of broken jobs (v_broken),
+     and probabilities (p).
+    """
+
+    v_served: list[float] | None = None
+    v_broken: list[float] | None = None
+
+
+@dataclass
+class DependsOnChannelsResults:
+    """
+    Class for storing results that depend on the number of channels.
+     Contains calculated and simulated results,
+     as well as parameters such as the number of channels,
+     utilization factor, and service time variation coefficient.
+    """
+
+    calc: list[NegativeArrivalsResults]
+    sim: list[NegativeArrivalsResults]
+    channels: list[int]
+    utilization_factor: float
+    service_time_variation_coef: float
+
+
+@dataclass
+class DependsOnUtilizationResults:
+    """
+    Class for storing results that depend on the utilization factor.
+     Contains calculated and simulated results,
+     as well as parameters such as the number of channels,
+     utilization factor, and service time variation coefficient.
+    """
+
+    calc: list[NegativeArrivalsResults]
+    sim: list[NegativeArrivalsResults]
+    utilization_factor: list[float]
+    channels: int
+    service_time_variation_coef: float
+
+
+@dataclass
+class DependsOnVariationResults:
+    """
+    Class for storing results that depend on the service time variation coefficient.
+     Contains calculated and simulated results,
+     as well as parameters such as the number of channels,
+     utilization factor, and service time variation coefficient.
+    """
+
+    calc: list[NegativeArrivalsResults]
+    sim: list[NegativeArrivalsResults]
+    service_time_variation_coef: list[float]
+    channels: int
+    utilization_factor: float
+
+
+class DependsOnJSONEncoder(json.JSONEncoder):
+    """
+    Encoder for dataclasses to JSON.
+    """
+
+    def default(self, o):
+        if is_dataclass(o):
+            json_res = {
+                "service_time_variation_coef": o.service_time_variation_coef,
+                "channels": o.channels,
+                "utilization_factor": o.utilization_factor,
+                "calc": [asdict(r) for r in o.calc],
+                "sim": [asdict(r) for r in o.sim],
+            }
+            return json_res
+        return super().default(o)

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}")