GitHub Repository: restrepo/ComputationalMethods
Path: blob/master/material/matplotlib.ipynb
⁹³⁴ views

Kernel: Python 3 (ipykernel)

Matplotlib

Matplotlib is a python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms. matplotlib can be used in python scripts, the python and ipython shell, web application servers, and six graphical user interface toolkits.

Matplotlib tries to make easy things easy and hard things possible. You can generate plots, histograms, power spectra, bar charts, errorcharts, scatterplots, etc, with just a few lines of code. For a sampling, see the screenshots, thumbnail gallery, and examples directory

For simple plotting the pyplot interface provides a MATLAB-like interface, particularly when combined with IPython. For the power user, you have full control of line styles, font properties, axes properties, etc, via an object oriented interface or via a set of functions familiar to MATLAB users.

Official page

:depth: 2

Basic Use

One of the most appealing advantages of Matplotlib is its versatility. You can use it in a very basic way as well as in a very customizable way, allowing a total control of what we want to sketch. We illustrate here some of the basic functions.

In [1]:

#Importing numpy
import numpy as np
#Ignore me!! (for scripts)
%pylab inline
#Importing matplotlib
import matplotlib.pyplot as plt

Out[1]:

Populating the interactive namespace from numpy and matplotlib

In [1]:

%pylab inline

Out[1]:

Populating the interactive namespace from numpy and matplotlib

The line %pylab inline is always necessary when using a IPython notebook. If you are working on the interpreter or with scripts, always use the function plt.show() in order to display the resulting image.

In [6]:

#Ploting a function
x = np.linspace( 0, 2*np.pi, 500 )
y = np.sin( x )
plt.plot( x, y )
#plt.plot( x, y,'.' )

Out[6]:

[<matplotlib.lines.Line2D at 0x7f35a49404e0>]

In [8]:

#Scatter of points
X = np.random.random(200)
Y = np.random.random(200)
plt.plot( X, Y,'ro')

Out[8]:

[<matplotlib.lines.Line2D at 0x7f35a4899400>]

In [9]:

#Multiple plots
#Ploting a function
x = np.linspace( 0, 2*np.pi, 100 )
plt.plot( x, np.sin( x ) )
plt.plot( x, np.cos( x ) )

Out[9]:

[<matplotlib.lines.Line2D at 0x7f35a404c898>]

In [11]:

#Logaritmic axis Y
x = np.linspace( 1, 10, 10 )
plt.semilogy( x, np.exp( x ) )
p=plt.semilogy( x, np.exp( x ),'.' )

Out[11]:

In [12]:

p[0]

Out[12]:

<matplotlib.lines.Line2D at 0x7f359ee7c908>

In [13]:

Out[13]:

array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

In [14]:

np.exp(x)

Out[14]:

array([2.71828183e+00, 7.38905610e+00, 2.00855369e+01, 5.45981500e+01,
       1.48413159e+02, 4.03428793e+02, 1.09663316e+03, 2.98095799e+03,
       8.10308393e+03, 2.20264658e+04])

In [15]:

#Logaritmic axis X
x = np.linspace( 1, 10, 100 )
plt.semilogx( x, np.log( x ) )

Out[15]:

[<matplotlib.lines.Line2D at 0x7f359ec94518>]

In [16]:

#Double Logaritmic axis
x = np.linspace( 0.1, 16.5*np.pi, 200 )
plt.loglog( x, np.sin( x )**2 )
plt.loglog( x, np.sin( x )**2,'.' )

Out[16]:

[<matplotlib.lines.Line2D at 0x7f359ec514a8>]

In [63]:

#Double Logaritmic axis
x = np.logspace( np.log10(0.1), np.log10(16.5*np.pi), 200 )
plt.loglog( x, np.sin( x )**2 )
plt.loglog( x, np.sin( x )**2,'.' )

Out[63]:

[<matplotlib.lines.Line2D at 0x7ffb7c296978>]

In [17]:

#Polar plots
r = np.arange( 0, 3.0, 0.01 )
theta = 2*np.pi*r

plt.subplot(111, polar=True)
plt.plot( theta, r )

Out[17]:

[<matplotlib.lines.Line2D at 0x7f359ef9dda0>]

In [18]:

#Fill between
x = np.arange( 0, 2, 0.1 )
y1 = x/2.
y2 = x**2 + 1
plt.fill_between( x, y1, y2,alpha=0.6 )

Out[18]:

<matplotlib.collections.PolyCollection at 0x7f359ef43b00>

In [19]:

