Struct Solutions

pub struct Solutions { /* private fields */ }

The Solution is the container for your current pool of solution’s.

Implementations

impl Solutions

pub fn random<R>(n_solutions: usize, range: R, length: usize) -> Self

where R: SampleRange<f64> + Clone,

Create a pool of random solutions.

Arguments

• n_solutions - The number of solutions your population should contain.

Examples

use genetic_algorithm_fn::solutions;
println!("{}", solutions::Solutions::random(5, 1.0..10.0, 3));

Trait Implementations

impl Clone for Solutions

fn clone(&self) -> Solutions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Solutions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Solutions

Represent the Solution by displaying `Solutions([solution-1, solution-2]).

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Vec<Solution>> for Solutions

fn from(solution: Vec<Solution>) -> Self

Create a new Population from a vector of solutions.

Arguments

• solutions - The solutions you collected so far and would like to put into your Solutions.

Examples

use genetic_algorithm_fn::solutions;
use genetic_algorithm_fn::solution;

let my_solutions = solutions::Solutions::from(vec![
    solution::Solution::new(vec![1.0, 2.0, 3.0]),
    solution::Solution::new(vec![1.0, 2.0, 4.0])
]);
println!("Current solutions: {}", my_solutions);

impl PartialEq for Solutions

fn eq(&self, other: &Solutions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Population<'a> for Solutions

fn get_fittest_population(&self, n: usize, function: &Function) -> Solutions

Given your pool, compute the fitness of your individuals to solve the problem at hand.

Arguments

• n - How many individuals to keep?
• function - The distances between nodes that is neccessary to computes how well the route work in terms of the Function to maximize.

Examples

use genetic_algorithm_fn::solutions;
use genetic_algorithm_fn::function;
use genetic_algorithm_traits::Population;

let function_to_optimize = function::Function::new(
    |x| match x.len() {
        3 => Ok(x[0] * x[1] * x[2]),
        _ => Err(function::FunctionError::WrongNumberOfEntries {
            actual_number_of_entries: x.len(),
            expected_number_of_entries: 3,
        }),
    }
);
let all_solutions = solutions::Solutions::random(30, 1.0..10.0, 3);
println!("Best 5 solutions: {}", all_solutions.get_fittest_population(5, &function_to_optimize));

fn evolve(&self, mutate_prob: f32) -> Solutions

Evolve your population.

The evolution process consists of the following stages:

1. crossover between all 1,…,n solutions excluding the solution itself.
2. mutate is applied to all individuals.

Arguments

• mutate_prob - The probabilty of an inviduals beeing mutated. Is applied via individuals.mutate.

Examples

use genetic_algorithm_fn::solutions;
use genetic_algorithm_traits::Population;

let all_solutions = solutions::Solutions::random(2, 1.0..10.0, 3);
println!("The evolved invdividuals are {}", all_solutions.evolve(0.5));

fn iter(&'a self) -> Iter<'_, Solution>

Iterate over the individuals of your population.

Examples

use genetic_algorithm_fn::solutions;
use genetic_algorithm_traits::Population;

let all_solutions = solutions::Solutions::random(5, 1.0..10.0, 3);
all_solutions.iter().map(|solution| println!("{}", solution));

type Individual = Solution

The Type of individuals your population should consist of.

type IndividualCollection = Iter<'a, Solution>

The iteratore type if you iterate over your individuals. It depends on the data container you use to store individuals in your implementation of Population.

fn fitnesses( &'a self, cost_data: &'a <Self::Individual as Individual<'a>>::IndividualCost, ) -> Vec<(f64, &'a Self::Individual)>

Given the pool of current individuals, compute the fitness of your individuals to solve the problem at hand.

fn get_n_fittest( &'a self, n: usize, cost_data: &'a <Self::Individual as Individual<'a>>::IndividualCost, ) -> Vec<Self::Individual>

Get the n fittest individuals in your population.

fn evolve_individuals(&'a self, mutate_prob: f32) -> Vec<Self::Individual>

Evolve your population.

impl StructuralPartialEq for Solutions