1ex-Exercicio1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "# Exercício 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "Uma boa parte do trabalho das disciplinas de Física Experimental é o de calcular ajustes de reta para um dado conjunto de dados e uma teoria.\n",
    "Considere um conjunto de dados $\\{(x_1,y_1),(x_2,y_2),...,(x_n,y_n)\\}$ para o qual a teoria diz que a relação entre $x$ e $y$ é dada por:\n",
    "\n",
    "$$\n",
    "y = a + bx\n",
    "$$\n",
    "\n",
    "Sabendo que as medidas estão sujeitas a várias formas de imprecisão e que a teoria não conta com todas tais contribuições, consideremos o modelo pára os dados\n",
    "\n",
    "$$\n",
    "y_i = a + bx_i + \\xi_i\n",
    "$$\n",
    "\n",
    "onde $\\xi_i$ são valores de ruído que assumimos ser Gausiano.\n",
    "\n",
    "Os valores de $a$ e $b$ que melhor descrevem essa teoria devem ser aqueles que maximizam a verossimilhança de obsevar um certo valor de ruído, ou seja, minimizam $\\sum_i\\xi_i^2 = \\sum_i(y_i - a - bx_i)^2$.\n",
    "\n",
    "A solução desse problema é dada por:\n",
    "$$\n",
    "\\hat{a} = \\bar{y} - \\hat{b}\\bar{x}\\\\\n",
    "\\hat{b} = \\frac{\\sum_i(x_i-\\bar{x})(y_i-\\bar{y})}{\\sum_i(x_i-\\bar{x})^2}\n",
    "$$\n",
    "\n",
    "onde\n",
    "$$\n",
    "\\bar{x} = \\frac{1}{n}\\sum_i x_i\\\\\n",
    "\\bar{y} = \\frac{1}{n}\\sum_i y_i\n",
    "$$\n",
    "são as médias amostrais de $x$ e $y$\n",
    "\n",
    "Com seu conhecimento de Python, implemente funções para calcular a os coeficientes de ajuste da reta e aplique-os para o seguinte conjunto de dados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-19T14:22:17.529203Z",
     "start_time": "2017-07-19T14:22:17.518896Z"
    },
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "+--------+--------+\n",
      "|    x   |    y   |\n",
      "+--------+--------+\n",
      "|  -10.0 |  -32.8 |\n",
      "|   -9.0 |  -29.9 |\n",
      "|   -8.0 |  -25.6 |\n",
      "|   -7.0 |  -21.2 |\n",
      "|   -6.0 |  -19.5 |\n",
      "|   -5.0 |  -16.0 |\n",
      "|   -4.0 |  -10.7 |\n",
      "|   -3.0 |  -7.98 |\n",
      "|   -2.0 |  -5.72 |\n",
      "|   -1.0 |  -1.21 |\n",
      "|    0.0 |   1.29 |\n",
      "|    1.0 |   4.78 |\n",
      "|    2.0 |   8.99 |\n",
      "|    3.0 |   10.3 |\n",
      "|    4.0 |   14.0 |\n",
      "|    5.0 |   18.7 |\n",
      "|    6.0 |   21.7 |\n",
      "|    7.0 |   26.6 |\n",
      "|    8.0 |   28.8 |\n",
      "|    9.0 |   31.8 |\n",
      "|   10.0 |   38.2 |\n",
      "+--------+--------+\n"
     ]
    }
   ],
   "source": [
    "from numpy.random import randn, seed\n",
    "seed(42)\n",
    "a_real, b_real = 1.75, 3.5\n",
    "amostra = {x: y for (x, y) in zip(range(-10,11), [a_real + b_real*x_i + randn()\n",
    "                                                  for x_i in range(-10,11)])}\n",
    "print(\"\"\"\n",
    "+--------+--------+\n",
    "|    x   |    y   |\n",
    "+--------+--------+\n",
    "\"\"\" + \"\\n\".join([f\"| {float(x):6.3} | {y:6.3} |\" for (x,y) in amostra.items()]) +\\\n",
    "\"\"\"\n",
    "+--------+--------+\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "run_control": {
     "frozen": false,
     "read_only": false
    }
   },
   "source": [
    "No dicionário chamado `amostra`, as chaves são os medidas de $x$ e os valores são as de $y$. \n",
    "\n",
    "A linha \n",
    "\n",
    "```python\n",
    "from numpy.random import randn, seed\n",
    "```\n",
    "\n",
    "está importando uma função de uma biblioteca para gerar números aleatórios com distribuição normal e uma função para definir o estado inicial do gerador de números (pseudo)aleatórios, para que todos tenham os mesmos dados.\n",
    "\n",
    "Note que, como os dados são fictícios, sabemos exatamente os valores dos coeficientes linear e angular definidos nas variáveis `a_real` e `b_real`.\n",
    "\n",
    "Para entender a função `zip`, veja o exemplo a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-07-19T14:20:46.146502Z",
     "start_time": "2017-07-19T14:20:46.133071Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "tupla1 = (1, 2, 3, 4, 5)\n",
      "tupla2 = (10, 20, 30, 40, 50)\n",
      "zip12 = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50)]\n",
      "unzip1 = (1, 2, 3, 4, 5) == tupla1\n",
      "unzip2 = (10, 20, 30, 40, 50) == tupla2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tupla1 = (1,2,3,4,5)\n",
    "tupla2 = (10,20,30,40,50)\n",
    "zip12 = list(zip(tupla1, tupla2))\n",
    "unzip1, unzip2 = zip(*zip12)\n",
    "print(f\"\"\"\n",
    "tupla1 = {tupla1}\n",
    "tupla2 = {tupla2}\n",
    "zip12 = {zip12}\n",
    "unzip1 = {unzip1} == tupla1\n",
    "unzip2 = {unzip2} == tupla2\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que, embora a função `zip` seja muito útil, ela não essencial nem para construir esses dados, nem para a solução do problema.\n",
    "O que vocês precisam saber para resolver esse problema:\n",
    "  - como acessar as chaves e os valores de um dicionário\n",
    "  - criar novas listas com valores calculados usando o modelo e as fórmulas para o coeficiente\n",
    "  - como imprimir os resultados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solução"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n",
       " [-32.75328584698877,\n",
       "  -29.888264301171183,\n",
       "  -25.60231146189931,\n",
       "  -21.226970143591974,\n",
       "  -19.484153374723334,\n",
       "  -15.98413695694918,\n",
       "  -10.670787184492609,\n",
       "  -7.9825652708470916,\n",
       "  -5.719474385934952,\n",
       "  -1.2074399564140355,\n",
       "  1.2865823071875377,\n",
       "  4.7842702464297435,\n",
       "  8.991962271566035,\n",
       "  10.336719755342202,\n",
       "  14.025082167486968,\n",
       "  18.687712470759028,\n",
       "  21.737168879665575,\n",
       "  26.564247332595272,\n",
       "  28.84197592447879,\n",
       "  31.83769629866471,\n",
       "  38.215648768921554])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x,y = list(amostra.keys()), list(amostra.values())\n",
    "x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 1.6566513114326167)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_barra = sum(x)/len(x)\n",
    "y_barra = sum(y)/len(y)\n",
    "x_barra, y_barra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.435271311235283"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numerador = 0\n",
    "denominador = 0\n",
    "for i in range(len(x)):\n",
    "    numerador += (x[i] - x_barra)*(y[i] - y_barra)\n",
    "    denominador += (x[i] - x_barra)**2\n",
    "b_chapeu = numerador/denominador\n",
    "b_chapeu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6566513114326167"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_chapeu = y_barra - x_barra*b_chapeu\n",
    "a_chapeu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.75, 1.6566513114326167)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_real, a_chapeu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.5, 3.435271311235283)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_real, b_chapeu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def coeficientes_lineares(dados):\n",
    "    # dados é um dicionário\n",
    "    numerador = 0\n",
    "    denominador = 0\n",
    "    x_barra, y_barra = sum(dados.keys())/len(dados.keys()), sum(dados.values())/len(dados.values())\n",
    "    for (xi,yi) in dados.items():\n",
    "        numerador += (xi - x_barra)*(yi - y_barra)\n",
    "        denominador += (xi - x_barra)**2\n",
    "    b_chapeu = numerador/denominador\n",
    "    a_chapeu = y_barra - x_barra*b_chapeu\n",
    "    return a_chapeu, b_chapeu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.38 µs ± 166 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit coeficientes_lineares(amostra)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array(list(amostra.keys()))\n",
    "y = np.array(list(amostra.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.435271311235283"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((x - x.mean())*(y - y.mean())).sum()/(((x - x.mean())*(x - x.mean()))).sum()"
   ]
  }
 ],
 "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.6.4"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "48px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}