vrp-core 1.25.0

A core algorithms to solve a Vehicle Routing Problem
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

//! A feature to detect filter jobs based on their reachability.

use crate::construction::heuristics::MoveContext;
use crate::models::problem::{Job, TransportCost, TravelTime};
use crate::models::{ConstraintViolation, Feature, FeatureBuilder, FeatureConstraint, ViolationCode};
use rosomaxa::utils::GenericError;
use std::sync::Arc;

/// Creates a feature to check reachability of the jobs. It is a hard constraint.
pub fn create_reachable_feature(
    name: &str,
    transport: Arc<dyn TransportCost>,
    code: ViolationCode,
) -> Result<Feature, GenericError> {
    FeatureBuilder::default().with_name(name).with_constraint(ReachableConstraint { transport, code }).build()
}

struct ReachableConstraint {
    transport: Arc<dyn TransportCost>,
    code: ViolationCode,
}

impl FeatureConstraint for ReachableConstraint {
    fn evaluate(&self, move_ctx: &MoveContext<'_>) -> Option<ConstraintViolation> {
        match move_ctx {
            MoveContext::Route { .. } => None,
            MoveContext::Activity { route_ctx, activity_ctx } => {
                let prev = activity_ctx.prev;
                let target = activity_ctx.target;
                let next = activity_ctx.next;

                let prev_to_target = self.transport.distance(
                    route_ctx.route(),
                    prev.place.location,
                    target.place.location,
                    TravelTime::Departure(prev.schedule.departure),
                );

                if prev_to_target < 0. {
                    return ConstraintViolation::skip(self.code);
                }

                if let Some(next) = next {
                    let target_to_next = self.transport.distance(
                        route_ctx.route(),
                        target.place.location,
                        next.place.location,
                        TravelTime::Departure(target.schedule.departure),
                    );
                    if target_to_next < 0. {
                        return ConstraintViolation::skip(self.code);
                    }
                }

                None
            }
        }
    }

    fn merge(&self, source: Job, _: Job) -> Result<Job, ViolationCode> {
        // NOTE it is responsibility of the caller to check whether jobs are reachable
        Ok(source)
    }
}