chapter_11/counter_service.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the random module to generate random numbers\n",
    "import random\n",
    "\n",
    "# Define the main function to run the simulation\n",
    "def main():\n",
    "    # Define parameters for the simulation\n",
    "    n = 6  # Number of values in the interarrival time array\n",
    "    m = 5  # Number of values in the service time array\n",
    "    s = 4  # Number of servers (bearers)\n",
    "    \n",
    "    # Initialize lists to store simulation data\n",
    "    service_ending_times = [0.0] * 10  # List to keep track of service ending times for each server\n",
    "    cumulative_prob_interarrival = [0, 0.05, 0.4, 0.65, 0.80, 0.90, 0.97, 1.0]  # Array of cumulative probabilities for interarrival times\n",
    "    interarrival_times = [0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]  # Array of interarrival times\n",
    "    cumulative_prob_service = [0, 0.05, 0.3, 0.65, 0.85, 1, 0]  # Array of cumulative probabilities for service times\n",
    "    service_times = [1, 2, 3, 4, 5]  # Array of service times\n",
    "\n",
    "    # Get user input for the number of runs\n",
    "    print(\"\\nEnter the value of run: \")\n",
    "    run = int(input())\n",
    "\n",
    "    # Loop through different number of servers\n",
    "    for num_servers in range(2, s + 1):\n",
    "        # Set the random seed for reproducibility of results\n",
    "        random.seed(12345)\n",
    "        \n",
    "        # Initialize variables for the simulation\n",
    "        arrival_counter = 0  # Counter to keep track of the number of arrivals\n",
    "        next_arrival_time = 0.0  # Simulation clock representing the next arrival time\n",
    "        cumulative_waiting_time = 0.0  # Cumulative waiting time for all customers\n",
    "\n",
    "        # Initialize the service ending times for each server\n",
    "        for i in range(1, num_servers + 1):\n",
    "            service_ending_times[i] = 0.0\n",
    "\n",
    "        current_waiting_time = 0.0  # Initialize the waiting time for the current customer\n",
    "\n",
    "        # Run the simulation for the prescribed number of runs\n",
    "        for arrival_counter in range(1, run + 1):\n",
    "            # Generate random numbers for interarrival and service times\n",
    "            random_value = random.random()\n",
    "            for i in range(n):\n",
    "                if random_value > cumulative_prob_interarrival[i] and random_value <= cumulative_prob_interarrival[i + 1]:\n",
    "                    interarrival_time = interarrival_times[i]\n",
    "            \n",
    "            random_value = random.random()\n",
    "            for i in range(m):\n",
    "                if random_value > cumulative_prob_service[i] and random_value <= cumulative_prob_service[i + 1]:\n",
    "                    service_time = service_times[i]\n",
    "\n",
    "            # Update the simulation clock and calculate waiting time\n",
    "            next_arrival_time = next_arrival_time + interarrival_time\n",
    "\n",
    "            # Find the earliest service ending time and corresponding server\n",
    "            min_val = 99.9\n",
    "            chosen_server = 1\n",
    "            for i in range(1, num_servers + 1):\n",
    "                if service_ending_times[i] <= min_val:\n",
    "                    min_val = service_ending_times[i]\n",
    "                    chosen_server = i\n",
    "\n",
    "            # Assign service ending time for the current customer and update waiting time\n",
    "            if next_arrival_time <= min_val:\n",
    "                service_ending_times[chosen_server] = min_val + service_time\n",
    "                current_waiting_time = min_val - next_arrival_time\n",
    "            else:\n",
    "                service_ending_times[chosen_server] = next_arrival_time + service_time\n",
    "\n",
    "            # Accumulate waiting time for all customers\n",
    "            cumulative_waiting_time += current_waiting_time\n",
    "\n",
    "        # Print the simulation results for the current number of servers\n",
    "        print(f\"\\nServers = {num_servers} Total arrivals = {arrival_counter} Average Waiting time = {cumulative_waiting_time / run:6.2f}\")\n",
    "\n",
    "# Check if the script is being run as the main program and call the main function\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alternative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# Seed for random number generation\n",
    "RANDOM_SEED = 12345\n",
    "\n",
    "def main():\n",
    "    # Define the number of interarrival values, service values, and servers\n",
    "    num_interarrival_values = 6\n",
    "    num_service_values = 5\n",
    "    num_servers = 4\n",
    "    \n",
    "    # Define cumulative probabilities and arrays for interarrival and service times\n",
    "    cumulative_prob_interarrival = [0, 0.05, 0.4, 0.65, 0.80, 0.90, 0.97, 1.0]\n",
    "    interarrival_times = [0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]\n",
    "    cumulative_prob_service = [0, 0.05, 0.3, 0.65, 0.85, 1, 0]\n",
    "    service_times = [1, 2, 3, 4, 5]\n",
    "    \n",
    "    # Initialize a list to store service ending times for each server\n",
    "    service_ending_times = [0.0] * 10\n",
    "    \n",
    "    # Get user input for the number of runs\n",
    "    num_runs = int(input(\"Enter the value of num_runs: \"))\n",
    "\n",
    "    # Loop through different numbers of servers\n",
    "    for num_bearers in range(2, num_servers + 1):\n",
    "        # Print header for the current number of servers\n",
    "        print(\"\\nRun Length\\tAverage Waiting time for S={}\".format(num_bearers))\n",
    "        \n",
    "        # Loop through different run lengths\n",
    "        for run_length in range(50, 501, 100):\n",
    "            # Initialize the variable to store the average waiting time\n",
    "            avg_waiting_time = 0.0\n",
    "            \n",
    "            # Run the simulation for the prescribed number of runs\n",
    "            for iteration in range(1, num_runs + 1):\n",
    "                # Set the random seed for reproducibility\n",
    "                random.seed(RANDOM_SEED)\n",
    "                \n",
    "                # Initialize the variables for the current simulation run\n",
    "                arrival_counter = 0\n",
    "                next_arrival_time = 0.0\n",
    "                cumulative_waiting_time = 0.0\n",
    "                \n",
    "                # Initialize the service ending times for each server\n",
    "                for i in range(1, num_bearers + 1):\n",
    "                    service_ending_times[i] = 0.0\n",
    "\n",
    "                # Run the simulation for the prescribed length of run\n",
    "                for arrival_counter in range(1, run_length + 1):\n",
    "                    # Generate the interarrival and service times for the new arrival\n",
    "                    random_value_old = random.random()\n",
    "                    random_value = round(random_value_old, 6)\n",
    "                    for i in range(num_interarrival_values + 1):\n",
    "                        if cumulative_prob_interarrival[i] < random_value <= cumulative_prob_interarrival[i + 1]:\n",
    "                            interarrival_time = interarrival_times[i]\n",
    "                    random_value_old = random.random()\n",
    "                    random_value = round(random_value_old, 6)\n",
    "                    for i in range(num_service_values + 1):\n",
    "                        if cumulative_prob_service[i] < random_value <= cumulative_prob_service[i + 1]:\n",
    "                            service_time = service_times[i]\n",
    "\n",
    "                    # Update the next arrival time\n",
    "                    next_arrival_time += interarrival_time\n",
    "\n",
    "                    # Determine the earliest service ending time and bearer, then update the statistics\n",
    "                    min_ending_time = 99.9\n",
    "                    waiting_time = 0\n",
    "                    for i in range(1, num_bearers + 1):\n",
    "                        if service_ending_times[i] <= min_ending_time:\n",
    "                            min_ending_time = service_ending_times[i]\n",
    "                            chosen_bearer = i\n",
    "                    if next_arrival_time <= min_ending_time:\n",
    "                        service_ending_times[chosen_bearer] = min_ending_time + service_time\n",
    "                        waiting_time = min_ending_time - next_arrival_time\n",
    "                    else:\n",
    "                        service_ending_times[chosen_bearer] = next_arrival_time + service_time\n",
    "\n",
    "                    # Accumulate waiting time\n",
    "                    cumulative_waiting_time += waiting_time\n",
    "\n",
    "                # Calculate average waiting time for the current run and accumulate it\n",
    "                avg_waiting_time += cumulative_waiting_time / run_length\n",
    "\n",
    "            # Print the average waiting time for the current run length and number of servers\n",
    "            print(\"{}\\t\\t{:8.2f}\".format(run_length, avg_waiting_time / num_runs))\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\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
}