%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Tutorial slides on Python.
%
% Author: FOSSEE 
% Copyright (c) 2009, FOSSEE, IIT Bombay
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\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{infolines}
  \setbeamercovered{transparent}
}

\usepackage[english]{babel}
\usepackage[latin1]{inputenc}
%\usepackage{times}
\usepackage[T1]{fontenc}
\usepackage{amsmath}

% 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]{\lstinline{#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[Arrays]{Python for Science and Engg: \\Arrays}

\author[FOSSEE] {FOSSEE}

\institute[IIT Bombay] {Department of Aerospace Engineering\\IIT Bombay}
\date[] {SciPy.in 2010, Tutorials}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%\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}
  \frametitle{Outline}
  \tableofcontents
%  \pausesections
\end{frame}
\section{Motivation}

\begin{frame}[fragile]
  \frametitle{Why arrays?}
  \begin{itemize}
  \item Speed!
  \item Convenience
  \item Easier to handle multi-dimensional data
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Speed}
    \begin{lstlisting}
In []: a = linspace(0, 100*pi, 1000000) 
# array with a million elements
In []: b = []
In []: for each in a:
  ...:     b.append(sin(each))
  ...:     
  ...:     
In []: sin(a)
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Convenience}
The pendulum problem could've been solved as below::
    \begin{lstlisting}
In []: L, T = loadtxt('pendulum.txt', 
                      unpack=True)
In []: tsq = T*T
In []: plot (L, tsq, '.')
  \end{lstlisting}
\end{frame}

\section{Initializing}
\begin{frame}[fragile]
\frametitle{Initializing}
\begin{lstlisting}
In []: c = array([[11,12,13],
                  [21,22,23],
                  [31,32,33]])

In []: c
Out[]: 
array([[11, 12, 13],
       [21, 22, 23],
       [31, 32, 33]])
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
\frametitle{Some special arrays}
\begin{small}
  \begin{lstlisting}
In []: ones((3,5))
Out[]: 
array([[ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.]])

In []: ones_like([1, 2, 3, 4]) 
Out[]: array([1, 1, 1, 1])   

In []: identity(2)
Out[]: 
array([[ 1.,  0.],
       [ 0.,  1.]])
  \end{lstlisting}
Also available \alert{\typ{zeros, zeros_like, empty, empty_like}}
\end{small}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Accessing elements}
  \begin{small}
  \begin{lstlisting}
In []: c
Out[]: 
array([[11, 12, 13],
       [21, 22, 23],
       [31, 32, 33]])

In []: c[1][2]
Out[]: 23
In []: c[1,2]
Out[]: 23

In []: c[1]
Out[]: array([21, 22, 23])
  \end{lstlisting}
  \end{small}
Similar to \kwrd{lists} but improved!
\end{frame}

\begin{frame}[fragile]
  \frametitle{Changing elements}
  \begin{small}
  \begin{lstlisting}
In []: c[1,1] = -22
In []: c
Out[]: 
array([[ 11,  12,  13],
       [ 21, -22,  23],
       [ 31,  32,  33]])

In []: c[1] = 0
In []: c
Out[]: 
array([[11, 12, 13],
       [ 0,  0,  0],
       [31, 32, 33]])
  \end{lstlisting}
  \end{small}
How do you access one \alert{column}? -- Enter Slicing!
\end{frame}

\section{Slicing \& Striding}

\begin{frame}[fragile]
  \frametitle{Slicing: Lists}
  \begin{block}{Define a list}
	\kwrd{In []: p = [ 2, 3, 5, 7, 11, 13]}
  \end{block}
\begin{lstlisting}
In []: p[1:3]
Out[]: [3, 5]
\end{lstlisting}
\emphbar{A slice}
\begin{lstlisting}
In []: p[0:-1]
Out[]: [2, 3, 5, 7, 11]
In []: p[:]
Out[]: [2, 3, 5, 7, 11, 13]
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Striding: Lists}
\emphbar{Striding over \typ{p}}
\begin{lstlisting}
In []: p[::2]
Out[]: [2, 5, 11]
In []: p[1::2]
Out[]: [3, 7, 13]
In []: p[1:-1:2]
Out[]: [3, 7]
In []: p[::3]
Out[]: [2, 7]
\end{lstlisting}
\alert{\typ{list[initial:final:step]}}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Slicing \& Striding: Lists}
  What is the output of the following?
