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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: most_queue
-Version: 1.61
+Version: 1.62
 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>
@@ -41,7 +41,7 @@ Description-Content-Type: text/markdown
 
 # Queueing Systems: Simulation & Numerical Methods 🔄
 
-![Queue](assets/queue_long.png)
+![Queue](assets/3.gif)
 
 A Python package for simulating and analyzing queueing systems (QS) and networks. 
 
@@ -129,8 +129,8 @@ Most_queue consists of two main parts:
 
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
-| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
-| 2. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
+| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_sim.py) |  |
+| 2. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_sim.py) |  |
 
 
 ### Others
@@ -139,7 +139,10 @@ Most_queue consists of two main parts:
 | 1.  | M<sup>x</sup>/M/1          |  Solving for the of M<sup>x</sup>/M/1 QS with batch arrival    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_batch.py) | |
 | 2.  | 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) | |
 | 3. | M/M/1/N          |  Solving for the Engset model for M/M/1 with a finite number of sources.     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_engset.py) | |
-| 4.  | General Network |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_im_prty.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/network_with_priorities.ipynb) |
+| 4.  | Queuing Network |  Numerical calculation of queuing network     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_no_prty.py) |  |
+| 5.  | Queuing Network with Priorities  |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_sim_prty.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/network_with_priorities.ipynb) |
+| 6.  | Queuing Network Optimization  | Optimization of queuing network transition matrix     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_opt.py) |  |
+
 
 ---
 

{most_queue-1.61 → most_queue-1.62}/README.md

@@ -1,6 +1,6 @@
 # Queueing Systems: Simulation & Numerical Methods 🔄
 
-![Queue](assets/queue_long.png)
+![Queue](assets/3.gif)
 
 A Python package for simulating and analyzing queueing systems (QS) and networks. 
 
@@ -88,8 +88,8 @@ Most_queue consists of two main parts:
 
 | #   | Kendall Notations |  Description      | Example | Tutorial |
 |-----|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|-------------------|
-| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
-| 2. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_im.py) |  |
+| 1. | M/M/c/Fork-Join       |  Solving for Fork-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_sim.py) |  |
+| 2. | M/G/c/Split-Join       |  Solving for Split-Join queueing system      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_fj_sim.py) |  |
 
 
 ### Others
@@ -98,7 +98,10 @@ Most_queue consists of two main parts:
 | 1.  | M<sup>x</sup>/M/1          |  Solving for the of M<sup>x</sup>/M/1 QS with batch arrival    | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_batch.py) | |
 | 2.  | 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) | |
 | 3. | M/M/1/N          |  Solving for the Engset model for M/M/1 with a finite number of sources.     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_engset.py) | |
