1_Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Métodos Númericos\n",
    " + Universidad Tenológica de Panamá\n",
    " + por Stephen Krol\n",
    "<img src=\"Images/FIMLOGO.png\" width=\"100\" height=\"100\" />\n",
    "<img src=\"Images/planeFEM.jpg\" width=\"200\" height=\"100\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 1. Introducción\n",
    "\n",
    "El curso de métodos númericos propone visitar métodos númericos importantes para cada seccion del analisis numerico previamnte expuesto en el contenido del curso, y en el proceso desarrollar la filosofia detras da cada método, y su intución en el desarrollo. En este curso seguiremos un orden natural desde los métodos mas sencillos para buscar raices hasta metodos para ecuaciones diferenciales parciales. Para desarrollar los metodos numericos tenemos que entender la comportamineto de los numeros reales, y su aproximación finita como el caso de los numeros de coma flotante ademas de otros topicos introductorios que se expondran en esta sección.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 1.1 Contenido\n",
    "### Resumen\n",
    "\n",
    "Numerical analysis is the study of algorithms that use numerical approximation (as opposed to general symbolic manipulations) for the problems of mathematical analysis (as distinguished from discrete mathematics). Numerical analysis naturally finds application in all fields of engineering and the physical sciences, but in the 21st century also the life sciences, social sciences, medicine, business and even the arts have adopted elements of scientific computations. As an aspect of mathematics and computer science that generates, analyzes, and implements algorithms, the growth in power and the revolution in computing has raised the use of realistic mathematical models in science and engineering, and complex numerical analysis is required to provide solutions to these more involved models of the world.\n",
    "\n",
    "### Objetivos\n",
    "\n",
    "Implementar y diseñar diferentes algoritmos para resolver modelos comunmente utilizados en la inegnieria mecanica.\n",
    "Aprender a implenetar algoritmos en un lenguaje de programación real, analizar su implmentacion. Preparara graficas con calidad de publicación. Resolver los métodos númericos de forma manual. Aplicar los metodos númericos a problemas aplicados en la ingeniería mécanica.\n",
    "\n",
    "### Contenido Resumido\n",
    "\n",
    " 1. **Introducción (intro)** _(1 Semana)_\n",
    " 2. **Raices (root)**  _(2 semana)_\n",
    " 3. **Sistemas de ecuaciones lineales (Lin alg)** _(3 semana)_\n",
    " 4. **Calculo diferencial (diff/int)** _(6 semana)_\n",
    " 6. **Interpolación** _(10 semana)_\n",
    " 7. **Ecuaciones diferenciales Parciales (PDE)** _(11 y 12 semana)_\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Contenido Expandido\n",
    "\n",
    " 1. **Introducción (intro)** _(1 Semana)_ [link](#)\n",
    " \n",
    "   * Contenido, Resumen y Objetivos.\n",
    "   * Horario, Metodologia, Planificación, Calificaciones y Literatura.\n",
    "   * Introducción a Python, Jupyter, Numpy y Matplotlib.\n",
    "   * Sistemas Numericos.\n",
    "   * Error numerico\n",
    "   * Practicas   \n",
    "   \n",
    "   \n",
    " 2. **Raices (root)**  _(2 semana)_ [link](2_Raices.ipynb)\n",
    " \n",
    "     - Introducción a Busqueda de Raices.\n",
    "     - Raices Reales.\n",
    "     - Metodo de Biseccion.\n",
    "     - Metodo de Posición Falsa.\n",
    "     - Metodo de Secante\n",
    "     - Metodo de Newton-Rhapson\n",
    "   * Raices Complejas\n",
    "     - Bairstow\n",
    "     - Muller\n",
    "   * Raices de polinomios\n",
    "     - Metodo de Muller\n",
    "     \n",
    "     \n",
    " 3. **Sistemas de Ecuaciones Lineales (Lin alg)** _(3 semana)_ [link](3_SistemasLineales.ipynb)\n",
    " \n",
    "   * Sistema de ecuaciones lineales y notación matricial\n",
    "     - Sistema de Ecuaciones\n",
    "     - Rango e Independencia Lineal.\n",
    "     - Matrices y Vectores\n",
    "     - Matriz Aumentada\n",
    "   * Transformaciones Lineales\n",
    "     - Scala, Rotacion, identidad e inversa.\n",
    "   * Métodos Directos\n",
    "     - Reduccion gaussiana\n",
    "     - Metodo Gauss-Jordan\n",
    "     - Calculo de la inversa\n",
    "   * Metodos Iterativos\n",
    "     - Metodo Gauss-Seidel.\n",
    "     - Metodo de Jacobi.\n",
    "   * Otros\n",
    "     - Descomposicion LU\n",
    "     - Descoomposicion Espectral\n",
    "     - Sistemas esparcidos, y metodos de iteracion.\n",
    "     \n",
    "     \n",
    " 4. **Calculo diferencial (diff/int)** _(6 semana)_\n",
    " \n",
    "   * Derivación Númerica\n",
    "     - Series de taylor\n",
    "     - Diferenciación de primer orden y segundo orden\n",
    "     - Formulacion general\n",
    "   * Integración Númerica\n",
    "     - Interal de Riemann\n",
    "     - Regla de Simpson\n",
    "     - Metodo de Euler\n",
    "     \n",
    " 5. **Ecuaciones Diferenciales Ordinarias (ODE)** _(7 semana)_\n",
    " \n",
    "   * Ecuaciones Ordinarias de Primer Orden  \n",
    "     - Método de euler\n",
    "     - Método Runge-Kutta\n",
    "       + Primer Orden\n",
    "       + Cuarto Orden\n",
    "   * Sistema de Ecuaciones Diferenciales Ordinarias \n",
    "     - Método de Euler\n",
    "     - Método Runge-Kutta\n",
    "       + Primer Orden\n",
    "       + Cuarto Orden\n",
    "       \n",
    " 6. **Interpolación y Regresión** _(10 semana)_\n",
    " \n",
    "   * Interpolacón\n",
    "       * Interpolacion Lineal y Cuadratica.\n",
    "       * Polinomios de Lagrange\n",
    "       * Polinomios de Legendre\n",
    "       * Aproximacion de Taylor\n",
    "       * Aproximacion de Fourier\n",
    "   * Regresión\n",
    "       * Regresion Lineal\n",
    "       * Métodos de Minimos Cuadrados\n",
    "       * Regresión No Lineal\n",
    "   \n",
    "   \n",
    " 7. **Ecuaciones diferenciales Parciales (PDE)** _(11 y 12 semana)_\n",
    " \n",
    "   * Introducción\n",
    "     - Clasificacion y tipos\n",
    "     - Condiciones de frontera\n",
    "     - Estabilidad, consistencia y convergencia.\n",
    "   * Sistemas  Ellipticos\n",
    "     - Esquemas centrales\n",
    "     - Soluciones iterativas\n",
    "   * Sistemas Parabolicos\n",
    "     - Crank-Nicholson\n",
    "     - Analisis de Stabilidad\n",
    "   * Systemas Hyperbolicos\n",
    "     - Esquemas de marcha\n",
    "     - Analisis de Estabilida\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2  Planeación y Horarios\n",
    "\n",
    "Semana 4: Repaso y practicas\n",
    "\n",
    "1. Examen parcial numero 1 (5semana)\n",
    "  * ( 1. Introduccion, 2 Raices, 3 Systemas Lineales)\n",
    "\n",
    "Semana 8: Repaso y Practicas  \n",
    "  \n",
    "2. Examen parcial numero 2 (9semana)\n",
    "  * ( 4. derivacion e integracion numerica 5. Ecuaciones diferenciales)\n",
    "\n",
    "Semana 13: Repaso y Practicas\n",
    "\n",
    "3. Examen parcial numero 3 ( 14 semana)\n",
    "  * ( 6. Interpolacion, 7 Ec. Dif. PArciales)\n",
    "\n",
    "Semana 15: Practicas Finales\n",
    "\n",
    "+ Examen Semestral \n",
    "  * (Newton-Rhapson, Gauss-Jordan, Diferenciacion, Regla de simpson, Metodo Runge-Kutta 4°, Polinomio da lagrange, Metodos para sistemas Elipticos)\n",
    "\n",
    "\n",
    "## Competencias a desarrollar\n",
    "+ Habilidad de pensamiento analitico.\n",
    "+ Pensamiento algorithmico. Solucion de problemas por medio de algoritmos y secuencias de operaciones. \n",
    "+ Procesamiento de datos por medio de software.\n",
    "+ Automatizacion de procesos y tareas.\n",
    "+ Contruccion de software personalizado.\n",
    "+ Diseño y desarrolo de software\n",
    "+ Aplicacion de metodos numericos pararesolver prblemas en ingenieria.\n",
    "\n",
    "\n",
    "## Literatura\n",
    "\n",
    "#### Libro de texto:\n",
    "* Chapra, Canale, Introducción a los Métodos Númericos para la Ingeniería. McGraw-Hill 2016.\n",
    "\n",
    "#### Referencias:\n",
    "* R. Burden y  J. D. Faires ; Análisis Numérico 9na edicion.\n",
    "* Hamming, R. W. ; Numerical Methods for Scentist and Engineers. Second Edition. Dover Publications.\n",
    "* Nakamura ; Metodos Numericos Aplicados Con Software\n",
    "\n",
    "#### Extras:\n",
    "+ Tutorial de Python (en español): http://docs.python.org.ar/tutorial/3/index.html\n",
    "+ Tutorial de IPython(en ingles), proyecto padre de Jupyter: https://ipython.readthedocs.io/en/stable/interactive/tutorial.html\n",
    "+ Tuotrial completo de Python para ciencia (en ingles) : https://www.scipy-lectures.org/intro/index.html\n",
    "\n",
    "#### Ejemplos de Note book en la \"nube\"\n",
    "+ Microsoft: https://notebooks.azure.com/\n",
    "+ Google: https://colab.research.google.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calificaciones\n",
    "| Calificación       |  Porcetanje  |    descripción          |\n",
    "|--------------------|--------------|-------------------------|\n",
    "| Total de examenes  |  **45%**     |_Cada examen parcial 15%_|\n",
    "| Tareas y Practicas |  10%         |_dos tarea y tres practicas_|\n",
    "| Laboratorios       |  15%         |_se detallara en el laboratorio_     |\n",
    "|  |  |  |\n",
    "| Semestral          | **30%**      |   Examen Final           |\n",
    "| ____ | ____  |________|\n",
    "|Total $\\sum$        | ***100%***   |           ---            |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Nota final: 70\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo de calificaciones \n",
    "examenes    = [57, 84, 75]\n",
    "tareas      = [100, 100, 100, 0, 100]\n",
    "#tareas      = [0, 0, 0, 0, 0]\n",
    "laboratorio = [89]\n",
    "semestral   = [68]\n",
    "\n",
    "total = sum(examenes)/3.0*(.45) + sum(tareas)/5.0*(.1) + sum(laboratorio)*(.1) + sum(semestral)*(0.30)\n",
    "print(\" Nota final: %.0f\"%(total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Metodología\n",
    "En el procesos de enseñanza utilizaremos un libro interactivo (jupyter notebook) el cual es un conjunto de celdas. Cada celda puede ser de dos tipo diferente: texto o \n",
    "Como prime paso es la definicion del problema, se expondra un ejemplo tipo caso, donde un problema general y abstracto sin contexto se expondra y despues si es posible resolver de fomrma analitica. Despues crear la intucion detras del metodo numerico y desarrollar el algoritmo.\n",
    "Los métodos numericos se pueden derivar del analisis numerico. Despues podemos definir un algoritmo que implementa la solución. Por ultimo este algoritmo normalmente se documenta en un diagrama de flujo, pseudocodigo o codigo fuente en algun lenguaje de programación. \n",
    "\n",
    "#### Formato de tarea y practicas\n",
    "Para enterga de tarea por favor no crear pagina de presentación, utilizar una cabecera para ahorrar papel. Y no crear pagias nuevas entre secciones. utilizar un formato de reporte para ahorrar papel.\n",
    "##### Cabecera\n",
    "* Universidad - Facultad - Carrera <br>\n",
    "* Asignatura - codigo de asignatura - instructor <br>\n",
    "* Titulo - Tarea # N - fecha<br>\n",
    "* Nombre apllellido - cedula - codigo de grupo \n",
    "\n",
    "#### Secciones\n",
    "* Cabecera.\n",
    "* Cotenido (outline).\n",
    "* Cuerpo.\n",
    "\n",
    "##### Espesificaciones\n",
    "Espaciado simple, tipografia \"sans serif\" como Helvetica o Arial. Sin multiple espacios epacios entre secciones. \n",
    "\n",
    "### Definiciones Basicas\n",
    "+ *Método Númerico* : Algoritmo para solucionar un problema\n",
    "+ *Algoritmo* : Secuencia de pasos finitos. Que resuelven un problema.\n",
    "+ *Iteración* : ...\n",
    "+ *Lenguaje de programación*: nos permite implemntar un algoritmo para ejecutar en un computadora\n",
    "+ *Python*: lenguaje de proposito general, interpretado y de alto nivel.\n",
    "+ *Librerias* : Conjunto de funciones, clases y tipos predefinidos y documentados para que extienden el lenguaje de programacion\n",
    "+ *Libreria estandard de Python* : Librería de proposito general,, para entrada y salida de datos.\n",
    "+ *Numpy* : Libreria dePython para manejo de arreglos, vectores y matrices.\n",
    "+ *Matplotlib* : libreria de python para graficar.\n",
    "+ *Scipy* : Libreria de python con metodos numericos implementados profesionalmente listos para usar.\n",
    "+ *Notebook*: metafora de computacion para la creacion de documentos interactivos, usado en software comerciales como Mathematica, Maple, MathCAD y software libres como wxMaxima y Jupyter o IPython.\n",
    "+ *Jupyter* : Entorno de desarrollo para python utiliza el concepto de notebooks por medio de explorador, y un servidor local o remoto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introducción a Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para poder importar un modeulo dentro de las librerias en Python utilizamos la palabra reservada `import` seguida del nombre de modulo. Por ejemplo, el modulo `math` contiene las funciones mathematicas `sin` y `cos`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y para utilizar estas funciones basta utilizar las funciones dentro de el modulo tenmos que escribir el nombre del modulo despues el acceso del modulo utilizamos el operador `.` (punto) seguido del nombre de la funcion, en este caso sin. Para llamar la función utilizamos el operador de llamado `()`. Por ejemplo  para calcular el seno de $\\frac{1}{2}$ podemos escribir `math.sin(.5)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.479425538604203"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para importar los modulos principales podemos crear un alias para no tener que escribir el nombre completo del modulo, podemos importarlo como `import modulo as alias`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Esto es un comentraio y va a ser ignorado\n",
    "# Variables definicion y asignacion\n",
    "x = 2 \n",
    "Pi = 3.1416\n",
    "diametro = 15\n",
    "titulo = \"Cálculo de area\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de x\n",
      "2\n",
      "Cálculo de area\n"
     ]
    }
   ],
   "source": [
    "# Mostrar en la consola\n",
    "print(\"El valor de x\")\n",
    "print(x)\n",
    "print(titulo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Conocer los tipos de datos\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "333\n"
     ]
    }
   ],
   "source": [
    "#convertir tipos de datos\n",
    "x = int(\"333\")\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "9\n",
      "64\n",
      "0.4\n",
      "1024\n"
     ]
    }
   ],
   "source": [
    "#Operaciones aritmeticas para tipos numericos( int, float)\n",
    "# suma\n",
    "print(2+6)\n",
    "#resta\n",
    "print(10-1)\n",
    "#multiplicacion\n",
    "print(16*4)\n",
    "#Division\n",
    "print(4/10)\n",
    "#expo\n",
    "print(2**10)\n",
    "\n",
    "#Asignacion y operacion \n",
    "area = Pi*(diametro/2)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola -  mundo!\n",
      "2\n",
      "Hola -  mundo!\n"
     ]
    }
   ],
   "source": [
    "# Operaciones con cadenas (str)\n",
    "#Concatenacion\n",
    "cad1 = \"hola - \"\n",
    "cad2 = \" mundo!\"\n",
    "cad_total = cad1 + cad2\n",
    "print(cad_total)\n",
    "\n",
    "#Contar las o\n",
    "print(cad_total.count('o'))\n",
    "\n",
    "#Invitamos a copiar el nombre de la variable y colocar el \n",
    "#operador punto y presionra la tecla TAB para explorar \n",
    "#los diferentes metodos de str\n",
    "\n",
    "#Capitalizar\n",
    "print(cad_total.capitalize())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "manzana\n",
      "['manzana', 'Uvas', 'pera']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Pera'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Listas\n",
    "\n",
    "#creacion con [] y seprara elementos (objetos) con ,\n",
    "canasta = [\"manzana\", \"aguacate\", \"pera\"]   # En este caso es un alista de Str\n",
    "\n",
    "\n",
    "#acceder al primer elemento\n",
    "print(canasta[0])\n",
    "\n",
    "#cambiar el segundo elemento\n",
    "canasta[1] = \"Uvas\"\n",
    "\n",
    "#mostrar la lista entera\n",
    "print(canasta)\n",
    "\n",
    "#capitalizar el primer y ultimo elemento\n",
    "canasta[0].capitalize()\n",
    "canasta[-1].capitalize() # -1 se refiere al ultimo elmento, 2 tambien es valido\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-e0b0834b3e00>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Vamos a causar un error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcanasta\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# Vamos a causar un error\n",
    "print(canasta[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Cuantos elementos tiene?\n",
    "len(canasta)   #Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "<class 'bool'>\n",
      "True\n",
      "False\n",
      "True\n",
      "Es mayor de edad? False\n",
      "Es mayor de edad? True\n"
     ]
    }
   ],
   "source": [
    "# Tipos booleanos \n",
    "print(True)\n",
    "print(False)\n",
    "print(type(True))\n",
    "\n",
    "#Operaciones en tipos booleanos\n",
    "verdadero = True\n",
    "print(verdadero)\n",
    "print(not verdadero)\n",
    "print(not not verdadero)\n",
    "\n",
    "#Operaciones que producen booleanos a partir de otros tipos\n",
    "edad = 15\n",
    "resultado = edad >= 18\n",
    "print(\"Es mayor de edad? \" + str(resultado))\n",
    "\n",
    "edad = 25\n",
    "resultado = edad >= 18\n",
    "print(\"Es mayor de edad? \" + str(resultado))\n",
    "\n",
    "# < menor que , > mayor que, == igual que, etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Felicidades eres mayor de edad.\n"
     ]
    }
   ],
   "source": [
    "# Ejecucion condicional\n",
    "\n",
    "edad = 19\n",
    "resultado = edad >= 18\n",
    "\n",
    "if resultado == True :\n",
    "    print(\"Felicidades eres mayor de edad.\")\n",
    "else:\n",
    "    print(\"No eres mayor de edad.\")\n",
    "\n",
    "# if condicion:\n",
    "#    bloque de codigo a ejecutar si condicion es True\n",
    "# else:\n",
    "#    en condicion contraria, osea False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La suma de los numeros enteros de 0 a 10\n",
      "es :55\n"
     ]
    }
   ],
   "source": [
    "# Ejecucion repetida\n",
    "# introduccion al concepto de flujo de ejecucion linea a linea como un cursor\n",
    "\n",
    "final = 10\n",
    "print(\"La suma de los numeros enteros de 0 a \" + str(final))\n",
    "\n",
    "contador = 0\n",
    "acumulador = 0\n",
    "\n",
    "while contador <= final: \n",
    "    acumulador = acumulador + contador\n",
    "    contador = contador + 1\n",
    "    #print(\"acumulador: \" + str(acumulador))\n",
    "\n",
    "print(\"es :\" + str(acumulador))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "manzana\n",
      "Uvas\n",
      "pera\n"
     ]
    }
   ],
   "source": [
    "#Iteracion de iterable( o listas)\n",
    "\n",
    "for fruta in canasta:\n",
    "    print(fruta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manzana fresca\n",
      "Uvas fresca\n",
      "Pera fresca\n"
     ]
    }
   ],
   "source": [
    "for fruta in canasta:\n",
    "    print(fruta.capitalize() + \" fresca\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manzana fresca\n",
      "Uvas frescas\n",
      "Pera fresca\n"
     ]
    }
   ],
   "source": [
    "# combinacion de algunas estrucutra de control de flujo\n",
    "for fruta in canasta:\n",
    "    if fruta[-1] == 's':\n",
    "        print(fruta.capitalize() + \" frescas\")\n",
    "    else:\n",
    "        print(fruta.capitalize() + \" fresca\")        \n",
    "        \n",
    "# Sorpresa las cadenas son listas de caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mandarina fresca\n",
      "Sandias frescas\n"
     ]
    }
   ],
   "source": [
    "# IMPORTANTE!: definicion de funciones\n",
    "\n",
    "def procesar_fruta(frut):\n",
    "    if frut[-1] == 's':\n",
    "        return frut.capitalize() + \" frescas\"\n",
    "    else:\n",
    "        return frut.capitalize() + \" fresca\"\n",
    "\n",
    "print(procesar_fruta(\"Mandarina\"))\n",
    "print(procesar_fruta(\"Sandias\"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manzana fresca\n",
      "Uvas frescas\n",
      "Pera fresca\n"
     ]
    }
   ],
   "source": [
    "#reutilizacion de una funcion previamente definida\n",
    "for fruta in canasta:\n",
    "    print(procesar_fruta(fruta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Funciones  matematicas\n",
    "import math\n",
    "\n",
    "math.sin(math.pi/2)  #sin(90°)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tarea: definir una funcion que transforme grados a radianes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "#Extra milla\n",
    "#Creacion de lista por rangos\n",
    "\n",
    "lista_de_numeros_0_100 = list(range(0,11))\n",
    "print(lista_de_numeros_0_100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#suma de los elementos de una lista\n",
    "sum(lista_de_numeros_0_100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Tarea como implementar la funcion sum?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "{'nombre': 'Stephen', 'apellido': 'Krol', 'edad': 28}\n",
      "Stephen\n"
     ]
    }
   ],
   "source": [
    "#Tuplas\n",
    "tupla = (1,2,3)\n",
    "print(tupla)\n",
    "\n",
    "#Diccionarios\n",
    "persona1 = {\"nombre\": \"Stephen\", \"apellido\": \"Krol\", \"edad\":28} \n",
    "print(persona1)\n",
    "print(persona1[\"nombre\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduccion a numpy\n",
    "Libreria para manejo de arreglos(vectores y matrices). Es importante mecionar que para manejo numerico es mas eficiente utilizar objetos tipo ndarray que listas.\n",
    "Por lo tanto para manejo de vectores y matrices sufuientemente grandes utilizaremos `np.array([])` para construir arreglos numericos. Ademas obtenemos muchas operacion predefinidas en la libreria, como producto punto, producto cruz y operaciones matriciales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = np.array([1,2,3], dtype=np.int)\n",
    "b = np.array([2,3,2])\n",
    "display(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dot(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "arreglo = np.array([1,2,3,4,5,6,7,8,9])\n",
    "matriz = arreglo.reshape(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriz.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "arreglo[2] = 9999"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   1,    2, 9999],\n",
       "       [   4,    5,    6],\n",
       "       [   7,    8,    9]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30002,    32,    50])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriz.dot(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[    1,     4, 29997],\n",
       "       [    4,    10,    18],\n",
       "       [    7,    16,    27]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriz * a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linspace in module numpy.core.function_base:\n",
      "\n",
      "linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)\n",
      "    Return evenly spaced numbers over a specified interval.\n",
      "    \n",
      "    Returns `num` evenly spaced samples, calculated over the\n",
      "    interval [`start`, `stop`].\n",
      "    \n",
      "    The endpoint of the interval can optionally be excluded.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    start : scalar\n",
      "        The starting value of the sequence.\n",
      "    stop : scalar\n",
      "        The end value of the sequence, unless `endpoint` is set to False.\n",
      "        In that case, the sequence consists of all but the last of ``num + 1``\n",
      "        evenly spaced samples, so that `stop` is excluded.  Note that the step\n",
      "        size changes when `endpoint` is False.\n",
      "    num : int, optional\n",
      "        Number of samples to generate. Default is 50. Must be non-negative.\n",
      "    endpoint : bool, optional\n",
      "        If True, `stop` is the last sample. Otherwise, it is not included.\n",
      "        Default is True.\n",
      "    retstep : bool, optional\n",
      "        If True, return (`samples`, `step`), where `step` is the spacing\n",
      "        between samples.\n",
      "    dtype : dtype, optional\n",
      "        The type of the output array.  If `dtype` is not given, infer the data\n",
      "        type from the other input arguments.\n",
      "    \n",
      "        .. versionadded:: 1.9.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    samples : ndarray\n",
      "        There are `num` equally spaced samples in the closed interval\n",
      "        ``[start, stop]`` or the half-open interval ``[start, stop)``\n",
      "        (depending on whether `endpoint` is True or False).\n",
      "    step : float, optional\n",
      "        Only returned if `retstep` is True\n",
      "    \n",
      "        Size of spacing between samples.\n",
      "    \n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    arange : Similar to `linspace`, but uses a step size (instead of the\n",
      "             number of samples).\n",
      "    logspace : Samples uniformly distributed in log space.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.linspace(2.0, 3.0, num=5)\n",
      "    array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)\n",
      "    array([ 2. ,  2.2,  2.4,  2.6,  2.8])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, retstep=True)\n",
      "    (array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)\n",
      "    \n",
      "    Graphical illustration:\n",
      "    \n",
      "    >>> import matplotlib.pyplot as plt\n",
      "    >>> N = 8\n",
      "    >>> y = np.zeros(N)\n",
      "    >>> x1 = np.linspace(0, 10, N, endpoint=True)\n",
      "    >>> x2 = np.linspace(0, 10, N, endpoint=False)\n",
      "    >>> plt.plot(x1, y, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.plot(x2, y + 0.5, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.ylim([-0.5, 1])\n",
      "    (-0.5, 1)\n",
      "    >>> plt.show()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Pedir ayuda\n",
    "help(np.linspace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "li = np.linspace(0,10,11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]\n"
     ]
    }
   ],
   "source": [
    "print(li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Graficación\n",
    "El proceso de graficacion se lleva por medio de la libreria matplotlib (www.matplotlib.org) la cual viene incluida dentro de la distribución de anaconda(www.anaconda.com) en caso tal se utilize MacOS X o Linux, se puede instalar por medio de la linea de comandos como \n",
    "```bash\n",
    "pip3 install matplotlib\n",
    "```\n",
    "\n",
    "Una vez instalado el paquete podemos importar la funciones dentro del \"alias\" plt de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La funcion elemental pra graficar en python por medio de matplot lib es \"plot\", plot toma como argumento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x116907908>]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([1,2,3],[1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1189957b8>]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(li,np.sin(li))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1189fa7b8>]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "li = np.linspace(0,10,50)\n",
    "plt.plot(li,np.sin(li))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Systemas Numericos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los numeros puede pertenecer a un conjuto denominado $\\mathbb R$ o conjunto de numeros reales. \n",
    "Por ejemplo:\n",
    "$ 1.8992222  \\in \\mathbb R$.\n",
    "\n",
    "Los numeros real pueden poseer infinita presición y son utilizados ampliamente en matematicas en especial en analisis( o calcula infinito decimal). Existe el inconveniente que la computadoras son maquinas finitas, finitas en el espacio de memoria y finitas en el tiempo de calculo. Por lo tanto, es necesario delimitar los numeros reales a números de finita precición. Pero antes vamos recordad otros sistemas numerico\n",
    "El conjunto de numero naturales $ \\mathbb N $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "naturales = [1,2,3,4,5,6]\n",
    "type(naturales[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los números naturales son los numeros que utilizamos para contar.\n",
    "\n",
    "Los numeros de base binaria, para representar un numero normalmente utilizamos un numero fijo de simbolos, la cantidad disponible de simbolos y su posicion determina el peso de su digito. por ejemplo Un sistema de base dies o decimal (10 digitos) utilizamos los simboloy de origine arabico \"0,1,2,3,4,5,6,7,8,9\" cada uno representa una cantidad definida que pueden representar maximo la 9. La posicion de derecha a izquierda representa el \"peso de dicho numero\" y como el siguiente numero es 10 el proximo digito va a se amplificado ( o multiplicado) por esta tamño, y siguiente a este 10 *10 . Podemos defnir una estrucutra unica para respresentar numeros decimales como la posicion es el exponente de 10\n",
    "\n",
    "Por ejemplo: el numero 194 =  4 * 10^0 + 9 *10^1 + 1 * 10^2 = 4 + 90 + 100\n",
    "\n",
    "Teninedo en cuenta que el peso de le digito depende de su posición podemos definir cualquier sistema númerico \n",
    "Un sistema  comunmente utilizado en computación es el sistema hexadecimal que utiliza una base de 16 simbolos\n",
    "0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F y perimite escribir numeros como 256 = FF.\n",
    "\n",
    "\n",
    "El sistema que utiliza internamente las computadoras para representar numeros es el sistema binario. El sistema utiliza dos simbolos para representar los numeros, por ejemplo 0,1 o estados reales como 0 votios o  5 voltios , etc. DEbido a la cantidad finita en la memoria de una computadora podemos espesificar una cantidad de digitos binarios (o en ingles \"**bi**nary digi**ts**\" o **bits**).\n",
    "\n",
    "Al seleccionar una cantidad fijas de bits automaticamente delimitamos el numero de posible representaciones de numeros. si utilizamos 1 digito:\n",
    "0 , 1 : podemos representar dos estados\n",
    "\n",
    "Si escogemos 2 digitos:\n",
    "00, 01, 10, 11: podemos representar 4 estados\n",
    "\n",
    "Si escogemos 3 digitos:\n",
    "000, 001, 010,  011, 100, 101, 110, 111 : podemos representar 8 estados\n",
    "\n",
    "La formula para saber cunato estados podemos representar por cantidad de digitos (N) es \n",
    "\n",
    "$$ 2^N $$\n",
    "\n",
    "si asignamos una rregla para \"codificar\" cada numero natural a un numero binario:\n",
    "0 = 000\n",
    "1 = 001\n",
    "2 = 010\n",
    "3 = 011\n",
    "4 = 100\n",
    "5 = 101\n",
    "6 = 110\n",
    "7 = 111\n",
    "\n",
    "Podemos ver que al utilizar 3 bits podemos representar 8 numeros  en este caso del 0 a 7, si deseamos saber el numero entero maximo podemos utilizar la formula \n",
    "$$ 2^N -1 $$\n",
    "\n",
    "\n",
    "Nuestro problema de representar un numero entero natural en una computadora que utiliza una memoria  de estado binario es facilmente resuelto con la codificacion expuesta.\n",
    "\n",
    "Pregunta  cuantos bits minimos necesitamos para representar un 1 millon?.\n",
    "\n",
    "Es comun agrupar conjuntos de 8 bits en una unidad superior conocida como Byte \n",
    "$$ 1 Byte = 8 bits$$\n",
    "Por lo tanto un Byte de memoria es capas de representar numeros enteros positivos de 0 a 255.\n",
    "\n",
    "Existe una codificacion de orden superior que agrupa un caracter ( o letra en un byte) estas reglas de codificacion permiter persistir valores de texto en memoria, y esta fuera del alcance de este libro. estas reglas de codificacion mas estrucutrad de orden superior como estructurad de datos permiten \"guardar\" imagenes listas de numeros, videos, y otros tipos de documentos.\n",
    "\n",
    "\n",
    "Pero nuestro problema es como representar un numero de coma fija como\n",
    "129.575\n",
    "La solución mas ismple es utilizar un numero finito de bit para representar la parte entera y un numero finito de bits para la parte de coma decimal.\n",
    "\n",
    "El problem de esta regla de representacion es que en calculo cientifico podemos encontrar valores muy grandes o muy pequeños y  la cantidad de bit para representar la parte decimal puede crecer considerable emnte.\n",
    "\n",
    "La solución es utilizar la notación cientifica donde el significante o mantissa se guarda en una cantidad fija de bits y el exponente en otra cantidad finita de bits, a esta representación binaria de numeros se conoce como codificacion de coma flotante. Tenemos una mayor libertar para reprsentar numeros  muy grande o muy pequeños a cambio de sacrificar precición en valores extremos.\n",
    "\n",
    "En computacion la cantidad de bit que utilizamos para la mantissa y el exponente permite defnir una prección. \n",
    "Tradicionalmente utilizamos 4 bytes  (32 bits) para representar la precicion mas simple, de las cuales utilizamos 27 bits para la mantisssa y 5 bits para el exponente ( 4 bits significativos + 1 bit de signo)\n",
    "La doble precicion (double) que es de uso preferencial para calculo cientifico  en fisica e ingenieiria, utiliza tradicionalmente 8 bytes ( o 64 bits), invitamos al lector a investigar los limites teoricos utilizando doble precicion flotante.\n",
    "\n",
    "\n",
    "Existe diversa literatura que profundisa el aspecto problematico de discretiza los numeros reales dentro del sub conjunto de numero de coma flotante, y el efecto de presicion variable a lo largo de diferente numeros de mantisssa. y peor aun el dañino efecto de truncar un numero real dentro de un numero de coma flotante, y la acumulación de este error  a medida de la cantidad de calculos de coma flotante. Por lo tanto un proeso de pasoso finitos de computo con numeros flotantes aumentara el error de truncamiento proporcionalmente al numero de operacion con numeros flotantes. Debido a estos es comun  utilizar metodos directo para sistemas pequeños, y metodos iterativos para sistemas grandes y complejos por que continene ccondiciones de tolerancia que permiten corregir el error acumulado de truncamiento.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "340282366920938463463374607431768211456"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def numeros_posibles(numero_de_bits):\n",
    "    return 2**numero_de_bits\n",
    "\n",
    "numeros_posibles(128)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los numeros reales no se pueden representar en un computadora solo un subconjunto de ellos. Un numero racionalfacilmente se puede representar como la division de dos numeros naturales, por lo tanto es facilemente representable en una computadora. pero el caso de numeros de finita precicon podemos mencionar un sistema de coma fija.\n",
    "\n",
    "Si tenemos una cantidad de memoria de 8 bit "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "flotantes = [0.1,0.2,0.44444440,.123456789,20e10,20.99,6e99]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(flotantes[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(flotantes[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 1 bit = 2'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 2 bits = 4'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 3 bits = 8'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# cantidad de estados que se pueden represnetar con 1 byte\n",
    "display(\"Cantidad de estados que se pueden representar con 1 bit = %i\"%(2**1))\n",
    "display(\"Cantidad de estados que se pueden representar con 2 bits = %i\"%(2**2))\n",
    "display(\"Cantidad de estados que se pueden representar con 3 bits = %i\"%(2**3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 1 bit = 2'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 2 bit = 4'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 3 bit = 8'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 4 bit = 16'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 5 bit = 32'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 6 bit = 64'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 7 bit = 128'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 8 bit = 256'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 16 bit = 65536'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 32 bit = 4294967296'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 64 bit = 18446744073709551616'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in [1,2,3,4,5,6,7,8,16,32,64]:\n",
    "    display(\"Cantidad de estados que se pueden representar con %i bit = %i\"%(i, 2**i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 1 bytes = 256'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 2 bytes = 65536'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 3 bytes = 16777216'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 4 bytes = 4294967296'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 5 bytes = 1099511627776'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 6 bytes = 281474976710656'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 7 bytes = 72057594037927936'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 8 bytes = 18446744073709551616'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 16 bytes = 340282366920938463463374607431768211456'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 32 bytes = 115792089237316195423570985008687907853269984665640564039457584007913129639936'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'Cantidad de estados que se pueden representar con 64 bytes = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# un byte equivale a un bit\n",
    "for i in [1,2,3,4,5,6,7,8,16,32,64]:\n",
    "    display(\"Cantidad de estados que se pueden representar con %i bytes = %i\"%(i, 2**(8*i)))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2**(64*8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**(64*8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arreglos númericos\n",
    "El concepto de arreglo es fundamental para la computación cientifica. Aun asi es extremadamente simple.\n",
    "Un arreglo es una estructura de datos, que agrupa datos del mismo tipo de manera contigua en memoria. En palabras mas simples es una lista finita de elementos.\n",
    "\n",
    "el arreglo [1,2,3,5,9 ] es un arreglo de 5 elementos, por lo tanto decimos que el arreglo tiene un tamaño de 5 elementos, el tipo de datos es enteros naturales. Basicamente es la definicion de un arreglo.\n",
    "\n",
    "Utilizamos arreglos para \"codificar\" vectores, metrices  o tensores. utilizando reglas de columna  o fila.\n",
    "\n",
    "Los objetos como matrices o tensores se pueden \"flatear en un vector o arreglo\" utilizando reglas como \"column mayor\" o \"row major\" pero aprate es necesario guardar informacion extra como la cantidad de indices del tensor, y los tamaõs de cada indice o dimensiones.\n",
    "\n",
    "En python existe una forma para utilizar arreglos y es atravez de la libreria \"**Num**erical **Py**thon (Numpy)\"\n",
    "\n",
    "\n",
    "Para esto utilizamos \n",
    "al comienzo la palbla clave import \"nombre del modulo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Funciones recursivas contra iterativas\n",
    "La iteraciones un concepto de repeticón, si una funcion repite la llamada de una fucnión y utiliza el resultado para la siguietne se conoce com una iteracion o paso. Otro tipo de definicion es el concepto de recursividad, en una definición simple es que una funcion recursiva se lllama a si misma una cantidad finita de veces a continuacion famos a implementar una funcion que implemnte el factorial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial_recursivo(n):\n",
    "    if n<=1 :\n",
    "        return 1\n",
    "    else:\n",
    "        return n*factorial_recursivo(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#test\n",
    "factorial_recursivo(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#prueba\n",
    "6*5*4*3*2*1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial_iterativo(n):\n",
    "    resultado = 1\n",
    "    i = 1;\n",
    "    while i <= n:\n",
    "        resultado = resultado * i\n",
    "        i = i + 1\n",
    "    return resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial_iterativo(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tarea implementar una funcion que calcule los elemeto n de la serie de Fibonacci, de forma iterativa y la forma recursiva"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Otros lenguajes de programacion\n",
    "Lengauje de proposito general significa que no tiene algun objetivo de permancer en un rango espeifico de aplicacion, por ejemplo lenaguuajes com Python pertence a esta categoria. Sin embargo, la mayoria de los lenguages de programción pertences a un nicho. Por ejemplo Fortran era por muchos años la lingua franca el lenguaje de uso profesional para metodos numerico, y hasta la fecha utilizado por muchas aplicaciones comerciales debido a su cercania al lenguaje de maquinas. Pero esta ventaja es una desventaja porque  no permite crear aplicacion con un pbjetivo mas amplia, es posible pero no con tanta facilidad. Lenguaje de programacion como Java y c# son utilizados ampliamaente en la industria de l desarrrollo de software comercial con contratos militares o aplicaciones para bancos por su seguridad y robustes, pero al tener una arquitectura de software \"manejado\" no son tan eficientes para computacion cientifica. Lenguajes como Lavascript, PHP son muy populares en entornos web pero tampoco muy comunmente utilizados para computacion cientifica. Python es sin duda muy popular en diferentes campos pero el campo de analisis de datos disfurta por el momento un papel muy importante junto a R. Por ultimo el sucesor de FORTRAn en los clusters de programación es C++. C++ esun decendiente directo de C un lenguage simple por diseño pero capaz de traducir a lenguaje de maquina sin mucha indireccion. Por esto C es el lenguage que esta debajo de toda nuestra civilizacion moderna. Este lenguaje se utiliza par crear sistemas( lenguajes, servidores, sistemas operativos) su unico rival es assembler que technicamente no es un lenguaje de programcion si no una traducción nemotenica del lenguaje de maquina. El lenguaje de maquina es muy impractico par la computación moderna sin embargo aun goza exito en programacion embedida de microcontroladores o en casos especiales en sistemas operativos. Pero debido al avance masivo en optimizadores de codigo lenguaje de alto nivel generan codigo mas eficiente que los escritos directamente en ASM por humanos. Por ultimo C++, Es un lengauje muy especial, estremadamente exotico, multiparadigma y en muchas ocaciones los paradigmas se trslapan haciendolo un lenguaje muy complicado. Este lenguaje es la opción mas eficiente a la hora de contruir software cientifico. Permite crear capas de abstraccion con paradigmas orientado a objetos y al mismo tiempo sin sacrificar eficiencia como muchos lenguajes de alto nivel. Muchos sistema soperativos software comerciales de todo tipo estan contruidos en c++.\n",
    "En este curso usaremos Python como lenguaje de referencia pero se ofrence codigos fuentes para diferentes lenguajes.\n",
    "\n",
    "#### Paquetes de software\n",
    "Los paquete o software comerciales perimeter enfocarnos mas en el dominio del problma y menos en el dominio de la maquina o el lenguaje. por desgracias muchos son de ambito comercial y muy costosos. Por ejemplo el mas utilizado academicamente en ingenieria es Matlab, originalmente creado para no lidia con FORTRA, uno de los autore de Linpack( libreria de algebra linea de FORTRAN) fue credo para enfocar a los estudiantes en el area de algebra lineal y no en el dominio de la ciencia de computacion. Este lenguaje que evoluciono a en una suite de softwares(compiladores librerira o toolboxes), interfay grafica, etc. Permite crear plataformas para analisis numerico y simbolico. El paquete de software simbolicos tenemos Maple, MathCAD entre otros. uno muy utilizado por la comunidad cientifica e empresarial para analisis de datos es Mathematica, con espesificaciones muy amplias.\n",
    "En este curso utilisaremos Jupyter con las librerias Numpy, matplotlib, Sympy, entre otras. Juntos producen un paquete de software libre capaza de simular muchas de las opciones de matlab y mathematica sin coste alguno. con el sacrificio de la facilidad de uso y el soporte comercial. Como motivacion podemos mencionar que Python internacionalmente es mucho mas usados que todos los paquetes comericales previamente mencionados.\n",
    "\n",
    "#### Entornos de apoyo\n",
    "Tambien es importante mencion que Excel o cualquier hoja de numeros(OpenOffice o Apple Numbers), permite la implementacion de metodos numericos de una forma muy didactica y facil. Pero no puede compararse con el nivel de eficiencia y flexibilidad de utilizar un paquete de software o escribir nuestro codigo directamente en un lenguaje de programación. Por lo tanto solo se demostrara su uso de forma de referencia para aumentar las competencias en el uso de multiud de software."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Series de Taylor\n",
    "La series de taylor son una herramienta analitica que nos sirve para representar una funcion como una sumatoria infinita de potencias. En pocas palabras es la representacion polinomica de una función. Esta formula es base para derivarmultiples metodos numerico.\n",
    "\n",
    "Si concoemos la derivadas de una funcion en el punto $x_0$, Podemos aproximar en la cercandad de $x_0$ osea $x_1$\n",
    "\n",
    "$$ f(x)\\rvert_{x=x_0} = f(x_0) + f(x_0 + h)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "76e6af927ea441b88947987a9343ce7e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=5, description='n', max=10, min=1), Output()), _dom_classes=('widget-int…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ipywidgets import interact\n",
    "import matplotlib.pyplot as plt # libreria para graficas, plot, show, xlim, ylim, legend, title, annotate\n",
    "import numpy as np\n",
    "from \n",
    "\n",
    "\n",
    "@interact(n=(1,10,1))\n",
    "def plot(n):\n",
    "    xx = np.linspace(-2,2,100)\n",
    "    yy = np.sin(xx)\n",
    "\n",
    "    plt.title(\"Aproximación de taylor\")\n",
    "    plt.plot(xx, yy)\n",
    "    plt.grid()\n",
    "    plt.annotate(\"hola\", xy=(1, 2), xytext=(1, 1),arrowprops=dict(facecolor='black',width=.2))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practicas\n",
    "\n",
    "### Básico\n",
    "1. Escribir una función que resuelva la ecuación cuadratica de forma directa utilizando la formula cuadratica.\n",
    "2. escribir una función que resuelva el total de dos resistencias en paralello.\n",
    "3. Extender el problema 2, para que admita una lista de resitencias y calcule la resitencia toal.\n",
    "4. Escribir una función que admita la nota de un estudiante y muestre \"A\" \"b\" ... dependiento la nota de 100 a 0 acorde a la evaluación del curso.\n",
    "5. Escribir una función que calcule el BMI (indice de masa corporal) y muestre su estado actual ( normal, debajo del peso normal o obesidad).\n",
    "6. Escribir funciones que tome una lista de dos elementos ( componentes rectangulaes de un numero complejo) y convertir a las componentes polares.\n",
    "7. Escribir la funcion inversa de la practica 6.\n",
    "\n",
    "### Medio\n",
    "5. Investigar el uso de ipwidgets interact, y graphique la función senoida con decadencia exponencial y cree manipuladores para paremetros de frecuencia y constante de tiempo.\n",
    "6. Escribir un documento en jupyter para la salucion cuadrtica utilizando LaTex\n",
    "\n",
    "### Avanzado *\n",
    "7. Escribir manualemente una funcion que calcule el determinante de una matriz 3x3.\n",
    "8. Escriba una funcion que calcule la inversa de una matriz 3x3.\n",
    "9. Escribir sobre la definicion de numero de punto flotante y la definicion de mantissa(significante) y el exponente\n",
    "10. El prodcedimiento para convertir numeros enteros de entero a binario y vicevera. convertir el numero 7399 a binario. Invetigar el procedimiento en Python y comprobar.\n",
    "11. Mostrar el campo vectorial del campo electrico generado por una carga(+) utilizando matplotlib\n",
    "12. Mostrar el campo electrico generado por dos cargas(+ y -) utilizando matplotlib\n",
    "\n",
    "## Proyecto:\n",
    "* Crear libreria para analisis de viga simplemente apolladas donde se define la longitud de la viga(L) de \"A\" en X=0 a \"B\" en x=L en coordenadas en x.\n",
    "* Poder colocar cargas puntuales como un arreglo o lista de tuplas (F_z(x), x) (fuerza posiscion)\n",
    "* Poder mostrar las cargas utilizando matplotlib( graphica)\n",
    "* Mostrar las reacciones R resultantes\n",
    "* Mostrar el grafico de cortantes\n",
    "* Mostrar el grafico de momento flector\n",
    "* Presentar ejemplo de cargas aleatorimente distribuida, mostar los puntos anteriores en un reporte de  Jupyter\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/matplotlib/figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(\"Figura 1\")\n",
    "plt.plot([1,2,3],[1,2,3],label=\"test:  $x^2$\")\n",
    "plt.xlabel(\"X\")\n",
    "plt.ylabel(\"F(X)\")\n",
    "plt.legend(loc=\"best\")\n",
    "plt.subplot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}