The Chimp Optimization Algorithm: From ChOA to BChimp

Population structure and the quartet of leaders. The ChOA population consists of NN chimpanzees, each of which is a solution point in the search space. At each iteration, the four individuals with the highest fitness are designated as leaders and assigned the roles of Attacker, Barrier, Chaser, and Driver. This group of four conveys information about the most likely location of the prey; the remaining members adjust their positions, using all four leaders as reference points.

Basic hunting equations. An individual's approach to the prey is described by two vector equations. First, the distance between the individual and the target being pursued is calculated:

$$d=\mid c\cdot X_{prey}(t)-m\cdot X(t)\mid$$

Then, the new position is calculated from this distance:

$$X(t+1)=X_{prey}(t)-a\cdot d$$

Here, $X(t)$ is the individual’s current position, $X_{prey}(t)$ is the leader’s position, and $a$, $c$ and $m$ are coefficients that govern behavior. The coefficient $a$ determines the magnitude and direction of the step; $c$ determines the weight of the leader’s position in the distance calculation; $m$ is a chaotic multiplier modeling impulsivity.

where $t$ is the current iteration number, $T$ is the total number of iterations, and $r_1, r_2 \in [0,1]$. Parameter $f$ decreases linearly from 2 to 0: at the beginning of the run $|a|$ may exceed one, and the agent takes large steps (exploration); by the end $f \to 0$ and the steps converge toward the leaders (exploitation).

The diversity of the four roles stems from the fact that for each group $r_1$ and $r_2$ are scaled by their respective dynamic curves. For the four groups:

Two groups use the cube-root law $\left(\tfrac{t}{T}\right)^{1/3}$, producing a rapid initial decrease followed by a gently sloping tail; the other two use the cubic law $\left(\tfrac{t}{T}\right)^{3}$, which, conversely, keeps the value high for a long time before it drops sharply at the end. Thus, the groups achieve different balances between exploration and exploitation over time. (Note: In the authors’ reference code, the curves $c_2g_2$​ and $c_2g_4$​ are expressed using the cubic law rather than the cube-root law given in the article — a minor discrepancy that we will return to later.)

Four-leader position update. Each individual computes four candidate positions — one for each leader. For the attacker:

and similarly $X_2, X_3, X_4$ for the barrier, chaser, and driver, each with their own coefficients $a_k$, $c_k$​. The final position is the average of the four candidate positions:

Averaging is the mechanism that pulls the population toward the best solutions: each individual ends up at the center of gravity of four attractive forces.

The chaotic component and social motivation. The second pillar of the algorithm is chaotic behavior, which reflects the chimpanzee’s impulsive drive to capture prey. With a 50% probability, the regular four-leader position update is replaced by a jump determined by a chaotic map:

where $\mu \in [0,1]$ is a random number. A chaotic value is generated by one of the deterministic maps — the logistic map, Gauss map, tent map, etc. The logistic map, for example, is iterated as

and, for an initial value that is not a fixed point, yields an aperiodic sequence in $(0,1)$. The purpose of this phase is to give the population ways to escape local optima that smooth collective movement alone cannot provide.

Binarization: BChimp1 and BChimp2. ChOA itself is continuous. For problems where the solution is a bit string (feature selection), Ayeche and Alti added a binarization layer to the ChOA core in two variants.

BChimp1 converts each of the four candidates into a binary step. First, the continuous step is passed through a sigmoid function:

The result is then compared with a random number to produce a binary step, which is added to the leader's position:

From the four binary vectors $Y_1, \dots, Y_4$Y1​,…,Y4​, the final coordinate is chosen at random — stochastic crossover with an equal probability of $\tfrac{1}{4}$​ for each vector.

BChimp2 takes a different approach: it averages four continuous candidates and passes the average through a sigmoid function with a threshold cutoff:

In both cases, continuous values are not stored anywhere — they instantly collapse to 0 or 1. This is an important point: binarization masks any scale and sign characteristics of the continuous step. It is precisely this feature that hides the flaw we are about to examine.

