GOOSE Algorithm: A Powerful Optimization Tool for Real-World Engineering Challenges and Beyond

In plain words

Choosing the best settings for a physical design, such as the thickness of a beam, is often a search through many candidate settings. A metaheuristic handles this by keeping a population of candidates and moving them toward better ones, instead of solving the problem exactly. This paper proposes GOOSE, a method inspired by geese. In the natural behaviour it copies, one goose stands on one leg as a guard, carries a small stone that drops and wakes it if it falls asleep, and calls out to the flock when it hears something.

The algorithm turns this into random timings. A candidate may move toward a better region by a step set by a random "fall time", a random "sound time" and a stone weight. Or it may take a random step instead. Which step is taken depends on random draws and fixed thresholds.

The authors tested it on standard test functions, newer benchmark functions and four real-world problems. Its own tables give mixed results, and several of its equations do not match the authors' code. Anyone who implements it needs to decide which version to follow.

TL;DR

• GOOSE is a population search. Each agent moves by one of two rules: a fall-and-sound step, or a random step around a point §2.3.
• Author-reported: among five compared methods, GOOSE has the lowest mean on 8 of the 19 standard functions tab. 2. On the classical and CEC-style sets its ranks are mixed tab. 3, tab. 4.
• The welded-beam and pressure-vessel results do not support the text's claims tab. 15, tab. 18.
• In the authors' MATLAB code, the fall-and-sound branch almost never fires, so most agent moves are the random step GOOSE.m.
• The paper and code disagree on several update rules. Read "Paper vs code" before reproducing any number.

Problem

Minimise a black-box objective f(x) over a box lb ≤ x ≤ ub in dim dimensions, with no gradient information. The authors motivate metaheuristics by problems that conventional methods do not solve well §1. Engineering tests include constraints: the welded beam eq. 14, the economic load dispatch with a demand equality eq. 15–16, the IgG problem eq. 17–18, and the pressure vessel eq. 19–21. How constraints are handled is not stated for any of them.

Method

GOOSE keeps N agents, each a vector of length dim, drawn uniformly inside the bounds at start §2.3 alg. 1 l. 1. Each iteration does the following alg. 1:

1. Evaluate every agent and record the best position and score so far alg. 1 l. 4–5.
2. For each agent, draw pro and rnd from U(0, 1), and coe = min(U(0, 1), 0.17) §2.3.
3. Draw a stone weight S_W eq. 1, a fall time T_OAO and a sound time T_OAS for each dimension eq. 2–3. Average them into T_T eq. 4 and T_A = T_T / 2 eq. 5.
4. If rnd ≥ 0.5, use exploitation §2.3.1:
   • if pro > 0.2 and S_W ≥ 12, move with eq. 9, using the fall speed eq. 6 and the sound distance eq. 7–8;
   • if pro ≤ 0.2 and S_W < 12, move with eq. 11, using the fall speed eq. 10;
   • the mixed cases (pro > 0.2 with S_W < 12, or pro ≤ 0.2 with S_W ≥ 12) are not stated.
5. If rnd < 0.5, use exploration §2.3.2: alpha falls linearly from 2 to 0 eq. 12, and the agent moves by a Gaussian step scaled by M_T · alpha eq. 13.
6. Clamp agents to the bounds (the rule is not stated), re-evaluate, and update the best alg. 1 l. 30–32.

The printed equations are:

F_{FS} = T_{OAO} \cdot \sqrt{S_W} \cdot g \qquad [\text{eq. 6}]

D_{ST} = S_S \cdot T_{OAS}, \qquad D_G = 0.5 \cdot D_{ST} \qquad [\text{eq. 7, 8}]

X_{t+1} = X_t + F_{FS} + D_G \, T_A^{2} \qquad [\text{eq. 9}]

F_{FS} = T_{OAO} \cdot S_W \cdot g \qquad [\text{eq. 10}]

X_{t+1} = X_t + F_{FS} \, D_G \, T_A^{2} \, coe \qquad [\text{eq. 11}]

\alpha = 2 - \frac{loop}{Max\_It / 2} \qquad [\text{eq. 12}]