-| 4.  | General Network |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_im_prty.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/network_with_priorities.ipynb) |
+| 4.  | Queuing Network |  Numerical calculation of queuing network     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_no_prty.py) |  |
+| 5.  | Queuing Network with Priorities  |  Numerical calculation of queuing network with priorities in nodes      | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_sim_prty.py) | [link](https://github.com/xabarov/most-queue/blob/main/tutorials/network_with_priorities.ipynb) |
+| 6.  | Queuing Network Optimization  | Optimization of queuing network transition matrix     | [link](https://github.com/xabarov/most-queue/blob/main/tests/test_network_opt.py) |  |
+
 
 ---
 

{most_queue-1.61 → most_queue-1.62}/most_queue/general/tables.py

@@ -320,3 +320,5 @@ def print_mrx(mrx, is_short=False):
                 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(f'{Style.RESET_ALL}')

{most_queue-1.61 → most_queue-1.62}/most_queue/misc/flow_sum.py

@@ -1,9 +1,9 @@
 import matplotlib
 import matplotlib.pyplot as plt
 
-from most_queue.theory.utils.flow_sum import SummatorNumeric
 from most_queue.rand_distribution import GammaDistribution
 from most_queue.sim.flow_sum import FlowSumSim
+from most_queue.theory.utils.flow_sum import SummatorNumeric
 
 matplotlib.use('TkAgg')
 
@@ -19,7 +19,7 @@ def test():
     mean = 1  # среднее каждого потока
     num_of_jobs = 400000  # количество заявок для ИМ
     is_semi = False  # True, если необходимо использовать метод семиинвариантов вместо H2
-    distr_im = "Gamma"  # распределение, используемое для ИМ
+    distr_sim = "Gamma"  # распределение, используемое для ИМ
 
     # число суммируемых потоков
     ns = [x + 2 for x in range(n_nums - 1)]
@@ -38,7 +38,7 @@ def test():
     # i - кол-во суммируемых потоков, j - номер начального момента
 
     # ИМ
-    s_sim = FlowSumSim(a, distr=distr_im, num_of_jobs=num_of_jobs)
+    s_sim = FlowSumSim(a, distr=distr_sim, num_of_jobs=num_of_jobs)
     # в  s_sim._flows[i][j] содержатся начальные моменты суммируемых потокоы,
     s_sim.sum_flows()
     # i - кол-во суммируемых потоков, j - номер начального момента

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

@@ -931,7 +931,8 @@ class ErlangDistribution(Distribution):
     @staticmethod
     def get_params_by_mean_and_coev(f1: float, coev: float) -> ErlangParams:
         """
-        Method selects the parameters of the Erlang distribution by mean and coefficient of variation.
+        Method selects the parameters of the Erlang distribution 
+        by mean and coefficient of variation.
         """
         f = [0, 0]
         f[0] = f1

{most_queue-1.61 → most_queue-1.62}/most_queue/sim/base.py

@@ -105,7 +105,8 @@ class QsSim:
 
         self.is_set_source_params = True
 
-        self.source = create_distribution(params, kendall_notation, self.generator)
+        self.source = create_distribution(
+            params, kendall_notation, self.generator)
 
         self.arrival_time = self.source.generate()
 
@@ -137,14 +138,17 @@ class QsSim:
                             self.server_kendall_notation,
                             self.server_params, self.n)
 
-    def send_task_to_channel(self, is_warm_start=False):
+    def send_task_to_channel(self, is_warm_start=False, tsk=None):
         """
         Sends a job to the service channel
         """
+
+        if tsk is None:
+            tsk = Task(self.ttek)
+            tsk.wait_time = 0
+
         for s in self.servers:
             if s.is_free:
-                tsk = Task(self.ttek)
-                tsk.wait_time = 0
                 self.taked += 1
                 self.refresh_w_stat(tsk.wait_time)
                 self.zero_wait_arrivals_num += 1
@@ -159,42 +163,53 @@ class QsSim:
 
                 break
 
-    def send_task_to_queue(self):
+    def send_task_to_queue(self, new_tsk=None):
         """
         Send Task to Queue
         """
-        if self.buffer is None:  # queue length is not specified, i.e. infinite queue
+
+        if new_tsk is None:
             new_tsk = Task(self.ttek)
             new_tsk.start_waiting_time = self.ttek
+
+        if self.buffer is None:  # queue length is not specified, i.e. infinite queue
+
             self.queue.append(new_tsk)
         else:
             if self.queue.size() < self.buffer:
-                new_tsk = Task(self.ttek)
-                new_tsk.start_waiting_time = self.ttek
                 self.queue.append(new_tsk)
             else:
                 self.dropped += 1
                 self.in_sys -= 1
 
-    def arrival(self):
+    def arrival(self, moment=None, ts=None):
         """
         Actions upon arrival of the job by the QS.
         """
-
+        
         self.arrived += 1
         self.p[self.in_sys] += self.arrival_time - self.ttek
 
-        self.in_sys += 1
-        self.ttek = self.arrival_time
-        self.arrival_time = self.ttek + self.source.generate()
+        if moment:
+            self.ttek = moment
+            ts.arr_time = moment
+            ts.wait_time = 0
+            ts.start_waiting_time = -1
+            ts.time_to_end_service = 0
+            
+        else:
+            self.ttek = self.arrival_time
+            self.arrival_time = self.ttek + self.source.generate()
 
+        self.in_sys += 1
+        
         if self.free_channels == 0:
-            self.send_task_to_queue()
+            self.send_task_to_queue(new_tsk=ts)
 
         else:  # there are free channels:
-            self.send_task_to_channel()
+            self.send_task_to_channel(tsk=ts)
 
-    def serving(self, c):
+    def serving(self, c, is_network=False):
         """
         Actions upon receipt of a service job with - channel number
         """
@@ -219,9 +234,12 @@ class QsSim:
                 self.refresh_busy_stat(self.ttek - self.start_busy)
 
         if self.queue.size() != 0:
-            self.send_head_of_queue_to_channel(c)
+            self.send_head_of_queue_to_channel(c, is_network=is_network)
+            
+        if is_network:
+            return end_ts
 
-    def send_head_of_queue_to_channel(self, channel_num):
+    def send_head_of_queue_to_channel(self, channel_num, is_network=False):
         """
         Send first Task (head of queue) to Channel
         """
@@ -232,6 +250,8 @@ class QsSim:
 
         self.taked += 1
         que_ts.wait_time += self.ttek - que_ts.start_waiting_time
+        if is_network:
+            que_ts.wait_network += self.ttek - que_ts.start_waiting_time
         self.refresh_w_stat(que_ts.wait_time)
 
         self.servers[channel_num].start_service(que_ts, self.ttek)

most_queue-1.62/most_queue/sim/networks/network.py

@@ -0,0 +1,181 @@
+"""
+Simulation of a priority network with priorities and multiple channels.
+"""
+import math
+
+import numpy as np
+from colorama import Fore, Style, init
+from tqdm import tqdm
+
+from most_queue.rand_distribution import ExpDistribution
+from most_queue.sim.base import QsSim
+from most_queue.sim.utils.tasks import Task
+
+init()
+
+
+class NetworkSimulator:
+    """
+    Simulation of network with multiple channels in each node.
+    """
+
+    def __init__(self, arrival_rate: float, R: np.matrix, n: list[int],
+                 serv_params):
+        """
+        arrival_rate: arrival rate of tasks.
+
+        R: routing matrix
+        n: list of number of channels in each node.
+
+        serv_params: list of dictionaries with service parameters for each node 
+            [m][dict(type, params)]
+            where m - node number, 
+            type - distribution type, params - distribution parameters.
+        """
+        self.arrival_time = arrival_rate
+        self.R = R  
+        self.n_num = len(n)  # number of nodes
+        self.nodes = n  # n[i] - number of channels in node i
+
+        self.serv_params = serv_params
+
+        self.qs = []
+
+        for m in range(self.n_num):
+            self.qs.append(QsSim(n[m]))
+            self.qs[m].set_servers(serv_params[m]['params'], kendall_notation=serv_params[m]['type'])
+
+        self.source = ExpDistribution(self.arrival_time)
+        self.arrival_time = self.source.generate()
+        self.v_network = [0.0] * 3
+        self.w_network = [0.0] * 3
+
+        self.ttek = 0
+        self.total = 0
+        self.served = 0
+        self.in_sys = 0
+        self.arrived = 0
+
+    def choose_next_node(self, current_node):
+        """
+        Choose the next node for a task based on the current node
+        :param current_node: The current node of the task.
+        :return: The index of the next node.
+        """
+        sum_p = 0
+        p = np.random.rand()
+        for i in range(self.R.shape[0]):
+            sum_p += self.R[current_node + 1, i]
+            if sum_p > p:
+                return i
+        return 0
+
+    def refresh_v_stat(self, new_a):
+        """
+        Refresh sojourn time statistics
+        :param new_a: The new arrival time.
+        """
+        factor = (1.0 - (1.0 / self.served))
+        a_pow = [math.pow(new_a, i + 1) for i in range(3)]
+        for i in range(3):
+            self.v_network[i] = self.v_network[i] * \
+                factor + a_pow[i] / self.served
+
+    def refresh_w_stat(self, new_a):
+        """
+        Refresh waiting time statistics 
+        :param new_a: The new arrival time.
+
+        """
+        factor = (1.0 - (1.0 / self.served))
+        a_pow = [math.pow(new_a, i + 1) for i in range(3)]
+        for i in range(3):
+            self.w_network[i] = self.w_network[i] * \
+                factor + a_pow[i] / self.served
+
+    def run_one_step(self):
+        """
+        Run one step of the simulation.
+        """
+        num_of_serv_ch_earlier = -1  # номер канала узла, мин время до окончания обслуживания
+        num_of_node_earlier = -1  # номер узла, в котором раньше всех закончится обслуживание
+        arrival_earlier = 1e10  # момент прибытия ближайшего
+        serving_earlier = 1e10  # момент ближайшего обслуживания
+
+        if self.arrival_time < arrival_earlier:
+            arrival_earlier = self.arrival_time
+
+        for node in range(self.n_num):
+            for c in range(self.nodes[node]):
+                if self.qs[node].servers[c].time_to_end_service < serving_earlier:
+                    serving_earlier = self.qs[node].servers[c].time_to_end_service
+                    num_of_serv_ch_earlier = c
+                    num_of_node_earlier = node
+
+        if arrival_earlier < serving_earlier:
+            self.on_arrival(arrival_earlier)
+        else:
+            self.on_serving(serving_earlier,
+                            num_of_serv_ch_earlier, num_of_node_earlier)
+
+    def on_arrival(self, arrival_earlier):
+        """
+        Handle arrival event
+        """
+        self.ttek = arrival_earlier
+        self.arrived += 1
+        self.in_sys += 1
+
+        self.arrival_time = self.ttek + self.source.generate()
+
+        next_node = self.choose_next_node(-1)
+
+        ts = Task(self.ttek, is_network=True)
+
+        self.qs[next_node].arrival(self.ttek, ts)
+
+    def on_serving(self, serving_earlier, num_of_serv_ch_earlier, num_of_node_earlier):
+        """
+        Handle serving event
+        """
+        self.ttek = serving_earlier
+        ts = self.qs[num_of_node_earlier].serving(
+            num_of_serv_ch_earlier, True)
+
+        next_node = self.choose_next_node(num_of_node_earlier)
+
+        if next_node == self.n_num:
+            self.served += 1
+            self.in_sys -= 1
+
+            self.refresh_v_stat(self.ttek - ts.arr_network)
+            self.refresh_w_stat(ts.wait_network)
+
+        else:
+            self.qs[next_node].arrival(self.ttek, ts)
+
+    def run(self, job_served, is_real_served=True):
+        """
+        Run simulation
+        """
+        if is_real_served:
+            last_percent = 0
+
+            with tqdm(total=100) as pbar:
+                while self.served < job_served:
+                    self.run_one_step()
+                    percent = int(100*(self.served/job_served))
+                    if last_percent != percent:
+                        last_percent = percent
+                        pbar.update(1)
+                        pbar.set_description(Fore.MAGENTA + '\rJob served: ' +
+                                             Fore.YELLOW + f'{self.served}/{job_served}' + Fore.LIGHTGREEN_EX)
+        else:
+            print(Fore.GREEN + '\rStart simulation')
+            print(Style.RESET_ALL)
+
+            for _ in tqdm(range(job_served)):
+                self.run_one_step()
+
+            print(Fore.GREEN + '\rSimulation is finished')
+            print(Style.RESET_ALL)

{most_queue-1.61 → most_queue-1.62}/most_queue/sim/priority.py

@@ -60,12 +60,9 @@ class PriorityQueueSimulator:
 
         # probability of states of the system (number of requests in it j):
         self.p = []
-        if self.prty_type == "No":
-            # for no priority system, we have one queue for all classes of requests:
-            self.queue = []  # queue of Task's
-        else:
-            for _ in range(self.k):
-                self.queue.append([])
+        
+        for _ in range(self.k):
+            self.queue.append([])
 
         for _ in range(self.k):
             self.busy.append([0, 0, 0])
@@ -369,12 +366,12 @@ class PriorityQueueSimulator:
         """
         if not self.buffer:  # no buffer, infinite queue length
             new_tsk.start_waiting_time = self.ttek
-            self.queue.append(new_tsk)
+            self.queue[k].append(new_tsk)
         else:
 
             if len(self.queue) < self.buffer:
                 new_tsk.start_waiting_time = self.ttek
-                self.queue.append(new_tsk)
+                self.queue[k].append(new_tsk)
             else:
                 self.dropped[k] += 1
                 self.in_sys[k] -= 1
@@ -473,13 +470,14 @@ class PriorityQueueSimulator:
         self.refresh_w_stat(k, end_ts.wait_time)
         self.in_sys[k] -= 1
 
-        if len(self.queue[k]) == 0 and self.free_channels == 1:
-            if self.in_sys[k] == self.n - 1 and self.class_busy_started != -1:
-                # End of busy period
-                self.busy_moments[k] += 1
-                self.refresh_busy_stat(k, self.ttek - self.start_busy)
 
         if self.prty_type != "No":
+            if len(self.queue[k]) == 0 and self.free_channels == 1:
+                if self.in_sys[k] == self.n - 1 and self.class_busy_started != -1:
+                    # End of busy period
+                    self.busy_moments[k] += 1
+                    self.refresh_busy_stat(k, self.ttek - self.start_busy)
+
 
             start_number = 0
             if self.prty_type == "PR" or self.prty_type == "RS" or self.prty_type == "RW":
@@ -507,10 +505,15 @@ class PriorityQueueSimulator:
                     self.free_channels -= 1
                     break
         else:
+            if len(self.queue[0]) == 0 and self.free_channels == 1:
+                if self.in_sys == self.n - 1 and self.class_busy_started != -1:
+                    # End of busy period
+                    self.busy_moments += 1
+                    self.refresh_busy_stat(0, self.ttek - self.start_busy)
             # one queue
-            if len(self.queue) != 0:
+            if len(self.queue[0]) != 0:
 
-                que_ts = self.queue.pop(0)
+                que_ts = self.queue[0].pop(0)
 
                 if self.free_channels == 1 and k != end_ts.k:
                     self.start_busy[k] = self.ttek

{most_queue-1.61 → most_queue-1.62}/most_queue/sim/utils/tasks.py

@@ -10,10 +10,15 @@ class Task:
     """
     id = 0
 
-    def __init__(self, arr_time):
+    def __init__(self, arr_time, is_network=False):
         """
         :param arr_time: Момент прибытия в СМО
         """
+        
+        if is_network:
+            self.arr_network = arr_time
+            self.wait_network = 0
+            
         self.arr_time = arr_time
 
         self.start_waiting_time = 0
@@ -115,8 +120,8 @@ class ImpatientTask(Task):
     A task that can leave the queue if it has not been served by a server within a certain time.
     """
 
-    def __init__(self, arr_time, moment_to_leave):
-        super().__init__(arr_time)
+    def __init__(self, arr_time, moment_to_leave, is_network=False):
+        super().__init__(arr_time, is_network)
         self.moment_to_leave = moment_to_leave
 
     def __str__(self):
@@ -132,8 +137,8 @@ class ImpatientTaskWithRepairs(ImpatientTask):
     Tracking if the task arrived in repair mode or not.
     """
 
-    def __init__(self, arr_time, moment_to_leave, arrive_in_repair_mode=False):
-        super().__init__(arr_time, moment_to_leave)
+    def __init__(self, arr_time, moment_to_leave, arrive_in_repair_mode=False, is_network=False):
+        super().__init__(arr_time, moment_to_leave, is_network)
         self.arrive_in_repair_mode = arrive_in_repair_mode
         self.end_repair_time = 1e16
         self.is_end_repair = False

{most_queue-1.61 → most_queue-1.62}/most_queue/theory/fifo/ek_d_n.py

@@ -16,7 +16,7 @@ class EkDn:
 
     def __init__(self, erlang_params: ErlangParams, b, n, e=1e-12, p_num=100):
         """
-        l, k - parameters of the Erlang input request distribution
+        erlang_params - parameters of the Erlang input request distribution
         b - service time in a channel
         n - number of channels
         e - accuracy of calculations

most_queue-1.62/most_queue/theory/networks/open_network.py

@@ -0,0 +1,126 @@
+"""
+Calculates queueing network.
+"""
+import numpy as np
+
+from most_queue.rand_distribution import GammaDistribution
+from most_queue.theory.fifo.mgn_takahasi import MGnCalc
+from most_queue.theory.fifo.mmnr import MMnrCalc
+from most_queue.theory.utils.diff5dots import diff5dots
+from most_queue.theory.utils.transforms import lst_gamma
+
+
+class OpenNetworkCalc:
+    """
+    Calculates queueing network.
+    """
+
+    def __init__(self, R: np.matrix, b: list[list[float]],
+                 n: list[int], arrival_rate: float):
+        """
+        R: routing matrix
+        b: list of theoretical moments of service time distribution for each node.
+        n: list of number of channels in each node.
+        L: arrival intensitiy.
+        """
+        self.R = R
+        self.b = b
+        self.n = n
+        self.arrival_rate = arrival_rate
+
+    def balance_equation(self, L, R):
+        """
+        Calc the balance equation for the network.
+        """
+        # Create copies to avoid modifying original matrices
+        L = np.array(L)
+        R = np.array(R)
+
+        # Identify null columns using vectorized operation
+        null_mask = np.all(np.abs(R) < 1e-6, axis=0)
+        _null_numbers = np.where(null_mask)[0]
+
+        # Remove null columns and corresponding rows
+        R_nonull = R[:, ~null_mask]
+        R_nonull = R_nonull[~null_mask, :]
+
+        n_rows_mod, n_cols_mod = R_nonull.shape
+
+        # Calculate b and Q matrices using efficient indexing
+        if n_rows_mod > 0:
+            b = np.dot(L, R_nonull[0, :-1])
+            Q = R_nonull[1:, :-1]
+            A = np.eye(n_cols_mod - 1) - Q.T
+            intensities = np.linalg.solve(A, b)
+        else:
+            intensities = np.array([], dtype=np.float64)
+
+        # Create output array with zeros for null columns
+        l_out = np.zeros(R.shape[1] - 1, dtype=np.float64)
+
+        # Fill non-null columns
+        _valid_indices = np.arange(len(intensities))
+        l_out[~null_mask[:-1]] = intensities.flatten()
+
+        return l_out
+
+    def run(self, is_markovian=False):
+        """
+        Run the simulation and calculate the results.
+        """
+        res = {}
+
+        nodes = len(self.n)
+        res['loads'] = [0.0] * nodes
+        res['v'] = []
+
+        intensities = self.balance_equation(self.arrival_rate, self.R)
+
+        res['v_node'] = []
+        for i in range(nodes):
+            node_arrival_rate = intensities[i]
+            b1_node = self.b[i][0]
+
+            res['loads'][i] = node_arrival_rate * b1_node / self.n[i]
+            
+            if is_markovian:
+                mmnr_calc = MMnrCalc(l=node_arrival_rate, mu=1/b1_node, n=self.n[i], r=100)
+                res['v_node'].append(mmnr_calc.get_v())
+            else:
+                mgn_calc = MGnCalc(n=self.n[i], l=node_arrival_rate, b=self.b[i])
+                mgn_calc.run()
+                res['v_node'].append(mgn_calc.get_v())
+
+        h = 0.0001
+        s = [h * (i + 1) for i in range(4)]
+
+        I = np.eye(nodes)
+        N = np.zeros((nodes, nodes))
+        P = self.R[0, :nodes].reshape(1, -1)
+        T = self.R[1:, nodes].reshape(-1, 1)
+        Q = self.R[1:, :nodes]
+
+        gamma_mu_alpha = [GammaDistribution.get_params(
+            [res['v_node'][i][0], res['v_node'][i][1]]) for i in range(nodes)]
+
+        g_PLS = []
+        for i in range(4):
+            N = np.diag([lst_gamma(
+                gamma_mu_alpha[j], s[i]) for j in range(nodes)])
+
+            G = np.dot(N, Q)
+            FF = I - G
+            F = np.linalg.inv(FF)
+            F = np.dot(P, np.dot(F, np.dot(N, T)))
+            g_PLS.append(F[0, 0])
+
+        res['v'] = diff5dots(g_PLS, h)
+        res['v'][0] = -res['v'][0]
+        res['v'][2] = -res['v'][2]
+        
+        res['intensities'] = intensities
+        res['v'] = [float(v) for v in res['v']]
+        res['loads'] = [float(l) for l in res['loads']]
+
+
+        return res