The objective of this course is to understand what a numerical method is and what it can be used for. We will study together a variety of numerical methods that are used to solve equations and analyse experimental data. We will approach each topic from a practical perspective, covering for each motivation, method, and application.
The course will make extensive use of Python, specifically, we will learn how to use SciPy, Matplotlib, and Pandas. The course will be driven using iPython Notebooks which you will be able to run and edit locally on your computer (no worries, you are an expert on iPython Notebooks as you will have taken G. Gorman's excellent 'Programming for Geoscientists' class!).
We will have eight sessions, every Monday from 2:00 to 4:45pm. Every lecture we will take a coffee break (we will try to break after 2pm and before 3pm). Each session will blend theory and practice. I will introduce concepts, then we will use python to understand how the methods work and how and when we can apply them. We will complete all the work during class, and there will be only one (!) final assignment.
All course material will be posted online through ESESIS. If you have any questions after class, please contact me by e-mail (apaluszn@imperial.ac.uk). Office hours will be Tuesday morning 10:00 - 11:00am (at RSM 2.48).
Numerical methods are used to analyse numerical data. In many cases, methods are used to find solutions that cannot be computed "analytically" (by using ready-made equations), or to analyse "discrete" data such as the output of a lab experiment or the observations over time of some property. Numerical methods are techniques used to approximate solutions, so they rarely provide an exact solution - but a "good" estimate of the solution. In many cases, it is the only way of obtaining a solution!
In dealing with numerical methods, the main concerns are
Specific numerical methods can be used to interpolate data, compute approximate derivatives, integrate functions, among others. There are special libraries dedicated to implement these "solutions", in Python the library is called SciPy. In this class you will learn
Numerical Methods will be very useful in your career in almost any path you take! May it be when analysing lab data, making sense of observations in the field, or writing complex simulators; chances are you will end up using them on a daily basis.
optimize)optimize, interpolate). General Least Squares Fitting. Fitting functions: polynomial, exponential, non-linear. (leastsq)linalg)integrate) - with Practical 1 and Practical 2We will learn how numerical methods work, and what they are used for. We will use the Python SciPy library to execute implementations of the numerical methods that we discuss (in other words: SciPy is a large collection of programmes that execute numerical methods, like a super-powerful calculator!). We will use the Python library MatPlotLib to plot the data we analyse.
We will use NumPy as an underlying library to define some of the objects we use, such as polynomials (poly1d) and arrays.
From the SciPy Manual: "SciPy is a collection of mathematical algorithms and convenience functions built on the Numpy extension of Python. It adds significant power to the interactive Python session by providing the user with high-level commands and classes for manipulating and visualizing data. With SciPy an interactive Python session becomes a data-processing and system-prototyping environment rivaling sytems such as MATLAB, IDL, Octave, R-Lab, and SciLab." An important source of information on SciPy is the Reference Manual and its Tutorials, see: SciPy Tutorial.
From the MatPlotLib website: "matplotlib is a python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive ". In particular, we will be using PyPlot, a collection of specific commands that make plotting simpler (see PyPlot Tutorial).
In this course, we assume that you already have some basic Python skills (see: How to install Python). However, for most exercises example code will be provided. The two exercise sessions on Week 4 and 8 will be dedicated to practising what we learn about Numerical Methods, and learning how to apply them to analyse data.
In [1]:
%pylab inline
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
SciPy is organised into packages. We will only review the following:
- io
- interpolate
- optimize
- linalgArrays can be used to store data. For example:
In [2]:
a=np.array([100,3,-5,0.15])
print a
In [3]:
b=np.array([40,13,-5,7,9])
print b
In [4]:
plt.plot(a)
plt.ylabel('some numbers')
plt.show()
The command 'plot' can be used to plot data onto the screen. Its documentation can be found here: http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot. In general, plot takes either one argument (data points directly), or two arguments (two arrays of datapoints - such as x,y), and it takes successively parameters that define the colors and symbols to be used in the plot. So, adding 'r' will make the data red, adding 'b' will make it blue, adding '-' will make sure its a line, adding 'o' will make it plot as circles, and so on. And if you want to plot multiple datasets on one plot, you just continue to add information onto the command line.
In [5]:
plt.plot(a, 'ro', b, 'b-')
plt.show()
In [6]:
c=np.arange(10)
print c
In [7]:
d=np.arange(0,10,0.5)
print d
In [8]:
e=np.random.rand(20)
print e
In [9]:
plt.plot(d, e, '-', np.random.randint(0,10,100), np.random.rand(100), 'ro')
plt.ylabel('y')
plt.xlabel('x')
plt.show()
Data and functions can also be respresented using polynomials. A simple way of expressing a polynomial using Python is to use the poly1d class (from Numpy). This class constructs a polynomial of one variable, the poly1d polynomials can be initialised using a list of the polynomial coefficients. The polynomial can then be added, substracted, multiplied, differentiated, integrated, evaluated, etc. using in-built functions. Poly1D objects can even be printed to screen like a polynomial:
Poly1D Documentation can be found here: poly1d
A polynomial can be defined using its coefficients:
In [10]:
p = poly1d([10,-2,3])
print p
In [11]:
q = poly1d([3,4,5],True)
print q
Polynomials can be 'operated', they can be summed, substracted, multiplied with each other.
In [12]:
print p*q
In [13]:
print p+q
In [14]:
print p.deriv()
In [15]:
print p([5])
In [16]:
print p([5,6,7,8,9,10])
In [17]:
p.r
Out[17]:
In [18]:
p.c
Out[18]:
In [19]:
x=np.arange(0,10,0.5)
print x
In [20]:
p(x)
Out[20]:
Furthermore, we can plot our polynomial evaluated over a certain array, using the MatPlotLib library (that we imported earlier on) as:
In [21]:
plt.plot(x, p(x))
plt.ylabel('y')
plt.xlabel('x')
plt.xlim(0,10)
plt.ylim(0,1000)
plt.show()
In [21]: