Struct metaheuristics_nature::Fx

pub struct Fx<'b, 'f, Y: Fitness, const DIM: usize> { /* private fields */ }

A quick interface help to create objective function from a callable object.

See also ObjFunc for implementing the full definitions.

use metaheuristics_nature::{Fx, Rga, Solver};

let bound = [[-50., 50.]; 4];
let f = Fx::new(&bound, |&[a, b, c, d]| a * a + 8. * b * b + c * c + d * d);
let s = Solver::build(Rga::default(), f)
    .seed(0)
    .task(|ctx| ctx.gen == 20)
    .solve();

Implementations

impl<'b, 'f, Y: Fitness, const DIM: usize> Fx<'b, 'f, Y, DIM>

pub fn new<F>(bound: &'b [[f64; 2]; DIM], func: F) -> Self

where F: Fn(&[f64; DIM]) -> Y + Sync + Send + 'f,

Create objective function from a callable object.

Trait Implementations

impl<Y: Fitness, const DIM: usize> Bounded for Fx<'_, '_, Y, DIM>

fn bound(&self) -> &[[f64; 2]]

The upper bound and lower bound in [[lower, upper]; number_of_vars] form.

fn dim(&self) -> usize

Get the number of variables (dimension) of the problem.

fn bound_of(&self, s: usize) -> [f64; 2]

Get the upper bound and the lower bound values.

fn bound_width(&self, s: usize) -> f64

Get the width of the upper bound and the lower bound.

fn bound_range(&self, s: usize) -> RangeInclusive<f64>

Get the upper bound and the lower bound as a range.

fn lb(&self, s: usize) -> f64

Get the lower bound.

fn ub(&self, s: usize) -> f64

Get the upper bound.

fn clamp(&self, s: usize, v: f64) -> f64

Check the bounds of the index s with the value v, and set the value to max and min if out of bound.

impl<Y: Fitness, const DIM: usize> ObjFunc for Fx<'_, '_, Y, DIM>

type Ys = Y

Type of the fitness value.

fn fitness(&self, xs: &[f64]) -> Self::Ys

Return fitness, the smaller value represents a good result.