\documentclass{beamer}

\usepackage{beamerthemeprogressbar}
\usepackage[spanish]{babel}
\usepackage{fix-cm}
\usepackage{color}
\include{pythonlisting}

% the following is for unicode
\usepackage{fontspec}
\setmainfont[Mapping=tex-text]{DejaVu Sans}
\usepackage{xunicode}
\usepackage{xltxtra}

\usepackage{fancyvrb}

\definecolor{verdeoscuro}{rgb}{.2,.4,.2}
\newcommand{\vpy}[1] {\texttt{\textbf{\color{verdeoscuro}#1}}}

\setbeamersize{text margin left=20pt }
\setbeamersize{text margin right=20pt }
\setbeamertemplate{itemize item}[triangle]
\setbeamertemplate{itemize subitem}[triangle]

\title{NumPy / SciPy}
\author{Facundo Batista}
\date{\today}

\begin{document}
\frame[plain] {
\begin{picture}(0,0)
  \put(0,-150){\includegraphics[scale=.5]{images/caratula.png}}
\end{picture}
}

\frame {
\fontsize{38}{0}\selectfont
\begin{picture}(0,0)
  \put(30,40){NumPy}
  \put(190,-110){\includegraphics[scale=.6]{images/numpylogo.png}}
\end{picture}
}

\frame {
\frametitle{¿Qué es NumPy?}

\begin{itemize}
    \setlength{\itemsep}{10pt}
    \setlength{\parskip}{10pt}
    \item Es una biblioteca de Python para trabajar con arreglos multidimensionales.
    \item El principal tipo de dato es el arreglo o \textit{array}
    \item También nos permite trabajar con la semántica de matrices
    \item Nos ofrece muchas funciones útiles para el procesamiento de números
\end{itemize}
}

\begin{frame}[fragile]
\frametitle{Disclaimer}

\begin{itemize}
    \setlength{\itemsep}{10pt}
    \setlength{\parskip}{10pt}
    \item Pueden ver toda la info de esta presentación en
    \linebreak\vpy{        http://www.scipy.org/Tentative\_NumPy\_Tutorial}
    \item Los ejemplos suponen que primero se hizo en el intérprete:
    \linebreak\vpy{        >>> from numpy import *}
\end{itemize}
\end{frame}

\frame {
\frametitle{El Array}

\begin{itemize}
    \setlength{\itemsep}{5pt}
    \setlength{\parskip}{5pt}
    \item Es una tabla de elementos
    \begin{itemize}
        \item normalmente números
        \item todos del mismo tipo
        \item indexados por enteros
    \end{itemize}
    \item Ejemplo de arreglos multidimensionales
    \begin{itemize}
        \item Vectores
        \item Matrices
        \item Imágenes
        \item Planillas
    \end{itemize}
    \item ¿Multidimensionales?
    \begin{itemize}
        \item Que tiene muchas dimensiones o ejes
        \item Un poco ambiguo, mejor usar \textit{ejes}
        \item Rango: cantidad de ejes
    \end{itemize}
\end{itemize}
}

\begin{frame}[fragile]
\frametitle{Propiedades del Array}
\begin{itemize}
    \setlength{\itemsep}{8pt}
    \setlength{\parskip}{8pt}
    \item Como tipo de dato se llama \vpy{ndarray}
    \item \vpy{ndarray.ndim}: cantidad de ejes
    \item \vpy{ndarray.shape}: una tupla indicando el tamaño del array en cada eje
    \item \vpy{ndarray.size}: la cantidad de elementos en el array
    \item \vpy{ndarray.dtype}: el tipo de elemento que el array contiene
    \item \vpy{ndarray.itemsize}: el tamaño de cada elemento en el array
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Propiedades del Array}
\begin{python}
    >>> a = arange(10).reshape(2,5)
    >>> a
    array([[0, 1, 2, 3, 4],
           [5, 6, 7, 8, 9]])
    >>> a.shape
    (2, 5)
    >>> a.ndim
    2
    >>> a.size
    10
    >>> a.dtype
    dtype('int32')
    >>> a.itemsize
    4
\end{python}
\end{frame}

\begin{frame}[fragile]
\frametitle{Creando Arrays}
\begin{itemize}
\item Tomando un iterable como origen
\begin{python}
>>> array( [2,3,4] )
array([2, 3, 4])
>>> array( [ (1.5,2,3), (4,5,6) ] ) 
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Creando Arrays}
\begin{itemize}
\item Con funciones específicas en función del contenido
\begin{python}
>>> arange(5)
array([0, 1, 2, 3, 4])
>>> zeros((2, 3))
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])
>>> ones((3, 2), dtype=int)
array([[1, 1],
       [1, 1],
       [1, 1]])
