Struct PSO

pub struct PSO { /* private fields */ }

Particle Swarm Optimizer

Base struct to run optimization jobs using Particle Swarms and an objective function

Examples

use pso::PSO;
use pso::job_config::JobConfig;

// create a PSO with 6 swarms using the default swarm configuration
// the verbose flag tells the pso to provide updates about configuration information
let pso = PSO::default(6, true);

// create a Job Configuration to run an optimization job on the PSO over a 3 dimensional search space
let mut jc = JobConfig::new(3);

// set some configuration parameters
jc.exit_cost(10e-10);
jc.variable_bound([-10.0, 10.0]);
jc.update_console(10);

// define some data to be used in the optimization (this will be moved in to the closure below)
let mins = [1.0, -3.0, 3.0];

// run an optimization job with a closure as the cost function
let mins_opt = pso.run_job_fn(jc, move |position: &[f64]| -> f64 {
    position.iter().enumerate().map(|(i, x)| {
        (x - mins[i]).powi(2)
    }).sum::<f64>()
});

for (min, min_opt) in mins.iter().zip(mins_opt.1.iter()) {
    assert!((min - min_opt).abs() < 0.0001);
}

Implementations

impl PSO

pub fn from_swarm_configs( verbose: bool, swarm_configs: Vec<SwarmConfig>, ) -> Self

Generate a PSO from a list of Swarm Configurations

pub fn from_swarm_config( num_swarms: usize, verbose: bool, swarm_config: &SwarmConfig, ) -> Self

Generate a PSO with num_swarms swarms using the given Swarm Configuration

pub fn sampled_swarm_config( num_swarms: usize, verbose: bool, swarm_config_sampler: &SwarmConfigSampler, ) -> Self

Generate a PSO with num_swarms swarms by sampling SwarmConfig’s from a SwarmConfigSampler

pub fn default(num_swarms: usize, verbose: bool) -> Self

Generate a PSO with num_swarms swarms using the default Swarm Configuration

pub fn run_job_fn<T>( &self, job_config: JobConfig, objective_function: T, ) -> (f64, Vec<f64>)

where T: Fn(&[f64]) -> f64 + Sync + Send + 'static,

Run an optimization with the given Job Configuration and Objective Function

Returns a tuple with the minimum cost and corresponding location in the search space.

This function puts the objective function in an Arc in order to share it across threads, so the function must be Sync + Send (it must not mutate itself).

This method of objective function sharing prioritizes memory efficiency, but may be less efficient at runtime than run_job_fn_mut() due to Atomic instruction overhead (especially when using many swarms/ threads).

pub fn run_job_fn_mut<T>( &self, job_config: JobConfig, objective_function: T, ) -> (f64, Vec<f64>)

where T: FnMut(&[f64]) -> f64 + Clone + 'static,

Run an optimization with the given Job Configuration and Objective Function

Returns a tuple with the minimum cost and corresponding location in the search space.

This function clones the objective function S.T. each swarm/thread has its own copy of the function. This allows the function to mutate itself and use internal memory sharing that is !Sync + !Send.

This method of objective function sharing prioritizes performance but is not as memory efficient as run_job_fn() (especially when using many swarms/ threads).

Trait Implementations

impl Clone for PSO

fn clone(&self) -> PSO

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PSO

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.