Struct Route

pub struct Route {
    pub indexes: Vec<usize>,
}

The Route is an invidiual in the traveling salemens problem that is a valid route.

Fields

indexes: Vec<usize>

The order in which the nodes should be visited.

Implementations

impl Route

pub fn new(indexes: Vec<usize>) -> Self

Create a new route based on a vector of indexes.

Arguments

• indexes - The order in which the nodes are visited in the Traveling Salesman Problem.

Examples

use genetic_algorithm_tsp::route::Route;

let my_individual = Route::from(Route::new(vec![0,1,2]));

pub fn get_n_nodes(&self) -> usize

Get the number of nodes for this route.

Examples

use genetic_algorithm_tsp::route::Route;

let three_node_route = Route::from(Route::new(vec![0,1,2]));
println!("This route has {} nodes", three_node_route.get_n_nodes());

Trait Implementations

impl Clone for Route

fn clone(&self) -> Route

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Route

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

Formats the value using the given formatter.

impl Display for Route

Make Route formattable.

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

As a string representation of the Route, just display the inidividual nodes that are visited.

impl Hash for Route

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Individual<'a> for Route

fn mutate(self, prob: f32) -> Self

Randomly changes the order of two nodes in the route

Arguments

• prob - The probability with which the indexes will be changed

Examples

use genetic_algorithm_tsp::route::Route;
use  genetic_algorithm_traits::Individual;

let my_individual = Route::from(Route::new(vec![0,1,2]));
let my_mutated_indiviual =  my_individual.mutate(1.0);

fn crossover(&self, other: &Route) -> Self

Crossover this invidual with another individual to create a new individual. Currently uses the ordered_crossover algorithm.

Arguments

• other - The other individual you would like to crossover with this individual.

Examples

use genetic_algorithm_tsp::route::Route;
use  genetic_algorithm_traits::Individual;

let my_individual = Route::from(Route::new(vec![0,1,2]));
let my_individual = my_individual.crossover(
    &Route::from(Route::new(vec![1,0,2]))
);

fn fitness(&self, distance_mat: &DistanceMat) -> f64

Compute how much distance the individual implies with its order of nodes and the distance matrix.

Arguments

• distance_matrix - Distance Matrix that determines the length of the proposed route

Examples

use genetic_algorithm_tsp::route::Route;
use genetic_algorithm_tsp::distance_mat::DistanceMat;
use  genetic_algorithm_traits::Individual;

let my_individual = Route::from(Route::new(vec![0,1,2]));
println!("Fitness of your individual: {}", my_individual.fitness(
    &DistanceMat::new(vec![vec![0.0,1.0,2.0], vec![1.0,0.0,3.0], vec![2.0,3.0,0.0]]))
)

type IndividualCost = DistanceMat

The Type of cost data this individual is compatible to compute its fitness on.

impl PartialEq for Route

fn eq(&self, other: &Route) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Route

impl StructuralPartialEq for Route