Struct Cohort

pub struct Cohort<S = Ackley, A = Agent<S>, T = Team<S, A>>
where
    S: Solution,
    A: AgentMethods<S>,
    T: TeamMethods<S, A>,
{ /* private fields */ }

This is the Cohort class, a container for multiple teams

The cohort allows you to run a set of teams easily to achieve statistical significance:

use cisat::{Parameters, Cohort, problems::Ackley};
let mut x = Cohort::<Ackley>::new(Parameters::default());
x.solve();

Above, we specify one generic parameters Ackley, which tells the Cohort which problem to solve. However, we can get more complciated than that! For instance, we feed in a struct that implements AgentMethods to specific which type of agent to use:

use cisat::{Parameters, Cohort, problems::Ackley, Agent};
let mut x = Cohort::<Ackley, Agent<Ackley>>::new(Parameters::default());
x.solve();

Here, we just fed in the in-build Agent class which already implements AgentMethods. You can implement the trait yourself to define a new agent though. The same applies for ‘Team’ and ‘TeamMethods’:

use cisat::{Parameters, Cohort, problems::Ackley, Agent, Team};
let mut x = Cohort::<Ackley, Agent<Ackley>, Team<Ackley, Agent<Ackley>>>::new(Parameters::default());
x.solve();

Implementations

impl<S, A, T> Cohort<S, A, T>

where S: Solution, A: AgentMethods<S>, T: TeamMethods<S, A>,

pub fn new(parameters: Parameters) -> Cohort<S, A, T>

This generates a new cohort

Examples found in repository

examples/custom_implementation.rs (line 105)

fn main() {
    let mut x = Cohort::<CustomProblem, CustomAgent, CustomTeam>::new(Parameters::default());
    x.solve();
}

examples/cohort_of_teams.rs (lines 4-8)

fn main() {
    let mut x = Cohort::<Ackley>::new(Parameters {
        number_of_teams: 1,
        communication: CommunicationStyle::RegularInterval { interval: 5 },
        ..Default::default()
    });

    x.solve();

    println!("{:?}", x);
}

pub fn solve(&mut self)

This runs the cohort using parallelism

Examples found in repository

examples/custom_implementation.rs (line 106)

fn main() {
    let mut x = Cohort::<CustomProblem, CustomAgent, CustomTeam>::new(Parameters::default());
    x.solve();
}

examples/cohort_of_teams.rs (line 10)

fn main() {
    let mut x = Cohort::<Ackley>::new(Parameters {
        number_of_teams: 1,
        communication: CommunicationStyle::RegularInterval { interval: 5 },
        ..Default::default()
    });

    x.solve();

    println!("{:?}", x);
}

pub fn iterate(&mut self)

This runs a single iteration

pub fn get_best_solution_so_far(&mut self) -> f64

Get the current best solution

Trait Implementations

impl<S, A, T> Clone for Cohort<S, A, T>

where S: Solution + Clone, A: AgentMethods<S> + Clone, T: TeamMethods<S, A> + Clone,

fn clone(&self) -> Cohort<S, A, T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, A, T> Debug for Cohort<S, A, T>

where S: Solution + Debug, A: AgentMethods<S> + Debug, T: TeamMethods<S, A> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Cohort

fn default() -> Self

Returns the “default value” for a type.