Whale Optimization Algorithm

in reviewThis lesson is complete and being validated before release - details may still change.

Whale optimization

Loading interactive demo…

A pod of whales searches a landscape it can only sample. Each iteration the coefficient a shrinks, and every whale either encircles the leader, searches around a random pod mate, or spirals onto the leader; the lowest point reached becomes the leader. Take the tour, or press and explore. Legend:

The panel beside the stage is the real WhaleOptimization class from the published library executing in your browser, with the current line highlighted.

A whale where it stands; the one moving this step is brighter.
The leader: the hollow mark labelled best, the lowest point reached so far.
An encircling move, around the leader with a pull below 1 in size.
A search move, around a random pod mate (dashed line to the mate) with a pull of 1 or more.
A spiral move onto the leader.
The ring and trail of the followed whale. Tap near a whale to follow it.

a is the shrinking coefficient, best the height of the leader and at its position, modes the moves of this iteration by kind, iteration how far the run has come. The plot beneath the field is the best height as a share of the best of the scatter, with a over 2 drawn beside it; the strip under the plot counts the modes of this iteration. Reseed scatters a new pod.

The code panel shows bare executable code by default. The bar above it names the file (hover the name for the full published path); options holds the toggles: comments, the tracer instrumentation that produces this visualization, and verbose names for the terse identifiers (display only: the default is the byte-exact published file). The view switch adds plain-English narration: both interleaves it with the code, pseudo shows only the pseudocode. hide code collapses the panel; the rail it leaves behind brings it back.

Keys: Space play/pause · ←/→ step · Home/End jump · R reset · F fullscreen · G guided tour

The setting. A pod of $P$ whales sits on a landscape $f$ it cannot see; each whale can only ask the height where it stands. The leader $X^*$ is the lowest point any whale has reached. The run lasts $T$ iterations, and before each one a coefficient shrinks in a straight line:

a(t) = 2\left(1 - \frac{t}{T}\right), \qquad t = 0, \dots, T-1

so $a$ is 2 at the start and 0.1 on the last iteration of a run of 20. Every whale then draws three uniform numbers $r_1, r_2, p$ in $[0, 1)$ and sets its own pull and stretch:

A = 2 a r_1 - a, \qquad C = 2 r_2

$A$ lies anywhere in $[-a, a]$ and $C$ anywhere in $[0, 2)$ .

Three moves, picked by a coin and a size. If $p < 0.5$ the whale encircles: with $|A| < 1$ it moves relative to the leader,

X' = X^* - A\,\lvert C X^* - X \rvert

and with $|A| \ge 1$ it does the same move around a random pod mate in place of $X^*$ . The paper calls that search for prey; it is the only move that is not aimed at the leader, and on the stage it is the one with a dashed line to the partner. If $p \ge 0.5$ the whale spirals:

X' = \lvert X^* - X \rvert \, e^{bl} \cos(2\pi l) + X^*, \qquad l \sim U[-1, 1]

with the shape constant $b = 1$ . All of this is component-wise: the absolute values are taken on each coordinate separately, and the result is clamped back into the domain. Every whale moves against the pod as it stood when the iteration began, and the leader is updated only after all of them have moved.

Why exploration ends at the midpoint. The search move needs $|A| \ge 1$ , and $|A| \le a$ . Once $a < 1$ , which happens at $t > T/2$ , no whale can search again, whatever the landscape has shown so far. Half of the run explores and half closes in, by the schedule alone. The halfway tour step lands on the first iteration with $a = 1$ ; watch the modes strip from there and search stays at zero. Simulated annealing has the same shape with its temperature, but there the acceptance rule reads the landscape; here the coefficient reads only the clock.