#Multiple figures
X = np.arange( 0, 10, 0.1 )
#First plot
plt.subplot( 1, 2, 1 )
plt.plot( X, X**2+1 )
#Second plot
plt.subplot( 1, 2, 2 )
plt.semilogy( X, np.exp(X-10) )

Out[19]:

[<matplotlib.lines.Line2D at 0x7f359eb243c8>]

In [21]:

#Histograms
X = np.random.random( 500 )
plt.hist( X )

Out[21]:

(array([54., 54., 48., 53., 40., 53., 47., 46., 51., 54.]),
 array([0.0026303 , 0.10221054, 0.20179078, 0.30137101, 0.40095125,
        0.50053148, 0.60011172, 0.69969195, 0.79927219, 0.89885243,
        0.99843266]),
 <BarContainer object of 10 artists>)

Animmations

See: http://louistiao.me/posts/notebooks/embedding-matplotlib-animations-in-jupyter-as-interactive-javascript-widgets/

In [22]:

import matplotlib.pyplot as plt
import matplotlib.animation
import numpy as np

t = np.linspace(0,2*np.pi)
x = np.sin(t)

fig, ax = plt.subplots()
ax.axis([0,2*np.pi,-1,1])
l, = ax.plot([],[])

def animate(i):
    l.set_data(t[:i], x[:i])

#Avoid intial plot
plt.close()
ani = matplotlib.animation.FuncAnimation(fig, animate, frames=len(t))

from IPython.display import HTML
HTML(ani.to_jshtml())

Out[22]:

Easy animmations with video output

In [23]:

#See 
from IPython.display import HTML
from matplotlib import pyplot as plt
from celluloid import Camera

plt.ioff()
fig = plt.figure()
camera = Camera(fig)
for i in range(10):
    plt.plot([i] * 10)
    camera.snap()
plt.close()
animation = camera.animate()
animation.save('animation.mp4')
HTML(animation.to_html5_video())

Out[23]:

The double pendulum problem

(No usar cómo trabajo final)

From https://matplotlib.org/stable/gallery/animation/double_pendulum.html

In [1]:

from numpy import sin, cos
import numpy as np
import matplotlib.pyplot as plt
import scipy.integrate as integrate
import matplotlib.animation as animation
from collections import deque

G = 9.8  # acceleration due to gravity, in m/s^2
L1 = 1.0  # length of pendulum 1 in m
L2 = 1.0  # length of pendulum 2 in m
L = L1 + L2  # maximal length of the combined pendulum
M1 = 1.0  # mass of pendulum 1 in kg
M2 = 1.0  # mass of pendulum 2 in kg
t_stop = 5  # how many seconds to simulate
history_len = 500  # how many trajectory points to display


def derivs(state, t):

    dydx = np.zeros_like(state)
    dydx[0] = state[1]

    delta = state[2] - state[0]
    den1 = (M1+M2) * L1 - M2 * L1 * cos(delta) * cos(delta)
    dydx[1] = ((M2 * L1 * state[1] * state[1] * sin(delta) * cos(delta)
                + M2 * G * sin(state[2]) * cos(delta)
                + M2 * L2 * state[3] * state[3] * sin(delta)
                - (M1+M2) * G * sin(state[0]))
               / den1)

    dydx[2] = state[3]

    den2 = (L2/L1) * den1
    dydx[3] = ((- M2 * L2 * state[3] * state[3] * sin(delta) * cos(delta)
                + (M1+M2) * G * sin(state[0]) * cos(delta)
                - (M1+M2) * L1 * state[1] * state[1] * sin(delta)
                - (M1+M2) * G * sin(state[2]))
               / den2)

    return dydx

# create a time array from 0..t_stop sampled at 0.02 second steps
dt = 0.02
t = np.arange(0, t_stop, dt)

# th1 and th2 are the initial angles (degrees)
# w10 and w20 are the initial angular velocities (degrees per second)
th1 = 120.0
w1 = 0.0
th2 = -10.0
w2 = 0.0

# initial state
state = np.radians([th1, w1, th2, w2])

# integrate your ODE using scipy.integrate.
y = integrate.odeint(derivs, state, t)

x1 = L1*sin(y[:, 0])
y1 = -L1*cos(y[:, 0])

x2 = L2*sin(y[:, 2]) + x1
y2 = -L2*cos(y[:, 2]) + y1

fig = plt.figure(figsize=(5, 4))
ax = fig.add_subplot(autoscale_on=False, xlim=(-L, L), ylim=(-L, 1.))
ax.set_aspect('equal')
ax.grid()

line, = ax.plot([], [], 'o-', lw=2)
trace, = ax.plot([], [], '.-', lw=1, ms=2)
time_template = 'time = %.1fs'
time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)
history_x, history_y = deque(maxlen=history_len), deque(maxlen=history_len)


