06-programacion.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programación\n",
    "===\n",
    "\n",
    "**Juan David Velásquez Henao**  \n",
    "jdvelasq@unal.edu.co   \n",
    "Universidad Nacional de Colombia, Sede Medellín  \n",
    "Facultad de Minas  \n",
    "Medellín, Colombia\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "Haga click [aquí](https://github.com/jdvelasq/bash-for-analytics/tree/master/) para acceder al repositorio online.\n",
    "\n",
    "Haga click [aquí](http://nbviewer.jupyter.org/github/jdvelasq/bash-for-analytics/tree/master/) para explorar el repositorio usando `nbviewer`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables y arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las variables en Bash funcionan de forma análoga a las variables en otros lenguajes de programación.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las variables en Bash no necesitan ser declaradas (tal como en el lenguaje C) para ser usadas. Para hacer la asignación se utiliza el símbolo `=`; note que no puede haber espacio alrededor del `=`. En la segunda línea de código es necesario preceder el nombre de la variable por `$` para indicar que var1 es un nombre de variable y no una cadena de texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola mundo\n"
     ]
    }
   ],
   "source": [
    "var1='hola mundo'\n",
    "echo $var1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1\n"
     ]
    }
   ],
   "source": [
    "echo var1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A una variable se le puede asignar el resultado de un comando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola mundo\n"
     ]
    }
   ],
   "source": [
    "x=$(echo hola mundo)\n",
    "echo $x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El shell solo soporta aritmética entera y está diseñado primariamente para operaciones del sistema operativo y cadenas de caracteres, por lo que en el siguiente código lo que se indica es que se están concatenando cadenas de caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1+1\n"
     ]
    }
   ],
   "source": [
    "x=1\n",
    "y=$x+1\n",
    "echo $y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para indicar que se están realizando operaciones aritméticas hay dos opciones: la primera es utilizar el operador `$((` ... `))`  y la segunda es usar el comando `let`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x=1\n",
    "y=$((x+1))\n",
    "echo $y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "let x=1\n",
    "let y=x+1\n",
    "echo $y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El shell soporta los `+=`, `-=`, ... similares a los del lenguaje C. No pueden dejarse espacios alrededor de ellos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "let x=1\n",
    "let x+=1\n",
    "echo $x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bash también permite el uso de arrays. Para crear un array es necesario colocar sus componentes entre `(` y `)`. Note que cuando se imprime con `echo` solo aparece el primer elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n"
     ]
    }
   ],
   "source": [
    "x=(a b c d e)\n",
    "echo $x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a cada uno de los elementos se debe usar el operador `[` ... `]`, teniendo en cuenta que el primer elemento tiene índice cero, el segundo índice uno y así sucesivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n"
     ]
    }
   ],
   "source": [
    "echo ${x[1]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para imprimir todos los elementos se debe usar `[*]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b c d e\n"
     ]
    }
   ],
   "source": [
    "echo ${x[*]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden usar las estructuras de iteración anteriores para recorrer los elementos del vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "for n in ${x[*]}\n",
    "do\n",
    "    echo $n\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los elementos del vector también pueden ser modificados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "hola\n",
      "d\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "x[2]='hola'\n",
    "for n in ${x[*]}\n",
    "do\n",
    "    echo $n\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scripts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los scripts son archivos que contienen secuencias de comandos y que pueden ser ejecutados directamente en la línea de comandos (Bash en este caso). En el siguiente ejemplo, se va a crear un script llamado `demo.sh` el cual imprime `hola mundo` en la pantalla. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se direcciona la salida al archivo en vez de la pantalla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "echo 'echo hola mundo' > demo.sh  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se imprime en pantalla el contenido de demo.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo hola mundo\n"
     ]
    }
   ],
   "source": [
    "cat demo.sh  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El archivo fue creado en el directorio de trabajo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "demo.sh\n"
     ]
    }
   ],
   "source": [
    "ls *.sh  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecutarlo se usa el comando `bash`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola mundo\n"
     ]
    }
   ],
   "source": [
    "bash ./demo.sh  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible hacer que el archivo `demo.sh`  sea ejecutable por el sistema operativo. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En primer lugar, es necesario agregar la linea: \n",
    "\n",
    "    #! /usr/bin/env bash \n",
    "    \n",
    "la cual indica que el archivo actual puede ser ejecutado usando el comando `bash`; obligatoriamente esta tiene que ser la primera línea del archivo.  La cadena de caracteres `#!` se conoce como *shebang*, *hashbang* o *sharpbang* en la jerga de Unix; después del shebang va el `path` donde se encuentra el programa que puede ejecutar el archivo actual; y finalmente, aparece el nombre del programa como tal.       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat > demo <<EOF\n",
    "#! /usr/bin/env bash\n",
    "echo hola mundo\n",
    "EOF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se imprime el contenido de `demo.sh`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#! /usr/bin/env bash\n",
      "echo hola mundo\n"
     ]
    }
   ],
   "source": [
    "cat demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En segundo lugar, se modifican las propiedades del archivo `demo.sh` con el comando `chmod` para hacerlo ejecutable (opción `+x`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "chmod +x demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecutar `demo.sh` es necesario precederlo de `./` para indicar que el archivo se encuentra en el directorio actual de trabajo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola mundo\n"
     ]
    }
   ],
   "source": [
    "./demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La ventaja de los scripts es que pueden ser usados pasándoles parámetros."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso se modifica el programa anterior para que salude al usuario, cuyo nombre se pasa como un parámetro al script. `$1` corresponde al primer argumento de la llamada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat > demo.sh <<EOF\n",
    "#! /usr/bin/env bash\n",
    "echo hola \\$1 \\$2\n",
    "EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#! /usr/bin/env bash\n",
      "echo hola $1 $2\n"
     ]
    }
   ],
   "source": [
    "cat demo.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "chmod +x demo.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola juan david\n"
     ]
    }
   ],
   "source": [
    "./demo.sh juan david"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se observó en el ejemplo anterior: \n",
    "* `$1` indica el primer argumento. \n",
    "* `$2` indica el segundo argumento, y así sucesivamente. \n",
    "* `$0` es el nombre del script. \n",
    "* `$*` y `$@` representan la cadena de texto conformada por todos los argumentos. \n",
    "* `$#` indica el número de argumentos pasados al script. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo $@\n",
      "echo $*\n",
      "echo $0\n",
      "echo $1\n",
      "echo $#\n"
     ]
    }
   ],
   "source": [
    "echo \"echo \\$@\n",
    "echo \\$*\n",
    "echo \\$0\n",
    "echo \\$1\n",
    "echo \\$#\" > demo.sh\n",
    "cat demo.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b c d\n",
      "a b c d\n",
      "demo.sh\n",
      "a\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "bash demo.sh a b c d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Escriba un script que imprima en pantalla la cantidad de registros para cada ciudad en el archivo `customer`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el siguiente ejemplo se crea una función en Bash. Después del nombre de la función siempre se escribe `()` y se delimita el cuerpo de la función usando llaves (`{`  y `}`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "demo(){\n",
    "  echo hola mundo\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecutar la función simplemente se escribe su nombre (sin `()`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola mundo\n"
     ]
    }
   ],
   "source": [
    "demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los argumentos se notan como `$1`... al igual que en los scripts. En este caso `$0` es el `bash` y no se puede acceder al nombre de la función. Note que en la llamada a la función no se usan paréntesis, tal como si ocurre en otros lenguajes de programación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b c d\n",
      "a b c d\n",
      "/bin/bash\n",
      "a\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "demo() {\n",
    "  echo $@\n",
    "  echo $*\n",
    "  echo $0\n",
    "  echo $1\n",
    "  echo $#\n",
    "}\n",
    "demo a b c d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones pueden ser almacenadas y ejecutadas dentro de un script, tal como se muestra a continuación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cat > maxmin.sh <<EOF \n",
    "min2(){\n",
    "    echo 'arg1 (min2): ' \\$1\n",
    "    echo 'arg2 (min2): ' \\$2\n",
    "    if ((\\$1 < \\$2))\n",
    "    then \n",
    "        echo \\$1\n",
    "    else\n",
    "        echo \\$2\n",
    "    fi        \n",
    "}\n",
    "\n",
    "max2(){\n",
    "    echo 'arg1 (max2): ' \\$1\n",
    "    echo 'arg2 (max2): ' \\$2\n",
    "    if ((\\$1 > \\$2))\n",
    "    then \n",
    "        echo \\$1\n",
    "    else\n",
    "        echo \\$2\n",
    "    fi        \n",
    "}\n",
    "\n",
    "max2 \\$3 \\$4\n",
    "min2 \\$1 \\$2\n",
    "EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg1 (max2):  30\n",
      "arg2 (max2):  40\n",
      "40\n",
      "arg1 (min2):  10\n",
      "arg2 (min2):  20\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "bash maxmin.sh 10 20 30 40"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decisión con `if-then-else-fi` y `case-esac`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el siguiente ejemplo se codifica la función `min2` la cual recibe dos números enteros e imprime el menor de ellos. Si ambos números son iguales, se imprimen ambos argumentos. En este ejemplo también se presenta la estructura condicional `if`; para que el condicional sea evaluado correctamente es necesario colocar la expresión entre `((` y `))`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "min2(){\n",
    "    if (($1 < $2))\n",
    "    then \n",
    "        echo $1\n",
    "    elif (($1 == $2))\n",
    "    then\n",
    "        echo $1 $2\n",
    "    else\n",
    "        echo $2\n",
    "    fi        \n",
    "}\n",
    "min2 1 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "min2 2 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2\n"
     ]
    }
   ],
   "source": [
    "min2 2 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente codigo lee los nombres de los archivos del directorio actual e imprime los que son un jupyter notebook. En la primera línea, `*` indica los archivos y directorios en el directorio actual de trabajo.  En la cuarta línea, `*.ipynb` indica que el nombre de archivo (almacenado en `x`) debe terminar en la extensión `.ipynb`. La expresión `*)` en la quinta línea es el caso por defecto (cualquier nombre de archivo), es decir, se ejecuta si no han cumplido ninguna de las instrucciones especificadas por las sentencias `case` anteriores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01-archivos-y-directorios.ipynb  es un Jupyter notebook\n",
      "02-uso-interactivo.ipynb  es un Jupyter notebook\n",
      "03-sed.ipynb  es un Jupyter notebook\n",
      "04-awk.ipynb  es un Jupyter notebook\n",
      "05-sql.ipynb  es un Jupyter notebook\n",
      "06-programacion.ipynb  es un Jupyter notebook\n"
     ]
    }
   ],
   "source": [
    "for x in *\n",
    "do\n",
    "    case $x in\n",
    "        *.ipynb) echo -n -e $x ' es un Jupyter notebook\\n';;\n",
    "        *) \n",
    "    esac\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Escriba una función, llamada `mathop` que recibe tres argumentos y ejecuta el cálculo especificado. Por ejemplo:\n",
    "```\n",
    "mathop 1 + 2\n",
    "mathop 1 * 2\n",
    "mathop 1 - 2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Escriba una función que calcule el factorial de su argumento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Escriba una función que reciba un número variable de argumentos y calcule su suma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ciclos definidos con `for`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continuación se presentan varios ejemplos de procesos iterativos usando `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 "
     ]
    }
   ],
   "source": [
    "# imprime los números del 1 al 5.\n",
    "for x in 1 2 3 4 5  \n",
    "do\n",
    "    echo -n $x ''\n",
    "done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 "
     ]
    }
   ],
   "source": [
    "# el mismo ejemplo anterior.\n",
    "for x in $(seq 1 5) \n",
    "do\n",
    "    echo -n $x ''\n",
    "done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 "
     ]
    }
   ],
   "source": [
    "# de nuevo, el mismo ejemplo anterior\n",
    "for x in {1..5} \n",
    "do\n",
    "    echo -n $x ''\n",
    "done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 "
     ]
    }
   ],
   "source": [
    "# note que la expresión va entre '(('  y '))'\n",
    "for ((x=1; x <= 5; x++))  \n",
    "do\n",
    "  echo -n $x ''\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el siguiente ejemplo se generarán las cadenas de texto `file1.txt`, `file2.txt` ... hasta `file5.txt` usando un ciclo `for`. El nombre de la variable debe encerrarse entre `${` y `}` para distinguirlo del resto de la cadena de texto. Es decir, si se coloca `echo filex.txt` o `echo file$x.txt` el intérprete no puede diferenciar el nombre de la variable (`x`) del texto restante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file1.txt\n",
      "file2.txt\n",
      "file3.txt\n",
      "file4.txt\n",
      "file5.txt\n"
     ]
    }
   ],
   "source": [
    "for x in {1..5} \n",
    "do\n",
    "    echo file${x}.txt\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De hecho, se pueden generar salidas mucho más complejas, tal como se ilustra a continuación (Ok! no se necesita el for para esto, pero es para ejemplificar)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---> file1.txt\n",
      "---> file2.txt\n",
      "---> file3.txt\n",
      "---> file4.txt\n",
      "---> file5.txt\n"
     ]
    }
   ],
   "source": [
    "# el for recibe el resultado de ejecutar la expresión entre '$('  y  ')'.\n",
    "for x in $(seq -f'file%g.txt' 5) \n",
    "do\n",
    "    echo '--->' $x\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el siguiente ejemplo se genera un conjunto de archivos llamados `out.1`, `out.2`, ..., `out.5`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "out.1 out.2 out.3 out.4 out.5\n"
     ]
    }
   ],
   "source": [
    "for x in {1..5}\n",
    "do\n",
    "    seq -f'linea %g' 5 > out.${x}\n",
    "done\n",
    "ls out.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continuación se usa el comando `head` para iterar sobre los archivos e imprimir la primera línea de cada uno de ellos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "linea 1\n",
      "linea 1\n",
      "linea 1\n",
      "linea 1\n",
      "linea 1\n"
     ]
    }
   ],
   "source": [
    "head1(){\n",
    "    for x in out.*\n",
    "    do\n",
    "        head -n 1 $x\n",
    "    done\n",
    "}\n",
    "head1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ciclos condicionales con `while` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El último ejemplo puede ser realizado usando un ciclo `while` en vez de un ciclo `for`. En este caso, el condicional puede ser especificado con la palabra clave `test` o colocando el condicional entre `((` y `))`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file1.txt\n",
      "file2.txt\n",
      "file3.txt\n",
      "file4.txt\n",
      "file5.txt\n"
     ]
    }
   ],
   "source": [
    "n=1\n",
    "while test $n -le 5\n",
    "do\n",
    "    echo file${n}.txt\n",
    "    n=$((n+1))\n",
    "done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file1.txt\n",
      "file2.txt\n",
      "file3.txt\n",
      "file4.txt\n",
      "file5.txt\n"
     ]
    }
   ],
   "source": [
    "n=1\n",
    "while (($n <= 5))\n",
    "do\n",
    "    echo file${n}.txt\n",
    "    n=$((n+1))\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ciclos condicionales con `until`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra forma alternativa es usar un ciclo `until`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file1.txt\n",
      "file2.txt\n",
      "file3.txt\n",
      "file4.txt\n",
      "file5.txt\n"
     ]
    }
   ],
   "source": [
    "n=1\n",
    "until (($n > 5))\n",
    "do\n",
    "    echo file${n}.txt\n",
    "    n=$((n+1))\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el último ejemplo de esta sección, se codifica una función que recibe una lista de enteros e imprime el menor de ellos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "minimum(){\n",
    "    n=$1\n",
    "    for x in $*\n",
    "    do\n",
    "        if test $x -lt $n \n",
    "        then\n",
    "            n=$x\n",
    "        fi\n",
    "    done\n",
    "    echo $n\n",
    "}\n",
    "minimum 6 1 7 5 1 2  5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Escriba una función que genere un número entero consecutivo por cada valor diferente en un campo de un archivo CSV. Uselo en el archivo del ejercicio anterior."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Escriba la función `cpaste` que ejecuta un join cartesiano de dos archvos. Esto es, la primera fila del primer archivo con todas las filas del segundo archivo; luego la segunda fila del primer archivo con todas las filas del segundo archivo y así sucesivamente. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Escriba una función que concatene correctamente dos archivos CSV que tienen las mimas columnas, pero en diferente orden. Usela para concatenar los dos archivos especificados a continuación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cat > out.1 <<EOF\n",
    "   A, B, C\n",
    "   1, 2, 3\n",
    "   4, 5, 6\n",
    "EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cat > out.2 <<EOF\n",
    "   A, C, B\n",
    "   7, 8, 9\n",
    "   10, 11, 12\n",
    "EOF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Verifique que la función del ejercicio anterior opera correctamente con: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cat > out.1 <<EOF\n",
    "   A, B, C\n",
    "   1, 2, 3\n",
    "   4, 5, 6\n",
    "EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cat > out.2 <<EOF\n",
    "   A, C\n",
    "   7, 8\n",
    "   10, 11\n",
    "EOF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Agregue el campo `subtotal` al archivo `orderline` que es calculado como `quantity` * `price`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Agregue el campo `total` al archivo `order` el cual corresponde al valor total de la venta en cada orden. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Agregue el campo `quarter` y sus correspondientes valores al archivo `order`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Genere los archivos `order.` *`CostumerID`*, los cuales contienen las órdenes para cada `CustomerID`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Elimine el campo `Email` del archivo `customer`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Genere un archivo con el total pagado a cada `supplier` (archivo `product`) por año. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Transforme un archivo de CSV a CSV2 (CSV en español)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Transforme un archivo de CSV2 a CSV."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Transforme un archivo CSV a formato de ancho fijo (FAF)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio.--** Tranforme un archivo de ancho fijo (FAF) a CSV."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementación de herramientas escritas en otros lenguajes   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una de las características primordiales del sistema operativo Unix es que los comandos como cat y ls, realmente son programas (almacenados en archivos) que existen en el disco duro del computador y el interprete de comandos los ejecuta en respuesta a las acciones del usuario. Cada uno de estos programas puede estar escrito en un lenguaje de programación y el interprete permite que se ejecuten de una forma transparente. Consecuentemente, la utilidad de la línea de comandos radica en la posibilidad de crear nuevas herramientas con el lenguaje de programación que sea más ventajoso para cada tarea particular, y combinarlas con las herramientas existentes.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herramientas en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como primer ejemplo, se escribirá una herramienta `seq.py` en el lenguaje Python, la cual  recibe como parámetro un entero `n` e imprima la secuencia de `1` hasta `n`. Si se desea una herramientas que funcione de forma similar a los comandos del sistema operativo se obviaría la extensión del archivo. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El primer paso es ubicar el directorio de instalación de Python usando el comando `which`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/jdvelasq/anaconda3/bin/python\n",
      "/Users/jdvelasq/anaconda3/bin/python\n",
      "/usr/bin/python\n"
     ]
    }
   ],
   "source": [
    "which -a python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El resultado anterior indica que hay dos instalaciones de Python en la máquina local. El primer interprete está en el directorio `/Users/jdvelasq/anaconda/bin/python` y el segundo en `/usr/bin/python`. Para determinar que versión de Python se encuentra instalada en cada directorio se llama el interprete con la opción `--version`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.6.3 :: Anaconda, Inc.\n"
     ]
    }
   ],
   "source": [
    "/Users/jdvelasq/anaconda3/bin/python --version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 2.7.10\n"
     ]
    }
   ],
   "source": [
    "/usr/bin/python --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto indica que están instaladas las versiones 3.6.3 y 2.7.10. Ya que el directorio `/Users/jdvelasq/anaconda/bin/python` está en primero en el path de la máquina, cuando se invoca el intérprete se ejecuta Python 3.6.3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la siguiente porción de código se escribe la herramienta `seq.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat > seq.py <<EOF\n",
    "import sys\n",
    "x = int(sys.argv[1])\n",
    "for i in range(x):\n",
    "    print i+1, \n",
    "EOF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La sentencia `import sys` indica que se debe cargar la librería con las funciones del sistema. La variable `sys.argv`  es una lista que contiene los argumentos de la llamada; `sys.argv[0]` es el nombre del programa (`seq.py`) y `sys.argv[1]` es el entero `n`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecutarla es invoca el interprete de Python ubicado en el directorio `/usr/bin/python`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5\n"
     ]
    }
   ],
   "source": [
    "/usr/bin/python seq.py 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para comvertir el programa anterior en una herramienta del sistema operativo, se adiciona el shebang (`#!`) y se cambian las propiedades del archivo para hacerlo ejecutable usando `chmod`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cat > seq.py <<EOF\n",
    "#! /usr/bin/python\n",
    "import sys\n",
    "x = int(sys.argv[1])\n",
    "for i in range(x):\n",
    "    print i+1,\n",
    "    \n",
    "EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "chmod +x seq.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecutar el programa ya no es necesario invocar el interprete de Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "./seq.py 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herramientas en R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También es posible escribir herramientas en R. En este ejemplo se escribirá una herramienta que genere una secuencia de números aleatorios. En primer lugar (al igual que en el caso anterior), se obtiene la ubicación del interprete del lenguaje R para la consola de comandos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/usr/local/bin/Rscript\n"
     ]
    }
   ],
   "source": [
    "which -a Rscript"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seguidamente, se escribe el código en R en el archivo `unif.R` y se cambian las propiedades del archivo para hacerlo ejecutable usando `chmod`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cat > unif.R <<EOF\n",
    "#! /usr/bin/env Rscript\n",
    "args <- commandArgs(trailingOnly=TRUE)  \n",
    "cat(runif(as.numeric(args)), sep='\\n')  \n",
    "EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "chmod +x unif.R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso, y de forma similar al programa escrito en Python, args es una variable que almacena los argumentos con que se llama el programa `unif.R`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este punto ya es posible usar la herramienta para generar secuencias de números aleatorios uniformemente distribuidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8662854\n",
      "0.1127796\n",
      "0.1728782\n",
      "0.3981522\n",
      "0.8000487\n"
     ]
    }
   ],
   "source": [
    "./unif.R 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La potencia de la línea de comandos radica en que el Bash actua como un pegante que permite usar las herramientas escritas en distintos lenguajes. Como siguiente ejemplo, se desea escribir una función en `bash` llamada `randunif` que genere `n` archivos llamados `out.*` los cuales contienen `m` números aleatorios uniformes. Por ejemplo, la llamada `randunif 2 4` genera 2 archivos con 4 números aletorios cada uno. La función `randunif` es codificada en `bash`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "randunif(){\n",
    "    for n in $(seq $1)\n",
    "    do\n",
    "        echo $(./unif.R $2) > aux.${n}\n",
    "        tr ' '  '\\n' < aux.${n} > out.${n}\n",
    "        rm aux.${n}  \n",
    "    done\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continuación se generan los archivos `out.1`, `out.2` y `out.3` con 5 números aleatorios cada uno:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "randunif 3 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9997183\n",
      "0.7211681\n",
      "0.950011\n",
      "0.4199699\n",
      "0.5737943\n"
     ]
    }
   ],
   "source": [
    "cat out.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.02436071\n",
      "0.2348159\n",
      "0.2726424\n",
      "0.6450531\n",
      "0.1602258\n"
     ]
    }
   ],
   "source": [
    "cat out.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1347616\n",
      "0.1091697\n",
      "0.9894775\n",
      "0.05039657\n",
      "0.02610541\n"
     ]
    }
   ],
   "source": [
    "cat out.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Limpieza del directorio de trabajo.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "rm *.sh\n",
    "rm out*\n",
    "rm *.py\n",
    "rm *.R\n",
    "rm demo*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bash para Ciencia de los Datos -- 6 -- Programación\n",
    "===\n",
    "\n",
    "**Juan David Velásquez Henao**  \n",
    "jdvelasq@unal.edu.co   \n",
    "Universidad Nacional de Colombia, Sede Medellín  \n",
    "Facultad de Minas  \n",
    "Medellín, Colombia\n",
    "\n",
    "---\n",
    "\n",
    "Haga click [aquí](https://github.com/jdvelasq/Bash-for-data-science/blob/master/06-programacion.ipynb) para acceder a la última versión online.\n",
    "\n",
    "Haga click [aquí](http://nbviewer.jupyter.org/github/jdvelasq/Bash-for-data-science/blob/master/06-programacion.ipynb) para ver la última versión online en `nbviewer`. \n",
    "\n",
    "---\n",
    "[Licencia](https://github.com/jdvelasq/transformacion-datos-bash/blob/master/LICENCIA.txt)  \n",
    "[Readme](https://github.com/jdvelasq/transformacion-datos-bash/blob/master/readme.md)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cálculos numéricos en punto flotante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta sección es opcional y sirve para ilustrar otros procesos de cálculo en Bash; sin embargo, estas tareas son ejecutadas usualmente en otras herramientas, tal como los lenguajes R o Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(El comando bc no está disponible en Try Jupyter!)\n",
    "\n",
    "\n",
    "Como ya se indicó, Bash solo puede realizar aritmética entera. Para realizar cálculos en punto flotante se debe usar el comando `bc` o el comando `dc`. Se iniciará con `bc`. Para realizar una operación aritmética, como por ejemplo la suma, se debe generar una cadena de la forma `1.0+2.0+3.0`, la cual es pasada a `bc`. El siguiente código muestra como se genera dicha cadena en cada iteración del ciclo `for`. La variable `s` se usa para almacenar la expresión matemática como una cadena de caracteres. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 + 1.1\n",
      "0 + 1.1 + 2.2\n",
      "0 + 1.1 + 2.2 + 3.3\n"
     ]
    }
   ],
   "source": [
    "s=0\n",
    "for x in 1.1 2.2 3.3\n",
    "do\n",
    "    s=$(echo $s \\+ $x)\n",
    "    echo $s\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora se le pasa la cadena almacenada en `s` a `bc`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.6\n"
     ]
    }
   ],
   "source": [
    "s=0\n",
    "for x in 1.1 2.2 3.3 \n",
    "do\n",
    "    s=$(echo $s \\+ $x)\n",
    "done\n",
    "echo $s | bc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra forma sería usar la variable `s` para almacenar la suma parcial, tal como se ejemplifica a continuación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1\n",
      "3.3\n",
      "6.6\n"
     ]
    }
   ],
   "source": [
    "s=0\n",
    "for x in 1.1 2.2 3.3\n",
    "do\n",
    "    s=$(echo $s \\+ $x | bc)\n",
    "    echo $s\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora se puede encapsular el código en una función que sume sus argumentos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.4\n"
     ]
    }
   ],
   "source": [
    "sum(){\n",
    "    s=0\n",
    "    for x in $*\n",
    "    do\n",
    "        s=$(echo $s \\+ $x)\n",
    "    done\n",
    "    echo $s | bc\n",
    "}\n",
    "sum 1.1 2.1 3.1 4.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El comando `dc` es una calculadora de notación postfija. El siguiente código permite sumar los números 1, 2 y 3. Se debe colocar la letra `p` al final para que imprima el resultado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "echo '1 2 + 3 + p' | dc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.4\n"
     ]
    }
   ],
   "source": [
    "sum(){\n",
    "    s=0\n",
    "    for x in $*\n",
    "    do\n",
    "        s=$(echo $s  $x \\+)\n",
    "    done\n",
    "    echo $s ' p'  | dc\n",
    "}\n",
    "sum 1.1 2.1 3.1 4.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programación\n",
    "===\n",
    "\n",
    "**Juan David Velásquez Henao**  \n",
    "jdvelasq@unal.edu.co   \n",
    "Universidad Nacional de Colombia, Sede Medellín  \n",
    "Facultad de Minas  \n",
    "Medellín, Colombia\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "Haga click [aquí](https://github.com/jdvelasq/bash-for-analytics/tree/master/) para acceder al repositorio online.\n",
    "\n",
    "Haga click [aquí](http://nbviewer.jupyter.org/github/jdvelasq/bash-for-analytics/tree/master/) para explorar el repositorio usando `nbviewer`. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Bash",
   "language": "bash",
   "name": "bash"
  },
  "language_info": {
   "codemirror_mode": "shell",
   "file_extension": ".sh",
   "mimetype": "text/x-sh",
   "name": "bash"
  },
  "nbpresent": {
   "slides": {
    "940b5fc9-9cdd-41d7-8372-719403fc2bd2": {
     "id": "940b5fc9-9cdd-41d7-8372-719403fc2bd2",
     "prev": null,
     "regions": {
      "395f31a1-eb6e-4371-acb3-490ee879b8b8": {
       "attrs": {
        "height": 0.2,
        "width": 0.4,
        "x": 0.5,
        "y": 0.7
       },
       "id": "395f31a1-eb6e-4371-acb3-490ee879b8b8"
      },
      "92e1a1f9-4ebc-41a2-bfe8-899c8e794d14": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "id": "92e1a1f9-4ebc-41a2-bfe8-899c8e794d14"
      },
      "ad53a586-a210-4ed7-adb4-961b08e598b8": {
       "attrs": {
        "height": 0.2,
        "width": 0.4,
        "x": 0.1,
        "y": 0.7
       },
       "id": "ad53a586-a210-4ed7-adb4-961b08e598b8"
      },
      "bd4aba0d-fa0b-42e7-81a3-0beac29f2241": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "id": "bd4aba0d-fa0b-42e7-81a3-0beac29f2241"
      },
      "cefb04b2-32f0-4965-923e-1a6b36c37fd8": {
       "attrs": {
        "height": 0.6,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "a4b09f9a-453a-4787-83c4-61a43f75d860",
        "part": "source"
       },
       "id": "cefb04b2-32f0-4965-923e-1a6b36c37fd8"
      }
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}