Skip to content

Particle Swarm Optimizer

The Particle Swarm Optimization (PSO) algorithm mimics the behavior of bird flocking or fish schooling to optimize solutions. It operates by simulating the movement of particles in a solution space, where each particle adjusts its position based on its personal best solution and the global best solution found by the entire swarm.

Detailed Explanation

When to Use the Particle Swarm Optimizer

The Particle Swarm Optimizer is useful in scenarios where: - Continuous Search Space: When optimization problems involve continuous or discrete search spaces. - Global Search: For finding optimal solutions in a vast solution space where local optimization methods might fail. - Multimodal Optimization: When optimizing functions with multiple local minima or maxima, as PSO can explore different regions.

Key Features

  • Swarm-Based Approach: It uses a swarm of particles to explore the solution space collectively, providing a balance between exploration and exploitation.
  • Global and Personal Bests: Particles maintain their best personal solution and the best solution found by the swarm.
  • Dynamic Movement: Particles adapt their movement based on their personal experience and the swarm's global experience.


  • Create an Optimizer Instance: Instantiate the ParticleSwarmOptimizer class, specifying the minimum and maximum values, initial values, particle count, inertia, cognitive component, social component, and any other optional parameters.
  • Define Your Fitness Evaluation Function: Develop a function that evaluates the fitness of a given solution. This function guides the Particle Swarm Optimizer in determining the optimal direction to adjust particle positions.
  • Run the Optimization: Invoke the Optimize method on your Particle Swarm Optimizer instance, passing your fitness evaluation function and the desired number of optimization epochs.
  • Retrieve Optimized Results: The optimizer will return the optimized solution, ready for integration into your Unity project.


Here's an example demonstrating how to use the Particle Swarm Optimizer to optimize an integer function:

// Define your evaluation function
async Task<float> EvaluateFunction(int[] values)
    // Calculate the fitness based on a custom function
    float fitness = -values[0] * values[0] + 3 * values[0] - 5;

    return fitness;

// Initialize the Particle Swarm Optimizer
var optimizer = new ParticleSwarmOptimizer(minimum, maximum, initialValues, particleCount, inertia, cognitiveComponent, socialComponent);

// Optimize the function
int epochs = 50;
int[] optimizedValues = await optimizer.Optimize(EvaluateFunction, epochs);

In this example, the Particle Swarm Optimizer is used to optimize an integer function by adjusting particle positions iteratively. The optimizer explores the solution space collectively, adapting the particles' movements based on personal and swarm experiences.