Fix issue in lilim reader

Author: reinterpretcat

.gitignore

@@ -24,4 +24,6 @@ __pycache__
 heuristic_state.json
 
 # profiler
-callgrind*
+callgrind*
+
+.claude

vrp-scientific/src/lilim/reader.rs

@@ -14,7 +14,7 @@ use vrp_core::models::{Extras, Problem};
 use vrp_core::prelude::GenericError;
 use vrp_core::utils::Float;
 
-/// A trait to read lilim problem.
+/// A trait to read lilim problem. Original format is described here: https://www.sintef.no/projectweb/top/pdptw/documentation
 pub trait LilimProblem {
     /// Reads lilim problem.
     fn read_lilim(self, is_rounded: bool) -> Result<Problem, GenericError>;
@@ -146,7 +146,8 @@ impl<R: Read> LilimReader<R> {
         } else {
             Demand::<SingleDimLoad> {
                 pickup: (SingleDimLoad::default(), SingleDimLoad::default()),
-                delivery: (SingleDimLoad::default(), SingleDimLoad::new(customer.demand)),
+                // we have a negative demand for deliveries in original problem formulation
+                delivery: (SingleDimLoad::default(), SingleDimLoad::new(-customer.demand)),
             }
         });
 
@@ -156,7 +157,7 @@ impl<R: Read> LilimReader<R> {
                 duration: customer.service as Float,
                 times: vec![TimeSpan::Window(customer.tw.clone())],
             }],
-            dimens: Default::default(),
+            dimens,
         })
     }
 

vrp-scientific/tests/helpers/lilim.rs

@@ -0,0 +1,41 @@
+/// id  x   y  demand early late service pickup delivery
+pub type LilimCustomer = (i32, i32, i32, i32, i32, i32, i32, i32, i32);
+
+pub struct LilimBuilder {
+    vehicle: (usize, usize),
+    customers: Vec<LilimCustomer>,
+}
+
+impl Default for LilimBuilder {
+    fn default() -> Self {
+        Self { vehicle: (0, 0), customers: vec![] }
+    }
+}
+
+impl LilimBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn set_vehicle(&mut self, vehicle: (usize, usize)) -> &mut Self {
+        self.vehicle = vehicle;
+        self
+    }
+
+    pub fn add_customer(&mut self, customer: LilimCustomer) -> &mut Self {
+        self.customers.push(customer);
+        self
+    }
+
+    pub fn build(&self) -> String {
+        let mut data = String::new();
+
+        data.push_str(&format!("{} {} 0\n", self.vehicle.0, self.vehicle.1));
+
+        for c in &self.customers {
+            data.push_str(&format!("{} {} {} {} {} {} {} {} {}\n", c.0, c.1, c.2, c.3, c.4, c.5, c.6, c.7, c.8));
+        }
+
+        data
+    }
+}

vrp-scientific/tests/helpers/mod.rs

@@ -6,6 +6,9 @@ pub mod macros;
 mod analysis;
 pub use self::analysis::*;
 
+mod lilim;
+pub use self::lilim::LilimBuilder;
+
 mod solomon;
 pub use self::solomon::SolomonBuilder;
 

vrp-scientific/tests/unit/lilim/reader_test.rs

@@ -1,4 +1,8 @@
-use crate::helpers::{create_lc101_problem, get_job_ids, get_vehicle_capacity};
+use crate::helpers::{LilimBuilder, create_lc101_problem, get_job_ids, get_vehicle_capacity};
+use crate::lilim::LilimProblem;
+use vrp_core::construction::features::JobDemandDimension;
+use vrp_core::models::common::{Demand, SingleDimLoad};
+use vrp_core::models::problem::Job;
 
 #[test]
 fn can_read_lilim_format_from_test_file() {
@@ -9,3 +13,47 @@ fn can_read_lilim_format_from_test_file() {
     assert_eq!(problem.fleet.vehicles.len(), 25);
     assert_eq!(get_vehicle_capacity(&problem), 200);
 }
+
+#[test]
+fn can_read_lilim_format_properly() {
+    let problem = LilimBuilder::new()
+        .set_vehicle((3, 15))
+        .add_customer((0, 0, 0, 0, 0, 1000, 0, 0, 0)) // depot
+        .add_customer((1, 1, 0, 15, 0, 1000, 5, 0, 2)) // pickup, delivers to 2
+        .add_customer((2, 2, 0, -15, 0, 1000, 5, 1, 0)) // delivery, picked from 1
+        .add_customer((3, 3, 0, 10, 0, 1000, 3, 0, 4)) // pickup, delivers to 4
+        .add_customer((4, 4, 0, -10, 0, 1000, 3, 3, 0)) // delivery, picked from 3
+        .build()
+        .read_lilim(false)
+        .unwrap();
+
+    assert_eq!(problem.fleet.vehicles.len(), 3);
+    assert_eq!(get_vehicle_capacity(&problem), 15);
+    assert_eq!(get_job_ids(&problem), vec!["0", "1"]);
+
+    // verify demands on sub-jobs of each multi job
+    let jobs: Vec<_> = problem.jobs.all().into_iter().collect();
+
+    let (pickup_demand_0, delivery_demand_0) = get_multi_job_demands(&jobs[0]);
+    assert_eq!(pickup_demand_0.pickup.1.value, 15);
+    assert_eq!(pickup_demand_0.delivery.1.value, 0);
+    assert_eq!(delivery_demand_0.delivery.1.value, 15);
+    assert_eq!(delivery_demand_0.pickup.1.value, 0);
+
+    let (pickup_demand_1, delivery_demand_1) = get_multi_job_demands(&jobs[1]);
+    assert_eq!(pickup_demand_1.pickup.1.value, 10);
+    assert_eq!(pickup_demand_1.delivery.1.value, 0);
+    assert_eq!(delivery_demand_1.delivery.1.value, 10);
+    assert_eq!(delivery_demand_1.pickup.1.value, 0);
+}
+
+fn get_multi_job_demands(job: &Job) -> (&Demand<SingleDimLoad>, &Demand<SingleDimLoad>) {
+    match job {
+        Job::Multi(multi) => {
+            let pickup = multi.jobs[0].dimens.get_job_demand().unwrap();
+            let delivery = multi.jobs[1].dimens.get_job_demand().unwrap();
+            (pickup, delivery)
+        }
+        _ => panic!("expected multi job"),
+    }
+}