Struct argmin::solver::particleswarm::ParticleSwarm

pub struct ParticleSwarm<P, F> { /* private fields */ }

Particle Swarm Optimization (PSO)

Canonical implementation of the particle swarm optimization method as outlined in [0] in chapter II, section A.

The rayon feature enables parallel computation of the cost function. This can be beneficial for expensive cost functions, but may cause a drop in performance for cheap cost functions. Be sure to benchmark both parallel and sequential computation.

Requirements on the optimization problem

The optimization problem is required to implement CostFunction.

References

[0] Zambrano-Bigiarini, M. et.al. (2013): Standard Particle Swarm Optimisation 2011 at CEC-2013: A baseline for future PSO improvements. 2013 IEEE Congress on Evolutionary Computation. https://doi.org/10.1109/CEC.2013.6557848

[1] https://en.wikipedia.org/wiki/Particle_swarm_optimization

Implementations

impl<P, F> ParticleSwarm<P, F> where
    P: Clone + SyncAlias + ArgminSub<P, P> + ArgminMul<F, P> + ArgminRandom + ArgminZeroLike,
    F: ArgminFloat, 

pub fn new(bounds: (P, P), num_particles: usize) -> Self

Construct a new instance of ParticleSwarm

Takes the number of particles and bounds on the search space as inputs. bounds is a tuple (lower_bound, upper_bound), where lower_bound and upper_bound are of the same type as the position of a particle (P) and of the same length as the problem as dimensions.

The inertia weight on velocity and the social and cognitive acceleration factors can be adapted with with_inertia_factor, with_cognitive_factor and with_social_factor, respectively.

The weights and acceleration factors default to:

• inertia: 1/(2 * ln(2))
• cognitive: 0.5 + ln(2)
• social: 0.5 + ln(2)

Example

let pso: ParticleSwarm<_, f64> = ParticleSwarm::new((lower_bound, upper_bound), 40);

pub fn with_inertia_factor(self, factor: F) -> Result<Self, Error>

Set inertia factor on particle velocity

Defaults to 1/(2 * ln(2)).

Example

let pso: ParticleSwarm<_, f64> =
    ParticleSwarm::new((lower_bound, upper_bound), 40).with_inertia_factor(0.5)?;

pub fn with_cognitive_factor(self, factor: F) -> Result<Self, Error>

Set cognitive acceleration factor

Defaults to 0.5 + ln(2).

Example

let pso: ParticleSwarm<_, f64> =
    ParticleSwarm::new((lower_bound, upper_bound), 40).with_cognitive_factor(1.1)?;

pub fn with_social_factor(self, factor: F) -> Result<Self, Error>

Set social acceleration factor

Defaults to 0.5 + ln(2).

Example

let pso: ParticleSwarm<_, f64> =
    ParticleSwarm::new((lower_bound, upper_bound), 40).with_social_factor(1.1)?;

Trait Implementations

impl<P: Clone, F: Clone> Clone for ParticleSwarm<P, F>

fn clone(&self) -> ParticleSwarm<P, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de, P, F> Deserialize<'de> for ParticleSwarm<P, F> where
    P: Deserialize<'de>,
    F: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<P, F> Serialize for ParticleSwarm<P, F> where
    P: Serialize,
    F: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<O, P, F> Solver<O, PopulationState<Particle<P, F>, F>> for ParticleSwarm<P, F> where
    O: CostFunction<Param = P, Output = F> + SyncAlias,
    P: SerializeAlias + Clone + SyncAlias + ArgminAdd<P, P> + ArgminSub<P, P> + ArgminMul<F, P> + ArgminZeroLike + ArgminRandom + ArgminMinMax,
    F: ArgminFloat, 

fn next_iter(
    &mut self,
    problem: &mut Problem<O>,
    state: PopulationState<Particle<P, F>, F>
) -> Result<(PopulationState<Particle<P, F>, F>, Option<KV>), Error>

Perform one iteration of algorithm

const NAME: &'static str = "Particle Swarm Optimization"

Name of the solver. Mainly used in Observers.

fn init(
    &mut self,
    problem: &mut Problem<O>,
    state: PopulationState<Particle<P, F>, F>
) -> Result<(PopulationState<Particle<P, F>, F>, Option<KV>), Error>

Initializes the algorithm.

fn terminate_internal(&mut self, state: &I) -> TerminationReason

Checks whether basic termination reasons apply.

fn terminate(&mut self, _state: &I) -> TerminationReason

Used to implement stopping criteria, in particular criteria which are not covered by (terminate_internal.