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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most_queue
-Version: 1.58
+Version: 1.60
 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>
@@ -34,6 +34,7 @@ Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: numpy
 Requires-Dist: pandas
+Requires-Dist: pyyaml
 Requires-Dist: scipy==1.13.0
 Requires-Dist: tqdm
 Description-Content-Type: text/markdown

{most_queue-1.58 → most_queue-1.60}/most_queue/general/plots.py

@@ -42,11 +42,11 @@ def plot_sim_vs_calc_moments(xs: list[float], sim_results: list[float],
         errors = [100 * (w_sim - w_tt) / w_tt for w_sim,
                   w_tt in zip(sim_results, calc_results)]
 
-        ax.plot(xs, errors)
+        ax.plot(xs, errors, color='black')
         ax.set_ylabel(r"$\varepsilon$, %")
     else:
-        ax.plot(xs, sim_results, label="Sim")
-        ax.plot(xs, calc_results, label="Calc")
+        ax.plot(xs, sim_results, label="Sim", color='black', linestyle='--')
+        ax.plot(xs, calc_results, label="Calc", color='black')
         if is_waiting_time:
             ax.set_ylabel(r"$\omega_{1}$")
         else:

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

@@ -68,6 +68,10 @@ class MGnCalc:
         self.D = []
         self.Y = []
 
+        self.big_g = []
+        self.big_ag = []
+        self.big_bg = []
+
         self.w = None
 
     def _fill_cols(self):
@@ -109,13 +113,13 @@ class MGnCalc:
             for j in range(1, self.N):  # for all levels except the first.
 
                 # b':
-                self.b1[j] = np.dot(self.t[j - 1], self.AG[j])
+                self.b1[j] = np.dot(self.t[j - 1], self.big_ag[j])
 
                 # b":
                 if j != (self.N - 1):
-                    self.b2[j] = np.dot(self.t[j + 1], self.BG[j])
+                    self.b2[j] = np.dot(self.t[j + 1], self.big_bg[j])
                 else:
-                    self.b2[j] = np.dot(self.t[j - 1], self.BG[j])
+                    self.b2[j] = np.dot(self.t[j - 1], self.big_bg[j])
 
                 c = self._calculate_c(j)
 
@@ -128,7 +132,7 @@ class MGnCalc:
 
                 if self.R and j == (self.N - 1):
                     tA = np.dot(self.t[j - 1], self.A[j - 1])
-                    tag = np.dot(tA, self.G[j])
+                    tag = np.dot(tA, self.big_g[j])
                     tag_sum = 0
                     for t_i in range(tag.shape[1]):
                         tag_sum += tag[0, t_i]
@@ -142,7 +146,8 @@ class MGnCalc:
 
             self.x[0] = (1.0 + 0.0j) / self.z[1]
 
-            self.t[0] = self.x[0]*(np.dot(self.t[1], self.B[1]).dot(self.G[0]))
+            self.t[0] = self.x[0] * \
+                (np.dot(self.t[1], self.B[1]).dot(self.big_g[0]))
 
             x_max1 = np.max(self.x)
 
@@ -268,22 +273,22 @@ class MGnCalc:
             self.D.append(self._build_big_d_matrix(i))
 
     def _calc_g_matrices(self):
-        self.G = []
+        self.big_g = []
         for j in range(0, self.N):
-            self.G.append(np.linalg.inv(self.D[j] - self.C[j]))
+            self.big_g.append(np.linalg.inv(self.D[j] - self.C[j]))
 
     def _calc_ag_matrices(self):
-        self.AG = [0]
+        self.big_ag = [0]
         for j in range(1, self.N):
-            self.AG.append(np.dot(self.A[j - 1], self.G[j]))
+            self.big_ag.append(np.dot(self.A[j - 1], self.big_g[j]))
 
     def _calc_bg_matrices(self):
-        self.BG = [0]
+        self.big_bg = [0]
         for j in range(1, self.N):
             if j != (self.N - 1):
-                self.BG.append(np.dot(self.B[j + 1], self.G[j]))
+                self.big_bg.append(np.dot(self.B[j + 1], self.big_g[j]))
             else:
-                self.BG.append(np.dot(self.B[j], self.G[j]))
+                self.big_bg.append(np.dot(self.B[j], self.big_g[j]))
 
     def _calc_support_matrices(self):
         self._calc_g_matrices()

{most_queue-1.58 → most_queue-1.60}/most_queue/theory/negative/mgn_disaster.py

@@ -340,3 +340,74 @@ class MGnNegativeDisasterCalc(MGnCalc):
         v_broken = self.get_v_broken()
         w = self.get_w()
         return NegativeArrivalsResults(p=p, v=v, v_served=v_served, v_broken=v_broken, w=w)
+    
+    def run(self):
+        """
+        Run the algorithm.
+        """
+
+        self._fill_cols()
+        self._fill_t_b()
+        self._build_matrices()
+        self._initial_probabilities()
+
+        self.b1[0][0, 0] = 0.0 + 0.0j
+        self.b2[0][0, 0] = 0.0 + 0.0j
+        x_max1 = np.max(self.x)
+        x_max2 = 0.0 + 0.0j
+
+        self._calc_support_matrices()
+
+        self.num_of_iter_ = 0  # number of iterations
+
+        while np.fabs(x_max2.real - x_max1.real) >= self.e1:
+            x_max2 = x_max1
+            self.num_of_iter_ += 1
+
+            for j in range(1, self.N):  # for all levels except the first.
+
+                # b':
+                self.b1[j] = np.dot(self.t[j - 1], self.big_ag[j])
+
+                # b":
+                if j != (self.N - 1):
+                    self.b2[j] = np.dot(self.t[j + 1], self.big_bg[j])
+                else:
+                    self.b2[j] = np.dot(self.t[j - 1], self.big_bg[j])
+
+                c = self._calculate_c(j)
+
+                x_znam = np.dot(c, self.b1[j]) + self.b2[j]
+                self.x[j] = 0.0 + 0.0j
+                for k in range(x_znam.shape[1]):
+                    self.x[j] += x_znam[0, k]
+
+                self.x[j] = (1.0 + 0.0j) / self.x[j]
+
+                if self.R and j == (self.N - 1):
+                    tA = np.dot(self.t[j - 1], self.A[j - 1])
+                    tag = np.dot(tA, self.big_g[j])
+                    tag_sum = 0
+                    for t_i in range(tag.shape[1]):
+                        tag_sum += tag[0, t_i]
+                    self.z[j] = 1.0 / tag_sum
+                    self.t[j] = self.z[j] * tag
+
+                else:
+                    self.z[j] = np.dot(c, self.x[j])
+                    self.t[j] = np.dot(self.z[j], self.b1[j]) + \
+                        np.dot(self.x[j], self.b2[j])
+
+            self.x[0] = (1.0 + 0.0j) / self.z[1]
+
+            # Why ????
+            self.t[0] = self.x[0] * \
+                (np.dot(self.t[1], self.B[1]).dot(self.big_g[0]))
+
+            x_max1 = np.max(self.x)
+
+            if self.verbose:
+                print(f"End iter # {self.num_of_iter_}")
+
+        self._calculate_p()
+        self._calculate_y()

{most_queue-1.58 → most_queue-1.60}/most_queue/theory/negative/mgn_rcs.py

@@ -4,6 +4,7 @@ Calculate M/H2/n queue with negative jobs with RCS discipline,
 """
 
 import numpy as np
+import math
 
 from most_queue.rand_distribution import H2Distribution, H2Params
 from most_queue.theory.fifo.mgn_takahasi import MGnCalc
@@ -206,3 +207,74 @@ class MGnNegativeRCSCalc(MGnCalc):
                 (num - i) * self.mu[0] + i * self.mu[1]
 
         return output
+    
+    def run(self):
+        """
+        Run the algorithm.
+        """
+
+        self._fill_cols()
+        self._fill_t_b()
+        self._build_matrices()
+        self._initial_probabilities()
+
+        self.b1[0][0, 0] = 0.0 + 0.0j
+        self.b2[0][0, 0] = 0.0 + 0.0j
+        x_max1 = np.max(self.x)
+        x_max2 = 0.0 + 0.0j
+
+        self._calc_support_matrices()
+
+        self.num_of_iter_ = 0  # number of iterations
+
+        while math.fabs(x_max2.real - x_max1.real) >= self.e1:
+            x_max2 = x_max1
+            self.num_of_iter_ += 1
+
+            for j in range(1, self.N):  # for all levels except the first.
+
+                # b':
+                self.b1[j] = np.dot(self.t[j - 1], self.big_ag[j])
+
+                # b":
+                if j != (self.N - 1):
+                    self.b2[j] = np.dot(self.t[j + 1], self.big_bg[j])
+                else:
+                    self.b2[j] = np.dot(self.t[j - 1], self.big_bg[j])
+
+                c = self._calculate_c(j)
+
+                x_znam = np.dot(c, self.b1[j]) + self.b2[j]
+                self.x[j] = 0.0 + 0.0j
+                for k in range(x_znam.shape[1]):
+                    self.x[j] += x_znam[0, k]
+
+                self.x[j] = (1.0 + 0.0j) / self.x[j]
+
+                if self.R and j == (self.N - 1):
+                    tA = np.dot(self.t[j - 1], self.A[j - 1])
+                    tag = np.dot(tA, self.big_g[j])
+                    tag_sum = 0
+                    for t_i in range(tag.shape[1]):
+                        tag_sum += tag[0, t_i]
+                    self.z[j] = 1.0 / tag_sum
+                    self.t[j] = self.z[j] * tag
+
+                else:
+                    self.z[j] = np.dot(c, self.x[j])
+                    self.t[j] = np.dot(self.z[j], self.b1[j]) + \
+                        np.dot(self.x[j], self.b2[j])
+
+            self.x[0] = (1.0 + 0.0j) / self.z[1]
+
+            # Why?, because t[0] = [1.0] always
+            # self.t[0] = self.x[0] * \
+            #     (np.dot(self.t[1], self.B[1]).dot(self.big_g[0]))
+
+            x_max1 = np.max(self.x)
+
+            if self.verbose:
+                print(f"End iter # {self.num_of_iter_}")
+
+        self._calculate_p()
+        self._calculate_y()

{most_queue-1.58 → most_queue-1.60}/most_queue/theory/vacations/mgn_with_h2_delay_cold_warm.py

@@ -21,7 +21,7 @@ class MGnH2ServingColdWarmDelay:
     with arbitrary coefficients of variation (>1, <=1).
     """
 
-    def __init__(self, l, b, b_warm, b_cold, b_cold_delay, n, buffer=None, 
+    def __init__(self, l, b, b_warm, b_cold, b_cold_delay, n, buffer=None,
                  N=150, accuracy=1e-6, dtype="c16",
                  verbose=False, stable_w_pls=False, w_pls_dt=1e-3):
         """
@@ -136,6 +136,38 @@ class MGnH2ServingColdWarmDelay:
         self._build_matrices()
         self._initial_probabilities()
 
+    def get_probs_of_servers_busy(self):
+        """
+        Return probabilities of servers being busy.
+        prob[i] - probability that i number of servers is busy.
+        """
+
+        probs = np.zeros((self.n + 1), dtype=self.dt)
+
+        # servers are not busy, when system in [0,0] state, in cooling, and warming up states.
+
+        probs[0] += self.Y[0][0, 0] + self.Y[0][0, 3] + self.Y[0][0, 4]
+
+        # when cooling delay, 1 server is running
+
+        probs[1] += self.Y[0][0, 1] + self.Y[0][0, 2] 
+        
+        for k in range(1, self.n):
+            probs[k] += np.sum(self.Y[k][0, 2:k+3])
+
+        for k in range(1, self.N):
+            # warm-ups
+            for i in range(2):
+                probs[0] += self.Y[k][0, i]
+
+            # coolings
+            probs[0] += self.Y[k][0, -1] + self.Y[k][0, -2]
+
+        probs[-1] = 1.0 - np.sum(probs)
+        probs = probs.tolist()
+        return [prob.real for prob in probs]
+
+
     def run(self):
         """
         Запускает расчет

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "most_queue"
-version = "1.58"
+version = "1.60"
 authors = [
   { name="Xabarov Roman", email="xabarov1985@gmail.com" },
 ]
@@ -25,7 +25,8 @@ dependencies = [
   "scipy==1.13.0",
   "tqdm",
   "graphviz",
-  "networkx"
+  "networkx",
+  "pyyaml",
 ]
 [project.urls]
 "Homepage" = "https://github.com/xabarov/most-queue"

most_queue-1.60/requirements.txt

@@ -0,0 +1,169 @@
+accessible-pygments==0.0.5
+alabaster==1.0.0
+anyio==4.9.0
+argon2-cffi==23.1.0
+argon2-cffi-bindings==21.2.0
+arrow==1.3.0
+asttokens==3.0.0
+async-lru==2.0.5
+attrs==25.3.0
+autodocsumm==0.2.14
+babel==2.17.0
+beautifulsoup4==4.13.4
+bleach==6.2.0
+build==1.2.2.post1
+certifi==2025.1.31
+cffi==1.17.1
+charset-normalizer==3.4.1
+click==8.1.8
+colorama==0.4.6
+comm==0.2.2
+contourpy==1.3.2
+cryptography==44.0.2
+cycler==0.12.1
+debugpy==1.8.14
+decorator==5.2.1
+defusedxml==0.7.1
+distlib==0.3.9
+docutils==0.21.2
+executing==2.2.0
+fastjsonschema==2.21.1
+filelock==3.18.0
+fonttools==4.57.0
+fqdn==1.5.1
+graphviz==0.20.3
+h11==0.14.0
+hatch==1.14.1
+hatchling==1.27.0
+httpcore==1.0.8
+httpx==0.28.1
+hyperlink==21.0.0
+id==1.5.0
+idna==3.10
+imagesize==1.4.1
+iniconfig==2.1.0
+ipykernel==6.29.5
+ipython==9.1.0
+ipython_pygments_lexers==1.1.1
+ipywidgets==8.1.6
+isoduration==20.11.0
+jaraco.classes==3.4.0
+jaraco.context==6.0.1
+jaraco.functools==4.1.0
+jedi==0.19.2
+jeepney==0.9.0
+Jinja2==3.1.6
+json5==0.12.0
+jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+jupyter==1.1.1
+jupyter-console==6.6.3
+jupyter-events==0.12.0
+jupyter-lsp==2.2.5
+jupyter_client==8.6.3
+jupyter_core==5.7.2
+jupyter_server==2.15.0
+jupyter_server_terminals==0.5.3
+jupyterlab==4.4.0
+jupyterlab_pygments==0.3.0
+jupyterlab_server==2.27.3
+jupyterlab_widgets==3.0.14
+keyring==25.6.0
+kiwisolver==1.4.8
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.1
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+mistune==3.1.3
+more-itertools==10.6.0
+-e git+https://github.com/xabarov/most-queue@1f4278b54c746b025a324422455e129885e943e4#egg=most_queue
+nbclient==0.10.2
+nbconvert==7.16.6
+nbformat==5.10.4
+nest-asyncio==1.6.0
+networkx==3.4.2
+nh3==0.2.21
+notebook==7.4.0
+notebook_shim==0.2.4
+numpy==2.2.5
+overrides==7.7.0
+packaging==25.0
+pandas==2.2.3
+pandocfilters==1.5.1
+parso==0.8.4
+pathspec==0.12.1
+pexpect==4.9.0
+pillow==11.2.1
+platformdirs==4.3.7
+pluggy==1.5.0
+prometheus_client==0.21.1
+prompt_toolkit==3.0.51
+psutil==7.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pycparser==2.22
+pydata-sphinx-theme==0.15.4
+Pygments==2.19.1
+pyparsing==3.2.3
+pyproject_hooks==1.2.0
+pytest==8.3.5
+python-dateutil==2.9.0.post0
+python-json-logger==3.3.0
+pytz==2025.2
+PyYAML==6.0.2
+pyzmq==26.4.0
+readme_renderer==44.0
+referencing==0.36.2
+requests==2.32.3
+requests-toolbelt==1.0.0
+rfc3339-validator==0.1.4
+rfc3986==2.0.0
+rfc3986-validator==0.1.1
+rich==14.0.0
+roman-numerals-py==3.1.0
+rpds-py==0.24.0
+scipy==1.13.0
+SecretStorage==3.3.3
+Send2Trash==1.8.3
+setuptools==79.0.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+snowballstemmer==2.2.0
+soupsieve==2.7
+Sphinx==8.2.3
+sphinx-book-theme==1.1.4
+sphinx-rtd-theme==3.0.2
+sphinxcontrib-applehelp==2.0.0
+sphinxcontrib-devhelp==2.0.0
+sphinxcontrib-htmlhelp==2.1.0
+sphinxcontrib-jquery==4.1
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==2.0.0
+sphinxcontrib-serializinghtml==2.0.0
+stack-data==0.6.3
+terminado==0.18.1
+tinycss2==1.4.0
+tomli_w==1.2.0
+tomlkit==0.13.2
+tornado==6.4.2
+tqdm==4.67.1
+traitlets==5.14.3
+trove-classifiers==2025.4.11.15
+twine==6.1.0
+types-python-dateutil==2.9.0.20241206
+typing_extensions==4.13.2
+tzdata==2025.2
+uri-template==1.3.0
+urllib3==2.4.0
+userpath==1.9.2
+uv==0.6.14
+virtualenv==20.30.0
+wcwidth==0.2.13
+webcolors==24.11.1
+webencodings==0.5.1
+websocket-client==1.8.0
+widgetsnbextension==4.0.14
+zstandard==0.23.0

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

@@ -1,7 +1,7 @@
 from setuptools import find_packages, setup
 
 setup(name='most-queue',
-      version='1.58',
+      version='1.60',
       description='Software package for calculation and simulation of queuing systems',
       author='Xabarov Roman',
       author_email='xabarov1985@gmail.com',
@@ -23,6 +23,7 @@ setup(name='most-queue',
           "tqdm",
           "graphviz",
           "networkx",
+          'pyyaml',
       ],
       include_package_data=True,
       zip_safe=False)

most_queue-1.60/tests/cold_warm_delay_params.yaml

@@ -0,0 +1,52 @@
+arrival_rate: 1.0
+jobs_per_sim: 300000
+sim_to_average: 1
+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
+cooling:
+    cv:
+        base: 1.2
+        min: 0.3
+        max: 3
+        num_points: 20
+    mean:
+        base: 3.0
+        min: 0.1
+        max: 5
+        num_points: 20
+delay:
+    cv:
+        base: 1.2
+        min: 0.3
+        max: 3
+        num_points: 20
+    mean:
+        base: 3.0
+        min: 0.1
+        max: 5
+        num_points: 20
+
+warmup:
+    cv:
+        base: 1.2
+        min: 0.3
+        max: 3
+        num_points: 20
+    mean:
+        base: 3.0
+        min: 0.1
+        max: 5
+        num_points: 20

{most_queue-1.58 → most_queue-1.60}/tests/test_mgn_rcs.py

@@ -8,10 +8,10 @@ from most_queue.rand_distribution import GammaDistribution
 from most_queue.sim.negative import NegativeServiceType, QsSimNegatives
 from most_queue.theory.negative.mgn_rcs import MGnNegativeRCSCalc
 
-ARRIVAL_RATE_NEGATIVE = 0.3
+ARRIVAL_RATE_NEGATIVE = 0.9
 ARRIVAL_RATE_POSITIVE = 1.0
 NUM_OF_JOBS = 300000
-NUM_OF_CHANNELS = 3
+NUM_OF_CHANNELS = 5
 UTILIZATION = 0.7
 SERVICE_TIME_CV = 2.1
 
@@ -29,8 +29,6 @@ def test_mgn():
     b[1] = math.pow(b[0], 2) * (math.pow(SERVICE_TIME_CV, 2) + 1)
     b[2] = b[1] * b[0] * (1.0 + 2 / alpha)
 
-    print(f'Service time moments: {b}')
-
     # Run simulation
     queue_sim = QsSimNegatives(
         NUM_OF_CHANNELS, NegativeServiceType.RCS)
@@ -71,7 +69,7 @@ def test_mgn():
     times_print(v_sim_broken, v_calc_broken, is_w=False,
                 header='Broken sojourn time')
     times_print(w_sim, w_calc)
-
+    
 
 if __name__ == "__main__":
     test_mgn()