Algoritmo de evolución del caparazón de tortuga (Turtle Shell Evolution Algorithm, TSEA)

Vamos a escribir el pseudocódigo del algoritmo TSEA:

1.  Generamos individuos aleatorios en una población.
2.  Calculamos la FF.
3.  Realizamos la clusterización inicial de la población verticalmente.
4.  Realizamos la clusterización inicial de la población K-Means horizontalmente.
5.  Colocamos la población en un caparazón.
6.  Generamos una nueva población a partir de los datos del caparazón:
     6.1. Con una probabilidad de 0,8:
          Seleccionamos un clúster verticalmente.
          Seleccionamos con una probabilidad 0,5 el mejor agente de la celda, o cualquier agente aleatorio de la celda.
          Con una probabilidad 0,6 para cada coordenada, utilizamos el agente seleccionado en la celda, o utilizamos la mejor solución global.
          Luego utilizamos una distribución escalonada para crear una nueva coordenada para el agente.
     6.2 O bien:
          Seleccionamos un clúster verticalmente.
          Elegimos dos clústeres verticalmente de los que seleccionar al azar un agente de cada uno.
          Creamos una nueva coordenada como la media de las coordenadas de los agentes seleccionados.
7.   Calculamos la FF.
8.   Realizamos la clusterización vertical de la población.
9.   Determinamos si los agentes pertenecen a clústeres de caparazones K-NN (método de los N vecinos más próximos).
10. Realizamos la clusterización vertical del caparazón cada 50 épocas.
11. Colocamos la población en un caparazón.
12. Repetimos desde el paso 6.

Seleccionamos el clúster verticalmente según la ley cuadrática (Fig. 2), que determinará la mayor probabilidad de un clúster de ser elegido en último (mejor) lugar de la lista, en comparación con el 0º (peor).

Figura 2. Ley de probabilidad de selección de clústeres en vertical (según la calidad), donde 3 será el número de clústeres.

Así pues, la lógica de creación de nuevos sectores del caparazón (agentes - soluciones al problema de optimización) será la siguiente:

1. Selección de una capa del caparazón (clúster vertical). La probabilidad de seleccionar la capa superior, más dura, será mayor que la de seleccionar las capas inferiores, menos duras.
2. Selección de sectores del caparazón a partir de clústeres horizontales en la capa seleccionada.
3. "Empalme" de los sectores seleccionados.

La probabilidad de "empalme" (curado) será mayor en las capas superiores que en las inferiores.

Ahora que tenemos el pseudocódigo y la ley de selección de agentes en la población padre, podemos decir que la tarea está completada en un 99%. Obviamente, estoy bromeando, todavía tenemos que escribir el código.

El agente de optimización del algoritmo TSEA lo describiremos como una estructura "S_TSEA_Agent"; necesitaremos etiquetas de clúster verticales y horizontales.

1. La estructura contendrá los siguientes campos:

• c[] - array para almacenar las coordenadas del agente
• f - variable para almacenar la puntuación del agente (aptitud)
• label - etiqueta de pertenencia al clúster
• labelClustV - clusterización vertical
• minDist - distancia mínima al centroide más próximo

2. Init - método de la estructura "S_TSEA_Agent" que inicializará los campos de la estructura. Toma un argumento "coords" entero que se utilizará para redimensionar el array c usando la función ArrayResize.
3. f = -DBL_MAX - establece el valor inicial de la variable f igual al valor mínimo posible de un número de tipo double.
4. label = -1 y labelClustV = -1 - inicializa las etiquetas de pertenencia a clústeres con un valor de -1.
5. minDist = DBL_MAX - establece el valor inicial de la variable "minDist" igual al valor máximo posible del número de tipo duoble.

Este código representa la estructura básica de datos para los agentes en el algoritmo de optimización TSEA e inicializa sus campos cuando se crea un nuevo agente. Esto permite a los agentes almacenar información sobre su estado actual y actualizarla a medida que se ejecuta el algoritmo.

//——————————————————————————————————————————————————————————————————————————————
struct S_TSEA_Agent
{
    double c     [];     //coordinates
    double f;            //fitness
    int    label;        //cluster membership label
    int    labelClustV;  //clusters vertically
    double minDist;      //minimum distance to the nearest centroid

