Assignments/PT-BR/Assignment_7_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1)** A função `maxx` recebe dois números e retorna o maior entre eles.\n",
    "\n",
    ">```python\n",
    ">def maxx(x, y):\n",
    ">    if x >= y:\n",
    ">        return x\n",
    ">    else:\n",
    ">        return y\n",
    ">```\n",
    "\n",
    "Crie uma nova função `maxx2` que receba duas arrays numpy de mesma dimensão e retorne uma nova array com os máximos calculados elemento a elemento. Além disso, sua função deve levantar a excessão `ValueError` quando as dimensões das entradas divergirem.\n",
    "\n",
    "Exemplos:\n",
    "\n",
    ">```python\n",
    ">>>> a = np.array([5, 7, 9, 8, 6, 4, 5])\n",
    ">>>> b = np.array([6, 3, 4, 8, 9, 7, 1])\n",
    ">>>> maxx2(a, b)\n",
    ">>>> array([ 6.,  7.,  9.,  8.,  9.,  7.,  5.])\n",
    ">```\n",
    "\n",
    ">```python\n",
    ">>>> a = np.array([[0, 5], [5, 0]])\n",
    ">>>> b = np.array([[1, 0], [0, 1]])\n",
    ">>>> maxx2(a, b)\n",
    ">>>> array([[1., 5.],\n",
    ">            [5., 1.]])\n",
    ">```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 17.  ,   9.14, 127.  ,   5.5 ,  13.8 ])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "def maxx2(a, b):\n",
    "#     if a.shape != b.shape:\n",
    "#         raise ValueError(\"Dimensões divergentes!\")\n",
    "    c = np.zeros(a.shape)\n",
    "    for i in range(a.shape[0]):\n",
    "        if len(a.shape)==1:\n",
    "            if a[i] >= b[i]:\n",
    "                c[i] = a[i]\n",
    "            else:\n",
    "                c[i] = b[i]\n",
    "        else:\n",
    "            for j in range(a.shape[1]):\n",
    "                if a[i][j] >= b[i][j]:\n",
    "                    c[i][j] = a[i][j]\n",
    "                else:\n",
    "                    c[i][j] = b[i][j]\n",
    "    return c\n",
    "\n",
    "\n",
    "#Solução alternativa\n",
    "# def maxx2(a,b):\n",
    "#     return np.maximum(a,b)\n",
    "## ValueError já é implementado internamente!\n",
    "\n",
    "a = np.array([17,0.15,10,5.5,13.8])\n",
    "b = np.array([3.14,9.14,127,-15,8.8])\n",
    "maxx2(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2)** Dado um numpy array 1D, faça com que a função `picos` determine os máximos locais (valores cujos antecessor e sucessor sejam menores que eles), retornando um array de posição dos mesmos. Veja o caso a seguir:\n",
    "\n",
    ">```python\n",
    ">>>> a = np.array([1, 3, 7, 1, 2, 6, 0, 1])\n",
    ">>>> picos(a)\n",
    ">array([2, 5])\n",
    ">```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5, 7])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def picos(a):\n",
    "    doublediff = np.diff(np.sign(np.diff(a)))\n",
    "    return np.where(doublediff == -2)[0] + 1\n",
    "\n",
    "picos(np.array([1,4,13.5,11.4,-15,127,0.6,11,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3)** Programe a função `binarray`, usando exclusivamente numpy, para que ela receba uma lista de inteiros positivos e retorne uma matriz onde cada elemento é a representação binária, em 8 bits, dos números dados. Veja exemplo abaixo:\n",
    "\n",
    ">```python\n",
    ">>>> binarray( [0, 1, 3, 5, 7, 9, 11, 13, 15] )\n",
    ">[[0 0 0 0 0 0 0 0]\n",
    ">  [0 0 0 0 0 0 0 1]\n",
    ">  [0 0 0 0 0 0 1 1]\n",
    ">  [0 0 0 0 0 1 0 1]\n",
    ">  [0 0 0 0 0 1 1 1]\n",
    ">  [0 0 0 0 1 0 0 1]\n",
    ">  [0 0 0 0 1 0 1 1]\n",
    ">  [0 0 0 0 1 1 0 1]\n",
    ">  [0 0 0 0 1 1 1 1]]\n",
    ">```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 1, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 1, 1, 1, 1],\n",
       "       [0, 1, 1, 1, 1, 1, 1, 1],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 1],\n",
       "       [0, 0, 0, 0, 1, 0, 0, 1]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def binarray(l):\n",
    "    nums = np.array(l)\n",
    "    bin_nums = ((nums.reshape(-1,1) & (2**np.arange(8))) != 0).astype(int)\n",
    "    return(bin_nums[:,::-1])\n",
    "\n",
    "binarray([8,15,127,1,9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4)** Programe a função `strides` para que, dado um numpy array 1D, um tamanho de 'stride' e um tamanho de 'window', devolva o array com o stride correspondente gerado. Veja exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> a = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14])\n",
    ">\n",
    ">>>> strides(a,2,4)\n",
    ">array([[ 0,  1,  2,  3],\n",
    ">        [ 2,  3,  4,  5],\n",
    ">        [ 4,  5,  6,  7],\n",
    ">        [ 6,  7,  8,  9],\n",
    ">        [ 8,  9, 10, 11],\n",
    ">        [10, 11, 12, 13]])\n",
    ">\n",
    ">>>> strides(a,3,6)\n",
    ">array([[ 0,  1,  2,  3,  4,  5],\n",
    ">        [ 3,  4,  5,  6,  7,  8],\n",
    ">        [ 6,  7,  8,  9, 10, 11],\n",
    ">        [ 9, 10, 11, 12, 13, 14]])\n",
    ">```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4],\n",
       "       [ 3,  4,  5,  6],\n",
       "       [ 5,  6,  7,  8],\n",
       "       [ 7,  8,  9, 10]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def strides(a, stride_len, window_len):\n",
    "    n_strides = ((a.size-window_len)//stride_len) + 1\n",
    "    return np.array([a[s:(s+window_len)] for s in np.arange(0, n_strides*stride_len, stride_len)])\n",
    "\n",
    "a = np.array([1,2,3,4,5,6,7,8,9,10])\n",
    "strides(a,2,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5)** O método de Gram-Schmidt é um método utilizado para a ortogonalização de um conjunto de vetores em um espaço. Para mais detalhes sobre o algoritmo, [clique aqui](https://pt.wikipedia.org/wiki/Processo_de_Gram-Schmidt). Seu trabalho é, usando o numpy, implementar a função `gs`, que recebe uma lista contendo os vetores da base em questão e retorna um numpy array com a base devidamente ortonormalizada em suas colunas. Segue um exemplo:\n",
    "\n",
    ">```python\n",
    "># `A` é a lista de vetores da base original\n",
    ">>>> A=[(1,0,1),(1,1,0),(0,1,1)]\n",
    ">\n",
    "># Cada coluna do resultado é um vetor da base ortonormal\n",
    ">>>> gs(A)\n",
    ">array([[ 0.70710678,  0.40824829, -0.57735027],\n",
    ">        [ 0.        ,  0.81649658,  0.57735027],\n",
    ">        [ 0.70710678, -0.40824829,  0.57735027]])\n",
    ">```\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.18257419,  0.13794078,  0.87305858, -0.43058997],\n",
       "       [ 0.36514837,  0.90847622, -0.15500704,  0.13156916],\n",
       "       [ 0.54772256, -0.19241421, -0.42628374, -0.69372829],\n",
       "       [ 0.73029674, -0.34441265,  0.17895168,  0.56215913]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def gs(X, row_vecs=True, norm = True):\n",
    "    X=np.array(X)\n",
    "    if not row_vecs:\n",
    "        X = X.T\n",
    "    Y = X[0:1,:].copy()\n",
    "    for i in range(1, X.shape[0]):\n",
    "        proj = np.diag((X[i,:].dot(Y.T)/np.linalg.norm(Y,axis=1)**2).flat).dot(Y)\n",
    "        Y = np.vstack((Y, X[i,:] - proj.sum(0)))\n",
    "    if norm:\n",
    "        Y = np.diag(1/np.linalg.norm(Y,axis=1)).dot(Y)\n",
    "    if row_vecs:\n",
    "        return Y.transpose()\n",
    "    else:\n",
    "        return (Y.T).transpose()\n",
    "    \n",
    "A = [(1,2,3,4),(0.5,13,-10,-15),(1,-1,0,1),(3,0,-1,2)]\n",
    "gs(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desafio\n",
    "\n",
    "**6)** O sistema de amortização por [Tabela Price](https://pt.wikipedia.org/wiki/Tabela_Price?oldformat=true) é um método utilizado para amortização de empréstimos e dívidas, que apresenta como principal característica, prestações/parcelas constantes.\n",
    "\n",
    "Apesar do valor da parcela ser constante, a cada período, uma parte dessa parcela é dedicada para os juros da operação, enquanto outra parte é dedicada ao abatimento do valor inicial (amortização do principal). Os juros são calculados com base no principal devido, então a tendência natural é que o valor da parcela dedicado aos juros seja grande no início, e vai caindo conforme o valor devido for sendo amortizado.\n",
    "\n",
    "Veja abaixo um exemplo de uma Tabela Price, de um empréstimo de R$200 mil tomados à taxa de juros de 0.6% a.m com um financiamento de 30 anos (360 meses). A coluna Saldo Inical mostra o quanto do valor principal era devido naquele determinado mês antes do pagamento, e a coluna Saldo Final mostra o saldo devedor após a amortização. \n",
    "\n",
    "```\n",
    "     Saldo Inicial  Amortização    Juros  Saldo Final\n",
    "1        200000.00      -157.58 -1200.00    199842.42\n",
    "2        199842.42      -158.52 -1199.05    199683.90\n",
    "3        199683.90      -159.47 -1198.10    199524.43\n",
    "4        199524.43      -160.43 -1197.15    199364.00\n",
    "5        199364.00      -161.39 -1196.18    199202.61\n",
    "..             ...          ...      ...          ...\n",
    "356        6667.39     -1317.57   -40.00      5349.82\n",
    "357        5349.82     -1325.48   -32.10      4024.34\n",
    "358        4024.34     -1333.43   -24.15      2690.91\n",
    "359        2690.91     -1341.43   -16.15      1349.48\n",
    "360        1349.48     -1349.48    -8.10         0.00\n",
    "```\n",
    "\n",
    "Observe que os valores de juros e amortização são lançados como negativos pois são despesas para o devedor.\n",
    "\n",
    "Acima, o devedor tem uma despesa mensal fixa de 1357 reais (juros + amortizações). Note que porção dedicada ao pagamento de juros é bem alta nos primeiros meses, e bem baixa nos últimos, dando espaço para o crescimento da porção de amortizações ao longo dos meses.\n",
    "\n",
    "A proposta do desafio é a implementação de uma classe chamada `price` que entre outras funcionalidades, irá gerar um DataFrame similar ao apresentado acima.\n",
    "\n",
    "### Inicialização\n",
    "A função `__init__` receberá os parâmetros `vp, r` e  `n`, respectivamente valor presente (dívida inicial contratada), taxa de juros (na forma decimal), e quantidade de períodos. Aqui as unidades de `r` e `n` serão passadas de forma consistente, por exemplo, se a taxa for mensal, `n` deverá ser passado em meses.\n",
    "\n",
    "Além disso você deve criar um novo atributo `parcela` que irá armezanar o valor da parcela a ser paga a cada período. O cálculo segundo é feito pela fórmula abaixo:\n",
    "\n",
    "\\begin{equation}\n",
    "\\dfrac{VP\\cdot r}{1-(1+r)^{-n}}\n",
    "\\end{equation}\n",
    "\n",
    "Veja um exemplo de intância da classe do exemplo dado acima:\n",
    "\n",
    ">```python\n",
    ">>>> minha_divida = price(200000,.006,360)\n",
    ">>>> minha_divida.vp\n",
    ">200000\n",
    ">>>> minha_divida.r\n",
    ">0.006\n",
    ">>>> minha_divida.n\n",
    ">360\n",
    ">>>> minha_divida.parcela\n",
    ">1357.5764189349288\n",
    ">```\n",
    "\n",
    "Se tratanto de quantidades monetárias, seria conveniente arredondar o valor acima para duas casas decimais, nossa sugestão é que deixe os floats da forma que estão, e arredonde somente na exibição final da tabela (último exercicio) para evitar acúmulo de erros numéricos, mas fique à vontade para implementar da forma que preferir.\n",
    "\n",
    "### Saldo Devedor\n",
    "\n",
    "Complete a implementação do método `saldo_devedor` que recebe uma valor `m` e calcula o valor principal ainda devido do m-ésimo período após os pagamentos. O método Price também tem uma fórmula fechada pra isso:\n",
    "\n",
    "\\begin{equation}\n",
    "VP \\cdot (1+r)^m -p \\cdot \\dfrac{(1+r)^m-1}{r}\n",
    "\\end{equation}\n",
    "\n",
    "onde `p` é o valor fixo da parcela.\n",
    "\n",
    "Veja a execução do exemplo anterior, mostrando os saldos devedores nos tempos 0, 1, 180 e 360 representando respectivamente, o saldo antes de qualquer pagamento, saldo após o primeiro pagamento, após 15 anos, e no final do financiamento após 30 anos.\n",
    "\n",
    ">```python\n",
    ">>>> minha_divida = price(200000,.006,360)\n",
    ">>>> minha_divida.saldo_devedor(0)\n",
    ">200000.0\n",
    ">>>> minha_divida.saldo_devedor(1)\n",
    ">199842.42358106506\n",
    ">>>> minha_divida.saldo_devedor(180)\n",
    ">149176.5598701932\n",
    ">>>> minha_divida.saldo_devedor(360)\n",
    ">0.0\n",
    ">```\n",
    "\n",
    "### Arrays de Juros e Amortizações\n",
    "\n",
    "Complete a implementação dos métodos `juros` e `amortizacao`. A primeira deve retornar uma array numpy de tamanho `n` onde a i-ésima entrada contém o pagamento de juros no período i. A segunda retorna uma array de mesmo tamanho, porém a i-ésima entrada conterá o valor de amortização pago no i-ésimo período. \n",
    "\n",
    "**ATENÇÃO:** Os valores internos das arrays deverão ser negativos, pois representam um gasto para o devedor, essa é a convenção utilizada no mercado!\n",
    "\n",
    "Dado um período t, o módulo do pagamento de juros nada mais é do que uma multiplicação da taxa r, pelo saldo devedor principal do período t-1.\n",
    "\n",
    "A amortização de um determinado período i, pode ser calculada de duas formas:\n",
    "\n",
    "    1 - Lembrando que o módulo de (juro + amortização) é igual à parcela fixa.\n",
    "\n",
    "    2 - Pela fórmula:\n",
    "\n",
    "\\begin{equation}\n",
    "A_t = A_1 \\cdot (1+r)^{t-1}\n",
    "\\end{equation}\n",
    "\n",
    "onde A<sub>t</sub> é a porção de amortização a ser paga no período t, e A<sub>1</sub> é a amortização no período 1\n",
    "\n",
    "Veja a execução dessas funções no exemplo dos R$200 mil:\n",
    "\n",
    ">```python\n",
    ">>>> minha_divida = price(200000,.006,360)\n",
    ">>>> minha_divida.juros()\n",
    ">array([-1200., -1199.05454149, -1198.10341022, \n",
    ">        ..., -24.14604523,   -16.14546299,    -8.09687725])\n",
    ">>>> minha_divida.amortizacao()\n",
    ">array([ -157.57641893,  -158.52187745,  -159.47300871, \n",
    ">        ..., -1333.43037371, -1341.43095595, -1349.47954168])\n",
    ">```\n",
    "\n",
    "### Tabela Price\n",
    "\n",
    "\n",
    "Finalmente, complete o método `tabela` que deve retornar um DataFrame pandas com as seguintes características:\n",
    "\n",
    "- Índices (index) se referem aos períodos (começam com 1 e termina com n)\n",
    "\n",
    "- Colunas: Saldo Inicial, Amortização, Juros e Saldo Final, onde:\n",
    "\n",
    "  **Saldo Inicial** é o principal devido antes da realização do pagamento.\n",
    "\n",
    "  **Amortização** é a porção da prestação fixa destinada à amortizar o principal\n",
    "\n",
    "  **Juros** é a porção da prestação fixa destinada destinada ao pagamento de juros de acordo com a taxa contratada.\n",
    "\n",
    "  **Saldo Final** é a quantida devida do principal, após a realização do pagamento da prestação.\n",
    "\n",
    "- Todos os número devem ter no máximo 2 casas decimais.\n",
    "- Utilize os métodos construídos anteriormente.\n",
    "  \n",
    "\n",
    "Exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> minha_divida = price(200000,.006,360)\n",
    ">>>> minha_divida.tabela()\n",
    ">     Saldo Inicial  Amortização    Juros  Saldo Final\n",
    ">1        200000.00      -157.58 -1200.00    199842.42\n",
    ">2        199842.42      -158.52 -1199.05    199683.90\n",
    ">3        199683.90      -159.47 -1198.10    199524.43\n",
    ">4        199524.43      -160.43 -1197.15    199364.00\n",
    ">5        199364.00      -161.39 -1196.18    199202.61\n",
    ">..             ...          ...      ...          ...\n",
    ">356        6667.39     -1317.57   -40.00      5349.82\n",
    ">357        5349.82     -1325.48   -32.10      4024.34\n",
    ">358        4024.34     -1333.43   -24.15      2690.91\n",
    ">359        2690.91     -1341.43   -16.15      1349.48\n",
    ">360        1349.48     -1349.48    -8.10         0.00\n",
    ">\n",
    ">[360 rows x 4 columns]\n",
    ">```\n",
    "\n",
    "**Dicas:**\n",
    "\n",
    "- O saldo inicial do período t, é o saldo final do período t-1\n",
    "- Pesquise sobre o método DataFrame.round()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250000\n",
      "3586.7737100646827\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>Saldo Inicial</th>\n",
       "      <th>Amortização</th>\n",
       "      <th>Juros</th>\n",
       "      <th>Saldo Final</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>250000.00</td>\n",
       "      <td>-1086.77</td>\n",
       "      <td>-2500.00</td>\n",
       "      <td>248913.23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>248913.23</td>\n",
       "      <td>-1097.64</td>\n",
       "      <td>-2489.13</td>\n",
       "      <td>247815.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>247815.58</td>\n",
       "      <td>-1108.62</td>\n",
       "      <td>-2478.16</td>\n",
       "      <td>246706.97</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>246706.97</td>\n",
       "      <td>-1119.70</td>\n",
       "      <td>-2467.07</td>\n",
       "      <td>245587.26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>245587.26</td>\n",
       "      <td>-1130.90</td>\n",
       "      <td>-2455.87</td>\n",
       "      <td>244456.36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>116</th>\n",
       "      <td>17408.16</td>\n",
       "      <td>-3412.69</td>\n",
       "      <td>-174.08</td>\n",
       "      <td>13995.47</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>117</th>\n",
       "      <td>13995.47</td>\n",
       "      <td>-3446.82</td>\n",
       "      <td>-139.95</td>\n",
       "      <td>10548.65</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>118</th>\n",
       "      <td>10548.65</td>\n",
       "      <td>-3481.29</td>\n",
       "      <td>-105.49</td>\n",
       "      <td>7067.36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>119</th>\n",
       "      <td>7067.36</td>\n",
       "      <td>-3516.10</td>\n",
       "      <td>-70.67</td>\n",
       "      <td>3551.26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>120</th>\n",
       "      <td>3551.26</td>\n",
       "      <td>-3551.26</td>\n",
       "      <td>-35.51</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>120 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Saldo Inicial  Amortização    Juros  Saldo Final\n",
       "1        250000.00     -1086.77 -2500.00    248913.23\n",
       "2        248913.23     -1097.64 -2489.13    247815.58\n",
       "3        247815.58     -1108.62 -2478.16    246706.97\n",
       "4        246706.97     -1119.70 -2467.07    245587.26\n",
       "5        245587.26     -1130.90 -2455.87    244456.36\n",
       "..             ...          ...      ...          ...\n",
       "116       17408.16     -3412.69  -174.08     13995.47\n",
       "117       13995.47     -3446.82  -139.95     10548.65\n",
       "118       10548.65     -3481.29  -105.49      7067.36\n",
       "119        7067.36     -3516.10   -70.67      3551.26\n",
       "120        3551.26     -3551.26   -35.51         0.00\n",
       "\n",
       "[120 rows x 4 columns]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class price:\n",
    "    def __init__(self,vp,r,n):\n",
    "        self.vp = vp\n",
    "        self.r = r\n",
    "        self.n = n\n",
    "        self.parcela = vp*r/(1-(1+r)**(-n))\n",
    "        self.meses = np.arange(1,n+1)\n",
    "\n",
    "    def saldo_devedor(self,m):\n",
    "        d = (1+self.r)**m\n",
    "        return self.vp*d-self.parcela*(d-1)/self.r\n",
    "\n",
    "    def juros(self):\n",
    "        return - self.saldo_devedor(self.meses-1)*self.r\n",
    "\n",
    "    def amortizacao(self):\n",
    "        return -self.parcela -self.juros()\n",
    "    \n",
    "\n",
    "    def tabela(self):\n",
    "        cols = ['Saldo Inicial', 'Amortização', 'Juros', 'Saldo Final']\n",
    "        dados = [self.saldo_devedor(self.meses-1),self.amortizacao()\n",
    "                ,self.juros(),self.saldo_devedor(self.meses)]\n",
    "\n",
    "        tabela = pd.DataFrame(dados, columns=self.meses, index=cols).T\n",
    "        return tabela.round(2)\n",
    "\n",
    "divida = price(250000,0.01,120)\n",
    "print(divida.vp)\n",
    "print(divida.parcela)\n",
    "divida.tabela()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ".............\n",
      "----------------------------------------------------------------------\n",
      "Ran 13 tests in 0.162s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7f63eed43580>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest \n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "class gprice:\n",
    "    def __init__(self,vp,r,n):\n",
    "        self.vp = vp\n",
    "        self.r = r\n",
    "        self.n = n\n",
    "        self.parcela = vp*r/(1-(1+r)**(-n))\n",
    "        self.meses = np.arange(1,n+1)\n",
    "\n",
    "    def saldo_devedor(self,m):\n",
    "        d = (1+self.r)**m\n",
    "        return self.vp*d-self.parcela*(d-1)/self.r\n",
    "\n",
    "    def juros(self):\n",
    "        return - self.saldo_devedor(self.meses-1)*self.r\n",
    "\n",
    "    def amortizacao(self):\n",
    "        return -self.parcela -self.juros()\n",
    "    \n",
    "\n",
    "    def tabela(self):\n",
    "        cols = ['Saldo Inicial', 'Amortização', 'Juros', 'Saldo Final']\n",
    "        dados = [self.saldo_devedor(self.meses-1),self.amortizacao()\n",
    "                ,self.juros(),self.saldo_devedor(self.meses)]\n",
    "\n",
    "        tabela = pd.DataFrame(dados, columns=self.meses, index=cols).T\n",
    "        return tabela.round(2)\n",
    "    \n",
    "    \n",
    "class UnitTests(unittest.TestCase):\n",
    "    \n",
    "    def test_maxx2(self):\n",
    "        # 1.0 pts\n",
    "        a1 = np.array([5, 7, 9, 8, 6, 4, 5])\n",
    "        b1 = np.array([6, 3, 4, 8, 9, 7, 1])\n",
    "        r1 = np.array([6., 7., 9., 8., 9., 7., 5.])\n",
    "        a2 = np.array([[0, 5], [5, 0]])\n",
    "        b2 = np.array([[1, 0], [0, 1]])\n",
    "        r2 = np.array([[1., 5.],[5., 1.]])\n",
    "        self.assertTrue (np.array_equal(maxx2(a1,b1),r1))\n",
    "        self.assertTrue (np.array_equal(maxx2(a2,b2),r2))\n",
    "\n",
    "    def test_maxx2_exception(self):\n",
    "        #0.5 pts\n",
    "        a = np.array([5, 7, 9, 8, 6, 4, 5])\n",
    "        b = np.eye(3)           \n",
    "        with self.assertRaises(ValueError): maxx2(a,b)\n",
    "        \n",
    "\n",
    "    def test_picos(self):\n",
    "        #1.5 pts\n",
    "        a = np.array([1, 3, 7, 1, 2, 6, 0, 1])\n",
    "        b = np.array([1, 3, 1, 4, 2, 6, 7, 1])\n",
    "        ra = np.array([2, 5])\n",
    "        rb = np.array([1, 3, 6])\n",
    "        self.assertTrue(np.array_equal(picos(a),ra))\n",
    "        self.assertTrue(np.array_equal(picos(b),rb))\n",
    "\n",
    "    def test_binarray(self):\n",
    "        #2.0 pts\n",
    "        a = [0, 1, 3, 5, 7, 9, 11, 13, 15]\n",
    "        r = np.array([[0, 0, 0, 0, 0, 0, 0, 0],[0, 0, 0, 0, 0, 0, 0, 1],[0, 0, 0, 0, 0, 0, 1, 1],\n",
    "                      [0, 0, 0, 0, 0, 1, 0, 1],[0, 0, 0, 0, 0, 1, 1, 1],[0, 0, 0, 0, 1, 0, 0, 1],\n",
    "                      [0, 0, 0, 0, 1, 0, 1, 1],[0, 0, 0, 0, 1, 1, 0, 1],[0, 0, 0, 0, 1, 1, 1, 1]])\n",
    "        self.assertTrue (np.array_equal(binarray(a), r))\n",
    "\n",
    "    def test_strides(self):\n",
    "        #2.0 pts\n",
    "        a = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14])\n",
    "        r1 = np.array([[ 0,  1,  2,  3],[ 2,  3,  4,  5],[ 4,  5,  6,  7],\n",
    "                       [ 6,  7,  8,  9],[ 8,  9, 10, 11],[10, 11, 12, 13]])\n",
    "        r2 = np.array([[ 0,  1,  2,  3,  4,  5],[ 3,  4,  5,  6,  7,  8],\n",
    "                       [ 6,  7,  8,  9, 10, 11],[ 9, 10, 11, 12, 13, 14]])\n",
    "        self.assertTrue (np.array_equal(strides(a,2,4),r1))\n",
    "        self.assertTrue (np.array_equal(strides(a,3,6),r2))\n",
    "\n",
    "    def test_gs(self):\n",
    "        #3.0 pts\n",
    "        A = [(1,0,1),(1,1,0),(0,1,1)]\n",
    "        B = [(3,1),(2,2)]\n",
    "        RA = np.array([[0.70710678,0.40824829,-0.57735027],[0.,0.81649658,0.57735027],[0.70710678,-0.40824829,0.57735027]])\n",
    "        RB = np.array([[ 0.9486833 , -0.31622777],[ 0.31622777,  0.9486833 ]])\n",
    "        np.testing.assert_array_almost_equal(gs(A),RA, decimal = 1)\n",
    "        np.testing.assert_array_almost_equal(gs(B),RB, decimal = 1)\n",
    "\n",
    "    def test_price_init(self):\n",
    "        # 0.5 pts\n",
    "        div1 = price(200000,.006,360)\n",
    "        self.assertTrue (div1.vp == 200000)\n",
    "        self.assertTrue (div1.r == .006)\n",
    "        self.assertTrue (div1.n == 360)\n",
    "        self.assertAlmostEqual (div1.parcela, 1357.5764189349288, delta=0.1)\n",
    "\n",
    "    def test_price_saldo_devedor(self):\n",
    "        # 1.0 pts\n",
    "        div1 = price(200000,.006,360)\n",
    "        self.assertAlmostEqual (div1.saldo_devedor(0), 200000, delta=0.1)\n",
    "        self.assertAlmostEqual (div1.saldo_devedor(1), 199842.42358106506, delta=0.1)\n",
    "        self.assertAlmostEqual (div1.saldo_devedor(180), 149176.5598701932, delta=0.1)\n",
    "        self.assertAlmostEqual (div1.saldo_devedor(360), 0.0, delta=0.1)\n",
    "\n",
    "    def test_price_juros(self):\n",
    "        # 0.5 pts\n",
    "        div1 = price(200000,.006,360)\n",
    "        div2 = gprice(200000,.006,360)\n",
    "        np.testing.assert_array_almost_equal(div1.juros(),div2.juros(), decimal = 1)\n",
    "\n",
    "    def test_price_amortizacao(self):\n",
    "        #0.5 pts\n",
    "        div1 = price(200000,.006,360)\n",
    "        div2 = gprice(200000,.006,360)\n",
    "        np.testing.assert_array_almost_equal(div1.amortizacao(),div2.amortizacao(), decimal = 1)\n",
    "\n",
    "    def test_tabela_structure(self):\n",
    "        #Testa a estrutura da tabela\n",
    "        #1.0 pts\n",
    "        div1 = price(200000,.006,360)\n",
    "        div2 = gprice(200000,.006,360)\n",
    "        pd.testing.assert_frame_equal (div1.tabela(), div2.tabela())\n",
    "\n",
    "    def test_tabela_saldos_1(self):\n",
    "        #0.5 pts\n",
    "        #Testa a consistência de saldo inical e final\n",
    "        div1 = price(200000,.006,360)\n",
    "        si = np.array(div1.tabela()['Saldo Inicial'])\n",
    "        sf = np.array(div1.tabela()['Saldo Final'])\n",
    "        np.testing.assert_array_almost_equal(si[1:360],sf[0:359], decimal = 1)\n",
    "\n",
    "    def test_tabela_saldos_2(self):\n",
    "        #0.5 pts\n",
    "        div1 = price(200000,.006,360)\n",
    "        si = np.array(div1.tabela()['Saldo Inicial'])\n",
    "        sf = np.array(div1.tabela()['Saldo Final'])\n",
    "        am = np.array(div1.tabela()['Amortização'])\n",
    "        np.testing.assert_array_almost_equal(si-abs(am),sf,decimal=1)\n",
    "        \n",
    "unittest.main(argv=['first-arg-is-ignored'], exit=False)"
   ]
  }
 ],
 "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}