{
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# Simulation for Optimization examples\n"
]
},
{
"cell_type": "code",
"execution_count": 283,
"metadata": {},
"outputs": [],
"source": [
"\n",
"import itertools\n",
"import numpy as np\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"import scipy.stats as stats\n",
"\n",
"# you may not use them directly, stats.binom is suggested.\n",
"from scipy.stats import poisson, rv_discrete, binom, rv_discrete, norm, halfnorm\n",
"\n",
"import warnings\n",
"warnings.filterwarnings('ignore')\n",
"\n",
"np.random.seed(42)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"tags": []
},
"source": [
"## Problem 1\n",
"\n",
"### You operate an aircraft that flies two flights per day: an \"outbound\" flight from its base to a remote destination, and then and \"inbound\" flight back again. The aircraft can carry a mix of passengers and freight:\n",
"\n",
"### If configured for all passengers, the aircraft holds 216 seats. Each freight pallet you configure the aircraft to hold takes away 24 seats, and you are considering setting up the aircraft to hold 0, 1, 2, 3, 4, 5, or 6 freight pallets. The split between seats and space for pallets must be decided once a year when the aircraft undergoes \"heavy maintenance\"; it cannot be changed for each flight.\n",
"\n",
"### You make a profit of $50 for each passenger carried (in either direction), and demand for seats on the outbound flight is Poisson with a mean of 160, while demand for seats on the inbound flight is Poisson with a mean of 159 (independent of the outbound flight). Demand for freight carriage is independent of passenger demand and also independent between the inbound and outbound flights.(See Pallet_Table).You make a profit $275 per pallet carried (in either direction). What aircraft configuration maximizes the average profit per day?\n",
"\n",
"\n",
"\n",
"\n",
"|num | outbound_pallets_prob| inbound_pallets_prob |\n",
"|:--:|:--:|:--:|\n",
"| 0 | 0.06 | 0.07 |\n",
"| 1 | 0.08 | 0.09 |\n",
"| 2 | 0.18 | 0.18 |\n",
"| 3 | 0.20 | 0.19 |\n",
"| 4 | 0.21 | 0.17 |\n",
"| 5 | 0.16 | 0.16 |\n",
"| 6 | 0.11 | 0.14 |\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Set the parameters of the problem and generate the random variables\n"
]
},
{
"cell_type": "code",
"execution_count": 245,
"metadata": {},
"outputs": [],
"source": [
"N = 10000 # set the number of trials\n",
"n = (0, 1, 2, 3, 4, 5, 6) # number of pallets considered\n",
"\n",
"# seats_capacity = 216\n",
"# taken_by_each_pallet = 24\n",
"# passenger_profit = 50 / seat\n",
"# pallet_profit = 275 / pallet\n"
]
},
{
"cell_type": "code",
"execution_count": 246,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
outbound_pallets_prob
\n",
"
inbound_pallets_prob
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
0.06
\n",
"
0.07
\n",
"
\n",
"
\n",
"
1
\n",
"
0.08
\n",
"
0.09
\n",
"
\n",
"
\n",
"
2
\n",
"
0.18
\n",
"
0.18
\n",
"
\n",
"
\n",
"
3
\n",
"
0.20
\n",
"
0.19
\n",
"
\n",
"
\n",
"
4
\n",
"
0.21
\n",
"
0.17
\n",
"
\n",
"
\n",
"
5
\n",
"
0.16
\n",
"
0.16
\n",
"
\n",
"
\n",
"
6
\n",
"
0.11
\n",
"
0.14
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" outbound_pallets_prob inbound_pallets_prob\n",
"0 0.06 0.07\n",
"1 0.08 0.09\n",
"2 0.18 0.18\n",
"3 0.20 0.19\n",
"4 0.21 0.17\n",
"5 0.16 0.16\n",
"6 0.11 0.14"
]
},
"execution_count": 246,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Create the pallets_Table for inboud and outbound demand discrete probability\n",
"pallets_table = pd.DataFrame(\n",
" {\n",
" 'outbound_pallets_prob': [0.06, 0.08, 0.18, 0.2, 0.21, 0.16, 0.11],\n",
" 'inbound_pallets_prob': [0.07, 0.09, 0.18, 0.19, 0.17, 0.16, 0.14]\n",
" },\n",
" index=n)\n",
"pallets_table\n"
]
},
{
"cell_type": "code",
"execution_count": 247,
"metadata": {},
"outputs": [],
"source": [
"# genenerate the inbound and outbound demand random variables\n",
"\n",
"demand_pal_out_rvs = stats.rv_discrete(\n",
" name='Pal_Out_rvs',\n",
" values=(n, pallets_table['outbound_pallets_prob'])).rvs(size=N)\n",
"\n",
"demand_pal_in_rvs = stats.rv_discrete(\n",
" name='Pal_In_rvs',\n",
" values=(n, pallets_table['inbound_pallets_prob'])).rvs(size=N)\n"
]
},
{
"cell_type": "code",
"execution_count": 248,
"metadata": {},
"outputs": [],
"source": [
"# Generate seats demand random variables\n",
"\n",
"mu_out = 160 # demand for seats on the outbound flight is Poisson with a mean of 160\n",
"\n",
"mu_in = 159 # demand for seats on the inbound flight is Poisson with a mean of 159\n",
"\n",
"demand_seats_out_rvs = stats.poisson(mu_out).rvs(size=N)\n",
"demand_seats_in_rvs = stats.poisson(mu_in).rvs(size=N)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Considering setting up the aircraft to hold 0, 1, 2, 3, 4, 5, or 6 freight pallets\n"
]
},
{
"cell_type": "code",
"execution_count": 249,
"metadata": {},
"outputs": [],
"source": [
"# When there is 0 freight pallet in the plane.\n",
"# Pallets sale = min(demand_pallets and 0),thus:\n",
"\n",
"pallets_out_sale = 0\n",
"pallets_in_sale = 0\n"
]
},
{
"cell_type": "code",
"execution_count": 250,
"metadata": {},
"outputs": [],
"source": [
"# number_of_seats_In_and_Out_available = seats_capacity = 216\n",
"seats_out_sale = np.minimum(demand_seats_out_rvs, np.ones(N) * 216)\n",
"seats_in_sale = np.minimum(demand_seats_in_rvs, np.ones(N) * 216)\n"
]
},
{
"cell_type": "code",
"execution_count": 251,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"When there is 0 freight pallet in the plane.\n",
"the mean of the profit is 15950.37\n"
]
}
],
"source": [
"profit_Out = seats_out_sale * 50\n",
"profit_In = seats_in_sale * 50\n",
"\n",
"profit_total = profit_Out + profit_In\n",
"mean_profit_0 = np.mean(profit_total)\n",
"\n",
"print(\n",
" f\"When there is 0 freight pallet in the plane.\\nthe mean of the profit is {mean_profit_0}\"\n",
")\n"
]
},
{
"cell_type": "code",
"execution_count": 252,
"metadata": {},
"outputs": [],
"source": [
"# Create simulation function for the mean profit of each scenario from 1 to 6 pallets\n",
"\n",
"\n",
"def mean_profit(i, seats_capacity=216):\n",
" \"\"\"Simulate the actuall sales of pallets and seats numbers for each scenario,where i = numbers of palltes\"\"\"\n",
"\n",
" pallets_out_sale = np.minimum(demand_pal_out_rvs, np.ones(N) * i)\n",
" pallets_in_sale = np.minimum(demand_pal_in_rvs, np.ones(N) * i)\n",
"\n",
" # Next, calculate the available seats left for passengers:\n",
" seats_out_available = seats_capacity - pallets_out_sale * 24\n",
" seats_out_sale = np.minimum(demand_seats_out_rvs, seats_out_available)\n",
"\n",
" seats_in_available = seats_capacity - pallets_in_sale * 24\n",
" seats_in_sale = np.minimum(demand_seats_in_rvs, seats_in_available)\n",
" \"\"\"calculate the profit\"\"\"\n",
" profit_out = seats_out_sale * 50 + pallets_out_sale * 275\n",
" profit_in = seats_in_sale * 50 + pallets_in_sale * 275\n",
"\n",
" profit_total = profit_out + profit_in\n",
" return np.mean(profit_total).astype(int)\n"
]
},
{
"cell_type": "code",
"execution_count": 253,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"When there are 0 pallets in the plane:\n",
" The mean of the profit is $15950.\n",
"When there are 1 pallets in the plane:\n",
" The mean of the profit is $16462.\n",
"When there are 2 pallets in the plane:\n",
" The mean of the profit is $16770.\n",
"When there are 3 pallets in the plane:\n",
" The mean of the profit is $16183.\n",
"When there are 4 pallets in the plane:\n",
" The mean of the profit is $15339.\n",
"When there are 5 pallets in the plane:\n",
" The mean of the profit is $14815.\n",
"When there are 6 pallets in the plane:\n",
" The mean of the profit is $14582.\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"result_profits = np.empty(shape=(7, 1), dtype=int)\n",
"\n",
"_, ax = plt.subplots(figsize=(10, 5))\n",
"\n",
"for i in range(7):\n",
" result_profits[i] = mean_profit(i)\n",
"\n",
" print(\n",
" f\"When there are {i} pallets in the plane:\\n The mean of the profit is ${mean_profit(i).round(2)}.\"\n",
" )\n",
" ax.bar(i, result_profits[i], color='blue', width=0.5)\n",
" ax.set(title='Mean Profit of each scenario',\n",
" xlabel='Number of pallets',\n",
" ylabel='Mean Profit',\n",
" ylim=(np.min(result_profits) - 500, np.max(result_profits) + 500))\n"
]
},
{
"cell_type": "code",
"execution_count": 254,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Hence the highest profit is $16770,when there are 2 pallets assembeld in the plane.\n"
]
}
],
"source": [
"print(\n",
" f\"\\nHence the highest profit is ${np.max(result_profits)},when there are {np.argmax(result_profits)} pallets assembeld in the plane.\"\n",
")\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Problem 2\n",
"\n",
"### You run a newspaper stand. You cannot predict exactly how many copies of the Daily Blab newspaper you will be able to sell, but in the past, you have observed the following demand pattern:\n",
"\n",
"\n",
"\n",
"|Demand|Percentage of the Time|\n",
"|:-:|:-:|\n",
"| 20 | 1% |\n",
"| 21 | 2% |\n",
"| 22 | 3% |\n",
"| 23 | 4% |\n",
"| 24 | 5% |\n",
"| 25 | 6% |\n",
"| 26 | 6% |\n",
"| 27 | 7% |\n",
"| 28 | 7% |\n",
"| 29 | 7% |\n",
"| 30 | 7% |\n",
"| 31 | 7% |\n",
"| 32 | 7% |\n",
"| 33 | 6% |\n",
"| 34 | 5% |\n",
"| 35 | 4% |\n",
"| 36 | 4% |\n",
"| 37 | 3% |\n",
"| 38 | 3% |\n",
"| 39 | 3% |\n",
"| 40 | 3% |\n",
"\n",
"#### Each copy of the Daily Blab costs you $0.35 and sells for $0.45. You must place your order for the papers the night before they are sold, before you know exactly how many copies you will be able to sell. Unsold copies may be returned to the publisher at the end of the day for a credit of $0.05 each. You can buy the paper only in multiples of 5, and are considering stocking either 20, 25, 30, 35, or 40 papers per day. What is the right number of papers to order each night?\n"
]
},
{
"cell_type": "code",
"execution_count": 255,
"metadata": {},
"outputs": [],
"source": [
"n = np.arange(20, 41)\n",
"\n",
"percent_demand = pd.DataFrame(\n",
" [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.06, 0.07, 0.07, 0.07, 0.07, 0.07,\n",
" 0.07, 0.06, 0.05, 0.04, 0.04, 0.03, 0.03, 0.03, 0.03\n",
" ], index=n)\n"
]
},
{
"cell_type": "code",
"execution_count": 256,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAg0AAAIHCAYAAAAcg2/yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABArklEQVR4nO3de3iU5bn2/3MM2SgK1tBmowGCokSjoolisBGqEgTcQFGxVfBVosawFpIsWghxl4DGKsVIBbKUpOhbq3SVvqtW0kq0wkKTFoEEBCJqgQQ1EYIaEDTb6/cHv8xizJDcExJa9fs5jjkOcs/1XNzPZCZzzv08M+MxMxMAAEAnTvhnTwAAAHwzEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAICTLoWGxYsXKzY2VmFhYUpISNDatWs7rF+zZo0SEhIUFhamQYMGqaCgoF1Nfn6+zjnnHJ144omKiYlRRkaGvvrqq65MDwAA9ICAQ8Py5cs1Y8YMZWdnq7y8XMnJyRozZoyqq6v91u/cuVNjx45VcnKyysvLNWfOHE2fPl0rVqzw1rzwwguaPXu2HnroIVVWVqqwsFDLly9XVlZW1/cMAAB0K0+gX1g1bNgwXXzxxVqyZIl3LC4uTuPHj1deXl67+lmzZunll19WZWWldywtLU2bNm1SWVmZJOnf/u3fVFlZqddff91b8x//8R9at25dp6sYAADg+OgVSHFjY6M2bNig2bNn+4ynpKSotLTU7zZlZWVKSUnxGRs9erQKCwvV1NSk4OBg/fCHP9RvfvMbrVu3Tpdeeql27Nih4uJi3X777UedS0NDgxoaGrw/t7a26tNPP1V4eLg8Hk8guwUAwHeamenAgQOKjo7WCScc/SBEQKGhrq5OLS0tioiI8BmPiIhQbW2t321qa2v91jc3N6uurk5RUVG65ZZbtHfvXv3whz+Umam5uVn33ntvu3BypLy8POXk5AQyfQAA0IHdu3frjDPOOOr1AYWGNl9/JW9mHb6691d/5Pjq1av1yCOPaPHixRo2bJg++OAD3XfffYqKitIDDzzgt2dWVpYyMzO9P9fX16t///7avXu3+vTp05XdAgDgO2n//v2KiYnRKaec0mFdQKGhX79+CgoKareqsGfPnnarCW0iIyP91vfq1Uvh4eGSpAceeECTJ09WamqqJOn888/XwYMHdffddys7O9vvUkloaKhCQ0Pbjffp04fQAABAF3R2eD+gd0+EhIQoISFBJSUlPuMlJSUaPny4322SkpLa1a9atUqJiYkKDg6WJB06dKhdMAgKCpKZKcDzNAEAQA8J+C2XmZmZWrp0qYqKilRZWamMjAxVV1crLS1N0uHDBlOmTPHWp6WlqaqqSpmZmaqsrFRRUZEKCws1c+ZMb811112nJUuW6KWXXtLOnTtVUlKiBx54QNdff72CgoK6YTcBAMCxCvichkmTJmnfvn3Kzc1VTU2N4uPjVVxcrAEDBkiSampqfD6zITY2VsXFxcrIyNCiRYsUHR2thQsXauLEid6a+++/Xx6PR/fff78++ugjff/739d1112nRx55pBt2EQAAdIeAP6fhX9X+/fvVt29f1dfXc04DAAABcH0O5bsnAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4KRLoWHx4sWKjY1VWFiYEhIStHbt2g7r16xZo4SEBIWFhWnQoEEqKCjwuX7kyJHyeDztLuPGjevK9AAAQA8IODQsX75cM2bMUHZ2tsrLy5WcnKwxY8aourrab/3OnTs1duxYJScnq7y8XHPmzNH06dO1YsUKb80f/vAH1dTUeC9btmxRUFCQbrrppq7vGQAA6FYeM7NANhg2bJguvvhiLVmyxDsWFxen8ePHKy8vr139rFmz9PLLL6uystI7lpaWpk2bNqmsrMzv/5Gfn68HH3xQNTU16t27t9O89u/fr759+6q+vl59+vQJZJcAAPhOc30ODWilobGxURs2bFBKSorPeEpKikpLS/1uU1ZW1q5+9OjRWr9+vZqamvxuU1hYqFtuuaXDwNDQ0KD9+/f7XAAAQM/pFUhxXV2dWlpaFBER4TMeERGh2tpav9vU1tb6rW9ublZdXZ2ioqJ8rlu3bp22bNmiwsLCDueSl5ennJycQKYP9KiBs1c61+56zP18nZ7q25O96Qt8O3XpREiPx+Pzs5m1G+us3t+4dHiVIT4+XpdeemmHc8jKylJ9fb33snv3btfpAwCALghopaFfv34KCgpqt6qwZ8+edqsJbSIjI/3W9+rVS+Hh4T7jhw4d0ksvvaTc3NxO5xIaGqrQ0NBApg8AAI5BQCsNISEhSkhIUElJic94SUmJhg8f7nebpKSkdvWrVq1SYmKigoODfcZ/97vfqaGhQbfddlsg0wIAAMdBwIcnMjMztXTpUhUVFamyslIZGRmqrq5WWlqapMOHDaZMmeKtT0tLU1VVlTIzM1VZWamioiIVFhZq5syZ7XoXFhZq/Pjx7VYgAADAP19AhyckadKkSdq3b59yc3NVU1Oj+Ph4FRcXa8CAAZKkmpoan89siI2NVXFxsTIyMrRo0SJFR0dr4cKFmjhxok/f9957T2+++aZWrVp1jLsEAAB6QsChQZLS09OVnp7u97ply5a1GxsxYoQ2btzYYc+zzz5bAX5kBAAAOI747gkAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADASZdCw+LFixUbG6uwsDAlJCRo7dq1HdavWbNGCQkJCgsL06BBg1RQUNCu5vPPP9e0adMUFRWlsLAwxcXFqbi4uCvTAwAAPSDg0LB8+XLNmDFD2dnZKi8vV3JyssaMGaPq6mq/9Tt37tTYsWOVnJys8vJyzZkzR9OnT9eKFSu8NY2NjRo1apR27dql3//+99q+fbueffZZnX766V3fMwAA0K16BbrBggULNHXqVKWmpkqS8vPz9eqrr2rJkiXKy8trV19QUKD+/fsrPz9fkhQXF6f169dr/vz5mjhxoiSpqKhIn376qUpLSxUcHCxJGjBgQFf3CQAA9ICAVhoaGxu1YcMGpaSk+IynpKSotLTU7zZlZWXt6kePHq3169erqalJkvTyyy8rKSlJ06ZNU0REhOLj4/Xoo4+qpaXlqHNpaGjQ/v37fS4AAKDnBLTSUFdXp5aWFkVERPiMR0REqLa21u82tbW1fuubm5tVV1enqKgo7dixQ3/961916623qri4WO+//76mTZum5uZmPfjgg3775uXlKScnJ5Dp4xtm4OyVzrW7Hhv3T+8LfB33NXzbdOlESI/H4/OzmbUb66z+yPHW1lb94Ac/0DPPPKOEhATdcsstys7O1pIlS47aMysrS/X19d7L7t27u7IrAADAUUArDf369VNQUFC7VYU9e/a0W01oExkZ6be+V69eCg8PlyRFRUUpODhYQUFB3pq4uDjV1taqsbFRISEh7fqGhoYqNDQ0kOkDAIBjENBKQ0hIiBISElRSUuIzXlJSouHDh/vdJikpqV39qlWrlJiY6D3p8fLLL9cHH3yg1tZWb817772nqKgov4EBAAAcfwEfnsjMzNTSpUtVVFSkyspKZWRkqLq6WmlpaZIOHzaYMmWKtz4tLU1VVVXKzMxUZWWlioqKVFhYqJkzZ3pr7r33Xu3bt0/33Xef3nvvPa1cuVKPPvqopk2b1g27CAAAukPAb7mcNGmS9u3bp9zcXNXU1Cg+Pl7FxcXet0jW1NT4fGZDbGysiouLlZGRoUWLFik6OloLFy70vt1SkmJiYrRq1SplZGToggsu0Omnn6777rtPs2bN6oZdBAAA3SHg0CBJ6enpSk9P93vdsmXL2o2NGDFCGzdu7LBnUlKS/va3v3VlOgAA4DjguycAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADgpEuhYfHixYqNjVVYWJgSEhK0du3aDuvXrFmjhIQEhYWFadCgQSooKPC5ftmyZfJ4PO0uX331VVemBwAAekDAoWH58uWaMWOGsrOzVV5eruTkZI0ZM0bV1dV+63fu3KmxY8cqOTlZ5eXlmjNnjqZPn64VK1b41PXp00c1NTU+l7CwsK7tFQAA6Ha9At1gwYIFmjp1qlJTUyVJ+fn5evXVV7VkyRLl5eW1qy8oKFD//v2Vn58vSYqLi9P69es1f/58TZw40Vvn8XgUGRnZxd0AAAA9LaCVhsbGRm3YsEEpKSk+4ykpKSotLfW7TVlZWbv60aNHa/369WpqavKOffHFFxowYIDOOOMMXXvttSovL+9wLg0NDdq/f7/PBQAA9JyAVhrq6urU0tKiiIgIn/GIiAjV1tb63aa2ttZvfXNzs+rq6hQVFaUhQ4Zo2bJlOv/887V//3499dRTuvzyy7Vp0yYNHjzYb9+8vDzl5OQEMn30kIGzVzrX7npsXA/OBPhu4DGHf5YunQjp8Xh8fjazdmOd1R85ftlll+m2227ThRdeqOTkZP3ud7/T2WefrV/96ldH7ZmVlaX6+nrvZffu3V3ZFQAA4CiglYZ+/fopKCio3arCnj172q0mtImMjPRb36tXL4WHh/vd5oQTTtAll1yi999//6hzCQ0NVWhoaCDTBwAAxyCglYaQkBAlJCSopKTEZ7ykpETDhw/3u01SUlK7+lWrVikxMVHBwcF+tzEzVVRUKCoqKpDpAQCAHhTw4YnMzEwtXbpURUVFqqysVEZGhqqrq5WWlibp8GGDKVOmeOvT0tJUVVWlzMxMVVZWqqioSIWFhZo5c6a3JicnR6+++qp27NihiooKTZ06VRUVFd6eAADgny/gt1xOmjRJ+/btU25urmpqahQfH6/i4mINGDBAklRTU+PzmQ2xsbEqLi5WRkaGFi1apOjoaC1cuNDn7Zaff/657r77btXW1qpv37666KKL9D//8z+69NJLu2EXAQBAdwg4NEhSenq60tPT/V63bNmydmMjRozQxo0bj9rvySef1JNPPtmVqQAAgOOE754AAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAky6FhsWLFys2NlZhYWFKSEjQ2rVrO6xfs2aNEhISFBYWpkGDBqmgoOCotS+99JI8Ho/Gjx/flakBAIAeEnBoWL58uWbMmKHs7GyVl5crOTlZY8aMUXV1td/6nTt3auzYsUpOTlZ5ebnmzJmj6dOna8WKFe1qq6qqNHPmTCUnJwe+JwAAoEcFHBoWLFigqVOnKjU1VXFxccrPz1dMTIyWLFnit76goED9+/dXfn6+4uLilJqaqjvvvFPz58/3qWtpadGtt96qnJwcDRo0qGt7AwAAekxAoaGxsVEbNmxQSkqKz3hKSopKS0v9blNWVtaufvTo0Vq/fr2ampq8Y7m5ufr+97+vqVOnOs2loaFB+/fv97kAAICe0yuQ4rq6OrW0tCgiIsJnPCIiQrW1tX63qa2t9Vvf3Nysuro6RUVF6a233lJhYaEqKiqc55KXl6ecnJxApv+dN3D2SufaXY+N68GZAPhX1JN/I/j78+3QpRMhPR6Pz89m1m6ss/q28QMHDui2227Ts88+q379+jnPISsrS/X19d7L7t27A9gDAAAQqIBWGvr166egoKB2qwp79uxpt5rQJjIy0m99r169FB4erq1bt2rXrl267rrrvNe3trYenlyvXtq+fbvOPPPMdn1DQ0MVGhoayPQBAMAxCGilISQkRAkJCSopKfEZLykp0fDhw/1uk5SU1K5+1apVSkxMVHBwsIYMGaJ33nlHFRUV3sv111+vH/3oR6qoqFBMTEyAuwQAAHpCQCsNkpSZmanJkycrMTFRSUlJeuaZZ1RdXa20tDRJhw8bfPTRR3r++eclSWlpaXr66aeVmZmpu+66S2VlZSosLNSLL74oSQoLC1N8fLzP/3HqqadKUrtxAADwzxNwaJg0aZL27dun3Nxc1dTUKD4+XsXFxRowYIAkqaamxuczG2JjY1VcXKyMjAwtWrRI0dHRWrhwoSZOnNh9ewEAAHpcwKFBktLT05Wenu73umXLlrUbGzFihDZu3Ojc318PAADwz8V3TwAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMAJoQEAADghNAAAACeEBgAA4ITQAAAAnBAaAACAE0IDAABwQmgAAABOCA0AAMBJl0LD4sWLFRsbq7CwMCUkJGjt2rUd1q9Zs0YJCQkKCwvToEGDVFBQ4HP9H/7wByUmJurUU09V7969NXToUP3f//t/uzI1AADQQwIODcuXL9eMGTOUnZ2t8vJyJScna8yYMaqurvZbv3PnTo0dO1bJyckqLy/XnDlzNH36dK1YscJbc9pppyk7O1tlZWXavHmz7rjjDt1xxx169dVXu75nAACgWwUcGhYsWKCpU6cqNTVVcXFxys/PV0xMjJYsWeK3vqCgQP3791d+fr7i4uKUmpqqO++8U/Pnz/fWjBw5UhMmTFBcXJzOPPNM3Xfffbrgggv05ptvdn3PAABAtwooNDQ2NmrDhg1KSUnxGU9JSVFpaanfbcrKytrVjx49WuvXr1dTU1O7ejPT66+/ru3bt+uKK6446lwaGhq0f/9+nwsAAOg5vQIprqurU0tLiyIiInzGIyIiVFtb63eb2tpav/XNzc2qq6tTVFSUJKm+vl6nn366GhoaFBQUpMWLF2vUqFFHnUteXp5ycnICmf43xsDZK51rdz02rgdnAgD/2nrq7yV9/evSiZAej8fnZzNrN9ZZ/dfHTznlFFVUVOjtt9/WI488oszMTK1evfqoPbOyslRfX++97N69uwt7AgAAXAW00tCvXz8FBQW1W1XYs2dPu9WENpGRkX7re/XqpfDwcO/YCSecoLPOOkuSNHToUFVWViovL08jR4702zc0NFShoaGBTB8AAByDgFYaQkJClJCQoJKSEp/xkpISDR8+3O82SUlJ7epXrVqlxMREBQcHH/X/MjM1NDQEMj0AANCDAlppkKTMzExNnjxZiYmJSkpK0jPPPKPq6mqlpaVJOnzY4KOPPtLzzz8vSUpLS9PTTz+tzMxM3XXXXSorK1NhYaFefPFFb8+8vDwlJibqzDPPVGNjo4qLi/X8888f9R0ZAADg+As4NEyaNEn79u1Tbm6uampqFB8fr+LiYg0YMECSVFNT4/OZDbGxsSouLlZGRoYWLVqk6OhoLVy4UBMnTvTWHDx4UOnp6frwww914oknasiQIfrNb36jSZMmdcMuAgCA7hBwaJCk9PR0paen+71u2bJl7cZGjBihjRs3HrXfvHnzNG/evK5MBQAAHCd89wQAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcEBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACcdCk0LF68WLGxsQoLC1NCQoLWrl3bYf2aNWuUkJCgsLAwDRo0SAUFBT7XP/vss0pOTtb3vvc9fe9739PVV1+tdevWdWVqAACghwQcGpYvX64ZM2YoOztb5eXlSk5O1pgxY1RdXe23fufOnRo7dqySk5NVXl6uOXPmaPr06VqxYoW3ZvXq1frJT36iN954Q2VlZerfv79SUlL00UcfdX3PAABAtwo4NCxYsEBTp05Vamqq4uLilJ+fr5iYGC1ZssRvfUFBgfr376/8/HzFxcUpNTVVd955p+bPn++teeGFF5Senq6hQ4dqyJAhevbZZ9Xa2qrXX3/9qPNoaGjQ/v37fS4AAKDn9AqkuLGxURs2bNDs2bN9xlNSUlRaWup3m7KyMqWkpPiMjR49WoWFhWpqalJwcHC7bQ4dOqSmpiaddtppR51LXl6ecnJyApl+txo4e6Vz7a7HxvXgTAAAOD4CWmmoq6tTS0uLIiIifMYjIiJUW1vrd5va2lq/9c3Nzaqrq/O7zezZs3X66afr6quvPupcsrKyVF9f773s3r07kF0BAAABCmiloY3H4/H52czajXVW729ckh5//HG9+OKLWr16tcLCwo7aMzQ0VKGhoYFMGwAAHIOAQkO/fv0UFBTUblVhz5497VYT2kRGRvqt79Wrl8LDw33G58+fr0cffVSvvfaaLrjggkCmBgAAelhAhydCQkKUkJCgkpISn/GSkhINHz7c7zZJSUnt6letWqXExESf8xmeeOIJzZ07V3/5y1+UmJgYyLQAAMBxEPC7JzIzM7V06VIVFRWpsrJSGRkZqq6uVlpamqTD5xpMmTLFW5+WlqaqqiplZmaqsrJSRUVFKiws1MyZM701jz/+uO6//34VFRVp4MCBqq2tVW1trb744otu2EUAANAdAj6nYdKkSdq3b59yc3NVU1Oj+Ph4FRcXa8CAAZKkmpoan89siI2NVXFxsTIyMrRo0SJFR0dr4cKFmjhxordm8eLFamxs1I033ujzfz300EN6+OGHu7hrAACgO3XpRMj09HSlp6f7vW7ZsmXtxkaMGKGNGzcetd+uXbu6Mg0AAHAc8d0TAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgJMuhYbFixcrNjZWYWFhSkhI0Nq1azusX7NmjRISEhQWFqZBgwapoKDA5/qtW7dq4sSJGjhwoDwej/Lz87syLQAA0IMCDg3Lly/XjBkzlJ2drfLyciUnJ2vMmDGqrq72W79z506NHTtWycnJKi8v15w5czR9+nStWLHCW3Po0CENGjRIjz32mCIjI7u+NwAAoMcEHBoWLFigqVOnKjU1VXFxccrPz1dMTIyWLFnit76goED9+/dXfn6+4uLilJqaqjvvvFPz58/31lxyySV64okndMsttyg0NLTrewMAAHpMQKGhsbFRGzZsUEpKis94SkqKSktL/W5TVlbWrn706NFav369mpqaApzu/2poaND+/ft9LgAAoOf0CqS4rq5OLS0tioiI8BmPiIhQbW2t321qa2v91jc3N6uurk5RUVEBTvmwvLw85eTkdFo3cPZK5567HhvXpbkAAPBd0KUTIT0ej8/PZtZurLN6f+OByMrKUn19vfeye/fuLvcCAACdC2iloV+/fgoKCmq3qrBnz552qwltIiMj/db36tVL4eHhAU73f4WGhnL+AwAAx1FAKw0hISFKSEhQSUmJz3hJSYmGDx/ud5ukpKR29atWrVJiYqKCg4MDnC4AAPhnCfjwRGZmppYuXaqioiJVVlYqIyND1dXVSktLk3T4sMGUKVO89WlpaaqqqlJmZqYqKytVVFSkwsJCzZw501vT2NioiooKVVRUqLGxUR999JEqKir0wQcfdMMuAgCA7hDQ4QlJmjRpkvbt26fc3FzV1NQoPj5excXFGjBggCSppqbG5zMbYmNjVVxcrIyMDC1atEjR0dFauHChJk6c6K35+OOPddFFF3l/nj9/vubPn68RI0Zo9erVx7B7AACguwQcGiQpPT1d6enpfq9btmxZu7ERI0Zo48aNR+03cOBA78mRAADgXxPfPQEAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnhAYAAOCE0AAAAJwQGgAAgBNCAwAAcEJoAAAATggNAADACaEBAAA4ITQAAAAnXQoNixcvVmxsrMLCwpSQkKC1a9d2WL9mzRolJCQoLCxMgwYNUkFBQbuaFStW6Nxzz1VoaKjOPfdc/b//9/+6MjUAANBDAg4Ny5cv14wZM5Sdna3y8nIlJydrzJgxqq6u9lu/c+dOjR07VsnJySovL9ecOXM0ffp0rVixwltTVlamSZMmafLkydq0aZMmT56sm2++WX//+9+7vmcAAKBbBRwaFixYoKlTpyo1NVVxcXHKz89XTEyMlixZ4re+oKBA/fv3V35+vuLi4pSamqo777xT8+fP99bk5+dr1KhRysrK0pAhQ5SVlaWrrrpK+fn5Xd4xAADQvXoFUtzY2KgNGzZo9uzZPuMpKSkqLS31u01ZWZlSUlJ8xkaPHq3CwkI1NTUpODhYZWVlysjIaFfTUWhoaGhQQ0OD9+f6+npJ0v79+33qWhsOdbpfbb6+bUd6qm9P9qYvfY9Xb/rS93j1pm/39G0bM7OON7YAfPTRRybJ3nrrLZ/xRx55xM4++2y/2wwePNgeeeQRn7G33nrLJNnHH39sZmbBwcH2wgsv+NS88MILFhISctS5PPTQQyaJCxcuXLhw4dJNl927d3eYAwJaaWjj8Xh8fjazdmOd1X99PNCeWVlZyszM9P7c2tqqTz/9VOHh4R1uJx1OVDExMdq9e7f69OnTYW0g6NuzfXuyN33pe7x605e+x6t3IH3NTAcOHFB0dHSHdQGFhn79+ikoKEi1tbU+43v27FFERITfbSIjI/3W9+rVS+Hh4R3WHK2nJIWGhio0NNRn7NRTT3XdFUlSnz59uv2XT9+e79uTvelL3+PVm770PV69Xfv27du305qAToQMCQlRQkKCSkpKfMZLSko0fPhwv9skJSW1q1+1apUSExMVHBzcYc3RegIAgOMv4MMTmZmZmjx5shITE5WUlKRnnnlG1dXVSktLk3T4sMFHH32k559/XpKUlpamp59+WpmZmbrrrrtUVlamwsJCvfjii96e9913n6644gr94he/0A033KA//vGPeu211/Tmm292024CAIBjFXBomDRpkvbt26fc3FzV1NQoPj5excXFGjBggCSppqbG5zMbYmNjVVxcrIyMDC1atEjR0dFauHChJk6c6K0ZPny4XnrpJd1///164IEHdOaZZ2r58uUaNmxYN+xie6GhoXrooYfaHd6g7792357sTV/6Hq/e9KXv8erdE309Zp29vwIAAIDvngAAAI4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNCAHtVTb875Jr3pp7W1tcd6f5NuB+B44/HR/QgN30DfhAdC2zeQejyebp3vJ5984u3bnT755BPV1dV1a09J2rlzp5YuXaqWlpZuvR3agkh33w7At8HBgwcl9ezj45vwd7gnfOdCQ3V1tVauXKmlS5eqpqbGe+c6Vl999VW39PHnk08+0dtvv60//elPkrrvibi6ulq///3vtWDBAn344YfH3K/N9u3blZqaqjfeeENS981306ZNGjp0qP76178ec68jvfPOO7r88sv1wgsv6Isvvui2vps3b9a5556rnJwcSd13O7z//vt68MEHdfvtt+v555/Xvn37jrlnm927d+u1115TUVGRPvnkEx065P51u4H6Lv7RNTO1tLR0e99PP/1Ue/fu7fa+0uHH81tvvdXtfT/44AP993//txobG7u17/bt25WWltatf9Mk6dChQ/rss8+8f+v/1QPJ0Z7rjrl3h9+B+S2zadMmi4iIsIsuushOPfVUi4mJsZkzZ9qOHTuOqe+WLVvssssus9WrV3fTTP/X5s2b7YILLrDzzjvPTj75ZEtMTLRDhw6ZmVlra+sx9R04cKANHz7cTjvtNIuNjbWamppjnm9DQ4P9+Mc/No/HY7fffrvP16gfy3wrKiosLCzMfv7zn7e77lj6bt++3cLDw+1nP/uZ7du3r8t9vq6iosJOOukku+222/x+PXxXbd682cLDw+3mm2+2yy67zOLj4+2VV17plt6bNm2yqKgoGzFihEVHR9vAgQNt1qxZnX5Vbmfeffddy8jIsEmTJlleXp5t2LDBe92x/O4++eQT++yzz45pbv7s2LHDFixYYJmZmfbSSy91W9/t27fbfffdZ+PGjbOcnByrq6vrlr7/+Mc/bNCgQfbAAw/YRx991C0925SXl9tJJ51kCxcu7Na+mzdvtoiICLv33nvt448/7ra+FRUVduKJJ5rH47Ff//rX3dZ3y5YtNnbsWIuLi7MbbrjBVq5c2S193333XZs9e7ZNnjzZnnjiCSsvL/dedyyPjc6e646l93cmNHz22WeWkJBgP/vZz+zTTz81M7OcnBxLTk6266+/3t5///0u9d21a5cNGTLEQkJC7PTTT7e1a9d225zfe+89i4iIsDlz5lhlZaW9++67NmTIEJs8efIx9X333XftBz/4gT3wwAP26aefWmtrq0VHR9vzzz/fLfOeO3eujRs3zoYMGWLXXnut/c///M8x9du6dauFhYXZww8/bGaH7/BVVVW2bt06a2xsPKYHwMyZM+0nP/mJmZm1tLTYf//3f9sTTzxhr7/+epf/mFVUVFjv3r0tOzvbzMxuueUWGzVqlDU1NXV5nmZme/bssaFDh9r999/vHRs5cmS3BJKamhqLj4+3hx9+2Pbv329mZtOmTTOPx2MTJkywDz74oEt9t27dan379rVrr73WbrvtNouMjLTk5GT75S9/6a3pyu9v27ZtFhISYjfeeKPV19d3aW7+bN682c444wy7+uqrbfjw4XbCCSfY448/3i19f/CDH9iNN95o99xzj4WEhHjvz8dqyZIl5vF47KKLLrJHHnnEJ/y3trZ2+fHRFnz/4z/+46g1XeldVVVl/fv39/sC4Fj6tgWGn//85zZz5kxLTk7ulhdCW7dute9973s2bdo0KygosMsvv9xuu+22Y57v1q1b7dRTT7WbbrrJ0tLSLDo62oYOHWpLliw5pr6uz3VdvV98Z0JDVVWVDRgwwF599VWf8eeee86uuOIK++lPfxrwk0RjY6P98pe/tPHjx9vmzZvtxhtvtH79+nVLcDh48KDdfvvtds8991hzc7N3/Je//KX98Ic/7HLfAwcO2OTJk+3f//3frbm52XvHuf766y0vL89mzZplr732mu3duzfg3m29nnzyScvNzbWdO3faOeecYxMmTLBt27bZrFmzbPv27QH1/Pzzz2348OEWExPjHbv55pstPj7ewsLCbPDgwbZ06VL7/PPPA56vmdk111xjCxYsMDOzyy+/3IYPH25nnHGGxcfHW0pKir377rsB9fvHP/5hHo/HGxjMzNauXWsej8dWrFjRpTm22bx5s51zzjm2fv1679gdd9xh/+f//B+79tpr7aGHHgp4vm1KS0tt6NChtmPHDu/9bceOHRYbG2uXXHKJ3X777QGvxDQ2NtqUKVNs6tSp3rGqqipLS0uziy++2ObNm+cdD+QPWG1trV1++eV21VVXWb9+/eymm27qluCwa9cuO+uss+znP/+59zYoLCy0yMjILr+oMDt8Ow4cONCysrK8Yw8//LClp6dbY2OjT21X/pBv2rTJbr/9dps3b55FR0fb3Llzj3kF5r333rPQ0FDv/bixsdH+8Ic/2K9+9St76aWX7JNPPuly7z/96U82duxYb9/s7GybMGGCpaam2nPPPeetC+S2WL9+vfXp08fmzJljZmYvvvii9e3b1958800zO/yCoCsOHTpk48ePt/vuu8879sc//tF+/OMf2yeffGIHDhzo0nwPHDhgo0eP9glO1dXVduqpp1pkZOQxvRDoiee6I31nzmkICgrSiSeeqI8//liS1NzcLEmaMmWKbr31Vm3ZssX79dzmeMwnODhYF1xwgSZPnqzzzz9fv/vd7zRixAhNmDDhmL+hMywsTCeeeKLOOussBQUFeceHDh2qXbt26fPPP1dTU1PAfU8++WRde+21uu222xQUFCSPx6O5c+equLhY69ev1+rVq3X33XersLAw4LP+247xXXHFFVq/fr0GDhyo3//+99q+fbuuueYaLV682Hvbut7Gffv21YQJEzR48GDdfvvtSkxM1KFDh5Sbm6tNmzZp+PDheuyxxwL+3bWJiYlRVVWV8vLy1Lt3b/3ud79TVVWVcnNz5fF49NhjjwV0vsqgQYNUVFSkefPmSZJaWlo0bNgwjR8/Xr/97W914MCBgOZ3pC+//FJNTU36+9//rr179yovL0+/+c1v1L9/f/Xr10+lpaWaOXNml07orK2t1YcffqiTTz7Ze3/bu3evzjjjDI0cOVKrV6/W1q1bJQX2+KipqfH5nffv318PPvigrrjiCr3yyit64YUXJLkfHzYzlZeXa8CAAcrLy9PKlSv1+uuvKzU1Vfv37w90t71aW1v10ksv6ayzztKcOXO8t8Gll16q4ODgLp+H0NLSohUrVmjMmDGaPXu2d/zDDz9UeXm5Lr/8ct17770+5ysFysxUWlqqOXPm6J577tEzzzyj5557Tj/+8Y+VnZ0dcL/m5mY9/fTTOvnkkzV06FBJ0g033KCcnBw99dRTmjx5slJTU7V69eqAe0vSxo0b9emnn0qSxo4dq7feekv9+/dXVVWVnnzySc2ZM0eS221hZjp48KBGjBihqVOn6pFHHpEk3XLLLUpMTNSDDz6o5uZmnXBC157qQkNDVVdXp9NOO807tnbtWm3cuFEJCQm64YYblJWV5TzfNieccII+/fRT7+176NAhxcTE6Oqrr9Z5552nlStX6s9//nOX5uzxeJyf67r0zq4ux41voOuuu86GDh3qTeFHLhffeOONlpSUdMz/R1NTk3fFoS3lNjU1WUlJiXepqDNtibXt3IUjx1avXm2DBw/2WX348MMPnZK0vyS8adMmi4uLsz/96U/e2+Pee++1c845x7744gun+X69d0VFhZ111lneV3/XXXedBQcH28iRI+3tt9927nnkPj311FN27rnn2jXXXNMuJY8ePTrg1Ze22+/RRx+1Cy+80CZOnGiPPfaYT81TTz1lAwcOdD723NHhh8WLF1vfvn29KwFdfeVz++232+DBg+3KK6+0k046yV5++WXvdS+88IKdfvrptnHjxoD7fvXVV3bWWWfZ6NGj7fXXX7dXX33VevfubQ8++KCZmSUlJdk999wTUM+Ghga74447bPz48fbll19aa2urd7+rqqpszJgxdv311wc8108++cTeeOMN789lZWV22mmn2U033eSz4hToq/bVq1f7rAaYHf49xcbG+vx/gaqurraysjLvz3PnzrWgoCDLzs62hQsX2iWXXGJXXXXVMS2lp6Sk2M6dO83M7PHHH7fevXtb3759273adLV9+3a7++677dJLL7WYmBgbN26cbd++3Zqbm+2dd96x8847zyZOnNil3iUlJTZy5EhbunSpjRo1yj788EMzO7yqmJOTY5dddplt3bo1oJ5HnpfW9th+9tln7eyzz/aeQ9OVx9xnn31mo0ePtvHjx9vTTz9tWVlZduKJJ9qvf/1r+/Of/2w5OTl28cUX2x//+MeA+tbU1Fh0dLTPoa/du3fbueeea88995xdcMEFlpqa6tzv448/9rnNrr322h57rvvWhoYvvvjC9u/f77NsuXfvXouNjbVRo0ZZQ0ODT/2zzz5rl112Wbtxl75mvn+gGhsbvcHhjTfesHvuuceGDBnS6ZLe0XofeWdfvXq1nXnmmd7/b+bMmTZy5Eg7ePBgwH3NzOrr670nT7UtlT733HN24YUXeo9tB9r3q6++sgkTJtiXX35pd9xxh51xxhn24osv2vnnn28jR460v//9713q+/zzz9srr7zi3fe2B8Ls2bOdQsPR+iYnJ5vH47EpU6b4LBdv3LjRzj333E5PBOzo9j3yfjFs2DC75ZZbnJ/MjtZ327Zt9uabb9qQIUNs165dPuODBw+2devWdan3pk2b7IILLrCoqCiLioqyWbNmea+78cYbfQ4zHM2+ffussrLS3nvvPTM7/IQeFBRkTz31lLem7f68bt0683g8Pid/ddR327Zt7Q5vtT1B/O1vf/MGh/r6emtsbLTFixfbqlWrutS37XfU2tpqgwYN8unz2muv2Z49e7rUt66uzmbMmGF//vOfvWPbtm0zj8fjM9ZR37bb98j76ogRI7xL+1OnTrU+ffpYZGSkPf74484nR7bNuS3Y7t692yZPnmzXXnut9/fZ5rXXXjOPx2ObN28OaM4tLS22c+dOi46OtnPPPdeuvvpqn9rq6mo76aST7Le//a1T361bt9r27dvtq6++anf9gQMHLCYmxqZNm9ZpL3/zbfvdlZeX29ixY+2nP/2pnXPOOVZYWOitra2ttf79+1teXp5z37bb99lnnzWPx2N33nmn3X///XbKKafYXXfdZWZm//Vf/+V9wdJZ2Pnwww8tPDzcJkyY4A2ne/futYEDBx7Tc93RfCtDw9atWy0lJcUuuugii46Ott/85jfeG76srMxiYmJsxIgR9u6779qXX35pZmZ33XWXjRo1yu+dr6O+Zv5f0TQ1NdlNN91kHo/HTj755E5fYR+t99eVlpZadHS0NTU12Zw5c+zEE0+0v/3tb8c056/Pf9q0aXbTTTd5b5tA59va2mpXXnml9e7d2yIjI737vmHDBrvkkkusuro6oL5Hrqp8/RiwmdnkyZPtnnvusZaWlqM+Ifvr2xY62o6Rn3zyyVZQUOA9dj9r1ixLTEzs8HwJ1/tEa2urzZ071+Lj472vrDrS2e1QXl5u8fHxVlVV5R2bPXu2nX/++Z0+oXV2X3vvvfd8juG3tLTYDTfc4D0H4Wi38TvvvGMXXXSRnX/++RYcHOw90e+JJ56wE044wZ555hmf+m3bttl5553X6XkuR/YNCQmxuXPnWlNTU7t5/P3vf7fTTjvNbr75ZrvjjjssODi4wxM4O+vb2NhoX3zxhZ111lnex1hWVpZ5PJ4On4j99T3yd9cW8NtWXrZs2WIJCQmdPgEf2Tc0NNTmzp3rfYzOmjXLnn/+efv3f/93i46Oth07dtijjz5qJ510kv3yl7/0+f9d5pyTk2Nmh8/z+Mtf/uJ93LWdWPnKK6/YOeec0+kLoa/3bbtPvPzyy9arVy/7wQ9+YKWlpd76hoYGu/LKK+0vf/lLwLfFkfvY9u9FixbZmWee6XMekGvfI+/DBw4csObmZktKSrLly5d76xsbG23UqFG2aNEi7+3j0jc3N9caGxutqKjILr30UrvmmmvsF7/4hbf+V7/6lV100UVOLzD++te/Wq9evezKK6+0KVOmeF80lJWVWVRUlF1++eUBP9d15FsXGrZu3Wrh4eGWkZFhv/3tby0zM9OCg4N9lmzfeecdO//88+3MM8+0xMREu+666+yUU06xioqKgPse7VVSc3Oz3X333Xbaaad1utQWSO8333zTLrzwQsvIyLCQkBCft68d65wPHTpk999/v/Xr16/DObv0/fWvf23jxo3zPljbQltnoSyQ+X755ZeWnZ1t3//+9zs8AdDlPnHgwAEbNWqUDR482CIjI23UqFEWHh7e4avgQOf72Wefmcfjsblz5x61p2vf1tZWi4uLs7i4OLvzzjvttttu63S+rrfFkfbu3WuzZs2y8PDwdq82/fWdOXOmbd261ebPn28ej8eqq6utqanJHn74YfN4PJaVlWXr16+3vXv32uzZs23QoEFWW1vbpb5Hart/vfnmm+bxeOy0005zemx01LelpcUOHjzofdLJzc213r17d7iS49L3608E2dnZNmzYsA7D3tH6toXGwsJC83g8FhER4fMC5Re/+EWHv7eOeretYvl7pfvzn//crrrqqk4Dtb++bYdRfvvb39oJJ5xgo0aNshdffNHef/99mz17tkVHR3f6wsLlPmF2+ATJ008/3fuk3pXboe02PnDggA0bNszmzJljn332mR04cMAeeOABi4qK6vBt+1/v+8QTT/j0PXToULtX/f/2b/9mN954o/ewXkf27dtn119/vf3nf/6nXXzxxfbTn/7Utm3bZmaHVw9/+MMf2qBBg5yf6zrzrQoN+/bts5SUFJs+fbrP+I9+9CPv2JG/gKefftpmz55tOTk5HT7pBNrXzKyoqMg8Hk+nCTfQ3m3LguHh4R3+UQy071/+8hcbN26cDRgwoMNj4i59zQ4/Qfp7B8bRHgCBznflypV21VVXdXoM36XvkasXr776qj355JP261//2v7xj38cU98j59v2yuexxx6zysrKbpnvF198YT/5yU9s3LhxNnXqVO8fiu6a87Zt2+xnP/uZ9e/fv8PbeO/evXbFFVf4nGHe2tpqo0ePttLSUquoqLCqqip7+eWXLSoqyiIjI23IkCGd/u6O1veaa66x0tJSKy8v93mi+OqrrywtLc1OOeWUDkOvS98jD0kNHTrULrnkEgsJCelwxTDQvlu2bLH777/f+vTpY5s2bepS37feesvKy8vt9ddft/nz53ufDFyP33fWe+PGjT638ebNmy07O9v69OnT4cpIZ303bNhgBw8etA0bNlhSUpJ9//vftyFDhtjZZ5/drfcJs8PnAZ1zzjkdvj27s74bNmywQ4cO2apVq8zj8djgwYNt2LBhnf697Oix8eabb9rGjRt9Vgu3bdtmM2bMsFNOOcXp0E9zc7Pt2bPHzj77bPvwww/tD3/4g11yySWWmppqw4cPtylTppiZ2cKFC52e61x8q0JDbW2tXXrppd7PBWh74EydOtVuvfVWb11nS3Vd7Xukt99+25uou7N3fX29paSkdPhHpit9Dx06ZPPnz+/0VYlL3668bSzQ+R48eNDmzZvX6QPgX+k+YdbxyZKB9P36k4LLZ0B0Zc6rV6/u8FWf2eHj9I8++qjPfSc3N9c8Ho9deOGFFhMTYykpKfaPf/zDPv74Y1uzZo2tWrWq08M0HfUdOnSonXHGGTZ69GjvW5zXrVtn559/fqfndLj2Xb16tX3xxRfWt29fCw4O7vSPeCDzra2ttQkTJth5553X6au+zm7f/v3727XXXtulkx4DmfPHH39so0ePtrPOOqvTFa3O5nz66afb1Vdfbdu3b7cDBw7Ye++9Z5s2ber0rd6B3ifMDt8vOvsAv876ts333XfftXXr1tm8efPsmWee6fRvfCDz/eqrr2zhwoX2ox/9yOk8H7P//Vt76623eg/prFy50vr162cnn3yyPfvss059AvGtCg1m5vPLaXtF9uCDD7b7QKQjT/JzeZLrSt/unnPbUqC/4/rH0jfQ97i79j3yPczf5fn+q9wOPdn7yPv9iy++aB6Px1566SXbt2+frV692hITE73vxOiuvmvWrLFLL73Ue9y5vr7e+R1KLn0feughMzNbvny5bdmypdvnu2XLFudP2+yo7xtvvOHTN1CBzLlt1ag7+iYmJnpv456ab3f2veSSS3r8PlxXV+d8Hz7SlClTbPbs2WZ2+EXA9773PTv33HPtzjvv9HnnzrF8EF6bXl16I+i/sMGDB0s6/P7T4OBgSYffK932RUeSlJeXp9DQUE2fPl29evVyen9tV/p295xDQkJ03333eWv+WXOm7zezb0/2PuWUU7z/TkpK0vr163XxxRdLkkaMGKGoqCiVl5c7z9Ol7xVXXKGIiAht2LBBktSnT58e6XvzzTd3a9/169dLks4777xu6Tty5Eif+QYqkDlfeOGF3dY3KipKGzdu7JH5duW26KxvZGRkj8237fYNDw8PqLeZyePx6Morr9SOHTuUnp6u4uJibdiwQRUVFfrZz36mkJAQXXTRRQoNDe2W78v41oWGNieccIL3BvV4PN4Pa3nwwQc1b948lZeXB/THtqf7fhPnTN9vZt+e7j1gwAANGDBA0uE/ao2NjTr55JMVHx/fpX70PT59v4lz/q73bQsBsbGxuuOOOxQREaFXXnlFsbGxio2Nlcfj0YUXXqjQ0NBjmveRvtWfCGn//yfRBQUFKSYmRvPnz9fjjz+u9evXB5SYj1ffb+Kc6fvN7NvTvdt4PB498sgjeuutt3TTTTd1S0/69nzfnuxN3+7vm5SUpKVLl+rVV19VQkKC97E9fvx4xcbGdsd0/9cxH+D4Bpg3b555PB7r27dvQJ9I+M/q25O96Uvf49X7v/7rv2zatGkWHh7epU+ppO8/p29P9qZvz/Xt6qfMBuo7ERrefvtt83g8AX806T+rb0/2pi99j1fvLVu22M0330zfb1jfnuxN357tezx4zAL8hp9vqIMHD6p3797fmL492Zu+9D1evZuampxP3KXvv07fnuxN357t29O+M6EBAAAcm2/1iZAAAKD7EBoAAIATQgMAAHBCaAAAAE4IDQAAwAmhAQAAOCE0AAAAJ4QGAADghNAAAACc/H8+gwZUkTXIMgAAAABJRU5ErkJggg==",
"text/plain": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"_, ax = plt.subplots(figsize=(6, 6))\n",
"\n",
"plt.plot(means, 'o-')\n",
"\n",
"ax.set_xticks(range(len(means)))\n",
"ax.set_xticklabels(['20', '25', '30', '35', '40'])\n",
"\n",
"plt.show()\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ans:\n",
"\n",
"### We should order 20 newspapers each night to make the mean profit by 2 dollars.\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Problem 3\n",
"\n",
"You are taking reservations for an airline flight. This particular flight uses an aircraft with 50 first- class seats and 190 economy-class seats.\n",
"\n",
"First-class tickets on the flight cost $600, with demand to purchase them distributed like a Poisson random variable with mean 50. Each passenger who buys a first-class ticket has a 93% chance of showing up for the flight. If a first-class passenger does not show up, he or she can return their unused ticket for a full refund. Any first class passengers who show up for the flight with tickets but are denied boarding are entitled to a full refund plus a $500 inconvenience penalty.\n",
"\n",
"Economy tickets cost $300. Demand for them is Poisson distributed with a mean of 200, and is independent of the demand for first-class tickets. Each ticket holder has a 96% chance of showing up for the flight, and \"no shows\" are not entitled to any refund. If an economy ticket holder shows up and is denied a seat, however, they get a full refund plus a $200 penalty. If there are free seats in first class and economy is full, economy ticket holders can be seated in first class.\n",
"\n",
"The airline allows itself to sell somewhat more tickets than it has seats. This is a common practice called \"overbooking\". The firm is considering the 18 possible polices obtained through all possible combinations of:\n",
"\n",
"- Allowing overbooking of up to 0, 5, or 10 first-class seats\n",
"- Allowing overbooking of up to 0, 5, 10, 15, 20, or 25 economy seats\n",
"\n",
"1. Which option gives the highest average profit?\n",
"2. What are the average numbers of first-class and economy passengers denied seating under this policy.\n",
"3. If no overbooking of first class is allowed, what is the best policy?\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Part3-Problem 1\n",
"\n",
"### You make a perishable, volatile chemical for which you charge $2.25 per liter.\n",
"\n",
"You have 75 regular customers for the chemical, each of whom has an independent 90% chance of placing an order on any given day. You also get an average of 30 orders per day from other, non-regular customers; assume the number of non-regular customers per day has a Poisson distribution.\n",
"\n",
"Every order is for one 20-liter container. You produce the chemical by a process that produces 600 liters of the chemical at a cost of $1300.\n",
"\n",
"Each day, you can run the process any whole number of times. Because it is so unstable, any chemical left unsold at the end of the day must be recycled, at a cost of $0.35 per liter.\n",
"\n",
"What is the best number of times to run the process?\n",
"\n",
" Consider four possible policies of running the process 1, 2, 3 or 4 times.\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Define the scenarios"
]
},
{
"cell_type": "code",
"execution_count": 262,
"metadata": {},
"outputs": [],
"source": [
"# produce the chemical by a process that produces 600 liters of the chemical at a cost of $1300.\n",
"# Consider four possible policies of running the process 1, 2, 3 or 4 times.\n",
"# The process is described by the following dictionaries:\n",
"scen_param = {\n",
" 1: (600, 1300),\n",
" 2: (1200, 2600),\n",
" 3: (1800, 3900),\n",
" 4: (2400, 5200)\n",
"}\n"
]
},
{
"cell_type": "code",
"execution_count": 263,
"metadata": {},
"outputs": [],
"source": [
"class chemSim:\n",
" \"\"\"simulate the chemical producing process for 100 days\n",
" where : scen_param = { 1:(600, 1300), 2:(1200, 2600), 3:(1800, 3900), 4:(2400, 5200)}\n",
" \"\"\"\n",
"\n",
" def __init__(self, scen_param):\n",
" self.days = 100\n",
" self.scen_param = {\n",
" 1: (600, 1300),\n",
" 2: (1200, 2600),\n",
" 3: (1800, 3900),\n",
" 4: (2400, 5200)\n",
" }\n",
"\n",
" def chem_df(self, i):\n",
" regular_order = stats.binom(n=75, p=0.9).rvs(size=self.days)\n",
" # 75 regular customers for the chemical, each of whom has an independent 90% chance of placing an order on any given day.\n",
"\n",
" non_regular_order = stats.poisson(mu=30).rvs(\n",
" size=self.days\n",
" ) # an average of 30 orders per day from other, non-regular customers\n",
"\n",
" chem_prod_sim_df = pd.DataFrame({\n",
" 'regular_L': regular_order * 20,\n",
" 'non_regular_L': non_regular_order * 20,\n",
" 'left_cost': np.zeros(self.days),\n",
" 'produce': self.scen_param[i][0],\n",
" 'cost': self.scen_param[i][1],\n",
" 'sale': np.zeros(self.days)\n",
" }) # Create the simulation dataframe\n",
"\n",
" # analyze the demand and the production of the chemical:\n",
" chem_prod_sim_df_1 = chem_prod_sim_df.copy()\n",
" # if the demand is greater than the production,all the chemicals will be sold in the end.\n",
" chem_prod_sim_df_1.query(expr='regular_L + non_regular_L > produce',\n",
" inplace=True)\n",
" chem_prod_sim_df_1['sale'] = chem_prod_sim_df_1['produce'] * 2.25\n",
"\n",
" chem_prod_sim_df_2 = chem_prod_sim_df.copy()\n",
" # if the demand is less than the production, there will be unsold chemicals which need to be handled in the end, the recycle fee should be considered.\n",
" chem_prod_sim_df_2.query(expr='regular_L + non_regular_L <= produce',\n",
" inplace=True)\n",
" # actuall sale of the chemicals\n",
" chem_prod_sim_df_2['sale'] = (\n",
" chem_prod_sim_df_2['regular_L'] +\n",
" chem_prod_sim_df_2['non_regular_L']) * 2.25\n",
"\n",
" # the recycle fee for the chemical left:\n",
" chem_prod_sim_df_2['left_cost'] = (\n",
" chem_prod_sim_df_2['produce'] -\n",
" (chem_prod_sim_df_2['regular_L'] +\n",
" chem_prod_sim_df_2['non_regular_L'])) * 0.35\n",
"\n",
" # combine the two dataframes of codndiditons together.\n",
" chem_prod_sim_df = pd.concat([chem_prod_sim_df_1, chem_prod_sim_df_2])\n",
" chem_prod_sim_df['profit'] = chem_prod_sim_df['sale'] - (\n",
" chem_prod_sim_df['cost'] + chem_prod_sim_df['left_cost'])\n",
"\n",
" return chem_prod_sim_df\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Simulate the process for each of the four policies for 100 days:\n"
]
},
{
"cell_type": "code",
"execution_count": 264,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"result_Mean_profits = np.empty(shape=(5, 1), dtype=int)\n",
"\n",
"_, ax = plt.subplots(figsize=(10, 5))\n",
"\n",
"for i in range(1, 5):\n",
" result_Mean_profits[i] = np.mean(chemSim(i).chem_df(i)['profit'])\n",
"\n",
" ax.bar(i, result_Mean_profits[i], color='blue', width=0.3)\n",
" ax.set(ylim=(np.min(result_Mean_profits) - 100,\n",
" np.max(result_Mean_profits) + 100),\n",
" xticks=np.arange(1, 5),\n",
" xticklabels=['1', '2', '3', '4'],\n",
" title='Mean Profit of each scenario',\n",
" xlabel='Number of times of the producing process',\n",
" ylabel='Mean Profit')\n",
"\n",
"print(f\"The mean proifts of each scenatio is:{result_Mean_profits[1:]}\")\n",
"\n",
"print(\n",
" f\"\\nSo,if there are {np.argmax(result_Mean_profits) + 1} times of running the process,the highest profit is ${np.max(result_Mean_profits)}.\"\n",
")\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Part3-Problem 2\n",
"\n",
"The management of a hotel is considering renting a portable filtration unit to process the water to make it drinkable. There are three possible filtration units:\n",
"\n",
"\n",
"\n",
"| | Unit1 | Unit2 | Unit3 |\n",
"| :----------------: | :-----: | :------: | :------: |\n",
"| Capacity (Gallons) | 800 | 900 | 1000 |\n",
"| Cost | $\\$800$ | $\\$1000$ | $\\$1300$ |\n",
"\n",
"They are also considering not renting a filtration unit. If they don’t rent a unit, or if the unit’s capacity turns out to be insufficient to meet the hotel guests’ demand for water, the hotel will have to supply bottled water to every occupied room.Providing bottled water will cost the hotel a flat fee of $450, plus $5 per occupied room.The hotel has 250 rooms.\n",
"\n",
"At present, they have 200 room reservations they consider “firm”, with a negligible chance of cancellation.\n",
"\n",
"They have another 35 reservations they consider “doubtful”, each with an independent 65% chance of resulting in an occupied room.\n",
"\n",
"They also expect to get some “last minute” requests for rooms, which they estimate to be Poisson with a mean of 30.\n",
"\n",
"Occupied rooms consume random amounts of water independently from one another.\n",
"\n",
"Each occupied room consumes the amount of water that is distributed according to the normal distribution with an average of 4 gallons of water and a standard deviation of 3.1.\n",
"\n",
"Find an optimal plan for the management and also the probability of not having enough filtered water to meet this optimal demand.\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Analysis\n",
"\n",
"As the bottle water is the suppliment of the hotel filter-drinking system,there are four scenarios:\n",
"\n",
"- Unit1, Unit2, Unit3 and All bottle water with no unit.\n",
"\n",
"Thus we can define the scenarios(scenario,capacity of water, cost) as below:\n"
]
},
{
"cell_type": "code",
"execution_count": 269,
"metadata": {},
"outputs": [],
"source": [
"# define the scenario of bottle water only later since it meet all the demand of water consumption in the hotel.\n",
"vol = []\n",
"\n",
"scen_param = {1: (800, 800), 2: (900, 1000), 3: (1000, 1300), 4: (vol, 450)}\n"
]
},
{
"cell_type": "code",
"execution_count": 270,
"metadata": {},
"outputs": [],
"source": [
"# we would like to simulate each condition in 1000 days\n",
"num_days = 1000\n",
"\n",
"total_rooms = 250\n",
"firm_rooms = 200\n",
"\n",
"binom_rooms = binom.rvs(35, 0.65, size=num_days)\n",
"lastMin_rooms = np.minimum(50 - binom_rooms, poisson.rvs(30, size=num_days))\n",
"\n",
"day_rooms = 200 + binom_rooms + lastMin_rooms\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### halfnormal????\n"
]
},
{
"cell_type": "code",
"execution_count": 271,
"metadata": {},
"outputs": [],
"source": [
"room_consumption = []\n",
"water_consumption = []\n",
"\n",
"for i in range(num_days):\n",
" room_consumption.append(halfnorm.rvs(\n",
" loc=4, scale=3.1, size=day_rooms[i]).astype(int))\n",
" water_consumption.append(room_consumption[i].sum())\n"
]
},
{
"cell_type": "code",
"execution_count": 272,
"metadata": {},
"outputs": [],
"source": [
"# room_consumption = (halfnorm.rvs(loc=4,scale=3.1,size=day_room).astype(int) for day_room in day_rooms)\n",
"# water_consumption = (room_consump.sum() for room_consump in room_consumption)\n",
"# ## XB 0.2s\n"
]
},
{
"cell_type": "code",
"execution_count": 273,
"metadata": {},
"outputs": [],
"source": [
"water_consumption_df = pd.DataFrame(\n",
" {'room_booked': day_rooms, 'water_consumption': water_consumption})\n",
"\n",
"water_consumption_df['shortage_Unit1_800'] = water_consumption_df['water_consumption'] - 800\n",
"water_consumption_df['shortage_Unit1_800_ratio'] = round(\n",
" water_consumption_df['shortage_Unit1_800'] / water_consumption_df['water_consumption'], 2)\n",
"\n",
"water_consumption_df['shortage_Unit2_900'] = water_consumption_df['water_consumption'] - 900\n",
"\n",
"water_consumption_df['shortage_Unit2_900_ratio'] = round(\n",
" water_consumption_df['shortage_Unit2_900'] / water_consumption_df['water_consumption'], 2)\n",
"\n",
"water_consumption_df['shortage_Unit3_1000'] = water_consumption_df['water_consumption'] - 1000\n",
"\n",
"water_consumption_df['shortage_Unit3_1000_ratio'] = round(\n",
" water_consumption_df['shortage_Unit3_1000'] / water_consumption_df['water_consumption'], 2)\n",
"\n",
"water_consumption_df['bottle_water_fee'] = water_consumption_df['room_booked'] * 5\n"
]
},
{
"cell_type": "code",
"execution_count": 274,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"