Algoritmo da viagem evolutiva no tempo — Time Evolution Travel Algorithm (TETA)

Conteúdo

1. Introdução
2. Implementação do algoritmo
3. Resultados dos testes

Introdução

Já exploramos muitos algoritmos baseados em leis físicas, como CSS, EM, GSA, AEFA, AOSm, no entanto, o universo continua nos surpreendendo com novos fenômenos e nos alimenta com hipóteses e ideias diversas. Um dos componentes fundamentais do universo, o tempo, me levou à ideia de criar um novo algoritmo de otimização. O tempo não apenas inspira novas descobertas, como também permanece uma entidade misteriosa, difícil de compreender. Ele flui como um rio, carregando consigo momentos da nossa vida e deixando apenas lembranças. Viagens no tempo sempre foram alvo da admiração e das fantasias humanas. Para entender melhor a ideia do algoritmo, vamos imaginar a história de um cientista.

Era uma vez um físico obcecado com a ideia de se mover em direção a um futuro brilhante, afastando-se dos erros cometidos. Ao se aprofundar no estudo dos fluxos temporais, ele chegou a uma descoberta amarga: viajar para o futuro era impossível. Sem perder a esperança, voltou-se ao estudo das viagens ao passado, na expectativa de corrigir seus erros, mas também encontrou frustração.

No entanto, sua pesquisa sobre fluxos temporais hipotéticos o levou a uma descoberta impressionante: a existência de universos paralelos. Desenvolvendo um modelo teórico de máquina de deslocamento entre mundos, ele descobriu algo surpreendente: mesmo que a viagem direta no tempo fosse inviável, era possível escolher uma sequência de eventos que levasse a um ou outro universo paralelo.

Cada ação de qualquer pessoa gerava uma nova realidade paralela, mas o cientista se interessava apenas pelas realidades que envolviam diretamente a sua vida. Para navegar entre elas e distinguir os mundos entre si, ele inseriu na equação do sistema âncoras especiais, que eram pontos-chave de seu destino: família, carreira, descobertas científicas, amizades, eventos marcantes. Essas âncoras tornaram-se variáveis na sua máquina de deslocamento, permitindo escolher o caminho ideal entre os mundos probabilísticos.

Ao ativar sua invenção, ele iniciou uma jornada por mundos paralelos, mas já não buscava mais chegar a um futuro brilhante pronto e acabado. Ele compreendeu algo mais profundo, que é a possibilidade de criar esse futuro com as próprias mãos, tomando decisões no presente. Cada nova escolha traçava um caminho para aquela versão da realidade que ele mesmo queria tornar real. Assim, ele deixou de ser prisioneiro do sonho de um futuro ideal e passou a ser seu arquiteto. Sua máquina deixou de ser um meio de fuga da realidade e tornou-se uma ferramenta de criação consciente do próprio destino, por meio da escolha de decisões ótimas em cada momento do tempo.

Neste artigo, vamos analisar o Algoritmo da Viagem Evolutiva no Tempo (TETA), que implementa o conceito de deslocamento temporal e se diferencia por não conter nenhum parâmetro ou variável modificável. Esse algoritmo preserva de forma natural o equilíbrio entre a busca pela melhor solução e o seu refinamento. Normalmente, algoritmos que não possuem parâmetros externos ainda contam com parâmetros internos sob a forma de constantes que afetam sua eficácia. No entanto, o TETA não possui nem mesmo essas constantes, o que o torna único em sua categoria.

Implementação do algoritmo

Na história apresentada, o cientista descobriu uma forma de se deslocar entre universos paralelos alterando variáveis-chave de sua vida. Essa metáfora serve como base para o algoritmo de otimização proposto e, para facilitar a compreensão, vamos observar a imagem abaixo, que ilustra a ideia do algoritmo sobre os universos paralelos surgindo a cada tomada de decisão. Cada universo, contendo um espaço completo, é definido pela presença de características sob a forma de âncoras: família, carreira, conquistas etc.

Combinando as propriedades dessas âncoras, pode-se criar um novo universo, que representa a solução de um problema de otimização, no qual as âncoras são os parâmetros a serem otimizados.

Imagem 1. Universos paralelos com suas âncoras únicas (características)