The spiral is not symmetric about the leader. Take one coordinate with $X^* = 0$ , $X = 1$ , $b = 1$ . With $l = 0.5$ the factor $e^{0.5}\cos\pi$ is $-1.65$ , so the whale lands at $-1.65$ , past the leader and farther from it than it started. With $l = -1$ the factor is $e^{-1}\cos(-2\pi) = 0.37$ , so it lands at $0.37$ . Now start the whale at $X = -1$ instead: $|X^* - X|$ is again 1, and with $l = -1$ it lands at $0.37$ too, on the far side of the leader from where it came. As published, which side of the leader a spiral lands on depends on $l$ alone, never on where the whale was. A whale that spirals on a two-dimensional landscape therefore lands in one of the quadrants $X^* \pm d_x,\ X^* \pm d_y$ chosen by the sign of $e^{bl}\cos 2\pi l$ , the same quadrant for both coordinates. That is not a spiral in any geometric sense; it is a scaled, mirrored jump.

What the method is, in plain terms. Strip the story away and the whale optimization algorithm is a population of points, each repeatedly pulled toward the best point found so far by a random coefficient whose range shrinks on a schedule, with a second move that jumps to the far side of the best point by a random factor, and an early phase in which the pull is aimed at a random other point. Camacho-Villalón, Dorigo, and Stützle (International Transactions in Operational Research, online 2022, in print 2023) took it apart component by component and showed that each of these reduces to an operator the field already had, the pull toward a best point being the particle swarm's, and that the only novelty in the whale and the five other animal algorithms they examined is their terminology. Sörensen had named the pattern in 2015: a new metaphor is not a new method, and a method must be stated in the language of optimization before its contribution can be judged.

No free lunch. Wolpert and Macready (1997) showed that averaged over all possible objectives, no search algorithm beats any other, so a method is good only relative to a problem family, and only a comparison on that family, against the strongest known methods and with the same tuning effort, can show it. A new name attached to old operators is not a new result on any family. Camacho-Villalón and colleagues add that the usual argument for proposing one more metaphor, that no free lunch leaves room for it, misreads the theorem: it says nothing about any particular family, and it gives no reason to expect a renamed operator to do better than the operator it renames.

