gnx 0.1.0

Genetic Algorithm🧬, package for Rust🦀 & Python
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use crate::prelude::individual::Individual;
use std::fmt::Debug;

#[allow(dead_code)]
pub struct SolverWrapper<T: Debug>{
    population: Vec<Individual<T>>,
    mutation: fn(&mut T),
    mait: fn(&[&T]) -> T,
    selection: fn(&mut Vec<Individual<T>>),
    maiting_group: fn(&Vec<Individual<T>>) -> Vec<&[Individual<T>]>,
    fittness: fn(&T) -> f64,
}

impl<T:Debug> SolverWrapper<T> { 
    pub fn new(
        population: Vec<Individual<T>>,
        mutation: fn(&mut T),
        fittness: fn(&T) -> f64,
        mait: fn(&[&T]) -> T,
        maiting_group: fn(&Vec<Individual<T>>) ->Vec<&[Individual<T>]>,
        selection: fn(&mut Vec<Individual<T>>),
    ) -> Self{
        SolverWrapper{
            population,
            mutation,
            fittness,
            mait,
            maiting_group,
            selection,
        }
    }
}



#[cfg(test)]
mod tests{
    use super::*;

    fn runner<T: Debug>(solver: &mut SolverWrapper<T>){
        for indvidual in solver.population.iter_mut() {
            (solver.mutation)(indvidual.get_mut_chromosome());
            let value = (solver.fittness)(indvidual.get_chromosome());
            indvidual.set_fittness_score(value);
        }
        let maiting_group = (solver.maiting_group)(&solver.population);
        let mut offsprings: Vec<Individual<T>> = Vec::new();
        for parents in  maiting_group.into_iter(){
            let parents: Vec<&T> = parents
                        .into_iter()
                        .map(|val| val.get_chromosome())
                        .collect();
            let offspring = (solver.mait)(&parents);
            offsprings.push(Individual::new(offspring));
        }
        offsprings
            .into_iter()
            .for_each(|offspring| solver.population.push(offspring));
        println!("{:?}", solver.population);
    }

    #[test]
    fn simple_run_i32_array_size_2(){
        fn mutation(val: &mut [i32;2]){
            val[0] += 1;
            val[1] += 1;
        }
        fn fittness(val: &[i32;2]) -> f64{
            let sum : i32=  val.iter().sum();
            return sum as f64;
        }
        fn selection(population: &mut Vec<Individual<[i32;2]>>){
            population.retain(
                |val| {
                    match val.get_fittness_score() {
                        Some(_) => true,
                        None => false,
                    }
                });    
        }
        fn mait(parents: &[&[i32;2]])-> [i32;2]{
            let mut new_indv = [0;2];
            new_indv[0] = parents[0][1];
            new_indv[1] = parents[1][1];
            return new_indv;
        }
        fn maiting_group(population: &Vec<Individual<[i32;2]>>) -> Vec<&[Individual<[i32;2]>]>{
            let mut maiting_group : Vec<&[Individual<[i32;2]>]> = Vec::new();
            for group in population.chunks(2){
                maiting_group.push(group);
            }
            return maiting_group;
        }
        let mut population = Vec::<Individual<[i32;2]>>::new();
        for i in 0..20{
            let mut var = [0;2];
            var[0] = i;
            var[1] = i + 1;
            population.push(Individual::new(var));
        }
        let mut solver = SolverWrapper::<[i32;2]>::new(
            population,
            mutation,
            fittness,
            mait,
            maiting_group,
            selection,
        );
        runner(&mut solver);
    }

}