def animate(i):
    thisx = [0, x1[i], x2[i]]
    thisy = [0, y1[i], y2[i]]

    if i == 0:
        history_x.clear()
        history_y.clear()

    history_x.appendleft(thisx[2])
    history_y.appendleft(thisy[2])

    line.set_data(thisx, thisy)
    trace.set_data(history_x, history_y)
    time_text.set_text(time_template % (i*dt))
    return line, trace, time_text


ani = animation.FuncAnimation(
    fig, animate, len(y), interval=dt*1000, blit=True)
plt.show()

Out[1]:

Formating Figures

Matplotlib supports complex formatting, even allowing LaTeX expressions. These features makes Matplotlib a very appealing package for making professional figures, for example for a scientific paper. Next it is shown an example (script) where you can see some of the capabilities of Matplotlib

In [24]:

#! /usr/bin/python
#====================================================================
#Importing libraries
#====================================================================
import numpy as np
import matplotlib.pyplot as plt

#Arrays
X = np.linspace( 0, 10, 100 )
Y = X**0.5
Y1 = Y+0.5*(1+np.random.random(100))
Y2 = Y-0.5*(1+np.random.random(100))

#Setting the figure environment
plt.figure( figsize = (16,6) )

#====================================================================
#First plot
#====================================================================
plt.subplot( 1, 2, 1 )
plt.plot( X, Y )
plt.title( "This is an unformatted plot" )

#====================================================================
#Second plot
#====================================================================
plt.subplot( 1, 2, 2 )
#2D Plots
plt.plot( X, Y, linewidth=4, color="green", label="Function" )
plt.plot( X, Y1, linewidth=2, color="green" )
plt.plot( X, Y2, linewidth=2, color="green" )
#Error region
plt.fill_between( X, Y1, Y2, color="green", alpha=0.2 )
#Grid
plt.grid( True )
#X-axis limits
plt.xlim( (0, 10) )
#Y-axis limits
plt.ylim( (0, 5) )
#Label
plt.legend( loc="upper left", fontsize=16 )
#X label
plt.xlabel( "$x$ coordinate", fontsize=20 )
#Y label
plt.ylabel( "$\sqrt{x}$", fontsize=20 )
#Title
plt.title( "This is a formatted plot", fontsize=16 )

#====================================================================
#Showing
#====================================================================
#You can store this figure in any format, even in vectorial formats 
#like pdf
plt.savefig( "Figure.pdf" )
#Showing the figure on screen
plt.show()

Out[24]:

Gallery

This gallery comprehends some interesting advanced uses of matplotlib.

In [ ]:

from IPython.core.display import Image 
Image(filename='./figures/voids.png')

In [ ]:

Image(filename='./figures/VPHphase.png')

In [ ]:

Image(filename='./figures/simulation.png')

In [ ]:

Image(filename='./figures/voiddensity.png')

In [ ]:

Image(filename='./figures/halosfraction.png')

The orbit of a point $P$ is defined by the following parametric equation for $-2 \cdot \pi<t<2 \cdot \pi$ . $\left\{\begin{array}{l} x(t)=\cos (t)+\cos \left(\frac{1}{2} \cdot t\right), \\ y(t)=\sin (t)+\sin \left(\frac{1}{2} \cdot t\right) \end{array}\right.$ The point $P$ passes through the $x$ -axis in the origin. It passes through $x$ -axis two more times. Determine the values of $t$ where this happens. Give your answer as a list $[\square, \square]$ .

In [1]:

%pylab inline

Out[1]:

Populating the interactive namespace from numpy and matplotlib

In [2]:

import numpy as np
import pandas as pd

In [3]:

π=np.pi

In [9]:

t=np.linspace(-2*π,2*π,100)

In [28]:

plt.plot(np.cos(t)+np.cos(t/2), np.sin(t)+np.sin(t/2))
plt.grid()
θ=-2*π
plt.plot(np.cos(θ)+np.cos(θ/2), np.sin(θ)+np.sin(θ/2),'bo')
θ=0
plt.plot(np.cos(θ)+np.cos(θ/2), np.sin(θ)+np.sin(θ/2),'ko')
θ=4*π/3
plt.plot(np.cos(θ)+np.cos(θ/2), np.sin(θ)+np.sin(θ/2),'ro')

Out[28]:

[<matplotlib.lines.Line2D at 0x7faf830905e0>]

In [29]:

([2,0],[-1,0])

Out[29]:

([2, 0], [-1, 0])

In [ ]: