most-queue 1.60__tar.gz → 1.61__tar.gz

{most_queue-1.60 → most_queue-1.61}/.gitignore

@@ -162,4 +162,4 @@ cython_debug/
 
 .vscode
 
-/works/results/
+works/negative_queues/results/*

{most_queue-1.60 → most_queue-1.61}/PKG-INFO

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

{most_queue-1.60 → most_queue-1.61}/most_queue/general/distribution_params.py

@@ -35,6 +35,15 @@ class GammaParams:
     g: list[float] | None = None
 
 
+@dataclass
+class WeibullParams:
+    """
+     Weibull distribution parameters.
+    """
+    k: float  # Shape parameter
+    W: float  # Scale parameter
+
+
 @dataclass
 class GaussianParams:
     """

{most_queue-1.60 → most_queue-1.61}/most_queue/rand_distribution.py

@@ -16,10 +16,135 @@ from most_queue.general.distribution_params import (
     H2Params,
     ParetoParams,
     UniformParams,
+    WeibullParams
 )
 from most_queue.general.interfaces import Distribution
 
 
+class Weibull(Distribution):
+    """
+    Class for working with the Weibull distribution
+    """
+
+    def __init__(self, params: WeibullParams, generator=None):
+        """
+        :param params: WeibullParams object containing shape parameter (k) and scale parameter (T)
+        :param generator: random number generator. If None, np.random is used.
+        """
+
+        self.k = params.k
+        self.W = params.W
+        self.params = params
+        self.type = 'Weibull'
+        self.generator = generator
+
+    @staticmethod
+    def generate_static(params: WeibullParams, generator=None):
+        """
+        Generates a random number according to the Weibull distribution.
+        """
+        if generator:
+            p = generator.random()
+        else:
+            p = np.random.rand()
+        return math.pow(-math.log(p)*params.W, -1 / params.k)
+
+    def generate(self) -> float:
+        """
+        Generates a random number according to the Weibull distribution.
+        """
+
+        return self.generate_static(self.params, self.generator)
+
+    @staticmethod
+    def calc_theory_moments(params: WeibullParams, num: int) -> list[float]:
+        """
+        Calculates theoretical moments of the distribution up to the specified order.
+        :param params: WeibullParams parameters for the distribution.
+        :param num: number of moments to calculate.
+        :return: list[float]
+        """
+        f = [0.0]*num
+        for i in range(num):
+            f[i] = math.gamma(1 + i/params.k) * math.pow(params.W, i/params.k)
+        return f
+
+    @staticmethod
+    def get_params(moments: list[float]) -> WeibullParams:
+        """
+        Parameter selection for the distribution based 
+        on initial moments of the distribution 
+
+        params:
+            moments: initial moments of the random variable
+
+       return:
+            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))
+        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))
+            delta = u1 - u0
+            u0 = u1
+        k = 1 / u1
+        big_w = math.pow(moments[0] / math.gamma(u1 + 1), k)
+
+        return WeibullParams(k=k, W=big_w)
+
+    @staticmethod
+    def get_params_by_mean_and_coev(f1: float, coev: 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.
+         Returns:
+             WeibullParams
+        """
+
+        f = [0, 0, 0]
+        alpha = 1 / (coev ** 2)
+        f[0] = f1
+        f[1] = pow(f[0], 2) * (pow(coev, 2) + 1)
+        f[2] = f[1] * f[0] * (1.0 + 2 / alpha)
+
+        return Weibull.get_params(f)
+
+    @staticmethod
+    def get_tail(params: WeibullParams, t: float) -> float:
+        """
+        Calculate the tail probability of a Weibull distribution at a given value.
+         Args:
+            params (WeibullParams): The parameters of Weibull distribution
+            t: The value at which to calculate the tail probability.
+        """
+        k = params.k
+        big_w = params.W
+
+        return math.exp(-math.pow(t, k) / big_w)
+
+    @staticmethod
+    def get_cdf(params: WeibullParams, t: float) -> float:
+        """
+        Calculate the cumulative distribution function (CDF) of a Weibull distribution for a given set of values.
+         Args:
+            params (WeibullParams): The parameters of Weibull distribution
+            t: The value at which to calculate the cdf probability.
+
+        """
+        k = params.k
+        big_w = params.W
+
+        return 1.0 - math.exp(-math.pow(t, k) / big_w)
+
+
 class NormalDistribution(Distribution):
     """
     Gaussian distribution. Generates random numbers from a normal (Gaussian) distribution.

{most_queue-1.60 → most_queue-1.61}/most_queue/theory/fifo/mgn_takahasi.py

@@ -6,6 +6,8 @@ import math
 import numpy as np
 
 from most_queue.rand_distribution import H2Distribution
+from most_queue.theory.utils.transforms import lst_exp
+from scipy.misc import derivative
 
 
 class MGnCalc:
@@ -163,7 +165,7 @@ class MGnCalc:
         """
         return [prob.real for prob in self.p]
 
-    def get_w(self) -> list[float]:
+    def get_w(self, derivate=False) -> list[float]:
         """
         Get the waiting time moments
         """
@@ -173,6 +175,12 @@ class MGnCalc:
 
         w = [0.0] * 3
 
+        if derivate:
+            for i in range(3):
+                w[i] = derivative(self._calc_w_lst, 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):
@@ -191,6 +199,7 @@ class MGnCalc:
         """
         Get the sojourn time moments
         """
+
         w = self.get_w()
         b0 = self.b[0]
         b1 = self.b[1]
@@ -407,3 +416,54 @@ class MGnCalc:
             output[i, i] = self.l + (num - i) * self.mu[0] + i * self.mu[1]
 
         return output
+
+    def _calc_up_probs(self, from_level):
+
+        b_matrix = self.B[from_level]
+        low_level_size = self.cols[from_level - 1]
+        high_level_size = self.cols[from_level]
+
+        probs = np.zeros((high_level_size, low_level_size), dtype=self.dt)
+
+        for i in range(high_level_size):
+            for j in range(low_level_size):
+                if from_level != 1:
+                    probs[i, j] = b_matrix[i, j] / sum(b_matrix[i, :])
+                else:
+                    probs[i, j] = b_matrix[i, 0] / sum(b_matrix[i, :])
+
+        return probs
+
+    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_w_lst(self, s):
+
+        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], s) for j in
+             range(self.n + 1)])
+
+        up_transition_mrx = self._calc_up_probs(self.n+1)  # (n + 1 x n + 1)
+
+        for k in range(self.n, self.N):
+
+            Pa = np.linalg.matrix_power(
+                up_transition_mrx * 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(Pa, a)
+            for i in range(self.n + 1):
+                w += Ys[i] * aPa[i]
+
+        return w

most_queue-1.61/most_queue/theory/utils/residual.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+
+def lst_residual(lst_original: callable, b1: float, s: float) -> float:
+    """
+    Calculate the Laplace-Stieltjes transform of a residual distribution.
+    """
+    return (1-lst_original(s))/(b1*s)
+
+
+def get_b_residual(b_original: list[float]) -> list[float]:
+    """
+    Calculate the initial moments E[X^k] for k=0,1,...,n-1 of a residual distribution.
+    b_res1 = E[X^2]/(2*E[X])
+    """
+    b_res = np.zeros(len(b_original)-1)
+    for i in range(len(b_original)-1):
+        b_res[i] = b_original[i+1]/((i+2)*b_original[0])
+    return b_res

{most_queue-1.60 → most_queue-1.61}/most_queue/theory/utils/transforms.py

@@ -25,3 +25,6 @@ def lst_gamma(gamma_params: GammaParams, s: float) -> float:
     Calculate the Laplace-Stieltjes transform of a gamma distribution.
     """
     return math.pow(gamma_params.mu/(s+gamma_params.mu), gamma_params.alpha)
+
+
+

{most_queue-1.60 → most_queue-1.61}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "most_queue"
-version = "1.60"
+version = "1.61"
 authors = [
   { name="Xabarov Roman", email="xabarov1985@gmail.com" },
 ]

{most_queue-1.60 → most_queue-1.61}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import find_packages, setup
 
 setup(name='most-queue',
-      version='1.60',
+      version='1.61',
       description='Software package for calculation and simulation of queuing systems',
       author='Xabarov Roman',
       author_email='xabarov1985@gmail.com',

{most_queue-1.60 → most_queue-1.61}/tests/test_mgn_tt.py

@@ -15,6 +15,7 @@ from most_queue.general.tables import probs_print, times_print
 from most_queue.rand_distribution import GammaDistribution
 from most_queue.sim.base import QsSim
 from most_queue.theory.fifo.mgn_takahasi import MGnCalc
+import numpy as np
 
 ARRIVAL_RATE = 1.0
 NUM_OF_JOBS = 300000
@@ -45,6 +46,7 @@ def test_mgn_tt():
         # get numerical calculation results
         p_tt = tt.get_p()
         v_tt = tt.get_v()
+
         tt_time = time.process_time() - tt_start
         # also can find out how many iterations were required
         num_of_iter = tt.num_of_iter_
@@ -87,7 +89,8 @@ def test_mgn_tt():
 
         times_print(v_sim, v_tt, False)
 
-        assert 100*abs(v_tt[0] - v_sim[0])/max(v_tt[0], v_sim[0]) < 10
+        assert np.allclose(v_sim, v_tt, rtol=5e-1), "The results of the simulation and Takahasi-Takami method do not match!"
+
 
 
 if __name__ == "__main__":

most_queue-1.61/tests/units/test_tt_up_probs.py

@@ -0,0 +1,48 @@
+"""
+Testing the Takahasi-Takami method for calculating an M/H2/n queue
+
+When the coefficient of variation of service time is less than 1, 
+the parameters of the approximating H2 distribution
+are complex, which does not prevent obtaining meaningful results.
+
+For verification, simulation is used.
+
+"""
+import math
+
+from most_queue.general.tables import print_mrx
+from most_queue.theory.fifo.mgn_takahasi import MGnCalc
+
+ARRIVAL_RATE = 1.0
+NUM_OF_JOBS = 300000
+NUM_OF_CHANNELS = 3
+UTILIZATION = 0.7
+SERVICE_TIME_CV = 1.2
+
+
+def test_calc_up_probs():
+    """
+    Testing the Takahasi-Takami method calculation of up-probabilities
+    """
+
+    # calculate initial moments of service time based
+    # on the given average and coefficient of variation
+    b = [0.0] * 3
+    alpha = 1 / (SERVICE_TIME_CV ** 2)
+    b[0] = NUM_OF_CHANNELS * UTILIZATION / \
+        ARRIVAL_RATE  # average service time
+    b[1] = math.pow(b[0], 2) * (math.pow(SERVICE_TIME_CV, 2) + 1)
+    b[2] = b[1] * b[0] * (1.0 + 2 / alpha)
+
+    # run Takahasi-Takami method
+    tt = MGnCalc(NUM_OF_CHANNELS, ARRIVAL_RATE, b)
+    tt.run()
+
+    for i in range(1, NUM_OF_CHANNELS+2):
+        probs_mrx = tt._calc_up_probs(i)
+
+        print_mrx(probs_mrx)
+
+
+if __name__ == "__main__":
+    test_calc_up_probs()

most_queue-1.61/tests/units/test_weibull.py

@@ -0,0 +1,29 @@
+"""
+Test Weibull distribution
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+from most_queue.rand_distribution import Weibull
+
+if __name__ == "__main__":
+
+    MEAN = 1.0
+    coevs = [1.0, 2.1, 3.2]
+
+    fig, ax = plt.subplots()
+
+    for coev in coevs:
+        params = Weibull.get_params_by_mean_and_coev(MEAN, coev)
+
+        print(
+            f"Weibull params at CV= {coev:1.3f}: k = {params.k:1.3f} W = {params.W:1.3f}")
+        ts = np.linspace(0, 3 * coevs[len(coevs)-1], 100)
+        dfr = [Weibull.get_tail(params, t) for t in ts]
+
+        ax.plot(ts, dfr, label=f"$\\nu$  = {coev:1.1f}")
+
+    ax.set_xlabel('t')
+    ax.set_ylabel('Tail')
+    plt.legend()
+    plt.show()

{most_queue-1.60 → most_queue-1.61}/tutorials/queue_sim.ipynb

@@ -370,7 +370,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

most_queue-1.61/works/negative_queues/base_parameters.yaml

@@ -0,0 +1,21 @@
+accuracy: 1e-10
+arrival_rate: 
+    positive: 1.0
+    negative: 0.5
+num_of_jobs: 300000
+service:
+    cv:
+        base: 1.2
+        min: 0.3
+        max: 3
+        num_points: 20
+channels:
+    base: 3
+    min: 1
+    max: 10
+utilization:
+    base: 0.7
+    min: 0.1
+    max: 0.9
+    num_points: 20
+