What to take from the lesson. The algorithm is worth knowing because it is widely cited and because it is a clean example of how to read a published metaheuristic: write the moves as equations, ask what each one depends on (here, the clock and the leader, never the landscape's shape), check the geometry the story claims (the spiral is not one), and look for the operator underneath. The stage shows the method exactly as published, and that is the point: seen without the whales, it is a shrinking random pull toward the best, which is what simulated annealing's cooling and the particle swarm's attraction already were.

Choices worth reading closely in the implementation (the code panel's comments and tracer checkboxes reveal the full published file):

The equations as published. encircle is $X^* - A\,|C X^* - X|$ and spiralMove is $|X^* - X|\,e^{bl}\cos(2\pi l) + X^*$ , both component-wise with Math.abs on each coordinate, so the asymmetry the analysis describes is in the code, not smoothed over. Both are static so the test suite can pin single moves: spiralMove([1, 0], [0, 0], -1, 1) is [0.3679, 0].
The random draws are in a fixed order. Per whale: r1, r2, p, then either the partner index or l. The Mulberry32 stream is owned by the run, so the same seed replays the same run, and Reseed is one param bump.
A random pod mate that is never the whale itself. `rng.index(P
- 1)` draws from one fewer than the pod and the index is shifted past the whale's own slot, so the search move always has a partner that is not itself.
Synchronous update. Every move reads pod and target as they stood when the iteration began; the moved positions collect in moved and replace the pod only when the loop ends, and the leader is updated once per iteration, as the paper describes. The stage draws each whale at its new spot as it moves, but the dashed partner line points at the partner's position from the iteration's start.
Clamped, then measured. A move can leave the domain; clamp pulls it back to the edge before the height is read, so the traced position is always where the whale actually stands.
One move tag with a mode key. The three branches set mode, partner (-1 unless searching), and twist (l, 0 unless spiralling) and share one emit, so the code panel maps the tag to one line and the stage tones the move by the key.
WhaleMode counts are the result's modes. They sum to population times iterations, which the library test checks on every landscape over ten seeds, along with the property that no search move happens once a is 1 or less.

The whale optimization algorithm appeared in 2016, one of a long run of search methods named after an animal and framed by the story of how it hunts. Its moves are a pull toward the best point found, with random coefficients that shrink over the run, and a spiral onto that point. Kenneth Sörensen had already named the pattern in 2015: a flood of new metaheuristics whose novelty is the metaphor, not the method. In 2022 Camacho-Villalón, Dorigo, and Stützle took six such algorithms apart, the whale among them, and found each component was an operator the field already had.

1997David Wolpert and William Macready - Publish the no free lunch theorems for optimization in IEEE Transactions on Evolutionary Computation: averaged across all possible problems, any two search algorithms perform the same.source
2015Kenneth Sörensen - 'Metaheuristics, the metaphor exposed' in International Transactions in Operational Research 22(1), online since 2013, argues that the flood of methods inspired by a natural or man-made process risks pulling the field away from scientific rigor.source
2016Seyedali Mirjalili and Andrew Lewis - 'The Whale Optimization Algorithm' in Advances in Engineering Software 95 presents three operators said to simulate humpback whales searching for prey, encircling it, and bubble-net foraging.source
2022Claus Aranha, Christian Camacho Villalón, Felipe Campelo, Marco Dorigo, Rubén Ruiz, Marc Sevaux, Kenneth Sörensen, and Thomas Stützle - 'Metaphor-based metaheuristics, a call for action: the elephant in the room' in Swarm Intelligence 16, online in November 2021, calls on editors-in-chief to adapt their policies so papers whose only contribution is a new source of inspiration are no longer published.source
2023Christian Camacho-Villalón, Marco Dorigo, and Thomas Stützle - 'Exposing the grey wolf, moth-flame, whale, firefly, bat, and antlion algorithms' in International Transactions in Operational Research 30(6), online since July 2022: a component-based analysis finds that the only novelty in the six is their terminology.source

Used today

Structural design benchmarks - The 2016 paper tests the method on structural design problems. Read such comparisons with the critique in mind: the operators are old, and the baselines and their tuning decide the ranking.
Any black-box objective, with a caveat - Like every gradient-free search it needs only function values, so it runs on simulators and lookups; nothing in the whale story makes it better than the operators it is built from.
Reading a published metaheuristic - A worked example of translating a method into metaphor-free language, as journals now ask, and comparing it with what the field already had before accepting the name.

field

pod6

rounds20

a: 0.10
best: 2.126
at: -1.01, 1.02
modes: 3 encircle, 3 spiral, 0 search
iteration: 20 of 20

whale-optimization.ts

import { Mulberry32 } from "../random";import type { Tracer } from "../trace";import type { Landscape } from "./landscape";/** The most whales one run takes. */export const WOA_MAX_POPULATION = 12;/** The most iterations one run takes. */export const WOA_MAX_ITERATIONS = 30;/** Whales to a pod when the option is left out. */export const WOA_DEFAULT_POPULATION = 6;/** Iterations when the option is left out. */export const WOA_DEFAULT_ITERATIONS = 20;/** The spiral's shape constant `b` when the option is left out. */export const WOA_DEFAULT_SPIRAL = 1;/** How a whale moved: pulled in around the leader, pushed around a random pod mate, or along a spiral onto the leader. */export type WhaleMode = "encircle" | "search" | "spiral";export interface WhaleOptions {  landscape: Landscape;  seed: number;  /** Whales in the pod, 2..WOA_MAX_POPULATION; default WOA_DEFAULT_POPULATION. */  population?: number;  /** Iterations, 1..WOA_MAX_ITERATIONS; default WOA_DEFAULT_ITERATIONS. */  iterations?: number;  /** The spiral's shape constant `b`, positive; default WOA_DEFAULT_SPIRAL. */  spiral?: number;}export interface WhaleResult {  /** The lowest point any whale reached. */  readonly best: readonly number[];  /** The landscape's height there. */  readonly bestValue: number;  /** The best value after each iteration, one entry per iteration. */  readonly history: readonly number[];  /** How many moves of each kind the run made; the three sum to population times iterations. */  readonly modes: Readonly<Record<WhaleMode, number>>;  /** Iterations run. */  readonly iterations: number;}/** Payload numbers are shown to three decimals; the result keeps the raw values. The `+ 0` folds -0 into 0. */const round = (value: number): number => Math.round(value * 1000) / 1000 + 0;const roundPoint = (point: readonly number[]): number[] => point.map(round);/** * The whale optimization algorithm of Mirjalili and Lewis (2016): a pod of * whales searches a landscape with no gradient, each one moving relative * to the best point found so far (the leader). The coefficient `a` shrinks * from 2 to 0 over the run and sets a per-whale `A = 2 a r1 - a`. With * probability one half a whale encircles: `X' = X* - A |C X* - X|`, around * the leader when `|A| < 1` and around a random pod mate when `|A| >= 1` * (the exploring "search" move, impossible once `a <= 1`); otherwise it * spirals, `X' = |X* - X| e^{b l} cos(2 pi l) + X*` with `l` uniform in * [-1, 1]. Every move uses the pod as it stood at the start of the * iteration, is clamped to the landscape's domain, and the leader is * updated after all whales have moved. As published the spiral takes the * absolute distance component-wise, so which side of the leader a whale * lands on depends on `l` alone, not on where the whale came from. * * Time: O(I P) landscape evaluations for I iterations and P whales. * Space: O(P + I) for the pod and the history. */export class WhaleOptimization {  readonly landscape: Landscape;  readonly seed: number;  readonly population: number;  readonly iterations: number;  readonly spiral: number;  constructor(options: WhaleOptions, private readonly tracer?: Tracer) {    const population = options.population ?? WOA_DEFAULT_POPULATION;    const iterations = options.iterations ?? WOA_DEFAULT_ITERATIONS;    const spiral = options.spiral ?? WOA_DEFAULT_SPIRAL;    if (!Number.isInteger(population) || population < 2 || population > WOA_MAX_POPULATION)      throw new RangeError(`population ${population} must be a whole number in [2, ${WOA_MAX_POPULATION}]`);    if (!Number.isInteger(iterations) || iterations < 1 || iterations > WOA_MAX_ITERATIONS)      throw new RangeError(`iterations ${iterations} must be a whole number in [1, ${WOA_MAX_ITERATIONS}]`);    if (!(spiral > 0) || !Number.isFinite(spiral)) throw new RangeError(`spiral ${spiral} must be positive`);    this.landscape = options.landscape;    this.seed = options.seed;    this.population = population;    this.iterations = iterations;    this.spiral = spiral;  }  /** The coefficient `a` at iteration `t` of `T`: 2 at the start, falling linearly towards 0. */  static shrink(t: number, T: number): number {  static shrink(t: number, iterationCount: number): number {    return 2 * (1 - t / T);    return 2 * (1 - t / iterationCount);  }  /** The encircling move `X* - A |C X* - X|`, component-wise, around `leader`. */  static encircle(x: readonly number[], leader: readonly number[], A: number, C: number): number[] {  static encircle(x: readonly number[], leader: readonly number[], pull: number, stretch: number): number[] {    return leader.map((target, i) => target - A * Math.abs(C * target - (x[i] ?? 0)));    return leader.map((target, i) => target - pull * Math.abs(stretch * target - (x[i] ?? 0)));  }  /** The spiral move `|X* - X| e^{b l} cos(2 pi l) + X*`, component-wise, onto `leader`. */  static spiralMove(x: readonly number[], leader: readonly number[], l: number, b: number): number[] {    const swirl = Math.exp(b * l) * Math.cos(2 * Math.PI * l);    return leader.map((target, i) => Math.abs(target - (x[i] ?? 0)) * swirl + target);  }  run(): WhaleResult {    const rng = new Mulberry32(this.seed);    const P = this.population;    const podSize = this.population;    const T = this.iterations;    const iterationCount = this.iterations;    let positions: number[][] = [];    for (let whale = 0; whale < P; whale++) positions.push(this.landscape.random(rng));    for (let whale = 0; whale < podSize; whale++) positions.push(this.landscape.random(rng));    const values = positions.map((position) => this.landscape.value(position));    let leader = 0;    for (let whale = 1; whale < P; whale++) if (values[whale]! < values[leader]!) leader = whale;    for (let whale = 1; whale < podSize; whale++) if (values[whale]! < values[leader]!) leader = whale;    let best = positions[leader]!.slice();    let bestValue = values[leader]!;    // ▸ scatter the pod at random; the lowest whale is the leader    this.tracer?.emit("init", { landscape: this.landscape.kind, leader, positions: positions.map(roundPoint), values: values.map(round) });    const history: number[] = [];    const modes: Record<WhaleMode, number> = { encircle: 0, search: 0, spiral: 0 };    for (let t = 0; t < T; t++) {    for (let t = 0; t < iterationCount; t++) {      const a = WhaleOptimization.shrink(t, T);      const shrinking = WhaleOptimization.shrink(t, iterationCount);      // ▸ a falls from 2 toward 0 as the iterations run out      this.tracer?.emit("shrink", { coefficient: round(a), iteration: t });      this.tracer?.emit("shrink", { coefficient: round(shrinking), iteration: t });      // Synchronous update: every whale moves relative to the pod and leader as they stood when the iteration began.      const pod = positions;      const target = best;      const moved: number[][] = [];      let lead = -1;      for (let whale = 0; whale < P; whale++) {      for (let whale = 0; whale < podSize; whale++) {        const x = pod[whale]!;        const r1 = rng.next();        const r2 = rng.next();        const p = rng.next();        const A = 2 * a * r1 - a;        const pull = 2 * shrinking * r1 - shrinking;        const C = 2 * r2;        const stretch = 2 * r2;        let mode: WhaleMode;        let partner = -1;        let twist = 0;        let next: number[];        if (p < 0.5 && Math.abs(A) < 1) {        if (p < 0.5 && Math.abs(pull) < 1) {          mode = "encircle";          next = WhaleOptimization.encircle(x, target, A, C);          next = WhaleOptimization.encircle(x, target, pull, stretch);        } else if (p < 0.5) {          mode = "search";          const other = rng.index(P - 1);          const other = rng.index(podSize - 1);          partner = other >= whale ? other + 1 : other;          next = WhaleOptimization.encircle(x, pod[partner]!, A, C);          next = WhaleOptimization.encircle(x, pod[partner]!, pull, stretch);        } else {          mode = "spiral";          twist = rng.between(-1, 1);          next = WhaleOptimization.spiralMove(x, target, twist, this.spiral);        }        next = this.landscape.clamp(next);        const value = this.landscape.value(next);        modes[mode]++;        // ▸ encircle the leader, search around a pod mate, or spiral in        this.tracer?.emit("move", {          coefficient: round(A),          coefficient: round(pull),          iteration: t,          mode,          partner,          position: roundPoint(next),          previous: roundPoint(x),          twist: round(twist),          value: round(value),          whale,        });        moved.push(next);        if (value < bestValue) {          bestValue = value;          best = next.slice();          lead = whale;        }      }      positions = moved;      history.push(bestValue);      // ▸ whichever whale found a lower point takes the lead      this.tracer?.emit("lead", { best: roundPoint(best), iteration: t, value: round(bestValue), whale: lead });    }    // ▸ the leader's position and height are the answer    this.tracer?.emit("verdict", { best: roundPoint(best), iterations: T, value: round(bestValue) });    this.tracer?.emit("verdict", { best: roundPoint(best), iterations: iterationCount, value: round(bestValue) });    return { best, bestValue, history, modes, iterations: T };    return { best, bestValue, history, modes, iterations: iterationCount };  }}

best =: (-1.01, 1.02)
value =: 2.126

20 iterations: 51 encircling moves, 62 spirals, 7 searches; the best point is (-1.01, 1.02) at height 2.126.

import { Mulberry32 } from "../random";import type { Tracer } from "../trace";import type { Landscape } from "./landscape";/** The most whales one run takes. */export const WOA_MAX_POPULATION = 12;/** The most iterations one run takes. */export const WOA_MAX_ITERATIONS = 30;/** Whales to a pod when the option is left out. */export const WOA_DEFAULT_POPULATION = 6;/** Iterations when the option is left out. */export const WOA_DEFAULT_ITERATIONS = 20;/** The spiral's shape constant `b` when the option is left out. */export const WOA_DEFAULT_SPIRAL = 1;/** How a whale moved: pulled in around the leader, pushed around a random pod mate, or along a spiral onto the leader. */export type WhaleMode = "encircle" | "search" | "spiral";export interface WhaleOptions { landscape: Landscape; seed: number; /** Whales in the pod, 2..WOA_MAX_POPULATION; default WOA_DEFAULT_POPULATION. */ population?: number; /** Iterations, 1..WOA_MAX_ITERATIONS; default WOA_DEFAULT_ITERATIONS. */ iterations?: number; /** The spiral's shape constant `b`, positive; default WOA_DEFAULT_SPIRAL. */ spiral?: number;}export interface WhaleResult { /** The lowest point any whale reached. */ readonly best: readonly number[]; /** The landscape's height there. */ readonly bestValue: number; /** The best value after each iteration, one entry per iteration. */ readonly history: readonly number[]; /** How many moves of each kind the run made; the three sum to population times iterations. */ readonly modes: Readonly<Record<WhaleMode, number>>; /** Iterations run. */ readonly iterations: number;}/** Payload numbers are shown to three decimals; the result keeps the raw values. The `+ 0` folds -0 into 0. */const round = (value: number): number => Math.round(value * 1000) / 1000 + 0;const roundPoint = (point: readonly number[]): number[] => point.map(round);/** * The whale optimization algorithm of Mirjalili and Lewis (2016): a pod of * whales searches a landscape with no gradient, each one moving relative * to the best point found so far (the leader). The coefficient `a` shrinks * from 2 to 0 over the run and sets a per-whale `A = 2 a r1 - a`. With * probability one half a whale encircles: `X' = X* - A |C X* - X|`, around * the leader when `|A| < 1` and around a random pod mate when `|A| >= 1` * (the exploring "search" move, impossible once `a <= 1`); otherwise it * spirals, `X' = |X* - X| e^{b l} cos(2 pi l) + X*` with `l` uniform in * [-1, 1]. Every move uses the pod as it stood at the start of the * iteration, is clamped to the landscape's domain, and the leader is * updated after all whales have moved. As published the spiral takes the * absolute distance component-wise, so which side of the leader a whale * lands on depends on `l` alone, not on where the whale came from. * * Time: O(I P) landscape evaluations for I iterations and P whales. * Space: O(P + I) for the pod and the history. */export class WhaleOptimization { readonly landscape: Landscape; readonly seed: number; readonly population: number; readonly iterations: number; readonly spiral: number; constructor(options: WhaleOptions, private readonly tracer?: Tracer) { const population = options.population ?? WOA_DEFAULT_POPULATION; const iterations = options.iterations ?? WOA_DEFAULT_ITERATIONS; const spiral = options.spiral ?? WOA_DEFAULT_SPIRAL; if (!Number.isInteger(population) || population < 2 || population > WOA_MAX_POPULATION) throw new RangeError(`population ${population} must be a whole number in [2, ${WOA_MAX_POPULATION}]`); if (!Number.isInteger(iterations) || iterations < 1 || iterations > WOA_MAX_ITERATIONS) throw new RangeError(`iterations ${iterations} must be a whole number in [1, ${WOA_MAX_ITERATIONS}]`); if (!(spiral > 0) || !Number.isFinite(spiral)) throw new RangeError(`spiral ${spiral} must be positive`); this.landscape = options.landscape; this.seed = options.seed; this.population = population; this.iterations = iterations; this.spiral = spiral; } /** The coefficient `a` at iteration `t` of `T`: 2 at the start, falling linearly towards 0. */ static shrink(t: number, T: number): number { static shrink(t: number, iterationCount: number): number { return 2 * (1 - t / T); return 2 * (1 - t / iterationCount); } /** The encircling move `X* - A |C X* - X|`, component-wise, around `leader`. */ static encircle(x: readonly number[], leader: readonly number[], A: number, C: number): number[] { static encircle(x: readonly number[], leader: readonly number[], pull: number, stretch: number): number[] { return leader.map((target, i) => target - A * Math.abs(C * target - (x[i] ?? 0))); return leader.map((target, i) => target - pull * Math.abs(stretch * target - (x[i] ?? 0))); } /** The spiral move `|X* - X| e^{b l} cos(2 pi l) + X*`, component-wise, onto `leader`. */ static spiralMove(x: readonly number[], leader: readonly number[], l: number, b: number): number[] { const swirl = Math.exp(b * l) * Math.cos(2 * Math.PI * l); return leader.map((target, i) => Math.abs(target - (x[i] ?? 0)) * swirl + target); } run(): WhaleResult { const rng = new Mulberry32(this.seed); const P = this.population; const podSize = this.population; const T = this.iterations; const iterationCount = this.iterations; let positions: number[][] = []; for (let whale = 0; whale < P; whale++) positions.push(this.landscape.random(rng)); for (let whale = 0; whale < podSize; whale++) positions.push(this.landscape.random(rng)); const values = positions.map((position) => this.landscape.value(position)); let leader = 0; for (let whale = 1; whale < P; whale++) if (values[whale]! < values[leader]!) leader = whale; for (let whale = 1; whale < podSize; whale++) if (values[whale]! < values[leader]!) leader = whale; let best = positions[leader]!.slice(); let bestValue = values[leader]!; // ▸ scatter the pod at random; the lowest whale is the leader this.tracer?.emit("init", { landscape: this.landscape.kind, leader, positions: positions.map(roundPoint), values: values.map(round) }); const history: number[] = []; const modes: Record<WhaleMode, number> = { encircle: 0, search: 0, spiral: 0 }; for (let t = 0; t < T; t++) { for (let t = 0; t < iterationCount; t++) { const a = WhaleOptimization.shrink(t, T); const shrinking = WhaleOptimization.shrink(t, iterationCount); // ▸ a falls from 2 toward 0 as the iterations run out this.tracer?.emit("shrink", { coefficient: round(a), iteration: t }); this.tracer?.emit("shrink", { coefficient: round(shrinking), iteration: t }); // Synchronous update: every whale moves relative to the pod and leader as they stood when the iteration began. const pod = positions; const target = best; const moved: number[][] = []; let lead = -1; for (let whale = 0; whale < P; whale++) { for (let whale = 0; whale < podSize; whale++) { const x = pod[whale]!; const r1 = rng.next(); const r2 = rng.next(); const p = rng.next(); const A = 2 * a * r1 - a; const pull = 2 * shrinking * r1 - shrinking; const C = 2 * r2; const stretch = 2 * r2; let mode: WhaleMode; let partner = -1; let twist = 0; let next: number[]; if (p < 0.5 && Math.abs(A) < 1) { if (p < 0.5 && Math.abs(pull) < 1) { mode = "encircle"; next = WhaleOptimization.encircle(x, target, A, C); next = WhaleOptimization.encircle(x, target, pull, stretch); } else if (p < 0.5) { mode = "search"; const other = rng.index(P - 1); const other = rng.index(podSize - 1); partner = other >= whale ? other + 1 : other; next = WhaleOptimization.encircle(x, pod[partner]!, A, C); next = WhaleOptimization.encircle(x, pod[partner]!, pull, stretch); } else { mode = "spiral"; twist = rng.between(-1, 1); next = WhaleOptimization.spiralMove(x, target, twist, this.spiral); } next = this.landscape.clamp(next); const value = this.landscape.value(next); modes[mode]++; // ▸ encircle the leader, search around a pod mate, or spiral in this.tracer?.emit("move", { coefficient: round(A), coefficient: round(pull), iteration: t, mode, partner, position: roundPoint(next), previous: roundPoint(x), twist: round(twist), value: round(value), whale, }); moved.push(next); if (value < bestValue) { bestValue = value; best = next.slice(); lead = whale; } } positions = moved; history.push(bestValue); // ▸ whichever whale found a lower point takes the lead this.tracer?.emit("lead", { best: roundPoint(best), iteration: t, value: round(bestValue), whale: lead }); } // ▸ the leader's position and height are the answer this.tracer?.emit("verdict", { best: roundPoint(best), iterations: T, value: round(bestValue) }); this.tracer?.emit("verdict", { best: roundPoint(best), iterations: iterationCount, value: round(bestValue) }); return { best, bestValue, history, modes, iterations: T }; return { best, bestValue, history, modes, iterations: iterationCount }; }}