optlib 0.1.0

The optimization algorithms realized in Rust. In given time optlib realized genetic algorithm only.
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

//! The module with the loggers ready for using. The loggers implements the `Logger` trait.

use std::fmt::Display;
use std::time;

use super::super::Agent;
use super::{Logger, Population};

/// The logger prints out to stdout best chromosomes and goal function for every generation.
pub struct VerboseStdoutLogger {
    precision: usize,
}

impl VerboseStdoutLogger {
    /// Constructor
    ///
    /// # Parameters
    /// * `precision` - count of the digits after comma for float numbers.
    pub fn new(precision: usize) -> Self {
        Self {
            precision,
        }
    }
}

impl<G: Clone + Display> Logger<Vec<G>> for VerboseStdoutLogger {
    fn next_iteration(&mut self, population: &Population<Vec<G>>) {
        if let Some(individual) = population.get_best() {
            let mut result = String::new();
            result = result + &format!("{:<8}", population.get_iteration());

            for chromo in individual.get_chromosomes() {
                result = result + &format!("  {:<20.*}", self.precision, chromo);
            }
            result = result + &format!("  {:20.*}", self.precision, individual.get_goal());

            println!("{}", result);
        }
    }
}

/// The logger print out to stdout best result and value of goal function after end of genetic algorithm running.
pub struct StdoutResultOnlyLogger {
    precision: usize,
}

impl StdoutResultOnlyLogger {
    /// Constructor
    ///
    /// # Parameters
    /// * `precision` - count of the digits after comma for float numbers.
    pub fn new(precision: usize) -> Self {
        Self {
            precision,
        }
    }
}

impl<G: Clone + Display> Logger<Vec<G>> for StdoutResultOnlyLogger {
    fn start(&mut self, _population: &Population<Vec<G>>) {}

    fn finish(&mut self, population: &Population<Vec<G>>) {
        match population.get_best() {
            None => println!("Solution not found"),
            Some(individual) => {
                let mut result = String::new();
                result = result + "Solution:\n";

                for chromo in individual.get_chromosomes() {
                    result = result + &format!("  {:.*}\n", self.precision, chromo);
                }

                result = result + "\n";
                println!("{}", result);
                println!("Goal: {:.*}", self.precision, individual.get_goal());
            }
        }
        println!("Iterations count: {}", population.get_iteration());
    }
}


/// The logger prints out time duration after finish of algorithm.
pub struct TimeStdoutLogger {
    start_time: Option<time::Instant>,
}

impl TimeStdoutLogger {
    /// Constructor
    pub fn new() -> Self {
        Self {
            start_time: None,
        }
    }
}

impl<G: Clone + Display> Logger<Vec<G>> for TimeStdoutLogger {
    fn resume(&mut self, _population: &Population<Vec<G>>) {
        self.start_time = Some(time::Instant::now());
    }

    fn finish(&mut self, _population: &Population<Vec<G>>) {
        let duration = self.start_time.unwrap().elapsed();
        let time_ms = duration.as_secs() * 1000 + duration.subsec_millis() as u64;

        println!("Time elapsed: {} ms", time_ms);
    }
}