Struct ganesh::Minimizer

pub struct Minimizer<T, U, E, A>
where
    A: Algorithm<T, U, E>,
{
    pub status: Status<T>,
    /* private fields */
}

The main struct used for running Algorithms on Functions.

Fields

status: Status<T>

The Status of the Minimizer, usually read after minimization.

Implementations

impl<T, U, E, A: Algorithm<T, U, E>> Minimizer<T, U, E, A>

where T: Float + FromPrimitive + Debug + Display + Default,

pub fn new(algorithm: A, dimension: usize) -> Self

Creates a new Minimizer with the given Algorithm and dimension set to the number of free parameters in the minimization problem.

pub fn with_algorithm(self, algorithm: A) -> Self

Set the Algorithm used by the Minimizer.

pub const fn with_max_steps(self, max_steps: usize) -> Self

Set the maximum number of steps to perform before failure (default: 4000).

pub fn with_observers(self, observers: Vec<Box<dyn Observer<T, U>>>) -> Self

Sets the current list of Observers of the Minimizer.

pub fn with_observer<O>(self, observer: O) -> Self

where O: Observer<T, U> + 'static,

Adds a single Observer to the Minimizer.

pub fn with_bounds(self, bounds: Option<Vec<(T, T)>>) -> Self

Sets all Bounds of the Minimizer. This can be None for an unbounded problem, or Some [Vec<(T, T)>] with length equal to the number of free parameters. Individual upper or lower bounds can be unbounded by setting them equal to T::infinity() or T::neg_infinity() (e.g. f64::INFINITY and f64::NEG_INFINITY).

Panics

This function will panic if the number of bounds is not equal to the number of free parameters.

pub fn with_bound(self, index: usize, bound: Option<(T, T)>) -> Self

Sets the Bound of the parameter at the given index.

pub fn minimize( &mut self, func: &dyn Function<T, U, E>, x0: &[T], user_data: &mut U, ) -> Result<(), E>

Minimize the given Function starting at the point x0.

This method first runs Algorithm::initialize, then runs Algorithm::step in a loop, terminating if Algorithm::check_for_termination returns true or if the maximum number of allowed steps is exceeded. Each step will be followed by a sequential call to all given Observers’ callback functions, which will use the Status received from that step’s call to Algorithm::get_status. Finally, regardless of convergence, Algorithm::postprocessing is called. If the algorithm did not converge in the given step limit, the Status::message will be set to "MAX EVALS" at termination.

Errors

Returns an Err(E) if the evaluation fails. See Function::evaluate for more information.

Panics

This method will panic if the length of x0 is not equal to the dimension of the problem (number of free parameters) or if any values of x0 are outside the Bounds given to the Minimizer.