>>> empty((2, 2))
array([[  9.43647120e-268,   7.41399396e-269],
       [  1.08290285e-312,               NaN]])
>>> linspace(-pi, pi, 5)
array([-3.141592, -1.570796,  0.   ,  1.570796,  3.141592])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Manejando los ejes}
    \begin{python}
    >>> a = arange(6)
    >>> a
    array([0, 1, 2, 3, 4, 5])
    >>> a.shape = (2, 3)
    >>> a
    array([[0, 1, 2],
           [3, 4, 5]])
    >>> a.shape = (3, 2)
    >>> a
    array([[0, 1],
           [2, 3],
           [4, 5]])
    >>> a.size
    6
    \end{python}
\end{frame}

\begin{frame}[fragile]
\frametitle{Operaciones básicas}
\begin{itemize}
\item Los operadores aritméticos se aplican por elemento
\begin{python}
    >>> a = arange(20, 60, 10)
    >>> a
    array([20, 30, 40, 50])
    >>> a + 1
    array([21, 31, 41, 51])
    >>> a * 2
    array([ 40,  60,  80, 100])
\end{python}

\item Si es \textit{inplace}, no se crea otro array
\begin{python}
    >>> a
    array([20, 30, 40, 50])
    >>> a /= 2
    >>> a
    array([10, 15, 20, 25])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Operaciones básicas}
\begin{itemize}
\item Podemos realizar comparaciones
\begin{python}
    >>> a = arange(5)
    >>> a >= 3
    array([False, False, False,  True,  True], dtype=bool)
    >>> a % 2 == 0
    array([ True, False,  True, False,  True], dtype=bool)
\end{python}

\item También con otros arrays
\begin{python}
    >>> b = arange(4)
    >>> b
    array([0, 1, 2, 3])
    >>> a - b
    array([20, 29, 38, 47])
    >>> a * b
    array([  0,  30,  80, 150])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Operaciones básicas}
\begin{itemize}
\item Tenemos algunos métodos con cálculos típicos
\begin{python}
    >>> c
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> c.min(), c.max()
    (0, 9)
    >>> c.mean()
    4.5
    >>> c.sum()
    45
    >>> c.cumsum()
    array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])
\end{python}

\item Hay \textbf{muchas} funciones que nos dan info del array
\begin{itemize}
    \item all, alltrue, any, argmax, argmin, argsort, average, bincount, ceil, clip, conj, conjugate, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sometrue, sort, std, sum, trace, transpose, var, vdot, vectorize, where
\end{itemize}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Trabajando con los elementos}
\begin{itemize}
\item La misma sintaxis de Python
\begin{python}
    >>> a = arange(10)
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> a[2]
    2
    >>> a[2:5]
    array([2, 3, 4])
    >>>
    >>> a[1] = 88
    >>> a[-5:] = 100
    >>> a
    array([ 0,  88,  2,  3,  4, 100, 100, 100, 100, 100])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Trabajando con los elementos}
\begin{itemize}
\item Pero también podemos trabajar por eje
\begin{python}
    >>> a = arange(8).reshape((2,4))
    >>> a
    array([[0, 1, 2, 3],
           [4, 5, 6, 7]])
    >>> a[:,1]
    array([1, 5])
    >>> a[0,-2:]
    array([2, 3])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Cambiando la forma del array}
\begin{itemize}
\item Podemos usar \vpy{.shape} directamente
\begin{python}
    >>> a = arange(8)
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7])
    >>> a.shape = (2,4)
    >>> a
    array([[0, 1, 2, 3],
           [4, 5, 6, 7]])
\end{python}

\item Usando \vpy{.shape} con comodín
\begin{python}
    >>> a.shape = (4,-1)
    >>> a
    array([[0, 1],
           [2, 3],
           [4, 5],
           [6, 7]])
    >>> a.shape
    (4, 2)
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Cambiando la forma del array}
\begin{itemize}
\item Transponer y aplanar
\begin{python}
    >>> a
    array([[0, 1, 2, 3],
           [4, 5, 6, 7]])
    >>> a.transpose()
    array([[0, 4],
           [1, 5],
           [2, 6],
           [3, 7]])
    >>> a.ravel()
    array([0, 1, 2, 3, 4, 5, 6, 7])
    >>> a
    array([[0, 1, 2, 3],
           [4, 5, 6, 7]])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Juntando y separando arrays}
