week11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CS102-4 - Further Computing\n",
    "\n",
    "Prof. Götz Pfeiffer<br>\n",
    "School of Mathematics, Statistics and Applied Mathematics<br>\n",
    "NUI Galway"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Aspects of Data Visualization\n",
    "\n",
    "# Week 11: Visualizing higher dimensional data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Three-dimensional or even higher dimensional data is naturally more difficult to plot \n",
    "in a meaningful way (as a 2-dimensional drawing)  than\n",
    "2-dimensional data.   But `matplotlib` offers various solutions that apply well in particular situations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('seaborn-white')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Contour Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Sometimes it is useful to display three-dimensional data in two dimensions using **contours** or **color-coded regions**.\n",
    "* There are three `Matplotlib` functions that can be helpful for this task: \n",
    "  * ``plt.contour`` for contour plots, \n",
    "  * ``plt.contourf`` for filled contour plots, and \n",
    "  * ``plt.imshow`` for showing images.\n",
    "* Here, we look at several examples of using these. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example: Visualizing a Function of Two Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* We start with a **contour plot** of a function $z = f(x, y)$, using the following particular choice for $f$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x, y):\n",
    "    return np.sin(x) ** 10 + np.cos(10 + y * x) * np.cos(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A contour plot created with the `plt.contour` function takes three arguments: \n",
    "  * a grid of $x$ values, \n",
    "  * a grid of $y$ values, \n",
    "  * and a grid of $z$ values.\n",
    "* The $x$ and $y$ values represent positions on the plot, and the $z$ values will be represented by the contour levels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 5, 50)\n",
    "y = np.linspace(0, 5, 40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* This gives $50$ points between $0$ and $5$ in $x$-direction and $40$ points between $0$ and $5$ in $y$-direction to begin with.\n",
    "* For the broadcasting purposes within `f`, the `y` would need to be reshaped as a column vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = f(x, y.reshape(40,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Perhaps a cleaner way to prepare such data is to use the `np.meshgrid` function, which builds two-dimensional grids from one-dimensional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, Y = np.meshgrid(x, y)\n",
    "Z = f(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `meshgrid` combines these into $40 \\times 50$ pairs of $x, y$-values which are then returned separately\n",
    "as a $40 \\times 50$-array `X` of $x$-values\n",
    "and a $40 \\times 50$-array `Y` of $y$-values, both broadcasted from the original `linspace`s."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Now let's look at this with a standard line-only contour plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.contour(x, y, z);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.contour(X, Y, Z, colors = 'b');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Notice that by default when a single color is used, negative values are represented by dashed lines, and positive values by solid lines.\n",
    "* Alternatively, the lines can be color-coded by specifying a colormap with the ``cmap`` argument.\n",
    "* Here, we'll also specify that we want more lines to be drawn—20 equally spaced intervals within the data range:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.contour(X, Y, Z, 20, cmap='RdGy');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Here we chose the ``RdGy`` (short for *Red-Gray*) colormap, which is a good choice for centered data.\n",
    "* `Matplotlib` has a wide range of colormaps available, which you can easily browse in `IPython` by doing a tab completion on the ``plt.cm`` module:\n",
    "```\n",
    "plt.cm.<TAB>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filled Contour Plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Our plot is looking nicer, but the spaces between the lines may be a bit distracting.\n",
    "* We can change this by switching to a filled contour plot using the ``plt.contourf()`` function (notice the ``f`` at the end), which uses largely the same syntax as ``plt.contour()``.\n",
    "\n",
    "* Additionally, we'll add a ``plt.colorbar()`` command, which automatically creates an additional axis with labeled color information for the plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.contourf(X, Y, Z, 20, cmap='RdGy')\n",
    "plt.colorbar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The colorbar makes it clear that the black regions are \"peaks,\" while the red regions are \"valleys.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* An alternative way to plot these data is to use the ``plt.imshow()`` function, which interprets a two-dimensional grid of data as an image.\n",
    "\n",
    "* The following code shows this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(Z, extent=[0, 5, 0, 5], origin='lower',\n",
    "           cmap='RdGy')\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ``plt.imshow()`` doesn't accept an $x$ and $y$ grid, so you must manually specify the **extent** ``[xmin, xmax, ymin, ymax]`` of the image on the plot.\n",
    "- ``plt.imshow()`` by default follows the standard image array definition where the origin is in the upper left, not in the lower left as in most contour plots. This must be changed when showing gridded data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Finally, it can sometimes be useful to combine contour plots and image plots.\n",
    "* For example, here we'll use a partially transparent background image (with transparency set via the ``alpha`` parameter) and overplot contours with labels on the contours themselves (using the ``plt.clabel()`` function):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contours = plt.contour(X, Y, Z, 4, colors='black')\n",
    "plt.clabel(contours)\n",
    "\n",
    "plt.imshow(Z, extent=[0, 5, 0, 5], origin='lower',\n",
    "           cmap='RdGy', alpha=0.5)\n",
    "plt.colorbar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The combination of these three functions—``plt.contour``, ``plt.contourf``, and ``plt.imshow``—gives nearly limitless possibilities for displaying this sort of three-dimensional data within a two-dimensional plot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Three-Dimensional Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `Matplotlib` was initially designed with only two-dimensional plotting in mind.\n",
    "* Around the time of the 1.0 release, some three-dimensional plotting utilities were built on top of `Matplotlib`'s two-dimensional display, and the result is a convenient (if somewhat limited) set of tools for three-dimensional data visualization.\n",
    "* Three-dimensional plots are enabled by importing the ``mplot3d`` toolkit, included with the main `Matplotlib` installation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits import mplot3d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Once this submodule is imported, a three-dimensional axes can be created by passing the keyword ``projection='3d'`` to any of the normal axes creation routines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.axes(projection='3d')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* With this three-dimensional axes enabled, we can now plot a variety of three-dimensional plot types. \n",
    "* Three-dimensional plotting is one of the functionalities that benefits immensely from viewing figures interactively rather than statically in the notebook.\n",
    "* To use interactive figures, you can use ``%matplotlib notebook`` rather than ``%matplotlib inline`` when running this code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "fig = plt.figure()\n",
    "ax = plt.axes(projection='3d')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Three-dimensional Points and Lines\n",
    "\n",
    "*  The most basic three-dimensional plot is a line or collection of scatter plot created from sets of $(x, y, z)$ triples.\n",
    "* In analogy with the more common two-dimensional plots discussed earlier, these can be created using the ``ax.plot3D`` and ``ax.scatter3D`` functions.\n",
    "* The call signature for these is nearly identical to that of their two-dimensional counterparts.\n",
    "* Here we'll plot a trigonometric spiral, along with some points drawn randomly near the line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = plt.axes(projection='3d')\n",
    "\n",
    "# Data for a three-dimensional line\n",
    "zline = np.linspace(0, 15, 1000)\n",
    "xline = np.sin(zline)\n",
    "yline = np.cos(zline)\n",
    "ax.plot3D(xline, yline, zline, 'gray')\n",
    "\n",
    "# Data for three-dimensional scattered points\n",
    "zdata = 15 * np.random.random(100)\n",
    "xdata = np.sin(zdata) + 0.1 * np.random.randn(100)\n",
    "ydata = np.cos(zdata) + 0.1 * np.random.randn(100)\n",
    "ax.scatter3D(xdata, ydata, zdata, c=zdata, cmap='Greens');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Notice that by default, the scatter points have their transparency adjusted to give a sense of depth on the page.\n",
    "* While the three-dimensional effect is sometimes difficult to see within a static image, an interactive view can lead to some nice intuition about the layout of the points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Three-dimensional Contour Plots\n",
    "\n",
    "* ``mplot3d`` contains tools to create three-dimensional relief plots.\n",
    "* Like two-dimensional ``ax.contour`` plots, ``ax.contour3D`` requires all the input data to be in the form of two-dimensional regular grids, with the Z data evaluated at each point.\n",
    "* Here we'll show a three-dimensional contour diagram of a three-dimensional sinusoidal function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline \n",
    "\n",
    "def f(x, y):\n",
    "    return np.sin(np.sqrt(x ** 2 + y ** 2))\n",
    "\n",
    "x = np.linspace(-6, 6, 30)\n",
    "y = np.linspace(-6, 6, 30)\n",
    "\n",
    "X, Y = np.meshgrid(x, y)\n",
    "Z = f(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.axes(projection='3d')\n",
    "ax.contour3D(X, Y, Z, 50, cmap='binary')\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_zlabel('z');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wireframes and Surface Plots\n",
    "\n",
    "* Two other types of three-dimensional plots that work on gridded data are wireframes and surface plots.\n",
    "* These take a grid of values and project it onto the specified three-dimensional surface, and can make the resulting three-dimensional forms quite easy to visualize.\n",
    "* Here's an example of using a wireframe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = plt.axes(projection='3d')\n",
    "ax.plot_wireframe(X, Y, Z, color='black')\n",
    "ax.set_title('wireframe');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A surface plot is like a wireframe plot, but each face of the wireframe is a filled polygon.\n",
    "* Adding a colormap to the filled polygons can aid perception of the topology of the surface being visualized:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = plt.axes(projection='3d')\n",
    "ax.plot_surface(X, Y, Z, rstride=1, cstride=1,\n",
    "                cmap='viridis', edgecolor='none')\n",
    "ax.set_title('surface');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Note that though the grid of values for a surface plot needs to be two-dimensional, it need not be rectilinear.\n",
    "* Here is an example of creating a partial polar grid, which when used with the ``surface3D`` plot can give us a slice into the function we're visualizing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = np.linspace(0, 6, 20)\n",
    "theta = np.linspace(-0.9 * np.pi, 0.8 * np.pi, 40)\n",
    "r, theta = np.meshgrid(r, theta)\n",
    "\n",
    "X = r * np.sin(theta)\n",
    "Y = r * np.cos(theta)\n",
    "Z = f(X, Y)\n",
    "\n",
    "ax = plt.axes(projection='3d')\n",
    "ax.plot_surface(X, Y, Z, rstride=1, cstride=1,\n",
    "                cmap='viridis', edgecolor='none');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Surface Triangulations\n",
    "\n",
    "* For some applications, the evenly sampled grids required by the above routines is overly restrictive and inconvenient.\n",
    "* In these situations, the triangulation-based plots can be very useful.\n",
    "* What if rather than an even draw from a Cartesian or a polar grid, we instead have a set of random draws?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theta = 2 * np.pi * np.random.random(1000)\n",
    "r = 6 * np.random.random(1000)\n",
    "x = np.ravel(r * np.sin(theta))\n",
    "y = np.ravel(r * np.cos(theta))\n",
    "z = f(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* We could create a scatter plot of the points to get an idea of the surface we're sampling from:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = plt.axes(projection='3d')\n",
    "ax.scatter(x, y, z, c=z, cmap='viridis', linewidth=0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* This leaves a lot to be desired.\n",
    "* The function that will help us in this case is ``ax.plot_trisurf``, which creates a surface by first finding a set of triangles formed between adjacent points (remember that $x$, $y$, and $z$ here are one-dimensional arrays):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = plt.axes(projection='3d')\n",
    "ax.plot_trisurf(x, y, z,\n",
    "                cmap='viridis', edgecolor='none');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The result is certainly not as clean as when it is plotted with a grid, but the flexibility of such a triangulation allows for some really interesting three-dimensional plots.\n",
    "* For example, it is actually possible to plot a three-dimensional Möbius strip using this, as we'll see next."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example: Visualizing a Möbius strip\n",
    "\n",
    "* A Möbius strip is similar to a strip of paper glued into a loop with a half-twist.\n",
    "* Topologically, it's quite interesting because despite appearances it has only a single side!\n",
    "* Here we will visualize such an object using Matplotlib's three-dimensional tools.\n",
    "* The key to creating the Möbius strip is to think about it's parametrization: it's a two-dimensional strip, so we need two intrinsic dimensions. Let's call them $\\theta$, which ranges from $0$ to $2\\pi$ around the loop, and $w$ which ranges from -1 to 1 across the width of the strip:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theta = np.linspace(0, 2 * np.pi, 30)\n",
    "w = np.linspace(-0.25, 0.25, 8)\n",
    "w, theta = np.meshgrid(w, theta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Now from this parametrization, we must determine the $(x, y, z)$ positions of the embedded strip.\n",
    "\n",
    "* Thinking about it, we might realize that there are two rotations happening: one is the position of the loop about its center (what we've called $\\theta$), while the other is the twisting of the strip about its axis (we'll call this $\\phi$). \n",
    "* For a Möbius strip, we must have the strip makes half a twist during a full loop, or $\\Delta\\phi = \\Delta\\theta/2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phi = 0.5 * theta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Now we use our recollection of trigonometry to derive the three-dimensional embedding.\n",
    "* We'll define $r$, the distance of each point from the center, and use this to find the embedded $(x, y, z)$ coordinates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# radius in x-y plane\n",
    "r = 1 + w * np.cos(phi)\n",
    "\n",
    "x = np.ravel(r * np.cos(theta))\n",
    "y = np.ravel(r * np.sin(theta))\n",
    "z = np.ravel(w * np.sin(phi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Finally, to plot the object, we must make sure the triangulation is correct. The best way to do this is to define the triangulation *within the underlying parametrization*, and then let Matplotlib project this triangulation into the three-dimensional space of the Möbius strip.\n",
    "* This can be accomplished as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "# triangulate in the underlying parametrization\n",
    "from matplotlib.tri import Triangulation\n",
    "tri = Triangulation(np.ravel(w), np.ravel(theta))\n",
    "\n",
    "ax = plt.axes(projection='3d')\n",
    "ax.plot_trisurf(x, y, z, triangles=tri.triangles,\n",
    "                cmap='viridis', linewidths=0.2);\n",
    "\n",
    "ax.set_xlim(-1, 1); ax.set_ylim(-1, 1); ax.set_zlim(-1, 1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Combining all of these techniques, it is possible to create and display a wide variety of three-dimensional objects and patterns in Matplotlib."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `numpy`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `linspace`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.linspace.html)\n",
    "\n",
    "\n",
    "* `meshgrid`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.meshgrid.html)\n",
    "\n",
    "\n",
    "* `ravel`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.ravel.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `matplotlib.pyplot`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `plt.style`: [[doc]](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.style.html)\n",
    "\n",
    "\n",
    "* `plt.contour`: [[doc]](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.contour.html)\n",
    "\n",
    "\n",
    "* `plt.contourf`: [[doc]](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.contourf.html)\n",
    "\n",
    "\n",
    "* `plt.imshow`: [[doc]](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.imshow.html)\n",
    "\n",
    "\n",
    "* `plt.cm`: [[doc]](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.cm.html)\n",
    "\n",
    "\n",
    "* `plt.colorbar`: [[doc]](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.colorbar.html)\n",
    "\n",
    "\n",
    "* `plt.clabel`: [[doc]](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.clabel.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Plot the function $f(x, y) = x^2 + y$ as a contour plot.\n",
    "\n",
    "2. Plot the function $f(x, y) = x^2 + y$ as a surface plot.\n",
    "\n",
    "3. In your own words, explain the relationship between broadcasting and the effect of numpy's `meshgrid` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}