4_calculo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Integración y diferenciación numerica\n",
    "El calculo diferencial trata dos temas relacionados, las derivadas y las integrales. En nuestro caso estudiamos funciones analiticas que se pueden derivar, y ingrales propias  e impropias. Es importante tener en cuanta que el callculo o analisis real utiliza el procesos de limite. El proceso de limite es un calculo infinito y abstracto. Por otro lado las computadoras son maquinas finitas y poseen finitos recursos como memoria y tiempo de ejecucion. Por lo tanto tenemos que cuantificar el proceso de limite. En este capitulo desarrollaermos metodos numericos para computar derivadas e integrales de forma numerica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Settings\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import sympy as sym\n",
    "sym.init_printing()\n",
    "from ipywidgets import interact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Derivacion finita\n",
    "el concepto de derivacion proviene de la aproximacion de el calculo de la pendiente, una pendiente aproximada con dos puntos se puede calcular como la razon entre el cambio de la funcion como:\n",
    "$$ \\frac{\\Delta f(x)}{\\Delta x} = \\frac{f(x+\\Delta x) - f(x)}{\\Delta x}$$\n",
    "\n",
    "si tenemos una funcion de prueba como $f(x) = x^2$ podemos calcular su derivada como $f'(x) = 2x$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1143547f0>,\n",
       " <matplotlib.lines.Line2D at 0x1143549e8>]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = lambda x: x**2\n",
    "df = lambda x: 2*x\n",
    "\n",
    "line_at = lambda x:b + m*x\n",
    "\n",
    "v_f = np.vectorize(f)\n",
    "v_df = np.vectorize(df)\n",
    "x = np.linspace(0,3)\n",
    "\n",
    "plt.plot(x,v_f(x),x,v_df(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "30f8b7e70690442fa8a2848f076a976b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.400001, description='h', max=1.0, min=1e-06), Output()), _dom_classe…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def diff_finita(f,x,h):\n",
    "    return (f(x+h)-f(x))/(h)\n",
    "\n",
    "@interact(h=(1e-6,1.0,.1))\n",
    "def grafica(h):\n",
    "    display(diff_finita(f,1,h))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integración finita\n",
    "En esta seccion vamos a desarrollar metodos numerico para el calculo de integrales. Primero que todo vamos repasar le concepto de integral.\n",
    "\n",
    "Una integral definida, se puede representar con el simbolo de una $'S'$ alargada ($\\int$) que originalmente el corto para suma. Esto significa que el una suma infinitodecima al lo largo de x. Es muy util para calcular la contribucion total de una funcion a lo largo de un rango $[a,b]$\n",
    "\n",
    "$$ I = \\int_a^b f(x) \\quad \\mathrm d x $$\n",
    "\n",
    "Podemos imagina que la integral de $[a,b]$ computa el area debajo de la curva. en palabras simples, la integral toma una funcion y un rango y retorna un numero real. A continuacion un ejemplo\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: np.polyval([1,0,0],x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  4, 16])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f([1,2,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sumatoria_finita(f,a,b, intervalos):\n",
    "    acumulacion = 0\n",
    "    distancia_total = b-a\n",
    "    h = distancia_total/intervalos\n",
    "    x = a \n",
    "    print( \"paso h=\" +str(h))\n",
    "    while x <= b:\n",
    "        #print(x)\n",
    "        acumulacion = acumulacion + f(x)*h\n",
    "        x = x + h\n",
    "    return acumulacion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La integral de $f(x) = x^2$ es $\\int_0^4 {x^2} \\mathrm d x$ es igual a $[\\frac{1}{3}x^3]^4_0 = [64/3]-[0] \\approx  21.3333$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "paso h=0.4\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALMAAAAPBAMAAABdMuPOAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIpm7MhCriUTv3c12VGZoascqAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAB5klEQVQ4EbWTP2gUQRSHv8XsbZK7S1YbURCOFfyDzUEqq2wjKbNYCGqRKBjQ5o5TvEa4ba1iECSJxMLWImkUC/EOsRGFHCLYrqUoJmLU4GnOt28Cc5WZxik+hvdjvhnevsWLJmJgqCKA4NYNvOb1Lv7xm6EBZ5uXGIBLogrOEWyLc7Sam/2nnOIA5R3OZ96Cgf+AQ6GFU6IKrsCSSF+pel+FCda7/OIqXDYo3KFQsXBKVMEy1GK8T6qeD+WW26nfowctg/E1gk0Lp0QVtJNcHRRVfTrvCtIQ/xusn8kRz1QpbVk4JblCTasJH4y6N/UildKFOvfl1aliRF69beGUqEJEwz/xO6r2exkrcPBhIt2gnSmCTYo7Fk6JKkQ9OkuAUfcTTiYygosUO+VWV8Ez3v8ZgFOSK2RF8M6oZTLYSKW0lPD5ZSs2GHsztYWFU6IKShX8+q76kaiz/TDZFX9N3m9Q+C47i72TXcVbvCNzc7V7HTku07yRSldU/UQKKIqzsrMwxX8lRiF/eCmEkWoumpZecxdWw4/h0FcUYwtMhxamuEeiCg43G9dEOl5lZo1C3V/hC+XfvE4uZgalx/5zLJwSVdDu9+XjBZM/MpkUGsdihqOjKUF0Qqo5aETpIFwSVcjR/7X+Ah0oSVbmmV0xAAAAAElFTkSuQmCC\n",
      "text/latex": [
       "$$24.639999999999993$$"
      ],
      "text/plain": [
       "24.639999999999993"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sumatoria_finita(f,0,4,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Derivacion Numerica\n",
    "La derivacion numerica se puede aproximar utilizando la series de Taylor, expandida en un punto siguiente o anterior, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def derivada(f, x, h=1e-6):\n",
    "    return ( f(x+h) - f(x) ) / h\n",
    "\n",
    "def derivada_i(f, x, h=1e-6):\n",
    "    return ( f(x) - f(x-h) ) / h\n",
    "\n",
    "def derivada_c(f, x, h=1e-6):\n",
    "    h = h/2\n",
    "    return ( f(x +h) - f(x-h) ) / (2*h)\n",
    "\n",
    "\n",
    "def diff(f,x,i ,h=1e-6):\n",
    "    \"i=numero entero de 0,...,N-1(numero de columnas -1)\"\n",
    "    fx = f(x)\n",
    "    x[i] = x[i] +h\n",
    "    fxh = f(x)\n",
    "    return (fxh-fx)/h\n",
    "\n",
    "def jacn(f,x, h=1e-6):\n",
    "    N = len(x) #Columnas\n",
    "    M = len(f(x))\n",
    "    \n",
    "    J = np.zeros((N, M))\n",
    "    for i in range(N):\n",
    "        J[:,i] = diff(f,x,i,h)\n",
    "    \n",
    "    return J"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def derivative(f,a,method='central',h=0.01):\n",
    "    '''Compute the difference formula for f'(a) with step size h.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    f : function\n",
    "        Vectorized function of one variable\n",
    "    a : number\n",
    "        Compute derivative at x = a\n",
    "    method : string\n",
    "        Difference formula: 'forward', 'backward' or 'central'\n",
    "    h : number\n",
    "        Step size in difference formula\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    float\n",
    "        Difference formula:\n",
    "            central: f(a+h) - f(a-h))/2h\n",
    "            forward: f(a+h) - f(a))/h\n",
    "            backward: f(a) - f(a-h))/h            \n",
    "    '''\n",
    "    if method == 'central':\n",
    "        return (f(a + h) - f(a - h))/(2*h)\n",
    "    elif method == 'forward':\n",
    "        return (f(a + h) - f(a))/h\n",
    "    elif method == 'backward':\n",
    "        return (f(a) - f(a - h))/h\n",
    "    else:\n",
    "        raise ValueError(\"Method must be 'central', 'forward' or 'backward'.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integración Númerica\n",
    "Como observamos en el metodo anterior necesitamos muchos intervalos para tener una paroximacion, y aun asi tenemos aproximaciones muy deficientes incluso para funciones relativamente suaves. Por lo tanto es necesario desarrollar un meotodo co una convergencia mas alta que la dumatoria finita de rectangulos.\n",
    "### Familia de metodos de Newton-Cotes\n",
    "Este metodo para integrar ecuaciones basicamente utiliza un polinomio de interpolacion de varios puntos, y precalculamos la integral analitica del polinomio y remplazamos el valor numerico. Dependiento el grado del polinomio tenemos metodos diferentes, pero su nombre general que agrupa cada metodo, se conoce como la familia de metodos de Newton-Cotes.\n",
    "#### Regla del trapezoide\n",
    "El primer metodo del tipo Newton-cotes es el metodo que aproxima el area bajo una curva utilizando dos puntos. y en vez de utilizar una altura contantes, utiliza un trapecio para proximar el area, por ejemplo, utilizando la funcion de prueba $f(x)=x^2$:\n",
    "\n",
    "$f(0) = 0$\n",
    "\n",
    "$f(1) = 1$\n",
    "\n",
    "$f(2) = 4$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11440e828>,\n",
       " <matplotlib.lines.Line2D at 0x11440ea20>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = [0, 1, 2]\n",
    "Y = v_f(X)\n",
    "plt.plot(x,v_f(x), X, Y, \"o\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En vez de evaluar el area del rectangulo justo debajo de los puntos, podemos aproximar el area del trpezoide.\n",
    "$$ I = (a-b) \\frac{f(a)+f(b)}{2} $$\n",
    "\n",
    "Si tenemos muchos intervalos podemos aproxima una integral"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nc_1_simple(f,a,b):\n",
    "    print(\"h=\",b-a)\n",
    "    return (b-a)*(f(a)+f(b))/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h= 4\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAACQAAAAOBAMAAAC1GaP7AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIom7VJlmdt1E7xDNMqsI8sYEAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAA4ElEQVQYGS3Ov2rCUBTH8W+aGE3if+isZCilUHRw6eAzeEE6FcRH0KF0DdK5dOncrKWLCIK4mMEHcHHPC3RoETqkJZ6D3uH++VzO7xxohj24HPbRtby6BcswGAcpnVelLas6xQO1qDrHj0XcmIsE74NN4kdU/4XsFCeTUwrL2YlqKd5BJJipl/R3Y/B+Jf/6Qem9LVurTeVHXzfa7EVvLXMm/xMKRulUaNWxJfFRBYl3ZKhMyTE0hOwubobfpfTNHqZCMmohwR0zmFizcBQFf/DMegdv93eU8zyPtOni6YsjHm042XZ5kYcAAAAASUVORK5CYII=\n",
      "text/latex": [
       "$$32.0$$"
      ],
      "text/plain": [
       "32.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nc_1_simple(f,0,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nc_1(f,a,b,intervalos):\n",
    "    \"Regla del trapecio\"\n",
    "    acumulacion = 0\n",
    "    distancia_total = b-a\n",
    "    h = distancia_total/intervalos\n",
    "    x = a \n",
    "    print( \"paso h=\" +str(h))\n",
    "    while x < (b):\n",
    "        #print(x)\n",
    "        acumulacion = acumulacion + (h)*(f(x)+f(x+h))/2\n",
    "        x = x + h\n",
    "    return acumulacion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "paso h=0.4\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALQAAAAPBAMAAAC/7vi3AAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIpm7MhCriUTv3c12VGZoascqAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAB+klEQVQ4EbWUv2sTYRjHP9fkLm3vUg/BobrEDNZFWhAXp1tEcMnhUFCHxIBgFbVEabYmu4NmEPwB/gMOzaKT2Co6WTC4uOlNilA0YsVo0PN53xTuzdJ38hm+ee77vfeT5957OZzy0Qh3s9FGyn+VP6J+d8qdWwnhdPO8Kdq0JKfqzeYyixQGTMAVhZtK02Uo3pFWyZnE6eA+ZDbMZGRakq9pmta4APd4DwcU2l95DouHfuzIEtTxbuOVMkGbluQgeHAfrkXX4axCy7VUIGgtQ2ixp0uhnwnatCTy6DdgPRb0rWOsKug42v0Ob6LqAsF2Jto8YUlgckPxWIu99FOiOu/Li8iY+oFM3Z6SqQeZoE1LAjmFY/KnEIaxanOxMzDQLXmopNDH/5uJbJGYloTRJjBdo3hx7a5CSx030P5GsdXjKe/+GKJNW+L2NawMHwl+6bFhPsxeI1svWxEzmye3DRmZliToKnRQgg5UetJfVptroOX0qH/01JHJZGTumkwvyAre4uzry8pEenk78/EY+om6xa+NCdrcNamqFfkSQShT50K5KMEjY68/h/lvzHSohJmgTUtCRUjsbzYucTNmi2qXvQqUTf06PpcQPHafGYI2LQkfFHo9TX+Tr8vnSU6KM1ePmVgaXh1JoXxY7miU26Zo05bM9mTh/6t/wzE5+F1ZRQYAAAAASUVORK5CYII=\n",
      "text/latex": [
       "$$28.511999999999997$$"
      ],
      "text/plain": [
       "28.511999999999997"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nc_1(f,0,4,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para mantener esta seccion simple solo vamos a mencionar que la reglade simpson 1/3 utiliza 3 puntos, y su polinomi que aproxima una parabola. (los polinomios son calculados a partir de una intepolacion de newton o lagrange) a continuacion una tabla:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Segmentos | Puntos |    Nombre      |                 Formula                      |\n",
    "|:---------:|:------:|:--------------:|:--------------------------------------------:|\n",
    "| 1         |   2    | R. Trapezoide  | $(b-a)\\frac{f(x_0)+f(x_1)}{2}$               |\n",
    "| 2         |   3    | R. Simpson 1/3 | $(b-a)\\frac{f(x_0)+4f(x_1)+f(x_2)}{6}$       |\n",
    "| 3         |   4    | R. Simpson 3/8 | $(b-a)\\frac{f_0+3f_1+3f_2+f_3}{8}$           |\n",
    "| 4         |   5    | R. Boole       | $(b-a)\\frac{7f_0-32f_1+12f_2-32f_3+7f_4}{3}$ |\n",
    "| 5         |   6    |     ---        | $(b-a)\\frac{2f(x_1)-(x_2)+f(x_2)}{3}$        |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nc_2(f,a,b,intervalos):\n",
    "    \"Regla de Simpson 1/3\"\n",
    "    acumulacion = 0\n",
    "    distancia_total = b-a\n",
    "    h = distancia_total/(intervalos)\n",
    "    x = a \n",
    "    print(\"Paso h=\" +str(h))\n",
    "    while x < (b):\n",
    "        print(x)\n",
    "        acumulacion = acumulacion + (h)*(f(x)+4*f(x+(h/2))+f(x+h))/6\n",
    "        x = x + h\n",
    "    return acumulacion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Paso h=4.0\n",
      "0\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALMAAAAPBAMAAABdMuPOAAAAMFBMVEX///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv3aB7AAAAD3RSTlMAIpm7MhCriUTv3c12VGZoascqAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABhklEQVQ4EbWSPU5CQRSFz1MJPwFBGxIr8ozWJjY2RpZARWGDjYUWarQgWhE7a2MCVsbGUnaAO5C4AViBiQXRgIB37gDnZnon4cvN+YbDY94ginfLmK+oftVFABTr+zCgNqHuofGlVSR/gNyDtq8jN0GAqIRenzCaoU7G+NJjoIXq9gBuvXcxDJEdI/9EGM1QJ2O0FI/AeRlZX33XSIwQINVErU0YzVAnY3xpp2Kq5WQm8vAB5EAkJKhNqHpufKl86bUyf2rg8EKCAIkXyQijGepkjCsFUt9YVBefJQkQ3WwBhNEMdTJGS4HMEauRbMqPBcB1Q0KC2oSqaVwpEMtn9hplark/EiDtriZhNEOdaFwpsiUHf0PWgINugKiA5TEBaoY6GeNL8QERs+ppRaoD5AdSTYCaoU7G+NKVErKL6nu5LoUA6R1kvghQM9TJGF+6Ub889QdSa+MTud8Qq3303gijGepkjC/tTKdDLJ2MztxNScWbjRC4jfdgwD0m1D00Wupe5D+tPy4eN1hh5cm9AAAAAElFTkSuQmCC\n",
      "text/latex": [
       "$$21.333333333333332$$"
      ],
      "text/plain": [
       "21.333333333333332"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nc_2(f,0,4,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tarea: ImplementarNewton-cotes para simpson 3/8, y Regla de Bode. Porbar para la funcion impropia de la campana de gauss."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integración de ecuaciones\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value\n",
      "1st option\n",
      "value\n"
     ]
    }
   ],
   "source": [
    "#@title String fields\n",
    "\n",
    "text = 'value' #@param {type:\"string\"}\n",
    "dropdown = '1st option' #@param [\"1st option\", \"2nd option\", \"3rd option\"]\n",
    "text_and_dropdown = 'value' #@param [\"1st option\", \"2nd option\", \"3rd option\"] {allow-input: true}\n",
    "\n",
    "print(text)\n",
    "print(dropdown)\n",
    "print(text_and_dropdown)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initiated datasets repo at: /Users/stephenkrol/.pydataset/\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lat</th>\n",
       "      <th>long</th>\n",
       "      <th>depth</th>\n",
       "      <th>mag</th>\n",
       "      <th>stations</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-20.42</td>\n",
       "      <td>181.62</td>\n",
       "      <td>562</td>\n",
       "      <td>4.8</td>\n",
       "      <td>41</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-20.62</td>\n",
       "      <td>181.03</td>\n",
       "      <td>650</td>\n",
       "      <td>4.2</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-26.00</td>\n",
       "      <td>184.10</td>\n",
       "      <td>42</td>\n",
       "      <td>5.4</td>\n",
       "      <td>43</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-17.97</td>\n",
       "      <td>181.66</td>\n",
       "      <td>626</td>\n",
       "      <td>4.1</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>-20.42</td>\n",
       "      <td>181.96</td>\n",
       "      <td>649</td>\n",
       "      <td>4.0</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     lat    long  depth  mag  stations\n",
       "1 -20.42  181.62    562  4.8        41\n",
       "2 -20.62  181.03    650  4.2        15\n",
       "3 -26.00  184.10     42  5.4        43\n",
       "4 -17.97  181.66    626  4.1        19\n",
       "5 -20.42  181.96    649  4.0        11"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lat</th>\n",
       "      <th>long</th>\n",
       "      <th>depth</th>\n",
       "      <th>mag</th>\n",
       "      <th>stations</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>996</th>\n",
       "      <td>-25.93</td>\n",
       "      <td>179.54</td>\n",
       "      <td>470</td>\n",
       "      <td>4.4</td>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>997</th>\n",
       "      <td>-12.28</td>\n",
       "      <td>167.06</td>\n",
       "      <td>248</td>\n",
       "      <td>4.7</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>998</th>\n",
       "      <td>-20.13</td>\n",
       "      <td>184.20</td>\n",
       "      <td>244</td>\n",
       "      <td>4.5</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>999</th>\n",
       "      <td>-17.40</td>\n",
       "      <td>187.80</td>\n",
       "      <td>40</td>\n",
       "      <td>4.5</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1000</th>\n",
       "      <td>-21.59</td>\n",
       "      <td>170.56</td>\n",
       "      <td>165</td>\n",
       "      <td>6.0</td>\n",
       "      <td>119</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        lat    long  depth  mag  stations\n",
       "996  -25.93  179.54    470  4.4        22\n",
       "997  -12.28  167.06    248  4.7        35\n",
       "998  -20.13  184.20    244  4.5        34\n",
       "999  -17.40  187.80     40  4.5        14\n",
       "1000 -21.59  170.56    165  6.0       119"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pydataset import data\n",
    "quakes = data('quakes')\n",
    "quakes.head()\n",
    "quakes.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}