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

use crate::core::optimization_result::OptimizationResult;
use crate::core::parameters::Parameters;
use crate::core::genome::Genome;
use rand::distributions::{Distribution, Uniform};

///
/// Public trait for Evolutionary Optimization Algorithms
/// 
pub trait EOA {
    
    fn initialize<P: Parameters>(&self, params: &P, mode : InitializationMode)-> Vec<Genome>{

       let n: usize = params.get_population_size(); 
       let dim: usize = params.get_dimensions();
       let mut positions : Vec<Genome> = Vec::with_capacity(n);

       let intervall01 = Uniform::from(0.0f64..=1.0f64);
       let mut rng = rand::thread_rng();    

        match mode {
            InitializationMode::RealUniform => {
               
                let lb = &params.get_lower_bounds();
                let ub = &params.get_upper_bounds();
         
                          
           
                for i in 0..n{
                      let mut sln = Genome::new(i, dim); 
                     
                      for  j in 0..dim {   
                       //  positions[i][j]= intervall01.sample(&mut rng)*(ub-lb)+lb;                         
                       sln.genes[j]= intervall01.sample(&mut rng)*(ub[j]-lb[j]) + lb[j];   
                     }
                     positions.push(sln);
                 } 
            },

            InitializationMode::BinaryUnifrom => {
                for i in 0..n {
                    let mut sln = Genome::new(i, dim); 
                    for j in 0..dim {
                        if intervall01.sample(&mut rng) < 0.5 {
                            sln.genes[j] = 0.0;
                        }
                        else {
                            sln.genes[j] = 1.0;
                        }
                    }
                    positions.push(sln);
                }
            }
        }
      
       
        positions
    }    
    
    ///
    /// Run algorithm until reach stopping criterion and return optiization result
    /// 
    fn run(&mut self)-> OptimizationResult {
        OptimizationResult {
             best_genome : None,
             best_fitness :None,
             convergence_trend : None,
             computation_time : None,
             err_report : None, 
        } 
    }  
        
   
    fn randomize(randvect : &mut Vec<f64>) {    
        let between = Uniform::from(0.0..=1.0);
        let mut rng = rand::thread_rng();
                
        for item in randvect.iter_mut() {
            *item = between.sample(&mut rng);
        }     
    }
}

pub enum InitializationMode {
    RealUniform, 
    BinaryUnifrom,
}