Explicação do SPEA

PROCESSO PRINCIPAL:
------------------------------------------------------------------------------------
populacao = gera_populacao;
matriz_distancias = calcular_matriz_distancias(populacao, objetivos);

calcular_fitness(populacao, objetivos, matriz_distancias);
arquivo = selecionar_arquivo(populacao, tam_arquivo);

for (i = 0; i < numero_geracoes; i++) {
  pais = selecionar_pais(arquivo, tam_populacao);
  populacao = gerar_filhos(pais);
  todo_mundo = concatenar(populacao, arquivo);
  matriz_distancias = calcular_matriz_distancias(todo_mundo, objetivos);
  calcular_fitness(todo_mundo, objetivos, matriz_distancias);
  arquivo = selecionar_arquivo(todo_mundo, tam_arquivo, matriz_distancias);
}

return filtrar_array(arquivo, isNaoDominado);


calcular_matriz_distancias(populacao, objetivos):
------------------------------------------------------------------------------------
Você não precisa fazer esse cálculo pra todo elemento toda hora. Basta calcular uma matriz distâncias a cada geração. Na matriz,
a posição (i, j) corresponde à distância euclidiana entre o elemento i e o elemento j da população submetida ao método. Claramente,
vc terá como resultado uma matriz simétrica com diagonal igual a 0.
Os métodos calcular_fitness e selecionar_arquivo usam essa matriz para efetuar seus cálculos.


selecionar_arquivo(populacao, tam_arquivo, matriz_distancias):
------------------------------------------------------------------------------------
conjunto_nao_dominado = filtrar_array(populacao, isNaoDominado);

if (conjunto_nao_dominado.length === tam_arquivo) {
  return conjunto_nao_dominado;
}
if (conjunto_nao_dominado.length < tam_arquivo) {
  return primeiros(ordenar(populacao, 'fitness'), tam_arquivo); // ordene populacao pelo fitness retorne os primeiros tam_arquivo individuos do array resultante
}
return truncar_arquivo(conjunto_nao_dominado, tam_arquivo, matriz_distancias);


truncar_arquivo(arquivo, tam_arquivo, matriz_distancias):
------------------------------------------------------------------------------------
while (arquivo.length > tam_arquivo) {
  individuo_mais_similar = encontrar_mais_similar(arquivo, matriz_distancias);
  remover(individuo_mais_similar, arquivo); // remove individuo_mais_similar de arquivo
}
return arquivo;


encontrar_mais_similar(arquivo, matriz_distancias):
Deve-se encontrar no arquivo o indivíduo que possui menor distância para algum outro. 
Para isso, deve-se comparar todos com todos e pegar o que tem menor distancia.
------------------------------------------------------------------------------------
encontrar_distancias_para_vizinhos(arquivo, matriz_distancias); // para cada individuo no arquivo, cria um array em "individuo.distancias". Esse array contem as distância do individuo em questão para os demais elementos do arquivo. 
                                                                // O Array é ordenado em ordem crescente de distancias.
tam_array_distances = arquivo.length - 1; // a distancia para si mesmo é ignorada, o array de distancia é então o tamanho do arquivo menos 1
distancia_a_analisar = 0; // Cada array de distâncias está ordenado em ordem crescente. A distância na posição 0 é obviamente a menor. Portanto, para comparar cada indivíduo com outro, utilizaremos esse valor. Por exemplo se o 
                          // individuo A tem na posição 0 de seu array de distâncias o valor 5 e o indivíduo B tem o valor 6, está resolvido: o indivíduo A tem um grau de similaridade maior que o indivíduo B. Agora suponha que 
                          // o individuo B também tenha o valor 5 na posição 0 de seu vetor de distancias, como decidir quem é mais similar? Deve-se olhar a próxima distância, ora. Se forem iguais, olha-se a próxima, e assim por 
                          // diante, incrementando o valor de distancia_a_analisar.

while (arquivo.length > 1 && distancia_a_analisar < tam_array_distancias) {
  distMin = arquivo[0].distances[distancia_a_analisar]; // inicializa a distancia
  min = [archive[0]]; // inicializa o veror de minimos com o individuo 0

  for (i = 1; i < arquivo.length; i++) {
    distI = arquivo[i].distances[distancia_a_analisar]; // coloca em distI o "distancia_a_analisar-ésimo" menor valor do vetor de distancias do indivíduo de indice i do arquivo
    if (distI < distMin) { // se essa distancia é menor que distMin, então esse indivíduo tem grau de similaridade maior que qualquer indivíduo no vetor min
      min = [arquivo[i]]; // o vetor min agora contém apenas o individuo recém-descoberto, ele é até agora o mais similar
      distMin = distI; // distMin recebe a nova menor distancia
    } else if (distI === distMin) { // se a menor distancia do i-ésimo indivíduo do arquivo for igual a menor distancia encontrada até agora, então o i-ésimo individuo é igualmente similar a qualquer outro individuo no vetor min
      min.push(arquivo[i]); // adiciona o i-esimo individuo do arquivo ao vetor de individos com menosr distancia (mais similares)
    }
  }
  
  distancia_a_analisar++; // Analisamos todas as "distancia_a_analisar-ésimas" distâncias. Se existem individuos igualmente similares, o tamanho do vetor min é maior que 1, então precisamos olhar para a próxima menor distância e decidir quais individuos no vetor min sao os mais similares
  arquivo = min; // passamos a analisar apenas os individuos em min, os outros, com certeza, sao menos similares e ja podem ser descartados.
}

return min[0]; // min[0], pois é possivel que existam individuos igualmente similares, nesse caso, eliminar qualquer um deles da na mesma.