Example: Coefficient bias in A. Let's construct the coefficient $A$ as specified in the publication. The control parameter $f = 2 - 2\,t/T$ remains shared, while the group-specific curve is incorporated into the random factor: $r_{k1} = c_1g_k \cdot \text{rand}()$​​. Substituting gives:

Let's calculate the expected value. Since $\text{rand} \in [0,1]$ with a mean of $0.5$:

At the start of the run, $f \approx 2$ and $c_1g_1 \approx 1.95$, so

The coefficient $A$ is, on average, positive and large. The update has the form $X_1 = X_a - A_1 D_1$​, where $D_1 \ge 0$. Positive $A$ systematically shifts the coordinate below that of the leader — and does so along all axes simultaneously, since the coefficient structure is the same for all coordinates. The result is a directed drift of the entire population toward the $X_{min}$​ corner of the search space and movement along the main diagonal. Toward the middle of the run, $c_1g$ decreases, $E[A]$ changes sign, and the population is driven back out of the corner: this is not convergence, but oscillation caused by coefficient bias.

In a binary problem, this is not apparent: whatever the value of the continuous product $A \cdot D$, the sigmoid and threshold convert it to 0 or 1. But as soon as you remove the binarization, the algorithm performs worse than a random search.

This can be corrected by symmetrizing the random part. Instead of the shifted factor $(2\,c_1g_k\cdot\text{rand} - 1)$, we use the symmetric factor $c_1g_k\,(2\,\text{rand} - 1)$ with zero mean; retaining the shared factor $f$, we obtain

Now the coefficient is symmetric about zero — on average, the individual does not move toward or away from the leader — and the amplitude $f\,c_1g_k$ decays to zero by the end of the run, ensuring convergence. (In canonical ChOA, the same symmetry is achieved even more simply: the group curve itself serves as the amplitude $f$, and $r_1$ is uniform.) This is precisely the form we use in our implementation; the next section discusses it and the results.

Figure 1. Two Position Update Modes in ChOA

The left panel shows the hunting phase. Individual X(t) (gray) repositions itself using the four leaders surrounding the prey as reference points: the attacker, the barrier, the chaser, and the driver. For each leader, a candidate (X1…X4) is calculated — an attraction along the corresponding direction with its own role coefficients. The new position X(t+1) (green) is the average of the four candidates — the center of gravity of the attractions, pulling the population toward the best solutions.

The right panel shows the chaotic phase. With a probability of 0.5, a regular update is replaced by a jump: the individual’s coordinates are replaced by the value of a chaotic map (the gray dots show how the chaotic sequence covers the search space). It is precisely this phase that has been omitted from our continuous implementation.

Below is the pseudocode for BChimp as implemented and tested for the ranking: a continuous ChOA core with a corrected coefficient a, without the chaotic replacement phase.

Input:  N — population size, T — number of iterations, [lo, hi] — search bounds
Output: best found solution

 1.  Randomly initialize population X = {X_1, …, X_N} into [lo, hi]
 2.  Set static chaotic multiplier m[i] for each agent
         (Piecewise map, one value per agent, calculated only once)
 3.  Calculate the fitness of all agents
 4.  Select four leaders based on fitness:
         X_attacker, X_barrier, X_chaser, X_driver

 5.  for t = 1 … T:

 6.      f = 2 − 2·(t/T)                              // shared factor, 2 → 0
 7.      // group curves, k = 1–4
 8.      C1G_1 = C1G_2 = 1.95 − 2·(t/T)^(1/3)
 9.      C1G_3 = C1G_4 = −2·(t/T)^3 + 2.5
10.      C2G_1 = C2G_3 = 2·(t/T)^(1/3) + 0.5
11.      C2G_2 = C2G_4 = 2·(t/T)^3     + 0.5