    void Init (int coords)
    {
      ArrayResize (c,     coords);
      f           = -DBL_MAX;
      label       = -1;
      labelClustV = -1;
      minDist     = DBL_MAX;
    }
};
//——————————————————————————————————————————————————————————————————————————————

Deberemos describir un caparazón de tortuga, que no es sino un array bidimensional con clústeres en vertical según adaptabilidad y clústeres en horizontal según la ubicación. Cada celda del array bidimensional contiene desde 0 hasta el valor máximo especificado en los parámetros externos del algoritmo.

El clúster horizontal lo describiremos usando la estructura "S_TSEA_horizontal", que contiene los campos:

• indBest - índice del mejor agente de la celda
  
• agent[] - array de estructuras S_TSEA_Agent, que se utiliza para almacenar los agentes

El clúster vertical puede describirse usando la estructura "S_TSEA_horizontal" que contiene los campos:

• cell[] - array de estructuras "S_TSEA_horizontal".
  

Así, el código nos ofrecerá una forma de describir el caparazón de la tortuga en dos direcciones de un array bidimensional, en cada celda del cual podremos almacenar los agentes de optimización. En esencia, un caparazón es una población padre especialmente estructurada a la que se accederá cómodamente cuando se creen los agentes hijo.

//——————————————————————————————————————————————————————————————————————————————
struct S_TSEA_horizontal
{
    int indBest;
    S_TSEA_Agent agent [];
};

struct S_TSEA_vertical
{
    S_TSEA_horizontal cell [];
};

//——————————————————————————————————————————————————————————————————————————————

Para realizar la clusterización, según el pseudocódigo dado, se utilizarán dos métodos de clusterización en el algoritmo TSEA: K-Means y K-NN. Ya hablamos de K-Means en el artículo sobre el algoritmo BSO, así que aquí nos limitaremos a recordar el aspecto de la estructura de los clústeres:

• centroid[] - array para almacenar las coordenadas del centroide de la celda
• f - variable para almacenar la puntuación del centroide (aptitud)
• count - número de agentes en el clúster
• agentList[] - lista de agentes en el clúster
• Init - método de la estructura "S_Cluster", que inicializa los campos de la estructura
  

//——————————————————————————————————————————————————————————————————————————————
struct S_Cluster
{
    double centroid [];  //cluster centroid
    double f;            //centroid fitness
    int    count;        //number of points in the cluster

    void Init (int coords)
    {
      ArrayResize (centroid, coords);
      f     = -DBL_MAX;
      count = 0;
      ArrayResize (ideasList, 0, 100);
    }
};
//——————————————————————————————————————————————————————————————————————————————

Para determinar si un agente hijo pertenece al clúster correspondiente, utilizaremos el método K-NN (vecinos k-próximos).

La clase "C_TSEA_clusters" contendrá los siguientes métodos, aparte del método K-Means:

1. Método "VectorDistance":

• Este método calcula la distancia euclídea entre dos vectores "v1" y "v2" representados por arrays de números de tipo "double".
• Utiliza la fórmula de la distancia euclídea: .
• Se retornará la distancia calculada.

2. Estructura "DistanceIndex":

• La estructura representará un par de valores: la distancia "distance" y el índice "index".
• Se utiliza para almacenar las distancias de un punto a otros puntos y sus índices.

3. Método "BubbleSort":

• Este método clasifica un array de objetos de tipo "DistanceIndex" según la clasificación de burbuja en orden de distancias ascendente.
• La variable temporal "temp" se utilizará para intercambiar elementos del array.

4. El método "KNN" aplica el algoritmo de vecinos k-próximos para la clasificación de los puntos "point":

• Calcula las distancias desde el punto "point" hasta todos los puntos del array "data", clasifica estas distancias y determina si el punto pertenece a uno de los "n_clusters", clústeres basados en los k vecinos más cercanos.
• Se utilizará un array "votes" para contar los votos de cada grupo.
• Se retornará el índice del clúster con mayor número de votos.

//——————————————————————————————————————————————————————————————————————————————
class C_TSEA_clusters
{
  public:

  double VectorDistance (double &v1 [], double &v2 [])
  {
    double distance = 0.0;
    for (int i = 0; i < ArraySize (v1); i++)
    {
      distance += (v1 [i] - v2 [i]) * (v1 [i] - v2 [i]);
    }
    return MathSqrt (distance);
  }

  struct DistanceIndex
  {
      double distance;
      int index;
  };

  void BubbleSort (DistanceIndex &arr [], int start, int end)
  {
    for (int i = start; i < end; i++)
    {
      for (int j = start; j < end - i; j++)
      {
        if (arr [j].distance > arr [j + 1].distance)
        {
          DistanceIndex temp = arr [j];
          arr [j] = arr [j + 1];
          arr [j + 1] = temp;
        }
      }
    }
  }

  int KNN (S_TSEA_Agent &data [], S_TSEA_Agent &point, int k_neighbors, int n_clusters)
  {
    int n = ArraySize (data);
    DistanceIndex distances_indices [];

    // Calculate the distances from a point to all other points
    for (int i = 0; i < n; i++)
    {
      DistanceIndex dist;
      dist.distance = VectorDistance (point.c, data [i].c);
      dist.index = i;
      ArrayResize (distances_indices, n);
      distances_indices [i] = dist;
    }

    // Sort the distances
    BubbleSort (distances_indices, 0, n - 1);

    // Define the cluster for the point
    int votes [];
    ArrayResize (votes, n_clusters);
    ArrayInitialize (votes, 0);

    for (int j = 0; j < k_neighbors; j++)
    {
      int label = data [distances_indices [j].index].label;

      if (label != -1 && label < n_clusters)
      {
        votes [label]++;
      }
    }

    int max_votes = 0;
    int max_votes_cluster = -1;

    for (int j = 0; j < n_clusters; j++)
    {
      if (votes [j] > max_votes)
      {
        max_votes = votes [j];
        max_votes_cluster = j;
      }
    }

    return max_votes_cluster;
  }
};
//——————————————————————————————————————————————————————————————————————————————

Vamos a pasar ahora directamente a la descripción de la clase "C_AO_TSEA", que deriva de la clase básica "C_AO" e implementará el algoritmo "Turtle Shell Evolution Algorithm" (TSEA). Campos y métodos de la clase:

1. C_AO_TSEA - constructor que inicializa los campos de la clase. Establecerá el nombre del algoritmo, su descripción y un enlace a un artículo sobre el algoritmo. También establecerá varios parámetros del algoritmo como: el tamaño de la población, el número de clústeres verticales y horizontales, el número de vecinos más próximos y el número máximo de agentes en una celda.

2. SetParams - método que establece los parámetros del algoritmo basándose en los valores de el array "params".

3. Init - método que inicializa el algoritmo. Admite rangos de búsqueda mínimo y máximo, paso de búsqueda y número de épocas.

4. Los métodos "Moving", "Revision" son los métodos principales del TSEA que implementan su lógica básica.

5. Los campos "vClusters", "hClusters", "neighbNumb" y "maxAgentsInCell" son parámetros de algoritmo que se establecen en el constructor y pueden modificarse usando el método "SetParams".

6. Las arrays "agent", "cell" y "clusters" son las estructuras de datos utilizadas por el algoritmo. Contienen información sobre agentes, células y clústeres, respectivamente.

7. El objeto "km" de la clase "C_TSEA_clusters" se usa para realizar operaciones de clusterización.

8. Los campos privados "minFval", "stepF", "epochs" y "epochsNow" son variables internas. No hemos previsto que se acceda a ellas desde fuera de la clase.