\begin{lstlisting}
In []: p[1::4]

In []: p[1:-1:3]
\end{lstlisting}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Slicing: \typ{arrays}}
\begin{small}
  \begin{lstlisting}
In []: c[:,1]
Out[]: array([12,  0, 32])

In []: c[1,:]
Out[]: array([0, 0, 0])

In []: c[0:2,:]
Out[]: 
array([[11, 12, 13],
       [ 0,  0,  0]])

In []: c[1:3,:]
Out[]: 
array([[ 0,  0,  0],
       [31, 32, 33]])
  \end{lstlisting}
\end{small}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Slicing: \typ{arrays} \ldots}
\begin{small}
  \begin{lstlisting}
In []: c[:2,:]
Out[]: 
array([[11, 12, 13],
       [ 0,  0,  0]])

In []: c[1:,:]
Out[]: 
array([[ 0,  0,  0],
       [31, 32, 33]])

In []: c[1:,:2]
Out[]: 
array([[ 0,  0],
       [31, 32]])
  \end{lstlisting}

\end{small}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Striding: \typ{arrays}}
  \begin{small}
  \begin{lstlisting}
In []: c[::2,:]
Out[]: 
array([[11, 12, 13],
       [31, 32, 33]])

In []: c[:,::2]
Out[]: 
array([[11, 13],
       [ 0,  0],
       [31, 33]])

In []: c[::2,::2]
Out[]: 
array([[11, 13],
       [31, 33]])
  \end{lstlisting}
  \end{small}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Shape of an \typ{array}}
  \begin{lstlisting}
In []: c
Out[]: 
array([[11, 12, 13],
       [ 0,  0,  0],
       [31, 32, 33]])

In []: c.shape
Out[]: (3, 3)
  \end{lstlisting}
\emphbar{Shape specifies shape or dimensions of an array}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Elementary image processing}
\begin{small}
  \begin{lstlisting}
In []: a = imread('lena.png')

In []: imshow(a)
Out[]: <matplotlib.image.AxesImage object at 0xa0384cc>
  \end{lstlisting}
  \end{small}
\typ{imread} returns an array of shape (512, 512, 4) which represents an image of 512x512 pixels and 4 shades.\\
\typ{imshow} renders the array as an image.
\end{frame}

\begin{frame}[fragile]
\frametitle{Slicing \& Striding Exercises}
  \begin{itemize}
  \item Crop the image to get the top-left quarter
  \item Crop the image to get only the face
  \item Resize image to half by dropping alternate pixels
  \end{itemize}

\end{frame}
\begin{frame}[fragile]
  \frametitle{Solutions}
\begin{small}
  \begin{lstlisting}
In []: imshow(a[:256,:256])
Out[]: <matplotlib.image.AxesImage object at 0xb6f658c>

In []: imshow(a[200:400,200:400])
Out[]: <matplotlib.image.AxesImage object at 0xb757c2c>

In []: imshow(a[::2,::2])
Out[]: <matplotlib.image.AxesImage object at 0xb765c8c>
  \end{lstlisting}
\end{small}
\end{frame}

\section{Operations on \typ{arrays}}
\begin{frame}[fragile]
  \frametitle{Operations: Addition}
  Operations on arrays, as already mentioned, are \alert{element-wise}
  \begin{lstlisting}
In []: a = array([[-3,2.5],
                  [2.5,2]])

In []: b = array([[3,2],
                  [2,-2]])

In []: a + b
Out[]: 
array([[ 0. ,  4.5],
       [ 4.5,  0. ]])
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
\frametitle{Elementwise Multiplication}
\begin{lstlisting}
In []: a*b
Out[]: 
array([[-9.,  5.],
       [ 5., -4.]])
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
\frametitle{Matrix Operations using \typ{arrays}}

We can perform various matrix operations on \kwrd{arrays}\\ 
A few are listed below.

\vspace{-0.2in}

