Algoritmo da Cauda de Cometa (Comet Tail Algorithm, CTA)

Conteúdo:

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

1. Introdução

No campo da astronomia, os cometas sempre despertaram um interesse especial entre cientistas e pesquisadores. Esses objetos cósmicos únicos, compostos principalmente de gelo, poeira e gases, representam uma fonte importante de informações sobre os processos que ocorrem no espaço sideral. Um dos aspectos mais notáveis e impressionantes dos cometas é a sua cauda, que se forma à medida que o cometa se aproxima do Sol.

O Sol desempenha um papel crucial na formação da cauda do cometa. Sua radiação e o vento solar causam a evaporação e a destruição do material na superfície do cometa. Esse processo leva à formação da cauda do cometa — uma área composta de poeira, gases e partículas ionizadas, que se afastam do cometa sob a influência do vento solar e da força gravitacional do Sol.

Neste artigo, vamos explorar o algoritmo de otimização CTA (Comet Tail Algorithm), que foi inspirado por esse fenômeno astronômico único. O algoritmo CTA utiliza o conceito de movimento dos cometas e suas caudas para buscar soluções ótimas em problemas de otimização. Vamos examinar detalhadamente o movimento do cometa e sua cauda, bem como o papel do Sol nesses processos. Também discutiremos como esses conceitos são aplicados no algoritmo CTA para buscar soluções ótimas de forma eficaz.

Cometas são corpos pequenos do Sistema Solar que, ao se aproximarem do Sol, começam a evaporar e a liberar gases. Esse processo é chamado de sublimação. Cometas normalmente têm órbitas muito elípticas, com uma ampla gama de períodos orbitais, desde alguns anos até potencialmente milhões de anos.

O movimento do cometa e sua cauda está intimamente ligado à influência do Sol. O calor do Sol faz com que o gelo do cometa se transforme em gases, fazendo com que a coma (a nuvem gasosa que envolve o núcleo do cometa) aumente. A pressão da radiação solar e as partículas solares de alta velocidade (vento solar) podem afastar a poeira e os gases da coma para longe do Sol, às vezes formando uma cauda longa e brilhante. Além disso, a radiação solar e o vento solar ionizam os gases na cauda do cometa, o que faz com que ela brilhe.

No contexto do algoritmo CTA, podemos imaginar cada solução como partículas da cauda do cometa, movendo-se no espaço de soluções. O núcleo do cometa representa a melhor solução, e as partículas na cauda são soluções derivadas que se afastam do núcleo. Essa representação permite que o algoritmo "explore" o espaço de soluções e se adapte às suas características.

2. Implementação do algoritmo

Vamos agora examinar mais detalhadamente o movimento do cometa e sua cauda, que são elementos-chave neste algoritmo, assim como o papel do Sol nesses processos.

Movimento do cometa:

• O cometa se move em uma órbita elíptica ao redor do Sol.
• Quando o cometa se aproxima do Sol, ele começa a liberar gás e poeira, formando a cauda do cometa.
• O movimento do cometa é determinado pela atração gravitacional do Sol, assim como pela repulsão causada pelo vento solar e pela radiação solar.
• O cometa segue sua órbita, enquanto sua cauda está sempre direcionada para o lado oposto ao Sol.

Movimento da cauda do cometa:

• A cauda gasosa do cometa é composta por gases ionizados que são "expulsos" do núcleo do cometa sob a ação do vento solar.
• O vento solar é um fluxo de partículas carregadas que emanam do Sol. Ele "sopra" a cauda gasosa do cometa, direcionando-a para o lado oposto ao Sol.
• A cauda de poeira do cometa é composta por partículas maiores, que são "expulsas" do núcleo do cometa pela radiação solar.
• A radiação solar exerce pressão sobre as partículas de poeira, desviando-as ligeiramente da direção de movimento do cometa, formando uma cauda de poeira curva.

Papel do Sol:

• O Sol é o objeto central ao redor do qual o cometa se move em sua órbita.
• A atração gravitacional do Sol determina o movimento do cometa em sua órbita elíptica.
• O vento solar e a radiação solar "moldam" a cauda do cometa, direcionando-a para o lado oposto ao Sol.

