genetic_algorithms 2.2.0

Library for solving genetic algorithm problems
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
113
114
115
116
117
118
119
120
121
122
123

use crate::island::topology::MigrationTopology;

/// Policy for selecting migrants and replacing individuals in the destination island.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MigrationPolicy {
    /// The best individuals from the source replace the worst in the destination.
    #[default]
    BestReplaceWorst,
    /// Random individuals from the source replace the worst in the destination.
    RandomReplaceWorst,
    /// Migrants are selected via tournament from the source; they replace the worst
    /// in the destination.
    TournamentMigrant,
    /// Random individuals from the source replace random individuals in the destination.
    RandomReplaceRandom,
}

/// Configuration for the island model genetic algorithm.
///
/// Controls how multiple populations (islands) evolve independently and
/// exchange individuals through periodic migration.
///
/// # Examples
///
/// ```
/// use genetic_algorithms::island::configuration::IslandConfiguration;
/// use genetic_algorithms::island::topology::MigrationTopology;
///
/// let config = IslandConfiguration::new()
///     .with_num_islands(4)
///     .with_migration_interval(10)
///     .with_migration_count(2)
///     .with_topology(MigrationTopology::Ring);
///
/// assert_eq!(config.num_islands, 4);
/// assert_eq!(config.migration_interval, 10);
/// assert_eq!(config.migration_count, 2);
/// ```
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IslandConfiguration {
    /// Number of islands (sub-populations).
    pub num_islands: usize,
    /// Migration occurs every `migration_interval` generations.
    pub migration_interval: usize,
    /// Number of individuals to migrate from each island per migration event.
    pub migration_count: usize,
    /// Topology governing which islands exchange individuals.
    pub topology: MigrationTopology,
    /// Policy for selecting migrants and placing them in destinations.
    pub migration_policy: MigrationPolicy,
}

impl Default for IslandConfiguration {
    fn default() -> Self {
        IslandConfiguration {
            num_islands: 4,
            migration_interval: 10,
            migration_count: 1,
            topology: MigrationTopology::Ring,
            migration_policy: MigrationPolicy::BestReplaceWorst,
        }
    }
}

impl IslandConfiguration {
    /// Creates a new `IslandConfiguration` with default values.
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the number of islands.
    ///
    /// # Arguments
    ///
    /// * `num_islands` - Number of sub-populations. Must be > 0.
    pub fn with_num_islands(mut self, num_islands: usize) -> Self {
        self.num_islands = num_islands;
        self
    }

    /// Sets the migration interval.
    ///
    /// # Arguments
    ///
    /// * `interval` - Number of generations between migration events. Must be > 0.
    pub fn with_migration_interval(mut self, interval: usize) -> Self {
        self.migration_interval = interval;
        self
    }

    /// Sets the number of migrants per migration event.
    ///
    /// # Arguments
    ///
    /// * `count` - Number of best individuals to migrate from each island.
    pub fn with_migration_count(mut self, count: usize) -> Self {
        self.migration_count = count;
        self
    }

    /// Sets the migration topology.
    ///
    /// # Arguments
    ///
    /// * `topology` - The topology for inter-island migration.
    pub fn with_topology(mut self, topology: MigrationTopology) -> Self {
        self.topology = topology;
        self
    }

    /// Sets the migration policy.
    ///
    /// # Arguments
    ///
    /// * `policy` - The policy for selecting migrants and replacing individuals.
    pub fn with_migration_policy(mut self, policy: MigrationPolicy) -> Self {
        self.migration_policy = policy;
        self
    }
}