\begin{center}
\begin{tabular}{lll}
 Operation                    &  How?           &  Example           \\
\hline
 Transpose                    &  \typ{.T}       &  \typ{A.T}         \\
 Product                      &  \typ{dot}      &  \typ{dot(A, B)}   \\
 Inverse                      &  \typ{inv}      &  \typ{inv(A)}      \\
 Determinant                  &  \typ{det}      &  \typ{det(A)}      \\
 Sum of all elements          &  \typ{sum}      &  \typ{sum(A)}      \\
 Eigenvalues                  &  \typ{eigvals}  &  \typ{eigvals(A)}  \\
 Eigenvalues \& Eigenvectors  &  \typ{eig}      &  \typ{eig(A)}      \\
 Norms                        &  \typ{norm}     &  \typ{norm(A)}     \\
 SVD                          &  \typ{svd}      &  \typ{svd(A)}      \\
\end{tabular}
\end{center}

\end{frame}

\section{Summary}
\begin{frame}
  \frametitle{What did we learn?}
  \begin{itemize}
  \item Arrays
    \begin{itemize}
    \item Initializing
    \item Accessing elements
    \item Slicing \& Striding
    \item Element-wise Operations
    \item Matrix Operations
    \end{itemize}
  \end{itemize}
\end{frame}

\end{document}

%% Questions for Quiz %%
%% ------------------ %%

\begin{frame}[fragile]
\frametitle{\incqno }
\begin{lstlisting}
In []: a = array([[1, 2],
                  [3, 4]])
In []: a[1,0] = 0
\end{lstlisting}
What is the resulting array?
\end{frame}

\begin{frame}[fragile]
\frametitle{\incqno }
\begin{lstlisting}
  In []: x = array(([1,2,3,4],
                    [2,3,4,5]))
  In []: x[-2][-3] = 4
  In []: print x
\end{lstlisting}
What will be printed?
\end{frame}

%% \begin{frame}[fragile]
%% \frametitle{\incqno }
%% \begin{lstlisting}
%%   In []: x = array([[1,2,3,4],
%%                     [3,4,2,5]])
%% \end{lstlisting}
%% What is the \lstinline+shape+ of this array?
%% \end{frame}

\begin{frame}[fragile]
\frametitle{\incqno }
\begin{lstlisting}
  In []: x = array([[1,2,3,4]])
\end{lstlisting}
How to change \lstinline+x+ to \lstinline+array([[1,2,0,4]])+?
\end{frame}

\begin{frame}[fragile]
\frametitle{\incqno }
\begin{lstlisting}
  In []: x = array([[1,2,3,4],
                    [3,4,2,5]])
\end{lstlisting}
How do you get the following slice of \lstinline+x+?
\begin{lstlisting}
array([[2,3],
       [4,2]])
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
\frametitle{\incqno }
\begin{lstlisting}
  In []: x = array([[9,18,27],
                    [30,60,90],
                    [14,7,1]])
\end{lstlisting}
What is the output of \lstinline+x[::3,::3]+
\end{frame}


\begin{frame}[fragile]
\frametitle{\incqno }
\begin{lstlisting}
In []: a = array([[1, 2],
                  [3, 4]])
\end{lstlisting}
How do you get the transpose of this array?
\end{frame}

\begin{frame}[fragile]
\frametitle{\incqno }
\begin{lstlisting}
In []: a = array([[1, 2],
                  [3, 4]])
In []: b = array([[1, 1],
                  [2, 2]])
In []: a*b
\end{lstlisting}
What does this produce?
\end{frame}

\begin{frame}
\frametitle{\incqno }
What command do you use to find the inverse of a matrix and its
eigenvalues?
\end{frame}

%% \begin{frame}
%% \frametitle{\incqno }
%% The file \lstinline+datafile.txt+ contains 3 columns of data.  What
%% command will you use to read the entire data file into an array?
%% \end{frame}

%% \begin{frame}
%% \frametitle{\incqno }
%% If the contents of the file \lstinline+datafile.txt+ is read into an
%% $N\times3$ array called \lstinline+data+, how would you obtain the third
%% column of this data?
%% \end{frame}