Figura 1. Forma e tamanho dos cometas no contexto do algoritmo CTA em função da distância até a estrela (melhor solução global).

A Figura 1 ilustra as propriedades dos cometas no algoritmo. Cada cometa tem um número único, correspondente ao seu índice no array. A figura mostra as órbitas condicionais dos cometas em relação à estrela. À medida que a distância da estrela aumenta, a cauda do cometa se alonga e assume uma forma quase esférica. Ao mesmo tempo, a nuvem de partículas da cauda é menos deslocada em relação ao núcleo do cometa. Quanto mais próximo o cometa está da estrela, menor é a área de probabilidade da cauda e mais alongada ela se torna.

O cometa de número 1 chegou muito perto da estrela e evaporou. No entanto, no algoritmo, a destruição do cometa não ocorre de fato. Em vez disso, a formação da nuvem da cauda continua, com o centro correspondendo ao centro da estrela. Isso significa que quanto menor a nuvem da cauda, mais intensamente o ajuste da solução ocorre na região do cometa. Por outro lado, quanto maior o tamanho da cauda, mais intensamente o espaço de busca é explorado. Além disso, os eixos das elipses de todos os cometas estão sempre direcionados para longe da estrela, ou seja, na direção oposta à melhor solução global atual.

A lógica do algoritmo permite ajustar os coeficientes de expansão das nuvens dos cometas tanto na direção da expansão com o afastamento da estrela quanto na direção da redução. Também é possível ajustar o grau de achatamento das elipses dependendo do raio da órbita do cometa. Inclusive, é possível direcionar a cauda do cometa não para longe da estrela, mas em direção à estrela (se desejado).

A Figura 1 também mostra o momento de migração condicional do cometa número 2 para uma nova órbita (número 2 emoldurado). Isso acontece no processo de troca de material entre os núcleos de dois cometas. Na figura, o cometa 2 está emprestando material do cometa 4. Se no processo de troca de material entre os cometas for encontrada uma solução melhor, o cometa correspondente, cujo material estava sendo formado naquele momento, muda para uma nova órbita.

O tamanho da cauda do cometa e seu deslocamento em relação ao núcleo, dependendo da distância até a estrela, pode ser calculado de forma aproximada por uma lei linear. Assim, a distância máxima, igual a 1, corresponde ao intervalo entre os valores mínimo e máximo da coordenada otimizada da tarefa correspondente. Essa abordagem permite descrever a mudança dos parâmetros da cauda do cometa em função da distância até a estrela de uma maneira simples e clara.

Figura 2. Gráficos mostrando a dependência dos coeficientes de deslocamento da trilha do cometa (linha roxa) e o tamanho da trilha (linha verde) em função da distância até a estrela.

Assim, desenvolvemos leis para a mudança da forma e do tamanho da nuvem de partículas dos cometas, o que nos permite resumir as conclusões sobre as possíveis propriedades do algoritmo. As principais propriedades do algoritmo, inspirado na cauda de cometa, considerando a direção da cauda a partir do Sol (ótimo global) e a busca não apenas pelas melhores soluções, mas também em áreas de soluções menos ótimas, podem ser as seguintes:

1. Evaporação e evolução das soluções. O algoritmo pode utilizar o processo de evaporação e evolução de soluções, em que tanto as melhores quanto as áreas de soluções menos ótimas podem ser exploradas.
2. Multiplicidade de variações. O algoritmo pode buscar criar múltiplas variações de soluções, refletindo diferentes níveis de otimalidade, semelhante à diversidade da composição da cauda do cometa.
3. Adaptabilidade a fatores externos. Assim como o cometa reage à influência do Sol, o algoritmo pode ser adaptável a mudanças no ambiente ou na função objetivo.
4. Busca pelo ótimo global. A direção da cauda em relação ao Sol pode simbolizar a busca do algoritmo pelo ótimo global, mas também levando em consideração soluções menos ótimas para evitar uma convergência prematura a ótimos locais.

Agora, vamos escrever um esboço do algoritmo em forma de pseudocódigo:

1. Criar os núcleos dos cometas aleatoriamente.
2. A partir dos núcleos dos cometas, criar suas caudas – partículas com distribuição normal, com o núcleo no centro.
3. Calcular a adaptabilidade das partículas dos cometas.
4. Atualizar a solução global.
5. Designar a melhor partícula de cada cometa como seu núcleo.
6. Para cada coordenada das partículas dos cometas, executar o seguinte:
   Com uma probabilidade de 0,6, executar uma das seguintes ações:
      Criar partículas com distribuição normal, com o núcleo do cometa no centro.
   Ou:
      Criar uma partícula de cometa usando as coordenadas dos núcleos de dois cometas escolhidos aleatoriamente.
7. Atualizar a solução global.
8. Designar a melhor partícula de cada cometa como seu núcleo.
9. Repetir a partir do passo 6 até o critério de parada ser atendido.

Para o algoritmo CTA, não será necessário escrever uma estrutura específica para descrever cometas e suas partículas, pois a estrutura básica de agente, usada para troca de soluções entre o algoritmo e o programa executor, será suficiente. Vamos relembrar como essa estrutura é:

A estrutura "S_AO_Agent" contém dois campos:

• c[] – o array armazena as coordenadas do agente no espaço de soluções.
• f - o valor da adaptabilidade (fitness) do agente, usado para avaliar a qualidade da solução.
  

No contexto do algoritmo CTA, essa estrutura será usada para descrever tanto os cometas quanto as partículas de suas caudas.

//——————————————————————————————————————————————————————————————————————————————
struct S_AO_Agent
{
    double c []; //coordinates
    double f;    //fitness
};
//——————————————————————————————————————————————————————————————————————————————

Vamos definir a classe "C_AO_CTA", que é uma subclasse da classe "C_AO".

• C_AO_CTA () - o construtor inicializa o objeto da classe com valores predefinidos. Ele também configura alguns parâmetros do algoritmo, como o tamanho da população "popSize", o número de cometas "cometsNumb", o coeficiente do comprimento da cauda "tailLengthKo", os coeficientes máximo e mínimo de deslocamento "maxShiftCoef" e "minShiftCoef", bem como os coeficientes máximo e mínimo de tamanho "maxSizeCoef" e "minSizeCoef".
• SetParams() define os parâmetros do algoritmo com base nos valores do array "params".
• Init() - inicializa o algoritmo com os intervalos de busca e o número de épocas definidos.
• Os métodos "Moving()" e "Revision()" implementam a lógica principal do algoritmo.
  

O campo "comets[]" é um array de objetos do tipo "S_AO_Agent", que representa os cometas no algoritmo.

Os campos privados "tailLength[]", "maxSpaceDistance[]" e "partNumber" são usados internamente pelo algoritmo.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_CTA : public C_AO
{
  public: //--------------------------------------------------------------------
  ~C_AO_CTA () { }

  C_AO_CTA ()
  {
    ao_name = "CTA";
    ao_desc = "Comet Tail Algorithm";
    ao_link = "https://www.mql5.com/ru/articles/14841";

    popSize      = 50;   //population size
    cometsNumb   = 5;    //number of comets
    tailLengthKo = 0.2;  //tail length coefficient
    maxShiftCoef = 0.9;
    minShiftCoef = 0.5;
    maxSizeCoef  = 0.1;
    minSizeCoef  = 1.5;

    ArrayResize (params, 7);

    params [0].name = "popSize";       params [0].val = popSize;
    params [1].name = "cometsNumb";    params [1].val = cometsNumb;
    params [2].name = "tailLengthKo";  params [2].val = tailLengthKo;
    params [3].name = "maxShiftCoef";  params [3].val = maxShiftCoef;
    params [4].name = "minShiftCoef";  params [4].val = minShiftCoef;
    params [5].name = "maxSizeCoef";   params [5].val = maxSizeCoef;
    params [6].name = "minSizeCoef";   params [6].val = minSizeCoef;
  }

  void SetParams ()
  {
    popSize      = (int)params [0].val;
    cometsNumb   = (int)params [1].val;
    tailLengthKo = params      [2].val;
    maxShiftCoef = params      [3].val;
    minShiftCoef = params      [4].val;
    maxSizeCoef  = params      [5].val;
    minSizeCoef  = params      [6].val;
  }

  bool Init (const double &rangeMinP  [], //minimum search range
             const double &rangeMaxP  [], //maximum search range
             const double &rangeStepP [], //step search
             const int     epochsP = 0);  //number of epochs

  void Moving   ();
  void Revision ();
  void Injection (const int popPos, const int coordPos, const double value);

  //----------------------------------------------------------------------------
  int    cometsNumb;    //number of comets
  double tailLengthKo;  //tail length coefficient
  double maxShiftCoef;  //maximum shift coefficient
  double minShiftCoef;  //minimum shift coefficient
  double maxSizeCoef;   //maximum size coefficient
  double minSizeCoef;   //minimum size coefficient

  S_AO_Agent comets [];

  private: //-------------------------------------------------------------------
  int    epochs;
  int    epochNow;
  double tailLength       [];
  double maxSpaceDistance []; //maximum distance in space
  int    partNumber; //number of particles
};
//——————————————————————————————————————————————————————————————————————————————