//——————————————————————————————————————————————————————————————————————————————
class C_AO_TSEA : public C_AO
{
  public: //--------------------------------------------------------------------
  ~C_AO_TSEA () { }
  C_AO_TSEA ()
  {
    ao_name = "TSEA";
    ao_desc = "Turtle Shell Evolution Algorithm";
    ao_link = "https://www.mql5.com/ru/articles/14789";

    popSize         = 100; //population size

    vClusters       = 3;   //number of vertical clusters
    hClusters       = 10;  //number of horizontal clusters
    neighbNumb      = 5;   //number of nearest neighbors
    maxAgentsInCell = 3;   //max agents in cell

    ArrayResize (params, 5);

    params [0].name = "popSize";          params [0].val  = popSize;

    params [1].name = "vClusters";        params [1].val  = vClusters;
    params [2].name = "hClusters";        params [2].val  = hClusters;
    params [3].name = "neighbNumb";       params [3].val  = neighbNumb;
    params [4].name = "maxAgentsInCell";  params [4].val  = maxAgentsInCell;
  }

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

    vClusters       = (int)params [1].val;
    hClusters       = (int)params [2].val;
    neighbNumb      = (int)params [3].val;
    maxAgentsInCell = (int)params [4].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    vClusters;      //number of vertical clusters
  int    hClusters;      //number of horizontal clusters
  int    neighbNumb;     //number of nearest neighbors
  int    maxAgentsInCell;

  S_TSEA_Agent    agent   [];
  S_TSEA_vertical cell    [];

  S_Cluster      clusters [];
  C_TSEA_clusters km;

  private: //-------------------------------------------------------------------
  double minFval;
  double stepF;

  int    epochs;
  int    epochsNow;
};
//——————————————————————————————————————————————————————————————————————————————

El método "Init" de la clase "C_AO_TSEA" inicializará el algoritmo TSEA. Aquí vemos una descripción detallada de su funcionamiento:

1. StandardInit (rangeMinP, rangeMaxP, rangeStepP) - el método se llamará para la inicialización estándar del algoritmo. Admite rangos de búsqueda mínimo y máximo y paso de búsqueda. Si la inicialización falla, el método retornará "false".

2. ArrayResize (agent, popSize) - cambia el tamaño del array "agent" al tamaño de población "popSize". A continuación, se llamará al método "Init(coords)" para cada agente, que inicializará el agente.

3. ArrayResize (clusters, hClusters) - cambia el tamaño del array "clusters" al número de clústeres horizontales "hClusters". Luego se llamará al método "Init(coords)" para cada clúster, que inicializa el clúster.

4. ArrayResize (cell, vClusters) - cambia el tamaño del array "cell" al número de clústeres verticales "vClusters". Después el array "cell[i].cell" y el array de agentes de cada celda se inicializarán para cada celda.

5. "minFval = DBL_MAX", "stepF = 0.0", "epochs = epochsP", "epochsNow = 0". Esta es la inicialización de las variables internas del algoritmo.

6. Al final, el método retornará "true", lo cual indicará que la inicialización se ha realizado correctamente.

//——————————————————————————————————————————————————————————————————————————————
bool C_AO_TSEA::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;

  //----------------------------------------------------------------------------
  ArrayResize (agent, popSize);
  for (int i = 0; i < popSize; i++) agent [i].Init (coords);

  ArrayResize (clusters, hClusters);
  for (int i = 0; i < hClusters; i++) clusters [i].Init (coords);

  ArrayResize (cell, vClusters);

  for (int i = 0; i < vClusters; i++)
  {
    ArrayResize (cell [i].cell, hClusters);

    for (int c = 0; c < hClusters; c++) ArrayResize (cell [i].cell [c].agent, 0, maxAgentsInCell);
  }

  minFval   = DBL_MAX;
  stepF     = 0.0;
  epochs    = epochsP;
  epochsNow = 0;

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

El método "Moving" de la clase "C_AO_TSEA" implementará la lógica básica del movimiento de los agentes en el algoritmo TSEA. Breve descripción de los pasos básicos:

1. Inicialización de la población:

//——————————————————————————————————————————————————————————————————————————————
void C_AO_TSEA::Moving ()
{
  epochsNow++;

  //----------------------------------------------------------------------------
  //1. Generate random individuals for the population
  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]);

        agent [i].c [c] = a [i].c [c];
      }
    }

    return;
  }

  //----------------------------------------------------------------------------
  int    vPos = 0;
  int    hPos = 0;
  int    pos  = 0;
  int    size = 0;
  double val  = 0.0;
  double rnd  = 0.0;
  double min  = 0.0;
  double max  = 0.0;

  for (int v = 0; v < vClusters; v++)
  {
    for (int h = 0; h < hClusters; h++)
    {
      size = ArraySize (cell [v].cell [h].agent);

      if (size > 0)
      {
        max = -DBL_MAX;
        pos = -1;

        for (int c = 0; c < size; c++)
        {
          if (cell [v].cell [h].agent [c].f > max)
          {
            max = cell [v].cell [h].agent [c].f;
            pos = c;
            cell [v].cell [h].indBest = c;
          }
        }
      }
    }
  }

  for (int i = 0; i < popSize; i++)
  {
    if (u.RNDprobab () < 0.8)
    {
      while (true)
      {
        rnd = u.RNDprobab ();
        rnd = (-rnd * rnd + 1.0) * vClusters;

        vPos = (int)rnd;
        if (vPos > vClusters - 1) vPos = vClusters - 1;

        hPos = u.RNDminusOne (hClusters);

        size = ArraySize (cell [vPos].cell [hPos].agent);

        if (size > 0) break;
      }

      pos = u.RNDminusOne (size);

      if (u.RNDprobab () < 0.5) pos = cell [vPos].cell [hPos].indBest;

      for (int c = 0; c < coords; c++)
      {
        if (u.RNDprobab () < 0.6) val = cell [vPos].cell [hPos].agent [pos].c [c];
        else                      val = cB [c];

        double dist = (rangeMax [c] - rangeMin [c]) * 0.1;
        min = val - dist; if (min < rangeMin [c]) min = rangeMin [c];
        max = val + dist; if (max > rangeMax [c]) max = rangeMax [c];

        val = u.PowerDistribution (val, min, max, 30);

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

        agent [i].c [c] = a [i].c [c];
      }
    }
    else
    {
      int size2 = 0;
      int hPos2 = 0;
      int pos2  = 0;

      while (true)
      {
        rnd = u.RNDprobab ();
        rnd = (-rnd * rnd + 1.0) * vClusters;

        vPos = (int)rnd;
        if (vPos > vClusters - 1) vPos = vClusters - 1;

        hPos = u.RNDminusOne (hClusters);
        size = ArraySize (cell [vPos].cell [hPos].agent);

        hPos2 = u.RNDminusOne (hClusters);
        size2 = ArraySize (cell [vPos].cell [hPos2].agent);

        if (size > 0 && size2 > 0) break;
      }

      pos  = u.RNDminusOne (size);
      pos2 = u.RNDminusOne (size2);

      for (int c = 0; c < coords; c++)
      {
        val = (cell [vPos].cell [hPos ].agent [pos ].c [c] +
               cell [vPos].cell [hPos2].agent [pos2].c [c]) * 0.5;

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

        agent [i].c [c] = a [i].c [c];
      }
    }
  }
}
//——————————————————————————————————————————————————————————————————————————————

El método "Revision" de la clase "C_AO_TSEA" implementará el paso de redistribución de las secciones del caparazón de tortuga en el algoritmo TSEA.

El método es responsable del proceso de revisión (actualización) de la población de agentes y de la actualización de la mejor solución global.

Los principales pasos de esta parte del algoritmo serán:

1. Calculamos la adaptabilidad de cada agente "fitness" y determinamos la mejor solución "fB".
2. Etiquetamos los agentes en clústeres verticales "labelClustV" según su aptitud.
3. Si se trata de la primera iteración (revision == false), la clusterización de agentes se inicializará utilizando el algoritmo K-Means.
4. Si no es la primera iteración, se realizará lo siguiente:

- Recogemos todos los agentes en un única array de datos.
- Para cada agente de la población, determinamos su "etiqueta" de clúster horizontal usando el algoritmo de vecinos K-próximos.
- Cada 50 épocas, actualizamos la estructura de "celdas" que almacena los agentes divididos en clústeres.

5. Colocamos cada agente en la celda correspondiente. Si la celda ya está llena, el agente sustituirá al agente de la celda con la adaptabilidad más baja (o más alta, si la celda está en un nivel inferior).