\begin{itemize}
\item Tenemos vstack y hstack
\begin{python}
    >>> a = ones((2,5)); b = arange(5)
    >>> a
    array([[ 1.,  1.,  1.,  1.,  1.],
           [ 1.,  1.,  1.,  1.,  1.]])
    >>> b
    array([0, 1, 2, 3, 4])
    >>> juntos = vstack((a,b))
    >>> juntos
    array([[ 1.,  1.,  1.,  1.,  1.],
           [ 1.,  1.,  1.,  1.,  1.],
           [ 0.,  1.,  2.,  3.,  4.]])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Juntando y separando arrays}
\begin{itemize}
\item También hsplit y vsplit
\begin{python}
    >>> hsplit(juntos, (1,3))
    [array([[ 1.],
            [ 1.],
            [ 0.]]),
     array([[ 1.,  1.],
            [ 1.,  1.],
            [ 1.,  2.]]),
     array([[ 1.,  1.],
            [ 1.,  1.],
            [ 3.,  4.]])]
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Indexado avanzado}
\begin{itemize}
\item Podemos indizar con otros arrays
\begin{python}
    >>> a = arange(10) ** 2
    >>> i = array([ (2,3), (6,7) ])
    >>> a
    array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])
    >>> a[i]
    array([[ 4,  9],
           [36, 49]])
\end{python}

\item O elegir elementos
\begin{python}
    >>> a = arange(5)
    >>> b = a % 2 == 0
    >>> a
    array([0, 1, 2, 3, 4])
    >>> b
    array([ True, False,  True, False,  True], dtype=bool)
    >>> a[b]
    array([0, 2, 4])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Matrices}
\begin{itemize}
\item Es un caso específico del array
\begin{python}
    >>> a
    array([[0, 1, 2],
           [3, 4, 5]])
    >>> A = matrix(a)
    >>> A
    matrix([[0, 1, 2],
            [3, 4, 5]])
    >>> A.T
    matrix([[0, 3],
            [1, 4],
            [2, 5]])
    >>> A.I
    matrix([[-0.77777778,  0.27777778],
            [-0.11111111,  0.11111111],
            [ 0.55555556, -0.05555556]])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Matrices}
\begin{itemize}
\item Se comportan, obviamente, como matrices
\begin{python}
    >>> A
    matrix([[0, 1, 2],
            [3, 4, 5]])
    >>> M
    matrix([[2, 3],
            [4, 5],
            [6, 7]])
    >>> A * M
    matrix([[16, 19],
            [52, 64]])
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Polinomios}
\begin{python}
    >>> p = poly1d([2, 3, 4])
    >>> print p
       2
    2 x + 3 x + 4
    >>> print p*p
       4      3      2
    4 x + 12 x + 25 x + 24 x + 16
    >>> print p.deriv()
    4 x + 3
    >>> print p.integ(k=2)
            3       2
    0.6667 x + 1.5 x + 4 x + 2
    >>> p(range(5))
    array([ 4,  9, 18, 31, 48])
\end{python}
\end{frame}



\frame {
\fontsize{38}{0}\selectfont
\begin{picture}(0,0)
  \put(30,40){SciPy}
  \put(170,-110){\includegraphics[scale=.6]{images/scipylogo.png}}
\end{picture}
}

\begin{frame}[fragile]
\frametitle{Intro}
\begin{itemize}
    \setlength{\itemsep}{10pt}
    \setlength{\parskip}{10pt}
    \item Colección de algoritmos matemáticos y funciones
    \begin{itemize}
        \item Construido sobre NumPy
    \end{itemize}
    \item Poder al intérprete interactivo
    \begin{itemize}
        \setlength{\itemsep}{5pt}
        \item Procesamiento de datos y prototipado de sistemas
        \item Compite con Matlab, IDL, Octave, R-Lab, y SciLab
    \end{itemize}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Disclaimer}

\begin{itemize}
    \setlength{\itemsep}{10pt}
    \setlength{\parskip}{10pt}
    \item Pueden ver toda la info de esta presentación en
\vpy{        http://docs.scipy.org/doc/}
    \item ¿Les conté que me recibí de ingeniero hace más de 9 años?
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Funciones y funciones!}
\begin{itemize}
    \item De todo tipo!
    \begin{itemize}
        \setlength{\itemsep}{5pt}
        \item airy
        \item elliptic
        \item bessel
        \item gamma
        \item beta
        \item hypergeometric
        \item parabolic cylinder
        \item mathieu
        \item spheroidal wave
        \item struve
        \item kelvin
    \end{itemize}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Integration}
