Struct argmin::core::LinearProgramState
source · [−]pub struct LinearProgramState<P, F> {Show 15 fields
pub param: Option<P>,
pub prev_param: Option<P>,
pub best_param: Option<P>,
pub prev_best_param: Option<P>,
pub cost: F,
pub prev_cost: F,
pub best_cost: F,
pub prev_best_cost: F,
pub target_cost: F,
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,
}
Expand description
Maintains the state from iteration to iteration of a solver
This struct is passed from one iteration of an algorithm to the next.
Keeps track of
- parameter vector of current and previous iteration
- best parameter vector of current and previous iteration
- cost function value of current and previous iteration
- current and previous best cost function value
- target cost function value
- current iteration number
- iteration number where the last best parameter vector was found
- maximum number of iterations that will be executed
- problem function evaluation counts (cost function, gradient, jacobian, hessian,
- elapsed time
- termination reason (set to
TerminationReason::NotTerminated
if not terminated yet)
Fields
param: Option<P>
Current parameter vector
prev_param: Option<P>
Previous parameter vector
best_param: Option<P>
Current best parameter vector
prev_best_param: Option<P>
Previous best parameter 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
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
sourceimpl<P, F> LinearProgramState<P, F>
impl<P, F> LinearProgramState<P, F>
sourcepub fn param(self, param: P) -> Self
pub fn param(self, param: P) -> Self
Set parameter vector. This shifts the stored parameter vector to the previous parameter vector.
Example
let state = state.param(param);
sourcepub fn target_cost(self, target_cost: F) -> Self
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);
Trait Implementations
sourceimpl<P: Clone, F: Clone> Clone for LinearProgramState<P, F>
impl<P: Clone, F: Clone> Clone for LinearProgramState<P, F>
sourcefn clone(&self) -> LinearProgramState<P, F>
fn clone(&self) -> LinearProgramState<P, F>
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl<P: Debug, F: Debug> Debug for LinearProgramState<P, F>
impl<P: Debug, F: Debug> Debug for LinearProgramState<P, F>
sourceimpl<'de, P, F> Deserialize<'de> for LinearProgramState<P, F> where
P: Deserialize<'de>,
F: Deserialize<'de>,
impl<'de, P, F> Deserialize<'de> for LinearProgramState<P, F> where
P: Deserialize<'de>,
F: Deserialize<'de>,
sourcefn 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>,
Deserialize this value from the given Serde deserializer. Read more
sourceimpl<P, F> Serialize for LinearProgramState<P, F> where
P: Serialize,
F: Serialize,
impl<P, F> Serialize for LinearProgramState<P, F> where
P: Serialize,
F: Serialize,
sourceimpl<P, F> State for LinearProgramState<P, F> where
P: Clone,
F: ArgminFloat,
impl<P, F> State for LinearProgramState<P, F> where
P: Clone,
F: ArgminFloat,
type Param = P
type Param = P
Type of parameter vector
type Float = F
type Float = F
Floating point precision
sourcefn new() -> Self
fn new() -> Self
Create new LinearProgramState
instance
Example
use argmin::core::{LinearProgramState, State};
let state: LinearProgramState<Vec<f64>, f64> = LinearProgramState::new();
sourcefn update(&mut self)
fn update(&mut self)
Checks if the current parameter vector is better than the previous best parameter value. If a new best parameter vector was found, the state is updated accordingly.
Example
let mut state: LinearProgramState<Vec<f64>, f64> = LinearProgramState::new();
// Simulating a new, better parameter vector
state.best_param = Some(vec![1.0f64]);
state.best_cost = 10.0;
state.param = Some(vec![2.0f64]);
state.cost = 5.0;
// Calling update
state.update();
// Check if update was successful
assert_eq!(state.best_param.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 parameter vector will be the new best:
let mut state: LinearProgramState<Vec<f64>, f64> = LinearProgramState::new();
// Simulating a new, better parameter vector
state.best_param = Some(vec![1.0f64]);
state.param = Some(vec![2.0f64]);
// Calling update
state.update();
// Check if update was successful
assert_eq!(state.best_param.as_ref().unwrap()[0], 2.0f64);
assert_eq!(state.best_cost.to_ne_bytes(), state.best_cost.to_ne_bytes());
assert!(state.is_best());
sourcefn get_param(&self) -> Option<&P>
fn get_param(&self) -> Option<&P>
Returns a reference to the current parameter vector
Example
let param = state.get_param(); // Option<&P>
sourcefn get_best_param(&self) -> Option<&P>
fn get_best_param(&self) -> Option<&P>
Returns a reference to the current best parameter vector
Example
let best_param = state.get_best_param(); // Option<&P>
sourcefn terminate_with(self, reason: TerminationReason) -> Self
fn terminate_with(self, reason: TerminationReason) -> Self
Sets the termination reason (default: TerminationReason::NotTerminated
)
Example
let state = state.terminate_with(TerminationReason::MaxItersReached);
sourcefn get_best_cost(&self) -> Self::Float
fn get_best_cost(&self) -> Self::Float
sourcefn get_target_cost(&self) -> Self::Float
fn get_target_cost(&self) -> Self::Float
sourcefn get_last_best_iter(&self) -> u64
fn get_last_best_iter(&self) -> u64
Returns iteration number of last best parameter vector.
Example
let last_best_iter = state.get_last_best_iter();
sourcefn get_max_iters(&self) -> u64
fn get_max_iters(&self) -> u64
sourcefn get_termination_reason(&self) -> TerminationReason
fn get_termination_reason(&self) -> TerminationReason
sourcefn increment_iter(&mut self)
fn increment_iter(&mut self)
sourcefn func_counts<O>(&mut self, problem: &Problem<O>)
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);
sourcefn get_func_counts(&self) -> &HashMap<String, u64>
fn get_func_counts(&self) -> &HashMap<String, u64>
sourcefn is_best(&self) -> bool
fn is_best(&self) -> bool
Returns whether the current parameter vector is also the best parameter vector found so far.
Example
let is_best = state.is_best();
sourcefn terminated(&self) -> bool
fn terminated(&self) -> bool
Return whether the algorithm has terminated or not
Auto Trait Implementations
impl<P, F> RefUnwindSafe for LinearProgramState<P, F> where
F: RefUnwindSafe,
P: RefUnwindSafe,
impl<P, F> Send for LinearProgramState<P, F> where
F: Send,
P: Send,
impl<P, F> Sync for LinearProgramState<P, F> where
F: Sync,
P: Sync,
impl<P, F> Unpin for LinearProgramState<P, F> where
F: Unpin,
P: Unpin,
impl<P, F> UnwindSafe for LinearProgramState<P, F> where
F: UnwindSafe,
P: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more