rapid_solve 0.1.7

This library provides a metaheuristic framework for solving combinatorial optimization 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

use std::env;
use std::sync::Arc;

use rapid_solve::examples::tsp::solvers;
use rapid_solve::examples::tsp::tsp_tour_with_info::TspTourWithInfo;
use rapid_solve::examples::tsp::{tsp_instance::TspInstance, tsp_tour::TspTour};
use rapid_solve::heuristics::Solver;

/// With this main function, you can run a TSP solver with a provided TSPLIB file.
fn main() {
    let args: Vec<String> = env::args().collect();
    let start_time = std::time::Instant::now();

    if args.len() != 3 {
        print_usage(args[0].as_str());
        std::process::exit(1);
    }

    let tsp_instance = Arc::new(TspInstance::from_tsplib_file(&args[2]).unwrap());
    let initial_tour = TspTour::from_instance_nearest_neighbor(tsp_instance.clone());

    let final_tour = match args[1].as_str() {
        "basic_local_search" => {
            let basic_local_search_solver =
                Box::new(solvers::basic_local_search::build(tsp_instance));
            basic_local_search_solver.solve(initial_tour).unwrap()
        }
        "take_first_local_search" => {
            let take_first_local_search_solver =
                Box::new(solvers::take_first_local_search::build(tsp_instance));
            take_first_local_search_solver.solve(initial_tour).unwrap()
        }
        "parallel_local_search" => {
            let parallel_local_search_solver =
                Box::new(solvers::parallel_local_search::build(tsp_instance));
            parallel_local_search_solver.solve(initial_tour).unwrap()
        }
        "threshold_accepting" => {
            let threshold_accepting_solver =
                Box::new(solvers::threshold_accepting::build(tsp_instance));
            let tsp_tour_with_info =
                threshold_accepting_solver.solve(TspTourWithInfo::new(initial_tour, 0));
            tsp_tour_with_info.unwrap().unwrap()
        }
        "simulated_annealing" => {
            let simulated_annealing_solver =
                Box::new(solvers::simulated_annealing::build(tsp_instance));
            let tsp_tour_with_info =
                simulated_annealing_solver.solve(TspTourWithInfo::new(initial_tour, 0));
            tsp_tour_with_info.unwrap().unwrap()
        }
        "tabu_search" => {
            let tabu_search_solver = Box::new(solvers::tabu_search::build(tsp_instance));
            tabu_search_solver.solve(initial_tour).unwrap()
        }
        "parallel_tabu_search" => {
            let parallel_tabu_search_solver =
                Box::new(solvers::parallel_tabu_search::build(tsp_instance));
            parallel_tabu_search_solver.solve(initial_tour).unwrap()
        }
        _ => {
            eprintln!("Unknown solver: {}", args[1]);
            print_usage(args[0].as_str());
            std::process::exit(1);
        }
    };

    println!("\nFinal tour: {:?}", final_tour.get_nodes());
    println!("Total distance: {:0.2}", final_tour.get_total_distance());
    println!(
        "\nRunning time: {:0.2}sec",
        start_time.elapsed().as_secs_f64()
    );
}

fn print_usage(program_name: &str) {
    eprintln!("Usage: {} <solver> <tsplib_file>", program_name);
    eprintln!(
        "  <solver>: \n\
        - basic_local_search\n\
        - take_first_local_search\n\
        - parallel_local_search\n\
        - threshold_accepting\n\
        - simulated_annealing\n\
        - tabu_search\n\
        - parallel_tabu_search\n"
    );
}