sistemas_lineares_gauss_jacobi.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Básico sobre matrizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×4 Array{Float64,2}:\n",
       " 0.901371  1.32112  1.5118   0.52211\n",
       " 1.31784   1.71442  1.74042  1.39822\n",
       " 0.875512  1.29479  1.01955  1.07038"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiplicação de matrizes implementada pela própria linguagem\n",
    "\n",
    "A = rand(3,5)\n",
    "B = rand(5, 4)\n",
    "A * B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×4 Array{Float64,2}:\n",
       " 0.901371  1.32112  1.5118   0.52211\n",
       " 1.31784   1.71442  1.74042  1.39822\n",
       " 0.875512  1.29479  1.01955  1.07038"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# algoritmo de multiplicação de matrizes\n",
    "\n",
    "C = zeros(3, 4)\n",
    "\n",
    "for i=1:3, j=1:4\n",
    "    C[i,j] = sum(A[i,k] * B[k,j] for k=1:5)\n",
    "end\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.2888031005859375, 76293.9453125)"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# comparação da quantidade de memória necessária para armazenar matrizes\n",
    "\n",
    "n = 100000\n",
    "\n",
    "matriz_esparsa = Float64.size * (3n - 2) / 1024 / 1024 # exemplo com uma matriz laplaciana\n",
    "matriz_comum = Float64.size * n^2 / 1024 / 1024\n",
    "\n",
    "matriz_esparsa, matriz_comum # em megabytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "multAx2 (generic function with 2 methods)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiplicação de matriz por vetor\n",
    "\n",
    "# essa função percorre a matriz no sentido horizontal\n",
    "# ou seja, primeiro itera sobre todas as colunas para depois mudar de linha\n",
    "function multAx1(A, x)\n",
    "    m, n = size(A)\n",
    "    y = zeros(m)\n",
    "    \n",
    "    for linha = 1:m\n",
    "        for coluna = 1:n\n",
    "            y[linha] += A[linha,coluna] * x[coluna]\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    return y\n",
    "end\n",
    "\n",
    "# essa função percorre a matriz no sentido vertical\n",
    "# ou seja, primeiro itera sobre todas as linhas para depois mudar de coluna\n",
    "function multAx2(A, x)\n",
    "    m, n = size(A)\n",
    "    y = zeros(m)\n",
    "    \n",
    "    for coluna = 1:n\n",
    "        for linha = 1:m\n",
    "            y[linha] += A[linha,coluna] * x[coluna]\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    return y\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testando o desempenho e eficácia de cada função"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "using BenchmarkTools # biblioteca para fazer teste de desempenho em funções"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define dimensão das matrizes\n",
    "n = 1000\n",
    "\n",
    "A = rand(n, n)\n",
    "x = rand(n)\n",
    "\n",
    "y1 = multAx1(A, x)\n",
    "y2 = multAx2(A, x)\n",
    "\n",
    "# testa se esses vetores estão próximos (teste de corretude)\n",
    "y1 ≈ y2 ≈ A * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  7.94 KiB\n",
       "  allocs estimate:  1\n",
       "  --------------\n",
       "  minimum time:     3.363 ms (0.00% GC)\n",
       "  median time:      3.545 ms (0.00% GC)\n",
       "  mean time:        3.635 ms (0.00% GC)\n",
       "  maximum time:     7.254 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          1372\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# o desempenho dessa função é pior\n",
    "@benchmark multAx1($A, $x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BenchmarkTools.Trial: \n",
       "  memory estimate:  7.94 KiB\n",
       "  allocs estimate:  1\n",
       "  --------------\n",
       "  minimum time:     1.132 ms (0.00% GC)\n",
       "  median time:      1.156 ms (0.00% GC)\n",
       "  mean time:        1.218 ms (0.00% GC)\n",
       "  maximum time:     3.656 ms (0.00% GC)\n",
       "  --------------\n",
       "  samples:          4083\n",
       "  evals/sample:     1"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# essa função desempenha bem melhor que a anterior\n",
    "# imagino que seja por conta do melhor uso da memória cache\n",
    "# dependendo da forma que a estrutura de dados esteja organizada no baixo nível\n",
    "@benchmark multAx2($A, $x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10×10 SparseMatrixCSC{Float64,Int64} with 32 stored entries:\n",
       "  [3 ,  1]  =  0.241685\n",
       "  [4 ,  1]  =  0.841772\n",
       "  [5 ,  1]  =  0.563358\n",
       "  [8 ,  1]  =  0.672684\n",
       "  [10,  1]  =  0.53812\n",
       "  [5 ,  2]  =  0.873475\n",
       "  [9 ,  2]  =  0.660849\n",
       "  [10,  2]  =  0.758892\n",
       "  [1 ,  3]  =  0.0712516\n",
       "  [2 ,  3]  =  0.222792\n",
       "  [5 ,  3]  =  0.843653\n",
       "  [7 ,  3]  =  0.822025\n",
       "  ⋮\n",
       "  [4 ,  6]  =  0.102911\n",
       "  [8 ,  6]  =  0.678657\n",
       "  [1 ,  7]  =  0.75043\n",
       "  [3 ,  7]  =  0.587887\n",
       "  [5 ,  7]  =  0.770649\n",
       "  [9 ,  7]  =  0.164284\n",
       "  [9 ,  8]  =  0.836219\n",
       "  [2 ,  9]  =  0.39427\n",
       "  [3 ,  9]  =  0.41924\n",
       "  [5 ,  9]  =  0.777633\n",
       "  [1 , 10]  =  0.600459\n",
       "  [5 , 10]  =  0.167393\n",
       "  [6 , 10]  =  0.905136"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using SparseArrays # biblioteca para trabalhar com matrizes esparsas\n",
    "\n",
    "A = sprand(10, 10, 0.3) # a forma como ele printa a matriz é diferente, mostra só as posições em que há algo diferente de zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([3, 4, 5, 8, 10, 5, 9, 10, 1, 2  …  3, 5, 9, 9, 2, 3, 5, 1, 5, 6], [1, 1, 1, 1, 1, 2, 2, 2, 3, 3  …  7, 7, 7, 8, 9, 9, 9, 10, 10, 10], [0.24168493923499468, 0.8417717401755755, 0.5633579381177041, 0.6726842763010734, 0.5381195541079953, 0.8734748520665003, 0.6608487362889588, 0.75889167613772, 0.07125163795737466, 0.22279242745556793  …  0.5878872156312716, 0.7706487532278419, 0.1642836063627764, 0.8362186866390438, 0.3942699740718525, 0.41924042985798415, 0.7776331686846663, 0.600459438729912, 0.1673929788222126, 0.905136442451554])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# retorna um vetor com a posição vertical de cada elemento\n",
    "# um vetor com a posição horizontal de cada elemento\n",
    "# um vetor com todos os elementos não nulos da matriz\n",
    "\n",
    "rows, cols, vals = findnz(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resolução de sistemas lineares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 0.6729498440793755\n",
       " 1.362481168954216\n",
       " 1.263438569202847"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = rand(3,3)\n",
    "b = A * ones(3) # podemos usar isso pra já saber que o resultado é um vetor de 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 1.0000000000000007\n",
       " 0.9999999999999986\n",
       " 1.0000000000000016"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A \\ b # função implementada na linguagem que resolve o sistema Ax = b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 3.0   1.0          2.0\n",
       " 0.0   2.33333      1.66667\n",
       " 0.0  -1.11022e-16  2.85714"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# eliminação gaussiana\n",
    "\n",
    "A = [3.0 1 2; -1 2 1; 1 1 4]\n",
    "\n",
    "m21 = A[2,1] / A[1,1] # coeficiente para zerar a primeira posição da segunda linha\n",
    "m31 = A[3,1] / A[1,1] # coeficiente para zerar a primeira posição da terceira linha\n",
    "\n",
    "A[2,:] = A[2,:] - m21 * A[1,:] # subtrai a primeira linha da segunda com um coeficiente calculado para zerar a primeira posição\n",
    "A[3,:] = A[3,:] - m31 * A[1,:] # subtrai a primeira linha da terceira com um coeficiente calculado para zerar a primeira posição\n",
    "\n",
    "m32 = A[3,2] / A[2,2] # coeficiente para zerar a segunda posição da terceira linha\n",
    "\n",
    "A[3,:] = A[3,:] - m32 * A[2,:] # subtrai a segunda linha da terceira com um coeficiente calculado para zerar a segunda posição\n",
    "\n",
    "A # o resultado é uma matriz triangular superior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "eliminação_gaussiana! (generic function with 1 method)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Modifica A e b, fazendo eliminação gaussiana\n",
    "\"\"\"\n",
    "\n",
    "function eliminação_gaussiana!(A, b)\n",
    "    m, n = size(A)\n",
    "    \n",
    "    for j = 1:n\n",
    "        for i = j+1:m\n",
    "            mij = A[i,j] / A[j,j] # calcula o coeficiente para zerar a posição i,j\n",
    "            \n",
    "            A[i,:] -= mij * A[j,:] # subtrai a linha j da linha i\n",
    "            \n",
    "            b[i] -= mij * b[j] # efetua a mesma operação do outro lado da equação\n",
    "            \n",
    "            A[i,j] = 0.0 # zera a posição i,j para evitar propagação de erros\n",
    "        end\n",
    "    end\n",
    "\n",
    "    return A, b\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([3.0 1.0 2.0; 0.0 2.3333333333333335 1.6666666666666665; 0.0 0.0 2.857142857142857], [6.0, 4.0, 2.8571428571428568])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [3.0 1 2; -1 2 1; 1 1 4]\n",
    "b = A * ones(3)\n",
    "\n",
    "eliminação_gaussiana!(A, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 1.0\n",
       " 1.0000000000000002\n",
       " 0.9999999999999998"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A \\ b # podemos resolver o sistema e ver que a eliminação funcionou"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gauss-Jacobi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É um método iterativo para resolver sistemas lineares de forma aproximada\n",
    "\n",
    "Sua vantagem é que é bem mais rápido e pode ser paralelizado\n",
    "Sua desvantagem é que nem sempre converge"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A ideia é usar o mesmo princípio do método do ponto fixo, isolando o x da seguinte forma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ Ax = b \\implies x = D^{-1}(b - Rx) $$\n",
    "\n",
    "Onde $D = \\begin{bmatrix}\n",
    "a_{1,1} & 0 & ... & 0\\\\\n",
    "0 & a_{1,1} & ... & 0\\\\\n",
    "\\vdots &  & \\ddots & 0\\\\\n",
    "0 & 0 & ... & a_{m,n}\n",
    "\\end{bmatrix}$ e $R = A - D$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "using LinearAlgebra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "gauss_jacobi (generic function with 1 method)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function inverte_diagonal(D)\n",
    "    m, n = size(D)\n",
    "    inversa = zeros(m, n)\n",
    "    \n",
    "    for i = 1:m\n",
    "        inversa[i,i] = 1.0 / D[i,i]\n",
    "    end\n",
    "    \n",
    "    return inversa\n",
    "end\n",
    "\n",
    "function gauss_jacobi(A, b; tolerancia = 1e-8, max_iterações = 100, max_tempo = 10.0)\n",
    "    m, n = size(A)\n",
    "\n",
    "    D = Diagonal(A) # pega a diagonal da matriz A\n",
    "    R = A - D\n",
    "    D_inv = inverte_diagonal(D)\n",
    "\n",
    "    x = rand(m) # gera um chute aleatório para ser começado\n",
    "    xk = D_inv * (b - R * x)\n",
    "    \n",
    "    iterações = 0\n",
    "    # calcula quanto tempo o programa está levando\n",
    "    t0 = time()\n",
    "    Δt = time() - t0\n",
    "    \n",
    "    # testa os critérios de parada\n",
    "    resolvido() = norm(x - xk) <= tolerancia\n",
    "    cansado() = (iterações >= max_iterações) || (Δt >= max_tempo)\n",
    "    \n",
    "    while !(resolvido() || cansado())\n",
    "        x = xk\n",
    "        xk = D_inv * (b - R * x)\n",
    "        \n",
    "        iterações += 1\n",
    "        Δt = time() - t0\n",
    "    end\n",
    "    \n",
    "    exitflag = :desconhecido\n",
    "    \n",
    "    # verifica qual das condições de parada foram alcançadas para retornar um feedback\n",
    "    if resolvido()\n",
    "        exitflag = :sucesso\n",
    "    else\n",
    "        if iterações >= max_iterações\n",
    "            exitflag = :max_iterações\n",
    "        else\n",
    "            exitflag = :max_tempo\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    return x, iterações, exitflag, Δt\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([6.399999998196171, 7.199999996740197, 8.899999996270218], 16, :sucesso, 0.1182258129119873)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# teste com uma matriz que claramente converge pelo teorema de convergência, pois 2*A[i,i] > sum(A[i,:])\n",
    "A = [15 1 1; 1 11 2; 6 2 18]\n",
    "c = [6.4, 7.2, 8.9]\n",
    "\n",
    "b = A * c # c será a resposta do algoritmo\n",
    "\n",
    "x = gauss_jacobi(A, b, max_iterações=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([6.399999997135199, 7.199999997097284, 8.899999997071308], 692, :sucesso, 0.000392913818359375)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nesse caso onde A[i,i] é só um pouco maior que a soma dos outros elementos da linha\n",
    "# a convergência é bem mais lenta\n",
    "A = [2.1 1 1; 1 3.1 2; 6 2 8.1]\n",
    "c = [6.4, 7.2, 8.9]\n",
    "\n",
    "b = A * c\n",
    "\n",
    "x = gauss_jacobi(A, b, max_iterações=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([6.400000000087434, 7.200000000098931, 8.900000000224656], 5, :sucesso, 1.3828277587890625e-5)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nesse caso onde A[i,i] é só um muito maior que a soma dos outros elementos da linha\n",
    "# a convergência é bem mais rápida\n",
    "# coincidência?? imagino que não\n",
    "A = [500 1 1; 1 700 2; 6 2 480]\n",
    "c = [6.4, 7.2, 8.9]\n",
    "\n",
    "b = A * c # c será a resposta do algoritmo\n",
    "\n",
    "x = gauss_jacobi(A, b, max_iterações=10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analisando o desempenho em comparação com o método da Julia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "testa_diferença (generic function with 1 method)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function matriz_que_converge(n)\n",
    "    A = ones(n, n)\n",
    "    A = A + (2n) * Diagonal(A) #  cria A de forma que seja sempre convergente\n",
    "    \n",
    "    return A\n",
    "end\n",
    "\n",
    "\n",
    "function testa_diferença(n)\n",
    "    A = matriz_que_converge(n)\n",
    "    c = ones(n)\n",
    "\n",
    "    b = A * c # c será a resposta do algoritmo\n",
    "\n",
    "    x, iter, flag, tempo = gauss_jacobi(A, b, max_iterações = 2000)\n",
    "\n",
    "    t0_julia = time()\n",
    "    solução_julia = A \\ b\n",
    "    tempo_julia = time() - t0_julia\n",
    "    \n",
    "    println(\"------ n = $n -------\")\n",
    "    println(\"As soluções são próximas? $(x ≈ c ≈ solução_julia)\")\n",
    "    println(\"Tempo Gauss-Jacobi: $(tempo)\")\n",
    "    println(\"Tempo Julia: $(tempo_julia)\")\n",
    "    println(\"Ganho com o Gauss-Jacobi: $(tempo_julia / tempo) vezes mais rápido\")\n",
    "    println(\"---------------------\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------ n = 3 -------\n",
      "As soluções são próximas? true\n",
      "Tempo Gauss-Jacobi: 5.0067901611328125e-5\n",
      "Tempo Julia: 1.811981201171875e-5\n",
      "Ganho com o Gauss-Jacobi: 0.3619047619047619 vezes mais rápido\n",
      "---------------------\n"
     ]
    }
   ],
   "source": [
    "testa_diferença(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------ n = 300 -------\n",
      "As soluções são próximas? true\n",
      "Tempo Gauss-Jacobi: 0.009564876556396484\n",
      "Tempo Julia: 0.09540700912475586\n",
      "Ganho com o Gauss-Jacobi: 9.974724562540505 vezes mais rápido\n",
      "---------------------\n"
     ]
    }
   ],
   "source": [
    "testa_diferença(300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------ n = 1000 -------\n",
      "As soluções são próximas? true\n",
      "Tempo Gauss-Jacobi: 0.10318303108215332\n",
      "Tempo Julia: 0.053282976150512695\n",
      "Ganho com o Gauss-Jacobi: 0.5163928176144517 vezes mais rápido\n",
      "---------------------\n"
     ]
    }
   ],
   "source": [
    "testa_diferença(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "------ n = 10000 -------\n",
    "As soluções são próximas? true\n",
    "Tempo Gauss-Jacobi: 4.18436598777771\n",
    "Tempo Julia: 15.223865985870361\n",
    "Ganho com o Gauss-Jacobi: 3.6382730455075847 vezes mais rápido\n",
    "---------------------\n",
    "\"\"\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.4.1",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}