calculator-copy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Interquartile Rule (IQR)\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "source": [
    "def iqr(q1, q3):\r\n",
    "    iqr = q3 - q1\r\n",
    "    s = 1.5* iqr\r\n",
    "    UB = s +q3\r\n",
    "    LB = q1 - s\r\n",
    "    return q1, q3, iqr, s, UB, LB\r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "source": [
    "print(f\"IQR = {q3} - {q1} = {iqr}\")\r\n",
    "print(f\"S = 1.5 * {iqr} = {s}\")\r\n",
    "print(f\"Upper Boundary = {q3} +{s} = {UB}\")\r\n",
    "print(f\"Lower Boundary = {q1} -{s} = {LB}\")\r\n",
    "print(f\"Valid Range = {LB} <= x <= {UB}\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "IQR = 500 - 200 = 300\n",
      "S = 1.5 * 300 = 450.0\n",
      "Upper Boundary = 500 +450.0 = 950.0\n",
      "Lower Boundary = 200 -450.0 = -250.0\n",
      "Valid Range = -250.0 <= x <= 950.0\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Empirical Rule (68-95-99.7 rule)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "source": [
    "def empirical_rule(mean, std_dev):\r\n",
    "    one_std = []\r\n",
    "    two_std = []\r\n",
    "    three_std = []\r\n",
    "    one_std.extend([mean-std_dev, mean+std_dev])\r\n",
    "    two_std.extend([mean-(2*std_dev), mean+(2*std_dev)])\r\n",
    "    three_std.extend([mean-(3*std_dev), mean+(3*std_dev)])\r\n",
    "    return one_std, two_std, three_std\r\n",
    "one_std, two_std, three_std = empirical_rule(600, 60)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "source": [
    "print(f\"68% of data observed fall under {one_std} with 1 standard deviation\")\r\n",
    "print(f\"95% of data observed fall under {two_std} with 2 standard deviation\")\r\n",
    "print(f\"99.7% of data observed fall under {three_std} with 3 standard deviation\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "68% of data observed fall under [540, 660] with 1 standard deviation\n",
      "95% of data observed fall under [480, 720] with 2 standard deviation\n",
      "99.7% of data observed fall under [420, 780] with 3 standard deviation\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Standard Score (Z Score)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "source": [
    "def z_score(data_point, mean, std_dev):\r\n",
    "    z_score = (data_point -mean) /std_dev\r\n",
    "    return data_point, mean, std_dev, z_score\r\n",
    "data_point, mean, std_dev, z_score = z_score(72, 63, 15)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "source": [
    "print(f\"Z Score = ({data_point} - {mean}) / {std_dev}\")\r\n",
    "print(f\"Z Score = {z_score}\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Z Score = (72 - 63) / 15\n",
      "Z Score = 0.6\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# DETERMINISTIC CONTINUOUS REVIEW MODELS"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "source": [
    "import numpy as np\r\n",
    "def deterministic(d, h, K):\r\n",
    "    Q = np.sqrt((2*d*K)/h)\r\n",
    "    t = Q/d\r\n",
    "    return d, h, K, Q, t\r\n",
    "d, h, K, Q, t = deterministic(400, 4500, 2000)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "source": [
    "print(f\"Q*, Order Quantity each unit time = ((2*d*K)/h)^(0.5)\")\r\n",
    "print(f\"Q* = ((2*{d}*{K})/{h})^(0.5)\")\r\n",
    "print(f\"Q* = {Q}\")\r\n",
    "print(f\"t*, Cycle time = Q/d\")\r\n",
    "print(f\"t* = {Q}/{d}\")\r\n",
    "print(f\"t* = {t}\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Q*, Order Quantity each unit time = ((2*d*K)/h)^(0.5)\n",
      "Q* = ((2*400*2000)/4500)^(0.5)\n",
      "Q* = 18.856180831641268\n",
      "t*, Cycle time = Q/d\n",
      "t* = 18.856180831641268/400\n",
      "t* = 0.04714045207910317\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# DETERMINISTIC CONTINUOUS REVIEW MODELS (With Shortage Assumption)\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "source": [
    "def deterministic_shortage(d, h, K, p):\r\n",
    "    S = (np.sqrt((2*d*K)/h))*(np.sqrt(p/(p+h)))\r\n",
    "    Q = (np.sqrt((2*d*K)/h))*(np.sqrt((p+h)/p))\r\n",
    "    t = Q/d\r\n",
    "    Q_S = Q-S\r\n",
    "    return d, h, K, p, S, Q, t, Q_S\r\n",
    "    \r\n",
    "d, h, K, p, S, Q, t, Q_S = deterministic_shortage(400, 4500, 2000, 1500)\r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "source": [
    "print(f\"S*, Optimum Inventory Level (Maximum) = [(2*d*K/h)^0.5]*[(p/(p+h))^0.5]\")\r\n",
    "print(f\"S* = [(2*{d}*{K}/{h})^0.5]*[({p}/({p}+{h}))^0.5]\")\r\n",
    "print(f\"S* = {S} \\n\")\r\n",
    "print(f\"Q*, Optimum Order Quantity Per Unit Time = [(2*d*K/h)^0.5]*[((p+h)/p)^0.5]\")\r\n",
    "print(f\"Q* = [(2*{d}*{K}/{h})^0.5]*[(({p}+{h})/{p})^0.5]\")\r\n",
    "print(f\"Q* = {Q}\\n\")\r\n",
    "print(f\"t*, Optimal Cycle length = Q*/d\")\r\n",
    "print(f\"t* = {Q}/{d}\")\r\n",
    "print(f\"t* = {t}\\n\")\r\n",
    "print(f\"Q*-S*, Maximum Shortage (To Fulfill the backorders) = Q* - S*\")\r\n",
    "print(f\"Q*-S* = {Q} - {S}\")\r\n",
    "print(f\"Q*-S* = {Q_S}\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "S*, Optimum Inventory Level (Maximum) = [(2*d*K/h)^0.5]*[(p/(p+h))^0.5]\n",
      "S* = [(2*400*2000/4500)^0.5]*[(1500/(1500+4500))^0.5]\n",
      "S* = 9.428090415820634 \n",
      "\n",
      "Q*, Optimum Order Quantity Per Unit Time = [(2*d*K/h)^0.5]*[((p+h)/p)^0.5]\n",
      "Q* = [(2*400*2000/4500)^0.5]*[((1500+4500)/1500)^0.5]\n",
      "Q* = 37.712361663282536\n",
      "\n",
      "t*, Optimal Cycle length = Q*/d\n",
      "t* = 37.712361663282536/400\n",
      "t* = 0.09428090415820634\n",
      "\n",
      "Q*-S*, Maximum Shortage (To Fulfill the backorders) = Q* - S*\n",
      "Q*-S* = 37.712361663282536 - 9.428090415820634\n",
      "Q*-S* = 28.284271247461902\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# stochastic_continuous"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "source": [
    "from scipy.stats import norm\r\n",
    "norm.ppf(0.95)\r\n",
    "def stochastic_continuous(Q, L, mean, std):\r\n",
    "    ZL = norm.ppf(0.95)\r\n",
    "    ss = ZL *std\r\n",
    "    R = mean + ss\r\n",
    "    return Q, L, mean, std, ZL, ss, R\r\n",
    "Q, L, mean, std, ZL, ss, R = stochastic_continuous(37.71, 0.95, 50, 20)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "source": [
    "print(f\"Z(L), Z Value of Management Desired Probability = norminv(Management desired Probability)\")\r\n",
    "print(f\"Z(L) =  = norminv({L})\")\r\n",
    "print(f\"Z(L) = {ZL}\")\r\n",
    "print(f\"ss, Safety Stock = Z(L)* Standard Deviation\")\r\n",
    "print(f\"ss = {ZL} * {std}\")\r\n",
    "print(f\"ss = {ss}\")\r\n",
    "print(f\"R, Reorder Point = mean + Safety Stock\")\r\n",
    "print(f\"R = {mean} + {ss}\")\r\n",
    "print(f\"R = {R}\")\r\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Z(L), Z Value of Management Desired Probability = norminv(Management desired Probability)\n",
      "Z(L) =  = norminv(0.95)\n",
      "Z(L) = 1.6448536269514722\n",
      "ss, Safety Stock = Z(L)* Standard Deviation\n",
      "ss = 1.6448536269514722 * 20\n",
      "ss = 32.897072539029445\n",
      "R, Reorder Point = mean + Safety Stock\n",
      "R = 50 + 32.897072539029445\n",
      "R = 82.89707253902944\n"
     ]
    }
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "orig_nbformat": 4,
  "language_info": {
   "name": "python",
   "version": "3.7.6",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.7.6 64-bit ('base': conda)"
  },
  "interpreter": {
   "hash": "2b968b960d18f37426d480937b0b7a80e4ddcac4b277f1937fa775492d7343e5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}