Trabalho 01 - Algoritmos de Busca.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este trabalho é referente à disciplina de Inteligência Artificial do curso de Bacharelado em Ciência da Computação na Universidade Federal do Pará. Ele propõe a implementação de uma versão do algoritmo **_Stochastic Hill Climbing_** (**_Simulated Annealing_**) e de uma meta-heurística (**_Genetic Algorithm_**) para a resolução do **problema das oito rainhas**.\n",
    "\n",
    "Integrantes:\n",
    "\n",
    "- [201804940002] Eduardo Gil Serrão Cardoso\n",
    "- [201804940016] Gabriela Souza Maximino\n",
    "- [201704940007] Igor Matheus Souza Moreira\n",
    "\n",
    "Durante todo o ciclo de desenvolvimento deste trabalho, o GitHub foi utilizado como ferramenta de versionamento. O histórico de desenvolvimento da equipe, bem como versões iniciais do código aqui contido, está disponível ao público no GitHub em [@Ygarasab/oito-rainhas](https://github.com/Ygarasab/oito-rainhas).\n",
    "\n",
    "**Observação:** antes de interagir com o código no Jupyter Notebook/Lab, é importante observar que certas células anteriores à que se quer executar podem ser necessárias. A fim de evitar isso, é importante certificar-se de executar ao menos uma vez todas as células contendo definições de funções ou importações de módulos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. [Requisitos](#Requisitos)\n",
    "    1. [Ambiente](#Ambiente)\n",
    "    2. [Funções de checagem](#Funções-de-checagem)\n",
    "2. [Modelagem do tabuleiro, da função-objetivo e das soluções](#Modelagem-do-tabuleiro,-da-função-objetivo-e-das-soluções)\n",
    "    1. [Funções auxiliares relacionadas ao tabuleiro](#Funções-auxiliares-relacionadas-ao-tabuleiro)\n",
    "    2. [A classe `Tabuleiro`](#A-classe-Tabuleiro)\n",
    "    3. [A função-objetivo](#A-função-objetivo)\n",
    "    4. [As soluções](#As-soluções)\n",
    "3. [Outras definições globais](#Outras-definições-globais)\n",
    "    1. [Heurísticas adotadas](#Heurísticas-adotadas)\n",
    "    2. [Critérios de parada adotados](#Critérios-de-parada-adotados)\n",
    "4. [Problemas](#Problemas)\n",
    "    1. [_Stochastic Hill Climbing: Simulated Annealing_](#Stochastic-Hill-Climbing:-Simulated-Annealing)\n",
    "        1. [Implementação do SA](#Implementação-do-SA)\n",
    "            1. [Funções auxiliares ao SA](#Funções-auxiliares-ao-SA)\n",
    "            2. [Algoritmo principal SA](#Algoritmo-principal-SA)\n",
    "        4. [Heurísticas e critérios de parada do SA](#Heurísticas-e-critérios-de-parada-do-SA)\n",
    "        5. [Resultados do SA](#Resultados-do-SA)\n",
    "    2. [_Meta-heuristic: Genetic Algorithm_](#Meta-heuristic:-Genetic-Algorithm)\n",
    "        1. [Implementação do GA](#Implementação-do-GA)\n",
    "            1. [Funções auxiliares ao GA](#Funções-auxiliares-ao-GA)\n",
    "            2. [Algoritmo principal GA](#Algoritmo-principal-GA)\n",
    "        2. [Operadores do GA](#Operadores-do-GA)\n",
    "        3. [Resultados do GA](#Resultados-do-GA)\n",
    "5. [Considerações finais](#Considerações-finais)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Requisitos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ambiente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este trabalho foi feito utilizando a seguinte linguagem de programação:\n",
    "\n",
    "- `python` 3.8.5\n",
    "\n",
    "Em adição, os seguintes módulos precisam estar instalados no ambiente em que este notebook for executado:\n",
    "\n",
    "- `ipypublish` 0.10.12\n",
    "- `matplotlib` 3.3.2\n",
    "- `numpy` 1.19.2\n",
    "- `pandas` 1.1.4\n",
    "- `scipy` 1.5.3\n",
    "- `seaborn` 0.11.0\n",
    "\n",
    "Observe que o código pode funcionar em versões distintas às que foram mencionadas acima; contudo, sabe-se que a sua execução é garantida nas versões mencionadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import decimal as d\n",
    "import numpy as np\n",
    "import random as r\n",
    "import seaborn as sns\n",
    "import typing as t\n",
    "\n",
    "from ipypublish import nb_setup\n",
    "from scipy import stats\n",
    "from timeit import default_timer as timer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "plt = nb_setup.setup_matplotlib(output=('pdf',), usetex=False, rcparams={'axes.facecolor': 'white', 'figure.facecolor': 'white'})\n",
    "pd = nb_setup.setup_pandas(escape_latex=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funções de checagem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma vez configurado o ambiente em que este notebook será executado, é necessário definir algumas funções de checagem que serão utilizadas mais adiante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_comprimento_binario_igual_a(**parametros):\n",
    "    numero_de_parametros = len(parametros.keys())\n",
    "\n",
    "    if numero_de_parametros != 2:\n",
    "        raise ValueError(f\"Apenas um parâmetro pode ser passado para esta função. Foram recebidos {numero_de_parametros}.\")\n",
    "\n",
    "    parametro, outro_parametro = parametros.keys()\n",
    "\n",
    "    valor, descricao = parametros[parametro]\n",
    "    outro_valor, outra_descricao = parametros[outro_parametro]\n",
    "\n",
    "    if outro_valor is not None and len(valor) != outro_valor:\n",
    "        raise ValueError(f\"O comprimento do {descricao} {parametro}, em binário, precisa ser igual ao {outra_descricao} {outro_parametro}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_comprimento_maior_ou_igual_a(**parametros):\n",
    "    numero_de_parametros = len(parametros.keys())\n",
    "\n",
    "    if numero_de_parametros != 2:\n",
    "        raise ValueError(f\"Apenas um parâmetro pode ser passado para esta função. Foram recebidos {numero_de_parametros}.\")\n",
    "\n",
    "    parametro, outro_parametro = parametros.keys()\n",
    "\n",
    "    valor, descricao = parametros[parametro]\n",
    "    outro_valor, outra_descricao = parametros[outro_parametro]\n",
    "\n",
    "    if outro_valor is not None and len(valor) < outro_valor:\n",
    "        raise ValueError(f\"O {descricao} {parametro} precisa receber um valor, no mínimo, igual ao {outra_descricao} {outro_parametro}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_comprimento_menor_ou_igual_a(**parametros):\n",
    "    numero_de_parametros = len(parametros.keys())\n",
    "\n",
    "    if numero_de_parametros != 2:\n",
    "        raise ValueError(f\"Apenas um parâmetro pode ser passado para esta função. Foram recebidos {numero_de_parametros}.\")\n",
    "\n",
    "    parametro, outro_parametro = parametros.keys()\n",
    "\n",
    "    valor, descricao = parametros[parametro]\n",
    "    outro_valor, outra_descricao = parametros[outro_parametro]\n",
    "\n",
    "    if outro_valor is not None and len(valor) > outro_valor:\n",
    "        raise ValueError(f\"O comprimento do {descricao} {parametro} precisa ser, no máximo, igual ao {outra_descricao} {outro_parametro}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_dtype(**parametro_dict):\n",
    "    numero_de_parametros = len(parametro_dict.keys())\n",
    "\n",
    "    if numero_de_parametros != 1:\n",
    "        raise ValueError(f\"Apenas um parâmetro pode ser passado para esta função. Foram recebidos {numero_de_parametros}.\")\n",
    "\n",
    "    parametro = list(parametro_dict.keys())[0]\n",
    "    valor, descricao, dtype = parametro_dict[parametro]\n",
    "\n",
    "    if dtype == np.int_ and valor.dtype != dtype:\n",
    "        if valor.dtype == np.float_:\n",
    "            return valor.astype(np.int_)\n",
    "        else:\n",
    "            raise TypeError(f\"O {descricao} {parametro} precisa ser um numpy array com atributo dtype igual a {dtype}. O dtype do numpy array recebido é {valor.dtype}.\")\n",
    "\n",
    "    if valor.dtype != dtype:\n",
    "        raise TypeError(f\"O {descricao} {parametro} precisa ser um numpy array com atributo dtype igual a {dtype}. O dtype do numpy array recebido é {valor.dtype}.\")\n",
    "    else:\n",
    "        return valor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_maior_ou_igual_a(**parametros):\n",
    "    numero_de_parametros = len(parametros.keys())\n",
    "\n",
    "    if numero_de_parametros != 2:\n",
    "        raise ValueError(f\"Apenas um parâmetro pode ser passado para esta função. Foram recebidos {numero_de_parametros}.\")\n",
    "\n",
    "    parametro, outro_parametro = parametros.keys()\n",
    "\n",
    "    valor, descricao = parametros[parametro]\n",
    "    outro_valor, outra_descricao = parametros[outro_parametro]\n",
    "\n",
    "    if outro_valor is not None and valor < outro_valor:\n",
    "        raise ValueError(f\"O {descricao} {parametro} precisa receber um valor, no mínimo, igual ao {outra_descricao} {outro_parametro}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_menor_ou_igual_a(**parametros):\n",
    "    numero_de_parametros = len(parametros.keys())\n",
    "\n",
    "    if numero_de_parametros != 2:\n",
    "        raise ValueError(f\"Apenas um parâmetro pode ser passado para esta função. Foram recebidos {numero_de_parametros}.\")\n",
    "\n",
    "    parametro, outro_parametro = parametros.keys()\n",
    "\n",
    "    valor, descricao = parametros[parametro]\n",
    "    outro_valor, outra_descricao = parametros[outro_parametro]\n",
    "\n",
    "    if outro_valor is not None and valor > outro_valor:\n",
    "        raise ValueError(f\"O {descricao} {parametro} precisa receber um valor, no máximo, igual ao {outra_descricao} {outro_parametro}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_nao_negatividade(**parametros):\n",
    "    for parametro in parametros.keys():\n",
    "        valor, descricao = parametros[parametro]\n",
    "\n",
    "        if valor < 0:\n",
    "            raise ValueError(f\"O {descricao} {parametro} precisa receber um número não-negativo.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_ndim(**parametros):\n",
    "    for parametro in parametros.keys():\n",
    "        valor, descricao, ndim = parametros[parametro]\n",
    "\n",
    "        if valor.ndim != ndim:\n",
    "            raise ValueError(f\"O o atributo ndim do {descricao} {parametro} precisa ser igual a {ndim}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_tipo(**parametro_dict):\n",
    "    numero_de_parametros = len(parametro_dict.keys())\n",
    "\n",
    "    if numero_de_parametros != 1:\n",
    "        raise ValueError(f\"Apenas um parâmetro pode ser passado para esta função. Foram recebidos {numero_de_parametros}.\")\n",
    "\n",
    "    parametro = list(parametro_dict.keys())[0]\n",
    "    valor, descricao, tipos = parametro_dict[parametro]\n",
    "\n",
    "    if tipos == t.SupportsFloat:\n",
    "        if not isinstance(valor, tipos):\n",
    "            raise TypeError(f\"O {descricao} {parametro} precisa receber um número de ponto flutuante ou um objeto que possa ser convertido para tal.\")\n",
    "        else:\n",
    "            return float(valor)\n",
    "\n",
    "    if tipos == t.SupportsInt:\n",
    "        if not isinstance(valor, tipos):\n",
    "            raise TypeError(f\"O {descricao} {parametro} precisa receber um número inteiro ou um objeto que possa ser convertido para tal.\")\n",
    "        else:\n",
    "            return int(valor)\n",
    "\n",
    "    if tipos == np.ndarray:\n",
    "        if not isinstance(valor, np.ndarray):\n",
    "            if not isinstance(valor, (list, tuple)):\n",
    "                raise TypeError(f\"O {descricao} {parametro} precisa receber um array numpy ou um objeto que possa ser convertido para tal.\")\n",
    "            else:\n",
    "                return np.array(valor)\n",
    "\n",
    "    if tipos == bool:\n",
    "        if not isinstance(valor, bool):\n",
    "            if isinstance(valor, np.bool_):\n",
    "                return bool(valor)\n",
    "            else:\n",
    "                raise TypeError(f\"O {descricao} {parametro} precisa receber um objeto booleano ou um objeto que possa ser convertido para tal.\")\n",
    "        else:\n",
    "            return valor\n",
    "\n",
    "    if not isinstance(valor, tipos):\n",
    "        raise TypeError(f\"O {descricao} {parametro} precisa receber um objeto de classe {tipos} ou que herde dela.\")\n",
    "    else:\n",
    "        return valor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_tipo_operador(operador, valor, tipo):\n",
    "    if not isinstance(valor, tipo):\n",
    "        raise TypeError(f\"O operador '{operador}' precisa ser do tipo {tipo}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modelagem do tabuleiro, da função-objetivo e das soluções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma vez que ambos os algoritmos a serem discutidos aqui – _Simulated Annealing_ e _Genetic Algorithm_ — são utilizados para resolver o mesmo problema – o problema das oito rainhas –, optou-se por definir uma classe comumente utilizada por ambos os algoritmos, intitulada `Tabuleiro`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funções auxiliares relacionadas ao tabuleiro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de definirmos a classe `Tabuleiro`, precisamos definir algumas funções para auxiliar na representação e nas operações da classe quando a codificação binária estiver ativada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ajusta_indentacao(string, string_para_adicionar):\n",
    "    string = verifica_tipo(string=(string, \"parâmetro\", str))\n",
    "    string_para_adicionar = verifica_tipo(string_para_adicionar=(string_para_adicionar, \"parâmetro\", str))\n",
    "    \n",
    "    linhas = string.split(\"\\n\")\n",
    "\n",
    "    for linha in range(1, len(linhas)):\n",
    "        linhas[linha] = string_para_adicionar + linhas[linha]\n",
    "\n",
    "    return \"\\n\".join(linhas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binario_para_decimal(bits):\n",
    "    bits = verifica_tipo(bits=(bits, \"parâmetro\", np.ndarray))\n",
    "\n",
    "    return int(\"\".join(bits.astype(np.int_).astype(str)), base=2) - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decimal_para_binario(numero, numero_de_bits):\n",
    "    numero = verifica_tipo(numero=(numero, \"parâmetro\", t.SupportsInt))\n",
    "    digitos_binarios = list(bin(numero + 1)[2:].zfill(numero_de_bits))\n",
    "\n",
    "    verifica_comprimento_binario_igual_a(numero=(digitos_binarios, \"parâmetro\"), numero_de_bits=(numero_de_bits, \"parâmetro\"))\n",
    "\n",
    "    return np.array(digitos_binarios, dtype=np.int_).astype(np.bool_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A classe `Tabuleiro`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma vez definidas as funções auxiliares, definamos agora a classe `Tabuleiro`. Alguns recursos permitidos por esta implementação incluem\n",
    "\n",
    "- suporte às notações binária e decimal (i.e., inteira), com possibilidade de alteração entre notações após a inicialização do objeto;\n",
    "- suporte a operadores e funções internas ao `python`, como `__str__`, `__repr__`, `__lt__` (`<`), `__eq__` (`=`), `__gt__` (`>`) e outras;\n",
    "- verificação de ataques (i.e., a função objetivo definida para este problema);\n",
    "- homogeneização das heurísticas adotadas na inicialização (no caso, não aceitar rainhas na mesma linha ou na mesma coluna);\n",
    "- suporte a diferentes tamanhos de tabuleiro e números de rainhas (o que quer dizer que `Tabuleiro` representa também a _ausência_ de rainhas),\n",
    "\n",
    "entre outros. Embora se tenha o entendimento de que alguns recursos da implementação não serão utilizados na resolução dos exercícios ora propostos (e.g., o último recurso citado), eles compõem a implementação e a tornam mais flexível, aumentando a possibilidade de reciclagem desta peça de código para outros fins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tabuleiro:\n",
    "    def __init__(self, *, binario=False, lado_tabuleiro=8, n_rainhas=8, rainhas=None):\n",
    "        self.__lado_tabuleiro, self.__n_rainhas, self.__rainhas, self.__valor = None, None, None, np.inf\n",
    "\n",
    "        self.binario = binario\n",
    "        self.lado_tabuleiro = lado_tabuleiro\n",
    "        self.n_rainhas = n_rainhas\n",
    "\n",
    "        if rainhas is not None:\n",
    "            self.rainhas = rainhas\n",
    "\n",
    "    @property\n",
    "    def binario(self):\n",
    "        return self.__binario\n",
    "\n",
    "    @binario.setter\n",
    "    def binario(self, novo_binario):\n",
    "        novo_binario = verifica_tipo(binario=(novo_binario, \"atributo\", (bool, np.bool_)))\n",
    "\n",
    "        self.__binario = novo_binario\n",
    "\n",
    "        if self.__rainhas is not None:\n",
    "            if novo_binario is True:\n",
    "                numero_de_casas = np.ceil(np.log2(self.lado_tabuleiro + 1)).astype(np.int_)\n",
    "                self.rainhas = [decimal_para_binario(posicao, numero_de_casas) for posicao in self.rainhas]\n",
    "            else:\n",
    "                self.rainhas = [binario_para_decimal(posicao) for posicao in self.rainhas]\n",
    "\n",
    "    @property\n",
    "    def lado_tabuleiro(self):\n",
    "        return self.__lado_tabuleiro\n",
    "\n",
    "    @lado_tabuleiro.setter\n",
    "    def lado_tabuleiro(self, novo_lado_tabuleiro):\n",
    "        novo_lado_tabuleiro = verifica_tipo(lado_tabuleiro=(novo_lado_tabuleiro, \"atributo\", t.SupportsInt))\n",
    "\n",
    "        verifica_nao_negatividade(lado_tabuleiro=(novo_lado_tabuleiro, \"atributo\"))\n",
    "        verifica_maior_ou_igual_a(lado_tabuleiro=(novo_lado_tabuleiro, \"atributo\"), n_rainhas=(self.n_rainhas, \"atributo\"))\n",
    "\n",
    "        self.__lado_tabuleiro = novo_lado_tabuleiro\n",
    "\n",
    "    @property\n",
    "    def n_rainhas(self):\n",
    "        return self.__n_rainhas\n",
    "\n",
    "    @n_rainhas.setter\n",
    "    def n_rainhas(self, novo_n_rainhas):\n",
    "        novo_n_rainhas = verifica_tipo(n_rainhas=(novo_n_rainhas, \"atributo\", t.SupportsInt))\n",
    "\n",
    "        verifica_nao_negatividade(n_rainhas=(novo_n_rainhas, \"atributo\"))\n",
    "        verifica_menor_ou_igual_a(n_rainhas=(novo_n_rainhas, \"atributo\"), lado_tabuleiro=(self.lado_tabuleiro, \"atributo\"))\n",
    "\n",
    "        self.__n_rainhas = novo_n_rainhas\n",
    "\n",
    "        self.aleatoriza_rainhas()\n",
    "\n",
    "    def aleatoriza_rainhas(self):\n",
    "        posicoes = np.random.choice(self.lado_tabuleiro, self.n_rainhas, replace=False)\n",
    "\n",
    "        if self.binario is True:\n",
    "            digitos_necessarios = np.ceil(np.log2(self.lado_tabuleiro + 1)).astype(np.int_)\n",
    "            rainhas = np.empty((self.lado_tabuleiro, digitos_necessarios), dtype=np.bool_)\n",
    "            rainhas[:self.n_rainhas, :] = [decimal_para_binario(posicao, digitos_necessarios) for posicao in posicoes]\n",
    "            rainhas[self.n_rainhas:, :] = np.False_\n",
    "        else:\n",
    "            rainhas = np.empty(self.lado_tabuleiro, dtype=np.int_)\n",
    "\n",
    "            rainhas[:self.n_rainhas] = posicoes\n",
    "            rainhas[self.n_rainhas:] = -1\n",
    "\n",
    "        self.rainhas = rainhas\n",
    "\n",
    "    @property\n",
    "    def rainhas(self):\n",
    "        return self.__rainhas.copy() if self.__rainhas is not None else None\n",
    "\n",
    "    @rainhas.setter\n",
    "    def rainhas(self, novo_rainhas):\n",
    "        novo_rainhas = verifica_tipo(rainhas=(novo_rainhas, \"atributo\", np.ndarray))\n",
    "\n",
    "        verifica_comprimento_menor_ou_igual_a(rainhas=(novo_rainhas, \"atributo\"), lado_tabuleiro=(self.lado_tabuleiro, \"atributo\"))\n",
    "\n",
    "        if self.binario is True:\n",
    "            novo_rainhas = verifica_dtype(rainhas=(novo_rainhas, \"atributo\", np.bool_))\n",
    "\n",
    "            verifica_ndim(rainhas=(novo_rainhas, \"atributo\", 2))\n",
    "\n",
    "            if novo_rainhas.shape[0] < self.lado_tabuleiro:\n",
    "                diferenca = self.lado_tabuleiro - novo_rainhas.shape[0]\n",
    "                novo_rainhas = np.concatenate((novo_rainhas, diferenca * [[np.False_, np.False_, np.False_]]))\n",
    "        else:\n",
    "            novo_rainhas = verifica_dtype(rainhas=(novo_rainhas, \"atributo\", np.int_))\n",
    "\n",
    "            verifica_ndim(rainhas=(novo_rainhas, \"atributo\", 1))\n",
    "\n",
    "            if novo_rainhas.shape[0] < self.lado_tabuleiro:\n",
    "                diferenca = self.lado_tabuleiro - novo_rainhas.shape[0]\n",
    "                novo_rainhas = np.append(novo_rainhas, diferenca * [-1])\n",
    "\n",
    "        self.__rainhas = novo_rainhas\n",
    "\n",
    "        self.calcula_valor()\n",
    "\n",
    "    def calcula_valor(self):\n",
    "        ataques = 0\n",
    "\n",
    "        for indice_rainha in range(self.n_rainhas):\n",
    "            for indice_prox_rainha in range(indice_rainha + 1, self.n_rainhas):\n",
    "                ataques += self.ha_ataque(indice_rainha, indice_prox_rainha)  \n",
    "                \n",
    "        self.__valor = ataques\n",
    "\n",
    "    @property\n",
    "    def valor(self):\n",
    "        return self.__valor\n",
    "\n",
    "    def ha_ataque(self, indice_a, indice_b):\n",
    "        if self.binario is True:\n",
    "            iterador = (binario_para_decimal(posicao) for posicao in self.rainhas)\n",
    "            rainhas = np.fromiter(iterador, np.int_, self.n_rainhas)\n",
    "        else:\n",
    "            rainhas = self.rainhas\n",
    "\n",
    "        indice_a = verifica_tipo(indice_a=(indice_a, \"parâmetro\", t.SupportsInt))\n",
    "        indice_b = verifica_tipo(indice_b=(indice_b, \"parâmetro\", t.SupportsInt))\n",
    "\n",
    "        ha_ataque_diagonal = (indice_b - indice_a) == abs(rainhas[indice_b] - rainhas[indice_a])\n",
    "\n",
    "        return ha_ataque_diagonal\n",
    "\n",
    "    @property\n",
    "    def ha_rainhas_na_mesma_linha(self):\n",
    "        if self.binario is True:\n",
    "            iterador = (binario_para_decimal(posicao) for posicao in self.rainhas)\n",
    "            rainhas = np.fromiter(iterador, np.int_, self.n_rainhas)\n",
    "        else:\n",
    "            rainhas = self.rainhas\n",
    "\n",
    "        rainhas = rainhas[rainhas != -1]\n",
    "\n",
    "        return True if rainhas.shape[0] != np.unique(rainhas).shape[0] else False\n",
    "\n",
    "    def __sub__(self, outro):\n",
    "        verifica_tipo_operador('-', outro, Tabuleiro)\n",
    "\n",
    "        return self.valor - outro.valor\n",
    "\n",
    "    def __lt__(self, outro):\n",
    "        verifica_tipo_operador('<', outro, Tabuleiro)\n",
    "\n",
    "        return self.valor < outro.valor\n",
    "\n",
    "    def __gt__(self, outro):\n",
    "        verifica_tipo_operador('>', outro, Tabuleiro)\n",
    "\n",
    "        return self.valor > outro.valor\n",
    "\n",
    "    def __eq__(self, outro):\n",
    "        verifica_tipo_operador('==', outro, Tabuleiro)\n",
    "\n",
    "        return self.valor == outro.valor\n",
    "\n",
    "    def __repr__(self):\n",
    "        if self.binario is False:\n",
    "            representacao_rainhas = str(self.rainhas)\n",
    "            tipo = \"Decimal\"\n",
    "        else:\n",
    "            representacao_rainhas = caixinha.ajusta_indentacao(str(self.rainhas), 12 * ' ')\n",
    "            tipo = \"Binário\"\n",
    "\n",
    "        return f\"[Tabuleiro] {representacao_rainhas} | {self.valor} ataques | {tipo}\"\n",
    "\n",
    "    def __str__(self):\n",
    "        if self.binario is False:\n",
    "            return str(self.rainhas.tolist())\n",
    "        else:\n",
    "            representacao = []\n",
    "\n",
    "            for rainha in self.rainhas:\n",
    "                string = \"\"\n",
    "\n",
    "                for bit in rainha:\n",
    "                    if bit is np.True_:\n",
    "                        string += \"1\"\n",
    "                    else:\n",
    "                        string += \"0\"\n",
    "\n",
    "                representacao.append(string)\n",
    "\n",
    "            return str(representacao).replace(\"'\", \"\")\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.n_rainhas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A função-objetivo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função objetivo utilizada, retornada por `Tabuleiro.valor` e calculada em `Tabuleiro.calcula_valor()`, verifica a existência de ataques de rainhas no tabuleiro na diagonal, uma vez que as heurísticas adotadas não permitem rainhas na mesma coluna ou linha. Ela é utilizada por ambos os algoritmos solicitados pela atividade, que serão descritos mais adiante neste documento. Sua implementação é mostrada abaixo:\n",
    "\n",
    "```\n",
    "def calcula_valor(self):\n",
    "    ataques = 0\n",
    "\n",
    "    for indice_rainha in range(self.n_rainhas):\n",
    "        for indice_prox_rainha in range(indice_rainha + 1, self.n_rainhas):\n",
    "            ataques += self.ha_ataque(indice_rainha, indice_prox_rainha)  \n",
    "\n",
    "    self.__valor = ataques\n",
    "    \n",
    "def ha_ataque(self, indice_a, indice_b):\n",
    "    if self.binario is True:\n",
    "        iterador = (binario_para_decimal(posicao) for posicao in self.rainhas)\n",
    "        rainhas = np.fromiter(iterador, np.int_, self.n_rainhas)\n",
    "    else:\n",
    "        rainhas = self.rainhas\n",
    "\n",
    "    indice_a = verifica_tipo(indice_a=(indice_a, \"parâmetro\", t.SupportsInt))\n",
    "    indice_b = verifica_tipo(indice_b=(indice_b, \"parâmetro\", t.SupportsInt))\n",
    "\n",
    "    ha_ataque_diagonal = (indice_b - indice_a) == abs(rainhas[indice_b] - \n",
    "                                                      rainhas[indice_a])\n",
    "\n",
    "    return ha_ataque_diagonal\n",
    "```\n",
    "\n",
    "Dado que o tabuleiro é representado por um vetor com $n$ elementos tal que o valor de cada elemento da posição $i$ representa a linha onde a rainha se encontra nessa mesma coluna $i$, percorre-se esse vetor varrendo para cada elemento da posição `indice_a` os elementos seguintes que estão na posição `indice_b`. \n",
    "\n",
    "Para detectar ataques diagonais, verifica-se se a diferença entre o `indice_b` e `indice_a` é igual ao valor absoluto da diferença entre o item da posição `indice_b` e o item da posição `indice_a`. Esta regra foi utilizada pois observou-se que os elementos da diagonal estão uma (ou mais) coluna(s) na frente e uma (ou mais) linha(s) abaixo do elemento anterior a eles na diagonal (exceto pelo primeiro elemento, que não possui elemento anterior). Dessa forma, a diferença entre os valores da coluna e a diferença entre os valores da linha dos elementos _a_ e _b_ será igual quando eles estiverem na mesma diagonal. Por isso a diferença entre as colunas, representados por `indice_b` e `indice_a`, e a diferença entre as linhas, que são os valores armazenados nos vetores, representados por `rainhas[indice_b]` e `rainhas[indice_a]`, são calculadas.\n",
    "\n",
    "Com isso, caso algum ataque seja detectado, soma-se 1 ao valor do tabuleiro."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## As soluções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma solução, da forma como está codificada na classe `Tabuleiro`, pode ser descrita de duas formas: binária e decimal (i.e., inteira). Cada solução consiste, sucintamente, em um vetor em que cada número corresponde à linha em que a rainha se encontra em uma dada coluna.\n",
    "\n",
    "Uma vez que a implementação da classe `Tabuleiro` foi feita de forma a suportar diferentes números de rainhas e tamanhos do lado do tabuleiro (que é sempre quadrado), tem-se que há um valor que representa a ausência de rainha em uma dada coluna:\n",
    "\n",
    "- **Na notação binária**, o valor `0` (representado aqui, em notação decimal, por -1) representa a ausência de rainha em uma dada coluna; e\n",
    "- **Na notação decimal**, o valor `-1` (representado aqui, em notação binária, por `0`) representa a ausência de rainha em uma dada coluna.\n",
    "\n",
    "Isso significa, em suma, que há um deslocamento em uma unidade na notação binária em relação à notação decimal. Para fins ilustrativos, analisemos a seguinte solução para um tabuleiro quadrado de lado 8 contendo 8 rainhas, tal que os índices possíveis do vetor variem de 0 a 7: $$[0011, 0110, 1000, 0001, 0100, 0111, 0101, 0010]$$\n",
    "\n",
    "A sua versão decimal seria: $$[0002, 0005, 0007, 0000, 0003, 0006, 0004, 0001]$$\n",
    "\n",
    "Se ignorássemos esse deslocamento, erros ocorreriam a nível de implementação, uma vez que o Python, assim como Java e outras linguagens, possui vetores _zero-based_. Contudo, em termos de tabuleiro, isso não seria problemático. Se ignorássemos o deslocamento, teríamos a seguinte solução no mundo real:\n",
    "\n",
    "$$[0003, 0006, 0008, 0001, 0004, 0007, 0005, 0002]$$\n",
    "\n",
    "Logo, teríamos raínhas:\n",
    "\n",
    "- Na primeira coluna e terceira linha;\n",
    "- Na segunda coluna e sexta linha;\n",
    "- Na terceira coluna e oitava linha;\n",
    "- Na quarta coluna e primeira linha;\n",
    "- Na quinta coluna e quarta linha;\n",
    "- Na sexta coluna e sétima linha;\n",
    "- Na sétima coluna e quinta linha; e\n",
    "- Na oitava coluna e segunda linha.\n",
    "\n",
    "Note que, neste exemplo, não há colunas nem linhas sem rainhas, i.e., todas as colunas possuem exatamente uma rainha."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Outras definições globais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de seguirmos às resoluções para os problemas da atividade, definamos aqui alguns aspectos globalmente aplicados a ambos os algoritmos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Heurísticas adotadas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como conhecimento prévio estipulado pelo projetista, foi estipulado que as rainhas não podem estar em uma mesma coluna ou linha. Quaisquer soluções que não adiram a esses requisitos são descartadas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Critérios de parada adotados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dois critérios de parada são adotados por ambos os algoritmos:\n",
    "\n",
    "1. quando o número máximo de iterações for atingido; e\n",
    "2. quando uma solução ótima for encontrada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problemas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com o auxílio das definições-suporte feitas acima, pode-se seguir para as que dizem respeito aos algoritmos. Antes de fazê-lo, contudo, é necessário que definamos uma função para os experimentos que serão conduzidos, a fim de se produzirem as tabelas, gráficos e informações estipuladas em algumas alíneas desta atividade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def executa_experimento(funcao, n_execucoes=50, verboso=True):\n",
    "    n_execucoes = verifica_tipo(n_execucoes=(n_execucoes, \"parâmetro\", t.SupportsInt))\n",
    "    verboso = verifica_tipo(verboso=(verboso, \"parâmetro\", (bool, np.bool_)))\n",
    "    \n",
    "    melhores_solucoes = np.empty((n_execucoes, 1), dtype=np.object_)\n",
    "    melhores_valores = np.empty((n_execucoes, 1), dtype=np.int_)\n",
    "    tempos_gastos = np.empty((n_execucoes, 1), dtype=np.float_)\n",
    "    iteracoes_gastas = np.empty((n_execucoes, 1), dtype=np.int_)\n",
    "\n",
    "    for e in range(n_execucoes):\n",
    "        if verboso is True:\n",
    "            print(f\"Execução {e + 1}...\", end=\"\\r\")\n",
    "\n",
    "        tempos_gastos[e, 0] = timer()\n",
    "        melhores_solucoes[e, 0], iteracoes_gastas[e, 0] = funcao()\n",
    "        tempos_gastos[e, 0] = timer() - tempos_gastos[e, 0]\n",
    "        melhores_valores[e, 0] = melhores_solucoes[e, 0].valor\n",
    "        melhores_solucoes[e, 0] = str(melhores_solucoes[e, 0])\n",
    "\n",
    "    tabela = np.concatenate((melhores_solucoes, melhores_valores, tempos_gastos, iteracoes_gastas), axis=1)\n",
    "    tabela = pd.DataFrame(tabela, columns=[\"Solução\", \"Função-objetivo\", \"Tempo (seg.)\", \"Iterações\"]).infer_objects()\n",
    "\n",
    "    figura, eixos = plt.subplots(1, 2, figsize=(10, 5))\n",
    "    \n",
    "    # figura.tight_layout()\n",
    "    eixos[0].set_xlim(1, 50)\n",
    "    eixos[1].set_xlim(1, 50)\n",
    "\n",
    "    figura.suptitle(f\"Dados da execução do algoritmo {str(funcao).split(' ')[1]}\", y=1.05)\n",
    "\n",
    "    eixos[0].set_title(\"Iterações por execução\")\n",
    "    eixos[1].set_title(\"Tempo por execução (seg.)\")\n",
    "\n",
    "    sns.lineplot(x=range(1, n_execucoes + 1), y=iteracoes_gastas.ravel(), ax=eixos[0])\n",
    "    sns.lineplot(x=range(1, n_execucoes + 1), y=tempos_gastos.ravel(), ax=eixos[1])\n",
    "\n",
    "    if verboso is True:\n",
    "        print(f\"Execução concluída.\")\n",
    "\n",
    "    return tabela, figura"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, definamos aqui uma função que desempenhe a análise de correlação linear que faremos mais adiante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verifica_correlacao(funcao, tabela):\n",
    "    tabela_ordenada = tabela.sort_values([\"Iterações\", \"Tempo (seg.)\"])\n",
    "    pearson = stats.pearsonr(tabela['Tempo (seg.)'].to_numpy(), tabela['Iterações'].to_numpy())[0]\n",
    "    figura_correlacao, eixo_correlacao = plt.subplots(1, 1)\n",
    "\n",
    "    figura_correlacao.tight_layout()\n",
    "    figura_correlacao.suptitle(f\"{str(funcao).split(' ')[1]}: Iterações vs. Tempo (seg.)\", y=1.05)\n",
    "\n",
    "    sns.lineplot(x=tabela_ordenada[\"Iterações\"].to_numpy().ravel(), y=tabela_ordenada[\"Tempo (seg.)\"].to_numpy().ravel(), ax=eixo_correlacao)\n",
    "    \n",
    "    return figura_correlacao, pearson"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Stochastic Hill Climbing: Simulated Annealing_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para resolver a primeira questão, que diz respeito ao _Stochastic Hill Climbing_ (SHC), optamos por implementar o _Simulated Annealing_ (SA)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementação do SA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de seguirmos à resolução para as alíneas referentes a este algoritmo, definamos algumas funções."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Funções auxiliares ao SA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma função auxiliar necessária precisa produzir um vetor com as temperaturas a serem iteradas pelo algoritmo. Nesta implementação, utilizou-se o decaimento linear da temperatura."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gera_temperaturas(temperatura_inicial, variacao):\n",
    "    temperatura_inicial = verifica_tipo(temperatura_inicial=(temperatura_inicial, \"parâmetro\", t.SupportsFloat))\n",
    "    variacao = verifica_tipo(variacao=(variacao, \"parâmetro\", t.SupportsFloat))\n",
    "    \n",
    "    n_iteracoes = np.round(np.floor(temperatura_inicial / variacao))\n",
    "    temperaturas = temperatura_inicial - variacao * np.arange(n_iteracoes)\n",
    "\n",
    "    return temperaturas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, uma segunda função auxiliar é necessária para definir se o algoritmo deve ir para uma solução pior (i.e., uma solução com mais ataques)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tabuleiro_deve_mudar(temperatura, variacao):\n",
    "    temperatura = verifica_tipo(temperatura=(temperatura, \"parâmetro\", t.SupportsFloat))\n",
    "    variacao = verifica_tipo(variacao=(variacao, \"parâmetro\", t.SupportsFloat))\n",
    "    e = float(np.e)\n",
    "\n",
    "    exp = d.Decimal(d.Decimal(e) ** (d.Decimal(variacao) / d.Decimal(temperatura)))\n",
    "\n",
    "    return np.random.uniform() < exp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Algoritmo principal SA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com base nas definições acima, definamos agora o algoritmo principal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recozimento_simulado(temperatura_inicial=100, variacao=.01, binario=False, verboso=False):\n",
    "    temperatura_inicial = verifica_tipo(temperatura_inicial=(temperatura_inicial, \"parâmetro\", t.SupportsFloat))\n",
    "    variacao = verifica_tipo(variacao=(variacao, \"parâmetro\", t.SupportsFloat))\n",
    "    verboso = verifica_tipo(verboso=(verboso, \"parâmetro\", (bool, np.bool_)))\n",
    "\n",
    "    verifica_menor_ou_igual_a(variacao=(variacao, \"parâmetro\"), temperatura_inicial=(temperatura_inicial, \"parâmetro\"))\n",
    "\n",
    "    tabuleiro_atual = Tabuleiro(binario=binario)\n",
    "    temperaturas = gera_temperaturas(temperatura_inicial, variacao)\n",
    "\n",
    "    if verboso is True:\n",
    "        print(f\"[Iteração -1] {tabuleiro_atual}\")\n",
    "\n",
    "    if tabuleiro_atual.valor == 0:\n",
    "        return tabuleiro_atual, 0\n",
    "\n",
    "    for iteracao, temperatura in enumerate(temperaturas):\n",
    "        tabuleiro_seguinte = Tabuleiro(binario=binario)\n",
    "\n",
    "        if tabuleiro_seguinte.valor == 0:\n",
    "            return tabuleiro_seguinte, iteracao + 1\n",
    "\n",
    "        variacao = tabuleiro_atual - tabuleiro_seguinte\n",
    "        \n",
    "        if variacao > 0:\n",
    "            tabuleiro_atual = tabuleiro_seguinte\n",
    "        elif tabuleiro_deve_mudar(temperatura, variacao):\n",
    "            tabuleiro_atual = tabuleiro_seguinte\n",
    "\n",
    "        if verboso is True:\n",
    "            print(f\"[Iteração {iteracao}] {tabuleiro_atual} [Temperatura {np.round(temperatura, 3)}]\")\n",
    "\n",
    "    if verboso is True:\n",
    "        print(\"A temperatura chegou a zero.\")\n",
    "\n",
    "    return tabuleiro_atual"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta implementação foi realizada nas linhas do pseudo-código exposto na aula para este algoritmo, utilizando a codificação decimal (i.e., inteira). Nota-se que, graças ao suporte tanto à notação decimal quanto binária por parte da classe `Tabuleiro` e à simplicidade deste algoritmo, pode-se utilizar também a decimal ao regular o parâmetro `binario` da função `recozimento_simulado()`.\n",
    "\n",
    "A cada rodada, a temperatura sofre um decaimento seguindo alguma função (neste caso, utilizou-se uma função de decaimento linear cujo coeficiente angular é passado em `variacao`) e um novo posicionamento das rainhas é produzido por meio da criação de uma nova instância da classe `Tabuleiro`. Caso essa solução seja melhor do que a atual (i.e., tenha menos ataques, ou um atributo `valor` menor), o algoritmo a toma como a solução atual. Caso contrário, a função `tabuleiro_deve_mudar()` é chamada passando a temperatura e o coeficiente angular da função de decaimento como parâmetros, de forma que se obtenha uma resposta booleana à seguinte pergunta: \"o algoritmo deve escolher uma solução pior?\" A depender da resposta, o algoritmo pode tomar (ou não) a solução pior como solução atual e seguir para as próximas iterações.\n",
    "\n",
    "O algoritmo cessa sua execução quando a temperatura chega a 0, e retorna a solução atual."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Heurísticas e critérios de parada do SA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As heurísticas e critérios de parada adotados aqui são os globalmente definidos (rainhas não podem estar na mesma linha nem na mesma coluna). O mesmo vale para os critérios de parada: o algoritmo finaliza sua execução quando\n",
    "\n",
    "1. a temperatura chega a zero (i.e., o vetor de _arrays_ de temperaturas, cujo tamanho depende da temperatura inicial e variação e define o número de iterações, é integralmente percorrido); e\n",
    "2. o número de ataques chega a zero (i.e., `tabuleiro_atual.valor == 0` ou `tabuleiro_seguinte.valor == 0`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resultados do SA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pode-se obter os resultados pedidos através da função `executa_experimento()`, passando `recozimento_simulado()` pelo parâmetro `funcao`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execução concluída.\n"
     ]
    },
    {
     "data": {
      "application/pdf": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tabelaSA, figuraSA = executa_experimento(recozimento_simulado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste primeiro gráfico, temos o detalhamento da execução do algoritmo `recozimento_simulado()`. À esquerda, tem-se o número de iterações por execução; à direita, o tempo por execução em segundos. À primeira vista, nota-se a semelhança no comportamento entre os dois plots e a diferença na escala adotada no eixo das ordenadas pelos dois plots, o que dá a entender que o tempo cresce linearmente em função do número de iterações. Vamos tentar confirmar essa tendência dos resultados produzidos de duas formas: visualmente e numericamente.\n",
    "\n",
    "Em termos visuais, pode-se verificar a presença de correlação linear ao produzir um plot cujo eixo das abscissas representa as iterações e eixo das ordenadas, o tempo, produzido sobre a tabela de resultados ordenada em função do número de iterações e tomando o tempo como critério de desempate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/pdf": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figuraSAcorrelacao, pearsonSA = verifica_correlacao(recozimento_simulado, tabelaSA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em termos numéricos, pode-se verificar a presença de correlação linear ao utilizar o coeficiente de correlação estatística Pearson, que mede a presença de correlação linear em duas distribuições de valores. Quando o valor se aproxima de 1, tem-se uma forte correlação positiva; quando o valor se aproxima de -1, tem-se uma forte correlação negativa; e quando o valor se aproxima de 0, não há correlação linear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coeficiente de correlação Pearson dos resultados de recozimento_simulado: 0.997\n"
     ]
    }
   ],
   "source": [
    "print(f\"Coeficiente de correlação Pearson dos resultados de recozimento_simulado: {np.round(pearsonSA, 3)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tem-se constatada, portanto, uma forte correlação linear nos resultados apresentados. Vejamos algumas entradas da tabela de resultados, em que algumas soluções produzidas pelo algoritmo podem ser vistas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "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>Solução</th>\n",
       "      <th>Função-objetivo</th>\n",
       "      <th>Tempo (seg.)</th>\n",
       "      <th>Iterações</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[5, 1, 6, 0, 3, 7, 4, 2]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.018009</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[7, 3, 0, 2, 5, 1, 6, 4]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.130405</td>\n",
       "      <td>98</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[5, 2, 0, 7, 3, 1, 6, 4]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.163332</td>\n",
       "      <td>1194</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>[5, 3, 1, 7, 4, 6, 0, 2]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.038340</td>\n",
       "      <td>42</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>[3, 1, 4, 7, 5, 0, 2, 6]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.190607</td>\n",
       "      <td>213</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>[3, 7, 0, 2, 5, 1, 6, 4]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.464528</td>\n",
       "      <td>480</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>[7, 1, 3, 0, 6, 4, 2, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.180725</td>\n",
       "      <td>214</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>[3, 1, 7, 5, 0, 2, 4, 6]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.180212</td>\n",
       "      <td>187</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>[5, 2, 4, 7, 0, 3, 1, 6]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.166690</td>\n",
       "      <td>1210</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>[3, 0, 4, 7, 5, 2, 6, 1]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.144864</td>\n",
       "      <td>1138</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>[5, 2, 6, 1, 3, 7, 0, 4]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.126367</td>\n",
       "      <td>105</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>[3, 7, 0, 4, 6, 1, 5, 2]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.073845</td>\n",
       "      <td>67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>[2, 6, 1, 7, 5, 3, 0, 4]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.048458</td>\n",
       "      <td>38</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>[6, 1, 3, 0, 7, 4, 2, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.015708</td>\n",
       "      <td>1805</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>[1, 7, 5, 0, 2, 4, 6, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.114864</td>\n",
       "      <td>112</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>[4, 0, 7, 5, 2, 6, 1, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.549206</td>\n",
       "      <td>429</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>[4, 2, 7, 3, 6, 0, 5, 1]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.205249</td>\n",
       "      <td>188</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>[4, 6, 0, 2, 7, 5, 3, 1]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.232352</td>\n",
       "      <td>198</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>[3, 6, 4, 1, 5, 0, 2, 7]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.957179</td>\n",
       "      <td>813</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>[6, 4, 2, 0, 5, 7, 1, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.119675</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>[3, 0, 4, 7, 5, 2, 6, 1]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.474622</td>\n",
       "      <td>414</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>[4, 6, 1, 5, 2, 0, 7, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.326074</td>\n",
       "      <td>302</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>[2, 0, 6, 4, 7, 1, 3, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.043434</td>\n",
       "      <td>33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>[2, 5, 7, 1, 3, 0, 6, 4]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.458578</td>\n",
       "      <td>400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>[6, 1, 5, 2, 0, 3, 7, 4]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.395698</td>\n",
       "      <td>349</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>[3, 6, 2, 7, 1, 4, 0, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.256433</td>\n",
       "      <td>2034</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>[3, 0, 4, 7, 1, 6, 2, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.149926</td>\n",
       "      <td>136</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>[6, 1, 3, 0, 7, 4, 2, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.175611</td>\n",
       "      <td>154</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>[3, 0, 4, 7, 1, 6, 2, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.357115</td>\n",
       "      <td>321</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>[3, 1, 4, 7, 5, 0, 2, 6]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.003323</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>[5, 1, 6, 0, 2, 4, 7, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.216795</td>\n",
       "      <td>190</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>[2, 5, 1, 6, 0, 3, 7, 4]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.628183</td>\n",
       "      <td>543</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>[2, 5, 3, 1, 7, 4, 6, 0]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.455530</td>\n",
       "      <td>401</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>[1, 5, 7, 2, 0, 3, 6, 4]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.010713</td>\n",
       "      <td>908</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>[1, 7, 5, 0, 2, 4, 6, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.030360</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>[0, 4, 7, 5, 2, 6, 1, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.185371</td>\n",
       "      <td>161</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>[2, 5, 7, 0, 3, 6, 4, 1]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.175295</td>\n",
       "      <td>128</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>[3, 1, 7, 4, 6, 0, 2, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.011832</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>[4, 6, 1, 3, 7, 0, 2, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.221057</td>\n",
       "      <td>201</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>[2, 6, 1, 7, 4, 0, 3, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.120031</td>\n",
       "      <td>88</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>[1, 7, 5, 0, 2, 4, 6, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.165382</td>\n",
       "      <td>143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>[3, 6, 4, 2, 0, 5, 7, 1]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.217966</td>\n",
       "      <td>1035</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>[4, 0, 7, 3, 1, 6, 2, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.259439</td>\n",
       "      <td>221</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>[3, 6, 2, 7, 1, 4, 0, 5]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.517157</td>\n",
       "      <td>455</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>[5, 2, 4, 7, 0, 3, 1, 6]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.860380</td>\n",
       "      <td>2581</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>[2, 5, 1, 6, 4, 0, 7, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.352824</td>\n",
       "      <td>311</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>[4, 2, 0, 5, 7, 1, 3, 6]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.523361</td>\n",
       "      <td>1393</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>[3, 0, 4, 7, 5, 2, 6, 1]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.101384</td>\n",
       "      <td>91</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>[2, 5, 7, 0, 4, 6, 1, 3]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.568954</td>\n",
       "      <td>479</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>[4, 1, 3, 5, 7, 2, 0, 6]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.244477</td>\n",
       "      <td>219</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/latex": [
       "\\begin{tabular}{llrrr}\n",
       "\\toprule\n",
       "{} &                   Solução &  Função-objetivo &  Tempo (seg.) &  Iterações \\\\\n",
       "\\midrule\n",
       "0  &  [5, 1, 6, 0, 3, 7, 4, 2] &                0 &      0.018009 &          7 \\\\\n",
       "1  &  [7, 3, 0, 2, 5, 1, 6, 4] &                0 &      0.130405 &         98 \\\\\n",
       "2  &  [5, 2, 0, 7, 3, 1, 6, 4] &                0 &      1.163332 &       1194 \\\\\n",
       "3  &  [5, 3, 1, 7, 4, 6, 0, 2] &                0 &      0.038340 &         42 \\\\\n",
       "4  &  [3, 1, 4, 7, 5, 0, 2, 6] &                0 &      0.190607 &        213 \\\\\n",
       "5  &  [3, 7, 0, 2, 5, 1, 6, 4] &                0 &      0.464528 &        480 \\\\\n",
       "6  &  [7, 1, 3, 0, 6, 4, 2, 5] &                0 &      0.180725 &        214 \\\\\n",
       "7  &  [3, 1, 7, 5, 0, 2, 4, 6] &                0 &      0.180212 &        187 \\\\\n",
       "8  &  [5, 2, 4, 7, 0, 3, 1, 6] &                0 &      1.166690 &       1210 \\\\\n",
       "9  &  [3, 0, 4, 7, 5, 2, 6, 1] &                0 &      1.144864 &       1138 \\\\\n",
       "10 &  [5, 2, 6, 1, 3, 7, 0, 4] &                0 &      0.126367 &        105 \\\\\n",
       "11 &  [3, 7, 0, 4, 6, 1, 5, 2] &                0 &      0.073845 &         67 \\\\\n",
       "12 &  [2, 6, 1, 7, 5, 3, 0, 4] &                0 &      0.048458 &         38 \\\\\n",
       "13 &  [6, 1, 3, 0, 7, 4, 2, 5] &                0 &      2.015708 &       1805 \\\\\n",
       "14 &  [1, 7, 5, 0, 2, 4, 6, 3] &                0 &      0.114864 &        112 \\\\\n",
       "15 &  [4, 0, 7, 5, 2, 6, 1, 3] &                0 &      0.549206 &        429 \\\\\n",
       "16 &  [4, 2, 7, 3, 6, 0, 5, 1] &                0 &      0.205249 &        188 \\\\\n",
       "17 &  [4, 6, 0, 2, 7, 5, 3, 1] &                0 &      0.232352 &        198 \\\\\n",
       "18 &  [3, 6, 4, 1, 5, 0, 2, 7] &                0 &      0.957179 &        813 \\\\\n",
       "19 &  [6, 4, 2, 0, 5, 7, 1, 3] &                0 &      0.119675 &        100 \\\\\n",
       "20 &  [3, 0, 4, 7, 5, 2, 6, 1] &                0 &      0.474622 &        414 \\\\\n",
       "21 &  [4, 6, 1, 5, 2, 0, 7, 3] &                0 &      0.326074 &        302 \\\\\n",
       "22 &  [2, 0, 6, 4, 7, 1, 3, 5] &                0 &      0.043434 &         33 \\\\\n",
       "23 &  [2, 5, 7, 1, 3, 0, 6, 4] &                0 &      0.458578 &        400 \\\\\n",
       "24 &  [6, 1, 5, 2, 0, 3, 7, 4] &                0 &      0.395698 &        349 \\\\\n",
       "25 &  [3, 6, 2, 7, 1, 4, 0, 5] &                0 &      2.256433 &       2034 \\\\\n",
       "26 &  [3, 0, 4, 7, 1, 6, 2, 5] &                0 &      0.149926 &        136 \\\\\n",
       "27 &  [6, 1, 3, 0, 7, 4, 2, 5] &                0 &      0.175611 &        154 \\\\\n",
       "28 &  [3, 0, 4, 7, 1, 6, 2, 5] &                0 &      0.357115 &        321 \\\\\n",
       "29 &  [3, 1, 4, 7, 5, 0, 2, 6] &                0 &      0.003323 &          1 \\\\\n",
       "30 &  [5, 1, 6, 0, 2, 4, 7, 3] &                0 &      0.216795 &        190 \\\\\n",
       "31 &  [2, 5, 1, 6, 0, 3, 7, 4] &                0 &      0.628183 &        543 \\\\\n",
       "32 &  [2, 5, 3, 1, 7, 4, 6, 0] &                0 &      0.455530 &        401 \\\\\n",
       "33 &  [1, 5, 7, 2, 0, 3, 6, 4] &                0 &      1.010713 &        908 \\\\\n",
       "34 &  [1, 7, 5, 0, 2, 4, 6, 3] &                0 &      0.030360 &         21 \\\\\n",
       "35 &  [0, 4, 7, 5, 2, 6, 1, 3] &                0 &      0.185371 &        161 \\\\\n",
       "36 &  [2, 5, 7, 0, 3, 6, 4, 1] &                0 &      0.175295 &        128 \\\\\n",
       "37 &  [3, 1, 7, 4, 6, 0, 2, 5] &                0 &      0.011832 &         11 \\\\\n",
       "38 &  [4, 6, 1, 3, 7, 0, 2, 5] &                0 &      0.221057 &        201 \\\\\n",
       "39 &  [2, 6, 1, 7, 4, 0, 3, 5] &                0 &      0.120031 &         88 \\\\\n",
       "40 &  [1, 7, 5, 0, 2, 4, 6, 3] &                0 &      0.165382 &        143 \\\\\n",
       "41 &  [3, 6, 4, 2, 0, 5, 7, 1] &                0 &      1.217966 &       1035 \\\\\n",
       "42 &  [4, 0, 7, 3, 1, 6, 2, 5] &                0 &      0.259439 &        221 \\\\\n",
       "43 &  [3, 6, 2, 7, 1, 4, 0, 5] &                0 &      0.517157 &        455 \\\\\n",
       "44 &  [5, 2, 4, 7, 0, 3, 1, 6] &                0 &      2.860380 &       2581 \\\\\n",
       "45 &  [2, 5, 1, 6, 4, 0, 7, 3] &                0 &      0.352824 &        311 \\\\\n",
       "46 &  [4, 2, 0, 5, 7, 1, 3, 6] &                0 &      1.523361 &       1393 \\\\\n",
       "47 &  [3, 0, 4, 7, 5, 2, 6, 1] &                0 &      0.101384 &         91 \\\\\n",
       "48 &  [2, 5, 7, 0, 4, 6, 1, 3] &                0 &      0.568954 &        479 \\\\\n",
       "49 &  [4, 1, 3, 5, 7, 2, 0, 6] &                0 &      0.244477 &        219 \\\\\n",
       "\\bottomrule\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "                     Solução  Função-objetivo  Tempo (seg.)  Iterações\n",
       "0   [5, 1, 6, 0, 3, 7, 4, 2]                0      0.018009          7\n",
       "1   [7, 3, 0, 2, 5, 1, 6, 4]                0      0.130405         98\n",
       "2   [5, 2, 0, 7, 3, 1, 6, 4]                0      1.163332       1194\n",
       "3   [5, 3, 1, 7, 4, 6, 0, 2]                0      0.038340         42\n",
       "4   [3, 1, 4, 7, 5, 0, 2, 6]                0      0.190607        213\n",
       "5   [3, 7, 0, 2, 5, 1, 6, 4]                0      0.464528        480\n",
       "6   [7, 1, 3, 0, 6, 4, 2, 5]                0      0.180725        214\n",
       "7   [3, 1, 7, 5, 0, 2, 4, 6]                0      0.180212        187\n",
       "8   [5, 2, 4, 7, 0, 3, 1, 6]                0      1.166690       1210\n",
       "9   [3, 0, 4, 7, 5, 2, 6, 1]                0      1.144864       1138\n",
       "10  [5, 2, 6, 1, 3, 7, 0, 4]                0      0.126367        105\n",
       "11  [3, 7, 0, 4, 6, 1, 5, 2]                0      0.073845         67\n",
       "12  [2, 6, 1, 7, 5, 3, 0, 4]                0      0.048458         38\n",
       "13  [6, 1, 3, 0, 7, 4, 2, 5]                0      2.015708       1805\n",
       "14  [1, 7, 5, 0, 2, 4, 6, 3]                0      0.114864        112\n",
       "15  [4, 0, 7, 5, 2, 6, 1, 3]                0      0.549206        429\n",
       "16  [4, 2, 7, 3, 6, 0, 5, 1]                0      0.205249        188\n",
       "17  [4, 6, 0, 2, 7, 5, 3, 1]                0      0.232352        198\n",
       "18  [3, 6, 4, 1, 5, 0, 2, 7]                0      0.957179        813\n",
       "19  [6, 4, 2, 0, 5, 7, 1, 3]                0      0.119675        100\n",
       "20  [3, 0, 4, 7, 5, 2, 6, 1]                0      0.474622        414\n",
       "21  [4, 6, 1, 5, 2, 0, 7, 3]                0      0.326074        302\n",
       "22  [2, 0, 6, 4, 7, 1, 3, 5]                0      0.043434         33\n",
       "23  [2, 5, 7, 1, 3, 0, 6, 4]                0      0.458578        400\n",
       "24  [6, 1, 5, 2, 0, 3, 7, 4]                0      0.395698        349\n",
       "25  [3, 6, 2, 7, 1, 4, 0, 5]                0      2.256433       2034\n",
       "26  [3, 0, 4, 7, 1, 6, 2, 5]                0      0.149926        136\n",
       "27  [6, 1, 3, 0, 7, 4, 2, 5]                0      0.175611        154\n",
       "28  [3, 0, 4, 7, 1, 6, 2, 5]                0      0.357115        321\n",
       "29  [3, 1, 4, 7, 5, 0, 2, 6]                0      0.003323          1\n",
       "30  [5, 1, 6, 0, 2, 4, 7, 3]                0      0.216795        190\n",
       "31  [2, 5, 1, 6, 0, 3, 7, 4]                0      0.628183        543\n",
       "32  [2, 5, 3, 1, 7, 4, 6, 0]                0      0.455530        401\n",
       "33  [1, 5, 7, 2, 0, 3, 6, 4]                0      1.010713        908\n",
       "34  [1, 7, 5, 0, 2, 4, 6, 3]                0      0.030360         21\n",
       "35  [0, 4, 7, 5, 2, 6, 1, 3]                0      0.185371        161\n",
       "36  [2, 5, 7, 0, 3, 6, 4, 1]                0      0.175295        128\n",
       "37  [3, 1, 7, 4, 6, 0, 2, 5]                0      0.011832         11\n",
       "38  [4, 6, 1, 3, 7, 0, 2, 5]                0      0.221057        201\n",
       "39  [2, 6, 1, 7, 4, 0, 3, 5]                0      0.120031         88\n",
       "40  [1, 7, 5, 0, 2, 4, 6, 3]                0      0.165382        143\n",
       "41  [3, 6, 4, 2, 0, 5, 7, 1]                0      1.217966       1035\n",
       "42  [4, 0, 7, 3, 1, 6, 2, 5]                0      0.259439        221\n",
       "43  [3, 6, 2, 7, 1, 4, 0, 5]                0      0.517157        455\n",
       "44  [5, 2, 4, 7, 0, 3, 1, 6]                0      2.860380       2581\n",
       "45  [2, 5, 1, 6, 4, 0, 7, 3]                0      0.352824        311\n",
       "46  [4, 2, 0, 5, 7, 1, 3, 6]                0      1.523361       1393\n",
       "47  [3, 0, 4, 7, 5, 2, 6, 1]                0      0.101384         91\n",
       "48  [2, 5, 7, 0, 4, 6, 1, 3]                0      0.568954        479\n",
       "49  [4, 1, 3, 5, 7, 2, 0, 6]                0      0.244477        219"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabelaSA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, vejamos algumas estatísticas obtidas a partir da tabela de resultados do SA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Média e desvio padrão da função-objetivo: 0.0 ± 0.0 ataques\n",
      "Média e desvio padrão do tempo gasto: 0.493 ± 0.611 segundos\n",
      "Média e desvio padrão das iterações gastas: 447.24 ± 559.441\n"
     ]
    }
   ],
   "source": [
    "print(f\"Média e desvio padrão da função-objetivo: {tabelaSA['Função-objetivo'].mean()} ± {tabelaSA['Função-objetivo'].std()} ataques\\n\"\n",
    "      f\"Média e desvio padrão do tempo gasto: {np.round(tabelaSA['Tempo (seg.)'].mean(), 3)} ± {np.round(tabelaSA['Tempo (seg.)'].std(), 3)} segundos\\n\"\n",
    "      f\"Média e desvio padrão das iterações gastas: {np.round(tabelaSA['Iterações'].mean(), 3)} ± {np.round(tabelaSA['Iterações'].std(), 3)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota-se que temos um desvio padrão no tempo e no número de iterações praticamente igual, respectivamente, ao tempo e ao número de iterações médios, o que demonstra uma significativa oscilação no número de iterações e no tempo entre execuções. Por um outro lado, tem-se que todas as execuções conseguiram encontrar uma solução ótima antes da temperatura chegar a zero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Meta-heuristic_: _Genetic Algorithm_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para resolver a segunda questão, realizamos a implementação da meta-heurística _Genetic Algorithm_ (GA)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementação do GA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de seguirmos à resolução para as alíneas referentes a este algoritmo, definamos algumas funções."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Funções auxiliares ao GA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma definição é necessária para auxiliar na exibição da evolução do algoritmo quando `verboso = True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gera_contagem_populacao(populacao):\n",
    "    ataques = [tabuleiro.valor for tabuleiro in populacao]\n",
    "\n",
    "    colunas = np.unique(ataques)\n",
    "    indices = [\"Contagem\"]\n",
    "\n",
    "    contagem_de_valores = {ataque: 0 for ataque in colunas}\n",
    "\n",
    "    for ataque in ataques:\n",
    "        contagem_de_valores[ataque] += 1\n",
    "\n",
    "    data_frame = pd.DataFrame(contagem_de_valores, columns=colunas, index=indices)\n",
    "    data_frame.columns.names = [\"Ataques\"]\n",
    "\n",
    "    return data_frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em adição, uma função é requerida para inicializar a população."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inicializa_populacao(tamanho_populacao):\n",
    "    populacao = [Tabuleiro(binario=True) for _ in range(tamanho_populacao)]\n",
    "\n",
    "    return sorted(populacao)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em seguida, definições que aplicam os operadores evolucionários são necessárias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def selecao_dos_pais(populacao, tamanho_ringue):\n",
    "    nova_populacao, tamanho_populacao = [], len(populacao)\n",
    "\n",
    "    for _ in range(tamanho_populacao):\n",
    "        lutadores = r.sample(populacao, tamanho_ringue)\n",
    "        lutadores = sorted(lutadores)\n",
    "\n",
    "        nova_populacao.append(lutadores[0])\n",
    "\n",
    "    return nova_populacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cruzamento(populacao, taxa_crossover):\n",
    "    nova_populacao, tamanho_populacao = [], len(populacao)\n",
    "    n_rodadas = np.ceil(tamanho_populacao / 2).astype(np.int_)\n",
    "\n",
    "    for _ in range(n_rodadas):\n",
    "        pai1, pai2 = r.sample(populacao, 2)\n",
    "        pai1, pai2 = pai1.rainhas, pai2.rainhas\n",
    "\n",
    "        if np.random.uniform() <= taxa_crossover:\n",
    "            corte = r.randint(1, len(pai1) - 1)\n",
    "\n",
    "            filho1 = np.concatenate((pai1[:corte], pai2[corte:]))\n",
    "            filho2 = np.concatenate((pai2[:corte], pai1[corte:]))\n",
    "        else:\n",
    "            filho1, filho2 = pai1, pai2\n",
    "\n",
    "        filho1, filho2 = Tabuleiro(binario=True, rainhas=filho1), Tabuleiro(binario=True, rainhas=filho2)\n",
    "\n",
    "        if tamanho_populacao - len(nova_populacao) >= 2:\n",
    "            nova_populacao.extend([filho1, filho2])\n",
    "        else:\n",
    "            nova_populacao.append(filho1 if np.random.uniform() <= .5 else filho2)\n",
    "\n",
    "    return nova_populacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutacao(populacao, taxa_mutacao):\n",
    "    nova_populacao, tamanho_populacao = [], len(populacao)\n",
    "\n",
    "    for i in range(tamanho_populacao):\n",
    "        rainhas = populacao[i].rainhas\n",
    "\n",
    "        for bit in range(rainhas.ravel().shape[0]):\n",
    "            if np.random.uniform() <= taxa_mutacao:\n",
    "                rainhas.ravel()[bit] = not rainhas.ravel()[bit]\n",
    "\n",
    "        novo_tabuleiro = Tabuleiro(binario=True, rainhas=rainhas)\n",
    "\n",
    "        nova_populacao.append(novo_tabuleiro)\n",
    "\n",
    "    return nova_populacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seleciona_sobreviventes(populacao, nova_populacao):\n",
    "    sobreviventes = sorted(populacao + nova_populacao)\n",
    "\n",
    "    return sobreviventes[:len(populacao)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em seguida, uma função que assegura que os filhos estão respeitando as heurísticas estipuladas (nenhuma rainha na mesma linha) é definida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gera_filhos_validos(pais, taxa_crossover, taxa_mutacao):\n",
    "    filhos = []\n",
    "\n",
    "    embrioes = cruzamento(pais, taxa_crossover)\n",
    "    fetos = mutacao(embrioes, taxa_mutacao)\n",
    "\n",
    "    for feto in fetos:\n",
    "        if feto.ha_rainhas_na_mesma_linha is False:\n",
    "            filhos.append(feto)\n",
    "\n",
    "    return filhos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, uma solução que gera a nova população é definida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gera_nova_populacao(populacao, taxa_crossover, taxa_mutacao, tamanho_ringue):\n",
    "    pais = selecao_dos_pais(populacao, tamanho_ringue)\n",
    "    filhos = gera_filhos_validos(pais, taxa_crossover, taxa_mutacao)\n",
    "\n",
    "    return sorted(filhos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Algoritmo principal GA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com base nas definições acima, definamos agora o algoritmo principal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def algoritmo_genetico(tamanho_populacao=20, max_iteracoes=1000, taxa_mutacao=.03, taxa_crossover=.8, tamanho_ringue=3, verboso=False):\n",
    "    tamanho_populacao = verifica_tipo(tamanho_populacao=(tamanho_populacao, \"parâmetro\", t.SupportsInt))\n",
    "    max_iteracoes = verifica_tipo(max_iteracoes=(max_iteracoes, \"parâmetro\", t.SupportsInt))\n",
    "    taxa_mutacao = verifica_tipo(taxa_mutacao=(taxa_mutacao, \"parâmetro\", t.SupportsFloat))\n",
    "    taxa_crossover = verifica_tipo(taxa_crossover=(taxa_crossover, \"parâmetro\", t.SupportsFloat))\n",
    "    tamanho_ringue = verifica_tipo(tamanho_do_ringue=(tamanho_ringue, \"parâmetro\", t.SupportsInt))\n",
    "    verboso = verifica_tipo(verboso=(verboso, \"parâmetro\", (bool, np.bool_)))\n",
    "\n",
    "    verifica_nao_negatividade(tamanho_populacao=(tamanho_populacao, \"parâmetro\"), max_iteracoes=(max_iteracoes, \"parâmetro\"), taxa_mutacao=(taxa_mutacao, \"parâmetro\"), taxa_crossover=(taxa_crossover, \"parâmetro\"), tamanho_ringue=(tamanho_ringue, \"parâmetro\"))\n",
    "    verifica_menor_ou_igual_a(taxa_mutacao=(taxa_mutacao, \"parâmetro\"), valor=(1, \"valor\"))\n",
    "    verifica_menor_ou_igual_a(taxa_mutacao=(taxa_crossover, \"parâmetro\"), valor=(1, \"valor\"))\n",
    "    verifica_menor_ou_igual_a(tamanho_ringue=(tamanho_ringue, \"parâmetro\"), tamanho_populacao=(tamanho_populacao, \"parâmetro\"))\n",
    "\n",
    "    pais = inicializa_populacao(tamanho_populacao)\n",
    "    iteracao = 0\n",
    "\n",
    "    if verboso is True:\n",
    "        print(f\"[Iteração {iteracao}] População inicial: \\n\"\n",
    "              f\"{gera_contagem_populacao(pais)}\", end=\"\\n\\n\")\n",
    "\n",
    "    while iteracao < max_iteracoes:\n",
    "        if pais[0].valor == 0:\n",
    "            if verboso is True:\n",
    "                print(\"Uma solução ótima foi encontrada.\")\n",
    "\n",
    "            break\n",
    "\n",
    "        filhos = gera_nova_populacao(pais, taxa_crossover, taxa_mutacao, tamanho_ringue)\n",
    "        pais = seleciona_sobreviventes(pais, filhos)\n",
    "        iteracao += 1\n",
    "\n",
    "        if verboso is True:\n",
    "            print(f\"[Iteração {iteracao}]\\n\"\n",
    "                  f\"Filhos: \\n\"\n",
    "                  f\"{gera_contagem_populacao(filhos)}\\n\\n\"\n",
    "                  f\"Sobreviventes: \\n\"\n",
    "                  f\"{gera_contagem_populacao(pais)}\", end=\"\\n\\n\")\n",
    "\n",
    "    if iteracao >= max_iteracoes and verboso is True:\n",
    "        print(\"O número máximo de iterações foi atingido.\")\n",
    "\n",
    "    return pais[0], iteracao"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesta implementação, começa-se com a inicialização de uma população de instâncias da classe `Tabuleiro` com `binario=True`, i.e., com a notação binária em uso. A cada rodada, os operadores genéticos binários são aplicados na população, gerando filhos. Isso se dá na função `gera_nova_populacao()`. \n",
    "\n",
    "A função `gera_nova_populacao()` não se restringe à aplicação dos operadores, no entanto: ela também descarta os filhos que possuem rainhas na mesma linha, assegurando o cumprimento das heurísticas que adotamos globalmente. Dessa forma, nenhuma solução pode ter rainhas na mesma linha nem na mesma coluna.\n",
    "\n",
    "Por fim, a população de filhos é concatenada à de pais (gerando um vetor com o dobro do valor `tamanho_população`) e tem-se um processo de seleção de sobreviventes elitista, em que apenas as melhores soluções entre os pais e filhos é preservada (para isso, ordena-se o vetor filhos+pais e seleciona-se apenas os melhores `tamanho_populacao` elementos).\n",
    "\n",
    "O algoritmo cessa sua execução quando atinge o número máximo de execuções ou quando o valor de alguma solução é igual a 0 (o que indica que o número de ataques do tabuleiro é igual a 0), retornando a solução atual."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores do GA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Descrevamos, agora, os operadores deste GA. É importante lembrar que, em função das estipulações da atividade proposta, apenas a implementação dos operadores de seleção dos pais, cruzamento e mutação ficaram a critério dos projetistas.\n",
    "\n",
    "- Para a **seleção dos pais**, utilizou-se a técnica **_n-Way Tournament Selection_**, em que são selecionados _n_ indivíduos aleatórios da população para \"lutar\" entre si, ganhando o que tiver melhor _fitness_. Adotamos `n = 3`. Os torneios ocorrem até que uma população de mesmo tamanho à original seja produzida (e.g., uma população de 50 indivíduos gerará uma _mating pool_ de 50 possíveis pais).\n",
    "- Para o **cruzamento**, utilizou-se a técnica de **cruzamento com ponto de corte aleatório**. Nessa técnica, dois indivíduos são aleatoriamente selecionados da população de pais (podendo haver repetição). Uma posição aleatória _c_ é escolhida como ponto de corte. Quando a taxa de _crossover_ não é ultrapassada, corta-se o vetor do pai 1 da posição inicial até a posição _c_ e o vetor do pai 2 de _c_ até a última posição. Os cortes são concatenados gerando o filho 1, e o restante dos vetores \"cortados\" também são concatenados para gerar o filho 2. Caso a taxa de crossover seja ultrapassada, os pais tornam-se os filhos. Esse processo se repete até que uma população de mesmo tamanho à original seja produzida.\n",
    "- Para a **mutação**, utilizou-se a técnica de **_bit flip_**. Nessa técnica, há um teste para cada bit de cada solução, tal que se o número aleatório gerado for inferior ao da taxa de mutação, um bit `False` é transformado em um bit `True` e vice-versa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resultados do GA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execução concluída.\n"
     ]
    },
    {
     "data": {
      "application/pdf": "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\n",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tabelaGA, figuraGA = executa_experimento(algoritmo_genetico)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este gráfico, similarmente ao primeiro, consiste no detalhamento da execução do algoritmo `algoritmo_genetico()`. À esquerda, tem-se o número de iterações por execução; à direita, o tempo por execução em segundos. À primeira vista, a semelhança entre o comportamento dos dois plots não é tão visível; contudo, nota-se que a escala do número de iterações e do tempo em segundos é parecida. Vamos tentar verificar a existência de correlação linear nos resultados produzidos. Fá-lo-emos, assim como ocorreu com o SA, de duas formas: visualmente e numericamente.\n",
    "\n",
    "Em termos visuais, pode-se verificar a presença de correlação linear ao produzir um plot cujo eixo das abscissas representa as iterações e eixo das ordenadas, o tempo, produzido sobre a tabela de resultados ordenada em função do número de iterações e tomando o tempo como critério de desempate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/pdf": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figuraGAcorrelacao, pearsonGA = verifica_correlacao(algoritmo_genetico, tabelaGA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em termos numéricos, pode-se verificar a presença de correlação linear ao utilizar o coeficiente de correlação estatística Pearson, que mede a presença de correlação linear em duas distribuições de valores. Quando o valor se aproxima de 1, tem-se uma forte correlação positiva; quando o valor se aproxima de -1, tem-se uma forte correlação negativa; e quando o valor se aproxima de 0, não há correlação linear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coeficiente de correlação Pearson dos resultados de algoritmo_genetico: 0.986\n"
     ]
    }
   ],
   "source": [
    "print(f\"Coeficiente de correlação Pearson dos resultados de algoritmo_genetico: {np.round(pearsonGA, 3)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tem-se constatada, portanto, uma forte correlação linear nos resultados apresentados, embora ligeiramente menor do que a vista no SA.\n",
    "\n",
    "Vejamos algumas entradas da tabela de resultados, em que algumas soluções produzidas pelo algoritmo podem ser vistas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "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>Solução</th>\n",
       "      <th>Função-objetivo</th>\n",
       "      <th>Tempo (seg.)</th>\n",
       "      <th>Iterações</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[0101, 0001, 1011, 0110, 1010, 0111, 0010, 0100]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.312335</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[0110, 0011, 0001, 1000, 0101, 0010, 0100, 0111]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.082703</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[0011, 0001, 1111, 1000, 0110, 0100, 0010, 0101]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.950228</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>[1100, 0101, 1011, 0001, 0110, 1010, 0011, 0111]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.704789</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>[0110, 0001, 1010, 0101, 0111, 1100, 0011, 1000]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.307488</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>[0000, 1100, 1000, 0110, 0011, 0001, 1110, 0101]</td>\n",
       "      <td>0</td>\n",
       "      <td>3.144580</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>[0101, 1100, 0001, 0100, 0111, 0011, 0110, 0010]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.947126</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>[1000, 0011, 0111, 0000, 1011, 0110, 0000, 0000]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.346030</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>[0101, 0111, 0001, 0100, 0010, 1000, 0110, 0011]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.075392</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>[0101, 0111, 0001, 0011, 1000, 0110, 0100, 0010]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.079228</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>[0001, 0111, 0000, 1000, 1101, 0010, 0110, 0011]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.657378</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>[1111, 1000, 1100, 0011, 0001, 1110, 0010, 0000]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.651467</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>[0101, 0011, 1000, 0100, 0111, 0001, 0110, 0010]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.078855</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>[0011, 0110, 1000, 0001, 0100, 0111, 0101, 0010]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.077606</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>[0101, 0010, 1000, 0011, 0111, 0100, 0001, 1110]</td>\n",
       "      <td>0</td>\n",
       "      <td>3.373618</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>[1101, 1111, 0011, 0000, 0110, 1100, 0001, 0101]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.679081</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>[0011, 0111, 0010, 0100, 0110, 1100, 0101, 1011]</td>\n",
       "      <td>0</td>\n",
       "      <td>3.451528</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>[0101, 1000, 0100, 0001, 0111, 0010, 0110, 1011]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.706135</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>[0100, 0110, 1001, 0010, 1101, 0111, 0011, 0001]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.346664</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>[1110, 1000, 0100, 1001, 0011, 0110, 0010, 1100]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.302312</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>[0011, 0000, 0110, 1111, 1011, 0010, 1000, 0101]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.341734</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>[1000, 0011, 0111, 0100, 1010, 0001, 1101, 0110]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.056320</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>[0000, 1010, 0001, 1111, 0110, 0000, 0011, 0101]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.295660</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>[1000, 0000, 0111, 0011, 0110, 0010, 1111, 1010]</td>\n",
       "      <td>0</td>\n",
       "      <td>6.221395</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>[1100, 0010, 0111, 1011, 0000, 0101, 0001, 0110]</td>\n",
       "      <td>0</td>\n",
       "      <td>7.968901</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>[0011, 0101, 1101, 0100, 0000, 0111, 1011, 1111]</td>\n",
       "      <td>0</td>\n",
       "      <td>3.267257</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>[0110, 0000, 0010, 0111, 1011, 0000, 1110, 0101]</td>\n",
       "      <td>0</td>\n",
       "      <td>3.543428</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>[0011, 0001, 0100, 0111, 1100, 0010, 0101, 1000]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.682577</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>[0101, 0011, 1000, 0100, 0111, 0001, 1010, 0110]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.107051</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>[0011, 1110, 0111, 0010, 0100, 0001, 1000, 0101]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.372144</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>[0011, 0001, 1100, 1000, 0101, 0111, 0010, 0110]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.703053</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>[0000, 1110, 0101, 0000, 1000, 0100, 0111, 0011]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.589566</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>[0010, 0111, 0001, 0011, 0101, 1000, 1110, 0100]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.066177</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>[1000, 1111, 0001, 0111, 0101, 0010, 0000, 1101]</td>\n",
       "      <td>0</td>\n",
       "      <td>4.236123</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>[0111, 0100, 0001, 0011, 0110, 1001, 1111, 1000]</td>\n",
       "      <td>0</td>\n",
       "      <td>4.476525</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>[0010, 0111, 0011, 0110, 1000, 0001, 1101, 0100]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.422873</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>[0010, 0110, 1000, 0011, 0001, 0100, 0111, 0101]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.074988</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>[1000, 0100, 0000, 1101, 0110, 0001, 0101, 0010]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.297490</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>[0010, 0111, 0011, 0110, 1000, 0101, 0001, 0100]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.079139</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>[1000, 1010, 0011, 0110, 1011, 0111, 0001, 1101]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.283877</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>[0110, 1000, 1011, 0100, 0111, 0101, 1010, 0001]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.325036</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>[1110, 0110, 1000, 0000, 0010, 0100, 0111, 1001]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.519844</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>[0001, 0101, 0111, 1010, 0100, 0010, 1000, 0011]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.743251</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>[1100, 0101, 0111, 1010, 0110, 0010, 1001, 0001]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.021382</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>[0101, 0001, 0100, 0110, 1000, 0010, 0111, 0011]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.080754</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>[1110, 0111, 0001, 0100, 1000, 0101, 1011, 0010]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.567141</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>[0110, 0011, 1100, 0010, 1000, 0101, 0111, 0100]</td>\n",
       "      <td>0</td>\n",
       "      <td>1.367358</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>[0000, 1011, 0100, 0110, 0001, 0011, 1010, 1000]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.559863</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>[0011, 0101, 0111, 0001, 0100, 0010, 1000, 0110]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.076224</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>[0000, 1000, 1110, 0101, 0010, 1001, 0001, 0100]</td>\n",
       "      <td>0</td>\n",
       "      <td>2.633026</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/latex": [
       "\\begin{tabular}{llrrr}\n",
       "\\toprule\n",
       "{} &                                           Solução &  Função-objetivo &  Tempo (seg.) &  Iterações \\\\\n",
       "\\midrule\n",
       "0  &  [0101, 0001, 1011, 0110, 1010, 0111, 0010, 0100] &                0 &      2.312335 &          5 \\\\\n",
       "1  &  [0110, 0011, 0001, 1000, 0101, 0010, 0100, 0111] &                0 &      0.082703 &          0 \\\\\n",
       "2  &  [0011, 0001, 1111, 1000, 0110, 0100, 0010, 0101] &                0 &      1.950228 &          6 \\\\\n",
       "3  &  [1100, 0101, 1011, 0001, 0110, 1010, 0011, 0111] &                0 &      0.704789 &          2 \\\\\n",
       "4  &  [0110, 0001, 1010, 0101, 0111, 1100, 0011, 1000] &                0 &      2.307488 &          7 \\\\\n",
       "5  &  [0000, 1100, 1000, 0110, 0011, 0001, 1110, 0101] &                0 &      3.144580 &         10 \\\\\n",
       "6  &  [0101, 1100, 0001, 0100, 0111, 0011, 0110, 0010] &                0 &      2.947126 &          9 \\\\\n",
       "7  &  [1000, 0011, 0111, 0000, 1011, 0110, 0000, 0000] &                0 &      1.346030 &          4 \\\\\n",
       "8  &  [0101, 0111, 0001, 0100, 0010, 1000, 0110, 0011] &                0 &      0.075392 &          0 \\\\\n",
       "9  &  [0101, 0111, 0001, 0011, 1000, 0110, 0100, 0010] &                0 &      0.079228 &          0 \\\\\n",
       "10 &  [0001, 0111, 0000, 1000, 1101, 0010, 0110, 0011] &                0 &      1.657378 &          5 \\\\\n",
       "11 &  [1111, 1000, 1100, 0011, 0001, 1110, 0010, 0000] &                0 &      1.651467 &          5 \\\\\n",
       "12 &  [0101, 0011, 1000, 0100, 0111, 0001, 0110, 0010] &                0 &      0.078855 &          0 \\\\\n",
       "13 &  [0011, 0110, 1000, 0001, 0100, 0111, 0101, 0010] &                0 &      0.077606 &          0 \\\\\n",
       "14 &  [0101, 0010, 1000, 0011, 0111, 0100, 0001, 1110] &                0 &      3.373618 &         10 \\\\\n",
       "15 &  [1101, 1111, 0011, 0000, 0110, 1100, 0001, 0101] &                0 &      2.679081 &          8 \\\\\n",
       "16 &  [0011, 0111, 0010, 0100, 0110, 1100, 0101, 1011] &                0 &      3.451528 &         11 \\\\\n",
       "17 &  [0101, 1000, 0100, 0001, 0111, 0010, 0110, 1011] &                0 &      0.706135 &          2 \\\\\n",
       "18 &  [0100, 0110, 1001, 0010, 1101, 0111, 0011, 0001] &                0 &      1.346664 &          4 \\\\\n",
       "19 &  [1110, 1000, 0100, 1001, 0011, 0110, 0010, 1100] &                0 &      2.302312 &          7 \\\\\n",
       "20 &  [0011, 0000, 0110, 1111, 1011, 0010, 1000, 0101] &                0 &      1.341734 &          4 \\\\\n",
       "21 &  [1000, 0011, 0111, 0100, 1010, 0001, 1101, 0110] &                0 &      1.056320 &          3 \\\\\n",
       "22 &  [0000, 1010, 0001, 1111, 0110, 0000, 0011, 0101] &                0 &      2.295660 &          7 \\\\\n",
       "23 &  [1000, 0000, 0111, 0011, 0110, 0010, 1111, 1010] &                0 &      6.221395 &         15 \\\\\n",
       "24 &  [1100, 0010, 0111, 1011, 0000, 0101, 0001, 0110] &                0 &      7.968901 &         20 \\\\\n",
       "25 &  [0011, 0101, 1101, 0100, 0000, 0111, 1011, 1111] &                0 &      3.267257 &         10 \\\\\n",
       "26 &  [0110, 0000, 0010, 0111, 1011, 0000, 1110, 0101] &                0 &      3.543428 &         11 \\\\\n",
       "27 &  [0011, 0001, 0100, 0111, 1100, 0010, 0101, 1000] &                0 &      1.682577 &          5 \\\\\n",
       "28 &  [0101, 0011, 1000, 0100, 0111, 0001, 1010, 0110] &                0 &      1.107051 &          3 \\\\\n",
       "29 &  [0011, 1110, 0111, 0010, 0100, 0001, 1000, 0101] &                0 &      1.372144 &          4 \\\\\n",
       "30 &  [0011, 0001, 1100, 1000, 0101, 0111, 0010, 0110] &                0 &      0.703053 &          2 \\\\\n",
       "31 &  [0000, 1110, 0101, 0000, 1000, 0100, 0111, 0011] &                0 &      2.589566 &          8 \\\\\n",
       "32 &  [0010, 0111, 0001, 0011, 0101, 1000, 1110, 0100] &                0 &      1.066177 &          3 \\\\\n",
       "33 &  [1000, 1111, 0001, 0111, 0101, 0010, 0000, 1101] &                0 &      4.236123 &         13 \\\\\n",
       "34 &  [0111, 0100, 0001, 0011, 0110, 1001, 1111, 1000] &                0 &      4.476525 &         14 \\\\\n",
       "35 &  [0010, 0111, 0011, 0110, 1000, 0001, 1101, 0100] &                0 &      0.422873 &          1 \\\\\n",
       "36 &  [0010, 0110, 1000, 0011, 0001, 0100, 0111, 0101] &                0 &      0.074988 &          0 \\\\\n",
       "37 &  [1000, 0100, 0000, 1101, 0110, 0001, 0101, 0010] &                0 &      2.297490 &          7 \\\\\n",
       "38 &  [0010, 0111, 0011, 0110, 1000, 0101, 0001, 0100] &                0 &      0.079139 &          0 \\\\\n",
       "39 &  [1000, 1010, 0011, 0110, 1011, 0111, 0001, 1101] &                0 &      2.283877 &          7 \\\\\n",
       "40 &  [0110, 1000, 1011, 0100, 0111, 0101, 1010, 0001] &                0 &      1.325036 &          4 \\\\\n",
       "41 &  [1110, 0110, 1000, 0000, 0010, 0100, 0111, 1001] &                0 &      2.519844 &          7 \\\\\n",
       "42 &  [0001, 0101, 0111, 1010, 0100, 0010, 1000, 0011] &                0 &      0.743251 &          2 \\\\\n",
       "43 &  [1100, 0101, 0111, 1010, 0110, 0010, 1001, 0001] &                0 &      2.021382 &          6 \\\\\n",
       "44 &  [0101, 0001, 0100, 0110, 1000, 0010, 0111, 0011] &                0 &      0.080754 &          0 \\\\\n",
       "45 &  [1110, 0111, 0001, 0100, 1000, 0101, 1011, 0010] &                0 &      2.567141 &          8 \\\\\n",
       "46 &  [0110, 0011, 1100, 0010, 1000, 0101, 0111, 0100] &                0 &      1.367358 &          4 \\\\\n",
       "47 &  [0000, 1011, 0100, 0110, 0001, 0011, 1010, 1000] &                0 &      2.559863 &          8 \\\\\n",
       "48 &  [0011, 0101, 0111, 0001, 0100, 0010, 1000, 0110] &                0 &      0.076224 &          0 \\\\\n",
       "49 &  [0000, 1000, 1110, 0101, 0010, 1001, 0001, 0100] &                0 &      2.633026 &          8 \\\\\n",
       "\\bottomrule\n",
       "\\end{tabular}\n"
      ],
      "text/plain": [
       "                                             Solução  Função-objetivo  \\\n",
       "0   [0101, 0001, 1011, 0110, 1010, 0111, 0010, 0100]                0   \n",
       "1   [0110, 0011, 0001, 1000, 0101, 0010, 0100, 0111]                0   \n",
       "2   [0011, 0001, 1111, 1000, 0110, 0100, 0010, 0101]                0   \n",
       "3   [1100, 0101, 1011, 0001, 0110, 1010, 0011, 0111]                0   \n",
       "4   [0110, 0001, 1010, 0101, 0111, 1100, 0011, 1000]                0   \n",
       "5   [0000, 1100, 1000, 0110, 0011, 0001, 1110, 0101]                0   \n",
       "6   [0101, 1100, 0001, 0100, 0111, 0011, 0110, 0010]                0   \n",
       "7   [1000, 0011, 0111, 0000, 1011, 0110, 0000, 0000]                0   \n",
       "8   [0101, 0111, 0001, 0100, 0010, 1000, 0110, 0011]                0   \n",
       "9   [0101, 0111, 0001, 0011, 1000, 0110, 0100, 0010]                0   \n",
       "10  [0001, 0111, 0000, 1000, 1101, 0010, 0110, 0011]                0   \n",
       "11  [1111, 1000, 1100, 0011, 0001, 1110, 0010, 0000]                0   \n",
       "12  [0101, 0011, 1000, 0100, 0111, 0001, 0110, 0010]                0   \n",
       "13  [0011, 0110, 1000, 0001, 0100, 0111, 0101, 0010]                0   \n",
       "14  [0101, 0010, 1000, 0011, 0111, 0100, 0001, 1110]                0   \n",
       "15  [1101, 1111, 0011, 0000, 0110, 1100, 0001, 0101]                0   \n",
       "16  [0011, 0111, 0010, 0100, 0110, 1100, 0101, 1011]                0   \n",
       "17  [0101, 1000, 0100, 0001, 0111, 0010, 0110, 1011]                0   \n",
       "18  [0100, 0110, 1001, 0010, 1101, 0111, 0011, 0001]                0   \n",
       "19  [1110, 1000, 0100, 1001, 0011, 0110, 0010, 1100]                0   \n",
       "20  [0011, 0000, 0110, 1111, 1011, 0010, 1000, 0101]                0   \n",
       "21  [1000, 0011, 0111, 0100, 1010, 0001, 1101, 0110]                0   \n",
       "22  [0000, 1010, 0001, 1111, 0110, 0000, 0011, 0101]                0   \n",
       "23  [1000, 0000, 0111, 0011, 0110, 0010, 1111, 1010]                0   \n",
       "24  [1100, 0010, 0111, 1011, 0000, 0101, 0001, 0110]                0   \n",
       "25  [0011, 0101, 1101, 0100, 0000, 0111, 1011, 1111]                0   \n",
       "26  [0110, 0000, 0010, 0111, 1011, 0000, 1110, 0101]                0   \n",
       "27  [0011, 0001, 0100, 0111, 1100, 0010, 0101, 1000]                0   \n",
       "28  [0101, 0011, 1000, 0100, 0111, 0001, 1010, 0110]                0   \n",
       "29  [0011, 1110, 0111, 0010, 0100, 0001, 1000, 0101]                0   \n",
       "30  [0011, 0001, 1100, 1000, 0101, 0111, 0010, 0110]                0   \n",
       "31  [0000, 1110, 0101, 0000, 1000, 0100, 0111, 0011]                0   \n",
       "32  [0010, 0111, 0001, 0011, 0101, 1000, 1110, 0100]                0   \n",
       "33  [1000, 1111, 0001, 0111, 0101, 0010, 0000, 1101]                0   \n",
       "34  [0111, 0100, 0001, 0011, 0110, 1001, 1111, 1000]                0   \n",
       "35  [0010, 0111, 0011, 0110, 1000, 0001, 1101, 0100]                0   \n",
       "36  [0010, 0110, 1000, 0011, 0001, 0100, 0111, 0101]                0   \n",
       "37  [1000, 0100, 0000, 1101, 0110, 0001, 0101, 0010]                0   \n",
       "38  [0010, 0111, 0011, 0110, 1000, 0101, 0001, 0100]                0   \n",
       "39  [1000, 1010, 0011, 0110, 1011, 0111, 0001, 1101]                0   \n",
       "40  [0110, 1000, 1011, 0100, 0111, 0101, 1010, 0001]                0   \n",
       "41  [1110, 0110, 1000, 0000, 0010, 0100, 0111, 1001]                0   \n",
       "42  [0001, 0101, 0111, 1010, 0100, 0010, 1000, 0011]                0   \n",
       "43  [1100, 0101, 0111, 1010, 0110, 0010, 1001, 0001]                0   \n",
       "44  [0101, 0001, 0100, 0110, 1000, 0010, 0111, 0011]                0   \n",
       "45  [1110, 0111, 0001, 0100, 1000, 0101, 1011, 0010]                0   \n",
       "46  [0110, 0011, 1100, 0010, 1000, 0101, 0111, 0100]                0   \n",
       "47  [0000, 1011, 0100, 0110, 0001, 0011, 1010, 1000]                0   \n",
       "48  [0011, 0101, 0111, 0001, 0100, 0010, 1000, 0110]                0   \n",
       "49  [0000, 1000, 1110, 0101, 0010, 1001, 0001, 0100]                0   \n",
       "\n",
       "    Tempo (seg.)  Iterações  \n",
       "0       2.312335          5  \n",
       "1       0.082703          0  \n",
       "2       1.950228          6  \n",
       "3       0.704789          2  \n",
       "4       2.307488          7  \n",
       "5       3.144580         10  \n",
       "6       2.947126          9  \n",
       "7       1.346030          4  \n",
       "8       0.075392          0  \n",
       "9       0.079228          0  \n",
       "10      1.657378          5  \n",
       "11      1.651467          5  \n",
       "12      0.078855          0  \n",
       "13      0.077606          0  \n",
       "14      3.373618         10  \n",
       "15      2.679081          8  \n",
       "16      3.451528         11  \n",
       "17      0.706135          2  \n",
       "18      1.346664          4  \n",
       "19      2.302312          7  \n",
       "20      1.341734          4  \n",
       "21      1.056320          3  \n",
       "22      2.295660          7  \n",
       "23      6.221395         15  \n",
       "24      7.968901         20  \n",
       "25      3.267257         10  \n",
       "26      3.543428         11  \n",
       "27      1.682577          5  \n",
       "28      1.107051          3  \n",
       "29      1.372144          4  \n",
       "30      0.703053          2  \n",
       "31      2.589566          8  \n",
       "32      1.066177          3  \n",
       "33      4.236123         13  \n",
       "34      4.476525         14  \n",
       "35      0.422873          1  \n",
       "36      0.074988          0  \n",
       "37      2.297490          7  \n",
       "38      0.079139          0  \n",
       "39      2.283877          7  \n",
       "40      1.325036          4  \n",
       "41      2.519844          7  \n",
       "42      0.743251          2  \n",
       "43      2.021382          6  \n",
       "44      0.080754          0  \n",
       "45      2.567141          8  \n",
       "46      1.367358          4  \n",
       "47      2.559863          8  \n",
       "48      0.076224          0  \n",
       "49      2.633026          8  "
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabelaGA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por fim, vejamos algumas estatísticas obtidas a partir da tabela de resultados do GA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Média e desvio padrão da função-objetivo: 0.0 ± 0.0 ataques\n",
      "Média e desvio padrão do tempo gasto: 1.925 ± 1.597 segundos\n",
      "Média e desvio padrão das iterações gastas: 5.58 ± 4.477\n"
     ]
    }
   ],
   "source": [
    "print(f\"Média e desvio padrão da função-objetivo: {tabelaGA['Função-objetivo'].mean()} ± {tabelaGA['Função-objetivo'].std()} ataques\\n\"\n",
    "      f\"Média e desvio padrão do tempo gasto: {np.round(tabelaGA['Tempo (seg.)'].mean(), 3)} ± {np.round(tabelaGA['Tempo (seg.)'].std(), 3)} segundos\\n\"\n",
    "      f\"Média e desvio padrão das iterações gastas: {np.round(tabelaGA['Iterações'].mean(), 3)} ± {np.round(tabelaGA['Iterações'].std(), 3)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diferentemente do visto no SA, o número de iterações é muito menor. Contudo, em função da aplicação de operadores inexistentes no SA, tem-se que o tempo de execução médio é aproximadamente de cinco a seis vezes maior, com um desvio correspondente a aproximados 50% deste valor. Esses fatos servem de subsídio para afirmar que este algoritmo, a despeito de definitivamente possuir fatores estocásticos, é mais estável do que o SA em termos de tempo de execução e número de iterações."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Considerações finais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com base no exposto acima, tem-se que o problema das oito rainhas foi resolvido de forma ótima por dois algoritmos: _simulated annealing_ e _genetic algorithm_. Os dois algoritmos se valem da classe `Tabuleiro`, que concentra a modelagem do problema, para desempenhar suas rotinas. Ambos os algoritmos, com a ajuda das heurísticas implementadas pelos projetistas, foram capazes de encontrar uma solução ótima em todas as suas execuções. Cumpre mencionar que todas as implementações ora expostas foram desenvolvidas almejando total concordância com o estipulado no documento que descreve a atividade.\n",
    "\n",
    "Durante a exposição dos resultados, foram realizadas análises para verificar a existência de correlação linear entre o número de iterações utilizado e o tempo gasto na execução de ambos os algoritmos. Constatou-se que tanto o recozimento simulado quanto o algoritmo genético implementados possuem forte correlação linear nesse sentido, com especial destaque para o SA.\n",
    "\n",
    "Em adição, como produtos oriundos da resolução dessas atividades, tem-se algoritmos flexíveis e uma modelagem do problema escalável: a classe `Tabuleiro` foi projetada de forma a suportar diferentes notações e números variados de rainhas e casas no tabuleiro, tal que variações do problema podem ser testadas com alterações mínimas nos algoritmos. Dessa forma, esta base de código pode ser facilmente reciclada para propósitos correlatos."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:dss] *",
   "language": "python",
   "name": "conda-env-dss-py"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}