X_{t+1} = \mathrm{randn}(1, dim) \, (M_T \, \alpha) + X_t \qquad [\text{eq. 13}]

Constants: g = 9.81 m/s² §2.3.1 and sound speed S_S = 343.2 m/s eq. 7. The T_T and T_OAO / T_OAS definitions are in eq. 2–5.

# GOOSE as printed in the paper  [alg. 1] [§2.3.3]
# Input:  objective f, bounds lb and ub (dim,), N agents, max_iter
# Output: best_pos (dim,), best_score

def goose(f, lb, ub, dim, n_agents, max_iter):
    # Uniform random start inside the box  [alg. 1 l. 1]
    agents = lb + (ub - lb) * uniform(0, 1, (n_agents, dim))  # (N, dim)
    # Evaluate the start population and keep the best  [alg. 1 l. 4-5]
    best_pos, best_score = keep_best(agents, f, lb, ub, zeros(dim), inf)
    m_t = inf   # running minimum of T_T; scope not stated  [§2.3.2]
    for loop in range(max_iter):
        for i in range(n_agents):
            # Random controls  [§2.3]
            pro = uniform(0, 1)
            rnd = uniform(0, 1)
            coe = min(uniform(0, 1), 0.17)
            # Stone weight and the two times  [eq. 1-3]
            s_w = uniform_int(5, 25)       # integer draw, paper says (5, 25)
            t_fall = uniform(0, 1, dim)    # code range; paper text says 1..dim
            t_sound = uniform(0, 1, dim)   # code range; paper text says 1..dim
            # Mean time and its half  [eq. 4-5]
            t_t = (sum(t_fall) + sum(t_sound)) / dim
            t_a = t_t / 2
            if rnd >= 0.5:
                # Exploitation: the guard goose wakes the flock  [§2.3.1]
                d_sound = 343.2 * t_sound       # S_S = 343.2 m/s  [eq. 7]
                d_g = 0.5 * d_sound             # [eq. 8]
                if pro > 0.2 and s_w >= 12:
                    f_fs = t_fall * sqrt(s_w) * 9.81        # [eq. 6]
                    agents[i] = agents[i] + f_fs + d_g * t_a**2  # [eq. 9]
                elif pro <= 0.2 and s_w < 12:
                    f_fs = t_fall * s_w * 9.81              # [eq. 10]
                    # Move with the coe-scaled step  [eq. 11]
                    agents[i] = agents[i] + f_fs * d_g * t_a**2 * coe
                # Mixed cases: not stated; left unchanged in this sketch
            else:
                # Exploration: random wake-up  [§2.3.2]
                m_t = min(m_t, t_t)
                alpha = 2 - loop / (max_iter / 2)           # [eq. 12]
                # Printed with X_t; the text and the code use the best point
                agents[i] = agents[i] + randn(dim) * (m_t * alpha)  # [eq. 13]
        # Clamp, evaluate and update the best after the moves  [alg. 1 l. 31-32]
        best_pos, best_score = keep_best(
            agents, f, lb, ub, best_pos, best_score)
    return best_pos, best_score


def keep_best(agents, f, lb, ub, best_pos, best_score):
    # Bound rule not stated in the paper; the code clamps  [§2.3]
    for i in range(len(agents)):
        agents[i] = clip(agents[i], lb, ub)
        score = f(agents[i])
        if score < best_score:
            best_score = score
            best_pos = agents[i].copy()
    return best_pos, best_score

Hyperparameters

Population size and iteration count vary per experiment, so compare each row with the table or section that uses it.

Results

Author-reported. Hardware: MATLAB R2019a on an Intel Core i7-7500U (2.70 GHz), 16 GB RAM §3.6. Competitor numbers are copied from earlier papers, as the table captions say, not re-run by the authors tab. 2, tab. 3, tab. 4.

Standard functions, 19 problems, mean best value over 30 runs tab. 2. Lowest value in each row is marked in the paper with bold. The paper's own ranking counts GOOSE first on 8 of 19 functions tab. 7.

Only means are shown; the standard deviations are in tab. 2. Wilcoxon-type tests against FDO give p < 0.05 on every standard function except F5, F11, F14, F15 and F18 tab. 12.