Vamos definir o método "Init" na classe "C_AO_CTA". Este método inicializa o algoritmo com os intervalos de busca e o número de épocas definidos. Descrição de cada etapa:

1. "if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false;" - este código chama o método "StandardInit" com os intervalos de busca definidos. Se "StandardInit" retornar "false", o método "Init" também retorna "false" imediatamente.

2. "ArrayResize (comets, cometsNumb);" - redimensiona o array "comets" segundo o número de cometas.

3. Dentro do laço "for", as coordenadas e o valor da função de adaptabilidade de cada cometa são inicializados.

4. "ArrayResize (tailLength, coords); ArrayResize (maxSpaceDistance, coords);" - redimensiona os arrays "tailLength" e "maxSpaceDistance" segundo o número de coordenadas.

5. Dentro do próximo laço "for", para cada coordenada, são calculados a distância máxima no espaço e o comprimento da cauda.

6. "partNumber = popSize / cometsNumb;" - calcula-se o número de partículas na cauda de cada cometa.

//——————————————————————————————————————————————————————————————————————————————
bool C_AO_CTA::Init (const double &rangeMinP [], //minimum search range
                     const double &rangeMaxP  [], //maximum search range
                     const double &rangeStepP [], //step search
                     const int     epochsP = 0)   //number of epochs
{
  if (!StandardInit (rangeMinP, rangeMaxP, rangeStepP)) return false;

  //----------------------------------------------------------------------------
  epochs   = epochsP;
  epochNow = 0;

  ArrayResize (comets, cometsNumb);
  for (int i = 0; i < cometsNumb; i++)
  {
    ArrayResize (comets [i].c, coords);
    comets [i].f = -DBL_MAX;
  }

  ArrayResize (tailLength,       coords);
  ArrayResize (maxSpaceDistance, coords);

  for (int i = 0; i < coords; i++)
  {
    maxSpaceDistance [i] = rangeMax [i] - rangeMin [i];
    tailLength       [i] = maxSpaceDistance [i] * tailLengthKo;
  }

  partNumber = popSize / cometsNumb;

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

A criação das partículas nas caudas dos cometas ocorre no método "Moving()" da classe "C_AO_CTA". Principais etapas do método:

1. A função começa incrementando o contador de épocas "epochNow" e inicializando as variáveis locais "cnt", "min" e "max".
2. Se "revision" for igual a "false", a inicialização das coordenadas dos cometas ocorre dentro dos intervalos definidos "rangeMin" e "rangeMax". Em seguida, as partículas (agentes) são criadas ao redor de cada cometa, usando uma distribuição gaussiana dentro do intervalo determinado pelo comprimento da cauda "tailLength".
3. Se "revision" for igual a "true", ocorre a atualização da posição das partículas (agentes). Para cada partícula, são calculados os coeficientes "coefTail" e "coefSize", que determinam o deslocamento e o tamanho da cauda do cometa com base na distância até o ponto central "cB". Esses coeficientes são usados para determinar a nova posição da partícula em um intervalo limitado pelo comprimento da cauda.
4. Se a probabilidade "u.RNDprobab()" for menor que 0,6, a nova posição da partícula é calculada usando uma distribuição gaussiana. Caso contrário, a nova posição da partícula é calculada como uma combinação linear das coordenadas dos núcleos de dois outros cometas selecionados aleatoriamente.
5. Em todos os casos, as novas coordenadas da partícula são limitadas pelos intervalos "rangeMin" e "rangeMax" e discretizadas com o passo "rangeStep".

A ideia geral desse método é modelar o movimento e comportamento dos cometas no algoritmo CTA, onde as partículas (agentes) representam a cauda do cometa, e suas coordenadas e tamanho da cauda dependem da distância até a melhor solução global (o Sol).

//——————————————————————————————————————————————————————————————————————————————
void C_AO_CTA::Moving ()
{
  epochNow++;
  int    cnt = 0;
  double min = 0.0;
  double max = 0.0;

  //----------------------------------------------------------------------------
  if (!revision)
  {
    for (int i = 0; i < cometsNumb; i++)
    {
      for (int c = 0; c < coords; c++)
      {
        comets [i].c [c] = u.RNDfromCI (rangeMin [c], rangeMax [c]);
        comets [i].c [c] = u.SeInDiSp  (comets [i].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
      }
    }

    for (int i = 0; i < cometsNumb; i++)
    {
      for (int p = 0; p < partNumber; p++)
      {
        for (int c = 0; c < coords; c++)
        {
          min = comets [i].c [c] - tailLength [c] * 0.5; if (min < rangeMin [c]) min = rangeMin [c];
          max = comets [i].c [c] + tailLength [c] * 0.5; if (max > rangeMax [c]) max = rangeMax [c];

          a [cnt].c [c] = u.GaussDistribution (comets [i].c [c], min, max, 1);
          a [cnt].c [c] = u.SeInDiSp  (a [cnt].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
        }

        cnt++;
      }
    }

    revision = true;
    return;
  }

  //----------------------------------------------------------------------------
  cnt             = 0;
  double coefTail = 0.0;
  double coefSize = 0.0;

  for (int i = 0; i < cometsNumb; i++)
  {
    for (int p = 0; p < partNumber; p++)
    {
      for (int c = 0; c < coords; c++)
      {
        if (u.RNDprobab () < 0.6)
        {
          coefTail = fabs (comets [i].c [c] - cB [c]) / maxSpaceDistance [c];
          coefSize = coefTail;

          //(1-x)*0.9+x*0.5
          coefTail = (1 - coefTail) * maxShiftCoef + coefTail * minShiftCoef;

          //(1-x)*0.1+x*0.9
          coefSize = (1 - coefSize) * maxSizeCoef + coefSize * minSizeCoef;

          if (cB [c] * Dir > comets [i].c [c] * Dir)
          {
            min = comets [i].c [c] - tailLength [c] * coefTail         * coefSize;
            max = comets [i].c [c] + tailLength [c] * (1.0 - coefTail) * coefSize;
          }
          if (cB [c] * Dir < comets [i].c [c] * Dir)
          {
            min = comets [i].c [c] - tailLength [c] * (1.0 - coefTail) * coefSize;
            max = comets [i].c [c] + tailLength [c] * (coefTail)*coefSize;
          }
          if (cB [c] == comets [i].c [c])
          {
            min = comets [i].c [c] - tailLength [c] * 0.1;
            max = comets [i].c [c] + tailLength [c] * 0.1;
          }

          if (min < rangeMin [c]) min = rangeMin [c];
          if (max > rangeMax [c]) max = rangeMax [c];

          a [cnt].c [c] = u.GaussDistribution (comets [i].c [c], min, max, Power);
          a [cnt].c [c] = u.SeInDiSp  (a [cnt].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
        }
        else
        {
          int    r   = 0;
          int    r1  = 0;
          int    r2  = 0;

          do
          {
            r = u.RNDminusOne (cometsNumb);
            r1 = r;
          }
          while (r1 == i);

          do
          {
            r = u.RNDminusOne (cometsNumb);
            r2 = r;
          }
          while (r2 == i || r2 == r1);

          a [cnt].c [c] = comets [r1].c [c] + 0.1 * (comets [r2].c [c] - comets [i].c [c]) * u.RNDprobab();
          a [cnt].c [c] = u.SeInDiSp (a [cnt].c [c], rangeMin [c], rangeMax [c], rangeStep [c]);
        }
      }

      cnt++;
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

Em seguida, vamos implementar o método "Revision()" da classe "C_AO_CTA", responsável por revisar a posição dos cometas no algoritmo Comet Tail Algorithm (CTA).

Principais etapas do método:

1. Busca pela melhor solução na população:

• O método percorre todas as soluções da população "popSize" e encontra a solução com o melhor valor da função objetivo "fB".
• Se for encontrada uma solução melhor, sua posição "a[ind].c" é copiada para o vetor "cB", que armazena a melhor solução conhecida.

2. Atualização da posição dos cometas:

• O método percorre todos os cometas "cometsNumb" e, para cada cometa, busca a melhor solução entre as partículas associadas a esse cometa "partNumber".
• Se for encontrada uma solução melhor para o cometa, a posição desse cometa "comets[i].c" é atualizada com a posição da melhor solução encontrada "a[ind].c".

Esse método implementa um passo importante do algoritmo CTA, no qual a posição dos cometas é revisada com base nas melhores soluções encontradas em suas caudas. Isso permite direcionar a busca para áreas com valores mais elevados da função objetivo.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_CTA::Revision ()
{
  int ind = -1;

  for (int i = 0; i < popSize; i++)
  {
    if (a [i].f > fB)
    {
      fB = a [i].f;
      ind = i;
    }
  }

  if (ind != -1) ArrayCopy (cB, a [ind].c, 0, 0, WHOLE_ARRAY);

  //set a new kernel------------------------------------------------------------
  int cnt = 0;

  for (int i = 0; i < cometsNumb; i++)
  {
    ind = -1;

    for (int p = 0; p < partNumber;  p++)
    {
      if (a [cnt].f > comets [i].f)
      {
        comets [i].f = a [cnt].f;
        ind = cnt;
      }

      cnt++;
    }

    if (ind != -1) ArrayCopy (comets [i].c, a [ind].c, 0, 0, WHOLE_ARRAY);
  }
}
//——————————————————————————————————————————————————————————————————————————————

3. Resultados dos testes

Impressão dos resultados da execução do algoritmo de cauda de cometa CTA:

CTA|Comet Tail Algorithm|80.0|40.0|4.0|-1.0|0.2|1.0|0.5|0.1|15.0|
=============================
5 Hilly's; Func runs: 10000; result: 0.9534613588697962
25 Hilly's; Func runs: 10000; result: 0.863192334000326
500 Hilly's; Func runs: 10000; result: 0.27769783965091077
=============================
5 Forest's; Func runs: 10000; result: 0.997942251272262
25 Forest's; Func runs: 10000; result: 0.857403562283056
500 Forest's; Func runs: 10000; result: 0.33949224947400775
=============================
5 Megacity's; Func runs: 10000; result: 0.8876923076923078
25 Megacity's; Func runs: 10000; result: 0.5643076923076924
500 Megacity's; Func runs: 10000; result: 0.10512307692307787
=============================
All score: 5.84631 (64.96%)

Com base nos testes realizados, podemos tirar as seguintes conclusões sobre o desempenho do algoritmo de otimização CTA (Comet Tail Algorithm):

A avaliação geral do algoritmo é de 5,84631, o que corresponde a 64,96% da pontuação máxima possível. Isso indica uma excelente eficiência do algoritmo CTA.

  CTA na função de teste Hilly.

  CTA na função de teste Forest.

  CTA na função de teste Megacity.

Como resultado dos testes, o algoritmo CTA ocupa uma honrosa 3ª posição na tabela de classificações.

№	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	BGA	binary genetic algorithm	0,99992	0,99484	0,50483	2,49959	1,00000	0,99975	0,32054	2,32029	0,90667	0,96400	0,23035	2,10102	6,921	76,90
2	(P+O)ES	(P+O) evolution strategies	0,99934	0,91895	0,56297	2,48127	1,00000	0,93522	0,39179	2,32701	0,83167	0,64433	0,21155	1,68755	6,496	72,18
3	CTA	comet tail algorithm	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
4	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
5	ESG	evolution of social groups	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
6	SIA	simulated isotropic annealing	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
7	TSEA	turtle shell evolution algorithm	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
8	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
9	BSA	bird swarm algorithm	0,90857	0,73661	0,25767	1,90285	0,90437	0,81619	0,16401	1,88457	0,61692	0,54154	0,10951	1,26797	5,055	56,17
10	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
11	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
12	(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
13	BSO	brain storm optimization	0,91301	0,56222	0,30047	1,77570	0,97162	0,57162	0,23449	1,77772	0,60462	0,27138	0,12011	0,99611	4,550	50,55
14	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
15	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
16	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
17	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
18	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
19	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
20	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
21	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
22	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
23	FAm	firefly algorithm M	0,58634	0,47228	0,32276	1,38138	0,68467	0,37439	0,10908	1,16814	0,28667	0,16467	0,04722	0,49855	3,048	33,87
24	GSA	gravitational search algorithm	0,64757	0,49197	0,30062	1,44016	0,53962	0,36353	0,09945	1,00260	0,32667	0,12200	0,01917	0,46783	2,911	32,34
25	BFO	bacterial foraging optimization	0,61171	0,43270	0,31318	1,35759	0,54410	0,21511	0,05676	0,81597	0,42167	0,13800	0,03195	0,59162	2,765	30,72
26	ABC	artificial bee colony	0,63377	0,42402	0,30892	1,36671	0,55103	0,21874	0,05623	0,82600	0,34000	0,14200	0,03102	0,51302	2,706	30,06
27	BA	bat algorithm	0,59761	0,45911	0,35242	1,40915	0,40321	0,19313	0,07175	0,66810	0,21000	0,10100	0,03517	0,34617	2,423	26,93
28	SA	simulated annealing	0,55787	0,42177	0,31549	1,29513	0,34998	0,15259	0,05023	0,55280	0,31167	0,10033	0,02883	0,44083	2,289	25,43
29	IWDm	intelligent water drops M	0,54501	0,37897	0,30124	1,22522	0,46104	0,14704	0,04369	0,65177	0,25833	0,09700	0,02308	0,37842	2,255	25,06
30	PSO	particle swarm optimisation	0,59726	0,36923	0,29928	1,26577	0,37237	0,16324	0,07010	0,60572	0,25667	0,08000	0,02157	0,35823	2,230	24,77
31	Boids	boids algorithm	0,43340	0,30581	0,25425	0,99346	0,35718	0,20160	0,15708	0,71586	0,27846	0,14277	0,09834	0,51957	2,229	24,77
32	MA	monkey algorithm	0,59107	0,42681	0,31816	1,33604	0,31138	0,14069	0,06612	0,51819	0,22833	0,08567	0,02790	0,34190	2,196	24,40
33	SFL	shuffled frog-leaping	0,53925	0,35816	0,29809	1,19551	0,37141	0,11427	0,04051	0,52618	0,27167	0,08667	0,02402	0,38235	2,104	23,38
34	FSS	fish school search	0,55669	0,39992	0,31172	1,26833	0,31009	0,11889	0,04569	0,47467	0,21167	0,07633	0,02488	0,31288	2,056	22,84
35	RND	random	0,52033	0,36068	0,30133	1,18234	0,31335	0,11787	0,04354	0,47476	0,25333	0,07933	0,02382	0,35648	2,014	22,37
36	GWO	grey wolf optimizer	0,59169	0,36561	0,29595	1,25326	0,24499	0,09047	0,03612	0,37158	0,27667	0,08567	0,02170	0,38403	2,009	22,32
37	CSS	charged system search	0,44252	0,35454	0,35201	1,14907	0,24140	0,11345	0,06814	0,42299	0,18333	0,06300	0,02322	0,26955	1,842	20,46
38	EM	electroMagnetism-like algorithm	0,46250	0,34594	0,32285	1,13129	0,21245	0,09783	0,10057	0,41085	0,15667	0,06033	0,02712	0,24412	1,786	19,85

Considerações finais

O algoritmo CTA analisado é baseado no conceito de movimento de cometas e possui várias características que contradizem as leis físicas e a evolução dos cometas. O impacto dessas características nos resultados do algoritmo deve ser considerado com mais detalhes.

Uma das contradições está na direção da cauda do cometa. No algoritmo CTA, o uso da direção da cauda em direção à estrela (Dir_P = -1) geralmente melhora significativamente sua eficiência. No entanto, o uso da direção da cauda afastada da estrela também aumenta a capacidade do algoritmo de explorar o espaço. Entusiastas dos métodos de otimização podem, se desejarem, considerar o uso de um coeficiente dinâmico para a direção da cauda, dependendo da época atual. Vale notar que a direção da cauda afastada da estrela garante melhor convergência em problemas de baixa dimensionalidade, enquanto a direção em direção à estrela é mais eficaz em problemas de alta dimensionalidade.

Outra contradição é o tamanho da cauda do cometa. No algoritmo CTA, foi descoberto que a mudança dinâmica no tamanho da cauda, aumentando-a com o crescimento da distância até a estrela, melhora a eficiência do algoritmo. Isso contradiz as leis físicas, já que, na realidade, o tamanho da cauda de um cometa aumenta à medida que ele se aproxima do Sol. No entanto, essa mudança dinâmica no tamanho da cauda permite ampliar a área de exploração do espaço de soluções ao redor do núcleo do cometa nas regiões distantes da solução global, aumentando as chances de encontrar soluções promissoras e reduzindo a probabilidade de ficar preso em extremos locais. À medida que se aproxima da estrela, a cauda do cometa se encurta, o que intensifica o refinamento da solução.

O algoritmo CTA também prevê a troca de informações entre cometas, semelhante ao que ocorre na natureza, quando cometas capturam partículas deixadas por outros cometas. Essa é uma capacidade adicional do algoritmo para explorar o espaço de soluções. Houve tentativas de usar métodos para aumentar a diversidade da população, modelando emissões coronais da estrela e usando as propriedades combinatórias do algoritmo, emprestando coordenadas de um cometa a outro.

O algoritmo CTA (Comet Tail Algorithm) representa uma nova abordagem interessante para otimização, que utiliza o conceito de movimento de cometas. O algoritmo demonstra boa convergência em vários tipos de funções (tanto contínuas quanto discretas), é muito simples de implementar (sua estrutura é bastante simples, o que facilita sua implementação em software), não requer muitos recursos computacionais (pois não utiliza ordenação de soluções ou cálculo de distâncias entre todas as soluções, permitindo que seja aplicado em uma ampla gama de problemas), e apresenta baixa variação de resultados em funções discretas (estabilidade e reprodutibilidade dos resultados ao trabalhar com funções objetivo discretas, como na maioria dos problemas de otimização de sistemas de negociação). Entretanto, o algoritmo possui muitos parâmetros externos (como o tamanho da cauda do cometa, coeficientes de deslocamento da cauda e direção, etc.) e em funções contínuas de alta dimensionalidade, pode não obter os melhores resultados.

Em resumo, as características do algoritmo CTA consistem em um equilíbrio dinâmico entre a exploração do espaço de soluções e o refinamento do ótimo global encontrado.

Portanto, o algoritmo CTA utiliza várias simplificações e suposições que não correspondem totalmente às leis físicas do movimento dos cometas. No entanto, essas discrepâncias da realidade permitem aumentar a eficácia do algoritmo na resolução de problemas de otimização, mantendo a simplicidade de sua implementação.

Figura 3. Graduação de cores dos algoritmos de acordo com os respectivos testes. Os resultados maiores ou iguais a 0,99 estão destacados em branco.

Figura 4. Histograma dos resultados dos testes dos algoritmos (na escala de 0 a 100, quanto maior, melhor,

onde 100 é o resultado teórico máximo possível, o script para cálculo da tabela de classificações está no arquivo).

Prós e contras do algoritmo de cauda de cometa (CTA):

Prós:

1. Boa convergência em vários tipos de funções.
2. Fácil implementação.
3. Baixa demanda por recursos computacionais.
4. Baixa variação de resultados em funções discretas.
   

Contras:

1. Muitos parâmetros externos.
   
2. Resultados modestos em funções contínuas de alta dimensionalidade.

Códigos-fonte

Um arquivo contendo as versões atuais dos códigos dos algoritmos está anexado ao artigo. 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 suas capacidades de busca. As conclusões e julgamentos apresentados nos artigos são baseados nos resultados dos experimentos realizados.

• github: https://github.com/JQSakaJoo/Population-optimization-algorithms-MQL5
• CodeBase: https://www.mql5.com/pt/code/49355