12.      for each agent i:
13.          for each coordinate j:
14.              sum ← 0
15.              for each leader k ∈ {attacker, barrier, chaser, driver}:
16.                  a_k = f · C1G_k · (2·rand() − 1)           // symmetric, E[a] = 0
17.                  c_k = C2G_k · rand()
18.                  d_k = | c_k · X_leader_k[j] − m[i] · X_i[j] |
19.                  sum += X_leader_k[j] − a_k · d_k
20.              X_i[j] ← sum / 4
21.              clamp X_i[j] to [lo[j], hi[j]]

22.      Calculate the fitness of all agents
23.      Update the four leaders (elitist update: retain the four best solutions found so far)
24.      Update the global best

25.  return the global best

Coordinate-wise randomness. The coefficients a_k and c_k are resampled for each coordinate j; each agent has its own chaotic multiplier m[i]. Even though m[i] is the same for all of the agent’s coordinates, the coordinate-wise variation is provided by a_k and c_k — therefore, a shared scalar that confines a candidate to a subspace does not arise, and there is no diagonal advantage on a symmetric benchmark.

Symmetric a. The factor f·C1G_k specifies the step amplitude and decays to zero by the end of the run, while the factor (2·rand − 1) makes the step symmetric (mean zero). This corrects the defect discussed in the description section: in the published form, the random component is shifted away from zero, causing the population to drift into a corner in continuous search.

Elitism. Each of the four leaders stores its best-ever position, rather than the best position in the current population; the population itself moves freely, without rollback.

The chaotic replacement phase of the original ChOA (where a position is replaced by a chaotic value with a probability of 0.5) has been omitted: in the continuous problem, it proved to be detrimental to convergence. For a binary problem (feature selection), line 20 is replaced by a binarization step — either sigmoid thresholding of the mean (BChimp2) or crossover of four binary steps (BChimp1).

Let's move on to the implementation. The C_AO_BChimp class inherits from the base class C_AO and follows the framework's standard life cycle: the Moving method proposes new positions, the outer loop evaluates fitness, and the Revision method updates the best positions. All internal state beyond that of the base agent is stored in structures — this keeps the data for the four leaders and the individual state of each agent self-contained, without flat buffers (index × coordinate).

The four leaders are stored as an array called lead[4] (0 = attacker, 1 = barrier, 2 = chaser, 3 = driver). Each leader is self-contained, and working with it does not require manually recalculating offsets in the shared buffer. In addition, the class maintains the iteration counters epochs, epochsDen, and epochNow for the t/T ratio, as well as a single visible parameter, popSize.

