{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For {ref}`ex_rr_1`, you have two options: work with **Python** or with **Excel**. When applicable, python code is provided below each sub-question on this page. If you prefer working with Excel, please use the Python code below to generate an Excel file with the required data and answer the sub-questions in the chronological order. To generate the Excel file, simply copy the Python code and paste it into a notebook on your laptop. **Remove the '#' before the last code line to activate the generation of the Excel file.** Once this is done, open the generated Excel file (located in the same folder as your notebook) in Excel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Qmax [m3/s]</th>\n",
       "      <th>Rank</th>\n",
       "      <th>Probability of Exceedance</th>\n",
       "      <th>Probability of non-Exceedance</th>\n",
       "      <th>Reduced variate</th>\n",
       "      <th>Return period [years]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1982</th>\n",
       "      <td>211</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1983</th>\n",
       "      <td>64</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1984</th>\n",
       "      <td>99</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1985</th>\n",
       "      <td>122</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1986</th>\n",
       "      <td>165</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Qmax [m3/s]  Rank  Probability of Exceedance  \\\n",
       "1982          211   NaN                        NaN   \n",
       "1983           64   NaN                        NaN   \n",
       "1984           99   NaN                        NaN   \n",
       "1985          122   NaN                        NaN   \n",
       "1986          165   NaN                        NaN   \n",
       "\n",
       "      Probability of non-Exceedance  Reduced variate  Return period [years]  \n",
       "1982                            NaN              NaN                    NaN  \n",
       "1983                            NaN              NaN                    NaN  \n",
       "1984                            NaN              NaN                    NaN  \n",
       "1985                            NaN              NaN                    NaN  \n",
       "1986                            NaN              NaN                    NaN  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "years = np.array([1982, 1983, 1984, 1985, 1986])\n",
    "QmaxY = np.array([211, 64, 99, 122, 165])\n",
    "data = pd.DataFrame(index = years)\n",
    "data['Qmax [m3/s]'] = QmaxY\n",
    "nan_array = np.array([np.nan]*len(data['Qmax [m3/s]']))\n",
    "data['Rank'] = nan_array\n",
    "data['Probability of Exceedance'] = nan_array\n",
    "data['Probability of non-Exceedance'] = nan_array\n",
    "data['Reduced variate'] = nan_array\n",
    "data['Return period [years]'] = nan_array\n",
    "display(data)\n",
    "#df.to_csv('Data.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{exercise-start}\n",
    ":label: ex_rr_1\n",
    "```\n",
    "**Extreme value analysis**\n",
    "\n",
    "You are asked to apply the Gumbel theory for extreme values to determine the design flow of a hypothetical river. No recent data is available, but you have found a very short time-series spanning over a few years in the 1980s, from which you have calculated the yearly maxima.\n",
    "\n",
    "```{exercise-end}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Qmax [m3/s]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1982</th>\n",
       "      <td>211</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1983</th>\n",
       "      <td>64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1984</th>\n",
       "      <td>99</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1985</th>\n",
       "      <td>122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1986</th>\n",
       "      <td>165</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Qmax [m3/s]\n",
       "1982          211\n",
       "1983           64\n",
       "1984           99\n",
       "1985          122\n",
       "1986          165"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "years = np.array([1982, 1983, 1984, 1985, 1986])\n",
    "QmaxY = np.array([211, 64, 99, 122, 165])\n",
    "data = pd.DataFrame(index = years)\n",
    "data['Qmax [m3/s]'] = QmaxY\n",
    "display(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a) First of all, fill in the table below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Qmax [m3/s]</th>\n",
       "      <th>Rank</th>\n",
       "      <th>Probability of Exceedance</th>\n",
       "      <th>Probability of non-Exceedance</th>\n",
       "      <th>Reduced variate</th>\n",
       "      <th>Return period [years]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1982</th>\n",
       "      <td>211</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1983</th>\n",
       "      <td>64</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1984</th>\n",
       "      <td>99</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1985</th>\n",
       "      <td>122</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1986</th>\n",
       "      <td>165</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Qmax [m3/s]  Rank  Probability of Exceedance  \\\n",
       "1982          211   NaN                        NaN   \n",
       "1983           64   NaN                        NaN   \n",
       "1984           99   NaN                        NaN   \n",
       "1985          122   NaN                        NaN   \n",
       "1986          165   NaN                        NaN   \n",
       "\n",
       "      Probability of non-Exceedance  Reduced variate  Return period [years]  \n",
       "1982                            NaN              NaN                    NaN  \n",
       "1983                            NaN              NaN                    NaN  \n",
       "1984                            NaN              NaN                    NaN  \n",
       "1985                            NaN              NaN                    NaN  \n",
       "1986                            NaN              NaN                    NaN  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "years = np.array([1982, 1983, 1984, 1985, 1986])\n",
    "QmaxY = np.array([211, 64, 99, 122, 165])\n",
    "data = pd.DataFrame(index = years)\n",
    "data['Qmax [m3/s]'] = QmaxY\n",
    "nan_array = np.array([np.nan]*len(data['Qmax [m3/s]']))\n",
    "data['Rank'] = nan_array\n",
    "data['Probability of Exceedance'] = nan_array\n",
    "data['Probability of non-Exceedance'] = nan_array\n",
    "data['Reduced variate'] = nan_array\n",
    "data['Return period [years]'] = nan_array\n",
    "display(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{dropdown} Answer&nbsp;{ref}`ex_rr_1` a\n",
    "\n",
    "The table with solutions can be found in the code cell below.\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Qmax [m3/s]</th>\n",
       "      <th>Rank [-]</th>\n",
       "      <th>Probability of Exceedance [1/year]</th>\n",
       "      <th>Probability of non-Exceedance [1/year]</th>\n",
       "      <th>Reduced variate [-]</th>\n",
       "      <th>Return period [years]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1982</th>\n",
       "      <td>211</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.167</td>\n",
       "      <td>0.833</td>\n",
       "      <td>1.702</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1986</th>\n",
       "      <td>165</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.333</td>\n",
       "      <td>0.667</td>\n",
       "      <td>0.903</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1985</th>\n",
       "      <td>122</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.500</td>\n",
       "      <td>0.500</td>\n",
       "      <td>0.367</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1984</th>\n",
       "      <td>99</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.667</td>\n",
       "      <td>0.333</td>\n",
       "      <td>-0.094</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1983</th>\n",
       "      <td>64</td>\n",
       "      <td>5.0</td>\n",
       "      <td>0.833</td>\n",
       "      <td>0.167</td>\n",
       "      <td>-0.583</td>\n",
       "      <td>1.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Qmax [m3/s]  Rank [-]  Probability of Exceedance [1/year]  \\\n",
       "1982          211       1.0                               0.167   \n",
       "1986          165       2.0                               0.333   \n",
       "1985          122       3.0                               0.500   \n",
       "1984           99       4.0                               0.667   \n",
       "1983           64       5.0                               0.833   \n",
       "\n",
       "      Probability of non-Exceedance [1/year]  Reduced variate [-]  \\\n",
       "1982                                   0.833                1.702   \n",
       "1986                                   0.667                0.903   \n",
       "1985                                   0.500                0.367   \n",
       "1984                                   0.333               -0.094   \n",
       "1983                                   0.167               -0.583   \n",
       "\n",
       "      Return period [years]  \n",
       "1982                    6.0  \n",
       "1986                    3.0  \n",
       "1985                    2.0  \n",
       "1984                    1.5  \n",
       "1983                    1.2  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "years = np.array([1982, 1983, 1984, 1985, 1986])\n",
    "QmaxY = np.array([211, 64, 99, 122, 165])\n",
    "data = pd.DataFrame(index = years)\n",
    "data['Qmax [m3/s]'] = QmaxY\n",
    "nan_array = np.array([np.nan]*len(data['Qmax [m3/s]']))\n",
    "data['Rank [-]'] = data['Qmax [m3/s]'].rank(ascending=False)\n",
    "data = data.sort_values('Rank [-]')\n",
    "data['Probability of Exceedance [1/year]'] = data['Rank [-]']/(len(data['Rank [-]'])+1)\n",
    "data['Probability of non-Exceedance [1/year]'] = 1 - data['Probability of Exceedance [1/year]']\n",
    "data['Reduced variate [-]'] = -np.log(-np.log(data['Probability of non-Exceedance [1/year]']))\n",
    "data['Return period [years]'] = (len(data.index.values) + 1) / data['Rank [-]']\n",
    "data = data.round(3)\n",
    "display(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Next, make the Gumbel graph used to estimate the river flow for very big return periods. The code cell below provides you with a template for plotting the Gumble graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": [
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plot\n",
    "fig, ax1 = plt.subplots(figsize=(8,6))\n",
    "ax1.set_title('Gumbel graph', fontsize='16')\n",
    "ax1.set_xlim(-2, 7)\n",
    "ax1.set_ylim(0,500)\n",
    "ax1.set_ylabel('Discharge [m3/s]', fontsize='12')\n",
    "ax1.set_xlabel('Reduced variate [-]', fontsize='12')\n",
    "plt.grid()\n",
    "\n",
    "# Set scond x-axis\n",
    "ax2 = ax1.twiny()\n",
    "\n",
    "# Decide the ticklabel position in the new x-axis,\n",
    "# then convert them to the position in the old x-axis\n",
    "newlabel = [1.01, 1.2, 1.5, 2., 5., 10., 20., 50., 100., 200., 500., 1000., 2000.] # labels of the xticklabels: the position in the new x-axis\n",
    "k2_convert = lambda z: -np.log(-np.log(1-1/z))\n",
    "newpos   = [k2_convert(z) for z in newlabel]   # position of the xticklabels in the old x-axis\n",
    "ax2.set_xticks(newpos)\n",
    "ax2.set_xticklabels(newlabel)\n",
    "\n",
    "ax2.xaxis.set_ticks_position('bottom') # set the position of the second x-axis to bottom\n",
    "ax2.xaxis.set_label_position('bottom') # set the position of the second x-axis to bottom\n",
    "ax2.spines['bottom'].set_position(('outward', 36))\n",
    "ax2.set_xlabel('Return period [years]',fontsize='14')\n",
    "ax2.set_xlim(ax1.get_xlim());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{dropdown} Answer&nbsp;{ref}`ex_rr_1` b\n",
    "\n",
    "The Gumble graph is generated in the code cell below. Don't get intimated by the length of the code, a big the part of the code below is only used to create the axis labels and make the graph look nicer!\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": [
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "years = np.array([1982, 1983, 1984, 1985, 1986])\n",
    "QmaxY = np.array([211, 64, 99, 122, 165])\n",
    "data = pd.DataFrame(index = years)\n",
    "data['Qmax [m3/s]'] = QmaxY\n",
    "nan_array = np.array([np.nan]*len(data['Qmax [m3/s]']))\n",
    "data['Rank [-]'] = data['Qmax [m3/s]'].rank(ascending=False)\n",
    "data = data.sort_values('Rank [-]')\n",
    "data['Probability of Exceedance [1/year]'] = data['Rank [-]']/(len(data['Rank [-]'])+1)\n",
    "data = data.round(3)\n",
    "data['Probability of non-Exceedance [1/year]'] = 1 - data['Probability of Exceedance [1/year]']\n",
    "data['Reduced variate [-]'] = -np.log(-np.log(data['Probability of non-Exceedance [1/year]']))\n",
    "data['Return period [years]'] = (len(data.index.values) + 1) / data['Rank [-]']\n",
    "\n",
    "X = data['Reduced variate [-]']\n",
    "y = data['Qmax [m3/s]']\n",
    "\n",
    "# Computing the coefficients of the regression line (y = mx + b)\n",
    "X_mean = np.mean(X)\n",
    "y_mean = np.mean(y)\n",
    "\n",
    "# Calculating the slope (m)\n",
    "numerator = np.sum((X - X_mean) * (y - y_mean))\n",
    "denominator = np.sum((X - X_mean) ** 2)\n",
    "slope = numerator / denominator\n",
    "\n",
    "# Calculating the intercept (b)\n",
    "intercept = y_mean - slope * X_mean\n",
    "\n",
    "# Plot\n",
    "X_plot = np.linspace(-2, 7, 100)\n",
    "fig, ax1 = plt.subplots(figsize=(8,6))\n",
    "ax1.set_title('Gumbel graph', fontsize='16')\n",
    "ax1.plot(X_plot, slope * X_plot + intercept, color='red', label='Regression Line')\n",
    "ax1.plot(data['Reduced variate [-]'], data['Qmax [m3/s]'], '*')\n",
    "ax1.set_xlim(-2, 7)\n",
    "ax1.set_ylim(0,500)\n",
    "ax1.set_ylabel('Discharge [m3/s]', fontsize='12')\n",
    "ax1.set_xlabel('Reduced variate [-]', fontsize='12')\n",
    "plt.grid()\n",
    "\n",
    "# Set scond x-axis\n",
    "ax2 = ax1.twiny()\n",
    "\n",
    "# Decide the ticklabel position in the new x-axis,\n",
    "# then convert them to the position in the old x-axis\n",
    "newlabel = [1.01, 1.2, 1.5, 2., 5., 10., 20., 50., 100., 200., 500., 1000., 2000.] # labels of the xticklabels: the position in the new x-axis\n",
    "k2_convert = lambda z: -np.log(-np.log(1-1/z))\n",
    "newpos   = [k2_convert(z) for z in newlabel]   # position of the xticklabels in the old x-axis\n",
    "ax2.set_xticks(newpos)\n",
    "ax2.set_xticklabels(newlabel)\n",
    "\n",
    "ax2.xaxis.set_ticks_position('bottom') # set the position of the second x-axis to bottom\n",
    "ax2.xaxis.set_label_position('bottom') # set the position of the second x-axis to bottom\n",
    "ax2.spines['bottom'].set_position(('outward', 36))\n",
    "ax2.set_xlabel('Return period [years]',fontsize='14')\n",
    "ax2.set_xlim(ax1.get_xlim());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Consider only one year. According to the table (i.e. without applying a Gumbel fit), what is the probability that the annual maximum river flow exceeds the maximum flow measured in 1985?\n",
    "\n",
    ":::{dropdown} Answer&nbsp;{ref}`ex_rr_1` c\n",
    "\n",
    "From the table above, the probability can be found to be equal to **0.500**.\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) Consider only one year. According to the table (i.e. without applying a Gumbel fit), what is the probability that the annual maximum river flow is lower than the maximum flow measured in 1984?\n",
    "\n",
    ":::{dropdown} Answer&nbsp;{ref}`ex_rr_1` d\n",
    "\n",
    "From the table above, the answer is **0.333**.\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e) Based on the Gumbel distribution, estimate the river flow corresponding to a return period of 55.1 years.\n",
    "\n",
    ":::{dropdown} Answer&nbsp;{ref}`ex_rr_1` e\n",
    "\n",
    "In the table above, the discharge corresponding to a return period of 55.1 years is equal to **361.2 m^3/s**.\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{exercise-start}\n",
    ":label: ex_rr_2\n",
    "```\n",
    "\n",
    "True or false?\n",
    "\n",
    "```{exercise-end}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [],
   "source": [
    "from jupyterquiz import display_quiz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div id=\"FWnnuqEsBzQK\" data-shufflequestions=\"False\"\n",
       "               data-shuffleanswers=\"True\"\n",
       "               data-preserveresponses=\"false\"\n",
       "               data-numquestions=\"1000000\"\n",
       "               data-maxwidth=\"600\"\n",
       "               style=\"border-radius: 10px; text-align: left\"> <style>\n",
       "#FWnnuqEsBzQK {\n",
       "   --jq-multiple-choice-bg: #6f78ffff;\n",
       "   --jq-mc-button-bg: #fafafa;\n",
       "   --jq-mc-button-border: #e0e0e0e0;\n",
       "   --jq-mc-button-inset-shadow: #555555;\n",
       "   --jq-many-choice-bg: #f75c03ff;\n",
       "   --jq-numeric-bg: #392061ff;\n",
       "   --jq-numeric-input-bg: #c0c0c0;\n",
       "   --jq-numeric-input-label: #101010;\n",
       "   --jq-numeric-input-shadow: #999999;\n",
       "   --jq-incorrect-color: #c80202;\n",
       "   --jq-correct-color: #009113;\n",
       "   --jq-text-color: #fafafa;\n",
       "}\n",
       "\n",
       ".Quiz {\n",
       "    max-width: 600px;\n",
       "    margin-top: 15px;\n",
       "    margin-left: auto;\n",
       "    margin-right: auto;\n",
       "    margin-bottom: 15px;\n",
       "    padding-bottom: 4px;\n",
       "    padding-top: 4px;\n",
       "    line-height: 1.1;\n",
       "    font-size: 16pt;\n",
       "    border-radius: inherit;\n",
       "}\n",
       "\n",
       ".QuizCode {\n",
       "    font-size: 14pt;\n",
       "    margin-top: 10px;\n",
       "    margin-left: 20px;\n",
       "    margin-right: 20px;\n",
       "}\n",
       "\n",
       ".QuizCode>pre {\n",
       "    padding: 4px;\n",
       "}\n",
       "\n",
       ".Answer {\n",
       "    margin: 10px 0;\n",
       "    display: grid;\n",
       "    grid-template-columns: 1fr 1fr;\n",
       "    grid-gap: 10px;\n",
       "    border-radius: inherit;\n",
       "}\n",
       "\n",
       ".Feedback {\n",
       "    font-size: 16pt;\n",
       "    text-align: center;\n",
       "    min-height: 2em;\n",
       "}\n",
       "\n",
       ".Input {\n",
       "    align: left;\n",
       "    font-size: 20pt;\n",
       "}\n",
       "\n",
       ".Input-text {\n",
       "    display: block;\n",
       "    margin: 10px;\n",
       "    color: inherit;\n",
       "    width: 140px;\n",
       "    background-color: var(--jq-numeric-input-bg);\n",
       "    color: var(--jq-text-color);\n",
       "    padding: 5px;\n",
       "    padding-left: 10px;\n",
       "    font-family: inherit;\n",
       "    font-size: 20px;\n",
       "    font-weight: inherit;\n",
       "    line-height: 20pt;\n",
       "    border: none;\n",
       "    border-radius: 0.2rem;\n",
       "    transition: box-shadow 0.1s);\n",
       "}\n",
       "\n",
       ".Input-text:focus {\n",
       "    outline: none;\n",
       "    background-color: var(--jq-numeric-input-bg);\n",
       "    box-shadow: 0.6rem 0.8rem 1.4rem -0.5rem var(--jq-numeric-input-shadow);\n",
       "}\n",
       "\n",
       ".MCButton {\n",
       "    background: var(--jq-mc-button-bg);\n",
       "    border: 1px solid var(--jq-mc-button-border);\n",
       "    border-radius: inherit;\n",
       "    padding: 10px;\n",
       "    font-size: 16px;\n",
       "    cursor: pointer;\n",
       "    text-align: center;\n",
       "    display: flex;\n",
       "    align-items: center;\n",
       "    justify-content: center;\n",
       "}\n",
       "\n",
       ".MCButton p {\n",
       "    color: inherit;\n",
       "}\n",
       "\n",
       ".MultipleChoiceQn {\n",
       "    padding: 10px;\n",
       "    background: var(--jq-multiple-choice-bg);\n",
       "    color: var(--jq-text-color);\n",
       "    border-radius: inherit;\n",
       "}\n",
       "\n",
       ".ManyChoiceQn {\n",
       "    padding: 10px;\n",
       "    background: var(--jq-many-choice-bg);\n",
       "    color: var(--jq-text-color);\n",
       "    border-radius: inherit;\n",
       "}\n",
       "\n",
       ".NumericQn {\n",
       "    padding: 10px;\n",
       "    background: var(--jq-numeric-bg);\n",
       "    color: var(--jq-text-color);\n",
       "    border-radius: inherit;\n",
       "}\n",
       "\n",
       ".NumericQn p {\n",
       "    color: inherit;\n",
       "}\n",
       "\n",
       ".InpLabel {\n",
       "    line-height: 34px;\n",
       "    float: left;\n",
       "    margin-right: 10px;\n",
       "    color: var(--jq-numeric-input-label);\n",
       "    font-size: 15pt;\n",
       "}\n",
       "\n",
       ".incorrect {\n",
       "    color: var(--jq-incorrect-color);\n",
       "}\n",
       "\n",
       ".correct {\n",
       "    color: var(--jq-correct-color);\n",
       "}\n",
       "\n",
       ".correctButton {\n",
       "    /*\n",
       "    background: var(--jq-correct-color);\n",
       "   */\n",
       "    animation: correct-anim 0.6s ease;\n",
       "    animation-fill-mode: forwards;\n",
       "    color: var(--jq-text-color);\n",
       "    box-shadow: inset 0px 0px 5px var(--jq-mc-button-inset-shadow);\n",
       "    outline: none;\n",
       "}\n",
       "\n",
       ".incorrectButton {\n",
       "    animation: incorrect-anim 0.8s ease;\n",
       "    animation-fill-mode: forwards;\n",
       "    color: var(--jq-text-color);\n",
       "    box-shadow: inset 0px 0px 5px var(--jq-mc-button-inset-shadow);\n",
       "    outline: none;\n",
       "}\n",
       "\n",
       "@keyframes incorrect-anim {\n",
       "    100% {\n",
       "        background-color: var(--jq-incorrect-color);\n",
       "    }\n",
       "}\n",
       "\n",
       "@keyframes correct-anim {\n",
       "    100% {\n",
       "        background-color: var(--jq-correct-color);\n",
       "    }\n",
       "}\n",
       "</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": "var questionsFWnnuqEsBzQK=[{\"question\": \"Which one of the following statements is true for a Gumbel graph?\", \"type\": \"multiple_choice\", \"answers\": [{\"answer\": \"For natural rivers, when applying Gumbel to water levels instead of discharges, one will observe a bend/kink downwards in the Gumbel graph at a return period of approximately 1.5 - 2 years.\", \"correct\": true}, {\"answer\": \"An observed discharge plotting below the Gumbel line indicates that the actual return period of that discharge is higher\", \"correct\": false}, {\"answer\": \"When applying Gumbel to water levels, a structure like a bridge causes a bend/kink downwards in the graph.\", \"correct\": false}]}];\n    // Make a random ID\nfunction makeid(length) {\n    var result = [];\n    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';\n    var charactersLength = characters.length;\n    for (var i = 0; i < length; i++) {\n        result.push(characters.charAt(Math.floor(Math.random() * charactersLength)));\n    }\n    return result.join('');\n}\n\n// Choose a random subset of an array. Can also be used to shuffle the array\nfunction getRandomSubarray(arr, size) {\n    var shuffled = arr.slice(0), i = arr.length, temp, index;\n    while (i--) {\n        index = Math.floor((i + 1) * Math.random());\n        temp = shuffled[index];\n        shuffled[index] = shuffled[i];\n        shuffled[i] = temp;\n    }\n    return shuffled.slice(0, size);\n}\n\nfunction printResponses(responsesContainer) {\n    var responses=JSON.parse(responsesContainer.dataset.responses);\n    var stringResponses='<B>IMPORTANT!</B>To preserve this answer sequence for submission, when you have finalized your answers: <ol> <li> Copy the text in this cell below \"Answer String\"</li> <li> Double click on the cell directly below the Answer String, labeled \"Replace Me\"</li> <li> Select the whole \"Replace Me\" text</li> <li> Paste in your answer string and press shift-Enter.</li><li>Save the notebook using the save icon or File->Save Notebook menu item</li></ul><br><br><br><b>Answer String:</b><br> ';\n    console.log(responses);\n    responses.forEach((response, index) => {\n        if (response) {\n            console.log(index + ': ' + response);\n            stringResponses+= index + ': ' + response +\"<BR>\";\n        }\n    });\n    responsesContainer.innerHTML=stringResponses;\n}\nfunction check_mc() {\n    var id = this.id.split('-')[0];\n    //var response = this.id.split('-')[1];\n    //console.log(response);\n    //console.log(\"In check_mc(), id=\"+id);\n    //console.log(event.srcElement.id)           \n    //console.log(event.srcElement.dataset.correct)   \n    //console.log(event.srcElement.dataset.feedback)\n\n    var label = event.srcElement;\n    //console.log(label, label.nodeName);\n    var depth = 0;\n    while ((label.nodeName != \"LABEL\") && (depth < 20)) {\n        label = label.parentElement;\n        console.log(depth, label);\n        depth++;\n    }\n\n\n\n    var answers = label.parentElement.children;\n\n    //console.log(answers);\n\n\n    // Split behavior based on multiple choice vs many choice:\n    var fb = document.getElementById(\"fb\" + id);\n\n\n\n\n    if (fb.dataset.numcorrect == 1) {\n        // What follows is for the saved responses stuff\n        var outerContainer = fb.parentElement.parentElement;\n        var responsesContainer = document.getElementById(\"responses\" + outerContainer.id);\n        if (responsesContainer) {\n            //console.log(responsesContainer);\n            var response = label.firstChild.innerText;\n            if (label.querySelector(\".QuizCode\")){\n                response+= label.querySelector(\".QuizCode\").firstChild.innerText;\n            }\n            console.log(response);\n            //console.log(document.getElementById(\"quizWrap\"+id));\n            var qnum = document.getElementById(\"quizWrap\"+id).dataset.qnum;\n            console.log(\"Question \" + qnum);\n            //console.log(id, \", got numcorrect=\",fb.dataset.numcorrect);\n            var responses=JSON.parse(responsesContainer.dataset.responses);\n            console.log(responses);\n            responses[qnum]= response;\n            responsesContainer.setAttribute('data-responses', JSON.stringify(responses));\n            printResponses(responsesContainer);\n        }\n        // End code to preserve responses\n        \n        for (var i = 0; i < answers.length; i++) {\n            var child = answers[i];\n            //console.log(child);\n            child.className = \"MCButton\";\n        }\n\n\n\n        if (label.dataset.correct == \"true\") {\n            // console.log(\"Correct action\");\n            if (\"feedback\" in label.dataset) {\n                fb.textContent = jaxify(label.dataset.feedback);\n            } else {\n                fb.textContent = \"Correct!\";\n            }\n            label.classList.add(\"correctButton\");\n\n            fb.className = \"Feedback\";\n            fb.classList.add(\"correct\");\n\n        } else {\n            if (\"feedback\" in label.dataset) {\n                fb.textContent = jaxify(label.dataset.feedback);\n            } else {\n                fb.textContent = \"Incorrect -- try again.\";\n            }\n            //console.log(\"Error action\");\n            label.classList.add(\"incorrectButton\");\n            fb.className = \"Feedback\";\n            fb.classList.add(\"incorrect\");\n        }\n    }\n    else {\n        var reset = false;\n        var feedback;\n         if (label.dataset.correct == \"true\") {\n            if (\"feedback\" in label.dataset) {\n                feedback = jaxify(label.dataset.feedback);\n            } else {\n                feedback = \"Correct!\";\n            }\n            if (label.dataset.answered <= 0) {\n                if (fb.dataset.answeredcorrect < 0) {\n                    fb.dataset.answeredcorrect = 1;\n                    reset = true;\n                } else {\n                    fb.dataset.answeredcorrect++;\n                }\n                if (reset) {\n                    for (var i = 0; i < answers.length; i++) {\n                        var child = answers[i];\n                        child.className = \"MCButton\";\n                        child.dataset.answered = 0;\n                    }\n                }\n                label.classList.add(\"correctButton\");\n                label.dataset.answered = 1;\n                fb.className = \"Feedback\";\n                fb.classList.add(\"correct\");\n\n            }\n        } else {\n            if (\"feedback\" in label.dataset) {\n                feedback = jaxify(label.dataset.feedback);\n            } else {\n                feedback = \"Incorrect -- try again.\";\n            }\n            if (fb.dataset.answeredcorrect > 0) {\n                fb.dataset.answeredcorrect = -1;\n                reset = true;\n            } else {\n                fb.dataset.answeredcorrect--;\n            }\n\n            if (reset) {\n                for (var i = 0; i < answers.length; i++) {\n                    var child = answers[i];\n                    child.className = \"MCButton\";\n                    child.dataset.answered = 0;\n                }\n            }\n            label.classList.add(\"incorrectButton\");\n            fb.className = \"Feedback\";\n            fb.classList.add(\"incorrect\");\n        }\n        // What follows is for the saved responses stuff\n        var outerContainer = fb.parentElement.parentElement;\n        var responsesContainer = document.getElementById(\"responses\" + outerContainer.id);\n        if (responsesContainer) {\n            //console.log(responsesContainer);\n            var response = label.firstChild.innerText;\n            if (label.querySelector(\".QuizCode\")){\n                response+= label.querySelector(\".QuizCode\").firstChild.innerText;\n            }\n            console.log(response);\n            //console.log(document.getElementById(\"quizWrap\"+id));\n            var qnum = document.getElementById(\"quizWrap\"+id).dataset.qnum;\n            console.log(\"Question \" + qnum);\n            //console.log(id, \", got numcorrect=\",fb.dataset.numcorrect);\n            var responses=JSON.parse(responsesContainer.dataset.responses);\n            if (label.dataset.correct == \"true\") {\n                if (typeof(responses[qnum]) == \"object\"){\n                    if (!responses[qnum].includes(response))\n                        responses[qnum].push(response);\n                } else{\n                    responses[qnum]= [ response ];\n                }\n            } else {\n                responses[qnum]= response;\n            }\n            console.log(responses);\n            responsesContainer.setAttribute('data-responses', JSON.stringify(responses));\n            printResponses(responsesContainer);\n        }\n        // End save responses stuff\n\n\n\n        var numcorrect = fb.dataset.numcorrect;\n        var answeredcorrect = fb.dataset.answeredcorrect;\n        if (answeredcorrect >= 0) {\n            fb.textContent = feedback + \" [\" + answeredcorrect + \"/\" + numcorrect + \"]\";\n        } else {\n            fb.textContent = feedback + \" [\" + 0 + \"/\" + numcorrect + \"]\";\n        }\n\n\n    }\n\n    if (typeof MathJax != 'undefined') {\n        var version = MathJax.version;\n        console.log('MathJax version', version);\n        if (version[0] == \"2\") {\n            MathJax.Hub.Queue([\"Typeset\", MathJax.Hub]);\n        } else if (version[0] == \"3\") {\n            MathJax.typeset([fb]);\n        }\n    } else {\n        console.log('MathJax not detected');\n    }\n\n}\n\nfunction make_mc(qa, shuffle_answers, outerqDiv, qDiv, aDiv, id) {\n    var shuffled;\n    if (shuffle_answers == \"True\") {\n        //console.log(shuffle_answers+\" read as true\");\n        shuffled = getRandomSubarray(qa.answers, qa.answers.length);\n    } else {\n        //console.log(shuffle_answers+\" read as false\");\n        shuffled = qa.answers;\n    }\n\n\n    var num_correct = 0;\n\n\n\n    shuffled.forEach((item, index, ans_array) => {\n        //console.log(answer);\n\n        // Make input element\n        var inp = document.createElement(\"input\");\n        inp.type = \"radio\";\n        inp.id = \"quizo\" + id + index;\n        inp.style = \"display:none;\";\n        aDiv.append(inp);\n\n        //Make label for input element\n        var lab = document.createElement(\"label\");\n        lab.className = \"MCButton\";\n        lab.id = id + '-' + index;\n        lab.onclick = check_mc;\n        var aSpan = document.createElement('span');\n        aSpan.classsName = \"\";\n        //qDiv.id=\"quizQn\"+id+index;\n        if (\"answer\" in item) {\n            aSpan.innerHTML = jaxify(item.answer);\n            //aSpan.innerHTML=item.answer;\n        }\n        lab.append(aSpan);\n\n        // Create div for code inside question\n        var codeSpan;\n        if (\"code\" in item) {\n            codeSpan = document.createElement('span');\n            codeSpan.id = \"code\" + id + index;\n            codeSpan.className = \"QuizCode\";\n            var codePre = document.createElement('pre');\n            codeSpan.append(codePre);\n            var codeCode = document.createElement('code');\n            codePre.append(codeCode);\n            codeCode.innerHTML = item.code;\n            lab.append(codeSpan);\n            //console.log(codeSpan);\n        }\n\n        //lab.textContent=item.answer;\n\n        // Set the data attributes for the answer\n        lab.setAttribute('data-correct', item.correct);\n        if (item.correct) {\n            num_correct++;\n        }\n        if (\"feedback\" in item) {\n            lab.setAttribute('data-feedback', item.feedback);\n        }\n        lab.setAttribute('data-answered', 0);\n\n        aDiv.append(lab);\n\n    });\n\n    if (num_correct > 1) {\n        outerqDiv.className = \"ManyChoiceQn\";\n    } else {\n        outerqDiv.className = \"MultipleChoiceQn\";\n    }\n\n    return num_correct;\n\n}\nfunction check_numeric(ths, event) {\n\n    if (event.keyCode === 13) {\n        ths.blur();\n\n        var id = ths.id.split('-')[0];\n\n        var submission = ths.value;\n        if (submission.indexOf('/') != -1) {\n            var sub_parts = submission.split('/');\n            //console.log(sub_parts);\n            submission = sub_parts[0] / sub_parts[1];\n        }\n        //console.log(\"Reader entered\", submission);\n\n        if (\"precision\" in ths.dataset) {\n            var precision = ths.dataset.precision;\n            // console.log(\"1:\", submission)\n            submission = Math.round((1 * submission + Number.EPSILON) * 10 ** precision) / 10 ** precision;\n            // console.log(\"Rounded to \", submission, \" precision=\", precision  );\n        }\n\n\n        //console.log(\"In check_numeric(), id=\"+id);\n        //console.log(event.srcElement.id)           \n        //console.log(event.srcElement.dataset.feedback)\n\n        var fb = document.getElementById(\"fb\" + id);\n        fb.style.display = \"none\";\n        fb.textContent = \"Incorrect -- try again.\";\n\n        var answers = JSON.parse(ths.dataset.answers);\n        //console.log(answers);\n\n        var defaultFB = \"\";\n        var correct;\n        var done = false;\n        answers.every(answer => {\n            //console.log(answer.type);\n\n            correct = false;\n            // if (answer.type==\"value\"){\n            if ('value' in answer) {\n                if (submission == answer.value) {\n                    if (\"feedback\" in answer) {\n                        fb.textContent = jaxify(answer.feedback);\n                    } else {\n                        fb.textContent = jaxify(\"Correct\");\n                    }\n                    correct = answer.correct;\n                    //console.log(answer.correct);\n                    done = true;\n                }\n                // } else if (answer.type==\"range\") {\n            } else if ('range' in answer) {\n                //console.log(answer.range);\n                if ((submission >= answer.range[0]) && (submission < answer.range[1])) {\n                    fb.textContent = jaxify(answer.feedback);\n                    correct = answer.correct;\n                    //console.log(answer.correct);\n                    done = true;\n                }\n            } else if (answer.type == \"default\") {\n                defaultFB = answer.feedback;\n            }\n            if (done) {\n                return false; // Break out of loop if this has been marked correct\n            } else {\n                return true; // Keep looking for case that includes this as a correct answer\n            }\n        });\n\n        if ((!done) && (defaultFB != \"\")) {\n            fb.innerHTML = jaxify(defaultFB);\n            //console.log(\"Default feedback\", defaultFB);\n        }\n\n        fb.style.display = \"block\";\n        if (correct) {\n            ths.className = \"Input-text\";\n            ths.classList.add(\"correctButton\");\n            fb.className = \"Feedback\";\n            fb.classList.add(\"correct\");\n        } else {\n            ths.className = \"Input-text\";\n            ths.classList.add(\"incorrectButton\");\n            fb.className = \"Feedback\";\n            fb.classList.add(\"incorrect\");\n        }\n\n        // What follows is for the saved responses stuff\n        var outerContainer = fb.parentElement.parentElement;\n        var responsesContainer = document.getElementById(\"responses\" + outerContainer.id);\n        if (responsesContainer) {\n            console.log(submission);\n            var qnum = document.getElementById(\"quizWrap\"+id).dataset.qnum;\n            //console.log(\"Question \" + qnum);\n            //console.log(id, \", got numcorrect=\",fb.dataset.numcorrect);\n            var responses=JSON.parse(responsesContainer.dataset.responses);\n            console.log(responses);\n            if (submission == ths.value){\n                responses[qnum]= submission;\n            } else {\n                responses[qnum]= ths.value + \"(\" + submission +\")\";\n            }\n            responsesContainer.setAttribute('data-responses', JSON.stringify(responses));\n            printResponses(responsesContainer);\n        }\n        // End code to preserve responses\n\n        if (typeof MathJax != 'undefined') {\n            var version = MathJax.version;\n            console.log('MathJax version', version);\n            if (version[0] == \"2\") {\n                MathJax.Hub.Queue([\"Typeset\", MathJax.Hub]);\n            } else if (version[0] == \"3\") {\n                MathJax.typeset([fb]);\n            }\n        } else {\n            console.log('MathJax not detected');\n        }\n        return false;\n    }\n\n}\n\nfunction isValid(el, charC) {\n    //console.log(\"Input char: \", charC);\n    if (charC == 46) {\n        if (el.value.indexOf('.') === -1) {\n            return true;\n        } else if (el.value.indexOf('/') != -1) {\n            var parts = el.value.split('/');\n            if (parts[1].indexOf('.') === -1) {\n                return true;\n            }\n        }\n        else {\n            return false;\n        }\n    } else if (charC == 47) {\n        if (el.value.indexOf('/') === -1) {\n            if ((el.value != \"\") && (el.value != \".\")) {\n                return true;\n            } else {\n                return false;\n            }\n        } else {\n            return false;\n        }\n    } else if (charC == 45) {\n        var edex = el.value.indexOf('e');\n        if (edex == -1) {\n            edex = el.value.indexOf('E');\n        }\n\n        if (el.value == \"\") {\n            return true;\n        } else if (edex == (el.value.length - 1)) { // If just after e or E\n            return true;\n        } else {\n            return false;\n        }\n    } else if (charC == 101) { // \"e\"\n        if ((el.value.indexOf('e') === -1) && (el.value.indexOf('E') === -1) && (el.value.indexOf('/') == -1)) {\n            // Prev symbol must be digit or decimal point:\n            if (el.value.slice(-1).search(/\\d/) >= 0) {\n                return true;\n            } else if (el.value.slice(-1).search(/\\./) >= 0) {\n                return true;\n            } else {\n                return false;\n            }\n        } else {\n            return false;\n        }\n    } else {\n        if (charC > 31 && (charC < 48 || charC > 57))\n            return false;\n    }\n    return true;\n}\n\nfunction numeric_keypress(evnt) {\n    var charC = (evnt.which) ? evnt.which : evnt.keyCode;\n\n    if (charC == 13) {\n        check_numeric(this, evnt);\n    } else {\n        return isValid(this, charC);\n    }\n}\n\n\n\n\n\nfunction make_numeric(qa, outerqDiv, qDiv, aDiv, id) {\n\n\n\n    //console.log(answer);\n\n\n    outerqDiv.className = \"NumericQn\";\n    aDiv.style.display = 'block';\n\n    var lab = document.createElement(\"label\");\n    lab.className = \"InpLabel\";\n    lab.textContent = \"Type numeric answer here:\";\n    aDiv.append(lab);\n\n    var inp = document.createElement(\"input\");\n    inp.type = \"text\";\n    //inp.id=\"input-\"+id;\n    inp.id = id + \"-0\";\n    inp.className = \"Input-text\";\n    inp.setAttribute('data-answers', JSON.stringify(qa.answers));\n    if (\"precision\" in qa) {\n        inp.setAttribute('data-precision', qa.precision);\n    }\n    aDiv.append(inp);\n    //console.log(inp);\n\n    //inp.addEventListener(\"keypress\", check_numeric);\n    //inp.addEventListener(\"keypress\", numeric_keypress);\n    /*\n    inp.addEventListener(\"keypress\", function(event) {\n        return numeric_keypress(this, event);\n    }\n                        );\n                        */\n    //inp.onkeypress=\"return numeric_keypress(this, event)\";\n    inp.onkeypress = numeric_keypress;\n    inp.onpaste = event => false;\n\n    inp.addEventListener(\"focus\", function (event) {\n        this.value = \"\";\n        return false;\n    }\n    );\n\n\n}\nfunction jaxify(string) {\n    var mystring = string;\n\n    var count = 0;\n    var loc = mystring.search(/([^\\\\]|^)(\\$)/);\n\n    var count2 = 0;\n    var loc2 = mystring.search(/([^\\\\]|^)(\\$\\$)/);\n\n    //console.log(loc);\n\n    while ((loc >= 0) || (loc2 >= 0)) {\n\n        /* Have to replace all the double $$ first with current implementation */\n        if (loc2 >= 0) {\n            if (count2 % 2 == 0) {\n                mystring = mystring.replace(/([^\\\\]|^)(\\$\\$)/, \"$1\\\\[\");\n            } else {\n                mystring = mystring.replace(/([^\\\\]|^)(\\$\\$)/, \"$1\\\\]\");\n            }\n            count2++;\n        } else {\n            if (count % 2 == 0) {\n                mystring = mystring.replace(/([^\\\\]|^)(\\$)/, \"$1\\\\(\");\n            } else {\n                mystring = mystring.replace(/([^\\\\]|^)(\\$)/, \"$1\\\\)\");\n            }\n            count++;\n        }\n        loc = mystring.search(/([^\\\\]|^)(\\$)/);\n        loc2 = mystring.search(/([^\\\\]|^)(\\$\\$)/);\n        //console.log(mystring,\", loc:\",loc,\", loc2:\",loc2);\n    }\n\n    //console.log(mystring);\n    return mystring;\n}\n\n\nfunction show_questions(json, mydiv) {\n    console.log('show_questions');\n    //var mydiv=document.getElementById(myid);\n    var shuffle_questions = mydiv.dataset.shufflequestions;\n    var num_questions = mydiv.dataset.numquestions;\n    var shuffle_answers = mydiv.dataset.shuffleanswers;\n    var max_width = mydiv.dataset.maxwidth;\n\n    if (num_questions > json.length) {\n        num_questions = json.length;\n    }\n\n    var questions;\n    if ((num_questions < json.length) || (shuffle_questions == \"True\")) {\n        //console.log(num_questions+\",\"+json.length);\n        questions = getRandomSubarray(json, num_questions);\n    } else {\n        questions = json;\n    }\n\n    //console.log(\"SQ: \"+shuffle_questions+\", NQ: \" + num_questions + \", SA: \", shuffle_answers);\n\n    // Iterate over questions\n    questions.forEach((qa, index, array) => {\n        //console.log(qa.question); \n\n        var id = makeid(8);\n        //console.log(id);\n\n\n        // Create Div to contain question and answers\n        var iDiv = document.createElement('div');\n        //iDiv.id = 'quizWrap' + id + index;\n        iDiv.id = 'quizWrap' + id;\n        iDiv.className = 'Quiz';\n        iDiv.setAttribute('data-qnum', index);\n        iDiv.style.maxWidth  =max_width+\"px\";\n        mydiv.appendChild(iDiv);\n        // iDiv.innerHTML=qa.question;\n        \n        var outerqDiv = document.createElement('div');\n        outerqDiv.id = \"OuterquizQn\" + id + index;\n        // Create div to contain question part\n        var qDiv = document.createElement('div');\n        qDiv.id = \"quizQn\" + id + index;\n        \n        if (qa.question) {\n            iDiv.append(outerqDiv);\n\n            //qDiv.textContent=qa.question;\n            qDiv.innerHTML = jaxify(qa.question);\n            outerqDiv.append(qDiv);\n        }\n\n        // Create div for code inside question\n        var codeDiv;\n        if (\"code\" in qa) {\n            codeDiv = document.createElement('div');\n            codeDiv.id = \"code\" + id + index;\n            codeDiv.className = \"QuizCode\";\n            var codePre = document.createElement('pre');\n            codeDiv.append(codePre);\n            var codeCode = document.createElement('code');\n            codePre.append(codeCode);\n            codeCode.innerHTML = qa.code;\n            outerqDiv.append(codeDiv);\n            //console.log(codeDiv);\n        }\n\n\n        // Create div to contain answer part\n        var aDiv = document.createElement('div');\n        aDiv.id = \"quizAns\" + id + index;\n        aDiv.className = 'Answer';\n        iDiv.append(aDiv);\n\n        //console.log(qa.type);\n\n        var num_correct;\n        if ((qa.type == \"multiple_choice\") || (qa.type == \"many_choice\") ) {\n            num_correct = make_mc(qa, shuffle_answers, outerqDiv, qDiv, aDiv, id);\n            if (\"answer_cols\" in qa) {\n                //aDiv.style.gridTemplateColumns = 'auto '.repeat(qa.answer_cols);\n                aDiv.style.gridTemplateColumns = 'repeat(' + qa.answer_cols + ', 1fr)';\n            }\n        } else if (qa.type == \"numeric\") {\n            //console.log(\"numeric\");\n            make_numeric(qa, outerqDiv, qDiv, aDiv, id);\n        }\n\n\n        //Make div for feedback\n        var fb = document.createElement(\"div\");\n        fb.id = \"fb\" + id;\n        //fb.style=\"font-size: 20px;text-align:center;\";\n        fb.className = \"Feedback\";\n        fb.setAttribute(\"data-answeredcorrect\", 0);\n        fb.setAttribute(\"data-numcorrect\", num_correct);\n        iDiv.append(fb);\n\n\n    });\n    var preserveResponses = mydiv.dataset.preserveresponses;\n    console.log(preserveResponses);\n    console.log(preserveResponses == \"true\");\n    if (preserveResponses == \"true\") {\n        console.log(preserveResponses);\n        // Create Div to contain record of answers\n        var iDiv = document.createElement('div');\n        iDiv.id = 'responses' + mydiv.id;\n        iDiv.className = 'JCResponses';\n        // Create a place to store responses as an empty array\n        iDiv.setAttribute('data-responses', '[]');\n\n        // Dummy Text\n        iDiv.innerHTML=\"<b>Select your answers and then follow the directions that will appear here.</b>\"\n        //iDiv.className = 'Quiz';\n        mydiv.appendChild(iDiv);\n    }\n//console.log(\"At end of show_questions\");\n    if (typeof MathJax != 'undefined') {\n        console.log(\"MathJax version\", MathJax.version);\n        var version = MathJax.version;\n        setTimeout(function(){\n            var version = MathJax.version;\n            console.log('After sleep, MathJax version', version);\n            if (version[0] == \"2\") {\n                MathJax.Hub.Queue([\"Typeset\", MathJax.Hub]);\n            } else if (version[0] == \"3\") {\n                MathJax.typeset([mydiv]);\n            }\n        }, 500);\nif (typeof version == 'undefined') {\n        } else\n        {\n            if (version[0] == \"2\") {\n                MathJax.Hub.Queue([\"Typeset\", MathJax.Hub]);\n            } else if (version[0] == \"3\") {\n                MathJax.typeset([mydiv]);\n            } else {\n                console.log(\"MathJax not found\");\n            }\n        }\n    }\n    return false;\n}\n/* This is to handle asynchrony issues in loading Jupyter notebooks\n           where the quiz has been previously run. The Javascript was generally\n           being run before the div was added to the DOM. I tried to do this\n           more elegantly using Mutation Observer, but I didn't get it to work.\n\n           Someone more knowledgeable could make this better ;-) */\n\n        function try_show() {\n          if(document.getElementById(\"FWnnuqEsBzQK\")) {\n            show_questions(questionsFWnnuqEsBzQK,  FWnnuqEsBzQK); \n          } else {\n             setTimeout(try_show, 200);\n          }\n        };\n    \n        {\n        // console.log(element);\n\n        //console.log(\"FWnnuqEsBzQK\");\n        // console.log(document.getElementById(\"FWnnuqEsBzQK\"));\n\n        try_show();\n        }\n        ",
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "q1 = [{\n",
    "        \"question\": \"Which one of the following statements is true for a Gumbel graph?\",\n",
    "        \"type\": \"multiple_choice\",\n",
    "        \"answers\": [\n",
    "            {\n",
    "                \"answer\": \"For natural rivers, when applying Gumbel to water levels instead of discharges, one will observe a bend/kink downwards in the Gumbel graph at a return period of approximately 1.5 - 2 years.\",\n",
    "                \"correct\": True\n",
    "            },\n",
    "            {\n",
    "                \"answer\": \"An observed discharge plotting below the Gumbel line indicates that the actual return period of that discharge is higher\",\n",
    "                \"correct\": False\n",
    "            },\n",
    "            {\n",
    "                \"answer\": \"When applying Gumbel to water levels, a structure like a bridge causes a bend/kink downwards in the graph.\",\n",
    "                \"correct\": False\n",
    "            }\n",
    "        ]\n",
    "    }]\n",
    "display_quiz(q1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "hydro",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}