Matplotlib, NumPy, SciPy 2020

Let's start from scratch with Python 2.7.

1. Install python from http://python.org/download/


2. Run distribute_setup.py script. Then, we'll have easy_install under Scripts directory.


3. Install NeworkX package for build/analyzing graphs

       C:\Python27\Scripts>easy_install networkx
     

   We can check if it's really installed:

      C:\Python27\Scripts>python
      >>> import networkx
      >>>
     

4. Install NumPy
   

       C:\Python27\Scripts>easy_install numpy
     

   We can test your progress:

       >>> import numpy
       >>> print numpy.__version__
     

   Matplotlib requires numpy version 1.1 or later


5. Install ipython
   

       C:\Python27\Scripts>easy_install ipython
     

6. Install Matplotlib
   
   
   1. Go to http://sourceforge.net/projects/matplotlib/files/
   2. Click "Download matplotlib-1.1.0.win32-py2.7.exe (4.2 MB)"

   In my case, since the ease_install for Matplotlib did not work, I directly executed matplotlib-1.1.0.win32-py2.7.exe.

7. Install SciPy
   
   
   1. Go to sourceforge.net

   Again, since the ease_install for SciPy did not work, scipy-0.9.0rc5-win32-superpack-python2.7.exe will be automatically run and install SciPy.

Let's import matplotlib's function-based interface:

import matplotlib.pyplot as pyp
x = [0, 2, 4, 6, 8]
y = [0, 3, 3, 7, 0]
pyp.plot(x, y)
pyp.savefig("MyFirstPlot.png")

The pyplot interface is a function-based interface that uses the Matlab-like conventions. However, it does not include the NumPy functions. So, if we want to use NumPy, it must be imported separately.

Actually, there is a good tutorial for beginners.
http://www.ast.uct.ac.za/~sarblyth/pythonGuide/PythonPlottingBeginnersGuide.pdf

Here is another simple Matplotlib code.

import numpy
import pylab

t = numpy.arange(0.0, 1.0+0.01, 0.01)
s = numpy.cos(numpy.pi*4*t)
pylab.plot(t, s)
 
pylab.xlabel('time (s)')
pylab.ylabel('cos(4t)')
pylab.title('Simple cosine')
pylab.grid(True)
pylab.savefig('simple_cosine')

pylab.show()

The last line of code, pylab.show() pops up 2D plot:

import scipy
import pylab 
import matplotlib.pyplot as plt

x,y = scipy.ogrid[-1.:1.:.01, -1.:1.:.01]
z = x**3-3*x*y**2
pylab.imshow(z, origin='lower', extent=[-1,1,-1,1])
plt.contour(z, origin='lower', extent=[-1,1,-1,1])
pylab.xlabel('x')
pylab.ylabel('y')
pylab.title('Saddle')
pylab.savefig('Saddle')
plt.show()

The following example show the case when x-axis is date string.

import numpy as np
import matplotlib.pyplot as plt
import datetime as DT

data= np.loadtxt('daily_count.csv', delimiter=',', 
         dtype={'names': ('date', 'count'),'formats': ('S10', 'i4')} )

x = [DT.datetime.strptime(key,"%Y-%m-%d") for (key, value) in data ]
y = [value for (key, value) in data]

fig = plt.figure()
ax = fig.add_subplot(111)
ax.grid()

fig.autofmt_xdate()

plt.plot(x,y,'b--o--')
plt.xlabel('Date')
plt.ylabel('Daily Count')
plt.title('Daily Count since February')
plt.show()

The input data is daily_count.csv

The following example show the case when we have several columns of data.

import numpy as np
import matplotlib.pyplot as plt
import datetime as dt
import matplotlib.dates as md

data= np.loadtxt('vmstat_7days_without_header.csv', delimiter=',', 
    dtype={'names': ['time', 'mon','tue','wed','thrs','fri','sat','sun'],
           'formats': ['S8','i4','i4','i4','i4','i4','i4','i4']} )

x,y1,y2,y3,y4,y5,y6,y7 = [],[],[],[],[],[],[],[]

for z in data:
# 10 minute span
	if int((z[0].split(':',2))[1]) % 10 == 0:
		xc = dt.datetime.strptime(z[0],"%H:%M:%S")
		x.append(xc)
		y1.append(z[1])
		y2.append(z[2])
		y3.append(z[3])
		y4.append(z[4])
		y5.append(z[5])
		y6.append(z[6])
		y7.append(z[7])

fig = plt.figure()
ax = fig.add_subplot(111)
xfmt = md.DateFormatter('%H')
ax.xaxis.set_major_formatter(xfmt)
ax.grid()

# slanted x-axis tick label
fig.autofmt_xdate()

p1 = plt.plot(x,y1,'rs')
p2 = plt.plot(x,y2,'gp')
p3 = plt.plot(x,y3,'b*')
p4 = plt.plot(x,y4,'ch')
p5 = plt.plot(x,y5,'mp')
p6 = plt.plot(x,y6,'ys')
p7 = plt.plot(x,y7,'kD')

plt.ylabel("CPU Idle [%]")
plt.xlabel("Time of the day[hr]")

plt.ylim(84.0, 101)

plt.title("CPU Load for 7 days (10min interval), Idling Time, from vmstat command")

#let python select the best position for legend
plt.legend([p1[0],p2[0],p3[0],p4[0],p5[0],p6[0],p7[0]], 
          ['Mon','Tue','Wed','Thu','Fri','Sat','Sun'], 'best', numpoints=1)

plt.show()

The input data used for the above example is vmstat_7days_without_header.csv

Unlike the other examples above, fore this one, I used Python 3.3 just because of my new computer is AMD64. So, I needed new packages:

1. NumPy for 3.3
2. Matplotlib for 3.3
3. mpl_toolkits.basemap for 3.3

The code used is virtually the same one as in the Plotting data on a map.

from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
import numpy as np
# set up orthographic map projection with
# perspective of satellite looking down at 38N, 127E.
# use low resolution coastlines.
map = Basemap(projection='ortho',lat_0=38,lon_0=127,resolution='l')
# draw coastlines, country boundaries, fill continents.
map.drawcoastlines(linewidth=0.25)
map.drawcountries(linewidth=0.25)
map.fillcontinents(color='coral',lake_color='aqua')
# draw the edge of the map projection region (the projection limb)
map.drawmapboundary(fill_color='aqua')
# draw lat/lon grid lines every 15 degrees.
map.drawmeridians(np.arange(0,360,15))
map.drawparallels(np.arange(-90,90,15))
# make up some data on a regular lat/lon grid.
nlats = 73; nlons = 145; delta = 2.*np.pi/(nlons-1)
lats = (0.5*np.pi-delta*np.indices((nlats,nlons))[0,:,:])
lons = (delta*np.indices((nlats,nlons))[1,:,:])
wave = 0.75*(np.sin(2.*lats)**8*np.cos(4.*lons))
mean = 0.5*np.cos(2.*lats)*((np.sin(2.*lats))**2 + 2.)
# compute native map projection coordinates of lat/lon grid.
x, y = map(lons*180./np.pi, lats*180./np.pi)
# contour data over the map.
cs = map.contour(x,y,wave+mean,15,linewidths=1.5)
plt.title('contours with continent background')
plt.show()

This was done as a preliminary step for my small project, "Uniform distribution of points on the surface of a sphere".

I removed axis, and the color display will be used to indicate the density of the points and it's not implemented yet. The calculation was done in C++, and this example was used to just for checking purpose. The points were calculated algebraically, 50(θ) x 50(φ).

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cm

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_aspect("equal")
ax.view_init(elev=0, azim=90)

u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 100)

x = np.outer(np.cos(u), np.sin(v))
y = np.outer(np.sin(u), np.sin(v))
z = np.outer(np.ones(np.size(u)), np.cos(v))

ax.plot_surface(x, y, z,  rstride=2, cstride=2, color='b', alpha = 0.3, linewidth = 0, cmap=cm.jet)

data = np.loadtxt(r'C:\matplotlib_test\sample.csv', delimiter=',',dtype=None)
xx, yy, zz = [], [], []
for d in data:
	xx.append(d[0])
	yy.append(d[1])
	zz.append(d[2])

ax.scatter(xx, yy, zz, color="k", s=1)

plt.axis('off')
plt.show()

We see that the points are certainly not distributed evenly. They are much more dense at the poles. This is because the mapping from spherical to Cartesian coordinates does not preserve area. That is, the spherical space is pinched and compressed at the poles by the mapping.

The followings sampling used random numbers. The incorrect ones used normal random numbers while the correct (at least better) ones reflected the dependency of $\phi$.

In other words, by using CDF (Cumulative Distribution Function),
we get the correct random variable for $\phi = \cos^{-1}(2v-1).$

Sampling points = 5,000 and Matplotlib were used for the plots.

For C++ code, please visit Algorithms: Distributing Points.

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import cm

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_aspect("equal")

# top: elev=90, side: elev=0
ax.view_init(elev=0, azim=0)

u = np.linspace(0, 2 * np.pi, 120)
v = np.linspace(0, np.pi, 60)

x = np.outer(np.cos(u), np.sin(v))
y = np.outer(np.sin(u), np.sin(v))
z = np.outer(np.ones(np.size(u)), np.cos(v))

#ax.plot_surface(x, y, z,  rstride=2, cstride=2, color='b', #alpha = 0.3, linewidth = 0, cmap=cm.jet)
ax.plot_surface(x, y, z,  rstride=1, cstride=1, color='c', alpha = 0.3, linewidth = 0)

data = np.loadtxt(r'C:\TEST2\CDF\first.csv', delimiter=',',dtype=None)

xx, yy, zz = [], [], []
for d in data:
	xx.append(d[0])
	yy.append(d[1])
	zz.append(d[2])

ax.scatter(xx,yy,zz,color="k",s=1)

plt.title('Correctly distributed - Side View')
plt.axis('off')
plt.show()

Here is a sample code of vectors:

import numpy as np
import matplotlib.pyplot as plt
soa =np.array( [ [0,0,1,0], [0,0,1,1],[0,0,0,1], [0,0,-1,1]]) 
X,Y,U,V = zip(*soa)
plt.figure()
ax = plt.gca()
ax.quiver(X,Y,U,V,angles='xy',scale_units='xy',scale=1)
ax.set_xlim([-2,2])
ax.set_ylim([-1,2])
plt.text(1.0, 0.1, r'$\vec a$', fontsize=24, color='red', fontweight='bold')
plt.text(1.1, 1.1, r'$\vec b$', fontsize=24, color='green', fontweight='bold')
plt.text(0.0, 1.1, r'$\vec c$', fontsize=24, color='blue', fontweight='bold')
plt.text(-1.1, 1.1, r'$\vec d$', fontsize=24, color='orange', fontweight='bold')
plt.draw()
plt.show()

Output:

Data Analysis with Open Source Tools by Philipp K. Janert (Nov 25, 2010)

Datasets and codes are available at http://examples.oreilly.com/9780596802363/

Programming Collective Intelligence by Toby Segaran.