Visualization with Matplotlib

Matplotlib is a powerful Python library that provides many functions for graphically displaying data in the form of plots and charts. In this chapter, we will learn the basic functionality.

Getting Started¶

Similar to NumPy, we first need to install Matplotlib. In a Conda environment, this is done with the following command:

conda install -c conda-forge matplotlib

Then we can import Matplotlib – specifically the submodule matplotlib.pyplot – into our program:

The most important command is plt.plot(...). We can type plt.plot? to view its documentation.

In its simplest form, this function expects two vectors with the $x$- and $y$-coordinates of a point cloud. These vectors can be lists or NumPy arrays.

For example, we can plot the sine function as follows:

Here we also see a nice application of element-wise mathematical functions from numpy.

Styling Plots¶

Let’s make our plot a bit more attractive:

Basically, Matplotlib has drawn our point cloud with coordinates from x and y and connected the points with lines. However, there are many ways to customize the appearance of the lines and markers.

The string ‘ro-’ specifies color (r), marker (o), and line style (-).

The help text plt.plot? explains additional line and marker types. Predefined colors are available in the submodule matplotlib.colors. There are various color palettes. The basic colors are:

In addition, there is the Tableau color palette, which is commonly used for charts:

In addition, many CSS colors are also available:

By setting the color parameter in the plot command, a color from one of these palettes can be selected:

Colors can be specified either using short codes ('r', 'g', 'b'), Tableau names ('tab:blue', 'tab:orange', ...), or CSS color names ('firebrick', 'gold', 'navy', ...).

The following table contains a complete list of all predefined colors:

In error analysis, logarithmic axes are often of interest.
Suppose we analyze an iterative algorithm and measure the error $\text{err}_n$ between the exact solution and the computed approximation after $n$ iterations.

A method is said to converge

• Q-linearly, if
  

  $$\text{err}_n \le C\,\text{err}_{n-1}, \qquad C\in(0,1)$$

  (1)

• Q-superlinearly, if
  

  $$\text{err}_n \le \varepsilon_n\,\text{err}_{n-1}$$

  (2)

  with a sequence $\varepsilon_n \searrow 0$

• Q-quadratically, if
  

  $$\text{err}_n \le C\,\text{err}_{n-1}^2, \qquad C>0$$

  (3)

Let us visualize the error progression once in a standard Cartesian coordinate system and once in a coordinate system with a logarithmic $y$-axis:

We observe that a Q-linearly convergent sequence appears as a linear function in a plot with a logarithmic $y$-axis.

Similarly, the $x$-axis can also be scaled logarithmically using plt.semilogx().
However, for the application considered above, this is not very useful.

Bar, Stem, and Pie Charts¶

Let us look at some additional basic plot types. Suppose we have the results of a survey and want to visualize them graphically. Our sample data is:

Instead of the command plt.plot, other plot types can also be used:

• stem – stem plot

• scatter – scatter plot

• bar – bar chart

• pie – pie chart

In the following example, these visualization types are compared:

Plots for Scalar and Vector Fields¶

For the graphical representation of scalar fields $f\colon \mathbb{R}^2 \to \mathbb{R}$ and vector fields $\vec F\colon \mathbb{R}^2 \to \mathbb{R}^2$, Matplotlib provides various functions.

Many visualizations of scalar fields expect three matrices as arguments: one for the $x$-coordinates, one for the $y$-coordinates, and one for the function values $f(x,y)$.

The function numpy.meshgrid is useful here, as it allows us to generate a two-dimensional tensor-product grid from two one-dimensional grids.

Contour Plots:

One possible way to visualize such a scalar field is a contour plot. Here, the curves

are drawn for various values $c_1<c_2<\dots<c_{\text{levels}}$:

Colormap Plots:

Another option is a color plot, where the function value at a point $(x,y)$ is represented using a color scale:

3D Representations of Scalar Fields:

Scalar fields can also be visualized in a three-dimensional coordinate system. Here, the arguments are plotted on the $x$- and $y$-axes, and the function value on the $z$-axis. First, we need to create a 3D coordinate system. We do this by creating a new figure via

fig = plt.figure()

and adding a 3D subplot:

ax = fig.add_subplot(projection='3d')

ax then provides the corresponding plot commands. Here is an example:

Plots for Vector Fields:

Vector fields $\vec F:\mathbb{R}^2\to\mathbb{R}^2$ can be visualized in Matplotlib using quiver plots. In a quiver plot, the function value $\vec F(\vec x)$ is represented by an arrow starting at the point $\vec x$.

Example: The vector field

can be displayed on a regular grid. Optionally, the arrows can be colored according to their length.

Plots for Curves¶

Curves can also be drawn in Matplotlib. A curve is initially a set of points

with a so-called curve parametrization $\vec x\colon[t_a,t_b]\to\mathbb{R}^n$, which is assumed to be regular, i.e., $\dot{\vec x}(t)\ne 0$ for all $t\in [t_a,t_b]$.

Curves in the plane:

For a planar curve ($n=2$), we can use the normal plot command. For example, the cloverleaf curve

can be plotted with:

Curves in space:

Similarly, space curves ($n=3$) can be plotted, but a three-dimensional coordinate system must be created first. We have already seen how to set this up. Here, we plot the helix