La idea principal de esta etapa consiste en mantener una estructura de caparazón en la que las mejores soluciones se sitúen más cerca de la superficie exterior y las menos acertadas, en el interior. La clusterización de los agentes y la actualización dinámica de la estructura del caparazón aportarán flexibilidad y adaptabilidad al algoritmo.

//——————————————————————————————————————————————————————————————————————————————
void C_AO_TSEA::Revision ()
{
  //get fitness--------------------------------------------------
  int pos = -1;

  for (int i = 0; i < popSize; i++)
  {
    agent [i].f = a [i].f;

    if (a [i].f > fB)
    {
      fB = a [i].f;
      pos = i;
    }

    if (a [i].f < minFval) minFval = a [i].f;
  }

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

  stepF = (fB - minFval) / vClusters;

  //Vertical layout of the child population-----------------------------------
  for (int i = 0; i < popSize; i++)
  {
    if (agent [i].f == fB) agent [i].labelClustV = vClusters - 1;
    else
    {
      agent [i].labelClustV = int((agent [i].f - minFval) / stepF);
      if (agent [i].labelClustV > vClusters - 1) agent [i].labelClustV = vClusters - 1;
    }
  }

  //----------------------------------------------------------------------------
  if (!revision)
  {
    km.KMeansPlusPlusInit (agent, popSize, clusters);
    km.KMeans             (agent, popSize, clusters);

    revision = true;
  }
  //----------------------------------------------------------------------------
  else
  {
    static S_TSEA_Agent data [];
    ArrayResize (data, 0, 1000);
    int size = 0;

    for (int v = 0; v < vClusters; v++)
    {
      for (int h = 0; h < hClusters; h++)
      {
        for (int c = 0; c < ArraySize (cell [v].cell [h].agent); c++)
        {
          size++;
          ArrayResize (data, size);

          data [size - 1] = cell [v].cell [h].agent [c];
        }
      }
    }

    for (int i = 0; i < popSize; i++)
    {
      agent [i].label = km.KNN (data, agent [i], neighbNumb, hClusters);
    }
    
    if (epochsNow % 50 == 0)
    {
      for (int v = 0; v < vClusters; v++)
      {
        for (int h = 0; h < hClusters; h++)
        {
          ArrayResize (cell [v].cell [h].agent, 0);
        }
      }

      for (int i = 0; i < ArraySize (data); i++)
      {
        if (data [i].f == fB) data [i].labelClustV = vClusters - 1;
        else
        {
          data [i].labelClustV = int((data [i].f - minFval) / stepF);
          if (data [i].labelClustV > vClusters - 1) data [i].labelClustV = vClusters - 1;
        }

        int v = data [i].labelClustV;
        int h = data [i].label;

        int size = ArraySize (cell [v].cell [h].agent) + 1;
        ArrayResize (cell [v].cell [h].agent, size);

        cell [v].cell [h].agent [size - 1] = data [i];
      }
    }
  }

  //Place the population in the shell------------------------------------
  for (int i = 0; i < popSize; i++)
  {
    int v = agent [i].labelClustV;
    int h = agent [i].label;

    int size = ArraySize (cell [v].cell [h].agent);
    int pos    = 0;
    int posMin = 0;
    int posMax = 0;

    if (size >= maxAgentsInCell)
    {
      double minF =  DBL_MAX;
      double maxF = -DBL_MAX;

      for (int c = 0; c < maxAgentsInCell; c++)
      {
        if (cell [v].cell [h].agent [c].f < minF)
        {
          minF = cell [v].cell [h].agent [c].f;
          posMin = c;
        }
        if (cell [v].cell [h].agent [c].f > maxF)
        {
          maxF = cell [v].cell [h].agent [c].f;
          posMax = c;
        }
      }

      if (v == 0)
      {
        if (agent [i].f < minF)
        {
          pos = posMin;
        }
        else
        {
          pos = posMax;
        }
      }
      else  pos = posMin;
    }
    else
    {
      ArrayResize (cell [v].cell [h].agent, size + 1);
      pos = size;
    }

    cell [v].cell [h].agent [pos] = agent [i];
  }
}
//——————————————————————————————————————————————————————————————————————————————

3. Resultados de las pruebas

Impresión de los resultados del algoritmo de evolución del caparazón de tortuga TSEA: