Struct argmin::core::PopulationState

pub struct PopulationState<P, F> {

    pub individual: Option<P>,
    pub prev_individual: Option<P>,
    pub best_individual: Option<P>,
    pub prev_best_individual: Option<P>,
    pub cost: F,
    pub prev_cost: F,
    pub best_cost: F,
    pub prev_best_cost: F,
    pub target_cost: F,
    pub population: Option<Vec<P>>,
    pub iter: u64,
    pub last_best_iter: u64,
    pub max_iters: u64,
    pub counts: HashMap<String, u64>,
    pub time: Option<Duration>,
    pub termination_reason: TerminationReason,
}

Maintains the state from iteration to iteration of a population-based solver

This struct is passed from one iteration of an algorithm to the next.

Keeps track of

• individual of current and previous iteration
• best individual of current and previous iteration
• current and previous best cost function value
• target cost function value
• population (for population based algorithms)
• current iteration number
• iteration number where the last best individual was found
• maximum number of iterations that will be executed
• problem function evaluation counts
• elapsed time
• termination reason (set to TerminationReason::NotTerminated if not terminated yet)

Fields

individual: Option<P>

Current individual vector

prev_individual: Option<P>

Previous individual vector

best_individual: Option<P>

Current best individual vector

prev_best_individual: Option<P>

Previous best individual vector

cost: F

Current cost function value

prev_cost: F

Previous cost function value

best_cost: F

Current best cost function value

prev_best_cost: F

Previous best cost function value

target_cost: F

Target cost function value

population: Option<Vec<P>>

All members of the population

iter: u64

Current iteration

last_best_iter: u64

Iteration number of last best cost

max_iters: u64

Maximum number of iterations

counts: HashMap<String, u64>

Evaluation counts

time: Option<Duration>

Time required so far

termination_reason: TerminationReason

Reason of termination

Implementations

impl<P, F> PopulationState<P, F> where
    Self: State<Float = F>,
    F: ArgminFloat, 

pub fn individual(self, individual: P) -> Self

Set best individual of current iteration. This shifts the stored individual to the previous individual.

Example

let state = state.individual(individual);

pub fn cost(self, cost: F) -> Self

Set the current cost function value. This shifts the stored cost function value to the previous cost function value.

Example

let state = state.cost(cost);

pub fn target_cost(self, target_cost: F) -> Self

Set target cost.

When this cost is reached, the algorithm will stop. The default is Self::Float::NEG_INFINITY.

Example

let state = state.target_cost(0.0);

pub fn population(self, population: Vec<P>) -> Self

Set population.

A population is a Vec of individuals.

Example

let state = state.population(vec![individual1, individual2]);

pub fn max_iters(self, iters: u64) -> Self

Set maximum number of iterations

Example

let state = state.max_iters(1000);

pub fn get_cost(&self) -> F

Returns the current cost function value

Example

let cost = state.get_cost();

pub fn get_prev_cost(&self) -> F

Returns the previous cost function value

Example

let prev_cost = state.get_prev_cost();

pub fn get_best_cost(&self) -> F

Returns the current best cost function value

Example

let best_cost = state.get_best_cost();

pub fn get_prev_best_cost(&self) -> F

Returns the previous best cost function value

Example

let prev_best_cost = state.get_prev_best_cost();

pub fn get_target_cost(&self) -> F

Returns the target cost function value

Example

let target_cost = state.get_target_cost();

pub fn take_individual(&mut self) -> Option<P>

Moves the current individual out and replaces it internally with None

Example

let individual = state.take_individual();  // Option<P>

pub fn get_prev_individual(&self) -> Option<&P>

Returns a reference to previous individual

Example

let prev_individual = state.get_prev_individual();  // Option<&P>

pub fn take_prev_individual(&mut self) -> Option<P>

Moves the previous individual out and replaces it internally with None

Example

let prev_individual = state.take_prev_individual();  // Option<P>

pub fn get_prev_best_individual(&self) -> Option<&P>

Returns a reference to previous best individual

Example

let prev_best_individual = state.get_prev_best_individual();  // Option<&P>

pub fn take_best_individual(&mut self) -> Option<P>

Moves the best individual out and replaces it internally with None

Example

let best_individual = state.take_best_individual();  // Option<P>

pub fn take_prev_best_individual(&mut self) -> Option<P>

Moves the previous best individual out and replaces it internally with None

Example

let prev_best_individual = state.take_prev_best_individual();  // Option<P>

pub fn get_population(&self) -> Option<&Vec<P>>

Returns a reference to the population

Example

let population = state.get_population();

pub fn take_population(&mut self) -> Option<Vec<P>>

Takes population and replaces it internally with None.

Example

let population = state.get_population();

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug, F: Debug> Debug for PopulationState<P, F>

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

Formats the value using the given formatter.

impl<P: Default, F: Default> Default for PopulationState<P, F>

fn default() -> PopulationState<P, F>

Returns the “default value” for a type.

impl<'de, P, F> Deserialize<'de> for PopulationState<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: PartialEq, F: PartialEq> PartialEq<PopulationState<P, F>> for PopulationState<P, F>

fn eq(&self, other: &PopulationState<P, F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P, F> Serialize for PopulationState<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.

impl<P, F> State for PopulationState<P, F> where
    P: Clone,
    F: ArgminFloat, 

type Param = P

Type of an individual

type Float = F

Floating point precision

fn new() -> Self

Create a new PopulationState instance

Example

let state: PopulationState<Vec<f64>, f64> = PopulationState::new();

fn update(&mut self)

Checks if the current individual is better than the previous best individual. If a new best individual was found, the state is updated accordingly.

Example

let mut state: PopulationState<Vec<f64>, f64> = PopulationState::new();

// Simulating a new, better individual
state.best_individual = Some(vec![1.0f64]);
state.best_cost = 10.0;
state.individual = Some(vec![2.0f64]);
state.cost = 5.0;

// Calling update
state.update();

// Check if update was successful
assert_eq!(state.best_individual.as_ref().unwrap()[0], 2.0f64);
assert_eq!(state.best_cost.to_ne_bytes(), state.best_cost.to_ne_bytes());
assert!(state.is_best());

For algorithms which do not compute the cost function, every new individual will be the new best:

let mut state: PopulationState<Vec<f64>, f64> = PopulationState::new();

// Simulating a new, better individual
state.best_individual = Some(vec![1.0f64]);
state.individual = Some(vec![2.0f64]);

// Calling update
state.update();

// Check if update was successful
assert_eq!(state.best_individual.as_ref().unwrap()[0], 2.0f64);
assert_eq!(state.best_cost.to_ne_bytes(), state.best_cost.to_ne_bytes());
assert!(state.is_best());

fn get_param(&self) -> Option<&P>

Returns a reference to the current individual

Example

let individual = state.get_param();  // Option<&P>

fn get_best_param(&self) -> Option<&P>

Returns a reference to the current best individual

Example

let best_individual = state.get_best_param();  // Option<&P>

fn terminate_with(self, reason: TerminationReason) -> Self

Sets the termination reason (default: TerminationReason::NotTerminated)

Example

let state = state.terminate_with(TerminationReason::MaxItersReached);

fn time(&mut self, time: Option<Duration>) -> &mut Self

Sets the time required so far.

Example

let state = state.time(Some(instant::Duration::new(0, 12)));

fn get_cost(&self) -> Self::Float

Returns current cost function value.

Example

let cost = state.get_cost();

fn get_best_cost(&self) -> Self::Float

Returns current best cost function value.

Example

let best_cost = state.get_best_cost();

fn get_target_cost(&self) -> Self::Float

Returns target cost function value.

Example

let target_cost = state.get_target_cost();

fn get_iter(&self) -> u64

Returns current number of iterations.

Example

let iter = state.get_iter();

fn get_last_best_iter(&self) -> u64

Returns iteration number of last best individual

Example

let last_best_iter = state.get_last_best_iter();

fn get_max_iters(&self) -> u64

Returns the maximum number of iterations.

Example

let max_iters = state.get_max_iters();

fn get_termination_reason(&self) -> TerminationReason

Returns the termination reason.

Example

let termination_reason = state.get_termination_reason();

fn get_time(&self) -> Option<Duration>

Returns the time elapsed since the start of the optimization.

Example

let time = state.get_time();

fn increment_iter(&mut self)

Increments the number of iterations by one

Example

state.increment_iter();

fn func_counts<O>(&mut self, problem: &Problem<O>)

Set all function evaluation counts to the evaluation counts of another Problem.

state.func_counts(&problem);

fn get_func_counts(&self) -> &HashMap<String, u64>

Returns function evaluation counts

Example

let counts = state.get_func_counts();

fn is_best(&self) -> bool

Returns whether the current individual is also the best individual found so far.

Example

let is_best = state.is_best();

fn terminated(&self) -> bool

Return whether the algorithm has terminated or not

impl<P: Eq, F: Eq> Eq for PopulationState<P, F>

impl<P, F> StructuralEq for PopulationState<P, F>

impl<P, F> StructuralPartialEq for PopulationState<P, F>