\begin{itemize}
    \setlength{\itemsep}{10pt}
    \item General integration
    \item Gaussian quadrature
    \item Integrating using samples
    \item Ordinary differential equations
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Optimization}
\begin{picture}(0,0)
  \put(170,-140){\includegraphics[scale=.4]{images/optimize-1.png}}
\end{picture}
\begin{itemize}
\item Nelder-Mead Simplex algorithm
\item Broyden-Fletcher-Goldfarb-Shanno algorithm
\item Newton-Conjugate-Gradient
\item Least-square fitting
\item Scalar function minimizers
\item Root finding
\begin{python}
  >>> f = poly1d([1, 4, 8])
  >>> print f
     2
  1 x + 4 x + 8
  >>> roots(f)
  array([-2.+2.j, -2.-2.j])
  >>> f(-2.+2.j)
  0j
\end{python}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Interpolation}
\begin{picture}(0,0)
  \put(20,-182){\includegraphics[scale=.45]{images/interpolate-3_00.png}}
  \put(170,-180){\includegraphics[scale=.45]{images/interpolate-3_01.png}}
\end{picture}
\begin{itemize}
    \item Linear 1-d interpolation
    \item Spline interpolation in 1-d
    \item Two-dimensional spline representation
\end{itemize}
\vspace{4cm}
\end{frame}

\begin{frame}[fragile]
\frametitle{Signal Processing}
\begin{picture}(0,0)
  \put(60,-200){\includegraphics[scale=.4]{images/signal-1_00.png}}
  \put(180,-200){\includegraphics[scale=.4]{images/signal-1_01.png}}
\end{picture}
\begin{itemize}
    \item B-splines
    \begin{itemize}
        \item second- and third-order cubic spline coefficients
        \item from equally spaced samples in one- and two-dimensions
    \end{itemize}

    \item Filtering
    \begin{itemize}
        \item Convolution/Correlation
        \item Difference-equation filtering
        \item Other filters: Median, Order, Wiener, Hilbert, ...
    \end{itemize}
\end{itemize}
\vspace{3.5cm}
\end{frame}
        
\begin{frame}[fragile]
\frametitle{Algebra lineal}
\begin{itemize}
    \item Matrices
    \begin{itemize}
    \setlength{\itemsep}{5pt}
        \item Inversas
        \item Determinantes
        \item Resolución de sistemas lineales
    \end{itemize}
    \item Descomposiciones
    \begin{itemize}
    \setlength{\itemsep}{5pt}
        \item Eigenvalues and eigenvectors
        \item Singular value, LU, Cholesky, QR, Schur
    \end{itemize}
    \item Funciones de matrices
    \begin{itemize}
    \setlength{\itemsep}{5pt}
        \item Exponentes y logaritmos
        \item Trigonometría (común e hiperbólica)
    \end{itemize}
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Estadísticas}
\begin{itemize}
    \item Masked statistics functions
    \begin{itemize}
        \item 64!
    \end{itemize}
    \item Continuous distributions
    \begin{itemize}
        \item 81!
    \end{itemize}
    \item Discrete distributions
    \begin{itemize}
        \item 12!
    \end{itemize}
    \item Statistical functions
    \begin{itemize}
        \item 72!
    \end{itemize}
\end{itemize}
\end{frame}
    

\frame
{
\begin{picture}(0,0)
  \fontsize{30}{0}\selectfont
  \put(60,50){¡Muchas gracias!}
  \fontsize{16}{0}\selectfont
  \put(90,9){\color{blue}¿Preguntas?}
  \put(150,-15){\color{blue}¿Sugerencias?}

  \fontsize{18}{0}\selectfont
  \put(105,-60){Facundo Batista}
  \fontsize{9}{0}\selectfont
  \put(112,-75){\color{blue}facundo@taniquetil.com.ar}
  \put(106,-88){\color{blue}http://www.taniquetil.com.ar}

  \put(65,-132){\includegraphics[scale=.6]{images/cc-byncsa.png}}
  \fontsize{5}{0}\selectfont
  \put(125,-117){\textbf{Licencia}: Creative Commons }
  \put(125,-124){Atribución-NoComercial-CompartirDerivadasIgual 2.5 Argentina}
  \put(125,-131){http://creativecommons.org/licenses/by-nc-sa/2.5/deed.es\_AR}
\end{picture}
}

\end{document}
