HerramientasCiencia/HerramientasCiencia.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:6e394a33871f4fcb983705a568c514c4dcb27ec13bcc2dbfe2458718871ef2c5"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Herramientas para hacer ciencia con Python\n",
      "\n",
      "- Hay varias alternativas para la realizaci\u00f3n de calculo num\u00e9rico y modelaci\u00f3n cient\u00edfica con Python, pero quiz\u00e1 la opci\u00f3n mas popular es la combinaci\u00f3n de librer\u00edas:\n",
      "  - numpy\n",
      "  - Scipy\n",
      "  - Matplotlib\n",
      "  \n",
      "- Un curso completo de trabajo num\u00e9rico puede ser accedido libremente, en la pagina\n",
      "https://www.python-course.eu/index.php\n",
      "\n",
      "- El objetivo de los desarrolladores, es hacer de Python una herramienta competitiva frente a sus rivales comerciales. \n",
      "  - En el caso del trabajo num\u00e9rico y an\u00e1lisis de datos, el principal competidor comercial es MATLAB.\n",
      "  - Siendo un software muy bueno y con una gran comunidad de soporte, por el hecho de ser software privativo, MATLAB carga los problemas intr\u00ednsecos de ese tipo de licencias.\n",
      "    - Los algoritmos son de car\u00e1cter privado, y como tal no pueden ser vistos (no hay acceso al c\u00f3digo fuente). Desde el punto de vista cient\u00edfico, esto es malo, puesto que no permite la revisi\u00f3n o peritaje. El usuario se ve obligado a tener fe en que el algoritmo ha sido correctamente implementado.\n",
      "    - El costo de las licencias es realmente alto, luego unicamente personas o grupos con fondos suficientes pueden hacer uso de los algoritmos implementados en MATLAB.\n",
      "    - Hay restricciones en la portabilidad del c\u00f3digo, luego un c\u00f3digo funcional en su maquina, puede no funcionar en otra maquina con una versi\u00f3n diferente del MATLAB\n",
      "    - Modificar el c\u00f3digo no esta permitido.\n",
      "    - Extender la funcionabilidad es dif\u00edcil, por la propia naturaleza de la licencia.\n",
      "    - La sintaxis utiliza par\u00e9ntesis en lugar de corchetes para acceder a los elementos de un arreglo, lo cual va en la direcci\u00f3n contraria del est\u00e1ndar en programaci\u00f3n. Adicionalmente, a  la lectura dicha sintaxis es confusa, pues es la misma que se utiliza para la evaluaci\u00f3n de funciones.\n",
      "  - Python es software de c\u00f3digo abierto y licencia libre. Adicionalmente, tiene caracter\u00edsticas que le hacen competitivo frente a sus rivales.\n",
      "      - Tiene un dise\u00f1o excelente, lo cual le permite tener una sintaxis intuitiva: Es f\u00e1cil llevar los algoritmos al c\u00f3digo.\n",
      "      - Posee mas tipos de datos: listas, tuplas, arreglos, etc... cada cual con sus caracter\u00edsticas que le hacen adecuado para alg\u00fan trabajo en particular.\n",
      "      - Usa espacios de nombre en todos los niveles: Python se estructura por m\u00f3dulos (librer\u00edas), que deben ser importadas antes de utilizar. Cada una con su propio espacio de nombres, lo que evita la anbig\u00fcedad en el uso de funciones.\n",
      "      - Soporta programaci\u00f3n orientada a objetos, lo cu\u00e1l provee un alto nivel de abstracci\u00f3n, que permite escribir de forma simple, l\u00f3gicas complejas."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Instalaci\u00f3n\n",
      "Al ser Python un lenguaje de programaci\u00f3n de proposito general, su instalaci\u00f3n b\u00e1sica no suele incluir los m\u00f3dulos cient\u00edficos por defecto. \n",
      "\n",
      "- Desde linux, instalar es tan f\u00e1cil como buscar los paquetes de numpy, scipy y matplotlib en el administrador de paquetes de la distribuci\u00f3n en uso.\n",
      "- Desde cualquier sistema, los paquetes pueden ser instalados en su ultima versi\u00f3n desde:\n",
      "    - numpy: www.numpy.org\n",
      "    - scipy: www.scipy.org\n",
      "    - matplotlib: www.matplotlib.org\n",
      "- numpy es un requisito para que las otras dos funcionen correctamente."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Que son:\n",
      "\n",
      "- numpy: **Numerical Python** es la librer\u00eda o modulo que contiene las herramientas necesarias para el trabajo num\u00e9rico.\n",
      "- scipy: **Scientifical Python** es definida por sus autores como: *la librer\u00eda fundamenta para el calculo cient\u00edfico*. Contiene herramientas especializadas para integraci\u00f3n, derivaci\u00f3n, interpolaci\u00f3n, ajuste de datos, funciones especiales, etc...\n",
      "- matplotlib: El proyecto se define como: *una herramienta de graf\u00edcaci\u00f3n en 2d para la producci\u00f3n de gr\u00e1ficas con calidad de publicaci\u00f3n en una amplia variedad de formatos e itegrable en ambientes interactivos*.\n",
      "    - El modulo tambi\u00e9n puede graf\u00edcar en 3D (NO renderiza)\n",
      "    - Para usuarios de MATLAB, la librer\u00eda posee una interfaz llamada pylab, que utiliza una sintaxis familiar y facilita la migraci\u00f3n a matplotlib"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# numpy\n",
      "\n",
      "La estructura fundamental en numpy es el arreglo de datos **array**\n",
      "- Un arreglo es una tabla de elementos, todos del mismo tipo.\n",
      "    - Aunque el uso fundamental del arreglo es el almacenamiento de datos num\u00e9ricos, numpy esta preparado para crear arreglos de todo tipo de datos, incluso de arreglos.\n",
      "    - Cada dimensi\u00f3n recibe el nombre de eje (axis).\n",
      "    - El n\u00famero de ejes se llama rango."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "# Un arreglo de rango 1 y longitud 3\n",
      "a=np.array([1,2,3])\n",
      "print(a, type(a))\n",
      "print(a.size, a.shape)\n",
      "a=np.array([[1,2,3],[4,5,6]])\n",
      "print(a.size, a.shape)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1 2 3] <class 'numpy.ndarray'>\n",
        "3 (3,)\n",
        "6 (2, 3)\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Pero podr\u00edamos tener un arreglo con caracteres"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=[\"hola\", \"mundo\"]\n",
      "a= np.array(a)\n",
      "print(a, type(a))\n",
      "print(a.size, a.shape)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['hola' 'mundo'] <class 'numpy.ndarray'>\n",
        "2 (2,)\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Un arreglo de arreglos:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=[np.array([1,2,3]),[\"hola\", \"mundo\"] ]\n",
      "a= np.array(a)\n",
      "print(a, type(a))\n",
      "print(a.size, a.shape)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[array([1, 2, 3]) ['hola', 'mundo']] <class 'numpy.ndarray'>\n",
        "2 (2,)\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Los arreglos son una clase, y como tal tiene atributos y m\u00e9todos a los que podemos acceder\n",
      "- Algunas propiedades \u00fatiles:\n",
      "    - size: el numero de elementos que contiene el array\n",
      "    - ndim: el rango del array (numero de dimensiones o ejes)\n",
      "    - shape: forma en que se distribuyen los elementos\n",
      "    - dtype: tipo de variable que contiene el arreglo"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.max()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 7,
       "text": [
        "6"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lista=[[1,2,3.],[3,2,1]]\n",
      "a=np.array(lista)\n",
      "print(a.size, a.ndim, a.shape, a.dtype)\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "6 2 (2, 3) float64\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 10,
       "text": [
        "array([[ 1.,  2.,  3.],\n",
        "       [ 3.,  2.,  1.]])"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Algunos m\u00e9todos:\n",
      "    - reshape: permite reorganizar los elementos del arreglo en distintas combinaciones\n",
      "    - max: reporta el m\u00e1ximo valor de un arreglo (num\u00e9rico)\n",
      "    - min: el m\u00ednimo.\n",
      "    - mean: el promedio de las entradas del arreglo"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.arange(12)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=(np.arange(12)).reshape(2,6)\n",
      "print(\"matriz 2x6\\n\", a)\n",
      "print(\"matriz 6x2\\n\", a.reshape(6,2))\n",
      "print(\"tensor 3x2x2\\n\", a.reshape(3,2,2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "matriz 2x6\n",
        " [[ 0  1  2  3  4  5]\n",
        " [ 6  7  8  9 10 11]]\n",
        "matriz 6x2\n",
        " [[ 0  1]\n",
        " [ 2  3]\n",
        " [ 4  5]\n",
        " [ 6  7]\n",
        " [ 8  9]\n",
        " [10 11]]\n",
        "tensor 3x2x2\n",
        " [[[ 0  1]\n",
        "  [ 2  3]]\n",
        "\n",
        " [[ 4  5]\n",
        "  [ 6  7]]\n",
        "\n",
        " [[ 8  9]\n",
        "  [10 11]]]\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=np.arange(9).reshape(3,3)\n",
      "print(a)\n",
      "print(a.max(), a.min(), a.mean(), a.trace(), a.diagonal())\n",
      "a.max(axis=1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[0 1 2]\n",
        " [3 4 5]\n",
        " [6 7 8]]\n",
        "8 0 4.0 12 [0 4 8]\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "array([2, 5, 8])"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Crear arreglos\n",
      "\n",
      "- Los arreglos se crean de forma est\u00e1ndar a partir de una lista.\n",
      "- De forma \"inteligente\", Python escoge el tipo de argumento en funci\u00f3n del contenido de la lista"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lista=[1,2,3]\n",
      "a=np.array(lista)\n",
      "a.dtype\n",
      "b=np.linspace(1,4,4)\n",
      "print(b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ 1.  2.  3.  4.]\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Pero se puede especificar el tipo de dato con la opci\u00f3n dtype"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=np.array(lista, dtype=np.float64)\n",
      "a.dtype"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 39,
       "text": [
        "dtype('float64')"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Tambi\u00e9n tenemos funciones auxiliares que ayudan a reservar la memoria en caso de que no se tenga a\u00fan conocido los datos del arreglo, pero si su tama\u00f1o"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# matriz de ceros\n",
      "a=np.zeros((3,2))\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 54,
       "text": [
        "array([[ 0.,  0.],\n",
        "       [ 0.,  0.],\n",
        "       [ 0.,  0.]])"
       ]
      }
     ],
     "prompt_number": 54
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# matriz de unos\n",
      "np.ones((3,3))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 56,
       "text": [
        "array([[ 1.,  1.,  1.],\n",
        "       [ 1.,  1.,  1.],\n",
        "       [ 1.,  1.,  1.]])"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# matriz \"vacia\", queda con la informaci\u00f3n basura que ya se encuentra en la memoria\n",
      "np.empty((2,2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 22,
       "text": [
        "array([[ 0.,  0.],\n",
        "       [ 0.,  0.]])"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Acceso a los elementos de un arreglo.\n",
      "- El acceso es similar a las dem\u00e1s secuencias que soporta Python."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=np.arange(9)\n",
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 23,
       "text": [
        "array([0, 1, 2, 3, 4, 5, 6, 7, 8])"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- El primer elemento se indexa con el cero, y se sigue hasta el ultimo, que tiene indice $n-1$, con $n$ la longitud del arreglo"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# el elemento 4, tiene indice 4-1=3\n",
      "print (a[3])\n",
      "# todos los elementos, desde el primero hasta el indice 3\n",
      "print(a[2:7])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "3\n",
        "[2 3 4 5 6]\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# todos los elementos desde el indice 2 (tercero), hasta el indice $dim-1-2$\n",
      "print(a[2:-2])\n",
      "# El ultimo elemento\n",
      "print(a[-1])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[2 3 4 5 6]\n",
        "8\n"
       ]
      }
     ],
     "prompt_number": 80
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Acceder elementos de 2 en 2"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(a[::2],\"\\n\")\n",
      "# o en un rango\n",
      "print(a[1:-1:3])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0 2 4 6 8] \n",
        "\n",
        "[1 4 7]\n"
       ]
      }
     ],
     "prompt_number": 100
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- En caso de matrices, se admite una notaci\u00f3n mas intuitiva"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=a.reshape(3,3)\n",
      "# El elemento (0,1) primera fila, segunda columna, accedido en forma de lista\n",
      "print(\"la matriz\\n\",a,\"\\n\")\n",
      "print( a[0][1])\n",
      "# se puede acceder de forma mas intuitiva\n",
      "a[0,1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "la matriz\n",
        " [[0 1 2]\n",
        " [3 4 5]\n",
        " [6 7 8]] \n",
        "\n",
        "1\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 27,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# columna 0 (primera)\n",
      "print(a[:,0],\"\\n\")\n",
      "# fila 0\n",
      "print(a[0,:])\n",
      "a[0,1:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0 3 6] \n",
        "\n",
        "[0 1 2]\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 30,
       "text": [
        "array([1, 2])"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Se puede utilizar listas para seleccionar elementos de un arreglo.\n",
      "- Por cada dimensi\u00f3n o eje, se puede incluir una lista"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "lista=[0,2]\n",
      "print(a,\"\\n\")\n",
      "a[[0,2],[1,2]]\n",
      "b=[[1,2],[3,4]]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[0 1 2]\n",
        " [3 4 5]\n",
        " [6 7 8]] \n",
        "\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Copias y vistas\n",
      "- En Python, la memoria del sistema se optimiza creando vistas (o punteros) a las clases, en ves de crear copias."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=np.arange(3)\n",
      "b=a\n",
      "print(a,b)\n",
      "b[0]=10\n",
      "print(a,b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0 1 2] [0 1 2]\n",
        "[10  1  2] [10  1  2]\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Si se requiere una copia real (otro espacio de memoria con la misma informaci\u00f3n), se debe de utilizar el m\u00e9todo copia"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=np.arange(3)\n",
      "b=a.copy()\n",
      "print(a,b)\n",
      "b[0]=10\n",
      "print(a,b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0 1 2] [0 1 2]\n",
        "[0 1 2] [10  1  2]\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Operaciones b\u00e1sicas"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=np.array([1,2,3])\n",
      "b=np.array([4,5,6])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# suma\n",
      "print(\"suma\",a+b)\n",
      "# multiplicaci\u00f3n escalar\n",
      "print(\"dos por \",a,\"es \",2*a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "suma [5 7 9]\n",
        "dos por  [1 2 3] es  [2 4 6]\n"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- numpy define las operaciones y los operadores elemento a elemento:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# vector o arreglo mas un escalar\n",
      "print(\"suma 1 a cada elemento del arreglo\",a+1)\n",
      "# funciones actuando sobre el arreglo\n",
      "print(\"eleva al cuadrado cada elemento\", a**2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "suma 1 a cada elemento del arreglo [2 3 4]\n",
        "eleva al cuadrado cada elemento [1 4 9]\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# las operaciones matriciales requieren el llamado de la funci\u00f3n correspondiente\n",
      "print(\"a*b no es el producto interno,\", a*b, \"es el producto elemento a elemento\")\n",
      "print(\"el producto interno lo realizamos con la funci\u00f3n dot: np.dot(a,b)=\",np.dot(a,b))\n",
      "print(\"producto cruz axb\", np.cross(a,b))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "a*b no es el producto interno, [ 4 10 18] es el producto elemento a elemento\n",
        "el producto interno lo realizamos con la funci\u00f3n dot: np.dot(a,b)= 32\n",
        "producto cruz axb [-3  6 -3]\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Funciones matem\u00e1ticas b\u00e1sicas"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# basicas sin, cos, tan, arcsin, log, etc...\n",
      "print( np.sin(a) )\n",
      "print (np.exp(a) )"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ 0.84147098  0.90929743  0.14112001]\n",
        "[  2.71828183   7.3890561   20.08553692]\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Implementaci\u00f3n de calculo en los complejos\n",
      "- numpy viene preparado para trabajar en variable compleja"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a=a+b*1j"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.sin(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "array([ 22.97908558 +14.74480519j,  67.47891524 -30.87943134j,\n",
        "        28.46611220-199.69451226j])"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print( np.real(a), np.imag(a))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ 1.  2.  3.] [ 4.  5.  6.]\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a.conj()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 23,
       "text": [
        "array([ 1.-4.j,  2.-5.j,  3.-6.j])"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## \u00c1lgebra lineal\n",
      "- numpy viene con un sub m\u00f3dulo de \u00e1lgebra lineal."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.linalg?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 26
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Scipy\n",
      "El m\u00f3dulo scipy es una colecci\u00f3n de algoritmos y funciones especiales, de uso habitual en ciencia. Esta librer\u00eda esta construida sobre numpy.\n",
      "\n",
      "Los sub m\u00f3dulos de scipy:\n",
      "\n",
      "- cluster: Algoritmos para creaci\u00f3n y manejo de clusters\n",
      "- constants: constantes f\u00edsicas y matem\u00e1ticas predefinidas.\n",
      "- fftpack: Rutinas que implementan la transformada de fourier en varios algoritmos.\n",
      "- integrate: integraci\u00f3n num\u00e9rica.\n",
      "- interpolate: Interpolaci\u00f3n \n",
      "- io: entrada y salida de datos\n",
      "- linalg: \u00e1lgebra lineal a trav\u00e9s de LAPACK y BLAS\n",
      "- ndimage: Manejo de imagenes\n",
      "- odr: orthogonal distance regression\n",
      "- optimize: optimizaci\u00f3n y busqueda de ra\u00edces.\n",
      "- signal: procesamiento de se\u00f1ales\n",
      "- sparce: rutinas optimizadas para matrices sparce\n",
      "- special: implementaci\u00f3n de funciones especiales\n",
      "\n",
      "Los sub m\u00f3dulos deben ser importados por separado."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Integraci\u00f3n\n",
      "\n",
      "- Podemos obtener un resumen de las funciones del modulo mediante la ayuda de Ipython o el comando help"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import scipy as sc\n",
      "import scipy.integrate as scint"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 38
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Ejemplos ilustrativos.\n",
      "\n",
      "- Integraci\u00f3n de funciones de una sola variable con quad "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "scint.quad?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 40
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(x):\n",
      "    return x**2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 41
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "scint.quad(f,0,1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 42,
       "text": [
        "(0.33333333333333337, 3.700743415417189e-15)"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- La rutina soporta la integraci\u00f3n entre $\\pm \\infty$, si la funci\u00f3n es de cuadrado integrable"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(x):\n",
      "    return np.exp(-x**2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 43
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "scint.quad(f, -np.inf, +np.inf)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 44,
       "text": [
        "(1.7724538509055159, 1.4202636780944923e-08)"
       ]
      }
     ],
     "prompt_number": 44
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### ODE Problema de valores iniciales"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- scipy implementa la rutina odeint, para integrar sistemas de ecuaciones diferenciales de primer orden\n",
      "$$\n",
      "\\frac{\\text{d} \\mathbf{y}}{\\text{d} t} = \\mathbf{f}(\\mathbf{y}, t)\n",
      "$$\n",
      "\n",
      "- Como ejemplo, considere el sistema de ecuaciones diferenciales:\n",
      "\\begin{align}\n",
      "    \\frac{\\text{d} x}{\\text{d} t} = v, &&& \\frac{\\text{d} v}{\\text{d} t} = - \\omega^2 x\n",
      "\\end{align}"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# definimos el vector de funciones derivada\n",
      "def f(y,t):\n",
      "    omega= 1\n",
      "    return np.array([y[1], - omega * y[0]])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 45
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# debemos especificar los tiempos en los que queremos tener evaluada las funciones\n",
      "tiempos= np.linspace(0,10,1000)\n",
      "# Planteamos una condici\u00f3n inicial\n",
      "yo=np.array([0,1])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 46
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "y= scint.odeint(f,yo,tiempos)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 48
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 49,
       "text": [
        "array([[ 0.        ,  1.        ],\n",
        "       [ 0.01000983,  0.9999499 ],\n",
        "       [ 0.02001867,  0.99979961],\n",
        "       ..., \n",
        "       [-0.5271149 , -0.8497942 ],\n",
        "       [-0.5355948 , -0.84447529],\n",
        "       [-0.54402103, -0.83907176]])"
       ]
      }
     ],
     "prompt_number": 49
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Esto nos da los valores del sistema $(x,v)$ para los tiempos solicitados"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Visualizaci\u00f3n de datos con matplotlib\n",
      "\n",
      "Para ver el resultado de la integraci\u00f3n anterior de una forma mas clara, podemos hacer una gr\u00e1fica. El m\u00f3dulo matplotlib es indicado para esto."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import matplotlib.pylab as plt\n",
      "plt.plot(tiempos,y)\n",
      "label=[\"x\",\"v\"]\n",
      "plt.legend(label)\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 50
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Optimizaci\u00f3n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import scipy.optimize as scopt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 55
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "scopt.minimize?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Minimizaci\u00f3n\n",
      "def f(x):\n",
      "    return (x-2)**2\n",
      "\n",
      "scopt.minimize(f, 10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 66,
       "text": [
        "      fun: 5.552228233152667e-17\n",
        " hess_inv: array([[ 0.5]])\n",
        "      jac: array([ -1.49391610e-12])\n",
        "  message: 'Optimization terminated successfully.'\n",
        "     nfev: 12\n",
        "      nit: 2\n",
        "     njev: 4\n",
        "   status: 0\n",
        "  success: True\n",
        "        x: array([ 1.99999999])"
       ]
      }
     ],
     "prompt_number": 66
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## M\u00ednimos cuadrados y ajuste no lineal"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def f(x):\n",
      "    return np.exp(-(x-2)**2/2) + 0.1*(np.random.rand(len(x)) - 0.5)\n",
      "def f2(x):\n",
      "    return np.exp(-(x-2)**2/2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 57
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "xx=np.linspace(-4,7,300)\n",
      "y=f(xx)\n",
      "plt.plot(xx,y,\"r.\")\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 58
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Definimos la funci\u00f3n de ajuste"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def modelo(x, a, b, c):\n",
      "    return a*np.exp( -b* (x-c)**2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 53
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "opt_fun=scopt.curve_fit(modelo,xx,y)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 59
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Ahora comparamos la curva con los datos experimentales"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a,b,c=opt_fun[0]\n",
      "x2=np.linspace(-4,7,1500)\n",
      "plt.plot(x2, modelo(x2,a,b,c), \"k-\", label=\"modelo\")\n",
      "plt.plot(xx,y,\"r.\", label=\"experimento\")\n",
      "plt.plot(x2, f2(x2), label=\"real\")\n",
      "plt.legend()\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 60
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}