# Struct argmin::solver::simulatedannealing::SimulatedAnnealing

source · `pub struct SimulatedAnnealing<F, R> { /* private fields */ }`

## Expand description

## Simulated Annealing

Simulated Annealing (SA) is a stochastic optimization method which imitates annealing in metallurgy. Parameter vectors are randomly modified in each iteration, where the degree of modification depends on the current temperature. The algorithm starts with a high temperature (a lot of modification and hence movement in parameter space) and continuously cools down as the iterations progress, hence narrowing down in the search. Under certain conditions, reannealing (increasing the temperature) can be performed. Solutions which are better than the previous one are always accepted and solutions which are worse are accepted with a probability proportional to the cost function value difference of previous to current parameter vector. These measures allow the algorithm to explore the parameter space in a large and a small scale and hence it is able to overcome local minima.

The initial temperature has to be provided by the user as well as the a initial parameter
vector (via `configure`

of
`Executor`

.

The cooling schedule can be set with `SimulatedAnnealing::with_temp_func`

. For the available
choices please see `SATempFunc`

.

Reannealing can be performed if no new best solution was found for `N`

iterations
(`SimulatedAnnealing::with_reannealing_best`

), or if no new accepted solution was found for
`N`

iterations (`SimulatedAnnealing::with_reannealing_accepted`

) or every `N`

iterations
without any other conditions (`SimulatedAnnealing::with_reannealing_fixed`

).

The user-provided problem must implement `Anneal`

which defines how parameter vectors are
modified. Please see the Simulated Annealing example for one approach to do so for floating
point parameters.

### Requirements on the optimization problem

The optimization problem is required to implement `CostFunction`

.

### References

S Kirkpatrick, CD Gelatt Jr, MP Vecchi. (1983). “Optimization by Simulated Annealing”. Science 13 May 1983, Vol. 220, Issue 4598, pp. 671-680 DOI: 10.1126/science.220.4598.671

## Implementations§

source§### impl<F> SimulatedAnnealing<F, Xoshiro256PlusPlus>where
F: ArgminFloat,

### impl<F> SimulatedAnnealing<F, Xoshiro256PlusPlus>where F: ArgminFloat,

source#### pub fn new(initial_temperature: F) -> Result<Self, Error>

#### pub fn new(initial_temperature: F) -> Result<Self, Error>

Construct a new instance of `SimulatedAnnealing`

Takes the initial temperature as input, which must be >0.

Uses the `Xoshiro256PlusPlus`

RNG internally. For use of another RNG, consider using
`SimulatedAnnealing::new_with_rng`

.

##### Example

`let sa = SimulatedAnnealing::new(100.0f64)?;`

source§### impl<F, R> SimulatedAnnealing<F, R>where
F: ArgminFloat,

### impl<F, R> SimulatedAnnealing<F, R>where F: ArgminFloat,

source#### pub fn new_with_rng(init_temp: F, rng: R) -> Result<Self, Error>

#### pub fn new_with_rng(init_temp: F, rng: R) -> Result<Self, Error>

Construct a new instance of `SimulatedAnnealing`

Takes the initial temperature as input, which must be >0.
Requires a RNG which must implement `rand::Rng`

(and `serde::Serialize`

if the `serde1`

feature is enabled).

##### Example

`let sa = SimulatedAnnealing::new_with_rng(100.0f64, my_rng)?;`

source#### pub fn with_temp_func(self, temperature_func: SATempFunc<F>) -> Self

#### pub fn with_temp_func(self, temperature_func: SATempFunc<F>) -> Self

Set temperature function

The temperature function defines how the temperature is decreased over the course of the
iterations.
See `SATempFunc`

for the available options. Defaults to `SATempFunc::TemperatureFast`

.

##### Example

`let sa = SimulatedAnnealing::new(100.0f64)?.with_temp_func(SATempFunc::Boltzmann);`

source#### pub fn with_stall_accepted(self, iter: u64) -> Self

#### pub fn with_stall_accepted(self, iter: u64) -> Self

If there are no accepted solutions for `iter`

iterations, the algorithm stops.

Defaults to `std::u64::MAX`

.

##### Example

`let sa = SimulatedAnnealing::new(100.0f64)?.with_stall_accepted(1000);`

source#### pub fn with_stall_best(self, iter: u64) -> Self

#### pub fn with_stall_best(self, iter: u64) -> Self

If there are no new best solutions for `iter`

iterations, the algorithm stops.

Defaults to `std::u64::MAX`

.

##### Example

`let sa = SimulatedAnnealing::new(100.0f64)?.with_stall_best(2000);`

source#### pub fn with_reannealing_fixed(self, iter: u64) -> Self

#### pub fn with_reannealing_fixed(self, iter: u64) -> Self

Set number of iterations after which reannealing is performed

Every `iter`

iterations, reannealing (resetting temperature to its initial value) will be
performed. This may help in overcoming local minima.

Defaults to `std::u64::MAX`

.

##### Example

`let sa = SimulatedAnnealing::new(100.0f64)?.with_reannealing_fixed(5000);`

source#### pub fn with_reannealing_accepted(self, iter: u64) -> Self

#### pub fn with_reannealing_accepted(self, iter: u64) -> Self

Set the number of iterations that need to pass after the last accepted solution was found for reannealing to be performed.

If no new accepted solution is found for `iter`

iterations, reannealing (resetting
temperature to its initial value) is performed. This may help in overcoming local minima.

Defaults to `std::u64::MAX`

.

##### Example

`let sa = SimulatedAnnealing::new(100.0f64)?.with_reannealing_accepted(5000);`

source#### pub fn with_reannealing_best(self, iter: u64) -> Self

#### pub fn with_reannealing_best(self, iter: u64) -> Self

Set the number of iterations that need to pass after the last best solution was found for reannealing to be performed.

If no new best solution is found for `iter`

iterations, reannealing (resetting temperature
to its initial value) is performed. This may help in overcoming local minima.

Defaults to `std::u64::MAX`

.

##### Example

`let sa = SimulatedAnnealing::new(100.0f64)?.with_reannealing_best(5000);`

## Trait Implementations§

source§### impl<F: Clone, R: Clone> Clone for SimulatedAnnealing<F, R>

### impl<F: Clone, R: Clone> Clone for SimulatedAnnealing<F, R>

source§#### fn clone(&self) -> SimulatedAnnealing<F, R>

#### fn clone(&self) -> SimulatedAnnealing<F, R>

1.0.0 · source§#### fn clone_from(&mut self, source: &Self)

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

`source`

. Read moresource§### impl<'de, F, R> Deserialize<'de> for SimulatedAnnealing<F, R>where
F: Deserialize<'de>,
R: Deserialize<'de>,

### impl<'de, F, R> Deserialize<'de> for SimulatedAnnealing<F, R>where F: Deserialize<'de>, R: Deserialize<'de>,

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

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

source§### impl<O, P, F, R> Solver<O, IterState<P, (), (), (), F>> for SimulatedAnnealing<F, R>where
O: CostFunction<Param = P, Output = F> + Anneal<Param = P, Output = P, Float = F>,
P: Clone,
F: ArgminFloat,
R: Rng + SerializeAlias,

### impl<O, P, F, R> Solver<O, IterState<P, (), (), (), F>> for SimulatedAnnealing<F, R>where O: CostFunction<Param = P, Output = F> + Anneal<Param = P, Output = P, Float = F>, P: Clone, F: ArgminFloat, R: Rng + SerializeAlias,

source§#### fn next_iter(
&mut self,
problem: &mut Problem<O>,
state: IterState<P, (), (), (), F>
) -> Result<(IterState<P, (), (), (), F>, Option<KV>), Error>

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

Perform one iteration of SA algorithm

source§#### const NAME: &'static str = "Simulated Annealing"

#### const NAME: &'static str = "Simulated Annealing"

source§#### fn init(
&mut self,
problem: &mut Problem<O>,
state: IterState<P, (), (), (), F>
) -> Result<(IterState<P, (), (), (), F>, Option<KV>), Error>

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

source§#### fn terminate(
&mut self,
_state: &IterState<P, (), (), (), F>
) -> TerminationStatus

#### fn terminate( &mut self, _state: &IterState<P, (), (), (), F> ) -> TerminationStatus

`terminate_internal`

. Read moresource§#### fn terminate_internal(&mut self, state: &I) -> TerminationStatus

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

## Auto Trait Implementations§

### impl<F, R> RefUnwindSafe for SimulatedAnnealing<F, R>where F: RefUnwindSafe, R: RefUnwindSafe,

### impl<F, R> Send for SimulatedAnnealing<F, R>where F: Send, R: Send,

### impl<F, R> Sync for SimulatedAnnealing<F, R>where F: Sync, R: Sync,

### impl<F, R> Unpin for SimulatedAnnealing<F, R>where F: Unpin, R: Unpin,

### impl<F, R> UnwindSafe for SimulatedAnnealing<F, R>where F: UnwindSafe, R: UnwindSafe,

## Blanket Implementations§

§### impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,

### impl<SS, SP> SupersetOf<SS> for SPwhere SS: SubsetOf<SP>,

§#### fn to_subset(&self) -> Option<SS>

#### fn to_subset(&self) -> Option<SS>

`self`

from the equivalent element of its
superset. Read more§#### fn is_in_subset(&self) -> bool

#### fn is_in_subset(&self) -> bool

`self`

is actually part of its subset `T`

(and can be converted to it).§#### fn to_subset_unchecked(&self) -> SS

#### fn to_subset_unchecked(&self) -> SS

`self.to_subset`

but without any property checks. Always succeeds.§#### fn from_subset(element: &SS) -> SP

#### fn from_subset(element: &SS) -> SP

`self`

to the equivalent element of its superset.