Basic Python Packages for Science.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Python Madrid Logo](./static/pycones2016.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Python Packages for Science\n",
    "## The Aeropython’s guide to the Python Galaxy! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Aropython_logo](./static/aeropython_name_mini.png)\n",
    "###### Siro Moreno Martín\n",
    "###### Alejandro Sáez Mollejo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Who are we? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Siro Moreno "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"static/siro.jpg\" width=\"175\" style=\"float: right\" />\n",
    "* **Aerospace Engineer**\n",
    "* Working at: Instituto Nacional de Técnica Aeroespacial\n",
    "* Full-time Nerd\n",
    "* Have another workshop later because stupidity (please COME!!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Álex Sáez "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"static/alex.jpg\" width=\"175\" style=\"float: right\" />\n",
    "\n",
    "* **Aerospace Engineer**\n",
    "* **Flight Test Methods Engineer** at AIRBUS Defence & Space on behalf of ALTRAN\n",
    "*  Co-creator of AeroPython --> PyFME \n",
    "* Member of Python España (come and join us!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0. Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python in the Scientific environment  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Principal Python Packages for scientific purposes "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Anaconda & conda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![conda](./static/conda.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://conda.pydata.org/docs/intro.html\n",
    "\n",
    "Conda is a package manager application that quickly installs, runs, and updates packages and their dependencies. The conda command is the primary interface for managing installations of various packages. It can query and search the package index and current installation, create new environments, and install and update packages into existing conda environments. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from IPython.display import HTML\n",
    "HTML('<iframe src=\"http://conda.pydata.org/docs/_downloads/conda-cheatsheet.pdf\" width=\"700\" height=\"400\"></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Main objectives of this workshop \n",
    "\n",
    "* Provide you with a **first insight into the principal Python tools & libraries used in Science**:\n",
    "    - conda.\n",
    "    - Jupyter Notebook and preview of JupyterLab\n",
    "    - NumPy, matplotlib, SciPy\n",
    "    - SymPy\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Other common libraries that will not be covered here are:\n",
    "\n",
    "- Pandas\n",
    "- scikit-learn\n",
    "- Numba & Cython"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./static/jupyter-logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Jupyter Notebook is a web application that allows you to create and share documents that contain live code, equations, visualizations and explanatory text. Uses include: data cleaning and transformation, numerical simulation, statistical modeling, machine learning and much more.\n",
    "\n",
    "It has been widely recognised as a great way to distribute scientific papers, because of the capability to have an integrated format with text and executable code, highly reproducible. Top level investigators around the world are already using it, like the team behind the Gravitational Waves discovery (LIGO), whose analysis was translated to an interactive dowloadable Jupyter notebook. You can see it here: https://github.com/minrk/ligo-binder/blob/master/GW150914_tutorial.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Using arrays: NumPy "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![numpy-logo](./static/numpy.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ndarray object "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| index     | 0     | 1     | 2     | 3     | ...   | n-1   | n  |\n",
    "| ---------- | :---: | :---: | :---: | :---: | :---: | :---: | :---: |\n",
    "| value      | 2.1   | 3.6   | 7.8   | 1.5   | ...   | 5.4   | 6.3 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* N-dimensional data structure.\n",
    "* Homogeneously typed.\n",
    "* Efficient!\n",
    "\n",
    "A universal function (or ufunc for short) is a function that operates on ndarrays. It is a “**vectorized** function\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a look at the efficiency of a ndarray against the efficiency of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# List \n",
    "my_list  = list(range(0,100000))\n",
    "# Array \n",
    "my_array = np.arange(0, 100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%timeit sum(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%timeit np.sum(my_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%timeit [ii**2 for ii in range(100000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%timeit np.arange(100000)**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# [1, 2, 3, 4]\n",
    "one_dim_array = np.array([1, 2, 3, 4])\n",
    "one_dim_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# [1, 2, 3],\n",
    "# [4, 5, 6],\n",
    "# [7, 8, 9]\n",
    "\n",
    "two_dim_array = np.array([[1, 2, 3],\n",
    "                                           [4, 5, 6],\n",
    "                                           [7, 8, 9]])\n",
    "two_dim_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# size\n",
    "two_dim_array.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# shape\n",
    "two_dim_array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# dtype\n",
    "two_dim_array.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "two_dim_array.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Other interesting functions for array creation\n",
    "# zeros\n",
    "zeros_arr = np.zeros([3, 3])\n",
    "# ones\n",
    "ones_arr = np.ones([10])\n",
    "# identity\n",
    "eye_arr = np.eye(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# range\n",
    "range_arr = np.arange(15)\n",
    "range_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# reshape\n",
    "range_arr.reshape([3, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# linspace\n",
    "np.linspace(0, 10, 21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Basic slicing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "one_dim_array[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "two_dim_array[-1, -1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`[start:stop:step]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "my_arr = np.arange(100)\n",
    "my_arr[0::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "chess_board = np.zeros([8, 8], dtype=int)\n",
    "\n",
    "chess_board[0::2, 1::2] = 1\n",
    "chess_board[1::2, 0::2] = 1\n",
    "\n",
    "chess_board"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Drawing: Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Matplotlib-logo](./static/matplotlib.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.matshow(chess_board, cmap=plt.cm.gray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operations & linalg "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# numpy functions\n",
    "x = np.linspace(1, 10)\n",
    "y = np.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y_2 = (1 + np.log(x)) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(x, y_2, 'r-*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Creating a 2d array\n",
    "two_dim_array = np.array([[10, 25, 33],\n",
    "                          [40, 25, 16],\n",
    "                          [77, 68, 91]])\n",
    "\n",
    "two_dim_array.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# matrix multiplication\n",
    "two_dim_array @ two_dim_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# matrix vector\n",
    "one_dim_array = np.array([2.5, 3.6, 3.8])\n",
    "\n",
    "two_dim_array @ one_dim_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# inv\n",
    "np.linalg.inv(two_dim_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# eigenvectors & eigenvalues\n",
    "np.linalg.eig(two_dim_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Air quality data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from IPython.display import HTML\n",
    "HTML('<iframe src=\"http://www.mambiente.munimadrid.es/sica/scripts/index.php\" \\\n",
    "            width=\"700\" height=\"400\"></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Loading the data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Linux command \n",
    "!head ./data/barrio_del_pilar-20160322.csv\n",
    "\n",
    "# Windows\n",
    "# !gc log.txt | select -first 10 # head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# loading the data\n",
    "# ./data/barrio_del_pilar-20160322.csv\n",
    "data1 = np.genfromtxt('./data/barrio_del_pilar-20160322.csv', skip_header=3, delimiter=';', usecols=(2,3,4))\n",
    "data1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dealing with missing values "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.mean(data1, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.nanmean(data1, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# masking invalid data\n",
    "data1 = np.ma.masked_invalid(data1)\n",
    "np.mean(data1, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data2 = np.genfromtxt('./data/barrio_del_pilar-20151222.csv', skip_header=3, delimiter=';', usecols=(2,3,4))\n",
    "data2 = np.ma.masked_invalid(data2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Plotting the data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Maximum values ** from: http://www.mambiente.munimadrid.es/opencms/export/sites/default/calaire/Anexos/valores_limite_1.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* NO2\n",
    "    - Media anual: 40 µg/m3\n",
    "    - **Media horaria: 200 µg/m3 **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(data1[:, 1], label='2016')\n",
    "plt.plot(data2[:, 1], label='2015')\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.hlines(200, 0, 200, linestyles='--')\n",
    "plt.ylim(0, 220)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from IPython.display import HTML\n",
    "HTML('<iframe src=\"http://ccaa.elpais.com/ccaa/2015/12/24/madrid/1450960217_181674.html\" width=\"700\" height=\"400\"></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* CO \n",
    "    - **Máxima diaria de las medias móviles octohorarias: 10 mg/m³**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.convolve.html\n",
    "def moving_average(x, N=8):\n",
    "    return np.convolve(x, np.ones(N)/N, mode='same')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(moving_average(data1[:, 0]), label='2016')\n",
    "\n",
    "plt.plot(moving_average(data2[:, 0]), label='2015')\n",
    "\n",
    "plt.hlines(10, 0, 250, linestyles='--')\n",
    "plt.ylim(0, 11)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* O3\n",
    "    - **Máxima diaria de las medias móviles octohorarias: 120 µg/m3**\n",
    "    - Umbral de información. 180 µg/m3\n",
    "    - Media horaria. Umbral de alerta. 240 µg/m3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(moving_average(data1[:, 2]), label='2016')\n",
    "#plt.plot(data1[:, 2])\n",
    "\n",
    "plt.plot(moving_average(data2[:, 2]), label='2015')\n",
    "#plt.plot(data2[:, 2])\n",
    "\n",
    "plt.hlines(180, 0, 250, linestyles='--')\n",
    "plt.ylim(0, 190)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Scientific functions: SciPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![matplotlib](./static/scipy_logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "scipy.linalg: ATLAS LAPACK and BLAS libraries\n",
    "\n",
    "scipy.stats: distributions, statistical functions...\n",
    "\n",
    "scipy.integrate: integration of functions and ODEs\n",
    "\n",
    "scipy.optimization: local and global optimization, fitting, root finding...\n",
    "\n",
    "scipy.interpolate: interpolation, splines...\n",
    "\n",
    "scipy.fftpack: Fourier trasnforms\n",
    "\n",
    "scipy.signal, scipy.special, scipy.io\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Temperature and precipitation data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we will use some temperature data from Consejeria Agricultura Pesca y Desarrollo Rural Andalucía."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "HTML('<iframe src=\"http://www.juntadeandalucia.es/agriculturaypesca/ifapa/ria/servlet/FrontController?action=Static&url=coordenadas.jsp&c_provincia=4&c_estacion=4\" width=\"700\" height=\"400\"></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The file contains data from 2004 to 2015 (included). Each row corresponds to a day of the year, so evey 365 lines contain data from a whole year*\n",
    "\n",
    "Note1: 29th February has been removed for leap-years.\n",
    "Note2: Missing values have been replaced with the immediately prior valid data.\n",
    "\n",
    "These kind of events are better handled with Pandas!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "!head 'data/tabernas_meteo_data.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data_file = 'data/tabernas_meteo_data.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Loading the data\n",
    "temp_data = np.genfromtxt(data_file, skip_header=2, delimiter=';', usecols=(1,2,3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Importing SciPy stats\n",
    "import scipy.stats as st"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Applying some functions: describe, mode, mean...\n",
    "st.describe(temp_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "st.mode(temp_data.astype(int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.mean(temp_data, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.median(temp_data, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also get information about **percentiles**!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "st.scoreatpercentile(temp_data, per=25, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "st.percentileofscore(temp_data[:,0], score=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "st.percentileofscore(temp_data[:,1], score=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "st.percentileofscore(temp_data[:,2], score=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Rearranging the data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![3d_array](./static/3d_array.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "temp_data2 = np.zeros([365, 4, 15])\n",
    "\n",
    "for year in range(15):\n",
    "    temp_data2[:, :, year] = temp_data[year*365:(year+1)*365, :]\n",
    "    temp_data2[:, :, year] = temp_data2[::-1, :, year]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Calculating mean of mean temp\n",
    "mean_mean = np.mean(temp_data2[:, 2, :], axis=1)\n",
    "# max of max\n",
    "max_max = np.max(temp_data2[:, 0, :], axis=1)\n",
    "# min of min\n",
    "min_min = np.min(temp_data2[:, 1, :], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Let's visualize data! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using matplotlib styles http://matplotlib.org/users/whats_new.html#styles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "plt.style.available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "days = np.arange(1, 366)\n",
    "\n",
    "plt.fill_between(days, max_max, min_min, alpha=0.7)\n",
    "plt.plot(days, mean_mean)\n",
    "plt.xlim(1, 365)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see if 2015 was a normal year..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot(days, temp_data2[:,2,-1], lw=2)\n",
    "plt.plot(days, mean_mean)\n",
    "plt.xlim(1, 365)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.fill_between(days, max_max, min_min, alpha=0.7)\n",
    "plt.fill_between(days, temp_data2[:,0,-1], temp_data2[:,1,-1],\n",
    "                 color='purple', alpha=0.5)\n",
    "plt.plot(days, temp_data2[:,2,-1], lw=2)\n",
    "plt.xlim(1, 365)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, lets represent a function over a 2D domain!\n",
    "\n",
    "For this we will use the contour function, which requires some special inputs..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#we will use numpy functions in order to work with numpy arrays\n",
    "def funcion(x,y):\n",
    "    return np.cos(x) + np.sin(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 0D: works!\n",
    "funcion(3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 1D: works!\n",
    "x = np.linspace(0, 5, 100)\n",
    "plt.plot(x, funcion(x,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib AGAIN, Now with 2D COLOURSSS!!1!1!11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Matplotlib-logo](./static/matplotlib.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, lets represent a function over a 2D domain!\n",
    "\n",
    "For this we will use the contour function, which requires some special inputs..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#we will use numpy functions in order to work with numpy arrays\n",
    "def funcion(x,y):\n",
    "    '''This is the help of the function funcion.\n",
    "    This function receives two parameters and returns another.\n",
    "    Such sicence. Wow.'''\n",
    "    return ????"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 0D: works?\n",
    "funcion(,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 1D: works?\n",
    "x = np.???(0,5, 100)\n",
    "z = funcion(,)\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.plot(x, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In oder to plot the 2D function, we will need a grid.\n",
    "\n",
    "For 1D domain, we just needed one 1D array containning the X position and another 1D array containing the value.\n",
    "\n",
    "Now, we will create a grid, a distribution of points covering a surface. For the 2D domain, we will need:\n",
    "- One 2D array containing the X coordinate of the points.\n",
    "- One 2D array containing the Y coordinate of the points.\n",
    "- One 2D array containing the function value at the points.\n",
    "\n",
    "The three matrices must have the exact same dimensions, because each cell of them represents a particular point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#We can create the X and Y matrices by hand, or use a function designed to make ir easy:\n",
    "\n",
    "#we create two 1D arrays of the desired lengths:\n",
    "x_1d = np.linspace(0, 5, 5)\n",
    "y_1d = np.linspace(-2, 4, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x_1d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y_1d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#And we use the meshgrid function to create the X and Y matrices!\n",
    "X, Y = np.meshgrid(x_1d, y_1d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that with the meshgrid function we can only create rectangular grids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Using Numpy arrays, calculating the function value at the points is easy!\n",
    "Z = funcion(X,Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Let's plot it!\n",
    "plt.contour(X, Y, Z)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can try a little more resolution..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x_1d = np.linspace(0, 5, 100)\n",
    "y_1d = np.linspace(-2, 4, 100)\n",
    "X, Y = np.meshgrid(x_1d, y_1d)\n",
    "Z = funcion(X,Y)\n",
    "plt.contour(X, Y, Z)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The countourf function is simmilar, but it colours also between the lines. In both functions, we can manually adjust the number of lines/zones we want to differentiate on the plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.contourf(X, Y, Z, np.linspace(-2, 2, 6),cmap=plt.cm.Spectral) #With cmap, a color map is specified\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.contourf(X, Y, Z, np.linspace(-2, 2, 100),cmap=plt.cm.Spectral)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#We can even combine them!\n",
    "plt.contourf(X, Y, Z, np.linspace(-2, 2, 100),cmap=plt.cm.Spectral)\n",
    "plt.colorbar()\n",
    "cs = plt.contour(X, Y, Z, np.linspace(-2, 2, 9), colors='k')\n",
    "plt.clabel(cs)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These functions can be enormously useful when you want to visualize something.\n",
    "\n",
    "And remember!\n",
    "\n",
    "## Always visualize data!\n",
    "\n",
    "Let's try it with **Real** data!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "time_vector = np.loadtxt('data/ligo_tiempos.txt')\n",
    "frequency_vector =  np.loadtxt('data/ligo_frecuencias.txt')\n",
    "intensity_matrix =  np.loadtxt('data/ligo_datos.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The time and frequency vectors contain the values at which the instrument was reading, and the intensity matrix, the postprocessed strength measured for each frequency at each time.\n",
    "\n",
    "We need again to create the 2D arrays of coordinates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "time_2D, freq_2D = np.meshgrid(time_vector, frequency_vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6)) #We can manually adjust the sice of the picture\n",
    "plt.contourf(time_2D, freq_2D, intensity_matrix, np.linspace(0, 0.02313, 200), cmap='bone')\n",
    "plt.xlabel('time (s)')\n",
    "plt.ylabel('Frequency (Hz)')\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wow! What is that? Let's zoom into it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "plt.figure(figsize=(10,6))\n",
    "plt.contourf(time_2D, freq_2D,intensity_matrix,np.linspace(0, 0.02313, 200),cmap = plt.cm.Spectral)\n",
    "plt.colorbar()\n",
    "plt.contour(time_2D, freq_2D,intensity_matrix,np.linspace(0, 0.02313, 9), colors='k')\n",
    "plt.xlabel('time (s)')\n",
    "plt.ylabel('Frequency (Hz)')\n",
    "\n",
    "plt.axis([9.9, 10.05, 0, 300])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IPython Widgets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The IPython Widgets are interactive tools to use in the notebook. They are fun and very useful to quickly understand how different parameters affect a certain function.\n",
    "\n",
    "This is based on a section of the PyConEs 14 talk by Kiko Correoso \"Hacking the notebook\": http://nbviewer.jupyter.org/github/kikocorreoso/PyConES14_talk-Hacking_the_Notebook/blob/master/notebooks/Using%20Interact.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from ipywidgets import interact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Lets define a extremely simple function:\n",
    "def ejemplo(x):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "interact(ejemplo, x =10) #Try changing the value of x to True, 'Hello' or ['hello', 'world']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#We can control the slider values with more precission:\n",
    "interact(ejemplo, x = (9, 10, 0.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want a dropdown menu that passes non-string values to the Python function, you can pass a dictionary. The keys in the dictionary are used for the names in the dropdown menu UI and the values are the arguments that are passed to the underlying Python function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "interact(ejemplo, x={'one': 10, 'two': 20})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have some fun! We talked before about frequencys and waves. Have you ever learn about AM and FM modulation? It's the process used to send radio communications!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(-1, 7, 1000)\n",
    "\n",
    "fig = plt.figure()\n",
    "\n",
    "plt.subplot(211)#This allows us to display multiple sub-plots, and where to put them\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.grid(False)\n",
    "plt.title(\"Audio signal: modulator\")\n",
    "\n",
    "plt.subplot(212)\n",
    "plt.plot(x, np.sin(50 * x))\n",
    "plt.grid(False)\n",
    "plt.title(\"Radio signal: carrier\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Am modulation simply works like this:\n",
    "am_wave = np.sin(50 * x) * (0.5 + 0.5 * np.sin(x))\n",
    "plt.plot(x, am_wave)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to interact with it, we will need to transform it into a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def am_mod (f_carr=50, f_mod=1, depth=0.5): #The default values will be the starting points of the sliders\n",
    "    x = np.linspace(-1, 7, 1000)\n",
    "    am_wave = np.sin(f_carr * x) * (1- depth/2 + depth/2 * np.sin(f_mod * x))\n",
    "   \n",
    "    plt.plot(x, am_wave)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "interact(am_mod,\n",
    "        f_carr = (1,100,2),\n",
    "        f_mod = (0.2, 2, 0.1),\n",
    "        depth = (0, 1, 0.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Other options... \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Other packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Symbolic calculations with SymPy "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![sympy](./static/sympy.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy is a Python package for symbolic math. We will not cover it in depth, but let's take a picure of the basics!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Importación\n",
    "from sympy import init_session\n",
    "\n",
    "init_session(use_latex='matplotlib') #We must start calling this function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic unit of this package is the symbol. A simbol object has name and graphic representation, which can be different:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "coef_traccion = symbols('c_T')\n",
    "coef_traccion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "w = symbols('omega')\n",
    "W = symbols('Omega')\n",
    "w, W"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, SymPy takes symbols as complex numbers. That can lead to unexpected results in front of certain operations, like logarithms. We can explicitly signal that a symbol is real when we create it. We can also create several symbols at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x, y, z, t = symbols('x y z t', real=True)\n",
    "x.assumptions0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expressions can be created from symbols:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "expr = cos(x)**2 + sin(x)**2\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simplify(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#We can substitute pieces of the expression:\n",
    "expr.subs(x, y**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#We can particularize on a certain value:\n",
    "(sin(x) + 3 * x).subs(x, pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#We can evaluate the numerical value with a certain precission:\n",
    "(sin(x) + 3 * x).subs(x, pi).evalf(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can manipulate the expression in several ways. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "expr1 = (x ** 3 + 3 * y + 2) ** 2\n",
    "expr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "expr1.expand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can derivate and integrate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "expr = cos(2*x)\n",
    "expr.diff(x, x, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "expr_xy = y ** 3 * sin(x) ** 2 + x ** 2 * cos(y)\n",
    "expr_xy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "diff(expr_xy, x, 2, y, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "int2 =  1 / sin(x)\n",
    "integrate(int2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x, a = symbols('x a', real=True)\n",
    "\n",
    "int3 = 1 / (x**2 + a**2)**2\n",
    "integrate(int3, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also have ecuations and differential ecuations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a, x, t, C = symbols('a, x, t, C', real=True)\n",
    "ecuacion = Eq(a * exp(x/t), C)\n",
    "ecuacion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "solve(ecuacion ,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = symbols('x')\n",
    "f = Function('y')\n",
    "ecuacion_dif = Eq(f(x).diff(x,2) + f(x).diff(x) + f(x), cos(x))\n",
    "ecuacion_dif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dsolve(ecuacion_dif, f(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Analysis with pandas "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![pandas](./static/pandas_logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas is a package that focus on data structures and data analysis tools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Machine Learning with scikit-learn "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![scikit-learn](./static/scikit-learn-logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scikit-learn is a very complete Python package focusing on machin learning, and data mining and analysis. We will not cover it in depth because it will be the focus of many more talks at the PyData."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### A world of possibilities... "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![scikit-learn](./static/cheatsheet-scikit-learn.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ¡Gracias por vuetra atención! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![PyData_logo](./static/pycones2016.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Alguna pregunta?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Notebook style\n",
    "from IPython.core.display import HTML\n",
    "css_file = './static/style.css'\n",
    "HTML(open(css_file, \"r\").read())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}