Classical functions, five problems, 30-D tab. 3. Means only.

CEC-style set, ten problems tab. 4. Means only.

GOOSE has the lowest mean on CEC06, CEC07, CEC08 and CEC10, and ties WOA on CEC03 tab. 4. Its rank counts over these ten functions are in tab. 10.

Rank summaries (the paper's own tables). Rank counts over the 19 standard functions: GOOSE 8 first, 3 second, 5 third, 3 fourth, 0 fifth; FDO 7 first tab. 7. Over the ten CEC-style functions: GOOSE 5 first, SSA 4 first tab. 10. The paper reports GOOSE's average rank as 41/19 = 2.158 among the standard functions tab. 5.

Engineering problems (each with its own setting, see §3.9).

Welded beam, minimisation, 30 runs, 20 agents, 500 iterations §3.9.1 tab. 15:

Economic load dispatch, three units, demand 150 MW, 50 runs, 1000 iterations §3.9.2 tab. 16, tab. 17:

Pathological IgG fraction: 150 iterations, 12 agents. The best value is 0.00047792 at iteration 135. The paper also gives 5.088 for a method it calls LEO, with no table or setting §3.9.3 fig. 13.

Pressure vessel, best value (minimisation) tab. 18: CEPSO 6061.0777, PSO 6059.7143, MBA 5889.3216, GWO 6051.5639, QOCSOS 5885.332774, SFS 6059.714335, ISOS 6059.714335, mSSA 6059.71433, GOOSE 6343.6587. Run settings are not stated for this problem.

Paper vs code

Repository: https://github.com/Rebwarkh/GOOSE-Algorithm, cloned at commit 544e1ff78e6e6b01512af09e3f2fc0cf27423429. The owner's profile name matches the first author. The repo has no LICENSE file, so it is cite-only: no code is quoted. It holds GOOSE.m, main.m, initialization.m, Get_Functions_details.m (F1–F23 only), func_plot.m and a README. It contains no CEC functions and no code for the engineering problems or the competitor algorithms. The file headers cite a 2024 Evolving Systems version GOOSE.m. That journal version was not checked; this card follows arXiv v3.

• Eq. 9 sign and base point. Paper: X_t + F_FS + D_G T_A² eq. 9. Code: Best_pos − F_FS + D_G T_A² GOOSE.m. The code subtracts the fall term and uses the best point.
• Eq. 11 is never reached. The pro ≤ 0.2 branch sits inside the if pro > 0.2 block, so it cannot run GOOSE.m. Eq. 10 and eq. 11 are dead code.
• Eq. 13 base point. Paper prints X_t, but the paper's text says exploration follows the best position. Code uses Best_pos GOOSE.m.
• Eq. 1 and eq. 2–3 ranges. Paper gives (5, 25) and "1 to dim". Code draws integers 5–25 GOOSE.m and uniform(0, 1) GOOSE.m.
• Fall-and-sound branch test. Paper tests S_W per agent. MATLAB's if on the whole vector S_W is true only when every weight is at least 12 GOOSE.m. See Pitfalls.
• Mean-time minimum M_T. Code keeps a running minimum over all iterations GOOSE.m. Paper does not say over which scope.
• Evaluation order. Code evaluates at the top of each iteration GOOSE.m. Any update in the final iteration is never evaluated. Paper's Algorithm 1 evaluates again after the update alg. 1 l. 31.
• Bound handling. Code clamps to the bounds before evaluation GOOSE.m. Paper says agents are "adapted" without a rule.
• Default settings. main.m runs F1 with 10 agents, 500 iterations and 30 runs main.m. Paper's standard setting is 30 agents tab. 14.
• Test-function dimensions. Code uses dim 10 for F15–F18 Get_Functions_details.m. Paper's table gives 4, 2, 2, 2 app. A tab. A3.
• Broken per-variable bounds. initialization.m's branch for vector bounds refers to undefined names (dimValue, x, Value) and returns no X initialization.m. Only scalar bounds work initialization.m.
• README. The README calls GOOSE a PSO-based method with a velocity term README.md. Neither the paper nor the code has a velocity term.
• Engineering code. None of the four real-world problems is in the repo.

Pitfalls

• The fall-and-sound step almost never fires in the code. It needs every stone weight in the population to be at least 12 GOOSE.m. With integer weights from 5 to 25 GOOSE.m, each weight is at least 12 with probability 14/21 = 2/3. The chance that all N are at least 12 is (2/3)^N: about 1.7% for N = 10 and about 0.0005% for N = 30. This is my calculation from the code. As a result, in about half of the agent-steps (rnd ≥ 0.5) the position stays unchanged, and the rest use the random step.
• Mixed cases are not stated. The paper covers the case pro > 0.2 with S_W ≥ 12 and the case pro ≤ 0.2 with S_W < 12 §2.3.1. The two mixed cases are missing. The code leaves the agent unchanged GOOSE.m.
• Equations cannot be implemented as printed without a choice. Eq. 9 and eq. 13 are printed with X_t, but the code uses the best position (eq. 13, and the sign in eq. 9). Pick one and say which in your write-up.
• Step sizes are not tied to the bounds. The sound step is at most 0.5 · 343.2 = 171.6 per dimension (T_OAS ≤ 1 in the code) eq. 7–8. For bounds of ±5 Get_Functions_details.m, a single step can overshoot the box many times, so clamping decides the outcome.
• The times and weights have no units in practice. The paper gives the physical meaning, but the code draws unitless uniform numbers.
• Rank tables do not match each other. Table 11 gives unimodal ranking 2.158, but 22/7 = 3.143, which the text also uses. Its total row says 5.828, while 41/19 = 2.158 tab. 5 tab. 11.
• Claims that the paper's tables contradict:
  • The text says GOOSE beat FDO, FOX, BOA and WOA on F8 §3.1.2. Table 3 bolds GOOSE on F8, but FDO's value (−2285207) is lower tab. 3.
  • The text says GOOSE fared better than all others on the CEC-style set apart from CEC03 §3.2. Table 4 shows GOOSE worse than at least one method on CEC01, CEC02, CEC04, CEC05 and CEC09 tab. 4.
  • The welded-beam text says GOOSE performs better on average §3.9.1. Table 15 shows GOOSE's mean 3.1882 behind WOA and PSO, and ahead only of GSA.
  • The ELD text says FOX, PSO, GOOSE and WOA give the same power §3.9.2. Table 17 shows FOX at 152.6089 MW and PSO at 152.9285 MW.
  • The conclusion says the pressure-vessel result is a significant improvement §4. Table 18 has GOOSE as the highest (worst) value.
• Table 3's DA column repeats the 10-D values of Table 2 (for example F1 2.85E-18, F5 7.6005 vs 7.600558, F11 0.1933 vs 0.193354) even though §3.1.2 uses 30-D. Those numbers look copied rather than rerun. Verify before relying on them.
• Baselines come from earlier papers tab. 2, tab. 3, tab. 4. Their settings may differ from the authors' runs, and the paper does not say whether they match.
• ELD settings conflict. §3.9.2 gives 50 runs and 1000 iterations, while tab. 14 gives 30 runs and 500 iterations. The cost coefficients a_i, b_i, c_i and the output limits per unit are not stated eq. 15–16 tab. 16.
• IgG problem cannot be reproduced. Eq. 18 sums over an undefined index n and uses an undefined X_i. The bounds and population setup are the only stated values eq. 17–18 §3.9.3.
• Pressure vessel. The thicknesses must be multiples of 0.0625 eq. 19. How this is enforced (rounding, mapping) is not stated, and neither is the constraint handling eq. 20–21.
• Welded beam. Constraint handling is not stated eq. 14. Run settings are given §3.9.1.
• Complexity claim. The paper says time is O(N·D·it) and space O(n²) §3.8. The space bound is not explained.

Lineage

• Builds on: none stated. The inspiration is observed goose behaviour §2.1–2.2.
• Compared against: GA, PSO, DA, FDO, FOX, BOA, WOA, ChOA and SSA §3.
• Superseded by: not known from this wiki.