O algoritmo TETA é baseado na ideia de múltiplos universos paralelos, onde cada universo representa uma solução potencial para o problema de otimização. Em sua implementação técnica, cada universo é descrito por um vetor de coordenadas (a[i].c), sendo cada coordenada uma âncora, isto é, uma variável chave que define a configuração daquela realidade. Essas âncoras podem ser vistas como os parâmetros mais importantes, cuja configuração afeta diretamente a qualidade geral da solução.

Para avaliar a qualidade de cada universo, é usada uma função de fitness (a[i].f), que determina o "nível de conforto de existência" naquela realidade. Quanto maior o valor dessa função, mais favorável é considerado o universo. Cada universo armazena não apenas seu estado atual, mas também a melhor configuração conhecida até o momento (a[i].cB), o que equivale a uma "memória" da trajetória mais bem-sucedida até então. Além disso, o algoritmo mantém um melhor estado global (cB), representando a configuração mais favorável dentre todas as alternativas já encontradas.

A população de N indivíduos forma um conjunto de universos paralelos, sendo que cada um desses universos é descrito por seu próprio conjunto de valores das âncoras. Esses universos são constantemente classificados de acordo com o valor da função de fitness, o que gera uma espécie de hierarquia que vai dos estados menos favoráveis até os mais favoráveis. Cada âncora da realidade é uma variável a ser otimizada, e qualquer alteração dessas variáveis gera uma nova configuração do universo. O conjunto completo de âncoras forma um vetor de variáveis x = (x₁, x₂, ..., xₙ), que descreve completamente uma determinada realidade. Para cada variável são definidos limites de valores permitidos, que podem ser interpretados como leis físicas restringindo as possíveis alterações em cada universo.

A avaliação da favorabilidade de cada universo é realizada por meio da função de fitness f(x), que transforma a configuração do universo em um número real. Quanto mais alto for esse valor, mais desejável é considerada aquela realidade. Assim, estabelece-se um mecanismo matemático rigoroso para avaliar e comparar diferentes cenários de evolução dentro do conjunto de universos paralelos.

A característica central do algoritmo é um único coeficiente probabilístico (rnd *= rnd), que determina tanto a probabilidade de um universo ser escolhido para interação quanto a intensidade da alteração nas âncoras. Isso cria um mecanismo natural de autorregulação do sistema: os universos melhores têm maior chance de serem escolhidos, mas suas âncoras sofrem alterações menores (proporcionais a rnd), enquanto os universos piores, embora menos selecionados, passam por mudanças mais intensas (proporcionais a 1.0 - rnd).

Essa abordagem reflete uma ideia filosófica profunda: na vida, não é possível atingir a perfeição em tudo ao mesmo tempo. A melhoria ocorre por meio de um equilíbrio contínuo entre diferentes aspectos, quer dizer, às vezes, âncoras melhores podem ser levemente sacrificadas em nome do equilíbrio geral, enquanto âncoras piores tendem naturalmente à melhoria. A intensidade das mudanças é proporcional ao quão "boa" é a realidade, o que reflete a vida real, onde transformações radicais acontecem com mais frequência quando algo não vai bem.

Como resultado, o algoritmo não apenas otimiza valores, mas sim modela o processo de busca por equilíbrio em um sistema multidimensional complexo de circunstâncias da vida, buscando não uma realidade ideal, mas sim a versão mais harmônica da realidade por meio de um ajuste sutil de todos os seus aspectos.

Imagem 2. Linha vermelha — função de probabilidade de escolha dos universos em função de sua qualidade; linha verde — grau de alteração das âncoras para os respectivos universos

Pseudocódigo do algoritmo:

Inicialização:
1. Criar uma população com N universos paralelos
2. Para cada universo:
   - Inicializar aleatoriamente os valores das âncoras (coordenadas) dentro dos limites permitidos
   - Definir os melhores valores iniciais iguais aos valores atuais

Ciclo principal:
1. Ordenar os universos de acordo com a qualidade (função de fitness)
   - Os melhores universos recebem índices menores
   - Os piores universos recebem índices maiores