//+------------------------------------------------------------------+
class C_AO_BChimp : public C_AO
 {
public:
                    ~C_AO_BChimp() {}
                     C_AO_BChimp()
   {
    ao_name = "BChimp";
    ao_desc = "Chimp Optimization Algorithm";
    ao_link = "https://www.mql5.com/en/articles/23132";

    popSize = 30;

    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:
  //--- four leaders: 0=attacker, 1=barrier, 2=chaser, 3=driver
  S_Leader           lead [4];

  //--- agents' individual state
  S_Chimp            chimp [];

  //--- iteration counters (for the ratio t/T)
  int                epochs;
  int                epochsDen;
  int                epochNow;

  //--- attempt to insert an agent into the elite leader ranking
  void               InsertLeader(const int i);
 };

The pack leader is described by the S_Leader structure — coordinates and fitness in a single object:

//+------------------------------------------------------------------+
//| Pack leader: coordinates + fitness                               |
//+------------------------------------------------------------------+
struct S_Leader
 {
  double c           [];   // coordinates
  double             f;      // fitness

  void               Init(const int coords)
   {
    ArrayResize(c, coords);
    f = -DBL_MAX;
   }
 };

The individual state of an agent is represented by the S_Chimp structure with a single field, m, the chaotic multiplier. There is only one field, but moving it into the structure separates the algorithm's state from the base S_AO_Agent and leaves room for expansion.

//+------------------------------------------------------------------+
//| Individual state of a chimpanzee                                 |
//+------------------------------------------------------------------+
struct S_Chimp
 {
  double             m;      // chaotic multiplier (Piecewise map), static
 };

Init begins with StandardInit, which sets up the search boundaries and the array of agents. The initial population is then randomly distributed into cP[] — on the first call to Moving, it will be copied to the working coordinates c[] so that the outer loop can evaluate it. The four leaders are initialized with a fitness of -DBL_MAX, representing empty slots that will be filled during the first revision.

A separate block precomputes the chaotic multiplier based on the Piecewise map (index 6, P = 0.4, initial value x0 = 0.7). The value is taken before the next map update. Each agent receives its own static multiplier m[i], which is the same for all its coordinates and remains unchanged throughout the run — exactly as in the original implementation. The epochsDen counter is set to epochs − 1: this ensures that the ratio t/T reaches one precisely on the last actual iteration, and the control multiplier f = 2 − 2·t/T correctly decays to zero by the end of the run.

//+------------------------------------------------------------------+
//|                              Init                                |
//+------------------------------------------------------------------+
bool C_AO_BChimp::Init(const double &rangeMinP  [],
                       const double &rangeMaxP  [],
                       const double &rangeStepP [],
                       const int     epochsP = 0)
 {
  if(!StandardInit(rangeMinP, rangeMaxP, rangeStepP))
    return false;

//--- initial random population in cP[] (will be copied to c[] on the first call to Moving)
  for(int i = 0; i < popSize; i++)
    for(int c = 0; c < coords; c++)
      a [i].cP [c] = u.RNDfromCI(rangeMin [c], rangeMax [c]);

//--- leaders
  for(int k = 0; k < 4; k++)
    lead [k].Init(coords);

//--- individual state
  ArrayResize(chimp, popSize);

//--- chaotic multiplier m[i] — Piecewise map (index=6 in the source),
//    P=0.4, x0=0.7, Value=1; the value is taken BEFORE the update
  double P = 0.4;
  double x = 0.7;
  for(int i = 0; i < popSize; i++)
   {
    chimp [i].m = x;
    if(x >= 0.0 && x < P)
      x = x / P;
    else
      if(x >= P && x < 0.5)
        x = (x - P) / (0.5 - P);
      else
        if(x >= 0.5 && x < 1.0 - P)
          x = (1.0 - P - x) / (0.5 - P);
        else
          x = (1.0 - x) / P;
   }

//--- iteration counters
  epochs    = epochsP;
  epochsDen = (epochs > 1) ? epochs - 1 : 1;
  epochNow  = 0;

  return true;
 }

The first call is special: while 'revision' is still 'false', the method simply transfers the starting coordinates from cP[] to c[] using the SeInDiSp projection (clamping to the boundaries while accounting for the step size) and exits, handing control back to the outer loop for the first evaluation.

On subsequent iterations, the epoch coefficients are recalculated first: the ratio tRatio = epochNow / epochsDen, the shared multiplier aCoef = 2 − 2·tRatio, and the group curves using the cube-root law u1 = (t/T)^{1/3} and the cubic law u3 = (t/T)^3 (arrays C1G, C2G). Next, for each agent and each coordinate, four candidates are generated — one per leader — and averaged.

The key detail is the form of Ak: the group curve C1G[k] serves as the amplitude, while randomness is introduced through a symmetric multiplier (2·rand − 1) with zero mean. This is precisely what corrects the inherited bias: in the published formulation, the random component was shifted, causing the population to drift toward a corner in continuous search space. Random values of Ak and Ck are drawn anew for each coordinate, so despite the scalar m[i], there is no shared multiplier for the entire vector, and the algorithm gains no geometric diagonal advantage.

//+------------------------------------------------------------------------+
//|                            Moving                                      |
//|                                                                        |
//|  1. First pass: cP -> c (the outer loop will evaluate FF);             |
//|  2. Next: a and four sets of coefficients per iteration;               |
//|  3. For each agent/coordinate—four candidates derived from the leaders,|
//|     averaging, projection into the bounds (SeInDiSp).                  |
//+------------------------------------------------------------------------+
void C_AO_BChimp::Moving()
 {
//--- first pass: cP -> c
  if(!revision)
   {
    for(int i = 0; i < popSize; i++)
      for(int c = 0; c < coords; c++)
        a [i].c [c] = u.SeInDiSp(a [i].cP [c], rangeMin [c], rangeMax [c], rangeStep [c]);
    return;
   }

//--- ratio t/T (clamped at 1.0); a: decay from 2 to 0
  epochNow++;
  double tRatio = (double)epochNow / (double)epochsDen;
  if(tRatio > 1.0)
    tRatio = 1.0;

  double aCoef = 2.0 - 2.0 * tRatio;

//--- dynamic group coefficients
//    u1 = (t/T)^(1/3) — cube-root law,  u3 = (t/T)^3 — cubic law
  double u1 = MathPow(tRatio, 1.0 / 3.0);
  double u3 = tRatio * tRatio * tRatio;

  double C1G [4], C2G [4];
  C1G [0] = 1.95 - 2.0 * u1;
  C2G [0] = 2.0 * u1 + 0.5;   // Group 1 (attacker)
  C1G [1] = 1.95 - 2.0 * u1;
  C2G [1] = 2.0 * u3 + 0.5;   // Group 2 (barrier)
  C1G [2] = -2.0 * u3 + 2.5;
  C2G [2] = 2.0 * u1 + 0.5;   // Group 3 (chaser)
  C1G [3] = -2.0 * u3 + 2.5;
  C2G [3] = 2.0 * u3 + 0.5;   // Group 4 (driver)

//--- movement
  for(int i = 0; i < popSize; i++)
   {
    double mi = chimp [i].m;

    for(int c = 0; c < coords; c++)
     {
      double xi  = a [i].c [c];
      double sum = 0.0;

      for(int k = 0; k < 4; k++)
       {
        //--- A is symmetric about 0: amplitude aCoef*C1G[k] → 0
        //    by the end of the run (E[A] = 0; no drift toward the corner). C is scaled
        //    to the canonical range [0..~2.5]. The sign of C1G[k] does not matter—it is multiplied
        //    by the symmetric term (2r-1).
        double Ak = aCoef * C1G [k] * (2.0 * u.RNDprobab() - 1.0);
        double Ck = C2G [k] * u.RNDprobab();
        double Dk = MathAbs(Ck * lead [k].c [c] - mi * xi);
        sum += lead [k].c [c] - Ak * Dk;
       }

      double v = sum / 4.0;
      a [i].c [c] = u.SeInDiSp (v, rangeMin [c], rangeMax [c], rangeStep [c]);
     }
   }
 }

Revision first updates the personal (fB, cB for each agent) and global (fB, cB) best solutions. Next, InsertLeader is called for each agent to maintain an elite group of four leaders: on the first call, the group is populated with the best individuals from the initial population; on subsequent calls, it is updated if an individual better than the current leaders is found. Leaders store the best positions found throughout the run, not the best positions in the current population.

There is no rollback (greedy acceptance) here — the population moves freely, and this is a deliberate choice: this is the reference version, with no additions on top of the original mechanics.

//+--------------------------------------------------------------------------+
//|                           Revision                                       |
//|                                                                          |
//|  Personal/global best updates + elitist update of the                    |
//|  four leaders (best-ever). No rollbacks—this is the reference version.   |
//+--------------------------------------------------------------------------+
void C_AO_BChimp::Revision()
 {
//--- update personal and global bests
  for(int i = 0; i < popSize; i++)
   {
    if(a [i].f > a [i].fB)
     {
      a [i].fB = a [i].f;
      ArrayCopy(a [i].cB, a [i].c, 0, 0, coords);
     }
    if(a [i].f > fB)
     {
      fB = a [i].f;
      ArrayCopy(cB, a [i].c, 0, 0, coords);
     }
   }

//--- elitist update of leaders (initialization on the first call
//    and maintenance of the top four on subsequent calls)
  for(int i = 0; i < popSize; i++)
    InsertLeader(i);

  if(!revision)
    revision = true;
 }

InsertLeader inserts an agent into a list of four leaders sorted in descending order of fitness. If an agent's fitness exceeds that of any of the leaders, the position found determines the insertion point, the tail of the list shifts downward, and the agent takes its place. Since the leaders are not reset between iterations, the set of four solutions accumulated in this way always reflects the four best solutions encountered since the start of the run.

//+---------------------------------------------------------------------------+
//|        InsertLeader — insert an agent into the leader list                |
//|  Leaders are sorted in descending order of fitness (lead[0] is the best). |
//+---------------------------------------------------------------------------+
void C_AO_BChimp::InsertLeader(const int i)
 {
  double f = a [i].f;

  int p = -1;
  if(f > lead [0].f)
    p = 0;
  else
    if(f > lead [1].f)
      p = 1;
    else
      if(f > lead [2].f)
        p = 2;
      else
        if(f > lead [3].f)
          p = 3;

  if(p < 0)
    return;

//--- shift downward from the tail to the insertion point
  for(int s = 3; s > p; s--)
   {
    lead [s].f = lead [s - 1].f;
    ArrayCopy(lead [s].c, lead [s - 1].c, 0, 0, coords);
   }

//--- insert
  lead [p].f = f;
  ArrayCopy(lead [p].c, a [i].c, 0, 0, coords);
 }

Conclusions

In its continuous form, BChimp is a mid-tier algorithm compared with other metaheuristics. After correcting the inherited coefficient bias, it scores 33.94% on the standard set of test functions, performing particularly poorly on Forest and losing ground as dimensionality increases: what performs decently with 10 coordinates falls apart at 1,000. The chaotic replacement phase, inherited from the original ChOA and intended as a mechanism for escaping local optima, proved more detrimental than beneficial to convergence in continuous optimization, so it is omitted from our implementation — the hunting phase alone, with a symmetric coefficient, is more stable.

The main value of the analysis lies not in the scores themselves, but in what was revealed along the way. First, the published form of the coefficient A has a sign bias (E[A] = f·(c1g − 1) ≠ 0). This goes unnoticed in a binary problem because the sigmoid transfer function masks both the sign and the step size — but in the continuous version, this bias drives the entire population into a corner of the search space. A clear lesson: a defect hidden behind binarization surfaces when the algorithm is ported to another domain, and copying the code verbatim from a publication results in an optimizer that does not work. Second, comparing the code with the publication and the original ChOA revealed a series of discrepancies — from mix-ups in the coefficient formulas to the questionable replacement phase. Third, a run on the Ackley function revealed the algorithm’s bias toward the coordinate origin: the nearly perfect result there is not a search achievement, but a coincidence between the algorithm’s structural attractor and the position of the optimum at the center of the symmetric range.

It is hard to recommend BChimp as a general-purpose optimizer. The ranking includes much stronger algorithms at the same computational cost. Its real niche, if any, is in low-dimensional problems or as a component of a hybrid approach. For serious high-dimensional optimization, it is neither a first nor a second choice.

For a trader optimizing an expert advisor’s parameters, entry thresholds, or money management rules, the conclusion is simple: a tool should be chosen based on its actual effectiveness in a complex, multidimensional landscape. The parameter space of a trading system is typically rugged and not centered around zero — precisely the conditions in which BChimp is weak and its bias toward the center works against the search.

A striking result may turn out to be an artifact of the test geometry rather than a genuine advantage — just as the ideal result for the Ackley function arose from the coincidence of the optimum with the center of the space. The discipline that protects against both pitfalls is the same: test under shifted, challenging, and out-of-sample conditions, rather than conditions known in advance to yield flattering results.

What stays with the reader, regardless of the fate of BChimp itself, is the habit of not trusting a source blindly. A published algorithm, just like someone else's strategy, may contain errors in its formulas, discrepancies, and hidden biases. Checking against the original source, analyzing the algorithm equation by equation, and benchmarking it honestly separate what works from what is merely attractively described.