masud_sir_part/single_server_queue_system.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Detail Explanation for below code\n",
    "The `SingleServerQueue` class represents the single-server queuing system. It is initialized with the simulation environment (`env`), the average arrival rate of customers per unit of time (`arrival_rate`), and the average service rate of the server per unit of time (`service_rate`). The class also has attributes to keep track of the queue length (`queue_length`) and the waiting times of customers (`waiting_times`).\n",
    "\n",
    "The `customer_arrival` method is a generator function that simulates customer arrivals. It runs indefinitely in a loop (`while True`). Inside the loop, the function `yield` pauses the execution for a random time interval based on an exponential distribution with the specified arrival rate (`random.expovariate(self.arrival_rate)`). This simulates the inter-arrival time between consecutive customers. After a customer arrives, we increment the queue length by one (`self.queue_length += 1`), and then we start the customer service process using `self.env.process(self.customer_service(self.env.now))`. The `self.env.now` captures the current simulation time, representing the time of customer arrival.\n",
    "\n",
    "The `customer_service` method simulates the service process for a customer. It starts by capturing the arrival time passed as `arrival_time`. The service time is sampled from an exponential distribution with the specified service rate (`random.expovariate(self.service_rate)`). We then yield `self.env.timeout(service_time)`, which represents the duration of the service. After the service is completed, the departure time is captured as the current simulation time (`self.env.now`), and we calculate the waiting time as `waiting_time = departure_time - arrival_time`. We decrement the queue length by one (`self.queue_length -= 1`) and add the waiting time to the list of waiting times for customers (`self.waiting_times.append(waiting_time)`).\n",
    "\n",
    "In the main simulation part, we define the arrival rate (`arrival_rate`), service rate (`service_rate`), and the simulation time (`simulation_time`). We then create a simulation environment (`env`) using `simpy.Environment()`.\n",
    "Next, we create an instance of the `SingleServerQueue` class called `queue_system`, passing the simulation environment and the arrival and service rates to it.\n",
    "We then start the customer arrival process using `env.process(queue_system.customer_arrival())`, which initiates the queuing system simulation.\n",
    "The simulation runs until the specified `simulation_time` using `env.run(until=simulation_time)`.\n",
    "After the simulation is complete, we calculate the average waiting time of customers using the recorded waiting times and print the result.\n",
    "Finally, we plot the waiting time distribution using `matplotlib`. The histogram shows the probability density of waiting times for customers in the single-server queuing system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import simpy\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "class SingleServerQueue:\n",
    "    def __init__(self, env, arrival_rate, service_rate):\n",
    "        self.env = env\n",
    "        self.arrival_rate = arrival_rate\n",
    "        self.service_rate = service_rate\n",
    "        self.queue_length = 0\n",
    "        self.waiting_times = []\n",
    "\n",
    "    def customer_arrival(self):\n",
    "        while True:\n",
    "            yield self.env.timeout(random.expovariate(self.arrival_rate))\n",
    "            self.queue_length += 1\n",
    "            self.env.process(self.customer_service(self.env.now))  # Capture arrival time\n",
    "\n",
    "    def customer_service(self, arrival_time):\n",
    "        service_time = random.expovariate(self.service_rate)\n",
    "        yield self.env.timeout(service_time)\n",
    "        departure_time = self.env.now\n",
    "        self.queue_length -= 1\n",
    "        waiting_time = departure_time - arrival_time\n",
    "        self.waiting_times.append(waiting_time)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    arrival_rate = 0.5  # Average arrival rate of customers per unit of time\n",
    "    service_rate = 0.6  # Average service rate of the server per unit of time\n",
    "    simulation_time = 1000\n",
    "\n",
    "    env = simpy.Environment()\n",
    "    queue_system = SingleServerQueue(env, arrival_rate, service_rate)\n",
    "    env.process(queue_system.customer_arrival())\n",
    "    env.run(until=simulation_time)\n",
    "\n",
    "    # Calculate and print average waiting time\n",
    "    average_waiting_time = sum(queue_system.waiting_times) / len(queue_system.waiting_times)\n",
    "    print(\"Average Waiting Time:\", average_waiting_time)\n",
    "\n",
    "    # Plotting the waiting time distribution\n",
    "    plt.hist(queue_system.waiting_times, bins=30, density=True, alpha=0.7, color='blue')\n",
    "    plt.xlabel('Waiting Time')\n",
    "    plt.ylabel('Probability Density')\n",
    "    plt.title('Waiting Time Distribution in Single-Server Queuing System')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alternative 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Detail Explanation for below code\n",
    "We set the random seed for reproducibility (`RANDOM_SEED`), the simulation time (`SIM_TIME`), and the service time for the server (`SERVICE_TIME`).\n",
    "\n",
    "The `SingleServerQueue` class represents the single-server queuing system. It is initialized with the simulation environment (`env`) and the service time of the server (`service_time`). The class uses `simpy.Resource` to create a resource representing the server with a capacity of 1 (meaning only one customer can be served at a time). The `service` method is a generator function that simulates the service process for a customer. It yields a `timeout` event based on an exponential distribution with the inverse of the service time (`1/self.service_time`), which represents the duration of the service.\n",
    "\n",
    "The `customer_arrivals` function simulates the arrival of customers to the queuing system. It runs indefinitely in a loop (`while True`). Inside the loop, it increments the customer index `i` by one to keep track of the number of arriving customers. The function then yields a `timeout` event based on an exponential distribution with a rate of `1/5`, which represents the average time between customer arrivals. After the timeout, it starts the `customer` process, passing the simulation environment (`env`), the customer name (`f'Customer {i}'`), and the `queue` object representing the single-server queue.\n",
    "\n",
    "The `customer` function simulates the behavior of a customer in the queuing system. When a customer arrives, it prints a message indicating the arrival time and the customer's name. It then requests to use the server using `queue.server.request()` as a context manager. If the server is available, the customer is served. It prints a message when the customer starts being served, and it yields the service process by calling `env.process(queue.service())`. The `queue.service()` generator function is called, which represents the service time of the customer. After the service is completed, the customer prints a message indicating the finish time.\n",
    "\n",
    "In the main simulation part, we set the random seed using `random.seed(RANDOM_SEED)` for reproducibility. We create the simulation environment `env` using `simpy.Environment()`. We also create an instance of the `SingleServerQueue` class called `queue`, passing the simulation environment and the service time `SERVICE_TIME`.\n",
    "\n",
    "Next, we start the customer arrival process using `env.process(customer_arrivals(env, queue))`. This initiates the arrival of customers to the queuing system.\n",
    "\n",
    "The simulation runs until the specified `SIM_TIME` using `env.run(until=SIM_TIME)`. During the simulation, the arrivals and services of customers are simulated, and their interactions with the single-server queuing system are recorded and printed as messages.\n",
    "\n",
    "The output will show the arrival, service start, and service finish times for each customer, which helps analyze the performance of the queuing system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import simpy\n",
    "\n",
    "RANDOM_SEED = 42\n",
    "SIM_TIME = 1000\n",
    "SERVICE_TIME = 5\n",
    "\n",
    "class SingleServerQueue:\n",
    "    def __init__(self, env, service_time): \n",
    "        self.server = simpy.Resource(env, capacity=1)\n",
    "        self.service_time = service_time\n",
    "    def service(self):\n",
    "        yield env.timeout (random.expovariate(1/self.service_time))\n",
    "\n",
    "def customer_arrivals(env, queue):\n",
    "    i = 0\n",
    "    while True:\n",
    "        i += 1 \n",
    "        yield env.timeout(random.expovariate(1/5)) \n",
    "        env.process(customer (env, f'Customer {i}', queue))\n",
    "\n",
    "def customer(env, name, queue): \n",
    "    print (f\" {env.now}: {name} arrived\")\n",
    "    with queue.server.request() as request:\n",
    "        yield request\n",
    "        print(f\" {env.now}: {name} being served\")\n",
    "        yield env.process(queue.service())\n",
    "        print(f\"{env.now}: {name} finished being served\")\n",
    "\n",
    "# Setup and start the simulation \n",
    "random.seed(RANDOM_SEED)\n",
    "env = simpy.Environment()\n",
    "queue = SingleServerQueue(env, SERVICE_TIME) \n",
    "env.process(customer_arrivals (env, queue))\n",
    "env.run(until=SIM_TIME)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alternative 3, 4\n",
    "https://towardsdatascience.com/simulating-a-queuing-system-in-python-8a7d1151d485\n",
    "\n",
    "https://medium.com/analytics-vidhya/simulating-a-single-server-queuing-system-in-python-f8e32578749f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alternative 5\n",
    "From book that masud sir wants , But using random function to generates numbers uniformly between 0 and 1,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import random\n",
    "\n",
    "# Constants and variables initialization\n",
    "Q_LIMIT = 100\n",
    "BUSY = 1\n",
    "IDLE = 0\n",
    "next_event_type, num_custs_delayed, num_delays_required, num_events, num_in_q, server_status = 0, 0, 0, 2, 0, IDLE\n",
    "area_num_in_q, area_server_status, mean_interarrival, mean_service, sim_time, total_of_delays = 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
    "time_arrival = [0.0] * (Q_LIMIT + 1)\n",
    "time_last_event, time_next_event = 0.0, [0.0] * 3\n",
    "\n",
    "# Function to generate exponential random variates (using Python's random module)\n",
    "def expon(mean):\n",
    "    return -mean * math.log(random.random())\n",
    "\n",
    "# Function to initialize simulation parameters\n",
    "def initialize():\n",
    "    global sim_time, server_status, num_in_q, time_last_event, num_custs_delayed, total_of_delays, area_num_in_q, area_server_status, time_next_event\n",
    "    global time_last_event  # Add global declaration for time_last_event\n",
    "\n",
    "    # Initialize simulation parameters and schedule the first arrival event\n",
    "    sim_time = 0.0\n",
    "    server_status = IDLE\n",
    "    num_in_q = 0\n",
    "    time_last_event = 0.0\n",
    "    num_custs_delayed = 0\n",
    "    total_of_delays = 0.0\n",
    "    area_num_in_q = 0.0\n",
    "    area_server_status = 0.0\n",
    "    time_next_event[1] = sim_time + expon(mean_interarrival)\n",
    "    time_next_event[2] = 1.0e+30\n",
    "\n",
    "# Function to determine the next event type and update the simulation time\n",
    "def timing():\n",
    "    global next_event_type, sim_time\n",
    "    min_time_next_event = 1.0e+29\n",
    "    next_event_type = 0\n",
    "\n",
    "    # Find the next event type with the smallest time in time_next_event\n",
    "    for i in range(1, num_events + 1):\n",
    "        if time_next_event[i] < min_time_next_event:\n",
    "            min_time_next_event = time_next_event[i]\n",
    "            next_event_type = i\n",
    "\n",
    "    # If no event is scheduled, terminate the simulation\n",
    "    if next_event_type == 0:\n",
    "        print(\"\\nEvent list empty at time\", sim_time)\n",
    "        exit(1)\n",
    "\n",
    "    # Update the simulation time to the time of the next event\n",
    "    sim_time = min_time_next_event\n",
    "\n",
    "# Function to handle the arrival of a customer\n",
    "def arrive():\n",
    "    global num_in_q, server_status, num_custs_delayed, total_of_delays\n",
    "    delay = 0.0\n",
    "\n",
    "    # Schedule the next arrival event\n",
    "    time_next_event[1] = sim_time + expon(mean_interarrival)\n",
    "\n",
    "    # If the server is busy, the arriving customer joins the queue\n",
    "    if server_status == BUSY:\n",
    "        num_in_q += 1\n",
    "        # Check if the queue length exceeds the limit\n",
    "        if num_in_q > Q_LIMIT:\n",
    "            print(\"\\nOverflow of the array time_arrival at time\", sim_time)\n",
    "            exit(2)\n",
    "        # Store the arrival time of the customer in the queue\n",
    "        time_arrival[num_in_q] = sim_time\n",
    "    else:\n",
    "        # If the server is idle, the arriving customer starts service immediately\n",
    "        delay = 0.0\n",
    "        total_of_delays += delay\n",
    "        num_custs_delayed += 1\n",
    "        server_status = BUSY\n",
    "        # Schedule the departure event for the current customer\n",
    "        time_next_event[2] = sim_time + expon(mean_service)\n",
    "\n",
    "# Function to handle the departure of a customer\n",
    "def depart():\n",
    "    global num_in_q, server_status, num_custs_delayed, total_of_delays\n",
    "    delay = 0.0\n",
    "\n",
    "    # If there are no customers in the queue, the server becomes idle and no departure event is scheduled\n",
    "    if num_in_q == 0:\n",
    "        server_status = IDLE\n",
    "        time_next_event[2] = 1.0e+30\n",
    "    else:\n",
    "        # If there are customers in the queue, the first customer departs\n",
    "        num_in_q -= 1\n",
    "        # Calculate the delay experienced by the departing customer and update the total delays\n",
    "        delay = sim_time - time_arrival[1]\n",
    "        total_of_delays += delay\n",
    "        num_custs_delayed += 1\n",
    "        # Schedule the departure event for the next customer in the queue\n",
    "        time_next_event[2] = sim_time + expon(mean_service)\n",
    "        # Move the remaining customers' arrival times in the queue one position forward\n",
    "        for i in range(1, num_in_q + 1):\n",
    "            time_arrival[i] = time_arrival[i + 1]\n",
    "\n",
    "# Function to generate the simulation report\n",
    "def report():\n",
    "    global area_num_in_q, area_server_status, num_custs_delayed, sim_time\n",
    "\n",
    "    print(\"\\n\\nSingle-server queueing system\\n\")\n",
    "    print(\"Mean interarrival time{:11.3f} minutes\".format(mean_interarrival))\n",
    "    print(\"Mean service time{:16.3f} minutes\".format(mean_service))\n",
    "    print(\"Number of customers{:14d}\".format(num_delays_required))\n",
    "\n",
    "    # Calculate and print the average delay in the queue if there are delayed customers\n",
    "    if num_custs_delayed > 0:\n",
    "        print(\"\\n\\nAverage delay in queue{:11.3f} minutes\".format(total_of_delays / num_custs_delayed))\n",
    "    else:\n",
    "        print(\"\\n\\nAverage delay in queue: N/A (No customers have been delayed)\")\n",
    "\n",
    "    # Calculate and print the average number of customers in the queue and server utilization\n",
    "    if sim_time > 0:\n",
    "        print(\"Average number in queue{:10.3f}\".format(area_num_in_q / sim_time))\n",
    "        print(\"Server utilization{:15.3f}\".format(area_server_status / sim_time))\n",
    "        print(\"Time simulation ended{:12.3f} minutes\".format(sim_time))\n",
    "    else:\n",
    "        # If simulation has not started, print N/A for average number in queue, server utilization, and simulation end time\n",
    "        print(\"Average number in queue: N/A (Simulation has not started)\")\n",
    "        print(\"Server utilization: N/A (Simulation has not started)\")\n",
    "        print(\"Time simulation ended: N/A (Simulation has not started)\")\n",
    "\n",
    "# Function to update time-average statistics during the simulation\n",
    "def update_time_avg_stats():\n",
    "    global area_num_in_q, area_server_status, time_last_event  # Add global declaration for time_last_event\n",
    "    time_since_last_event = sim_time - time_last_event\n",
    "    time_last_event = sim_time\n",
    "    # Update the area for the number of customers in the queue and the server status based on the time since the last event\n",
    "    area_num_in_q += num_in_q * time_since_last_event\n",
    "    area_server_status += server_status * time_since_last_event\n",
    "\n",
    "# Main function to run the simulation\n",
    "def main():\n",
    "    global num_custs_delayed, outfile\n",
    "\n",
    "    # Input parameters (You can change these values as desired)\n",
    "    global mean_interarrival, mean_service, num_delays_required\n",
    "    mean_interarrival = 5.0\n",
    "    mean_service = 2.0\n",
    "    num_delays_required = 1000\n",
    "\n",
    "    # Initialize the simulation\n",
    "    initialize()\n",
    "\n",
    "    # Run the simulation while more delays are still needed\n",
    "    while num_custs_delayed < num_delays_required:\n",
    "        timing()\n",
    "        update_time_avg_stats()\n",
    "        if next_event_type == 1:\n",
    "            arrive()\n",
    "        elif next_event_type == 2:\n",
    "            depart()\n",
    "\n",
    "    # Generate the report and close the output file\n",
    "    report()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alternative 6\n",
    "From book that masud sir wants, it generate exponentially distributed random numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "# Define constant values for the simulation\n",
    "Q_LIMIT = 100  # Maximum number of customers allowed in the queue\n",
    "BUSY = 1       # Represents that the server is busy serving a customer\n",
    "IDLE = 0       # Represents that the server is idle and available for service\n",
    "\n",
    "# Initialize variables for the simulation\n",
    "next_event_type, num_custs_delayed, num_delays_required, num_events, num_in_q, server_status = 0, 0, 0, 2, 0, IDLE\n",
    "area_num_in_q, area_server_status, mean_interarrival, mean_service, sim_time, total_of_delays = 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n",
    "time_arrival = [0.0] * (Q_LIMIT + 1)  # Array to store arrival times of customers in the queue\n",
    "time_last_event, time_next_event = 0.0, [0.0] * 3  # Variables to store the last and next event times\n",
    "\n",
    "\n",
    "# Constants for random number generation\n",
    "MODLUS = 2147483647\n",
    "MULT1 = 24112\n",
    "MULT2 = 26143\n",
    "# List of random number generator seeds\n",
    "zrng = [1, 1973272912, 281629770, 20006270, 1280689831, 2096730329, 1933576050,\n",
    "        913566091, 246780520, 1363774876, 604901985, 1511192140, 1259851944,\n",
    "        824064364, 150493284, 242708531, 75253171, 1964472944, 1202299975,\n",
    "        233217322, 1911216000, 726370533, 403498145, 993232223, 1103205531,\n",
    "        762430696, 1922803170, 1385516923, 76271663, 413682397, 726466604,\n",
    "        336157058, 1432650381, 1120463904, 595778810, 877722890, 1046574445,\n",
    "        68911991, 2088367019, 748545416, 622401386, 2122378830, 640690903,\n",
    "        1774806513, 2132545692, 2079249579, 78130110, 852776735, 1187867272,\n",
    "        1351423507, 1645973084, 1997049139, 922510944, 2045512870, 898585771,\n",
    "        243649545, 1004818771, 773686062, 403188473, 372279877, 1901633463,\n",
    "        498067494, 2087759558, 493157915, 597104727, 1530940798, 1814496276,\n",
    "        536444882, 1663153658, 855503735, 67784357, 1432404475, 619691088,\n",
    "        119025595, 880802310, 176192644, 1116780070, 277854671, 1366580350,\n",
    "        1142483975, 2026948561, 1053920743, 786262391, 1792203830, 1494667770,\n",
    "        1923011392, 1433700034, 1244184613, 1147297105, 539712780, 1545929719,\n",
    "        190641742, 1645390429, 264907697, 620389253, 1502074852, 927711160,\n",
    "        364849192, 2049576050, 638580085, 547070247]\n",
    "\n",
    "\n",
    "# Random number generation function (lcgrand) is a random number generator \n",
    "# that generates uniform random numbers between 0 and 1.\n",
    "# It is based on a linear congruential generator and uses a list of seeds (zrng) to generate random numbers.\n",
    "def lcgrand(stream):\n",
    "    global zrng\n",
    "    zi, lowprd, hi31 = zrng[stream], 0, 0\n",
    "    lowprd = (zi & 65535) * MULT1\n",
    "    hi31 = (zi >> 16) * MULT1 + (lowprd >> 16)\n",
    "    zi = ((lowprd & 65535) - MODLUS) + ((hi31 & 32767) << 16) + (hi31 >> 15)\n",
    "    if zi < 0:\n",
    "        zi += MODLUS\n",
    "    lowprd = (zi & 65535) * MULT2\n",
    "    hi31 = (zi >> 16) * MULT2 + (lowprd >> 16)\n",
    "    zi = ((lowprd & 65535) - MODLUS) + ((hi31 & 32767) << 16) + (hi31 >> 15)\n",
    "    if zi < 0:\n",
    "        zi += MODLUS\n",
    "    zrng[stream] = zi\n",
    "    return (zi >> 7 | 1) / 16777216.0\n",
    "\n",
    "\n",
    "# Random seed setting function (lcgrandst) sets the seed (zset) for a specific stream of the random number generator.\n",
    "# It changes the value of a seed in the zrng list, which will affect the sequence of random numbers generated.\n",
    "def lcgrandst(zset, stream):\n",
    "    global zrng\n",
    "    zrng[stream] = zset\n",
    "\n",
    "\n",
    "# Random number getter function (lcgrandgt) retrieves the current seed value for a specific stream of the random number generator.\n",
    "def lcgrandgt(stream):\n",
    "    global zrng\n",
    "    return zrng[stream]\n",
    "\n",
    "\n",
    "\n",
    "# The expon function generates exponentially distributed random numbers using the inverse transform method.\n",
    "# It calls the lcgrand function to get a uniform random number and then transforms it to an exponential distribution.\n",
    "def expon(mean):\n",
    "    return -mean * math.log(lcgrand(1))\n",
    "\n",
    "\n",
    "# Function to initialize the simulation variables\n",
    "def initialize():\n",
    "    global sim_time, server_status, num_in_q, time_last_event, num_custs_delayed, total_of_delays, area_num_in_q, area_server_status, time_next_event\n",
    "    global time_last_event  # Add global declaration for time_last_event\n",
    "\n",
    "    # Initialize simulation time, server status, queue length, last event time, number of delayed customers, total delays, area for queue length, and area for server status\n",
    "    sim_time = 0.0\n",
    "    server_status = IDLE\n",
    "    num_in_q = 0\n",
    "    time_last_event = 0.0\n",
    "    num_custs_delayed = 0\n",
    "    total_of_delays = 0.0\n",
    "    area_num_in_q = 0.0\n",
    "    area_server_status = 0.0\n",
    "\n",
    "    # Schedule the first arrival event and set the departure event time to a large value (effectively, no departure event yet)\n",
    "    time_next_event[1] = sim_time + expon(mean_interarrival)\n",
    "    time_next_event[2] = 1.0e+30\n",
    "\n",
    "# Function to determine the next event and update simulation time\n",
    "def timing():\n",
    "    global next_event_type, sim_time\n",
    "    min_time_next_event = 1.0e+29\n",
    "    next_event_type = 0\n",
    "\n",
    "    # Find the minimum time for the next event and identify the type of that event\n",
    "    for i in range(1, num_events + 1):\n",
    "        if time_next_event[i] < min_time_next_event:\n",
    "            min_time_next_event = time_next_event[i]\n",
    "            next_event_type = i\n",
    "\n",
    "    # If no event is scheduled, terminate the simulation\n",
    "    if next_event_type == 0:\n",
    "        print(\"\\nEvent list empty at time\", sim_time)\n",
    "        exit(1)\n",
    "\n",
    "    # Update the simulation time to the time of the next event\n",
    "    sim_time = min_time_next_event\n",
    "\n",
    "# Function to handle the arrival of a customer\n",
    "def arrive():\n",
    "    global num_in_q, server_status, num_custs_delayed, total_of_delays\n",
    "    delay = 0.0\n",
    "\n",
    "    # Schedule the next arrival event\n",
    "    time_next_event[1] = sim_time + expon(mean_interarrival)\n",
    "\n",
    "    # If the server is busy, the arriving customer joins the queue\n",
    "    if server_status == BUSY:\n",
    "        num_in_q += 1\n",
    "        # Check if the queue length exceeds the limit\n",
    "        if num_in_q > Q_LIMIT:\n",
    "            print(\"\\nOverflow of the array time_arrival at time\", sim_time)\n",
    "            exit(2)\n",
    "        # Store the arrival time of the customer in the queue\n",
    "        time_arrival[num_in_q] = sim_time\n",
    "    else:\n",
    "        # If the server is idle, the arriving customer starts service immediately\n",
    "        delay = 0.0\n",
    "        total_of_delays += delay\n",
    "        num_custs_delayed += 1\n",
    "        server_status = BUSY\n",
    "        # Schedule the departure event for the current customer\n",
    "        time_next_event[2] = sim_time + expon(mean_service)\n",
    "\n",
    "# Function to handle the departure of a customer\n",
    "def depart():\n",
    "    global num_in_q, server_status, num_custs_delayed, total_of_delays\n",
    "    delay = 0.0\n",
    "\n",
    "    # If there are no customers in the queue, the server becomes idle and no departure event is scheduled\n",
    "    if num_in_q == 0:\n",
    "        server_status = IDLE\n",
    "        time_next_event[2] = 1.0e+30\n",
    "    else:\n",
    "        # If there are customers in the queue, the first customer departs\n",
    "        num_in_q -= 1\n",
    "        # Calculate the delay experienced by the departing customer and update the total delays\n",
    "        delay = sim_time - time_arrival[1]\n",
    "        total_of_delays += delay\n",
    "        num_custs_delayed += 1\n",
    "        # Schedule the departure event for the next customer in the queue\n",
    "        time_next_event[2] = sim_time + expon(mean_service)\n",
    "        # Move the remaining customers' arrival times in the queue one position forward\n",
    "        for i in range(1, num_in_q + 1):\n",
    "            time_arrival[i] = time_arrival[i + 1]\n",
    "\n",
    "# Function to generate the simulation report\n",
    "def report():\n",
    "    global area_num_in_q, area_server_status, num_custs_delayed, sim_time\n",
    "\n",
    "    print(\"\\n\\nSingle-server queueing system\\n\")\n",
    "    print(\"Mean interarrival time{:11.3f} minutes\".format(mean_interarrival))\n",
    "    print(\"Mean service time{:16.3f} minutes\".format(mean_service))\n",
    "    print(\"Number of customers{:14d}\".format(num_delays_required))\n",
    "\n",
    "    # Calculate and print the average delay in the queue if there are delayed customers\n",
    "    if num_custs_delayed > 0:\n",
    "        print(\"\\n\\nAverage delay in queue{:11.3f} minutes\".format(total_of_delays / num_custs_delayed))\n",
    "    else:\n",
    "        print(\"\\n\\nAverage delay in queue: N/A (No customers have been delayed)\")\n",
    "\n",
    "    # Calculate and print the average number of customers in the queue and server utilization\n",
    "    if sim_time > 0:\n",
    "        print(\"Average number in queue{:10.3f}\".format(area_num_in_q / sim_time))\n",
    "        print(\"Server utilization{:15.3f}\".format(area_server_status / sim_time))\n",
    "        print(\"Time simulation ended{:12.3f} minutes\".format(sim_time))\n",
    "    else:\n",
    "        # If simulation has not started, print N/A for average number in queue, server utilization, and simulation end time\n",
    "        print(\"Average number in queue: N/A (Simulation has not started)\")\n",
    "        print(\"Server utilization: N/A (Simulation has not started)\")\n",
    "        print(\"Time simulation ended: N/A (Simulation has not started)\")\n",
    "\n",
    "# Function to update time-average statistics during the simulation\n",
    "def update_time_avg_stats():\n",
    "    global area_num_in_q, area_server_status, time_last_event  # Add global declaration for time_last_event\n",
    "    time_since_last_event = sim_time - time_last_event\n",
    "    time_last_event = sim_time\n",
    "    # Update the area for the number of customers in the queue and the server status based on the time since the last event\n",
    "    area_num_in_q += num_in_q * time_since_last_event\n",
    "    area_server_status += server_status * time_since_last_event\n",
    "\n",
    "# Main function to run the simulation\n",
    "def main():\n",
    "    global num_custs_delayed, outfile\n",
    "\n",
    "    # Input parameters (You can change these values as desired)\n",
    "    global mean_interarrival, mean_service, num_delays_required\n",
    "    mean_interarrival = 5.0\n",
    "    mean_service = 2.0\n",
    "    num_delays_required = 1000\n",
    "\n",
    "    # Initialize the simulation\n",
    "    initialize()\n",
    "\n",
    "    # Run the simulation while more delays are still needed\n",
    "    while num_custs_delayed < num_delays_required:\n",
    "        timing()\n",
    "        update_time_avg_stats()\n",
    "        # Process the next event based on its type\n",
    "        if next_event_type == 1:\n",
    "            arrive()\n",
    "        elif next_event_type == 2:\n",
    "            depart()\n",
    "\n",
    "    # Generate the report and close the output file (if any)\n",
    "    report()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n",
    "    # Start the simulation by calling the main function when the script is executed as the main program.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}