2. Para cada universo i do total N:
   Para cada âncora (coordenada):
   
   a) Escolha do universo para interação:
      - Gerar um número aleatório rnd entre 0 e 1
      - Elevar rnd ao quadrado para priorizar os melhores universos
      - Selecionar o índice pair proporcionalmente a rnd
   
   b) Se o universo atual for diferente do selecionado (i ≠ pair):
      
      Se o universo atual for melhor que o selecionado (i < pair):
         - Alteração fraca da âncora proporcional a rnd
         - novo_valor = atual + rnd * (valor_selecionado - atual)
      
      Caso contrário (universo atual pior que o selecionado):
         Se (número_aleatório > rnd):
            - Alteração forte da âncora proporcional a (1 - rnd)
            - novo_valor = atual + (1 - rnd) * (valor_selecionado - atual)
         Caso contrário:
            - Cópia total do valor da âncora do universo melhor
            - novo_valor = valor_selecionado
   
   c) Caso contrário (interação consigo mesmo):
      - Busca local via distribuição gaussiana
      - novo_valor = GaussDistribution(melhor_atual)
   
   d) Correção do novo valor da âncora dentro dos limites permitidos

3. Atualização dos melhores valores:
   Para cada universo:
   - Se a solução atual for melhor que a melhor pessoal, atualizar o melhor pessoal
   - Se a solução atual for melhor que a melhor global, atualizar o melhor global

4. Repetir o ciclo principal até que o critério de parada seja atendido

Agora temos tudo pronto para implementar a máquina de deslocamento entre universos paralelos em código. Vamos escrever a classe "C_AO_TETA", que será derivada da classe "C_AO". Aqui está sua descrição resumida:

• Construtor — inicializa o nome, a descrição e a referência ao algoritmo, além de definir o tamanho da população.
• Método SetParams — define os parâmetros utilizando os valores do array "params".
• Métodos Init, Moving,Revision — declarados, mas serão implementados em outro trecho de código.

class C_AO_TETA : public C_AO
{
  public: //--------------------------------------------------------------------
  ~C_AO_TETA () { }
  C_AO_TETA ()
  {
    ao_name = "TETA";
    ao_desc = "Time Evolution Travel Algorithm";
    ao_link = "https://www.mql5.com/ru/articles/16963";

    popSize = 50; // количество параллельных вселенных в популяции

    ArrayResize (params, 1);
    params [0].name = "popSize"; params [0].val = popSize;
  }

  void SetParams ()
  {
    popSize = (int)params [0].val;
  }

  bool Init (const double &rangeMinP  [],  // минимальные значения для якорей
             const double &rangeMaxP  [],  // максимальные значения для якорей
             const double &rangeStepP [],  // шаг изменения якорей
             const int     epochsP = 0);   // количество эпох поиска

  void Moving ();
  void Revision ();

  private: //-------------------------------------------------------------------
};
//——————————————————————————————————————————————————————————————————————————————

Inicialização do método "Init" da classe "C_AO_TETA" realiza a configuração inicial do algoritmo. 

Parâmetros do método:

• rangeMinP — array com os valores mínimos das âncoras.
• rangeMaxP — array com os valores máximos das âncoras.
• rangeStepP — array com os passos de variação das âncoras.
• epochsP — número de épocas da busca (padrão 0).

Inicialização padrão:

• O método chama "StandardInit", realizando a verificação e o ajuste dos intervalos para as âncoras. Se essa inicialização falhar (retorna false), o processo não segue adiante.

Retorno de valor:

• Se todas as verificações e ajustes forem concluídos com sucesso, o método retorna "true", indicando a inicialização bem-sucedida do algoritmo.

//——————————————————————————————————————————————————————————————————————————————
// TETA - Time Evolution Travel Algorithm
// Алгоритм оптимизации, основанный на концепции перемещения между параллельными вселенными
// через изменение ключевых якорей (событий) жизни

//——————————————————————————————————————————————————————————————————————————————
bool C_AO_TETA::Init (const double &rangeMinP  [], // минимальные значения для якорей
                      const double &rangeMaxP  [], // максимальные значения для якорей
                      const double &rangeStepP [], // шаг изменения якорей
                      const int     epochsP = 0)   // количество эпох поиска
{
  if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false;

  //----------------------------------------------------------------------------
  return true;
}
//——————————————————————————————————————————————————————————————————————————————

O método "Moving" da classe "C_AO_TETA" é responsável pela alteração das âncoras nos universos paralelos para criar novas versões dentro do algoritmo.

Verificação do estado da revisão:

• Se "revision" for igual a "false", o método inicializa os valores das âncoras para todos os universos paralelos, utilizando valores aleatórios dentro dos intervalos definidos e aplicando funções que ajustam os valores aos limites permitidos (com base no passo definido).

