BE_com_eps.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Informações úteis resgatadas:\n",
    "\n",
    "+ [Python Raiz: flatten lists](https://stackoverflow.com/questions/952914/how-to-make-a-flat-list-out-of-list-of-lists)\n",
    "+ Numpy: encontrar linha mais próxima de uma matriz dado o input\n",
    "    + [Matching a row](https://stackoverflow.com/questions/40382384/finding-a-matching-row-in-a-numpy-matrix)\n",
    "    + [Matching a row 2](https://stackoverflow.com/questions/25823608/find-matching-rows-in-2-dimensional-numpy-array)\n",
    "    + [Matching a row 3](https://stackoverflow.com/questions/18927475/numpy-array-get-row-index-searching-by-a-row)\n",
    "    + [Nearest value that is greater](https://stackoverflow.com/questions/17118350/how-to-find-nearest-value-that-is-greater-in-numpy-array)\n",
    "    + [Finding elements approx equal - prelim](https://stackoverflow.com/questions/2566412/find-nearest-value-in-numpy-array)\n",
    "    + [Finding elements approx equal - isclose](https://stackoverflow.com/questions/49191460/numpy-check-where-elements-of-two-arrays-are-approximately-equal)\n",
    "    + [Sorting arrays](https://stackoverflow.com/questions/2828059/sorting-arrays-in-numpy-by-column)\n",
    "\n",
    "+ Numba:\n",
    " + [Pass function as argument](https://stackoverflow.com/questions/59573365/using-a-function-object-as-an-argument-for-numba-njit-function)\n",
    " \n",
    " \n",
    "\n",
    "## Utilidades:\n",
    "+ O Numba não aceita o np.isclose, o que foi um problema. Tive de alterar o programa de localização de parâmetro de arco s comparando o ponto de colisão com um ponto na matriz de parametrização numérica. As modificações essenciais foram:\n",
    " * Seja all_points a matriz de colunas x,y (pontos de fato da parametrização), com data_in uma matriz de três colunas da parametrização: x,y,s.\n",
    " * Como não pude usar np.isclose, tirei np.abs(all_points - r_comparação). Depois disso, como quero a linha da matriz \n",
    "   all_points que melhor se aproxime de r_comparação, precisei tirar o np.linalg.norm no eixo 1 (restando apenas uma matriz coluna onde cada elemento é a distância de um ponto da parametrização numérica ao dado ponto r_comparação, que é o ponto de colisão)\n",
    " * Em seguida, foi suficiente extrair o i = argmin(), o índice da linha tal que o (x,y) dessa linha tivesse a menor distância ao ponto de colisão. Esse índice é tal que ``data_in[i,:]`` fornece (x_localizado, y_localizado, s)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import numba\n",
    "import scipy.optimize\n",
    "import os\n",
    "plt.rc('font', family='serif', size=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "@numba.njit('f8(f8[:],f8[:,:])')\n",
    "def mapeia_arco(r,data_in):\n",
    "    '''\n",
    "    Entrada:\n",
    "        data_in é um array de 5 colunas (x,y,vx,vy,t) proveniente de uma parametrização numérica.\n",
    "        r é um vetor de 2 elementos (flat array)\n",
    "    \n",
    "    Saída:\n",
    "        s: parâmetro de arco no dado ponto de colisão r\n",
    "    \n",
    "    '''\n",
    "    # Basta calcular a distância do ponto de colisão r a todos os pontos (x,y) presentes na parametrização numérica.\n",
    "#     Exemplo: data_in = [[1,1],\n",
    "#                         [1,-1],\n",
    "#                         [-1,1],\n",
    "#                         [-1,-1]]\n",
    "    # Se r = [1,-1], teremos data_in-r =\n",
    "#                         [[0,2],\n",
    "#                         [0,0],\n",
    "#                         [-2,2],\n",
    "#                         [-2,0]]    \n",
    "    # De imediato, vemos que a linha 2 de data_in é que melhor se aproxima de r. O procedimento geral é o seguinte:\n",
    "    # tomamos data_in-r e então calculamos a norma de cada linha. A linha que tiver a menor norma certamente é a que melhor\n",
    "    # representa o ponto r. Extrai-se o índice dessa linha com np.argmin.\n",
    "    \n",
    "    dist_prelim = data_in[:,:2]-r\n",
    "    dist_abs = np.sqrt(dist_prelim[:,0]**2 + dist_prelim[:,1]**2)\n",
    "    melhor_ind = dist_abs.argmin()\n",
    "    \n",
    "    s = data_in[melhor_ind, 4] #extrai o tempo t de parametrização\n",
    "    return s/data_in[-1,4] # Retorna s normalizado entre 0 e 1\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "@numba.njit('Tuple((b1,f8))(f8[:],f8,f8,f8)')\n",
    "def verifica(r,a,b,eps):\n",
    "    \"\"\"\n",
    "    Função que averigua se extrapolou a região útil da função.\n",
    "    Entrada:\n",
    "        r (float64[:]): o vetor posição no dado ponto\n",
    "        a (float64): semieixo maior\n",
    "        b (float64): semieixo menor\n",
    "        eps (float64)\n",
    "    Saída:\n",
    "        bool (True ou False): True se ultrapassar, False do contrário.\n",
    "        err (float64): Erro absoluto cometido\n",
    "    \"\"\"\n",
    "    \n",
    "    x,y = r\n",
    "    err = ((x/a)**2 + (y/b)**2) - 1 + eps*np.sin(x)\n",
    "    \n",
    "    if err > 0:\n",
    "        return True, np.abs(err)\n",
    "    else:\n",
    "        return False, np.abs(err)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "@numba.njit('Tuple((f8[:],f8))(f8[:],f8[:],f8,f8,f8,f8)')\n",
    "def corrigir(r_antes,v_antes, a, b, dt, eps):\n",
    "    \"\"\"\n",
    "    Função que corrige a posição da colisão.\n",
    "    \n",
    "    Variveis internas:\n",
    "        prec: precisão (10^-6)\n",
    "    \n",
    "    Entrada: \n",
    "        r_antes(float64[:]): posição inicial mais próxima da colisão\n",
    "        v_antes(float64[:]): velocidade antes da colisão\n",
    "        a(float64): semieixo maior\n",
    "        b(float64): semieixo menor\n",
    "        dt(float64): passo de integração\n",
    "        eps(float64)\n",
    "    \n",
    "    Saída:\n",
    "        r_colisão(float64[:]): vetor posição da colisão\n",
    "        error(float64): erro cometido na localização do ponto de colisão\n",
    "    \"\"\"\n",
    "    \n",
    "    prec = 1e-8\n",
    "    #print('prec =',prec)\n",
    "    while True:\n",
    "        dt = dt/10\n",
    "        \n",
    "        extrapolado, erro_antes = verifica(r_antes,a,b,eps)\n",
    "        \n",
    "        while True:\n",
    "            r_novo = r_antes + v_antes*dt\n",
    "            extrapolado,erro_novo = verifica(r_novo,a,b,eps)\n",
    "            \n",
    "            if extrapolado==True:\n",
    "                break\n",
    "            \n",
    "            r_antes = r_novo\n",
    "            erro_antes = erro_novo\n",
    "            \n",
    "            \n",
    "        r_colisao = r_antes\n",
    "        error = erro_antes\n",
    "        \n",
    "        if error < prec:\n",
    "            #print(error)\n",
    "            break\n",
    "            \n",
    "    return r_colisao, error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "@numba.njit('f8[:](f8[:],f8[:],f8,f8,f8)')\n",
    "def vel_refletida(r_col, v_antes,a ,b, eps):\n",
    "    \"\"\"\n",
    "    Função que calcula a velocidade após uma reflexão especular.\n",
    "    \n",
    "    Entrada: r_col (float64[:])\n",
    "             v_antes (float64[:])\n",
    "             a (float64)\n",
    "             b (float64)\n",
    "             eps (float64)\n",
    "    \n",
    "    Saída:   v (float64[:])\n",
    "    \"\"\"\n",
    "    x,y = r_col\n",
    "    nabla = np.array([2*x/a**2 +eps*np.cos(x), 2*y/b**2])\n",
    "    \n",
    "    normal = nabla/np.linalg.norm(nabla)\n",
    "    paralelo = np.array([-normal[1], normal[0]])\n",
    "    \n",
    "#     v_refletida = -(np.dot(v_antes, normal) * normal) + (np.dot(v_antes, paralelo)) * paralelo\n",
    "    v_refletida = - (v_antes*normal).sum() * normal + ((v_antes* paralelo).sum()) * paralelo\n",
    "    \n",
    "    return v_refletida"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "@numba.njit('f8[:](f8[:],f8,f8,f8)')\n",
    "def par_vec(r,a,b,eps):\n",
    "    x,y = r\n",
    "    u = np.array([-2*y/b**2, 2*x/a**2 + eps*np.cos(x)])\n",
    "    u = u/np.linalg.norm(u)\n",
    "    return u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "@numba.njit()\n",
    "def numeric_parameterization(r0,dt,a,b, eps):\n",
    "    \n",
    "    \"\"\"\n",
    "    Entrada:\n",
    "        r0: f8[:]\n",
    "        dt: f8\n",
    "        a: f8\n",
    "        b: f8\n",
    "        eps: f8\n",
    "    \n",
    "    Saída:\n",
    "        full_parameterization: array python->np f8[:,:] (5 colunas)\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    full_parameterization = []\n",
    "    \n",
    "    t=0\n",
    "    r = r0\n",
    "\n",
    "    while True:\n",
    "        r_anterior = r\n",
    "        u = par_vec(r,a,b,eps)\n",
    "        x,y = r\n",
    "        ux,uy = u\n",
    "        param_row = [x,y,ux,uy,t]\n",
    "        full_parameterization.append(param_row)\n",
    "        \n",
    "        r = r+u*dt\n",
    "        t = t+dt\n",
    "        \n",
    "        # Verificação para conclusão da curva fechada:\n",
    "        if t/dt > 100:\n",
    "            if np.linalg.norm(np.abs(r-r0)) < 1e-3:\n",
    "                break\n",
    "            else:\n",
    "                if t/dt > 1e6:\n",
    "                    break\n",
    "    return np.array(full_parameterization)\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "@numba.njit('Tuple((f8[:,:],f8[:,:]))(i8,f8,f8[:],f8[:],f8,f8,f8,f8[:,:])')\n",
    "def simula(Ncol,dt,v0,r0,a,b,eps, param_data):\n",
    "    \n",
    "    \"\"\"\n",
    "    Entrada:\n",
    "        Ncol: i8\n",
    "        dt:   f8\n",
    "        v0:   f8[:]\n",
    "        r0:   f8[:]\n",
    "        a:    f8\n",
    "        b:    f8\n",
    "        param_data: f8[:,:] (3 colunas: x,y,s)\n",
    "    \n",
    "    Saída:\n",
    "        pos_vel: f8[:,:]\n",
    "        fase: f8[:,:]\n",
    "    \"\"\"\n",
    "    \n",
    "    pos_vel = []\n",
    "    fase = []\n",
    "    r_a = r0\n",
    "    v = v0\n",
    "    t = 0.\n",
    "    cols=0\n",
    "    \n",
    "#     List comprehension e \"flattening\":\n",
    "#         Sejam a = [1,2], b = [3,4] e c = [5]. O objetivo é gerar d = [1,2,3,4,5], ou seja, dar um\n",
    "#         flatten geral em [a,b,c] = [[1,2], [3,4], [5]]. Em loops explícitos, isso é bem simples:\n",
    "            \n",
    "#             lista = []\n",
    "#             for x in (a,b,c):\n",
    "#                 for y in x:\n",
    "#                     lista.append(y)\n",
    "        \n",
    "#         Convertendo para list comprehension:\n",
    "            \n",
    "#             [y for x in (a,b,c) for y in x]\n",
    "    \n",
    "    xt,yt = r_a\n",
    "    vxt,vyt = v\n",
    "    temp_array = [xt,yt,vxt,vyt,t]\n",
    "    pos_vel.append(temp_array)\n",
    "    \n",
    "    while True:\n",
    "        \n",
    "        t = t+dt\n",
    "        r = r_a + v*dt\n",
    "        \n",
    "        explodiu, _ = verifica(r,a,b,eps)\n",
    "        if explodiu:\n",
    "            r, _ = corrigir(r_a, v, a, b, dt, eps)\n",
    "            v = vel_refletida(r,v,a,b,eps)\n",
    "            u = par_vec(r,a,b, eps)\n",
    "            p = (v*u).sum()/np.linalg.norm(v)\n",
    "            s = mapeia_arco(r, param_data)\n",
    "            \n",
    "            fase.append([s,p])\n",
    "            \n",
    "            cols+=1\n",
    "            if cols>= Ncol:\n",
    "                break\n",
    "        \n",
    "        \n",
    "        xt,yt = r\n",
    "        vxt,vyt = v\n",
    "        temp_array = [xt,yt,vxt,vyt,t]\n",
    "        pos_vel.append(temp_array)\n",
    "\n",
    "        \n",
    "        r_a = r\n",
    "    \n",
    "    return np.array(pos_vel), np.array(fase)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcula_raio(N):\n",
    "    assert N>4\n",
    "    return np.cos(2*np.pi/N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7987209453715995\n",
      "Wall time: 201 ms\n",
      "Wall time: 202 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# OBSERVAÇÃO IMPORTANTE:\n",
    "#     Respeite as tipagens do numba (use a = 1. ao invés de a = 1). Não use int32 quando se exige float64, por exemplo\n",
    "a = 1.5\n",
    "b = 1.3\n",
    "eps = 1\n",
    "\n",
    "\n",
    "def f(x,y,a,b):\n",
    "    return x**2/a**2+y**2/b**2-1+eps*np.sin(x)\n",
    "# root é uma função que retorna um dicionário. Use o método get() para recuperar\n",
    "# os valores das chaves de interesse (\"x\" e \"success\")\n",
    "\n",
    "x_max = scipy.optimize.root(f,a,args=(0,a,b)).x[0]\n",
    "print(x_max)\n",
    "r0 = np.array([x_max, 0.])\n",
    "dt = 1e-4\n",
    "%time full_param = numeric_parameterization(r0,dt,a,b,eps)\n",
    "\n",
    "# # Nota: o que mais toma tempo aqui é o processo de salvar os dados em um documento .dat\n",
    "# %time np.savetxt('./curve_data/num_param.dat',full_param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def c(a,b):\n",
    "    return np.sqrt(a**2-b**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 149 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# a = 1.\n",
    "# b = 1.\n",
    "r0 = np.array([0.2, 0])\n",
    "v0 = np.array([0, 1.])\n",
    "dt = 1e-3\n",
    "Tsim = 100\n",
    "pos_vel, fase = simula(Tsim,dt,v0,r0,a,b,eps, full_param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def full_sim(a,b,eps,r0):\n",
    "    # Num_Parametr\n",
    "    def f(x,y,a,b):\n",
    "        return x**2/a**2+y**2/b**2-1+eps*np.sin(x)\n",
    "    x_max = scipy.optimize.root(f,a,args=(0,a,b)).x[0]\n",
    "    pos0 = np.array([x_max,0.])\n",
    "    dt=1e-4\n",
    "    full_param = %time numeric_parameterization(pos0,dt,a,b, eps)    \n",
    "    \n",
    "    # Num_Simul.\n",
    "    v0 = np.array([0.,1.])\n",
    "    dt=1e-3\n",
    "    Ncol = 85\n",
    "    pos_vel, fase = %time simula(Ncol,dt,v0,r0,a,b,eps, full_param)\n",
    "    \n",
    "    return full_param, pos_vel, fase\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def full_plots(full_param,pos_vel,fase,local,nome,titulos):\n",
    "    path_xy = os.path.join(local,'xy_'+nome) + '.jpg'\n",
    "    path_fase = os.path.join(local,'fase_'+nome) + '.jpg'\n",
    "    \n",
    "    #Plot (x,y):\n",
    "    fig,ax = plt.subplots(figsize=(5,5))\n",
    "    ax.plot(full_param[:,0], full_param[:,1], 'k-')\n",
    "    ax.plot(pos_vel[:,0], pos_vel[:,1], 'r-')\n",
    "    # plt.axis('scaled')\n",
    "    ax.set_aspect('equal', 'box')\n",
    "    ax.set(xlabel=r'$x$ [u.d.]',\n",
    "           ylabel=r'$y$ [u.d.]',\n",
    "           title=titulos[0],\n",
    "           yticks = np.linspace(-1,1,5)\n",
    "          )\n",
    "    fig.tight_layout()\n",
    "    fig.savefig(path_xy,dpi=300)\n",
    "#     plt.show()\n",
    "    plt.close()\n",
    "    \n",
    "    \n",
    "    # Plot (s,p)\n",
    "    fig2,ax2 = plt.subplots(figsize=(5,5))\n",
    "    ax2.plot(fase[:,0], fase[:,1], 'ko')\n",
    "    # plt.axis('scaled')\n",
    "#     ax2.set_aspect('equal', 'box')\n",
    "    ax2.set(xlabel=r'$S$ [em termos de $L$]',\n",
    "            ylabel=r'$p$ [adimensional]',\n",
    "            title=titulos[1],\n",
    "            ylim=(-1,1)\n",
    "          )\n",
    "#     fig2.tight_layout()\n",
    "    fig2.savefig(path_fase,dpi=300)\n",
    "#     plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simple_plots(full_param,pos_vel, fase):\n",
    "    \n",
    "    #Plot (x,y):\n",
    "    fig,ax = plt.subplots(figsize=(5,5))\n",
    "    ax.plot(full_param[:,0], full_param[:,1], 'k-')\n",
    "    ax.plot(pos_vel[:,0], pos_vel[:,1], 'r-')\n",
    "    # plt.axis('scaled')\n",
    "    ax.set_aspect('equal', 'box')\n",
    "    ax.set(xlabel=r'$x$ [u.d.]',\n",
    "           ylabel=r'$y$ [u.d.]',\n",
    "           title=r'Plot $(x,y)$',\n",
    "           yticks = np.linspace(-1,1,5)\n",
    "          )\n",
    "    fig.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "    # Plot (s,p)\n",
    "    fig2,ax2 = plt.subplots(figsize=(5,5))\n",
    "    ax2.plot(fase[:,0], fase[:,1], 'ko')\n",
    "    # plt.axis('scaled')\n",
    "#     ax2.set_aspect('equal', 'box')\n",
    "    ax2.set(xlabel=r'$S$ [em termos de $L$]',\n",
    "            ylabel=r'$p$ [adimensional]',\n",
    "            title=r'Seção de Poincaré $(s,p)$',\n",
    "            ylim=(-1,1)\n",
    "          )\n",
    "#     fig2.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 230 ms\n",
      "Wall time: 329 ms\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a=1.5\n",
    "b=1.3\n",
    "eps=2\n",
    "x0=0.2\n",
    "\n",
    "full_param,pos_vel,fase = full_sim(a,b,eps,np.array([x0,0.]))\n",
    "simple_plots(full_param,pos_vel,fase)\n",
    "# full_plots(full_param, pos_vel, fase,\n",
    "#            'pres_img/graf_eps',\n",
    "#            'eps_{:.3f}'.format(eps),\n",
    "#            [r'Posição no plano $(x,y)$, $\\epsilon$ = {:.3f}'.format(eps),\n",
    "#            r'Seção de Poincaré $(S,p)$, $\\epsilon$ = {:.3f}'.format(eps)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gráfico no espaço de fase $(s,p)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 140 ms\n",
      "Wall time: 135 ms\n",
      "Wall time: 123 ms\n",
      "Wall time: 159 ms\n",
      "Wall time: 137 ms\n",
      "Wall time: 129 ms\n",
      "Wall time: 131 ms\n",
      "Wall time: 128 ms\n",
      "Wall time: 126 ms\n",
      "Wall time: 135 ms\n",
      "Wall time: 122 ms\n",
      "Wall time: 131 ms\n",
      "Wall time: 122 ms\n",
      "Wall time: 145 ms\n",
      "Wall time: 140 ms\n",
      "Wall time: 118 ms\n",
      "Wall time: 146 ms\n",
      "Wall time: 156 ms\n",
      "Wall time: 240 ms\n",
      "Wall time: 284 ms\n",
      "Wall time: 318 ms\n",
      "Wall time: 299 ms\n",
      "Wall time: 350 ms\n",
      "Wall time: 289 ms\n",
      "Wall time: 314 ms\n",
      "Wall time: 320 ms\n",
      "Wall time: 354 ms\n",
      "Wall time: 328 ms\n",
      "Wall time: 302 ms\n",
      "Wall time: 297 ms\n",
      "Wall time: 134 ms\n",
      "Wall time: 133 ms\n",
      "Wall time: 128 ms\n",
      "Wall time: 158 ms\n",
      "Wall time: 170 ms\n",
      "Wall time: 136 ms\n",
      "Wall time: 133 ms\n",
      "Wall time: 139 ms\n",
      "Wall time: 138 ms\n",
      "Wall time: 151 ms\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEcCAYAAADgJkIVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO29e7wlVXnn/X3O6XMazmkV2Og7tNINOKhp0agwGozJG20zKjPxEiEjohFjZNyOjMZkIrxkEofIm6hjzKhxlICCbuItk1GGqETx1kkE0sgdbQWbi5dEjUK4eMHuNX9UVXedOuteq2rXPmf9Pp/1OWfvXatq1aq1nt9zW6tEKUVGRkZGRkZbzE27ARkZGRkZawOZUDIyMjIykiATSkZGRkZGEmRCycjIyMhIgkwoGRkZGRlJkAklIyMjIyMJMqFkZGRkZCRBJpSMjIyMjCTIhJIxeIjIBSLyhsi6jxSRq0XkbhH5z6nbtp4gIneIyBOm3Y6M4SITyhqGiNwqIj8UkXtq5R3TblfP+F3gc0qpByil3jbtxqSEiLxKRHaKyI9F5ALHsZ8TkR/VxsGuwGsdBGwGvtKiybrzet9DefxERL4tIv8iIl8Vkd9M2Z5QhLZ/rWPDtBuQ0Tl+RSn16Wk3YorYCnxw2o3oCN8C3gA8AzjQ4/hXKaXOi7zWY4DblVL3RdY3IfQe/gh4mVLqxyLyKOBzInK1UuqqxO3yRWj71zSyhbJOISKvE5Fvlq6gXSKyvfz+VhE5U0RuEpEfiMh7ReSAWr0zROSWst5NIvK82m+Hi8hfich3ReSf69aQiPxMqSXfKSI3isizLW17vIh8qbzGh4ADGr9vFpH/VV5nt8mVJSKfAZ4KvKPUyh/haL+2T0KuaWjHQ0TkYhH5p1Kz/j8i8kDf+iYopf5KKfVR4J/bnssDjwF2iciflOPiayLylLYnDb0HpdSNSqkfVx/L8nCfuiLyIBH5gIh8r3zG14hIKxnY8zMYPDKhrEOIyCOBVwH/Rin1AArt6tbaIaeU3z0ceATwe7XfbgF+AXgQ8N+AiYgcJiLzwCXAbcARwEMpLQMRWQD+D/A3wEOA04GLynY027YIfBR4P3AI8BHg+bXf58pzXVteYzvwGhF5RvNcSqmnATsoNPNNSqmvWtpv7BPXNUXknSLyTm1nF3gg8HZgS9k3hwL/UXPvl5SEqyuXWM7viz8qhenficgvBdZ9LPAk4AsUz3AC/HnzoB7uoerv+yjcb98GPu5Z9Y3AHgqr9UHAi5RSe/tu/5qGUiqXNVooBOI9wJ218nLgXwPfAZ4OLGjqvKL2+QTgFss1rgGeAxwPfBfYoDnmF4B/BOZq330AeL3m2F+kcCNI7bu/B95Q/v8kCtdLvc6ZwHsN7fsc8Jse7bf1SdA1PZ7L2cD/n/A5vwG4wHHMk4AHABuBlwB3Aw8PuMbfAb9f+/xQYK/ueXd1D43j54GnUCg7C5513g78QX1s9fkM1kPJFsrax3OVUgfVyp8rpW4GXgO8HviOiHxQRDbX6txR+/82imAsACLy66Wr4E4RuRM4hkLjPhy4TSn1U00bNgN3qJXa4G0UQkl37DdVOUtrx1bYCmyua47A/wf8P/ZusLff0Sdtr3lSaRV8p6x7BvBVn7qpoJS6Qil1t1Lqx0qpCykI4oSAUxwD/GXt86HAXYbn3TmUUnuUUn8LPAwYe1b7CvA7wL0isspCzGiPTCjrFEqpv1BKPYVCWCoKd0CFw2v/b6GwGBCRrRRujlcBI6XUQcANgFCQ0BYR0SV6fAs4vOGv3gJ8U3Pst4GHiog0jq1wB7C7QZIPUEo5haOj/bY+aXPNp5XneQ0FWR5KYQldozn2E7IyI69ePuG6ViAU5X27UPbbAyks0Aq/SuHibB7b5z1AkVjkjKFIEbN7FfAEpdSSUurdhuP6bv+aQiaUdQgp1mY8TUQ2Aj8CfkjhW67wn0TkYSJyCIUm/qHy+2UKQfTd8jwvpdBcAa6kIIM/FpFlETlARH6+/O0K4F7gd0VkofTf/wr67KsvAj8F/rOIbBCRXwWeWPv9SuBfpAigHygi8yJyjIj8G49bN7bf0SdtrvmzFIT0FeBg4D0UMYibmgcqpZ6liliPrjyreXzZPwdQuH/myz5fRegicpCIPKP6XUROoXAtXlo75gIxp70+huKZvFBE5kTkBIoY0Nl93UN57ENE5AUisql8Bs8ATgY+43EPx1AoMP9UHrtFRA7us/3rAtP2ueXSXaGIh/yQIo5Slf9NEWC9ksKP/n0KTXNzrc6ZFALvTuBCYKl2znPKOt8D/gT4PGWMgsKS+CiFIL4feFut3qPLY+8qz/08S7uPA64u2/ehsryh9vtmihjMPwI/AC4Hnm441+eoxVBM7bf1ieuawLuAdxmu/xCKGNC9FMT6X4FrEj3f17M/06kqr6/9/gkKheDBwD+U93Zn2fZfbpzrMuDlhuucCZwPfLh8flcCT+rzHsr/H1w+rzuBfwGur7fZcQ+HUQTv7yrLTuDBXbd/vRUpOyUjAyjShikEcPTaFRHZQkEAv56sYRmdQYrMumuBxyql7p92e2KwFu5hLWD9mmYZnUBENlFo/0+adlsy/KCU+gnwM9NuRxushXtYCxhUDEVE3lNmwtxg+F1E5G0icrOIXCe1fYVE5CVSLLb6moi8pL9WZzTwGxSEsp5X52dkrEsMyuUlIr9I4ed/n1LqGM3vJ1AsijuBQgP+H0qpJ5XB450UvncFXAUcq5T6QW+Nz8jIyFjnGJSFopT6AkVA1ITnUJCNUkpdDhwkIodRrGr+lFLq+yWJfAp4ZvctzsjIyMioMChC8cBDWbno7hvld6bvMzIyMjJ6wqwF5XULsUwLtLS+PBE5DTgNYHl5+dhHPepR6VoXg2uugT173McNFfPz8LjHTbsV7XDjjfCjH027FcPHgx8MW7a4jxs6rrsO7p/hRLABPIerrrrqe0qpB6/6Ydp5y5q87iOAGwy/vRs4ufZ5F0V++cnAu03Hmcqxxx6rgjGZKAW5dFW2b9f3ucj025ZLt2U81s+57dun37a1Wkx97gCwUymNjNZ9Oc3iIJR/R7HQSYCfA64svz8E2E2xEvng8v9DXNcKJpRMJrnkkstaKxGkYiKUQcVQROQDFFtvPFJEviEiLxORV4jIK8pDPg58HbiZYk+mVwIopb4P/CHFauB/AM4uv0uLs85KfsqMjIyMqeLcc5OdalBpw33juOOOUzt37vSvMDdXcHpGRkbGWkKgXBORq5RSxzW/H5SFMnishYBkRkZGRh3z88lOlQklBOec0+npVWCJqZOqrEVMqy+HXtYyuuy3vQmv0RUUwGmnJTtfJpQQnHIKTCb7PqYegHdQPJCqbFpa4j+Nx2xaWlr1/V9MJqAUfzGZrPq9Xg5YXGRexPi7b6mf428S33cIuhYAunt3PQfXM0hVDlhcZOPCQq9tS/2sUwjKlNe/PbJf6v38y9u3a5/VBwLmaPO51sspwI876Pu9wDsB3ml7e3UgYrOx1kKJShuuYevWrcme79LSkhqPx2rr1q1KRNTWrVvVZDJRSik1Ho/V3NzcvmOXl5f3/aaUUpPJZF+90WikRqPRvnNs375de70DDjhALS8v7/u8adOmVZ/r5xmPx2ppaWnFORYXF9XCwsKq+xiNRt73/UlQewPK/d3Kt333Vb/3qq/r/Vz/XvcMDjjggBXn3LRpkwLU/Py8Avb1ab2vNm3apBYXF43tGo/HxjZU39ePn5+fX1WnOT6qMVdvW+piOu/bQe0JfP57ynqma41Go1Xj1FY2bNhgbbOpv+qfm3Ogqu8zR6txUS/VXB+NRivmfRdl69atUbKPWUkb7rO0JZTJZKIdTD5lbm5OLS8vKxFZJXy219ZimK6xuLi4YsCaYJrM8/PzQffZJInRaKQmk4lWwE0mk6BJ7Vt0BKb7zla/+l9E9v3fJE9Tv47H4339WQlr03G665uOr8OmpLgmf8h1J5PJCgVibm5u33HN521TNurCcTQaaRUMnTLSRVlaWloxJqvnVI3X6p7q3+kEtu/c6up51cnIpBDWn0NzPPvOnaq/YkAmlPSEopR+8jUHrk4brQSyacBUpNJmwCqlrIPM9/5iCM00qeuCqT4J6v/XNbSmoDcRmEmANI/TPYM6ms+jeg4hwroNidsEg4hY6/pedzKZGDXfyqJx9ZOJXH0sKNN4qNrUbJtpPJgsel+0nVtK2edX7POqywzfMdfsd13f2CzsUGRC6YhQfDCZTLSmtUuzVsouYHxIoa2FEjrpfLX4vuFDjDZyD+lH3+elm+BthJzvdW3XmJubc/ZTGwusD/gQolLtyLu6ju0cbZ6XiDjH3DTnWiaUKRJKSEyhKQRsk19EnFpGzOSvCzrXoG97rRTwESA+gjrmGTWFtVJ+JK5zC1buoVgXp03jrdd1PVdXP4WQq69wT4UQi7qthWKrv2HDBqcb1WWh2J7FtEmdTCjdEYpr0rQRVK44jc/AD9FkQuIfzWvbBI3JleTqV5eJ7itAfLRR272a7m1ubm5VG30mu0lgVOeIEcKm68JKf7lLWLXpp5hnEwvduA4hCZ+5ZWunbUw1z1sdWz+nK4Zim08h7s0uCJ1MKN0Qis+ksU3AjRs3ar/ftm3bPkFls3B8TPMQ+AobnVAIFVCbN282Et1kMlmV8dRGy2xroZgmf9PfXwluF4mbhFHb52kjFR1ZNUs9pmHqJ19hltJd2lRINm/eHDzedH3r6g9b4Np0f65sufo5bRmctmdpK/V764rQyYTSDaH4TBrbgNUF5rdt27bKSjAJIN/goS983CEmLSdF2mklREx9NhqNvNtbFyBtYyi6rCiT8K2eic3CslkoLrgsN1ufmKzPubk5tX37dmO/x8RQQmIUtnPaMp1CiqtvTfduqmdyW6ZoS71fQuZVndRTJB2YQCaUbgjFZ9KYhJnJ9WQaCM1rtUn7M8HXQtEJsliNSjchbMf4tlfn4ojJ8ooRHDrhVH9epnOa3Hp1a9WV/hmqOddTak2/+2Z5xT4bm9UTOoZisxJd89hULySxonlel1vNpy/rpf4c2iYd2EAmlG4IxXfShKTsuTJHQgZiaKqgK3PFJQB1giZUICjlTyihfvCY1MlQAW3rv7qF1SZG5DpvrOZsG8OhCHG5xLTN9Exi4gahiontuYXEIU3zqAnXnNSRerZQZpBQbJPGlCevy8mv/97GHdJsm68WXEdqgRPisqgsFF+XV3Wfrky65eVl7arktpPZ1zVZLyEEF5Ih6Dqvr5bbvB9f6K7pK9xTWSixWU6259bsV585Ve9vnzHhmkcxMiHHUGaQUJTSu1J0q4Ndq4brAV3d79u3bw/SrmOJKUTw+Aoc36BqfYFcczIsLCy00jS7mMxNIep7PRMJNoVTyvsI1Zx9zlmd1+deqmN1YzgmhmJK6khphTYVmFjBXrUndh7FKoc5y2sGCUWHUDdJfWCa6obGUGIzidqkDofA5oePnQgxayxi+uPUhQV192hUvJp469bibZ7Kn9Bs/Vv1qc2vH3Mf1TnrwjY2w8nWN6bx4RKKtvGwbdu2FfW2bdumvR+TIhdzH7p6bbPz2ngfYoiyK2RC6ZlQYhePiUhQXdtAbDt4Xe4W20Q1DX7fuEGMULDdc2wf6u7n9NFI3b+4WEyfqiwtKTVJs49ZJZxC7yWG3E3t9SVwVxvrgjZ2PJrGg4482mRDNpMfdAsT28wp2710QQ5dElAmlB4Ipf4AY33CNgvFNml1A6bN4NXVXVhY8NpEMUQA6NrTlghTBkS1k3Lr1pVkUpWaZRFDbM37DFk410YotRE8LuWn/sxitftYa79ZQvrDNE5TrFDvw9LomrhmglCAZwK7KN4Zf4bm97cC15Tlq8Cdtd/21H672Od6KQnFR5D5xlB05/KxWkJ81i60EeqhAqB5zrZuBR/rCvbHukz9Y5qUe3VkAoX7y6MfbFuS+6xor6yHIbg/bMTpm87sGlOx1n5z7LW9J5uyF2Kh9PHcQtfUhIKhEwowD9wCHAUsAtcC2yzHnw68p/b5ntBrxhJKTAaNzu1TF7I6YVa/hu8W4KkGTBuhHiMA6mg7aSuMx2NtW+pb79u0OFM77pif1xNKo32TyerV/tUz12XfNN1MIbGbtogVdCEus1jtvm8LxTb228yLvtxdtthbqp01ZoFQjgcurX0+EzjTcvzfA79c+9wLoZgGhW0gpxo0PtkiIRPHBptQdwmfUM28ucllyolna6uLuEz9/EIoYiZ1MiljKE3Y0p99BLhv7KYNfPu7TVxMqeHFUEzt7spCCa0bSvK+im0KzAKhnAicV/v8YuAdhmO3At8G5mvf/RTYCVwOPNfnmjGEEuPGCB3QPkjx4iwb2sRBdHUXFxetfdTsHx8rri1c2qZVAFSxFIelkHTPLkfsJhY+gs5FOj5j2TY/XPB9/4pvnM52P7G/uRAyFkKv4xs7TLUb8SwQykkaQnm74djXNX8DNpd/jwJuBR5uqHtaSTw7t2zZEtyRNuvA9vrW5qBpq4W3mZy+CHHtnT4arRCwOxqxCVdMI8WkCoVLkKa4foxGaxTOInpCaenG8BF0LovVp59ilaAY4eoiN59nbzpHH3HJ0HHjskx8xl0IZoFQvF1ewNXAky3nugA40XXNlBYKFG4M38BzG9PZ1Y7UmnwdOuFzMqh7mkKu4YoJGegu092nj3wmvY+gahtETaFp7jt+ihaKjXR8x7Lt+dv6t4sAc1LLsQGba9B3LIS2zzduuZ5iKBuArwNHsj8o/2jNcY+ksECk9t3BwMby/0OBr2EJ6FclNoZie1i+g8Y2YGKFYYjQihWSOuGxWyfkaoJuMrHvD+baNDF0UoRMXO++GI9X39/CglefhfS3VThPJt6xmxD49JetXb7Cz0eL1hG67fhY5amtQmdCCtdgTPuyhaInlRMo0oFvAc4qvzsbeHbtmNcDf9yo92Tg+pKErgde5nO92Cwvl8bUxuQejUZBwtDmStINnrZuHF39PSZC8Vig18wG8pkYrkmRXFjoyCSQVHzhFM6esZtQuMasLZvLx4JwjVVTvRgS8r1f73kQ0Oepxl4XMZR1tw6l7xJroegmhs8+U83z6DJUdBsY2gaka8K1WumrE6BqtfC5ezTSH1te17d9rmOr4139nNydYUoTrvVJKnSlOaeAaewvLi5aF1r6Boybz9hX647tHy9rIdAqTDn22mR51RMYqv6xrbkKRSaUBIRimxgxO3ia1kmEDEjf+tUE9x7wIQLUMOl2eK6dMQklU3EhuVC29UViQklhQeqERttYUAWbZW06v6mO7f0sodvXpIoNaG5Y+8zvmJ+PSkVvi9jnmDrBJRNKAkJxaUyhgyaFBhZ6Du8AZ6gA1bgFQtoWcg8x7plW5n6PFspkMln1Jsj6a2FdddtseeODGA3cFT+rf15YWHCm4HcpsDWN1z7zPZq+1D27qqRI120zrlMTXSaUBITisgZCtaRQ60KHUHeC9/sREgjQFFtmxArHVBq5Uqq3GIrtZWRttu43CegVwsQzThAjmGx16s9pNBpZU+/b9E00DBbK7kYbXFZVCsJrQwqp3cCZUBIQSl8Wiu8q6gpN4Rk6IXUvrUpBKCkslPmGayFVn4X052QyaZXl5XvNkI0WdYje8iYgThCjJfvWiR0v2vEbAe1z1/TNPRSp8qHtbDs+25BCtlAGSCg2a6B62NPya9YnQ+hA1w7ICEJpTkjf/cdMJSTd2qeubz92sZjSZTH5CFNXSnmoQN6X4GDQwpVB2MRYfz51Yi3aVGtHTNu4nD4a7ds/7Y75+Sgyad5bzJhqQwo5hjJAQlFKn0nRZrDYXirkaMg+F8Xdo5E61TOgrStGDS+QTEz++xjN0yR0Qs4Vo32l1uRsfVO/P9/n5FrjENPPXa3AD0WshdKlO6nZz6Eu5pTtnkxWbzYakgyU0g2cCSURoTQxFa0hoRkOqE2bNnXeD7p7XVhYWDVBYtwnpuK7SLQOm5Yco41X74/Rna9SIHwFqSmlvN62kHfQV31kS/vuEz7P1qm8ecaCmvCxjupjObSfTfcS2j/1GOjJoG6F4nUKtXtNGj80IBNKR4QyFb+mZ6AwpLQddD79oBvoKdwnth19QwnbV1O1tS2VBhtaTEkLto05R6V129w65/7FxWSLJkNQ9wDoyMO6liIgFtSEL6m3SR4InueWNuq2O7pXRJ1s6LfUpJIJpSNCaWOhRJORRypj14M7ZT+0hcnSsxFNyLlM5wh5RWyfpd620WhkXN9T76OTKRSSPeXf02t95JOm3YVGHHzewFhQ/TopLI6QEiPk6/Jit+4+MSuVqedhJpSOCGUqueEeFsrc3FyQFtU2sNlVMDvk+k3hY3Nj2NKwY4SLa+Fo36XS5m0vobLdZzUeXM+1r+fuRS4RsaA+LcpmxqK2rRbU5YVpuyOTUpl64WcmlI4IRakprF71iKEsLi4GrcRPkXrp1Q+RPu4Y2KyFuj+8Hu/wXa0/C6UNuVX941J6+rBMvedJhIXSl0W5qr26dlbFox92G+rudjzPVCATSneE0gbR7oLJRN09Gu1zUegC8rb4QrMsLy93Hshr4+O2n9a83YhN2OqyZnLZX3wsmLa7ZvvAm7QixpfPYuUY0llcXNS6RPeh3sZmsaDq0xdSxEzq9UyJOTmGMiOE0kc2he3aPhkxsVpqzN5kTkT6uG1waa+2rWb69puvpeKyUGISIkwIijUGWsAusvBxnzbL/Py8+z5186AqvijvdS+o28qAfL1v6u1PDTKhpCWUaccMfLUmmw/dVWLSia0k28F6B5f2antO0xbKs1JsWUOhCRExrpcQt1qokmdTzGLWUXnLAN08qEoE+lZuyYSSllB8BnmXD7nP4K9v250k24GFEpuurJSauqCepWIbxyEJEbHbuPvu3xaj5NVTlZvbvfvE1Op1vOe4bh5UZQZAJpS0hOKaMF1bMKF+XdOqft/i03YnyXYQQ2kTFA51eYXEW2J2zB1q6dqq0KIhZPfg3gur9TXVSnIMeYZRc7txj4r9ZDJNd7oPyISSllBcg/d+ihWsVflJi8mpQ2i6Y53oYoKMPm330kpbZHmZFkbGEndz5THs37l2PB5rBYqvkKnOMW0yaFtiY2mtFCqdoG0IXB1irSLbYsqU88MX03an+yATSmJCsT50yu0QaqUiFevgDhS2dQHripU0XXExE8Y1MVNoiLZ7NfW3jzZnywQz1TXdT7WzsW9fT3ttSmwcbW5urtV7PKK17EhCiRl/KdehpFrrYb2PHtPubciEkphQlLJMGMNk2Gsb3C3dQTah1eZ1rCHE0KVm1YasYtvl2terEiKu83ZJFrb9var2tNn1uWvNWDuHIgnFZxFm3c1Z7SiQ6lmkslBM4+6FlUyIlBEpMROEAjwT2AXcDJyh+f1U4LvANWX5zdpvLwG+VpaX+Fyvs3UohsmwF8ueWS0D1iaB20xhbDuB6pOwPvBHo5G3tRCDNu4Mk4buEgCnj0YrtiM5uXbNZhuq84X49lMUXXqurj3NBZwh4yCVoGzCRABN635F8Tinbvx17X7c9yqAiD5ottc0Xu4wvTm0o+djw+AJBZgHbgGOAhaBa4FtjWNOBd6hqXsI8PXy78Hl/we7rjkNC8WIlim1Plp416mynaxdKdGFO8Plfrx/cXHFs7iHQks0tcPmVutye49YEvdtl68rJ7Qdpmd6v2H+KNv8cbSrD7djTLtMr3wIIlrX8+nATTYLhHI8cGnt85nAmY1jTIRyMvDu2ud3Aye7rtllDCV4QiRIqXVN6C41ZR8B3wYxbivX/Vrbangeuy3nC3G3mIrrVbImQmnTr9WYibXkqvOEPh+r1RkydxwY6ri3KUnauRwjIzSu9HtF1AsJTHNuYBYI5UTgvNrnFzfJoySUbwPXAX8JHF5+/zvA79WO+6/A7xiucxqwE9i5ZcuWqM5UykNjDp0QHjGUNu6kvhby+WbUxN5DSF3fuJKhsvYZmjbf83lvu0uwmZIMXESUisTbxMBiLMiYOjHo2jqJiTPZ5qNxDsXEWR2KUWyMbBYI5SQNoby9ccwI2Fj+/wrgM+X//0VDKL/tumaX61CiYDFN2yzacgVuU5a6MGgKRp0pf+rCwr7Xq6YyxyuYBJbX1hiGiXh34Lsw6uPBJdhMbXIpAyl3ko0lfNu92RZE+rhpYxWQCl1aKCKiNm3aFNQ+l6vRSqih7isPxSiGwGeBUJwur8bx88Bd5f+9u7z60q7aXG8y6X/zQ1vcoCl0dC8JSpm10irrzKINxga0bYLNNW5s12w15jTCJgY+Qtu0ut1EGKmyBvuyzmH/OqbYvkqeVefhuo1RSJgBQtlAEUw/kv1B+Uc3jjms9v/zgMvL/w8BdlME5A8u/z/Edc1Z2ssrxiLqw3dcL9u3bw+69m6dMIOkcaNWGq5BG/R1oei0bR3Bm4RQMzNLF+PwEWBGmPrfg1R8rE9dCSG/lEpbnxuBul4FEfOenmhoFKPmrsRr0kIp2sgJwFcpsr3OKr87G3h2+f8fATdSkM1ngUfV6v4GRbrxzcBLfa43S7sNx0yuvhfU1QWoz7VNLwlKmdlmqxv77EzPolrw6Fpg2VwLYTpO9yrf5eVlRSkQbp+bW/U+8SBEEkq9bfU3PTZ3vNWVEG246/3Auiw29O3dqBQj3a7EazaGMo0yhPehVPDRtFNnOXVRqknhoxHuNgkzz4kVOzHbWpd9WKfWe4sJzuoQSShV23Quy0r7NZHBNCyU+tqONrtvpyIU5/jpIM232RdtleBMKAMmFF8BFToYphFDqbRHH0J5+fKy+tGGDSsE0v2Li613B+hji5iurVObhZdsgVskoVRt222ou7v2HNqQbgri7tsygf0uL1d8qElyW7duVTvG48GshrchE8qACaVLE9h3/UOqUrXZx+U1Go3UqQsLK1ajnxoQE4jtt04y9BLD9szaugr3IZJQqn73ea95W9JtS9zTsNKrsd1U5nQxtSbZ3WZag9OVOywSmVB6JpSQidCngGsGejds2JBsEtVXyreZyL5EGqvB9uHDbrvexvYejt0mEohpfyCZVO1bWlpyWiidxQSUf/92GUesLIuQV0PU+0Q3DpMpCx0jE0qPhLKY7bAAACAASURBVBIq6HoP0jmu20Yrs/WBbwkh0h3jsbpjfl7toXAF7fDYHbfrGEjb87ueiyndekf5dsF65lVXbrnJZKJOH42MMZQuMx5D+rdL67w+TkPmUgUdAe02EUq2UIZfuiKUUIJIKeBSWEZtSv2adT9x6Dk8bzba39xlDKStguDzXE4uCbQK3O7wSNvtRMjXMojumJ9ftaVHqn6un8d3i5iuY4j16/nOpfn5+X11dGR3Mqh7m2SSYyizUboilBgXVszE81kLEGMZtS263W596wYJPcOirU61OY8MnBQvegrtJ996dSHYdWJByoWJMZtYdhk/ie1/YF8dk/X08uXlQbzzxIZMKD0SSl8+etdK9KrMz88bM026zgKrJp6pT5prN4LcNJE7NEcLUk+LKOb5h7gIdWtXfDXkSuhOPfU5wXlMY6ka812NaV3/+z4/H6smdp1Nl8pBE5lQeiSUaU5WXwFftdMW/E1VqgHus29TUL9FWCitno3n9VKvGaqnlepST21uIJNA60PpSSUwQ9xJXY9lWx/5WJg+Vo1rpb3uun2/MjiaUCi2NXGVg1znGWLpMstrPB6vyALxeZWqT9569VuKCVGtuu6jTCbul28FCzmDxdAMTusm8Scp3k9TL+rAA+0PKMAiCtUYQ4VvTNKDz04GKTMLY0mr2Xd9pr37lpj7bhKFyUMQup1OH8pBE7QglB9R7LG121Jud51niGVIFoqtToh7y6eISOdvsDNdU3fflfCw1bV03Ap/sy44vbCwoEaj0b5rVGSidMVGKh3GbHyFgksLrrs3be7D5jnqW6jE+O11BJpqHiwuLhpfDzCtYlMQTWSvc5WZyDKEDKaxrooWhHJ1imOGWPqOodi2TbcJFNNvsaSydevW3twDtokY43eO7ft6sb5iFswnb5FV5oLO/djUVH36y1eI1M8VtetzjcjvLheo1ttREYfLUp8Fa8Q0l139q7uXJqGmIINZs1AOSHHMEEvfWV66AeWqIyLW84VOxkpIuY7rakGYyP53b/sI/1BfsE+7owlFqc72WdK5P6qFoj6++RgLozrvblM/BLgamzvYgv7tk80YXt/boqQsLthcX67YVwgZzFoM5ULgtcDTgJHr+FkqfVsotsESY6Ho3CGuSVD5cW0WStsYjatU7Y55KVPbvoeWhOKBmIwbm/BxCd3W75UJzZYzuP52Bz7/rsdZl8VloRTdGqeUxaZWh465NqAFoWynIJQLgWsotpa/BHgDcJKr/pBLnzGUprD0qWOLoYSuDG5qsOdv3649rnJJdDnZq/v30eBCJ4eP1hsdQ4m8vo+AaGMR7jbdi6+WGxobMhCQ6fXIpucfkurc1Vis4mu66ywtLalt27ZZ54m9W/3nkCm1f6ggVdowxYuwHkvxit7/Hlp/SKXrvbxCzVmfLK9q8FXn8cmHN2mw52/fbvRvx7ojqklpyyCr7l93jYWFBeemej59X/WjaZO+b2zblpxMlIr3Z8cS+NLSkpkcff3wobEhDwtlaWnJGXD2VSi6TiCpj0fd/IvJ2KzO5zuHhrQxqQ9aEwrF+9zHwEuBJwIH+tYdaul6t+HUvk1btld9AjQDgrtNAsczfbN+nZAJOh6PnVuY+wZlfXzKJoHQpzugzSp53Vhxvfp3UsV0Ip5vowH+sSENAd2/uKhOLzPpqna5xn8Ky7sinLrA3759e5Ay1KUwTzm+h4QUhPIF4PeBbwOfB34CfNm3/hBLH9vXpxRmLi3WJKxT7GAasoiuPkG7Xo9Rv07fgUkdfCyUEOLzuq8Os8+M8CQg1/P3HR+hz9eUZeUjzLtUQIYyTtsiBaFcXf69pvz7fOB1vvWHWIbyPhRf+FoJqyZB4vUTLlM+dKVvHaldRn1rfim18vo5nQKuo+yzQWBi34DSXM29E0TTwu9D4PcdQO8CKQjli+XfKyjdXcDnfet7XuOZwC6K98Kfofn9tcBNwHXAZcDW2m97KJIGrgEu9rnerBFKiJ991StFE2uwk8nESHDLy8utzpsyqD0N37RNYAyF+LpArKC01msxdk19bXp/iU/cJyVmmVhSEMrzKbZZ+W3gA8DpwM2+9T3OP0+RQXYUsAhcC2xrHPNUYKn8fwx8qPbbPaHXnDVCCQ2UV5NgMineXbGbIhPn7tEoiQZrs5jaTI6UabcpBUEKATAk4kuJWEXAWa+FdW3r6xDlzPZ82pDoLLu+WhPKikpFhtebgEfH1Dec83jg0trnM4EzLcc/Hvi72uc1TyhKhQXKq0WEXQ1c26QcmqtpKOdfqxaK6b5c7k9nf0TuKK07dz11fjerF2L6KGd1tBkTsz4OWhMKxcLG84G3UGR6HQts9K3vcf4TgfNqn18MvMNy/DuA36t9/imwE7gceK6l3mnlcTu3bNmSvKP7RJ1cTIOzy4FrW0g5NFdTW6Tqx2lopn24VmKtVafF1sJCqfe1LnVet7pfV0zPp82YmHVLNQWhfAt4HnAS8IfAx0jr8jpJQyhvNxz7opI4Nta+21z+PQq4FXi465qzaKHosGM8VreJrNC8qklgm+gp4ONzbq4LGTXSS2cBs/ruir4ILNZaNY2ffZZNy/hf1de7daSEe3W/7fm0GRPZQoEv+B4bU/B0eQFPB74MPMRyrguAE13XXBOEoplw94rse7e6aeDW99Rqd3mLwJpM1N2jkdXFMCt+Y5sAaBJEl+9yT9nulIi1Vp2EUpy8fQZbxOp+FzH49K0tRXxdx1AorJLfAsS3TkihWIH/deBI9gflH9045vEUgfujG98fTGmtAIcCX6MR0NeVNUEoDpeAzUpxChXdeTXQThoN0ZlcDLOglZkEgO61y0MizT5dKzEZUr21zzJPYkm3bYr4es/y+ivgq8A/An8NnEPivbyAE8pr3AKcVX53NvDs8v9PA/9EIz0YeDJwfUlC1wMv87nemiAUj6BllAamO6eFVCrEuBhmxW+sEwA2V88QSLNP10qM1t1b+yyuszbWwnpNEW9NKPsqwIHAccCpwFtC6w+prAlC8QhaRg3sCEKpT0zT6nydiyFmgg1FuwvZ4HAa6Nu1EvpcTPt0+e6XFdg4o+usi/E064F3G1JYKIdQuL3eDbwaONi37lDLmiAUj6BllFCJIJQ6cYVYKLo32dlveTj+56FbKEoNh3x16EOLT3r/AfGcbKHYCeVvgN8F/j1FwPxG4Im+9YdY1gShKOU1yIMnVQSh1DUyU5rmy5eXtTsRuzaNHKorwWex6SwFW/tGV4tjKyRVPgIzzoak+KRGCkK5vvH5KOBy3/pDLGuGUCLgJJiWFkpFKrtZ/RZBFyG4JuLQXAlDzvIaOmwWXgrhm1T5iFgT46vIDdmK1CEFoXweeGzju+t86w+xrFdC8dacAsgk5LwuQnAJgSFZKBnt4LLw2j7TpMpHi1X7NsyiJZOCUB4F3AD8T+CVFCvV/7dv/SGW9UooXQrkeuaT6UVgruu7hMAsTsAMM7rccWHaFkrvbewJrQmlOAeLwK8BrwdeDhwQUn9oZdYIJZVZ3LXLyLZmo5o8thdv+UywWXMRZNjRlVCdZgzFp202l9+Qs8GiCQX4g/Lvk4EHuI6fpTJLhJJyYtR3Ht7N/sWGqTQi0yRpkojubZOp7zVjYDAkkHT5zKeV5eVqkyuZY01aKMDx5d8PU7yL5KvARykWHDq3NxlymSVCSabBTSbq/sVFVdey7gF16sJCMoEd87rg1c3MFsiag0HD31GzXE1u0rjLpXlbZBewWSazoEAlcXkV52Ej8ATgJcB/D60/pDJLhJLMTWXwA9/d4i2Lqy9hnywpzPpMODMIw9i7zeT+1Bzri7bboqSCaZzalK5ZGM+tCYUiy+uB5f+vAF4DLPrWH2KZJUJJZqEkylSxCXTdZI3eT8xw7ewSm0EEbNB4v26MBpBKTKbgXaD2Nq+1fXv07drG6SwG4utIQSjXln+PBa4C/htwoW/9IZZZIpRkQjRBpopPW3RrM1KRwKxPxnULw9jbrXmWqwR7IKG4LHovMmlJKrZxOutKUQpC2UmxI/D/AH6t+s63/hDLLBGKUoncPDGZKo1A5OkBu8rW25zqXShDW9iY4QnN2LtXRLsDtQ+hxO6mMJms3oHbej1PEmvCJ/19Vt22KQjl1ym2W7kFOLD87iu+9YdYZo1QkiEkU0UjBEzb0DcFusn11Xbjv2yhzDAaY2+HwXJ1EUqbGIlu/HRBKGt5nLYmlOIcbKqRyb8G3htSf2hl3RJKCALcFM2JYksfbqONzbq7IGMltJq6Q7j7CGuTdayr1wWhrOVxmoRQ1lrJhOIBz0Cqa4uVn5STtir3R07SCrPsLsjwhEWwh7g9fdZ8dBFDqa69FsdpCpfX04DzgbcAL6UIzm/0rT/EkgnFA5Y0Y9dEqbTIn2gm677PPWCtTur1jBB3kk8a+9LSkvrxwkJSMlnLSEEo3wKeB5xE8V6UjwE3+9YfYsmE4oEW201UwU+bOyFY2AeuVF7Lbof1jJDnalvzkZWMOKQglC/4HjsrJROKJ1psNzEej42EsrcUAt7CPoLc1nJgdL3DVxnJYyA9UhDKHwK/BYhvndACPBPYBdwMnKH5fSPwofL3K4Ajar+dWX6/C3iGz/UyodiRylVkI5SgiR6xhianGGdkKzU9UhDKX1Hs4/WPwF8D5wAn+db3OP88RUryURS7Gl8LbGsc80rgXeX/LwA+VP6/rTx+I3BkeZ551zUzoZgxHo+tOwIHwUAmP7G4IbSIWOVv0k5HCbeaWc+IUTqmEdPKcbS0aE0o+yrAgcBxwKnAW0LrW857PHBp7fOZwJmNYy5l/2aVG4DvAdI8tn6crWRC0UO38Ku1m4CVWV4mMkltoUwmE7W4uLjqGgsJN8Ncr4jR/FNZC5kgposUFsrRFFle7/CtE1KAE4Hzap9f3LwWxQu+Hlb7fAtwKMXLvl5U+/58DDshA6dRrPrfuWXLltT9vCZgy4pp4yryzbZJGUNRSqlRwMr+DH/ExCZSxDPaklImo/ZIQSiXA8+ifO0vcAzwPt/6Huc/SUMob28cc6OGUEbAn2kI5fmua2YLRQ/XTqhdnLerLC/bdXMcpR1i+jXFs2hDSjmekgYmQpnDH3NKqU8AewCUUjeUpJIK3wAOr31+GEWqsvYYEdkAPAj4vmfdDE9s2bJF+72IcM455yQ/79atW9m7dy+33norp5xyiv0kp5wCt94Ke/cWf13HW65r+j7DDzH9muJZ3H777UHf13HWWWdx3333rfjuvvvu46yzzvK+foYZIYTyLRE5koLVERGhiKekwj8AR4vIkSKySBF0v7hxzMUU72GBwkX2mZItLwZeICIbyzYeDVyZsG3rCueccw5LS0srvhMRXvGKV6wQ+BdddBFHHHEEc3NzHHHEEVx00UVR573tttu86sfgoosu4p577ln1/dLSUityzNA/T1e/2ur4jicbKbnO0YaMMjygM1t0BTgC+DSF5v9SivTdj/jW97zGCRSZZLcAZ5XfnQ08u/z/AOAjFOnBVwJH1eqeVdbbBTzL53rZ5WWGz9vuYlwH9c35kmWRWa6l23JjNBplF0ciOOMRGhelrk7IeDId6/OKhLwmJQ1ItDnkBvavlH8lcEBI/aGVTCjxaDsxQ+rHBlGz8JgyApIoQp+Vbkz4nCPHUNIgFaEshBw/9JIJxQFLALxtcNW3fhsBkIPxU0ZAmneKZxUypnKWVzu0JhTgPIoA+B0Uq9T/HDjdt/4QSyYUCxzaZV8WSpvrZAtlyghYiJriWaV63plw3EhBKLsqCwV4KEW8Y9X2KLNUMqFY4NAuU6wF8KnfRnPN7o0pI8BCSfGshnKO9YAUhHIh8BDf42ehZEKxwEO7bKvJ+dTXaZ2fZP+K+33tMmwznrXNKSJwIWqKZ9X2HF1atWtpLKYglJ8Hvgz8DvALwIN86w61ZEKxIGKbky4wmUzUwsLCKjLRti2/u2J4aLFT9TTQVdxtrVk+JkIJWYcyAT5Mken1SuDvReSWgPoZs4RzzoHGegGWlorve0ax5KnAv6XYvE2Lyy7rozkZIWguRAU44giYmyv+drD2qI7QtVJdLYI1Lah89atfHdS+wUPHMroC7NB8l9/Y2BOmYi53oV0GnrPpguji3d8ZPcHhAks9xqe5eWUTtm2HUl+rD5DA5fV24NW+x89CmRVCaTPIB+W3jdjcsTkRM6HMMCxu1C4EeWw8pDlndozHrRUrU1ti2jcEpCCUD1PEUL4FXELi96FMo8wKobSZGKZJOhWiiYjLNO/dGkPJhDJsWBI9ugiGJ4mHRO5wvfo0+l0bWrdvSogmFOAPyr8/DzyA4iVWT6DYU+vNrvpDLrNCKLETwzRJR6PRdAKEES/I0k3Eu0yksm1bt+3PaAeLQtFFMDwJSSVMTmkqcabXKlRtHLLrqw2hVC+0+jDF9vFfBT5KsceW9p0js1JmhVBiJ4av37Y3UztycmqtqW3bMpnMGizafhcWShI3WoQS1KZ9vSt5kWjt8tpXIVsovcM6MSxB7hC/bX0Cd+YGS+Q+yJhhGMZrV8Hw1q7djtPnbXuQ9aLkRaKNhfIsYLPruFkss0IoShkmhkfWjG6Smkztrnf/LRs1U+sSMvrDoBJI9jdq1Ry7f3FRnT4aJW3nrO0714ZQzqN4Ze4dwKeANwMvoni51ryr/pDLLBGKFh7ak+9W4cnfIZ+RMUTEKDS1OnePRurU2kLbVIpXFy6/LtHa5QW8huJVu6+keMXufcA3fOsPscw8obTw7zaJxmRyD1VDGhpM2vUgte4ZQ7I+TOBydQn+Zlu/vH27fo5u3rzqHmdpJX0KQrm28flY4IO+9YdYZp5QRiP9YB2Ngk81axrSkNDmhU9dt2vWySypoE0QD7ElujRdyW/HkeKuIZVZeV4pCGUHcGzjuy/51h9imXlCWV7WD9TlZe3htgE7CxrSUCacb/rn/Pz81Eh6Ws8z9TPyUnR83VgJMrZM7dERzf02MqnKjCIFoRxN8R6U9wKvAt4NXOFbf4hl5gklYKD6CJhpCmzXtYdCeCEL1KbpRpyGxdnFM3IGq0PcWAkslJD4o3NXh/VMKMU5mGf/K4BfA4xC6lvOewhFwP9r5d+DNcc8DvgixVqY64D/UPvtAmA3cE1ZHudz3fVEKJ0KmJaZWz6CaCguOVu8aUgWyjSyhkyWWpv7dT53F0nUx+ZopNTioh/5WOAbf8wWil3oj4Ax8FLgicCBvnU9zv0mypd1AWcAb9Qc8wjg6PL/zcC3gYPUfkIJXmQ584QSEEPpTMD0EOjstP2BCNnkb5oxlL4JeDKZGPvC+Iw8FBGnsmFzY+nG5sJCMT8Spq2b+jo0hjJLSEEoXwB+vxTknwd+AnzFt77j3LuAw8r/DwN2edS5tkYw65NQJpNigjQnjGaStBYwpslv0hArLdFjwjaF9MmgdoPaUzuHT/v7cNmZ2jEajbTXnpYbsW8XoU1T146xAEXE2oc2C6XjRYn19uncoKPRyDvLa9aQglCuLv9eU/59PvA63/qOc9/Z+PwDx/FPpNiock7tJ5RdFK6wt2LZVh84jWJdzc4tW7Yk7uYpwNPdZPP9OgWdbfKbNESHkKijLoxOBnWP5hw7HNp+XwJ0KLEcH/RJZjbLTXtdk7Cfm9v//2jkVkjGY/15TAkrkGTblCba9PVQkk1CkIJQvlj+vYLS3QV8PqD+p4EbNOU5IYRSWTDAzzW+E4ptYS4Eft+nTTNvoQSivs1D0Kr4GC0wQCOsC+ndlnPYJl6fLp4u3tsxawKlCZvlpoVLEamKweKuXdhOHLrvR6PB7NYwSwpKHSkI5fkUwfPXAh8ATgdu9q3vOLeXywt4IPAlLNvmA78EXOJz3ZkhlMTblXgJ3/o1bRNWZ73oiqPNlVDdE6lVDiXGsgLjsVLz80X75+eLzw2YBEqrd3AkHi9+lwy0gH0UER+FxEVMzd8XFpIE5pv3HqsQ9B3rSoXWhLKiEryYIpD+6Jj6mvO9mZVB+TdpjlkELgNeo/mtIiMB/hT4Y5/rzgSh2AKLlaCqJp3nQI5KxbRN9EqA2Y71nbSRMZnBTUyTK6ZBKrp2nwzq3qYg9Om/yUSfqNHTBpxBFrDvGHMpE74WckWupkSWyHHiZWFYCH6QipAHkhJK6kKRQXYZRdrwZcAh5ffHAeeV/78IuJ/9qcH70oOBzwDXU7jQJsAmn+vOBKGEaHKegsMpfH2uubi4+louIeEzaV3nsARuB+U6sPVdDTqBsjum/8Zju7beI7H6kvuO8VjdJqL24EixtbU9dMy5ssICLTvnvTqSDwanCHkimlDwWA3vc8wQS1+E0spH7utrDhAc0amY9WLyjU8m7vb5aNouS8VwX4OIRZgyezSEohMowW4/n+SIHjVeX627mYzxI127bTGU+jipB/M1grt2UfN4jkh/d96rI9NscIqQJ9oQyg8psqdM5Xrgdtd5hlj6IJSYAVMXjHdULi3f4ik4dozH6o75ebUH1B3z84XPvoKPhdLGDeHrgunw5UadwtV3NejGx222YLIOAYkR00ytbmrdunTx71Bbu2HL8tJp/ouL7jUmJovB5QozWC/Oe/UYw5PJRJ0+Gu1Llb/bJ7ttymhDKFs9ysNc5xli6ZJQYl+c0xQw2jRaD8HhaJxdG/Pxb7dxQ/i2s6d1BMkRQChKrRbyO8bj1euLKoGpEzSeqdtJtGEPt5DvdVq5e9qMDd09hC6Q9O1Tn3a65uMAEU0oa7l0RSg++z2Zgm6mIO0d8/Pm7SNCB6HvIK+Oiw0QuzRnl/urp4mWWmv3Xh1tE84hO0nb+rmm7bb21wc8D58+bUVwqa1X25zwcFtt3bpVvbCcp3vrY9unz2ZQccqEoildEYrNMnFNYi//c11YR2R5BU/GNmmoIe4v3XU6ToFN7cOeTCbqU6zecmMvFFbH/gPtgsZmdfgkQ4isyihrnVHUgeCLJvPUbbE9D5/5YqtvGsMupcvzuUwjdpgJpUdCce33ZBNYrbVIH/SpEfm6v6Zk9qfu72qDxE+WJFKVzy8uNi9sfwahSQkexNv6XocU0+pivJj60Ge+hM6pRG7haQX1WxMKxbvlr6BYhPhh4HjfukMt07BQXBpELwOkb+Hto4lNyez3WpPjaSEFbZDoEs62bLlIAW7bc8prfA3NNdOx9briOq4EgNBnZXJpBs7HXhRQDVIQym7g54GDgacDfwuc7Ft/iKUrQhmPx9qHPNaslNbBaMKmnEB9TcY6bAKpQ+03essWB/H6vmhLO8F9hHPiRXhVm3Xt9FJaZjB4nAz1+TIarU6aMI1fkzVpI5OA+TithZEpCOXyxudl4Abf+kMsfVsorbQGn8nsQxJ9EknzWuOxfdV/B9qvy+Kz/m4R+qEv2lolrH2fZwcCvNX4nIYiMjSYxoVv8kqoO9PalA5kjQdSEMoHgTcAi+XnRcoNI2e19B1DsWoN27atHFjbtq383aXR+gQFQwZ9W5jaU9+jypax1qPwNFowFqvJ5tbUuZR01/HarytCgLuCtLO63cdg4NqRwPWsQhIuHJjlGMoHgJuAfyrdXbcDf0T5TpJZLIOxUJpkUpV6iqnLJWQiHN0K4JZakWcnuK/l0tQSTIpWwtNyDyEv2ppMEq0B8cAsvf0yCCHE2rUV1dYVaZurEZjpLC/gAIo9tl4GvI3iZVt3hJ5nCKXPdShW4WET9r6ZJqFbtOhIKSV8YiI9ZA21du8YrD7TeU0v2nK2I5EQ9LXIdDsD+8b4Okdzl+bt293WbtVnXcd5JhO9Ve3aZr95DtfC4mq+1/shoaLVFskIZS2VPlbKe2kNNmG/aVN1QvsgtGn7rpJKM60LRdOWMW1SLaOa1NIyMAj60PNaLaWEQtDXIhuPx6uOHcQeUqZdmk2KR7PPTC/WSjWmUlkXJgXCJ514AIkQmVA0ZTC7DbsmToXGINwxHu8jrdNHI3W/7j0PidITnYiZCLo6lZBIqIl15RIIOa/VckhIrL4W2WDdXqF714WQTwp0bVX7KoZTfk6ZUDRl5gilBp2GfOrCQrGxnMsF0IHQNk6EassYV9C5a7KbcmaS1aJJJKRCUoIHG5jvgkxSCuCurWpf1/WUn1MmFE0ZDKHYtjsP2PNrlYap88V2JVBjheJk0mna8JDWThgtmgRCKnTR4sxbKKExw5QxFN94TgyyhTK7ZTCEolSR0dUYNHtBXbC8rHWpRL11sUtBGiMUfdxkbTWx0HZNw5pJ8KxCCWKw7+HwiaFs2qRf02QimcjsKSN81lfFzrUcQ5ndMihCUWpFdsueuTn1rrk544R3CpAeAt4rECMUfbSxtu0NsZymac00LbXAd2LEuLAG80KyJjTK1YoyP18c16VgD0HquZazvGazDI5QanARRvRbF7v0vYZq9y63RZUB1QYhk70PEg7J7tEJQ0P9wbiwUll4rrHR9fVTtHXa8agOMWhCAQ4BPkXxTvlPAQcbjtvD/vfJX1z7/kiKjSu/BnyIcjW/qwyZUHw0TquG2beFEgObhSJSxJbaCocQq6NrwWBriy2pwYN0BuHCSmnhTSbmsVFZKEOBZa6Z5miIdThES3LohPIm4Izy/zOANxqOu8fw/YeBF5T/vwsY+1x3yITSWuMcUDDaCJO/eDRK75duukZ0RNU1CdvOb9PIXaRTs1qnKnhS958pWcWwAHNq92+YazvGYy3Jjw3fJ38JWYcYOqHsAg4r/z8M2GU4bhWhAAJ8D9hQfj4euNTnukMmlMlkohYXF1cMpMXFxbCB1LX5n+L8pnN0JdxtRGtKsU61gtxmAbniSTbSaVpQNrea63m1eaZdWHjNVfMWMjEK3j7cYJprmJTC+fl5b2UxSrHs4X6HTih3Nj7/wHDcT4GdwOXAc8vvDgVurh1zOJ67IA+dUBYWFlYMooWFhalrJvvQtQXUlfvJRVTjcZoNNHWT2nZtV3aPjXSaqeKmtNaY3Y1DCHWKblaT4D1dt5ddT5a63ggiEgAAFDRJREFU735vOne26xzGZIuePBNTJxTg08ANmvKcAELZXP49CrgVeDjwYA2hXG9px2klKe3csmVL0k5OiWRB1q60lWm6h9rARlSTid+WMUrZ+zVWqLuu7yMsTP02N+e+L1Nd3+SIKbpZTYJ3t4mgp0hyPhbKxGLhWOVAT6Q+dUKxFTxdXo06FwAnMgMuLy/fbkNAvTBAi7FcuLsJPo0AdvXulDbkaJpwrl2Z6/fl6leXJWIjeNe5XfVDF/z5bNZZ9Y8PppBlNZlMjEJ6j899p2nEqvs2ueFcMRTXu3asMZSeMs6GTihvZmVQ/k2aYw4GNpb/H0qR0bWt/PwRVgblX+lz3S4IpUkeXgE4jRC5V0SdHKKZ6NClttKHJlSfpLp3p8S6onREZdLgdffluve2k7qNUHbFYmLuq04qQ3G5lrAJ36WlpWIroj7GqSX7TqdMxrxFtJr/Vrd3tlAUwAi4rCSJy4BDyu+PA84r/38ycD1wbfn3ZbX6RwFXAjeX5LLR57qpCcW0LbjTZDUMgtva7gbbpbYSYf0EZeE0hWobwWDL8nK95Et3X65+nWIswZpu67qvycRt4fTkwvIdKza30r6AfNduuMSk1WqftfUSQxliSU0oNs3COjgMk3hvSTzRaZAdCrbJZKJOH43Ubgq3wt0O7TUo/dEVoA4hR1eg2aWV19eBVHD16xRjCUops4AbjdyWj8/WJ6m3MmkgZKx4Cd8us9tsBO6puDXJU7fBZ5B3Yr1neU2rpCaUkKwOHwulteDvSLDF5MabyFY7SULcNq4+sp0rdmt/n36dQiwhqH02uPql6ruO7ilkrASNKxPa9JdtfHm0QTeXFhYWVi0ZGMLakzoyofRAKKbB7XyRUZcabRvNy1DP5mZI8h5z38CyTx+FBqmrorNMUvRrX2jTPl8LsSOry6aYNS32JAv/2ih0rkQGR/+b5pLpzZ9DQSaUHgjFltXhHBypBVTM+ao6YF2L4WOJtXqPuS0Tqx778Mn4Cg1SdygoZwqTib+lkhihilnrFfJtYo2+48swpgb7XhoHMqH0QChKBQaeu0KMxeOjlZbC3zdWVCeL1jGUZuqs7/35BJqb97jeyaQOH1JJ3F/RyS2xaGOhmGJ0nudL4rLzRUKlNRNKT4QyCMRMEB9Nq9SaXHnyJi2rVZZX/djQ+9OtfjeVKn04E0sBn77rwEppjhXfMWaq7xxrbVzOzbHqmD/NdvayV1dit3omlFkllBitIsaE9xG4DYujmrAhexMlQcz9+bpwEk24QSJ0LIVk23XcTyGafJSQTulyDlR4evFqJE78yYQyi4QSq1V0YaFYrhv6+tnWaDM5fNJiE0y4wSFmLIXEnwaUSpzcjZSCiKetnCRek5YJpUtCCRlwIcfGCs6YAa1zbVSfPSbRZDLR5s8P0nwPJZUEmXFTh+9Yqt9DSB/59FPL/vHV5JMGumPH2tDGQrZQZoRQQgPEIYPTtZGhbcCGklybXWZLzFSAMSSuontGzevrNn6sNPeuhYlPX/hoqCEuLl2xWSk9au1Jx2EqQTxtgskxlBkhlJABFzo4bemzKSdnokkzcymQIXGVel+EZPZ0KDiNbdFdz+cZ+7i4Fhbsv4emb3egbCQNdKdwFU0mq/ttYaH/pQE5y2sGCCVkwIUOTpOwSL3hnWe7XC6HXi2UlPBxgdX7ImZtS1d9EOLKchGPjRTrQshGwqb77HJfOQ2SBbpTEKFtK5xYTDlOkwlFUwZtoVTaBOx/R0Y1oW2Cq6N78NH6kmiG03INuFxg9WcUE1/wFZyh9x8iqF3nDiGn0Pvs0UJJihSCO/V8VWrq/ZkJRVMGG0NxHWd6CVOstufRLl/ro5VmOO3sGJP23WyDaTL7EpLt+qkysWIES8j1Q63k1M+2T8Wj7bW6IJSeLb4mMqFoymCzvFxCwjZAfYLzvt/V0Gl8pG6NDUGL9Ul40AnH8dhJSFbCjSGHlIK6Sai2hIKY68YIZtNYnZbiEXMPXRBKtlCGVwa7DsWlffgKX9+sHY/J2Fl8xKeNrgWL03CR2a5r+M3pEozVOlP0QV8EkaJNfbw0K6Q9rvvuglByDGV4ZbCE4tI+fH3YISvDHZOxsy0ifALcfblROoaTlKepdQ4xxhGa/JDS3aMjS1sfmci1i5inrY09IROKpgyWUGxpqVX8xOavH42UWl5OPhk72SLCFeC2EURqIRgwQWP6wrZLc29vFzQ3rnshnapNkUqRN0zPwTVOdc/NptR1vLtAl8iEoimDJRSlVmpEMVlFoWVamqjLfWcTpimFYIAwj7XWTBbKivoepNYJsaci55Ras6lNqddh+V7XlAxj+t5lYQ3UkvbBoAkFOAT4FMU75T8FHKw55qnANbXyI+C55W8XALtrvz3O57rRhBLhPw86Rx2hZn9MmaabqI1WntJCCThXbDzJtUuzTzyqM9djCuuoi0wu0/liicunnmuRqu1zSOkSHbvDhk4obwLOKP8/A3ij4/hDgO8DS2o/oZwYet0oQplMzKteTQHmZrZMyMTr2jrpY2sQF9oIh1QCLMDaicl4q6wKE5n4Zsx1lhxRNLKdEOoiDpNSMPqOl9BYSYzS16W7qwfX6dAJZRdwWPn/YcAux/GnARfVPvdHKLZVr7aBVX+gIROvKwtlCESSAqkETocWiu/7Y3xIYdDb2wwxDlOH7zMOFci+2ZT10uXc6yHBYuiEcmfj8w8cx38G+Pe1zxeUpHQd8FZgo891owjFNkhc1kT1QENXN7cxq5ttS6Hl+QrwKWahBKPDGIrLMglxW3VmoaR4VkPMFKsj5a4CpuN9lbku0QOxT51QgE8DN2jKc0IIpbRgvgssNL4TYCNwIfD7lvqnATuBnVu2bInpSTthuIS6UuETrz5YqwBg9U71+nfN31IL8hDNTbeVyYBTepVSRZvrfWnZbTkkMG7L7goNrHcSQ0nlIhl6GnfXhOdKEa5kgE9/tCH4bKH4u7yAVwPnWn7/JeASn+smd3m5rIn6OpIhTzwTQlwGJi1pKNpqEx0+k9RWRfIsrxQCSKf0TMsqNQnjruedj0Lp80qItu3MMRTezMqg/Jssx14OPLXxXUVGAvwp8Mc+140Oyi8urnxYi4srB63PflCz5A6q4GtK2ybWUPzpTXSo1SW3KlKPnTYuEt/x3hdcwrTLeedaG+Z7rZQEv06zvEbAZRRpw5cBh5TfHwecVzvuCOCbwFyj/meA60sX2gTY5HPdTtKGQ46ZNfgO9LabJHYF2zPp2O+czKroQvuMFWC+FnmfmGYcx3Tt0JjJ0JMb1MAJZVpl0Asbh4i2aZe+/uMu4Gr7kALKNuLrKjU3hqR8Y4Z9YprCOBXZD2ksGpAJZS0TSh/WUIiPXDexfP3HXcE1SX2EQV/9bGtHVwIzICFhH3yzGvtEX8LYFqdpO0ZmIMaaCWWtEkofgy/mGkNz+fkIYpuQ6CtO4BKIs2KhDDWGYqpTf+7jsX3s9jXnhjR/GsiEslYJpQ+NbAZMcCdmJU7gIr5ZiKFMe9FsiDB2PV9d/66F+dASmVDWKqH04TOegSChE7MSJ/ARVkPL8hqwJu2E72LEev+vhfnQEplQ1iqhZAvFHzHCr+84wTT852vl+cbAd6+8Olms5/4qYSKUOTJmG+ecA0tLK79bWiq+n6Vr9IFTToFbb4W9e4u/p5zirrNli/m3LvrglFPg3HNh61YQKf6ee65fW2OxVp5vDGzP13Tceu4vF3Qss17KmrBQlOo3y2tWXRuxGGqcIDXy8zUXnYW4XvurBAYLRYrf1ieOO+44tXPnzmk3I2PouOgiOOssuP32QlM955xuLYaMftF8viecAB//eH7eFojIVUqp41Z9nwklE0pGRkZGCEyEkmMoGRkZGRlJkAklIyMjIyMJMqFkZGRkZCRBJpSMjIyMjCTIhJKRkZGRkQSZUDIyMjIykiATSkZGRkZGEmRCycjIyMhIgkwoGRkZGRlJkAklIyMjIyMJBkEoInKSiNwoIntFZNVy/tpxzxSRXSJys4icUfv+SBG5QkS+JiIfEpHFflqekZGRkVFhEIQC3AD8KvAF0wEiMg/8GfAsYBtwsohsK39+I/BWpdTRwA+Al3Xb3IyMjIyMJgZBKEqpLyuldjkOeyJws1Lq60qpnwAfBJ4jIgI8DfjL8rgLged219qMjIyMDB02TLsBAXgocEft8zeAJwEj4E6l1E9r3z/UdBIROQ04rfx4j4i4iMyEQ4HvRdadVeR7Xh/I97w+0Oaet+q+7I1QROTTwL/S/HSWUupjPqfQfKcs32uhlDoXONfjevbGiOzUbd+8lpHveX0g3/P6QBf33BuhKKWe3vIU3wAOr31+GPAtCoY9SEQ2lFZK9X1GRkZGRo8YRAzFE/8AHF1mdC0CLwAuLl9H+VngxPK4lwA+Fk9GRkZGRkIMglBE5Hki8g3geOCvReTS8vvNIvJxgNL6eBVwKfBl4MNKqRvLU7wOeK2I3EwRUzm/h2a3dpvNIPI9rw/ke14fSH7P6/oVwBkZGRkZ6TAICyUjIyMjY/aRCSUjIyMjIwkyoThg2u6l9vvGcruXm8vtX47ov5Vp4XHPrxWRm0TkOhG5TES0OemzBNc91447UUSUbYugWYDP/YrIr5XP+UYR+Yu+25gaHuN6i4h8VkSuLsf2CdNoZ0qIyHtE5DsicoPhdxGRt5V9cp2IPKHVBZVSuRgKMA/cAhwFLALXAtsax7wSeFf5/wuAD0273T3c81OBpfL/8Xq45/K4B1BsD3Q5cNy0293xMz4auBo4uPz8kGm3u4d7PhcYl/9vA26ddrsT3PcvAk8AbjD8fgLwCYr1fD8HXNHmetlCsUO73UvjmOdQbPcCxfYv28vtYGYVzntWSn1WKXVf+fFyirU/swyf5wzwh8CbgB/12bgO4HO/Lwf+TCn1AwCl1Hd6bmNq+NyzAh5Y/v8g1sB6NqXUF4DvWw55DvA+VeByijV9h8VeLxOKHbrtXprbuuw7RhWpzXdRpC7PKnzuuY6XUWg4swznPYvI44HDlVKX9NmwjuDzjB8BPEJE/k5ELheRZ/bWum7gc8+vB15ULmH4OHB6P02bKkLnuxWztJfXNOCzrUvQ1i8zAO/7EZEXAccB/2+nLeoe1nsWkTngrcCpfTWoY/g84w0Ubq9forBAd4jIMUqpOztuW1fwueeTgQuUUm8RkeOB95f3vLf75k0NSeVXtlDsMG33oj1GRDZQmMo2E3Po8LlnROTpwFnAs5VSP+6pbV3Bdc8PAI4BPicit1L4mi+e4cC877j+mFLqfqXUbmAXBcHMKnzu+WXAhwGUUl8EDqDYQHEtw2u++yITih3a7V4ax1xMsd0LFNu/fEaV0a4ZhfOeS/fPuynIZNZ96+C4Z6XUXUqpQ5VSRyiljqCIGz1bKbVzOs1tDZ9x/VGK5AtE5FAKF9jXe21lWvjc8+3AdgAR+RkKQvlur63sHxcDv15me/0ccJdS6tuxJ8suLwuUUj8VkWq7l3ngPUqpG0XkbGCnUupiim1e3l9u+/J9ioE6s/C85zcDm4CPlPkHtyulnj21RreE5z2vGXje76XAvxWRm4A9wH9RSv3z9FrdDp73/NvAn4vIb1G4fU6dceUQEfkAhdvy0DI29AfAAoBS6l0UsaITgJuB+4CXtrrejPdXRkZGRsZAkF1eGRkZGRlJkAklIyMjIyMJMqFkZGRkZCRBJpSMjIyMjCTIhJKRkZGRkQSZUDIyMjIykiATSsa6hYgcISI/FJFrOjr/w0TkP3Rx7pQQkfNF5N8FHP8fReTPGt8dKCLXiMhPyoWQGesQmVAy1jtuUUo9rqNzb6fYOtwbIjLfUVtseBzFdu6+eCxwff0LpdQPy36c+R16M+KRCSVjTUNEXiIiV5UvD9rhcfyRIvIxEdkpIleKyCPL7z8iIu8Qkb8VkdtE5Cki8j4R+aqInK85z1OAPwFOLDX3Ix3n/hMR+Sxwpu+1RORRIvIFKV6A9enKMnDds4g8ojz39eWq8H+llPqG7f4beAwNQsnIAPILtnJZu4ViU8ebgMXy80GN34+g9uIhii0pLgMeXn4+AXhv+f9XgNeW/59NsVniYRQva/oBsFFz/U8Cx3ie++xaPee1ynIj8PjyuNcB53jc8wbgSuCJ5ed3Ape52tg4x/eBBxn6/Fbg0Gk/+1ymU/JeXhlrGXuAA4G3iMiFyr2Z43OBRwP/q9yjbAPFtu0HAAcBf1oe90PgfFVuoici9wE/0ZzvkRRk4Dr3IRTEQcC1fg34W6XU1eVxNwHP9rjnXwW+rJS6svx8Y3kNYxvrlUXkcOBupdRdmvvNWOfIhJKxZqGUuk9EjgF+BThXRM5TSr3TUuVngbOUUitcWCJyLPAltf+9GD8L/M/yt4cB31JKqUadEcXOrfd7nPsKVbycDQqB7ryWiGxjpdvpMcBNHvf8WOCq2udjgc/Z2tjAqvhJRkaFHEPJWLMQkaOVUvcqpT4IXEKxHbkN3waeIcULtRCRx0ihqj+GlUHrxwLXlf//bO3/Oo5kZYDadu56fd9rfZPiveeIyFHAi4H3edzzP1O826Uis5OBKsvN1MY6cvwkw4hMKBlrGWeJyC4R+RKFgLdZJwDvoZgTXy5TiV9XWh6PoRS6pUvqQFW+a52VAr+Or1BsGX6DiDzZce4mofhc6/3AZhG5nuL96L+hiu3lXff8fuBxZRt+F7gT+LLj/ut4DHCaiNxali8a+jJjHSJvX5+xbiEiRwCXKKWOmXJT1gykeKPlcUqp7027LRn9I1soGesZe4AHdbWwcT2hWthIkSm2lt/BnmFBtlAyMjIyMpIgWygZGRkZGUmQCSUjIyMjIwkyoWRkZGRkJEEmlIyMjIyMJMiEkpGRkZGRBJlQMjIyMjKSIBNKRkZGRkYSZELJyMjIyEiC/wuydcmoMi20dAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 8.19 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "xsep = c(a,b)\n",
    "\n",
    "fig, ax = plt.subplots();\n",
    "for x0 in np.linspace(-x_max,0.9*x_max,20):\n",
    "    r0 = np.array([x0, 0.])\n",
    "    v0 = np.array([0., 1.])\n",
    "    dt = 1e-3\n",
    "    Tsim = 100\n",
    "    %time pos_vel, fase = simula(Tsim,dt,v0,r0,a,b,eps, full_param)\n",
    "    ax.plot(fase[:,0], fase[:,1],'ko');\n",
    "\n",
    "for x0 in np.linspace(xsep-0.0001,xsep+0.0001,10):\n",
    "    r0 = np.array([x0, 0])\n",
    "    v0 = np.array([0., 1.])\n",
    "    dt = 1e-3\n",
    "    Tsim = 100\n",
    "    %time pos_vel, fase = simula(Tsim,dt,v0,r0,a,b,eps, full_param)\n",
    "    ax.plot(fase[:,0], fase[:,1],'ro');\n",
    "\n",
    "for x0 in np.linspace(-xsep-0.0001,-xsep+0.0001,10):\n",
    "    r0 = np.array([x0, 0])\n",
    "    v0 = np.array([0., 1.])\n",
    "    dt = 1e-3\n",
    "    Tsim = 100\n",
    "    %time pos_vel, fase = simula(Tsim,dt,v0,r0,a,b,eps, full_param)\n",
    "    ax.plot(fase[:,0], fase[:,1],'ro');\n",
    "\n",
    "ax.grid(False)\n",
    "ax.set(ylim=(-1,1),\n",
    "       xlabel=r'$s \\ [em \\ termos \\ de \\ L]$',\n",
    "       ylabel=r'$p \\ [adimensional]$',\n",
    "       title=r'Espaço de fase: $a={}$, $b = {}$, $\\epsilon = {}$'.format(a,b,eps))\n",
    "plt.show()\n",
    "fig.savefig('./imagens/bilhar_eps={}.jpg'.format(eps), dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}