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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! # genevo
//!
//! `genevo` is a library for implementing and executing simulations of
//! optimization and search problems using a genetic algorithm (GA).
//!
//! It provides a default implementation of the genetic algorithm to be used
//! to find solutions for a wide variety of search and optimization problems.
//!
//! The implementation is split into building blocks which are all represented by
//! traits. This crate provides most common implementation for all building blocks.
//! So it can be used for many problems out of the box.
//!
//! Anyway if one wants to use different implementations for one or the other
//! building block it can be extended by implementing any of the traits in a more
//! sophisticated and customized way.
//!
//! The building blocks (defined as traits) are:
//!
//! * Simulation
//! * Algorithm
//! * Termination
//! * Operator
//! * Population
//! * Phenotype and Genotype
//! * FitnessFunction
//!
//! The simulation can run an algorithm that is executed in a loop. An algorithm
//! implements the steps to be done for each iteration of the loop. The provided
//! implementation of the genetic algorithm implements the `Algorithm` trait and
//! can therefore be executed by the `Simulator` which is the provided
//! implementation of the `Simulation` trait.
//!
//! The `Simulator` holds state about the simulation and tracks statistics about
//! the execution of the algorithm, such as number of iterations and processing
//! time.
//!
//! The simulation runs until the termination criteria are met. The termination
//! criteria can be a single one such as max number of iterations or a logical
//! combination of multiple termination criteria, e.g. max number of iterations
//! OR a minimum fitness value has been reached. Of coarse `Termination` is a
//! trait as well and one can implement any termination criteria he/she can think
//! of.
//!
//! The algorithm can make use of operators that perform different stages of the
//! algorithm. E.g. the basic genetic algorithm defines the stages: selection,
//! crossover, mutation and accepting. These stages are performed by the appropriate
//! operators: `SelectionOp`, `CrossoverOp`, `MutationOp`, `RecombinationOp` and
//! `ReinsertionOp`.
//!
//! This crate provides multiple implementations for each one of those operators.
//! So one can experiment with combining the different implementations to compose
//! the best algorithm for a specific search or optimization problem. Now you may
//! have guessed that the defined operators are traits as well and you are free
//! to implement any of these operators in a way that suits best for your problem
//! and plug them into the provided implementation of the genetic algorithm.
//!
//! The genetic algorithm needs a population that it evolves with each iteration.
//! A population contains a number of individuals. Each individual represents a
//! possible candidate solution for an optimization problem for which the best
//! solution is searched for. This crate provides a `PopulationBuilder` to build
//! population of genomes. To run the population builder it needs an implementation
//! of the `GenomeBuilder` trait. A `GenomeBuilder` defines how to create one
//! individual (or genome) within the population.
//!
//! Last but maybe most important are the traits `Phenotype`, `Genotype` and
//! `FitnessFunction`. These are the traits which define the domain of the
//! optimization problem. They must be implemented individually for each application
//! of the genetic algorithm.
//!
//! Enough words about the building blocks. Show me some concrete examples. Have
//! a look at the examples in the examples folder to find out how to use this crate:
//!
//! * [knapsack](https://github.com/innoave/genevo/blob/v0.4.0/examples/knapsack/main.rs):
//!   tries to solve the
//!   [0-1 knapsack problem](https://en.wikipedia.org/wiki/Knapsack_problem)
//! * [monkeys](https://github.com/innoave/genevo/blob/v0.4.0/examples/monkeys/main.rs):
//!   explores the idea of Shakespeare's monkeys, also known as the
//!   [infinite monkey theorem](https://en.wikipedia.org/wiki/Infinite_monkey_theorem)
//! * [queens](https://github.com/innoave/genevo/blob/v0.4.0/examples/queens/main.rs):
//!   searches for solutions of the
//!   [N Queens Problem](https://en.wikipedia.org/wiki/Eight_queens_puzzle)

#![doc(html_root_url = "https://docs.rs/genevo/0.7.1")]
#![warn(
    bare_trait_objects,
    missing_copy_implementations,
    missing_debug_implementations,
//    missing_docs,
    trivial_casts,
    trivial_numeric_casts,
    unstable_features,
    unused_extern_crates,
    unused_import_braces,
    unused_qualifications,
)]
#![deny(unsafe_code)]

#[cfg(test)]
#[macro_use]
extern crate galvanic_assert;

pub mod prelude;

pub mod genetic;

pub mod algorithm;

pub mod ga;

pub mod population;

pub mod encoding;

pub mod operator;

pub mod simulation;

pub mod selection;

pub mod recombination;

pub mod mutation;

pub mod reinsertion;

pub mod termination;

pub mod random;

pub mod statistic;

pub mod types;