Atualização dos valores das âncoras:

• Se a revisão já tiver sido feita, o algoritmo percorre todos os universos paralelos. Para cada âncora, é gerada uma probabilidade e calculado seu novo valor:
  • Se o universo atual for mais favorável, a âncora é ligeiramente ajustada positivamente para buscar melhor equilíbrio.
  • Se o universo atual for menos favorável, a verificação da probabilidade pode resultar em uma alteração significativa da âncora ou em sua substituição completa pela de um universo mais bem-sucedido.
  • Se os universos forem equivalentes, realiza-se um ajuste local da âncora por meio de distribuição gaussiana.
• Após o novo valor ser calculado, a âncora é ajustada para se manter dentro do intervalo permitido.

Na prática, esse método é responsável pela adaptação e aprimoramento das soluções (universos paralelos), o que representa uma parte fundamental do algoritmo de otimização. 

//——————————————————————————————————————————————————————————————————————————————
void C_AO_TETA::Moving ()
{
  //----------------------------------------------------------------------------
  if (!revision)
  {
    // Инициализация начальных значений якорей во всех параллельных вселенных
    for (int i = 0; i < popSize; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        a [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]);
        a [i].c [c] = u.SeInDiSp  (a [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      }
    }

    revision = true;
    return;
  }

  //----------------------------------------------------------------------------
  double rnd  = 0.0;
  double val  = 0.0;
  int    pair = 0.0;

  for (int i = 0; i < popSize; i++)
  {
    for (int c = 0; c < coords; c++)
    {
      // Генерация вероятности, которая определяет как шанс выбора вселенной,
      // так и силу изменения якорей
      rnd  = u.RNDprobab ();
      rnd *= rnd;

      // Выбор вселенной для обмена опытом
      pair = (int)u.Scale (rnd, 0.0, 1.0, 0, popSize - 1);

      if (i != pair)
      {
        if (i < pair)
        {
          // Если текущая вселенная более благоприятна:
          // Небольшое изменение якоря (пропорционально rnd) для поиска лучшего баланса
          val = a [i].c [c] + (rnd)*(a [pair].cB [c] - a [i].cB [c]);
        }
        else
        {
          if (u.RNDprobab () > rnd)
          {
            // Если текущая вселенная менее благоприятна:
            // Значительное изменение якоря (пропорционально 1.0 - rnd)
            val = a [i].cB [c] + (1.0 - rnd) * (a [pair].cB [c] - a [i].cB [c]);
          }
          else
          {
            // Полное принятие конфигурации якоря из более успешной вселенной
            val = a [pair].cB [c];
          }
        }
      }
      else
      {
        // Локальная настройка якоря через гауссово распределение
        val = u.GaussDistribution (cB [c], rangeMin [c], rangeMax [c], 1);
      }

      a [i].c [c] = u.SeInDiSp  (val, rangeMin [c], rangeMax [c], rangeStep [c]);
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

O método "Revision" da classe "C_AO_TETA" realiza a atualização das configurações das âncoras nos universos paralelos e a ordenação desses universos de acordo com sua qualidade. A seguir, os detalhes:

Atualização da melhor configuração global:

• O método percorre todos os universos paralelos (de 0 até popSize).
• Se o valor da função f do universo atual (a[i].f) for maior que o valor global atual "fB", então:
  • "fB" é atualizado com o valor de (a[i].f).
  • A configuração das âncoras do universo atual é copiada para a configuração global "cB".

Atualização da melhor configuração conhecida para cada universo:

• Se o valor da função "f" do universo atual for maior que o seu melhor valor conhecido (a[i].fB), então:
  • (a[i].fB) é atualizado com o valor de (a[i].f).
  • A configuração das âncoras do universo atual é copiada para sua melhor configuração conhecida (a[i].cB).

Ordenação dos universos:

• É declarado um array estático "aT" para armazenar os agentes.
• O tamanho do array é ajustado para "popSize".
• Os universos são ordenados com base em suas melhores características conhecidas individuais por meio da função "u.Sorting_fB".

//——————————————————————————————————————————————————————————————————————————————
void C_AO_TETA::Revision ()
{
  for (int i = 0; i < popSize; i++)
  {
    // Обновление глобально лучшей конфигурации якорей
    if (a [i].f > fB)
    {
      fB = a [i].f;
      ArrayCopy (cB, a [i].c);
    }

    // Обновление лучшей известной конфигурации якорей для каждой вселенной
    if (a [i].f > a [i].fB)
    {
      a [i].fB = a [i].f;
      ArrayCopy (a [i].cB, a [i].c);
    }
  }

  // Сортировка вселенных по степени их благоприятности
  static S_AO_Agent aT []; ArrayResize (aT, popSize);
  u.Sorting_fB (a, aT, popSize);
}
//——————————————————————————————————————————————————————————————————————————————

Resultados dos testes

Resultados do funcionamento do algoritmo TETA:

TETA|Time Evolution Travel Algorithm|50.0|
=============================
5 Hilly's; Func runs: 10000; result: 0.9136198796338938
25 Hilly's; Func runs: 10000; result: 0.8234856192574587
500 Hilly's; Func runs: 10000; result: 0.3199003852163246
=============================
5 Forest's; Func runs: 10000; result: 0.970957820488216
25 Forest's; Func runs: 10000; result: 0.8953189778250419
500 Forest's; Func runs: 10000; result: 0.29324457646900925
=============================
5 Megacity's; Func runs: 10000; result: 0.7346153846153844
25 Megacity's; Func runs: 10000; result: 0.6856923076923078
500 Megacity's; Func runs: 10000; result: 0.16020769230769372
=============================
All score: 5.79704 (64.41%)

Resultado final: 5.79704 (64,41%). Considerando a complexidade das funções de teste, esse é um excelente resultado. O algoritmo identifica rapidamente as regiões importantes da superfície com ótimos promissores e imediatamente começa o refinamento dessas regiões, o que pode ser observado em cada visualização do funcionamento do algoritmo.

TETA na função de teste Hilly

 TETA na função de teste Forest

TETA na função de teste Megacity

Vale destacar que, nos testes realizados com a função GoldsteinPrice, que faz parte do conjunto de funções de teste padrão para algoritmos de otimização, o algoritmo alcança o melhor desempenho entre todos os algoritmos avaliados, superando inclusive o líder entre os algoritmos populacionais, o ANS.

TETA na função de teste GoldsteinPrice (disponível para seleção na lista de funções de teste)

Resultados na função GoldsteinPrice:

5 GoldsteinPrice's; Func runs: 10000; result: 0.9999786723616957
25 GoldsteinPrice's; Func runs: 10000; result: 0.9999750431600845
500 GoldsteinPrice's; Func runs: 10000; result: 0.9992343490683104

Ao final da bateria de testes, o algoritmo TETA entra para o top 10 dos melhores algoritmos de otimização, ocupando o respeitável 6º lugar.

№	AO	Description	Hilly			Hilly final	Forest			Forest final	Megacity (discrete)			Megacity final	Final result	% of MAX
			10 p (5 F)	50 p (25 F)	1000 p (500 F)		10 p (5 F)	50 p (25 F)	1000 p (500 F)		10 p (5 F)	50 p (25 F)	1000 p (500 F)
1	ANS	across neighbourhood search	0,94948	0,84776	0,43857	2,23581	1,00000	0,92334	0,39988	2,32323	0,70923	0,63477	0,23091	1,57491	6,134	68,15
2	CLA	code lock algorithm (joo)	0,95345	0,87107	0,37590	2,20042	0,98942	0,91709	0,31642	2,22294	0,79692	0,69385	0,19303	1,68380	6,107	67,86
3	AMOm	animal migration ptimization M	0,90358	0,84317	0,46284	2,20959	0,99001	0,92436	0,46598	2,38034	0,56769	0,59132	0,23773	1,39675	5,987	66,52
4	(P+O)ES	(P+O) evolution strategies	0,92256	0,88101	0,40021	2,20379	0,97750	0,87490	0,31945	2,17185	0,67385	0,62985	0,18634	1,49003	5,866	65,17
5	CTA	comet tail algorithm (joo)	0,95346	0,86319	0,27770	2,09435	0,99794	0,85740	0,33949	2,19484	0,88769	0,56431	0,10512	1,55712	5,846	64,96
6	TETA	time evolution travel algorithm (joo)	0,91362	0,82349	0,31990	2,05701	0,97096	0,89532	0,29324	2,15952	0,73462	0,68569	0,16021	1,58052	5,797	64,41
7	SDSm	stochastic diffusion search M	0,93066	0,85445	0,39476	2,17988	0,99983	0,89244	0,19619	2,08846	0,72333	0,61100	0,10670	1,44103	5,709	63,44
8	AAm	archery algorithm M	0,91744	0,70876	0,42160	2,04780	0,92527	0,75802	0,35328	2,03657	0,67385	0,55200	0,23738	1,46323	5,548	61,64
9	ESG	evolution of social groups (joo)	0,99906	0,79654	0,35056	2,14616	1,00000	0,82863	0,13102	1,95965	0,82333	0,55300	0,04725	1,42358	5,529	61,44
10	SIA	simulated isotropic annealing (joo)	0,95784	0,84264	0,41465	2,21513	0,98239	0,79586	0,20507	1,98332	0,68667	0,49300	0,09053	1,27020	5,469	60,76
11	ACS	artificial cooperative search	0,75547	0,74744	0,30407	1,80698	1,00000	0,88861	0,22413	2,11274	0,69077	0,48185	0,13322	1,30583	5,226	58,06
12	BHAm	black hole algorithm M	0,75236	0,76675	0,34583	1,86493	0,93593	0,80152	0,27177	2,00923	0,65077	0,51646	0,15472	1,32195	5,196	57,73
13	ASO	anarchy society optimization	0,84872	0,74646	0,31465	1,90983	0,96148	0,79150	0,23803	1,99101	0,57077	0,54062	0,16614	1,27752	5,178	57,54
14	AOSm	atomic orbital search M	0,80232	0,70449	0,31021	1,81702	0,85660	0,69451	0,21996	1,77107	0,74615	0,52862	0,14358	1,41835	5,006	55,63
15	TSEA	turtle shell evolution algorithm (joo)	0,96798	0,64480	0,29672	1,90949	0,99449	0,61981	0,22708	1,84139	0,69077	0,42646	0,13598	1,25322	5,004	55,60
16	DE	differential evolution	0,95044	0,61674	0,30308	1,87026	0,95317	0,78896	0,16652	1,90865	0,78667	0,36033	0,02953	1,17653	4,955	55,06
17	CRO	chemical reaction optimisation	0,94629	0,66112	0,29853	1,90593	0,87906	0,58422	0,21146	1,67473	0,75846	0,42646	0,12686	1,31178	4,892	54,36
18	BSA	bird swarm algorithm	0,89306	0,64900	0,26250	1,80455	0,92420	0,71121	0,24939	1,88479	0,69385	0,32615	0,10012	1,12012	4,809	53,44
19	HS	harmony search	0,86509	0,68782	0,32527	1,87818	0,99999	0,68002	0,09590	1,77592	0,62000	0,42267	0,05458	1,09725	4,751	52,79
20	SSG	saplings sowing and growing	0,77839	0,64925	0,39543	1,82308	0,85973	0,62467	0,17429	1,65869	0,64667	0,44133	0,10598	1,19398	4,676	51,95
21	BCOm	bacterial chemotaxis optimization M	0,75953	0,62268	0,31483	1,69704	0,89378	0,61339	0,22542	1,73259	0,65385	0,42092	0,14435	1,21912	4,649	51,65
22	ABO	african buffalo optimization	0,83337	0,62247	0,29964	1,75548	0,92170	0,58618	0,19723	1,70511	0,61000	0,43154	0,13225	1,17378	4,634	51,49
23	(PO)ES	(PO) evolution strategies	0,79025	0,62647	0,42935	1,84606	0,87616	0,60943	0,19591	1,68151	0,59000	0,37933	0,11322	1,08255	4,610	51,22
24	TSm	tabu search M	0,87795	0,61431	0,29104	1,78330	0,92885	0,51844	0,19054	1,63783	0,61077	0,38215	0,12157	1,11449	4,536	50,40
25	BSO	brain storm optimization	0,93736	0,57616	0,29688	1,81041	0,93131	0,55866	0,23537	1,72534	0,55231	0,29077	0,11914	0,96222	4,498	49,98
26	WOAm	wale optimization algorithm M	0,84521	0,56298	0,26263	1,67081	0,93100	0,52278	0,16365	1,61743	0,66308	0,41138	0,11357	1,18803	4,476	49,74
27	AEFA	artificial electric field algorithm	0,87700	0,61753	0,25235	1,74688	0,92729	0,72698	0,18064	1,83490	0,66615	0,11631	0,09508	0,87754	4,459	49,55
28	AEO	artificial ecosystem-based optimization algorithm	0,91380	0,46713	0,26470	1,64563	0,90223	0,43705	0,21400	1,55327	0,66154	0,30800	0,28563	1,25517	4,454	49,49
29	ACOm	ant colony optimization M	0,88190	0,66127	0,30377	1,84693	0,85873	0,58680	0,15051	1,59604	0,59667	0,37333	0,02472	0,99472	4,438	49,31
30	BFO-GA	bacterial foraging optimization - ga	0,89150	0,55111	0,31529	1,75790	0,96982	0,39612	0,06305	1,42899	0,72667	0,27500	0,03525	1,03692	4,224	46,93
31	SOA	simple optimization algorithm	0,91520	0,46976	0,27089	1,65585	0,89675	0,37401	0,16984	1,44060	0,69538	0,28031	0,10852	1,08422	4,181	46,45
32	ABHA	artificial bee hive algorithm	0,84131	0,54227	0,26304	1,64663	0,87858	0,47779	0,17181	1,52818	0,50923	0,33877	0,10397	0,95197	4,127	45,85
33	ACMO	atmospheric cloud model optimization	0,90321	0,48546	0,30403	1,69270	0,80268	0,37857	0,19178	1,37303	0,62308	0,24400	0,10795	0,97503	4,041	44,90
34	ADAMm	adaptive moment estimation M	0,88635	0,44766	0,26613	1,60014	0,84497	0,38493	0,16889	1,39880	0,66154	0,27046	0,10594	1,03794	4,037	44,85
35	ATAm	artificial tribe algorithm M	0,71771	0,55304	0,25235	1,52310	0,82491	0,55904	0,20473	1,58867	0,44000	0,18615	0,09411	0,72026	3,832	42,58
36	ASHA	artificial showering algorithm	0,89686	0,40433	0,25617	1,55737	0,80360	0,35526	0,19160	1,35046	0,47692	0,18123	0,09774	0,75589	3,664	40,71
37	ASBO	adaptive social behavior optimization	0,76331	0,49253	0,32619	1,58202	0,79546	0,40035	0,26097	1,45677	0,26462	0,17169	0,18200	0,61831	3,657	40,63
38	MEC	mind evolutionary computation	0,69533	0,53376	0,32661	1,55569	0,72464	0,33036	0,07198	1,12698	0,52500	0,22000	0,04198	0,78698	3,470	38,55
39	IWO	invasive weed optimization	0,72679	0,52256	0,33123	1,58058	0,70756	0,33955	0,07484	1,12196	0,42333	0,23067	0,04617	0,70017	3,403	37,81
40	Micro-AIS	micro artificial immune system	0,79547	0,51922	0,30861	1,62330	0,72956	0,36879	0,09398	1,19233	0,37667	0,15867	0,02802	0,56335	3,379	37,54
41	COAm	cuckoo optimization algorithm M	0,75820	0,48652	0,31369	1,55841	0,74054	0,28051	0,05599	1,07704	0,50500	0,17467	0,03380	0,71347	3,349	37,21
42	SDOm	spiral dynamics optimization M	0,74601	0,44623	0,29687	1,48912	0,70204	0,34678	0,10944	1,15826	0,42833	0,16767	0,03663	0,63263	3,280	36,44
43	NMm	Nelder-Mead method M	0,73807	0,50598	0,31342	1,55747	0,63674	0,28302	0,08221	1,00197	0,44667	0,18667	0,04028	0,67362	3,233	35,92
44	BBBC	big bang-big crunch algorithm	0,60531	0,45250	0,31255	1,37036	0,52323	0,35426	0,20417	1,08166	0,39769	0,19431	0,11286	0,70486	3,157	35,08
45	CPA	cyclic parthenogenesis algorithm	0,71664	0,40014	0,25502	1,37180	0,62178	0,33651	0,19264	1,15093	0,34308	0,16769	0,09455	0,60532	3,128	34,76
	RW	random walk	0,48754	0,32159	0,25781	1,06694	0,37554	0,21944	0,15877	0,75375	0,27969	0,14917	0,09847	0,52734	2,348	26,09

Considerações finais

Durante o desenvolvimento do algoritmo TETA, meu objetivo constante foi criar algo simples e eficiente. A metáfora dos universos paralelos e das viagens no tempo parecia, a princípio, apenas uma ideia elegante, mas ao longo do processo ela se transformou organicamente em um mecanismo eficaz de otimização.

A característica central do algoritmo foi a ideia de que não é possível atingir a perfeição em tudo ao mesmo tempo, já que é preciso buscar o equilíbrio. Na vida, estamos constantemente equilibrando família, carreira e conquistas pessoais, e foi exatamente essa lógica que introduzi no algoritmo por meio do sistema de âncoras. Cada âncora representa um aspecto essencial a ser otimizado, mas sem prejudicar os demais.

A solução técnica mais interessante foi estabelecer a relação entre a probabilidade de um universo ser escolhido e a intensidade da sua influência sobre os outros. Isso gerou um mecanismo natural, em que as melhores soluções têm mais chance de serem selecionadas, e sua influência é proporcional à sua qualidade. Essa abordagem garante um equilíbrio entre a exploração de novas possibilidades e a exploração de boas soluções já encontradas.

Os testes do algoritmo trouxeram resultados surpreendentemente bons. Isso torna o algoritmo especialmente valioso para aplicações práticas com recursos computacionais limitados. Além disso, o algoritmo apresenta resultados consistentemente excelentes em diferentes tipos de funções, demonstrando sua versatilidade. O que é particularmente gratificante, dado que é a sua implementação compacta. Com cerca de 50 linhas de código essencial, sem parâmetros configuráveis, e ainda assim, com tamanha eficiência. É realmente uma solução bem-sucedida, em que simplicidade de implementação se combina com alto desempenho.

No fim das contas, o TETA superou minhas expectativas iniciais. A partir de uma metáfora sobre viagens no tempo, nasceu uma ferramenta prática e eficiente de otimização, com potencial de aplicação nas mais diversas áreas. Isso mostra que, às vezes, soluções simples, baseadas em analogias naturais compreensíveis, podem ser extremamente eficazes. O algoritmo foi criado literalmente em um só fôlego — da ideia à implementação — e estou muito satisfeito com o trabalho realizado. Trata-se de um algoritmo que pode se tornar um excelente aliado para pesquisadores e profissionais na busca rápida por soluções ótimas. 

Imagem 3. Graduação de cores dos algoritmos conforme os respectivos testes

Imagem 4. Histograma dos resultados de teste dos algoritmos (em uma escala de 0 a 100, quanto maior, melhor, onde 100 é o resultado teórico máximo possível, no arquivo compactado está o script para cálculo da tabela de classificação)

Pontos fortes e fracos do algoritmo TETA:

Pontos fortes:

1. O único parâmetro externo é o tamanho da população.
   
2. Implementação simples.
3. Muito rápido.
4. Resultados equilibrados tanto em problemas de pequena quanto de grande dimensionalidade.
   

Pontos fracos:

1. Alta variação nos resultados em tarefas discretas de baixa dimensionalidade.
   

O artigo vem acompanhado de um arquivo compactado contendo as versões atualizadas dos códigos dos algoritmos. O autor do artigo não se responsabiliza pela precisão absoluta na descrição dos algoritmos canônicos, pois muitos deles foram modificados para melhorar sua capacidade de busca. As conclusões e interpretações apresentadas nos artigos são baseadas nos resultados dos experimentos realizados.

• github: https://github.com/JQSakaJoo/Population-optimization-algorithms-MQL5

Programas utilizados no artigo

#	Nome	Tipo	Descrição
1	C_AO.mqh	Arquivo incluído	Classe base dos algoritmos populacionais de otimização
2	C_AO_enum.mqh	Arquivo incluído	Enumeração dos algoritmos populacionais de otimização
3	TestFunctions.mqh	Arquivo incluído	Biblioteca de funções de teste
4	TestStandFunctions.mqh	Arquivo incluído	Biblioteca de funções do banco de testes
5	Utilities.mqh	Arquivo incluído	Biblioteca de funções auxiliares
6	CalculationTestResults.mqh	Arquivo incluído	Script para cálculo de resultados na tabela comparativa
7	Testing AOs.mq5	Script	Banco de testes unificado para todos os algoritmos populacionais de otimização
8	Simple use of population optimization algorithms.mq5	Script	Exemplo simples de uso dos algoritmos populacionais de otimização sem visualização
9	Test_AO_TETA.mq5	Script	Banco de testes para o TETA