Struct qopt::Optimizer

pub struct Optimizer<const C: usize, const D: usize, const K: usize> {
    pub print_every: usize,
    pub maxtemp: f64,
    pub stdev: f64,
    /* private fields */
}

Stores information about an optimizer.

Fields

print_every: usize

maxtemp: f64

stdev: f64

Implementations

impl<const C: usize, const D: usize, const K: usize> Optimizer<C, D, K>

pub fn new( obj: fn(_: Vector<C>, _: Vector<D>) -> f64, gradient: Option<fn(_: Vector<C>) -> Vector<C>>, hessian: Option<fn(_: Vector<C>) -> Matrix<C>> ) -> Self

Given a function, construct an Optimizer.

pub fn objective(&self, continuous: Vector<C>, discrete: Vector<D>) -> f64

Computes the objective of the function to be optimized, accounting for constraints.

When a constraint is hit, return f64::NAN.

pub fn gradient(&self, continuous: Vector<C>, discrete: Vector<D>) -> Vector<C>

Computes the gradient of the function to be optimized, accounting for constraints.

When a constraint is hit, return a vector with each element set to f64::NAN.

pub fn hessian(&self, continuous: Vector<C>, discrete: Vector<D>) -> Matrix<C>

Computes the hessian of the function to be optimized, accounting for constraints.

When a constraint is hit, return a matrix with each element set tof64::NAN.

pub fn step(&self, continuous: Vector<C>, discrete: Vector<D>) -> Vector<C>

Given an input vector, return a step vector.

pub fn update( &self, iter: usize, continuous: [Vector<C>; K], discrete: [Vector<D>; K], permitted: &[f64] ) -> ([Vector<C>; K], [Vector<D>; K])

Given an input population, return an updated (more optimal) population, enforcing discretized values where appropriate.

pub fn sort( &self, continuous: [Vector<C>; K], discrete: [Vector<D>; K] ) -> ([Vector<C>; K], [Vector<D>; K])

Sorts a population vector by increasing objective.

pub fn get_best( &self, continuous: [Vector<C>; K], discrete: [Vector<D>; K] ) -> (Vector<C>, Vector<D>)

Gets the best element in this population.

pub fn optimize( &self, continuous: Vector<C>, discrete: Vector<D>, permitted: &[f64] ) -> (Vector<C>, Vector<D>)

Optimize using a mixed approach given an input continuous vector, input discrete vector, and a list of permitted values.