most-queue 2.1__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,7 +8,7 @@ from dataclasses import dataclass
 
 import numpy as np
 
-from most_queue.general.distribution_params import (
+from most_queue.distr_utils.distribution_params import (
     Cox2Params,
     ErlangParams,
     GammaParams,
@@ -102,27 +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))
@@ -151,23 +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))
@@ -198,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
@@ -319,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}

@@ -9,7 +9,8 @@ import numpy as np
 import scipy.special as sp
 from scipy import stats
 
-from most_queue.general.distribution_fitting import (
+from most_queue.distr_utils.base_distribution import Distribution
+from most_queue.distr_utils.distribution_fitting import (
     FittingParams,
     calc_gamma_func,
     fit_cox,
@@ -17,12 +18,12 @@ from most_queue.general.distribution_fitting import (
     fit_gamma,
     fit_h2,
     fit_h2_clx,
-    fit_pareto_by_mean_and_coev,
+    fit_pareto_by_mean_and_cv,
     fit_pareto_moments,
     fit_weibull,
-    gamma_moments_by_mean_and_coev,
+    gamma_moments_by_mean_and_cv,
 )
-from most_queue.general.distribution_params import (
+from most_queue.distr_utils.distribution_params import (
     Cox2Params,
     ErlangParams,
     GammaParams,
@@ -32,7 +33,6 @@ from most_queue.general.distribution_params import (
     UniformParams,
     WeibullParams,
 )
-from most_queue.general.interfaces import Distribution
 
 
 class Weibull(Distribution):
@@ -99,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)
 
@@ -202,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)
 
 
@@ -276,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)
@@ -414,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)
@@ -535,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)
 
@@ -589,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.
         """
@@ -694,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):
@@ -787,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)
 
 
@@ -845,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
 
@@ -877,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/misc/approx_cdf_make.py

@@ -4,21 +4,21 @@ import matplotlib.pyplot as plt
 import numpy as np
 from tqdm import tqdm
 
-from most_queue.rand_distribution import GammaDistribution, H2Distribution
+from most_queue.distributions import GammaDistribution, H2Distribution
 
 if __name__ == "__main__":
 
     # Входные данные
 
     b1 = 3  # мат. ожидание
-    coev = 1.2  # коэффициент вариации
+    cv = 1.2  # коэффициент вариации
     a_s = 4  # ассиметрия
 
     # задаем начальные моменты распределения
 
     b = [0, 0, 0]
     b[0] = b1
-    b[1] = pow(b[0], 2) * (1 + pow(coev, 2))
+    b[1] = pow(b[0], 2) * (1 + pow(cv, 2))
 
     # дисперсия
     D = b[1] - pow(b[0], 2)

most_queue/misc/calc_v_pls.py

@@ -9,7 +9,7 @@ from functools import lru_cache
 import numpy as np
 from scipy.misc import derivative
 
-from most_queue.rand_distribution import H2Distribution, H2Params
+from most_queue.distributions import H2Distribution, H2Params
 from most_queue.theory.fifo.mgn_takahasi import MGnCalc, TakahashiTakamiParams
 from most_queue.theory.utils.conv import conv_moments
 from most_queue.theory.utils.transforms import lst_exp

most_queue/misc/flow_sum.py

@@ -5,7 +5,7 @@ Test summation of flows.
 
 import matplotlib.pyplot as plt
 
-from most_queue.rand_distribution import GammaDistribution
+from most_queue.distributions import GammaDistribution
 from most_queue.sim.flow_sum import FlowSumSim
 from most_queue.theory.utils.flow_sum import SummatorNumeric
 
@@ -17,7 +17,7 @@ def test():
 
     # Задаем следующие параметры:
     n_nums = 10  # число суммируемых потоков
-    coev = 0.74  # коэффициент вариации каждого потока
+    cv = 0.74  # коэффициент вариации каждого потока
     mean = 1  # среднее каждого потока
     num_of_jobs = 400000  # количество заявок для ИМ
     is_semi = False  # True, если необходимо использовать метод семиинвариантов вместо H2
@@ -30,7 +30,7 @@ def test():
     # одинаково распределены
     a = []
     for i in range(n_nums):
-        params1 = GammaDistribution.get_params_by_mean_and_coev(mean, coev)
+        params1 = GammaDistribution.get_params_by_mean_and_cv(mean, cv)
         a1 = GammaDistribution.calc_theory_moments(params1, 4)
         a.append(a1)
 
@@ -47,14 +47,14 @@ def test():
     # i - кол-во суммируемых потоков, j - номер начального момента
 
     # Расчет ошибок и отображение результатов
-    coevs_sim = s_sim.coevs
-    coevs_num = s.coevs
+    cvs_sim = s_sim.cvs
+    cvs_num = s.cvs
     errors1 = []
     errors2 = []
-    errors_coev = []
+    errors_cv = []
 
     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", "cv"))
     print("-" * 80)
 
     for i in range(n_nums - 1):
@@ -67,7 +67,7 @@ def test():
                 s_sim.flows_[i][1],
                 s_sim.flows_[i][2],
                 s_sim.flows_[i][3],
-                coevs_num[i],
+                cvs_num[i],
             )
         )
         print("-" * 80)
@@ -78,13 +78,13 @@ def test():
                 s.flows_[i][1].real,
                 s.flows_[i][2].real,
                 s.flows_[i][3].real,
-                coevs_sim[i],
+                cvs_sim[i],
             )
         )
         print("-" * 80)
         errors1.append(SummatorNumeric.get_error(s.flows_[i][0].real, s_sim.flows_[i][0]))
         errors2.append(SummatorNumeric.get_error(s.flows_[i][1].real, s_sim.flows_[i][1]))
-        errors_coev.append(SummatorNumeric.get_error(coevs_num[i], coevs_sim[i]))
+        errors_cv.append(SummatorNumeric.get_error(cvs_num[i], cvs_sim[i]))
 
     fig, ax = plt.subplots()
     linestyles = ["solid", "dotted", "dashed", "dashdot"]
@@ -104,7 +104,7 @@ def test():
     fig, ax = plt.subplots()
     ax.plot(ns, errors1, label="error a1", linestyle=linestyles[0])
     ax.plot(ns, errors2, label="error a2", linestyle=linestyles[1])
-    ax.plot(ns, errors_coev, label="error coev", linestyle=linestyles[2])
+    ax.plot(ns, errors_cv, label="error cv", linestyle=linestyles[2])
 
     plt.legend()
     str_title = "Отн. ошибка от числа сумм-х потоков, %"