Created the pristine form of the repository for Goa workshop.

1 files changed, 0 insertions, 1987 deletions

diff --git a/day2/EngPython.tex b/day2/EngPython.tex
deleted file mode 100755
index b8cfbd2..0000000
--- a/day2/EngPython.tex
+++ /dev/null
@@ -1,1987 +0,0 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Tutorial slides on Python.
-%
-% Author: Prabhu Ramachandran <prabhu at aero.iitb.ac.in>
-% Copyright (c) 2005-2008, Prabhu Ramachandran
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\documentclass[14pt,compress]{beamer}
-%\documentclass[draft]{beamer}
-%\documentclass[compress,handout]{beamer}
-%\usepackage{pgfpages} 
-%\pgfpagesuselayout{2 on 1}[a4paper,border shrink=5mm]
-
-% Modified from: generic-ornate-15min-45min.de.tex
-\mode<presentation>
-{
-  \usetheme{Warsaw}
-  \useoutertheme{split}
-  \setbeamercovered{transparent}
-}
-
-\usepackage[english]{babel}
-\usepackage[latin1]{inputenc}
-%\usepackage{times}
-\usepackage[T1]{fontenc}
-
-% Taken from Fernando's slides.
-\usepackage{ae,aecompl}
-\usepackage{mathpazo,courier,euler}
-\usepackage[scaled=.95]{helvet}
-
-\definecolor{darkgreen}{rgb}{0,0.5,0}
-
-\usepackage{listings}
-\lstset{language=Python,
-    basicstyle=\ttfamily\bfseries,
-    commentstyle=\color{red}\itshape,
-  stringstyle=\color{darkgreen},
-  showstringspaces=false,
-  keywordstyle=\color{blue}\bfseries}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Macros
-\setbeamercolor{emphbar}{bg=blue!20, fg=black}
-\newcommand{\emphbar}[1]
-{\begin{beamercolorbox}[rounded=true]{emphbar} 
-      {#1}
- \end{beamercolorbox}
-}
-\newcounter{time}
-\setcounter{time}{0}
-\newcommand{\inctime}[1]{\addtocounter{time}{#1}{\tiny \thetime\ m}}
-
-\newcommand{\typ}[1]{\texttt{#1}}
-
-\newcommand{\kwrd}[1]{ \texttt{\textbf{\color{blue}{#1}}}  }
-
-%%% This is from Fernando's setup.
-% \usepackage{color}
-% \definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
-% % Use and configure listings package for nicely formatted code
-% \usepackage{listings}
-% \lstset{
-%    language=Python,
-%    basicstyle=\small\ttfamily,
-%    commentstyle=\ttfamily\color{blue},
-%    stringstyle=\ttfamily\color{orange},
-%    showstringspaces=false,
-%    breaklines=true,
-%    postbreak = \space\dots
-% }
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Title page
-\title[Basic Python]{Python,\\a great programming toolkit:\\
-numerics and plotting}
-
-\author[Asokan \& Prabhu] {Asokan Pichai\\Prabhu Ramachandran}
-
-\institute[IIT Bombay] {Department of Aerospace Engineering\\IIT Bombay}
-\date[] {26, July 2009}
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-%\pgfdeclareimage[height=0.75cm]{iitmlogo}{iitmlogo}
-%\logo{\pgfuseimage{iitmlogo}}
-
-
-%% Delete this, if you do not want the table of contents to pop up at
-%% the beginning of each subsection:
-\AtBeginSubsection[]
-{
-  \begin{frame}<beamer>
-    \frametitle{Outline}
-    \tableofcontents[currentsection,currentsubsection]
-  \end{frame}
-}
-
-\AtBeginSection[]
-{
-  \begin{frame}<beamer>
-    \frametitle{Outline}
-    \tableofcontents[currentsection,currentsubsection]
-  \end{frame}
-}
-
-% If you wish to uncover everything in a step-wise fashion, uncomment
-% the following command: 
-%\beamerdefaultoverlayspecification{<+->}
-
-%\includeonlyframes{current,current1,current2,current3,current4,current5,current6}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% DOCUMENT STARTS
-\begin{document}
-
-\begin{frame}
-  \titlepage
-\end{frame}
-\begin{frame}
-  {Acknowledgements}
-  \begin{center}
-  This program is conducted by\\
-  IIT, Bombay\\
-  through CDEEP\\
-  as part of  the open source initiatives\\
-  under the aegis of\\
-  \alert{National Mission on Education through ICT,} \\
-  Ministry of HRD.
-  \end{center}
-\end{frame}
-
-\begin{frame}
-  \frametitle{Outline}
-  \tableofcontents
-  % You might wish to add the option [pausesections]
-\end{frame}
-
-\begin{frame}{Goal of the Workshop}
-
-        At the end of this program, successful participants will be able
-        to use python as their scripting and problem solving language.
-        Aimed at Engg. students--focus on basic numerics and plotting--
-        but should serve a similar purpose for others.\\
-
-        At the minimum you will be able to use Python for your plotting immediately.
-
-\end{frame}
-
-\begin{frame}{Checklist}
-    
-  \begin{description}
-	\item[pylab] matplotlib interface 
-	\item[numpy] Array computing
-        \item[scipy] numerical work
-        \item[mayavi] \typ{enthought.mayavi}: 3D viz.
-  \end{description}
-\end{frame}
-
-\section{30000 feet view}
-\begin{frame}{Lets see what we can do!}
-  \huge
-  Hold on to your seatbelts
-\end{frame}
-
-\begin{frame}
-  {That was done by\ldots}
-  \begin{description}[CalisthenicsIsAnArt]
-      \item[Arrays] 2--3 lines; 5 minutes to learn
-      \item[2D plots] 5 lines; 10 minutes to learn
-      \item[Simple 3D plots] 5 lines; 10 minutes to learn; GUI
-          exploration!
-      \item[Complex plots] relatively short (10-15 lines); more time to master; 
-  \end{description}
-  \inctime{15}
-\end{frame}
-
-\section{Matplotlib}
-
-\subsection{Basic \typ{numpy} }
-
-\newcommand{\num}{\texttt{numpy}}
-
-\begin{frame}
-  \frametitle{The \num\ module}
-  \begin{itemize}
-      \item Why?
-  \item What:
-    \begin{itemize}
-    \item An efficient and powerful array type for various common data
-      types
-    \item Abstracts out the most commonly used standard operations on
-      arrays
-    \end{itemize}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Examples of \num}
-\begin{lstlisting}
-# Simple array math example
->>> from numpy import *
->>> a = array([1,2,3,4])
->>> b = array([2,3,4,5])
->>> a*2 + b + 1 # Basic math!
-array([5, 8, 11, 14])
-# Pi and e are defined.
->>> x = linspace(0.0, 10.0, 1000)
->>> x *= 2*pi/10 # inplace.
-# apply functions to array.
->>> y = sin(x)
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}
-  \frametitle{Basic concepts}
-  \begin{itemize}
-  \item fixed size (\typ{arr.size});
-  \item Same type (\typ{arr.dtype}) of data
-  \item arbitrary dimensionality
-  \item \typ{arr.shape}: size in each dimension
-  \item \alert{Note:} \typ{len(arr) != arr.size} in general
-  \item \alert{Note:} By default array operations are performed
-    \alert{elementwise}
-  \item Indices, slicing: just like lists 
-  \end{itemize}
-\end{frame}
-
-
-\begin{frame}[fragile]
-  \frametitle{More examples of \num}
-\vspace*{-8pt}
-\begin{lstlisting}
->>> x = array([1., 2, 3, 4])
->>> size(x)
-4
->>> x.dtype # What is a.dtype?
-dtype('float64')
->>> x.shape
-(4,)
->>> print rank(x), x.itemsize
-1 8
->>> x[0] = 10
->>> print x[0], x[-1]
-10.0 4.0
-\end{lstlisting}
-    
-\inctime{10}
-\end{frame}
-
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Plotting with \typ{pylab}}
-
-\begin{frame}
-    {IPython's \typ{pylab} mode}
-\begin{itemize}
-    \item \typ{pylab}: convenient 2D plotting interface to MPL
-    \item Immediate use: \typ{ipython -pylab}
-    \item Imports all of pylab for you!
-    \item Allows for interactive plotting
-\end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-    \frametitle{Basic 2D plotting}
-
-\begin{lstlisting}
->>> x = linspace(0, 2*pi, 1000)
->>> plot(x, sin(x)) 
->>> plot(x, sin(x), 'ro')
->>> xlabel(r'$\chi$', color='g')
-# LaTeX markup!
->>> ylabel(r'sin($\chi$)', color='r')
->>> title('Simple figure', fontsize=20)
->>> savefig('/tmp/test.eps')
-\end{lstlisting}
-\begin{itemize}
-  \item Also: PNG, PDF, PS, EPS, SVG, PDF
-\end{itemize}
-\end{frame}
-       
-
-\begin{frame}[fragile]
-  \frametitle{Basic plotting \ldots}
-\begin{lstlisting}
-# Set properties of objects:
->>> l, = plot(x, sin(x))
-# Why "l,"?
->>> setp(l, linewidth=2.0, color='r')
->>> l.set_linewidth(2.0)
->>> draw() # Redraw.
->>> setp(l) # Print properties
->>> clf() # Clear figure.
->>> close() # Close figure.
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-    \frametitle{Multiple figures}
-
-\begin{lstlisting}
->>> figure(1)
->>> plot(x, sin(x))
->>> figure(2)
->>> plot(x, tanh(x))
->>> figure(1)
->>> title('Easy as 1,2,3')
-\end{lstlisting}
-    
-\end{frame}
-
-
-\begin{frame}[fragile]
-  \frametitle{Legends and Annotation}
-\begin{lstlisting}
->>> plot(x, cos(5*x), 'r--', 
-         label='cosine')
->>> plot(x, sin(5*x), 'g--', 
-         label='sine')
->>> legend() 
-# Or use:
->>> legend(['cosine', 'sine'])
-# Annotation:
->>> text(1,0, '(1,0)')
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-    \frametitle{More commands \ldots}
-    \begin{lstlisting}
-# semilog, loglog 
->>> x = 10.**(-arange(100)*0.1)
->>> semilogx(x, x)
->>> semilogy(x, x)
->>> loglog(x, x)
->>> loglog(x, x*x)
-    \end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-    \frametitle{More plots \ldots}
-    \begin{lstlisting}
->>> clf()
->>> t = arange(0.1, 4, 0.1)
->>> s = exp(-t)
->>> e = 0.1*abs(randn(len(s)))
->>> errorbar(t, s, e)
-# Scatter plots
->>> clf()
->>> t = randn(len(e))
->>> scatter(t, e, c=s)
-    \end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-    \frametitle{Note: \typ{pylab} in Python scripts}
-\begin{lstlisting}
-import pylab
-x = pylab.linspace(0, 20, 1000)
-pylab.plot(x, pylab.sin(x))
-
-# Can also use:
-from pylab import linspace, sin, plot
-\end{lstlisting}
-\end{frame}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\begin{frame}[fragile]
-  \frametitle{X-Y plot}
-  \begin{columns}
-    \column{0.5\textwidth}
-    \hspace*{-0.5in}
-    \includegraphics[height=2in, interpolate=true]{data/xyplot}
-    \column{0.45\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-t1 = arange(0.0, 5.0, 0.1)
-t2 = arange(0.0, 5.0, 0.02)
-t3 = arange(0.0, 2.0, 0.01)
-subplot(211)
-plot(t1, cos(2*pi*t1)*exp(-t1), 'bo', 
-     t2, cos(2*pi*t2)*exp(-t2), 'k')
-grid(True)
-title('A tale of 2 subplots')
-ylabel('Damped')
-subplot(212)
-plot(t3, cos(2*pi*t3), 'r--')
-grid(True)
-xlabel('time (s)')
-ylabel('Undamped')
-\end{lstlisting}
-    \end{block}
-  \end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Semi-log and log-log plots}
-  \begin{columns}
-    \column{0.5\textwidth}
-    \hspace*{-0.5in}
-  \includegraphics[height=2in, interpolate=true]{data/log}  
-    \column{0.45\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-dt = 0.01
-t = arange(dt, 20.0, dt)
-subplot(311)
-semilogy(t, exp(-t/5.0))
-ylabel('semilogy')
-grid(True)
-subplot(312)
-semilogx(t, sin(2*pi*t))
-ylabel('semilogx')
-grid(True)
-# minor grid on too
-gca().xaxis.grid(True, which='minor')  
-subplot(313)
-loglog(t, 20*exp(-t/10.0), basex=4)
-grid(True)
-ylabel('loglog base 4 on x')
-\end{lstlisting}
-  \end{block}
-\end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Errorbar}
-  \begin{columns}
-    \column{0.5\textwidth}
-    \hspace*{-0.5in}
-  \includegraphics[height=2in, interpolate=true]{data/errorbar}  
-    \column{0.45\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-t = arange(0.1, 4, 0.1)
-s = exp(-t)
-e = 0.1*abs(randn(len(s)))
-f = 0.1*abs(randn(len(s)))
-g = 2*e
-h = 2*f
-errorbar(t, s, [e,g], f, fmt='o')
-xlabel('Distance (m)')
-ylabel('Height (m)')
-title('Mean and standard error '\
-      'as a function of distance')
-\end{lstlisting}
-  \end{block}
-\end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Histogram}
-  \begin{columns}
-    \column{0.5\textwidth}
-    \hspace*{-0.5in}
-  \includegraphics[height=2in, interpolate=true]{data/histogram}  
-    \column{0.45\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-mu, sigma = 100, 15
-x = mu + sigma*randn(10000)
-# the histogram of the data
-n, bins, patches = hist(x, 100, normed=1)
-# add a 'best fit' line
-y = normpdf( bins, mu, sigma)
-l = plot(bins, y, 'r--', linewidth=2)
-xlim(40, 160)
-xlabel('Smarts')
-ylabel('P')
-title(r'$\rm{IQ:}\/ \mu=100,\/ \sigma=15$')
-\end{lstlisting}
-  \end{block}
-\end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Bar charts}
-  \begin{columns}
-    \column{0.5\textwidth}
-    \hspace*{-0.5in}
-  \includegraphics[height=2in, interpolate=true]{data/barchart}  
-    \column{0.45\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-N = 5
-menMeans = (20, 35, 30, 35, 27)
-menStd =   ( 2,  3,  4,  1,  2)
-# the x locations for the groups
-ind = arange(N) 
-# the width of the bars
-width = 0.35       
-p1 = bar(ind, menMeans, width, 
-         color='r', yerr=menStd)
-womenMeans = (25, 32, 34, 20, 25)
-womenStd =   ( 3,  5,  2,  3,  3)
-p2 = bar(ind+width, womenMeans, width, 
-         color='y', yerr=womenStd)
-ylabel('Scores')
-title('Scores by group and gender')
-xticks(ind+width, 
-       ('G1', 'G2', 'G3', 'G4', 'G5'))
-xlim(-width,len(ind))
-yticks(arange(0,41,10))
-legend((p1[0], p2[0]), 
-       ('Men', 'Women'), shadow=True)
-\end{lstlisting}
-  \end{block}
-\end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Pie charts}
-  \begin{columns}
-    \column{0.5\textwidth}
-    \hspace*{-0.4in}
-  \includegraphics[height=2.0in, interpolate=true]{data/piechart}  
-    \column{0.45\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-# make a square figure and axes
-figure(1, figsize=(8,8))
-ax = axes([0.1, 0.1, 0.8, 0.8])
-labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
-fracs = [15,30,45, 10]
-explode=(0, 0.05, 0, 0)
-pie(fracs, explode=explode, labels=labels, 
-    autopct='%1.1f%%', shadow=True)
-title('Raining Hogs and Dogs', 
-      bbox={'facecolor':'0.8', 'pad':5})
-\end{lstlisting}
-  \end{block}
-\end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Scatter plots}
-  \begin{columns}
-    \column{0.5\textwidth}
-    \hspace*{-0.4in}
-  \includegraphics[height=2in, interpolate=true]{data/scatter}  
-    \column{0.45\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-N = 30
-x = 0.9*rand(N)
-y = 0.9*rand(N)
-# 0 to 10 point radiuses
-area = pi*(10 * rand(N))**2 
-volume = 400 + rand(N)*450
-scatter(x,y,s=area, marker='o', c=volume, 
-        alpha=0.75)
-xlabel(r'$\Delta_i$', size='x-large')
-ylabel(r'$\Delta_{i+1}$', size='x-large')
-title(r'Volume and percent change')
-grid(True)
-colorbar()
-savefig('scatter')
-\end{lstlisting}
-  \end{block}
-\end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Polar}
-  \begin{columns}
-    \column{0.5\textwidth}
-    \hspace*{-0.5in}
-  \includegraphics[height=2in, interpolate=true]{data/polar}  
-    \column{0.45\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-figure(figsize=(8,8))
-ax = axes([0.1, 0.1, 0.8, 0.8], 
-          polar=True, 
-          axisbg='#d5de9c')
-r = arange(0,1,0.001)
-theta = 2*2*pi*r
-polar(theta, r, color='#ee8d18', lw=3)
-# the radius of the grid labels
-setp(ax.thetagridlabels, y=1.075) 
-title(r"$\theta=4\pi r", fontsize=20)
-\end{lstlisting}
-  \end{block}
-\end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Contours}
-  \begin{columns}
-    \column{0.45\textwidth}
-    \hspace*{-0.5in}
-  \includegraphics[height=2in, interpolate=true]{data/contour}  
-    \column{0.525\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-x = arange(-3.0, 3.0, 0.025)
-y = arange(-2.0, 2.0, 0.025)
-X, Y = meshgrid(x, y)
-Z1 = bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)
-Z2 = bivariate_normal(X, Y, 1.5, 0.5, 1, 1)
-# difference of Gaussians
-Z = 10.0 * (Z2 - Z1)
-im = imshow(Z, interpolation='bilinear', 
-            origin='lower',
-            cmap=cm.gray, extent=(-3,3,-2,2))
-levels = arange(-1.2, 1.6, 0.2)
-# label every second level
-clabel(CS, levels[1::2],  inline=1,
-       fmt='%1.1f', fontsize=14)
-CS = contour(Z, levels,
-             origin='lower',
-             linewidths=2,
-             extent=(-3,3,-2,2))
-# make a colorbar for the contour lines
-CB = colorbar(CS, shrink=0.8, extend='both')
-title('Lines with colorbar')
-hot(); flag()
-\end{lstlisting}
-  \end{block}
-\end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Velocity vectors}
-  \begin{columns}
-    \column{0.5\textwidth}
-    \hspace*{-0.5in}
-  \includegraphics[height=2in, interpolate=true]{data/quiver}  
-    \column{0.45\textwidth}
-    \begin{block}{Example code}
-    \tiny
-\begin{lstlisting}
-X,Y = meshgrid(arange(0,2*pi,.2),
-               arange(0,2*pi,.2) )
-U = cos(X)
-V = sin(Y)
-Q = quiver(X[::3, ::3], Y[::3, ::3], 
-           U[::3, ::3], V[::3, ::3],
-           color='r', units='x', 
-           linewidths=(2,), 
-           edgecolors=('k'), 
-           headaxislength=5 )
-qk = quiverkey(Q, 0.5, 0.03, 1, '1 m/s', 
-               fontproperties=
-               {'weight': 'bold'})
-axis([-1, 7, -1, 7])
-title('triangular head; scale '\
-      'with x view; black edges')
-\end{lstlisting}
-  \end{block}
-\end{columns}
-\end{frame}
-
-\begin{frame}[fragile] \frametitle{Maps}
-  \includegraphics[height=2.5in, interpolate=true]{data/plotmap}  
-  \begin{center}
-    \tiny
-    For details see \url{http://matplotlib.sourceforge.net/screenshots/plotmap.py}
-  \end{center}
-\end{frame}
-
-
-\begin{frame}
-  \frametitle{More information}
-  \begin{itemize}
-  \item More information here: \url{http://matplotlib.sf.net}
-  \item \url{http://matplotlib.sf.net/tutorial.html}
-  \item \url{http://matplotlib.sf.net/screenshots.html}
-  \end{itemize}
-
-  \inctime{25}
-\end{frame}
-
-\begin{frame}
-  \frametitle{Problem set 1.0}
-  \begin{enumerate}
-      \item Write a function that plots any n-gon given \typ{n}.
-      \item Consider the logistic map, $f(x) = kx(1-x)$, plot it for
-          $k=2.5, 3.5$ and $4$
-\end{enumerate}
-\end{frame}
-
-\begin{frame}
-  \frametitle{Problem set 1.1}
-  \begin{enumerate}
-      \item Consider the iteration $x_{n+1} = f(x_n)$ where $f(x) =
-          kx(1-x)$.  Plot the successive iterates of this process.
-      \item Plot this using a cobweb plot as follows:
-          \begin{enumerate}
-              \item Start at $(x_0, 0)$
-              \item Draw line to $(x_i, f(x_i))$; 
-              \item Set $x_{i+1} = f(x_i)$
-              \item Draw line to $(x_i, x_i)$
-              \item Repeat from 2 for as long as you want 
-          \end{enumerate}
-    \end{enumerate}
-\end{frame}
-
-\begin{frame}
-  \frametitle{Problem set 1.2}
-  \begin{enumerate}
-
-      \item Plot the Koch snowflake.  Write a function to generate the
-          necessary points given the two points constituting a line.
-          \pause
-          \begin{enumerate}
-              \item Split the line into 4 segments.
-              \item The first and last segments are trivial.
-              \item To rotate the point you can use complex numbers,
-                  recall that $z e^{j \theta}$ rotates a point $z$ in 2D
-                  by $\theta$.
-              \item Do this for all line segments till everything is
-                  done.
-          \end{enumerate}
-      \item Show rate of convergence for a first and second order finite
-          difference of sin(x)
-\end{enumerate}
-\inctime{30}
-\end{frame}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-\begin{frame}[fragile]
-  \frametitle{More IPython features}
-  \begin{itemize}
-  \item Input and output caching:
-    \begin{itemize}
-    \item \verb+In+: a list of all entered input
-    \item \verb+Out+: a dict of all output
-    \item \verb+%hist [-n]+ macro shows previous history, \verb+-n+
-      suppresses line number information
-    \end{itemize}
-  \item Log the session using \verb+%logstart+, \verb+%logon+ and
-    \verb+%logoff+
-  \item Use \verb+;+ to suppress printing output
-  \item \verb+%time statement+
-  \item \verb+%timeit [-n<N> -r<R> [-t|-c]] statement+
-
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{More IPython features}
-  \begin{itemize}
-  \item \verb+%run [options] file[.py]+ -- running Python code
-  \item \verb+%prun+ runs a statement/expression under the profiler
-  \item \verb+%debug+: Helps with debugging after a crash
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{More IPython features \ldots}
-  \begin{itemize}
-  \item \verb+%edit [options] [args]+: edit lines of code or file
-    specified in editor (configure editor via \verb+$EDITOR+)
-  \item \verb+%cd+ changes directory, see also \verb+%pushd, %popd, %dhist+
-  \item Shell access
-    \begin{itemize}
-    \item \verb+!command+ runs a shell command and returns its output
-    \item \verb+files = !ls+ sets
-      \verb+files+ to all result of the \verb+ls+ command
-    \item \verb+!ls $files+ passes the \verb+files+ variable to the
-      shell command
-  \end{itemize}
-    \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{More IPython features \ldots}
-  \begin{itemize}
-  \item \verb+%bookmark+: store a bookmarked location, for use with \verb+%cd+
-  \item \verb+%save [options] filename n1-n2 n3-n4+: save lines to a
-    file
-  \item Can define and use profiles to setup IPython differently:
-    \verb+math, scipy, numeric, pysh+ etc.
-  \item \verb+%magic+: \alert{Show help on all magics}
-  \item Check out the \verb+%macro+ magic
-  \end{itemize}
-\end{frame}
-
-\begin{frame}
-  \frametitle{Problem set 2}
-  \begin{itemize}
-    \item Compare your linspace with that of numpy for 1 million
-        elements in terms of speed.
-\end{itemize}
-\inctime{10}
-\end{frame}
-
-
-\begin{frame}[fragile]
-    \frametitle{Debugging effectively}
-
-    \begin{itemize}
-        \item  \kwrd{print} based strategy
-        \item Process: Hypothesis, test, refine, rinse-repeat
-        \item Using \typ{\%debug} and \typ{\%pdb} in IPython
-    \end{itemize}
-
-    \inctime{10} 
-\end{frame}
-
-\section{Debugging and testing}
-
-\begin{frame}[fragile]
-    \frametitle{Testing code with \typ{nosetests}}
-   
-    \begin{itemize}
-        \item Writing tests is really simple!
-
-        \item Using nose
-
-        \item Example!
-    \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-    \frametitle{Nosetest}
-\begin{lstlisting}
-def gcd(a, b):
-    """Returns gcd of a and b, 
-     handles only positive numbers."""
-    if a%b == 0: return b
-    return gcd(b, a%b)
-def lcm(a, b):
-    return a*b/gcd(a, b)
-
-if __name__ == '__main__':
-    import nose
-    nose.main()
-\end{lstlisting}
-
-    \inctime{10} 
-\end{frame}
-
-\section{NumPy and SciPy}
-
-\begin{frame}
-    {More Numpy}
-
-    \begin{itemize}
-        \item Multi-dimensional arrays
-        \item Random number generation
-    \end{itemize}
-
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Multi-dimensional arrays}
-\begin{lstlisting}
->>> a = array([[ 0, 1, 2, 3],
-...            [10,11,12,13]])
->>> a.shape # (rows, columns)
-(2, 4)
-# Accessing and setting values
->>> a[1,3] 
-13
->>> a[1,3] = -1
->>> a[1] # The second row
-array([10,11,12,-1])
-
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Slicing arrays}
-\begin{lstlisting}
->>> a = array([[1,2,3], [4,5,6], 
-               [7,8,9]])
->>> a[0,1:3]
-array([2, 3])
->>> a[1:,1:]
-array([[5, 6],
-       [8, 9]])
->>> a[:,2]
-array([3, 6, 9])
-\end{lstlisting}
-\end{frame}
-\begin{frame}[fragile]
-  \frametitle{Striding arrays}
-\begin{lstlisting}
->>> a[0::2,0::2]
-array([[1, 3],
-       [7, 9]])
-# Slices are references to the 
-# same memory!
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Array creation functions}
-  \begin{itemize}
-  \item \typ{array(object, dtype=None, \ldots)}
-  \item \typ{arange(start, stop=None, step=1 \ldots)}
-  \item \typ{linspace(start, stop, num=50, \ldots)}
-  \item \typ{ones(shape, dtype=None, \ldots)}
-  \item \typ{zeros(shape, dtype=float,\ldots)}
-  \item \typ{identity(n)}
-  \item \typ{empty(shape, dtype=float,\ldots)}
-  \item \typ{ones\_like(x)}, 
-  \item \typ{zeros\_like(x)}, \typ{empty\_like(x)}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Array math}
-  \begin{itemize}
-  \item Basic \alert{elementwise} math (given two arrays \typ{a, b}):
-      \typ{+, -, *, /, \%}
-  \item Inplace operators: \typ{a += b}, or \typ{add(a, b,
-      a)} etc.
-  \item Logical operations: \typ{equal (==)}, \typ{not\_equal (!=)},
-    \typ{less (<)}, \typ{greater (>)} etc.
-  \item Trig and other functions: \typ{sin(x), arcsin(x), sinh(x),
-      exp(x), sqrt(x)} etc.
-  \item \typ{sum(x, axis=0), product(x, axis=0)} 
-  \item \typ{dot(a, b)}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Advanced}
-  \begin{itemize}
-  \item Only scratched the surface of \num
-  \item Ufunc methods: \typ{reduce, accumulate, outer, reduceat}
-  \item Typecasting
-  \item More functions: \typ{take, choose, where, compress,
-      concatenate}
-  \item Array broadcasting and \typ{None}
-  \end{itemize}
-  \inctime{15}
-\end{frame}
-
-\begin{frame}
-    {Intro to SciPy}
-  \begin{itemize}
-  \item \url{http://www.scipy.org}
-  \item Open source scientific libraries for Python
-  \item Based on NumPy
-    \end{itemize}
-
-    \inctime{25}
-\end{frame}
-
-\begin{frame}
-  \frametitle{SciPy}
-  \begin{itemize}
-  \item Provides:
-    \begin{itemize}
-    \item Linear algebra
-    \item Numerical integration
-    \item Fourier transforms
-    \item Signal processing
-    \item Special functions
-    \item Statistics
-    \item Optimization
-    \item Image processing
-    \item ODE solvers
-    \end{itemize}
-  \item Uses LAPACK, QUADPACK, ODEPACK, FFTPACK etc. from netlib
-  \end{itemize}
-\end{frame}
-
-
-\section{3D Plotting}
-
-\begin{frame}
-  \frametitle{Introduction to Mayavi}
-  \begin{itemize}
-  \item Most scientists not interested in details of visualization
-  \item Visualization of data files with a nice UI
-  \item Interactive visualization of data (think Matlab)
-  \item Embedding visualizations in applications
-  \item Customization
-  \end{itemize}
-  \pause
-  \begin{block}{The Goal}
-      Provide a \alert{flexible} library/app for every one of these needs!
-  \end{block}
-\end{frame}
-
-\begin{frame}[fragile]
-    \frametitle{\typ{mlab}}
-  \begin{columns}
-    \column{0.62\textwidth}
-    \hspace*{-0.45in}
-      \footnotesize
-\begin{lstlisting}
-from enthought.mayavi import mlab
-from numpy import ogrid, sin
-
-x, y, z = ogrid[-10:10:100j, 
-                -10:10:100j, 
-                -10:10:100j]
-
-mlab.contour3d(sin(x*y*z)/(x*y*z))
-mlab.show()
-\end{lstlisting}
-    \column{0.4\textwidth}
-    \hspace*{-0.1\linewidth}
-    \includegraphics[width=1.18\linewidth]{data/mlab.png}
-  \end{columns}
-\end{frame}
-
-\begin{frame}
-    {A Look at the docs }
-
-    \inctime{20}
-\end{frame}
-
-
-\section{Integration demo: Lorenz equations}
-
-\begin{frame}
-    \frametitle{Lorenz equation example}
-    \begin{eqnarray*}
-        \frac{d x}{dt} &=& s (y-x)\\
-        \frac{d y}{d t} &=& rx -y -xz\\
-        \frac{d z}{d t} &=& xy - bz\\
-    \end{eqnarray*}
-    \begin{itemize}
-        \item Specifies the evolution of the system
-        \item Think: Velocity of a particle in 3D
-        \item Lets trace its path
-    \end{itemize}
-\end{frame}
-
-\begin{frame}
-    {Interactive exploration}
-
-    \inctime{25}
-\end{frame}
-
-
-\end{document}
-
-- Numpy arrays (30 mins)
-    - Matrices
-    - random number generation.
-    - Image manipulation: jigsaw puzzle.
-    - Monte-carlo integration.
-
-
-
-
-
-\begin{frame}[fragile]
-  \frametitle{More on functions}
-  \begin{itemize}
-  \item Support default and keyword arguments
-  \item Scope of variables in the function is local
-  \item Mutable items are \alert{passed by reference}
-  \item First line after definition may be a documentation string
-    (\alert{recommended!})
-  \item Function definition and execution defines a name bound to the
-    function
-  \item You \emph{can} assign a variable to a function!
-  \end{itemize}
-\end{frame}
-
-
-\begin{frame}[fragile]
-  \frametitle{Functions: default arguments}
-  \begin{lstlisting}
-def ask_ok(prompt, retries=4, complaint='Yes or no!'):
-    while True:
-        ok = raw_input(prompt)
-        if ok in ('y', 'ye', 'yes'): 
-            return True
-        if ok in ('n', 'no', 'nop', 'nope'): 
-            return False
-        retries = retries - 1
-        if retries < 0: 
-            raise IOError, 'bad user'
-        print complaint
-  \end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Functions: keyword arguments}
-  \begin{lstlisting}
-def parrot(voltage, state='a stiff', 
-           action='voom', type='Norwegian Blue'):
-    print "-- This parrot wouldn't", action,
-    print "if you put", voltage, "Volts through it."
-    print "-- Lovely plumage, the", type
-    print "-- It's", state, "!"
-
-parrot(1000)
-parrot(action = 'VOOOOOM', voltage = 1000000)
-parrot('a thousand', state = 'pushing up the daisies')
-parrot('a million', 'bereft of life', 'jump')
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Functions: arbitrary argument lists}
-  \begin{itemize}
-  \item Arbitrary number of arguments using \verb+*args+ or
-    \verb+*whatever+
-  \item Keyword arguments using \verb+**kw+
-  \item Given a tuple/dict how do you call a function?
-    \begin{itemize}
-    \item Using argument unpacking
-    \item For positional arguments: \verb+foo(*[5, 10])+
-    \item For keyword args: \verb+foo(**{'a':5, 'b':10})+
-    \end{itemize}
-  \end{itemize}
-\begin{lstlisting}
-def foo(a=10, b=100):
-    print a, b
-def func(*args, **keyword):
-    print args, keyword
-# Unpacking:
-args = [5, 10]
-foo(*args)
-kw = {'a':5, 'b':10}
-foo(**kw)
-\end{lstlisting}
-\end{frame}
-
-\subsection{Modules, exceptions, classes}
-
-\begin{frame}
-  \frametitle{Modules}
-  \begin{itemize}
-  \item Define variables, functions and classes in a file with a
-    \typ{.py} extension
-  \item This file becomes a module!
-  \item Modules are searched in the following:
-    \begin{itemize}
-    \item Current directory
-    \item Standard: \typ{/usr/lib/python2.3/site-packages/} etc.
-    \item Directories specified in PYTHONPATH
-    \item \typ{sys.path}: current path settings (from the \typ{sys}
-      module)
-    \end{itemize}
-  \item The \typ{import} keyword ``loads'' a module
-  \item One can also use:
-    \mbox{\typ{from module import name1, name2, name2}}\\
-    where \typ{name1} etc. are names in the module, ``module''
-  \item \typ{from module import *} \ --- imports everything from module,
-    \alert{use only in interactive mode}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Modules: example}
-  \begin{lstlisting}
-# --- foo.py ---
-some_var = 1
-def fib(n): # write Fibonacci series up to n
-    """Print a Fibonacci series up to n."""
-    a, b = 0, 1
-    while b < n:
-        print b,
-        a, b = b, a+b
-# EOF
-
->>> import foo
->>> foo.fib(10)
-1 1 2 3 5 8 
->>> foo.some_var
-1
-  \end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Namespaces}
-  \begin{itemize}
-  \item A mapping from names to objects
-  \item Modules introduce a namespace 
-  \item So do classes
-  \item The running script's namespace is \verb+__main__+
-  \item A modules namespace is identified by its name
-  \item The standard functions (like \typ{len}) are in the
-    \verb+__builtin__+ namespace
-  \item Namespaces help organize different names and their bindings to
-    different objects
-  \end{itemize}
-\end{frame}
-
-\begin{frame}
-  \frametitle{Exceptions}
-  \begin{itemize}
-  \item Python's way of notifying you of errors
-  \item Several standard exceptions: \typ{SyntaxError}, \typ{IOError}
-    etc.
-  \item Users can also \typ{raise} errors
-  \item Users can create their own exceptions
-  \item Exceptions can be ``caught'' via \typ{try/except} blocks
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Exception: examples}
-\begin{lstlisting}
->>> 10 * (1/0)
-Traceback (most recent call last):
-  File "<stdin>", line 1, in ?
-ZeroDivisionError: integer division or modulo by zero
->>> 4 + spam*3
-Traceback (most recent call last):
-  File "<stdin>", line 1, in ?
-NameError: name 'spam' is not defined
->>> '2' + 2
-Traceback (most recent call last):
-  File "<stdin>", line 1, in ?
-TypeError: cannot concatenate 'str' and 'int' objects
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Exception: examples}
-\begin{lstlisting}
->>> while True:
-...     try:
-...         x = int(raw_input("Enter a number: "))
-...         break
-...     except ValueError:
-...         print "Invalid number, try again..."
-...
->>> # To raise exceptions
-... raise ValueError, "your error message"
-Traceback (most recent call last):
-  File "<stdin>", line 2, in ?
-ValueError: your error message
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Classes: the big picture}
-  \begin{itemize}
-  \item Lets you create new data types
-  \item Class is a template for an object belonging to that class
-  \item Note: in Python a class is also an object
-  \item Instantiating a class creates an instance (an object)
-  \item An instance encapsulates the state (data) and behavior
-    (methods)
-  \item Allows you to define an inheritance hierarchy
-    \begin{itemize}
-    \item ``A Honda car \alert{is a} car.''
-    \item ``A car \alert{is an} automobile.''
-    \item ``A Python \alert{is a} reptile.''
-    \end{itemize}
-  \item Programmers need to think OO
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Classes: what's the big deal?}
-  \begin{itemize}
-  \item Lets you create objects that mimic a real problem being
-    simulated
-  \item Makes problem solving more natural and elegant
-  \item Easier to create code
-  \item Allows for code-reuse
-  \item Polymorphism
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Class definition and instantiation}
-  \begin{itemize}
-  \item Class definitions when executed create class objects
-  \item Instantiating the class object creates an instance of the
-    class
-  \end{itemize}
-\footnotesize
-\begin{lstlisting}
-class Foo(object):
-    pass
-# class object created.
-# Create an instance of Foo.
-f = Foo()
-# Can assign an attribute to the instance
-f.a = 100
-print f.a
-100
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Classes \ldots}
-  \begin{itemize}
-  \item All attributes are accessed via the \typ{object.attribute}
-    syntax
-  \item Both class and instance attributes are supported
-  \item \emph{Methods} represent the behavior of an object: crudely
-    think of them as functions ``belonging'' to the object
-  \item All methods in Python are ``virtual''
-  \item Inheritance through subclassing
-  \item Multiple inheritance is supported
-  \item No special public and private attributes: only good
-    conventions
-    \begin{itemize}
-    \item \verb+object.public()+: public
-    \item \verb+object._private()+ \& \verb+object.__priv()+: 
-      non-public
-    \end{itemize}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Classes: examples}
-\begin{lstlisting}
-class MyClass(object):
-    """Example class (this is the class docstring)."""
-    i = 12345 # A class attribute
-    def f(self):
-        """This is the method docstring"""
-        return 'hello world'
-
->>> a = MyClass() # creates an instance
->>> a.f()
-'hello world'
->>> # a.f() is equivalent to MyClass.f(a)
-... # This also explains why f has a 'self' argument.
-... MyClass.f(a)
-'hello world'
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Classes (continued)}
-  \begin{itemize}
-  \item \typ{self} is \alert{conventionally} the first argument for a
-    method
-  \item In previous example, \typ{a.f} is a method object
-  \item When \typ{a.f} is called, it is passed the instance \typ{a} as
-    the first argument
-  \item If a method called \verb+__init__+ exists, it is called when
-    the object is created
-  \item If a method called \verb+__del__+ exists, it is called before
-    the object is garbage collected
-  \item Instance attributes are set by simply ``setting'' them in
-    \typ{self}
-  \item Other special methods (by convention) like \verb+__add__+ let
-    you define numeric types:
-    {\footnotesize \url{http://docs.python.org/ref/specialnames.html}
-      \\ \url{http://docs.python.org/ref/numeric-types.html}
-    }
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Classes: examples}
-\begin{lstlisting}
-class Bag(MyClass): # Shows how to derive classes
-    def __init__(self): # called on object creation.
-        self.data = [] # an instance attribute
-    def add(self, x):
-        self.data.append(x)
-    def addtwice(self, x):
-        self.add(x)
-        self.add(x)
->>> a = Bag()
->>> a.f() # Inherited method
-'hello world'
->>> a.add(1); a.addtwice(2)
->>> a.data
-[1, 2, 2]
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Derived classes}
-  \begin{itemize}
-  \item Call the parent's \verb+__init__+ if needed
-  \item If you don't need a new constructor, no need to define it in subclass
-  \item Can also use the \verb+super+ built-in function
-  \end{itemize}
-\begin{lstlisting}
-class AnotherBag(Bag):
-    def __init__(self):
-        # Must call parent's __init__ explicitly
-        Bag.__init__(self)
-        # Alternatively use this:
-        super(AnotherBag, self).__init__()
-        # Now setup any more data.
-        self.more_data = []
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Classes: polymorphism}
-\begin{lstlisting}
-class Drawable(object):
-    def draw(self):
-        # Just a specification.
-        pass
-\end{lstlisting}
-\mode<presentation>{\pause}
-\begin{lstlisting}
-class Square(Drawable):
-    def draw(self):
-        # draw a square.
-class Circle(Drawable):
-    def draw(self):
-        # draw a circle.
-\end{lstlisting}
-\mode<presentation>{\pause}
-\begin{lstlisting}
-class Artist(Drawable):
-    def draw(self):
-        for obj in self.drawables:
-            obj.draw()
-\end{lstlisting}
-\end{frame}
-
-\subsection{Miscellaneous}
-
-\begin{frame}[fragile]
-  \frametitle{Stand-alone scripts}
-Consider a file \typ{f.py}:
-\begin{lstlisting}
-#!/usr/bin/env python
-"""Module level documentation."""
-# First line tells the shell that it should use Python
-# to interpret the code in the file.
-def f():
-    print "f"
-
-# Check if we are running standalone or as module.
-# When imported, __name__ will not be '__main__'
-if __name__ == '__main__':
-    # This is not executed when f.py is imported.
-    f() 
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{List comprehensions}
-\begin{lstlisting}
->>> veg = ['tomato', 'cabbage', 'carrot', 'potato']
->>> [x.upper() for x in veg]
-['TOMATO', 'CABBAGE', 'CARROT', 'POTATO']
->>> vec = range(0, 8)
->>> even = [x for x in vec if x%2 == 0]
->>> even
-[0, 2, 4, 6]
->>> [x*x for x in even]
-[0, 4, 16, 36]
->>> odd = [x for x in vec if x%2 == 1]
->>> odd
-[1, 3, 5, 7]
->>> [x*y for x in even for y in odd]
-[0, 0, 0, 0, 2, 6, 10, 14, 4, 12, 20, 28, 6, 18,30,42]
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{File handling}
-\begin{lstlisting}
->>> # Reading files:
-... f = open('/path/to/file_name')
->>> data = f.read() # Read entire file.
->>> line = f.readline() # Read one line.
->>> # Read entire file appending each line into a list
-... lines = f.readlines()
->>> f.close() # close the file.
->>> # Writing files:
-... f = open('/path/to/file_name', 'w')
->>> f.write('hello world\n')
-\end{lstlisting}
-  \begin{itemize}
-  \item \typ{tell()}: returns int of current position
-  \item \typ{seek(pos)}: moves current position to specified byte
-  \item Call \typ{close()} when done using a file
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Math}
-  \begin{itemize}
-  \item \typ{math} module provides basic math routines for
-    floats
-  \item \typ{cmath} module provides math routies for complex
-    numbers
-  \item \typ{random}: provides pseudo-random number generators
-    for various distributions
-  \item These are always available and part of the standard library
-  \item More serious math is provided by the NumPy/SciPy modules --
-    these are not standard and need to be installed separately
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Timing and profiling}
-  \begin{itemize}
-  \item Timing code: use the \typ{time} module
-  \item Read up on \typ{time.time()} and \typ{time.clock()}
-  \item \typ{timeit}: is a better way of doing timing
-  \item IPython has handy \typ{time} and \typ{timeit} macros (type
-    \typ{timeit?} for help)
-  \item IPython lets you debug and profile code via the \typ{run}
-    macro (type \typ{run?} on the prompt to learn more)
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Odds and ends}
-  \begin{itemize}
-  \item \typ{dir([object])} function: attributes of given object
-  \item \typ{type(object)}: returns type information
-  \item \typ{str(), repr()}: convert object to string representation
-  \item \typ{isinstance, issubclass}
-  \item \typ{assert} statements let you do debugging assertions in
-    code
-  \item \typ{csv} module: reading and writing CSV files
-  \item \typ{pickle}: lets you save and load Python objects
-    (\alert{serialization})
-  \item \typ{sys.argv}: command line arguments
-  \item \typ{os.path}: common path manipulations
-  \item Check out the Python Library reference:
-    \url{http://docs.python.org/lib/lib.html}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Test driven development (TDD)}
-  \begin{itemize}
-      \item Why?
-          \begin{itemize}
-
-            \item Forces you to write reusable code!
-
-            \item Think about the API
-
-            \item More robust
-
-            \item Makes refactoring very easy
-
-          \end{itemize}
-      \item How?  Python offers three major ways of doing this
-          \begin{itemize}
-              \item doctest
-              \item unittest
-              \item nosetest (and similar like py.test)
-          \end{itemize}
-
-      \item Test every piece of functionality you offer
-
-      \item This isn't a formal introduction but more a practical one
-
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Unit test}
-\begin{lstlisting}
-import unittest
-
-class MyTestCase(unittest.TestCase):
-    def setUp(self):
-        # Called *before* each test_* 
-    def tearDown(self):
-        # Called *after* each test_* 
-    def test_something(self):
-        "docstring"
-        #  Test code.
-        self.assertEqual(x, y)
-        self.assertRaises(ValueError, func, arg1, arg2 ...)
-
-if __name__ == '__main__':
-    unittest.main() 
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-    \frametitle{Nosetest}
-\begin{lstlisting}
-import particle
-def test_particle():
-    # Use asserts here.
-    p = particle.Particle(1.0)
-    assert p.property[0] == 1.0
-    assert p.property[2] == 0.0
-
-if __name__ == '__main__':
-    import nose
-    nose.main()
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Testing}
-  \begin{itemize}
-      \item More details: see library reference and search for nosetest
-  \end{itemize}
-\end{frame}
-
-\section{Numerics \& Plotting}
-
-\subsection{NumPy Arrays}
-
-\subsection{Plotting: Matplotlib}
-
-\begin{frame}
-  \frametitle{About \texttt{matplotlib}}
-  \begin{itemize}
-  \item Easy to use, scriptable, ``Matlab-like'' 2D plotting
-  \item Publication quality figures and interactive capabilities
-  \item Plots, histograms, power spectra, bar charts, errorcharts,
-    scatterplots, etc.
-  \item Also does polar plots, maps, contours
-  \item Support for simple \TeX\ markup
-  \item Multiple output backends (images, EPS, SVG, wx, Agg, Tk, GTK)
-  \item Cross-platform: Linux, Win32, Mac OS X
-  \item Good idea to use via IPython:  \typ{ipython -pylab}
-  \item From scripts use: \typ{import pylab}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}
-  \frametitle{More information}
-  \begin{itemize}
-  \item More information here: \url{http://matplotlib.sf.net}
-  \item \url{http://matplotlib.sf.net/tutorial.html}
-  \item \url{http://matplotlib.sf.net/screenshots.html}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Basic plotting with \texttt{matplotlib}}
-\begin{lstlisting}
->>> x = arange(0, 2*pi, 0.05)
->>> plot(x, sin(x)) # Same as plot(x, sin(x), 'b-') 
->>> plot(x, sin(x), 'ro')
->>> axis([0,2*pi, -1,1])
->>> xlabel(r'$\chi$', color='g')
->>> ylabel(r'sin($\chi$)', color='r')
->>> title('A simple figure', fontsize=20)
->>> savefig('/tmp/test.eps')
-# Multiple plots in one figure
->>> t = arange(0.0, 5.2, 0.2)
-# red dashes, blue squares and green triangles
->>> plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Basic plotting \ldots}
-\begin{lstlisting}
-# Set properties of objects:
->>> plot(x, sin(x), linewidth=2.0, color='r')
->>> l, = plot(x, sin(x))
->>> setp(l, linewidth=2.0, color='r')
->>> l.set_linewidth(2.0); l.set_color('r')
->>> draw() # Redraws current figure.
->>> setp(l) # Prints available properties
->>> close() # Closes the figure.
-# Multiple figures:
->>> figure(1); plot(x, sin(x))
->>> figure(2); plot(x, tanh(x))
->>> figure(1); title('Easy as 1,2,3')
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Basic plotting \ldots}
-\begin{lstlisting}
->>> figure(1)
->>> subplot(211) # Same as subplot(2, 1, 1)
->>> plot(x, cos(5*x)*exp(-x))
->>> subplot(2, 1, 2)
->>> plot(x, cos(5*x), 'r--', label='cosine')
->>> plot(x, sin(5*x), 'g--', label='sine')
->>> legend() # Or legend(['cosine', 'sine'])
->>> text(1,0, '(1,0)')
->>> axes = gca() # Current axis
->>> fig = gcf() # Current figure
-\end{lstlisting}
-\end{frame}
-
-
-\subsection{SciPy}
-
-\begin{frame}
-  \frametitle{Using \texttt{SciPy}}
-  \begin{itemize}
-  \item SciPy is Open Source software for mathematics, science, and
-    engineering
-  \item \typ{import scipy}
-  \item Built on NumPy
-  \item Provides modules for statistics, optimization, integration,
-    linear algebra, Fourier transforms, signal and image processing,
-    genetic algorithms, ODE solvers, special functions, and more
-  \item Used widely by scientists world over
-  \item Details are beyond the scope of this tutorial
-  \end{itemize}
-\end{frame}
-
-\section{Standard library}
-
-\subsection{Quick Tour}
-
-\begin{frame}
-  \frametitle{Standard library}
-  \begin{itemize}
-  \item Very powerful
-  \item ``Batteries included''
-  \item Example standard modules taken from the tutorial
-    \begin{itemize}
-    \item Operating system interface: \typ{os}
-    \item System, Command line arguments: \typ{sys}
-    \item Regular expressions: \typ{re}
-    \item Math: \typ{math}, \typ{random}
-    \item Internet access: \typ{urllib2}, \typ{smtplib}
-    \item Data compression: \typ{zlib}, \typ{gzip}, \typ{bz2},
-      \typ{zipfile}, and \typ{tarfile}
-    \item Unit testing: \typ{doctest} and \typ{unittest}
-    \item And a whole lot more!
-    \end{itemize}
-  \item Check out the Python Library reference:
-    \url{http://docs.python.org/lib/lib.html}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Stdlib: examples}
-\begin{lstlisting}
->>> import os
->>> os.system('date')
-Fri Jun 10 22:13:09 IST 2005
-0
->>> os.getcwd()
-'/home/prabhu'
->>> os.chdir('/tmp')
->>> import os
->>> dir(os)
-<returns a list of all module functions>
->>> help(os)
-<extensive manual page from module's docstrings>
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Stdlib: examples}
-\begin{lstlisting}
->>> import sys
->>> # Print the list of command line args to Python
-... print sys.argv 
-['']
->>> import re # Regular expressions
->>> re.findall(r'\bf[a-z]*', 
-... 'which foot or hand fell fastest')
-['foot', 'fell', 'fastest']
->>> re.sub(r'(\b[a-z]+) \1', r'\1', 
-... 'cat in the the hat')
-'cat in the hat'
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Stdlib: examples}
-\begin{lstlisting}
->>> import math
->>> math.cos(math.pi / 4.0)
-0.70710678118654757
->>> math.log(1024, 2)
-10.0
->>> import random
->>> random.choice(['apple', 'pear', 'banana'])
-'pear'
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Stdlib: examples}
-\begin{lstlisting}
->>> import urllib2
->>> f = urllib2.urlopen('http://www.python.org/')
->>> print f.read(100)
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<?xml-stylesheet href="./css/ht2html
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Stdlib: examples}
-\begin{lstlisting}
->>> import zlib
->>> s = 'witch which has which witches wrist watch'
->>> len(s)
-41
->>> t = zlib.compress(s)
->>> len(t)
-37
->>> zlib.decompress(t)
-'witch which has which witches wrist watch'
->>> zlib.crc32(t)
--1438085031
-\end{lstlisting}
-\end{frame}
-
-\begin{frame}
-  \frametitle{Summary}
-  \begin{itemize}
-  \item Introduced Python
-  \item Basic syntax
-  \item Basic types and data structures
-  \item Control flow
-  \item Functions
-  \item Modules
-  \item Exceptions
-  \item Classes
-  \item Standard library
-  \end{itemize}
-\end{frame}
-
-\end{document}
-
-\subsection{Basic data structures}
-\begin{frame}{Lists}
-  \begin{itemize}
-    \item \texttt{species = [ 'humans', 'orcs', 'elves', 'dwarves' ]}
-    \item \texttt{ ids = [ 107, 109, 124, 141, 142, 144 ]}
-    \item \texttt{ oneliners = [ 'I will be back', 'Do or do not! No try!!', 42 ] }
-  \end{itemize}
-
-  \begin{block}{List operations}
-    ids + [ 100, 102 ]\\
-    species.append( 'unicorns')\\
-    print oneliners[ 1 ]\\
-    look up \alert{docs.python.org/tutorial/datastructures.html}
-  \end{block}
-\end{frame}
-\end{document}
-\section{Python Tutorial}
-\subsection{Preliminaries}
-\begin{frame}
-  \frametitle{Using the interpreter}
-  \begin{itemize}
-  \item Starting up: \typ{python} or \typ{ipython}
-  \item Quitting: \typ{Control-D} or \typ{Control-Z} (on Win32)
-  \item Can use it like a calculator
-  \item Can execute one-liners via the \typ{-c} option:
-    \typ{python -c "print 'hello world'"}
-  \item Other options via \typ{python -h}
-  \end{itemize}
-\end{frame}
-
-\begin{frame}
-  \frametitle{IPython}
-  \begin{itemize}
-  \item Recommended interpreter, IPython:
-    \url{http://ipython.scipy.org}
-  \item Better than the default Python shell
-  \item Supports tab completion by default
-  \item Easier object introspection
-  \item Shell access!
-  \item Command system to allow extending its own behavior
-  \item Supports history (across sessions) and logging
-  \item Can be embedded in your own Python code
-  \item Support for macros
-  \item A flexible framework for your own custom interpreter
-  \item Other miscellaneous conveniences
-  \item We'll get back to this later
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Basic IPython features}
-  \begin{itemize}
-  \item Startup: \verb+ipython [options] files+
-    \begin{itemize}
-    \item \verb+ipython [-wthread|-gthread|-qthread]+:
-      Threading modes to support wxPython, pyGTK and Qt
-    \item \verb+ipython -pylab+: Support for matplotlib
-    \end{itemize}
-  \item TAB completion:
-    \begin{itemize}
-    \item Type \verb+object_name.<TAB>+ to see list of options
-    \item Also completes on file and directory names
-    \end{itemize}
-  \item \verb+object?+ shows docstring/help for any Python object
-  \item \verb+object??+ presents more docs (and source if possible)
-  \item Debugging with \verb+%pdb+ magic: pops up pdb on errors
-  \item Access history (saved over earlier sessions also)
-    \begin{itemize}
-    \item Use \texttt{<UpArrow>}: move up history
-    \item Use \texttt{<Ctrl-r> string}: search history backwards
-    \item Use \texttt{Esc >}: get back to end of history
-    \end{itemize}
-  \item \verb+%run [options] file[.py]+ lets you run Python code
-  \end{itemize}
-\end{frame}
-% LocalWords:  BDFL Guido Rossum PSF Nokia OO Zope CMS RedHat SciPy MayaVi spam
-% LocalWords:  IPython ipython stdin TypeError dict int elif PYTHONPATH IOError
-% LocalWords:  namespace Namespaces SyntaxError ZeroDivisionError NameError str
-% LocalWords:  ValueError subclassed def
-
-
-  \item Types are of two kinds: \alert{mutable} and \alert{immutable}
-  \item Immutable types: numbers, strings, \typ{None} and tuples
-  \item Immutables cannot be changed ``in-place''
-  \item Mutable types: lists, dictionaries, instances, etc.
-  \item Mutable objects can be ``changed''
-  \end{itemize}
-
-
-\begin{frame}
-  \frametitle{Important!}
-  \begin{itemize}
-    \item Assignment to an object is by reference
-    \item Essentially, \alert{names are bound to objects}
-  \end{itemize}
-\end{frame}
-
-
-\end{document}
-\begin{frame}[fragile]
-  \frametitle{Dictionaries}
-  \begin{itemize}
-  \item Associative arrays/mappings
-  \item Indexed by ``keys'' (keys must be immutable)
-  \item \typ{dict[key] = value}
-  \item \typ{keys()} returns all keys of the dict
-  \item \typ{values()} returns the values of the dict
-  \item \verb+has_key(key)+ returns if \typ{key} is in the dict
-  \end{itemize}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{Dictionaries: example}
-  \begin{lstlisting}
->>> tel = {'jack': 4098, 'sape': 4139}
->>> tel['guido'] = 4127
->>> tel
-{'sape': 4139, 'guido': 4127, 'jack': 4098}
->>> tel['jack']
-4098
->>> del tel['sape']
->>> tel['irv'] = 4127
->>> tel
-{'guido': 4127, 'irv': 4127, 'jack': 4098}
->>> tel.keys()
-['guido', 'irv', 'jack']
->>> tel.has_key('guido')
-True
-  \end{lstlisting}
-\end{frame}
-
-\subsection{Control flow, functions}
-
-
-
-\begin{frame}[fragile]
-  \frametitle{\typ{If} example}
-  \begin{lstlisting}
->>> a = ['cat', 'window', 'defenestrate']
->>> if 'cat' in a:
-...    print "meaw"
-...
-meaw
->>> pets = {'cat': 1, 'dog':2, 'croc': 10}
->>> if 'croc' in pets:
-...    print pets['croc']
-...
-10
-  \end{lstlisting}
-\end{frame}
-
-\begin{frame}[fragile]
-  \frametitle{\typ{for} example}
-  \begin{lstlisting}
->>> a = ['cat', 'window', 'defenestrate']
->>> for x in a:
-...     print x, len(x)
-...
-cat 3
-window 6
-defenestrate 12
->>> knights = {'gallahad': 'the pure', 
-... 'robin': 'the brave'}
->>> for k, v in knights.iteritems():
-...     print k, v
-...
-gallahad the pure
-robin the brave
-\end{lstlisting}
-\end{frame}