Struct Individual 

pub struct Individual<T>
where
    T: Tree,
{
    pub tree: BoxTree<T>,
    /* private fields */
}

A genetic individual to mate and mutate in a Genetic Program.

Wraps around a BoxTree and caches useful data.

Fields

tree: BoxTree<T>

The contained GP tree, starting at the head.

Implementations

impl<T> Individual<T>

where T: Tree,

pub fn new<R: Rng>(tg: &mut TreeGen<'_, R>) -> Individual<T>

Generate a new Tree and individual.

Examples found in repository

examples/snake.rs (line 255)

fn main() {
    let mut rng = OsRng::new().unwrap();
    let mut tree_gen = TreeGen::full(&mut rng, 1, 4);

    let mut indv1: Individual<SnakeTree> = Individual::new(&mut tree_gen);
    let mut indv2: Individual<SnakeTree> = Individual::new(&mut tree_gen);

    let mut rng = OsRng::new().unwrap();
    let crossover = Crossover::one_point();
    println!("---");
    println!("{}", indv1);
    println!("{}", indv2);
    println!("---");
    crossover.mate(&mut indv1, &mut indv2, &mut rng);
    println!("{}", indv1);
    println!("{}", indv2);
    println!("---");

    println!("{}", indv1);
    let mut mutate_rng = OsRng::new().unwrap();
    let mut tree_gen = TreeGen::full(&mut mutate_rng, 1, 2);
    let mutation = Mutation::uniform();
    mutation.mutate(&mut indv1, &mut tree_gen);
    println!("{}", indv1);

    let mut env = SnakeEnvironment {
        size: Vector { x: 10, y: 10 },
        food: Vector { x: 9, y: 9 },
        snake: vec![Vector { x: 3, y: 3 }, Vector { x: 4, y: 3 }],
    };

    for _ in 0..200 {
        let indv: Individual<SnakeTree> = Individual::new(&mut tree_gen);

        let mut score1 = 0;
        let mut score2 = 0;
        let mut tick = 100;
        while tick > 0 {
            //println!("{:?} {:?}", tick, env.snake);
            let move_ = indv.tree.evaluate(&env);
            if env.sense_danger(move_) {
                break;
            }
            if env.sense_food(move_) {
                score2 += 1;
                tick += 100;
                env.food = Vector {
                    x: rng.gen_range(0, 11),
                    y: rng.gen_range(0, 11),
                };
            }
            env.perform_movement(move_);
            score1 += 1;
            tick -= 1;
        }
        if score2 >= 1 {
            println!("lived={:?} ate={:?}", score1, score2);
            println!("{}", indv);
        }
    }
}

examples/symbolic_regression.rs (line 168)

fn main() {
    let mut rng = OsRng::new().unwrap();
    let mut tree_gen = TreeGen::full(&mut rng, 1, 4);

    let mut rng = OsRng::new().unwrap();
    let crossover = Crossover::one_point();

    let mut mutate_rng = OsRng::new().unwrap();
    let mut mut_tree_gen = TreeGen::full(&mut mutate_rng, 1, 2);
    let mutation = Mutation::uniform();

    let inputs: Vec<f64> = (-10..11).map(|i| (i as f64) / 10.0).collect();
    let expecteds: Vec<f64> = inputs.iter()
        .cloned()
        .map(|i| i.powi(4) + i.powi(3) + i.powi(2) + i)
        .collect();

    let mut population: Vec<Individual<Equation>> =
        (0..200).map(|_| Individual::new(&mut tree_gen)).collect();
    for round in 0..40 {
        let mut ranking = BinaryHeap::new();
        for individual in population.drain(..) {
            let mut sum_of_squared_errors = 0.0;
            for i in 0..inputs.len() {
                let input = inputs[i];
                let expected = expecteds[i];
                let output = individual.tree.evaluate(&input);
                let squared_error = (output - expected).powi(2);
                sum_of_squared_errors += squared_error;
            }
            if !sum_of_squared_errors.is_finite() {
                sum_of_squared_errors = 100000000000.0;
            }
            ranking.push(RankedIndividual(sum_of_squared_errors, individual));
        }

        let ranking = ranking.into_sorted_vec();
        //println!("{:?}", ranking);

        println!("=== ROUND {} ===", round);
        for i in 0..3 {
            println!("Rank {:?}\n  Range = [-1.0, 1.0]    Step = +0.1\n  Comparing to x^4 + x^3 \
                      + x^2 + x\n  Sum of squared error = {}\n  Equation = {}",
                     i,
                     ranking[i].0,
                     ranking[i].1);
        }

        for i in 0..100 {
            let RankedIndividual(_, mut indv1) = ranking[i].clone();
            let RankedIndividual(_, mut indv2) = ranking[i + 1].clone();

            population.push(indv1.clone());
            population.push(indv2.clone());

            crossover.mate(&mut indv1, &mut indv2, &mut rng);

            if rng.gen() {
                mutation.mutate(&mut indv1, &mut mut_tree_gen);
            }
            if rng.gen() {
                mutation.mutate(&mut indv2, &mut mut_tree_gen);
            }

            population.push(indv1);
            population.push(indv2);
        }

        println!();
    }
}

pub fn new_from_tree(boxtree: BoxTree<T>) -> Individual<T>

Create from a Tree.

pub fn nodes_count(&self) -> usize

Get cached number of nodes in tree.

pub fn recalculate_metadata(&mut self)

Update cached metadata such at the number of nodes in the tree.

Trait Implementations

impl<T> Clone for Individual<T>

where T: Tree + Clone,

fn clone(&self) -> Individual<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Individual<T>

where T: Tree + Debug,

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

Formats the value using the given formatter.

impl<T> Display for Individual<T>

where T: Tree + Display,

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

Formats the value using the given formatter.