01-introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "41a374b9",
   "metadata": {},
   "source": [
    "#### Notebook style configuration <span style=\"font-weight:200;\">(optional)</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ef4f9df",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "style = open(\"data/style.css\").read()\n",
    "display(HTML(\"<style>%s</style>\" % style))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43ddcffc",
   "metadata": {},
   "source": [
    "### Table of contents <a name=\"TOC\"></a>\n",
    "\n",
    "* [Introduction](#introduction)\n",
    "* [Single axes](#single_axes)\n",
    "* [Multiple axes](#multiple_axes)\n",
    "* [Ticks and labels](#ticks)\n",
    "* [Exercises](#exercises)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee58eee6",
   "metadata": {},
   "source": [
    "# 1. Introduction <a name=\"introduction\"></a><span style=\"float:right;\"><a class=\"small\" style=\"color:black; text-decoration: none; \" href=\"#TOC\">[Back to TOC]</a></span>\n",
    "\n",
    "In this introduction, we'll see how to make a [figure](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.figure.html?highlight=figure#matplotlib.pyplot.figure) and play with the different settings such as to improve the rendering. We'll also see how to compose a figure made of several [subplots](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.subplot.html) with a moderatly complex layout.\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"data/anatomy.png\" width=\"50%\" align=\"left\" /> <img src=\"data/subplots.png\" width=\"50%\" />\n",
    "\n",
    "\n",
    "These images come from the [cheatsheets](https://github.com/matplotlib/cheatsheets).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9886e56e",
   "metadata": {},
   "source": [
    "# 2. Single axes <a name=\"single_axes\"></a> <span style=\"float:right;\"><a class=\"small\" style=\"color:black; text-decoration: none;\" href=\"#TOC\">[Back to TOC]</a></span>\n",
    "\n",
    "We'll start by playing with a very simple exampe (sine and cosine trigonometric functions) using the [plot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html) function and see what options are avalaible to us. We'll see there exists a (very) large number of options that allow to obtain quite different outputs. More precisely, you can modify any aspect of a figure and obtain the precise rendering you've in mind. The only difficulty is to know what are these options and how to apply them.\n",
    "\n",
    "**Note** The standard way of importing maplotlib is to write `import matplotlib.pyplot as plt` and then use the `plt` prefix in front of matplotlib related functions. In some rather rare cases, we also use the `matplotlib` prefix, but most of the time we only need `plt`.\n",
    "\n",
    "## 2.1 Data preparation\n",
    "\n",
    "Before starting any plot, we need first to have some data to plot. Such data can originate from your own experiment or analysis but for the sake of simplicity, we'll generate our own data using the [numpy](https://numpy.org) library. For the sine and cosine functions, we simply generate 257 values linearly spaced between -π and +π and we compute the sine and cosine of these values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42042a29",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "X = np.linspace(-np.pi, np.pi, 257, endpoint=True)\n",
    "C, S = np.cos(X), np.sin(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5f9fbb6",
   "metadata": {},
   "source": [
    "X is now a numpy array with 257 values ranging from -π to +π (included). C is the cosine (257 values) and S is the sine (257 values). We're ready to plot them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c08bf284",
   "metadata": {},
   "source": [
    "## 2.2 Plotting with defaults\n",
    "\n",
    "Let's draw our first figure and observe what the result looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22b1a627",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(X, C)\n",
    "plt.plot(X, S)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c949549e",
   "metadata": {},
   "source": [
    "**Exercise together:** What aspects of this plot could be improved?\n",
    "\n",
    "**Answer:**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02d36201",
   "metadata": {},
   "source": [
    "**Exercise together:** We chose the value `257` arbitrarily. But what if we had chosen fewer points? The plot is below--why does it look like what it does? What does this mean for plotting? What if I plotted 25,700 points instead?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "668d91a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "Xfew = np.linspace(-np.pi, np.pi, 8, endpoint=True)\n",
    "Cfew, Sfew = np.cos(Xfew), np.sin(Xfew)\n",
    "\n",
    "plt.plot(Xfew, Cfew)\n",
    "plt.plot(Xfew, Sfew)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6382ce59",
   "metadata": {},
   "source": [
    "**Answer:** \n",
    "\n",
    "### 2.2.1 The two interfaces\n",
    "\n",
    "Note that when dealing with figures and axes, `matplotlib` has two parallel interfaces: the `pyplot` interface (`plt.xlabel`) and the object-oriented interface (`ax.set_xlabel`). \n",
    "\n",
    "The pyplot interface was developed first, and its methods are generally applied to the current axes or figure. It is recommended to use the object-oriented interface, as it is both clearer code and more flexibile.\n",
    "\n",
    "**Exercise for the reader:** The code below was written by someone who was a little unfamiliar with how matplotlib works. \n",
    " Question 1. Why are the lines and labels only appearing in the second plot?  \n",
    " Question 2. Modify the code so it uses the object-oriented interface. Does the plot now look like what you'd expect?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3131c37",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(2, 1, num=1, figsize=(9, 4), clear=True)\n",
    "\n",
    "ax = axs[0]\n",
    "plt.plot(X, C)\n",
    "plt.plot(X, S)\n",
    "plt.xlabel('Angle')\n",
    "plt.ylabel('Trig (fine)')\n",
    "plt.xlim([-np.pi, np.pi])\n",
    "\n",
    "ax = axs[1]\n",
    "plt.plot(Xfew, Cfew)\n",
    "plt.plot(Xfew, Sfew)\n",
    "plt.xlabel('Angle')\n",
    "plt.ylabel('Trig (fine)')\n",
    "plt.xlim([-np.pi, np.pi])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03094433",
   "metadata": {},
   "source": [
    "## 2.3 Using style sheets\n",
    "\n",
    "Sometimes, we don't want fine control over our plot, but there are some plotting settings that we want to apply to all of our plots. (E.g., a new color cycle, changing the axes spines to dark grey, etc.) The easiest way to do that is to use [style sheets](https://matplotlib.org/stable/tutorials/introductory/customizing.html). Matplotlib has several built in, or you can make your own once you know which values in `plt.rcParams` you want to update (more on that later).\n",
    "\n",
    "To use a style sheet for all plots in a session:\n",
    "```python\n",
    "plt.style.use(<sheet_name>)\n",
    "```\n",
    "If you want to use a style sheet on just a single plot without changing the default plot settings you can use a context manager:\n",
    "```python\n",
    "with plt.style.context(<sheet_name>):\n",
    "    plt.plot(...)\n",
    "```\n",
    "\n",
    "**Exercise for the reader:** Use a context manager with the code below but using one of the built-in styles. You can find available built-in styles using the `plt.style.available` command. Did any style sheet resolve all the issues we discussed?\n",
    "\n",
    "**Answer:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34885fbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(X, C)\n",
    "plt.plot(X, S)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53943858",
   "metadata": {},
   "source": [
    "If you want to make your own style sheet to reuse, there is an exercise at the end of this notebook that may interest you. :)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0105893d",
   "metadata": {},
   "source": [
    "## 2.4 Customizing the plot\n",
    "\n",
    "None of the style sheets could address all the plot changes we want, so we need to explicitly control our settings. \n",
    "\n",
    "### 2.4.1 Accessing default plotting parameters\n",
    "\n",
    "To know what to change, we need to first know what settings are available and what they're called. We start by checking out the defaults from the [maplotlibrc](https://matplotlib.org/stable/tutorials/introductory/customizing.html#customizing-with-matplotlibrc-files) configuration file that is accessible through the `plt.rcParams` variable. \n",
    "\n",
    "**Exercise for the reader:** Run the following cell, then look at the keys the dictionary `p` contains. What is the default font size of the title? What is the default figure size?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ffc096e",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = plt.rcParams"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e897f1c",
   "metadata": {},
   "source": [
    "There are a lot of settings to look through. To help you, the function below can be used to output the default settings nested within each field of `rcParams`. It can be useful to easily see what values are what when tweaking plots.\n",
    "\n",
    "**Exercise for the reader:** Use the function below to find all the relevant default settings for the spines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0ec93b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "def defaults(pattern=''):\n",
    "    \"\"\"Return the default rcParams settings.\n",
    "    Optionally provide a pattern to select only\n",
    "    some keys.\n",
    "    \"\"\"\n",
    "    p = plt.rcParams\n",
    "    keys = [s for s in p.keys() if pattern in s]\n",
    "    data = {key:p[key] for key in keys}\n",
    "    frame = pd.DataFrame(data.values(), index=data.keys(),\n",
    "                         columns=['Default value'])\n",
    "    display(frame)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29b2cbea",
   "metadata": {},
   "source": [
    "We now have access to see the default values, but how do we use this during plotting?\n",
    "\n",
    "One option is to pass every value in `plt.rcParams` explicitly in while plotting. Remember our simple code from before:\n",
    "```python\n",
    "plt.plot(X, C)\n",
    "plt.plot(X, S)\n",
    "```\n",
    "When implicitly using the default values, it was simply two lines. Here is what it looks like if we pass everying in explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f505bb5",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize = p['figure.figsize'],\n",
    "                 dpi = p['figure.dpi'],\n",
    "                 facecolor = p['figure.facecolor'],\n",
    "                 edgecolor = p['figure.edgecolor'],\n",
    "                 frameon = p['figure.frameon'])\n",
    "\n",
    "ax = plt.subplot()\n",
    "                   \n",
    "ax.plot(X, C, color=\"C0\",\n",
    "              linewidth = p['lines.linewidth'],\n",
    "              linestyle = p['lines.linestyle'])\n",
    "\n",
    "ax.plot(X, S, color=\"C1\",\n",
    "              linewidth = p['lines.linewidth'],\n",
    "              linestyle = p['lines.linestyle'])\n",
    "\n",
    "xmin, xmax = X.min(), X.max()\n",
    "xmargin = p['axes.xmargin']*(xmax - xmin)\n",
    "ax.set_xlim(xmin - xmargin, xmax + xmargin)\n",
    "\n",
    "ymin, ymax = min(C.min(), S.min()), max(C.max(), S.max())\n",
    "ymargin = p['axes.ymargin']*(ymax - ymin)\n",
    "ax.set_ylim(ymin - ymargin, ymax + ymargin)\n",
    "\n",
    "ax.tick_params(axis = \"x\", which=\"major\",\n",
    "               direction = p['xtick.direction'],\n",
    "               length = p['xtick.major.size'],\n",
    "               width = p['xtick.major.width'])\n",
    "\n",
    "ax.tick_params(axis = \"y\", which=\"major\",\n",
    "               direction = p['ytick.direction'],\n",
    "               length = p['ytick.major.size'],\n",
    "               width = p['ytick.major.width'])\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e9f596f",
   "metadata": {},
   "source": [
    "Pretty much everything can specified, but passing this in explicitly is a pain. Let's instead modify `plt.rcParams`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cef3743",
   "metadata": {},
   "source": [
    "### 2.4.2 Making custom settings\n",
    "\n",
    "As you can see from the script above, pretty much everything can be changed. So let's modify our figure to improve the rendering a bit. Now that we know what the defaults are called, we can modify them directly in `plt.rcParams`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e711c98a",
   "metadata": {},
   "source": [
    "#### Figure size\n",
    "\n",
    "The plot appears a bit packed so let's first modify the figure size.\n",
    "To do so, we need to create it explicitely in order to specify a size in inches. Let's try 10 inches wide and 3 inches tall. We'll also use an Axes ( `ax` ) which can be considered as a subfigure and we'll increase the DPI (dots per inch) of the figure to get a better resolution in the notebook.\n",
    "\n",
    "**Exercise for the reader:** Modify the figure size and dpi in variable `p`.\n",
    "\n",
    "**Answer:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5373816b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set default figure size \n",
    "code here...\n",
    "\n",
    "# Set default figure dpi\n",
    "code here..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36886c0a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(X, C)\n",
    "ax.plot(X, S)\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e96a57e",
   "metadata": {},
   "source": [
    "**Important!** Since we modified `rcParams`, this will influence all subsequent figures in this notebook, including the top figures."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92ae7691",
   "metadata": {},
   "source": [
    "#### Line styles\n",
    "\n",
    "Solid line is the default line style but there exist [several other styles](https://matplotlib.org/stable/gallery/lines_bars_and_markers/linestyles.html) such as dashed lines (`linestyle=\"--\"`), dotted lines (`linestyle=\":\"`), etc. You can also combine a style with a marker. For example, we can add circular markers at regular intervals. To do that, we specify the `marker` symbol as `'o'`, the marker color and the spacing between markers (else you will have a marker at each data  point). \n",
    "\n",
    "**Exercise for the reader:** Modify the code below to have circular markers every 32 data ponts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cdbeee4",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "ax.plot(X, C, marker=None, markevery=None, markerfacecolor=\"white\")\n",
    "ax.plot(X, S, marker=None, markevery=None, markerfacecolor=\"white\")\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34337245",
   "metadata": {},
   "source": [
    "#### Tick positions and labels\n",
    "\n",
    "Ticks on the x axis are not ideal positioned because they do not show the interesting values (+/-$\\pi$,+/-$\\pi$/2) and there are too many ticks on the y axis. Moreover, it would be more interesting to express them in multiples of pi.\n",
    "\n",
    "**Exercise for the reader:** Change the xticks so they only occur at multiples of π/2 the yticks so they only occur at -1, 0 and 1. Change the xtick labels so they are multiples of π/2, and change the ytick labels to read \"-1\", \"0\", and \"+1\". (Hint: The methods you are looking for are `ax.set_xtick` and `ax.set_xticklabel`, and their y-axis counterparts.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a769ab70",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "ax.plot(X, C, marker=\"o\", markevery=32, markerfacecolor=\"white\")\n",
    "ax.plot(X, S, marker=\"o\", markevery=32, markerfacecolor=\"white\")\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a899a07b",
   "metadata": {},
   "source": [
    "#### Spines position\n",
    "\n",
    "Spines are the four lines around our figure and delimiting the data area. Byt default, there are four spines at top/bottom and left/right but we can hide some of them and move the others. Since there are four of them (top/bottom/left/right), we'll hide the top and right and we'll move the bottom and left ones to coordinate 0 (in data space coordinates).\n",
    "\n",
    "**Exercise for the reader:** Modify the following code so that the right and top spines are no longer visible. Change the position of the bottom and left spines so that their positions are at 0 in data coordinates. (Hint: The handles to the right spine is accessible by `ax.spines['right']`. The spine object has two relevant methods for this exercise: `set_visible` and `set_position`.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1ff65e8",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "ax.plot(X, C, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\")\n",
    "ax.plot(X, S, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\")\n",
    "\n",
    "ax.set_xticks([-np.pi, -np.pi/2, np.pi/2, np.pi])\n",
    "ax.set_xticklabels([\"-π\", \"-π/2\", \"π/2\", \"$π$\"])\n",
    "ax.set_yticks([-1,1])\n",
    "ax.set_yticklabels([\"-1\", \"+1\"])\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "598474a8",
   "metadata": {},
   "source": [
    "#### Z order\n",
    "\n",
    "Now that our spines overlap our lines, we can see that the axes are plotted on top the lines. It was already the case previosuly but it was less noticeable. Now with the markers, it is more obvious and pretty annoying. To fix the problem, we need to tell matplotlib to render our sine and cosine plots in front of the axis. To do so, we need to specify a zorder that specify the order of rendering. Elements are rendererd in increasing zorder.\n",
    "\n",
    "**Exercise for the reader:** Use the `zorder` keyword argument in `plot` to move the lines above the axes. Note that axes correspond to a zorder of 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2ac4965",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "ax.plot(X, C, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\")\n",
    "ax.plot(X, S, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\")\n",
    "\n",
    "ax.set_xticks([-np.pi, -np.pi/2, np.pi/2, np.pi])\n",
    "ax.set_xticklabels([\"-π\", \"-π/2\", \"π/2\", \"π\"])\n",
    "ax.set_yticks([-1, 1])\n",
    "ax.set_yticklabels([\"-1\",  \"+1\"])\n",
    "\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['bottom'].set_position(('data',0))\n",
    "ax.spines['left'].set_position(('data',0))\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a77509eb",
   "metadata": {},
   "source": [
    "#### Legend\n",
    "\n",
    "Matplotlib allows adding legends with [a great degree of control](https://matplotlib.org/stable/tutorials/intermediate/legend_guide.html). For now, we will add a simple legend in the upper left-hand corner. We do this by labelling the data we plot (i.e., adding the keyword argument `label` into our `plot` function) and then calling `ax.legend`.\n",
    "\n",
    "**Exercise for the reader**: Label the cosine and sine curves. Add a legend in the upper left corner, and use `frameon=False` to turn off the border around the legend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2091ce44",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "ax.plot(X, C, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\",\n",
    "              zorder=10)\n",
    "ax.plot(X, S, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\",\n",
    "              zorder=10)\n",
    "\n",
    "ax.set_xticks([-np.pi, -np.pi/2, np.pi/2, np.pi])\n",
    "ax.set_xticklabels([\"-π\", \"-π/2\", \"π/2\", \"π\"])\n",
    "ax.set_yticks([-1, 1])\n",
    "ax.set_yticklabels([\"-1\", \"+1\"])\n",
    "\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['bottom'].set_position(('data',0))\n",
    "ax.spines['left'].set_position(('data',0))\n",
    "\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dac14ee8",
   "metadata": {},
   "source": [
    "#### Font size\n",
    "\n",
    "The font size of the tick labels is a bit small. Let's increase it a bit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca75e6d8",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "ax.plot(X, C, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\",\n",
    "              zorder=10, label=\"cosine\")\n",
    "ax.plot(X, S, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\",\n",
    "              zorder=10, label=\"sine\")\n",
    "\n",
    "ax.set_xticks([-np.pi, -np.pi/2, np.pi/2, np.pi])\n",
    "ax.set_xticklabels([\"-π\", \"-π/2\", \"π/2\", \"π\"])\n",
    "ax.set_yticks([-1, 1])\n",
    "ax.set_yticklabels([\"-1\", \"+1\"])\n",
    "\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['bottom'].set_position(('data',0))\n",
    "ax.spines['left'].set_position(('data',0))\n",
    "\n",
    "ax.legend(loc='upper left', frameon=False);\n",
    "\n",
    "for label in ax.get_xticklabels() + ax.get_yticklabels():\n",
    "    label.set_fontsize(\"large\");\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77c16242",
   "metadata": {},
   "source": [
    "#### Title\n",
    "\n",
    "We're almost done. Let's now add a title on the left of our figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fbce4f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "\n",
    "ax.plot(X, C, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\",\n",
    "              zorder=10, label=\"cosine\")\n",
    "ax.plot(X, S, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\",\n",
    "              zorder=10, label=\"sine\")\n",
    "\n",
    "ax.set_xticks([-np.pi, -np.pi/2, np.pi/2, np.pi])\n",
    "ax.set_xticklabels([\"-π\", \"-π/2\", \"π/2\", \"π\"])\n",
    "ax.set_yticks([-1, 1])\n",
    "ax.set_yticklabels([\"-1\", \"+1\"])\n",
    "\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['bottom'].set_position(('data',0))\n",
    "ax.spines['left'].set_position(('data',0))\n",
    "\n",
    "ax.legend(loc='upper left', frameon=False);\n",
    "ax.set_title(\"Trigonometric functions\", x=0.1)\n",
    "\n",
    "for label in ax.get_xticklabels() + ax.get_yticklabels():\n",
    "    label.set_fontsize(\"large\")\n",
    "    \n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c95f1c0",
   "metadata": {},
   "source": [
    "### 2.4.3 Saving the result\n",
    "\n",
    "We can now save our figure in a file. There are many different figure formats, but vector graphics will produce a figure that is flawless independently of the zoom level. So let's save to a PDF."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c554dfb2",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(X, C, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\",\n",
    "              zorder=10, label=\"cosine\")\n",
    "ax.plot(X, S, marker=\"o\", markevery=(0, 32), markerfacecolor=\"white\",\n",
    "              zorder=10, label=\"sine\")\n",
    "\n",
    "ax.set_xticks([-np.pi, -np.pi/2, np.pi/2, np.pi])\n",
    "ax.set_xticklabels([\"-π\", \"-π/2\", \"π/2\", \"π\"])\n",
    "ax.set_yticks([-1, 1])\n",
    "ax.set_yticklabels([\"-1\", \"+1\"])\n",
    "\n",
    "ax.spines['right'].set_visible(False)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['bottom'].set_position(('data',0))\n",
    "ax.spines['left'].set_position(('data',0))\n",
    "\n",
    "ax.legend(loc='upper left', frameon=False);\n",
    "\n",
    "for label in ax.get_xticklabels() + ax.get_yticklabels():\n",
    "    label.set_fontsize(\"large\");\n",
    "    \n",
    "plt.savefig(\"./01-introduction.pdf\")\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12c14a1e",
   "metadata": {},
   "source": [
    "  \n",
    "---\n",
    "  \n",
    "  \n",
    "#  3. Multiple axes <a name=\"multiple_axes\"></a> <span style=\"float:right;\"><a class=\"small\" style=\"color:black; text-decoration: none;\" href=\"#TOC\">[Back to TOC]</a></span>\n",
    "\n",
    "So far, we've been dealing with a single axes  on a figure, but of course, Matplotlib offers the possibility to draw several plots on the same figure. The only difficulty is to express the layout of these different plots. But let's start with someting simple first."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "036f9a87",
   "metadata": {},
   "source": [
    "We want to split our sine and cosine plot in two different plots side by side. To do that we need to create two axes. The most straigthforward way is to use the `plt.subplots` method to create subplots with the specified rows and colums. This method returns an array of axes that you can index to access the axes of your choice. You can also use the `plt.subplot` method, which is similar to the Matlab `subplot` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3080e67",
   "metadata": {},
   "outputs": [],
   "source": [
    "nrows, ncols = 2, 3\n",
    "fig, axs = plt.subplots(nrows, ncols, figsize=(12,7))\n",
    "for index in range(nrows*ncols):\n",
    "    ax = axs[index // ncols, index % ncols];\n",
    "    ax.set_title(\"plt.subplot(%d,%d,%d)\" % (nrows, ncols, index+1), weight=\"bold\")\n",
    "    \n",
    "plt.tight_layout()\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90592285",
   "metadata": {},
   "source": [
    "Back to our example, we need one row and two columns. Let's also move our plotting code into a function so it's easier to reuse.\n",
    "\n",
    "**Exercise for the reader:** Modify the following code so it make a figure with two subplots, one next to the other. Plot the cosine into the left subplot and the sign into the right subplot. Label the cosine plot \"cosine\" and the sine plot \"sine\".\n",
    "\n",
    "**Answer:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b243278e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot(ax, X, Y, title=\"\"):\n",
    "    \"\"\"Plot a sinusoid in a very nice way.\"\"\"\n",
    "    ax.plot(X,Y)\n",
    "    \n",
    "    ax.set_xticks([-np.pi, -np.pi/2, np.pi/2, np.pi])\n",
    "    ax.set_xticklabels([\"-π\", \"-π/2\", \"π/2\", \"π\"])\n",
    "    ax.set_yticks([-1, 1])\n",
    "    ax.set_yticklabels([\"-1\", \"+1\"])\n",
    "\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['bottom'].set_position(('data',0))\n",
    "    ax.spines['left'].set_position(('data',0))\n",
    "    \n",
    "    ax.set_title(title, weight=\"bold\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b45750a0",
   "metadata": {},
   "source": [
    "What if we want to have more complex layout with plot of unequal size? In this case, the best is to use the [gridspec](https://matplotlib.org/stable/api/_as_gen/matplotlib.gridspec.GridSpec.html) method. It also involves dividing the figure into rows and columns, but now we can specify the bounds of each plot, i.e. position and extent and their relative size. Let's see some example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44924648",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(10,6))\n",
    "from matplotlib.gridspec import GridSpec\n",
    "    \n",
    "nrows, ncols = 2, 2\n",
    "widths = 1, 2  # Experiment changing 2 to 3,4,5, etc\n",
    "heights = 1, 2 # Experiment changing 2 to 3,4,5, etc\n",
    "G = GridSpec(nrows, ncols, width_ratios = widths, height_ratios=heights)\n",
    "\n",
    "aspect= 'auto' # Experiment with aspect=1\n",
    "ax = plt.subplot(G[0,0], aspect=aspect); ax.plot(X,C,X,S); ax.grid(1)\n",
    "ax = plt.subplot(G[1,0], aspect=aspect); ax.plot(X,C,X,S); ax.grid(1)\n",
    "ax = plt.subplot(G[0,1], aspect=aspect); ax.plot(X,C,X,S); ax.grid(1)\n",
    "ax = plt.subplot(G[1,1], aspect=aspect); ax.plot(X,C,X,S); ax.grid(1)\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87133b2b",
   "metadata": {},
   "source": [
    "Using gridspec, you can specify any layout, the only difficulty being to be able to express what you want to achieve."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98186ce3",
   "metadata": {},
   "source": [
    "# 4. Ticks and labels <a name=\"ticks\"></a> <span style=\"float:right;\"><a class=\"small\" style=\"color:black; text-decoration: none;\" href=\"#TOC\">[Back to TOC]</a></span>\n",
    "\n",
    "We have already manipulated ticks and tick labels in the previous sections but we only slighlty modified them. In fact, there exists a fairly extended machinery in matplotlib that allows you to put ticks at any position using any formats (for the label). Let's start with a very simple example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df116c8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.ticker import MultipleLocator\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))\n",
    "ax = plt.subplot()\n",
    "\n",
    "ax.set_xlim(0,10);\n",
    "ax.set_ylim(0,5);\n",
    "\n",
    "ax.xaxis.set_major_locator(MultipleLocator(1.0))\n",
    "ax.yaxis.set_major_locator(MultipleLocator(1.0))\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "215a9a41",
   "metadata": {},
   "source": [
    "This output of this first example is not fundamentally different from what we've seen so far. But the way to obtain this result is different because we use a `MultipleLocator` descriptor that instructs matplotlib to put major ticks at every unit ( `1.0` ) on the x and y axis. But we can also do the same for minor ticks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23b3beef",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.ticker import MultipleLocator\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))\n",
    "ax = plt.subplot()\n",
    "\n",
    "ax.set_xlim(0,10)\n",
    "ax.set_ylim(0,5)\n",
    "\n",
    "ax.xaxis.set_major_locator(MultipleLocator(1.0))\n",
    "ax.yaxis.set_major_locator(MultipleLocator(1.0))\n",
    "\n",
    "ax.xaxis.set_minor_locator(MultipleLocator(0.1))\n",
    "ax.yaxis.set_minor_locator(MultipleLocator(0.1))\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6182e875",
   "metadata": {},
   "source": [
    "We can also modify the labels under ticls. Let's make thme bold and white on black."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f4e8260",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.ticker import MultipleLocator\n",
    "\n",
    "fig = plt.figure(figsize=(10,5))\n",
    "ax = plt.subplot()\n",
    "\n",
    "ax.set_xlim(0,10);\n",
    "ax.set_ylim(0,5);\n",
    "\n",
    "ax.xaxis.set_major_locator(MultipleLocator(1.0));\n",
    "ax.yaxis.set_major_locator(MultipleLocator(1.0));\n",
    "\n",
    "ax.xaxis.set_minor_locator(MultipleLocator(0.1));\n",
    "ax.yaxis.set_minor_locator(MultipleLocator(0.1));\n",
    "\n",
    "for label in ax.yaxis.get_ticklabels() + ax.xaxis.get_ticklabels():\n",
    "    label.set_fontweight(\"bold\");\n",
    "    label.set_fontsize(\"x-small\");\n",
    "    label.set_color(\"white\");\n",
    "    label.set_bbox(dict(facecolor='black', linewidth=1, edgecolor='0.0', pad=2))\n",
    "    \n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc44e7fb",
   "metadata": {},
   "source": [
    "  \n",
    "---\n",
    "  \n",
    "\n",
    "# 5. Exercises <a name=\"exercises\"></a>  <span style=\"float:right;\"><a class=\"small\" style=\"color:black; text-decoration: none;\" href=\"#TOC\">[Back to TOC]</a></span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d4858cd",
   "metadata": {},
   "source": [
    "## 1. Better typography \n",
    "\n",
    "We used π/2 to display pi over two to but it would be better to display $\\frac{\\pi}{2}$. How would you do modify the tick labels such a to obtain the same output as in the figure below?\n",
    "\n",
    "**Hint:** You can edit this notebook cell to see how I wrote $\\frac{\\pi}{2}$.\n",
    "\n",
    "<img src=\"data/01-exercise-1.png\" width=\"100%\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29e20f9f",
   "metadata": {},
   "source": [
    "## 2. Making a style sheet\n",
    "\n",
    "We've discussed using built-in style sheets and `plt.rcParams`, but we have not explored how we can generate our own style sheets. Style sheets are text files with the extension `.mplstyle` that overwrite the settings in `plt.rcParams` when loaded. Here is a partial example of a simple style sheet from [this tutorial](https://towardsdatascience.com/how-to-create-and-use-custom-matplotlib-style-sheet-9393f498063):\n",
    "\n",
    "```\n",
    "### FIGURE\n",
    "figure.facecolor: white\n",
    "figure.dpi: 100\n",
    "figure.titleweight: bold\n",
    "\n",
    "### LINES\n",
    "lines.linewidth: 1.5\n",
    "\n",
    "### LEGEND\n",
    "legend.fontsize: 12\n",
    "\n",
    "### AXES\n",
    "axes.spines.top: True\n",
    "axes.spines.right: True\n",
    "axes.prop_cycle: cycler(\n",
    "    'color', ['0072B2', '009E73', 'D55E00', 'CC79A7', 'F0E442', '56B4E9']\n",
    ")\n",
    "```\n",
    "\n",
    "Your exercise is to make your own style sheet. Use the `defaults` function we wrote above to explore which options are available, and save the values into a local sheet. Test the style sheet in the function below.\n",
    "\n",
    "**When you are done!** Commit your notebook on a branch and push it to the repository. We will go through them together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "424c2587",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "X = np.linspace(-np.pi, np.pi, 257, endpoint=True)\n",
    "C, S = np.cos(X), np.sin(X)\n",
    "\n",
    "with plt.style.context('seaborn'):\n",
    "    plt.plot(X, C, label='cosine')\n",
    "    plt.plot(X, S, label='sine')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35e0b850",
   "metadata": {},
   "source": [
    "## 3. Better style \n",
    "\n",
    "Starting from the code template below, you need to write the subplot function to achieve the same result as the figure below. The only difficulty are the arrows at end of x and y axis. To plot them, you can plot them using specific [markers](https://matplotlib.org/stable/api/markers_api.html).\n",
    "\n",
    "<img src=\"data/01-exercise-2.png\" width=\"100%\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4659400",
   "metadata": {},
   "outputs": [],
   "source": [
    "raise Exception(\"!!! To be completed\")\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def subplot(index, title):    \n",
    "    # To be completed\n",
    "    return ax\n",
    "\n",
    "fig = plt.figure(figsize=(13,5), dpi=300)\n",
    "X = np.linspace (-4,4,200)\n",
    "\n",
    "subplot(1, \"y = cos(x)\").plot(X, np.cos(X), \"C1\")\n",
    "subplot(2, \"y = sin(x)\").plot(X, np.sin(X), \"C1\")\n",
    "subplot(3, \"y = tan(x)\").plot(X, np.tan(X), \"C1\")\n",
    "subplot(4, \"y = cosh(x)\").plot(X, np.cosh(X), \"C1\")\n",
    "subplot(5, \"y = sinh(x)\").plot(X, np.sinh(X), \"C1\")\n",
    "subplot(6, \"y = tanh(x)\").plot(X, np.tanh(X), \"C1\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50d9d588",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "**Copyright (c) 2021 Nicolas P. Rougier**  \n",
    "This work is licensed under a [Creative Commons Attribution 4.0 International License](http://creativecommons.org/licenses/by/4.0/).\n",
    "<br/>\n",
    "Code is licensed under a [2-Clauses BSD license](https://opensource.org/licenses/BSD-2-Clause)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}