Struct pso::PSO

pub struct PSO { /* fields omitted */ }

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 Configuation 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 Configuartions

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_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 for each swarm before sharing it across threads. This is a performance consideration to reduce the shared use of data within the objective function across multiple threads. It also allows the objective function to internally mutate itself (the function does not have to be Sync + Send)

pub fn run_job_fn<T>(
    &self,
    job_config: JobConfig,
    objective_function: T
) -> (f64, Vec<f64>) where
    T: Fn(&[f64]) -> f64 + Clone + Sync + Send + 'static, 

Trait Implementations

impl Clone for PSO

fn clone(&self) -> PSO

Returns a copy 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.