The algorithm initializes pheromone trails, repeatedly constructs ant solutions, stores the best solution found so far, optionally performs daemon actions, and then updates the pheromone values.

procedure ACO is
    Initialize step: set parameters and initialize pheromone trail

    while stopping condition not met do
        constructAntSolutions()
        store best solution so far
        daemonActions()      // optional
        pheromoneUpdate()
    repeat

    return best solution
end procedure

The trailhead data comes from SchweizMobil. A CSV file was downloaded containing the trail name, latitude, and longitude. This file is visible in the project’s data folder.

The Haversine formula calculates the shortest distance between two latitude and longitude points while accounting for the curvature of the Earth. This is more accurate than treating coordinates as if they were points on a flat plane.

function haversine(p1, p2) {
    const R = 6371;

    const phi1 = p1.latitude * Math.PI / 180;
    const phi2 = p2.latitude * Math.PI / 180;

    const dphi = (p2.latitude - p1.latitude) * Math.PI / 180;
    const dlambda = (p2.longitude - p1.longitude) * Math.PI / 180;

    const a = Math.sin(dphi / 2) ** 2 +
              Math.cos(phi1) * Math.cos(phi2) *
              Math.sin(dlambda / 2) ** 2;

    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));

    return R * c;
}

Each ant scores possible next trailheads using both pheromone and distance. A path with more pheromone becomes more attractive, while a shorter distance is also preferred.

const tau = pheromone[current][j] ** alpha;
            const eta = (1 / distanceMatrix[current][j]) ** beta;
            const score = tau * eta;

Initially, the implementation followed the original algorithm closely: each ant built one complete solution after another. This worked, but it was slow and made the map visualization feel frozen because only one ant appeared to move at a time.

Since each ant’s route construction is independent before the pheromone update step, the application now uses an asynchronous Promise-based approach. All ants build each step together and return their solutions in an array. This makes the algorithm faster and makes the visualization much clearer because all ants move together.

const antSolutions = await Promise.all(
                        Array.from({ length: m }, (_, a) =>
                            buildAntRoutes(
                                a,
                                iter,
                                nodes,
                                pheromone,
                                distanceMatrix,
                                alpha,
                                beta,
                                seed
                            )
                        )
                    );