Update knapsacksolver dependency

extern/CMakeLists.txt

@@ -67,11 +67,22 @@ set(KNAPSACKSOLVER_BUILD_TEST OFF)
 FetchContent_Declare(
     knapsacksolver
     GIT_REPOSITORY https://github.com/fontanf/knapsacksolver.git
-    GIT_TAG 5aee5d72a09fb228033d695fe22dc90dba65ec05
+    GIT_TAG 1d7a689f88e953c099087a31f174cb6646002f9f
     #SOURCE_DIR "${PROJECT_SOURCE_DIR}/../knapsacksolver/"
     EXCLUDE_FROM_ALL)
 FetchContent_MakeAvailable(knapsacksolver)
 
+# Fetch fontanf/multiplechoicesubsetsumsolver.
+set(MULTIPLECHOICESUBSETSUMSOLVER_BUILD_MAIN OFF)
+set(MULTIPLECHOICESUBSETSUMSOLVER_BUILD_TEST OFF)
+FetchContent_Declare(
+    multiplechoicesubsetsumsolver
+    GIT_REPOSITORY https://github.com/fontanf/multiplechoicesubsetsumsolver.git
+    GIT_TAG 83406f59044425aef1391030db0b29333c208d7f
+    #SOURCE_DIR "${PROJECT_SOURCE_DIR}/../multiplechoicesubsetsumsolver/"
+    EXCLUDE_FROM_ALL)
+FetchContent_MakeAvailable(multiplechoicesubsetsumsolver)
+
 # Fetch fontanf/treesearchsolver.
 set(TREESEARCHSOLVER_BUILD_TEST OFF)
 set(TREESEARCHSOLVER_BUILD_EXAMPLES OFF)

src/algorithms/CMakeLists.txt

@@ -13,5 +13,5 @@ target_include_directories(PackingSolver_algorithms INTERFACE
 target_link_libraries(PackingSolver_algorithms INTERFACE
     PackingSolver_common
     ColumnGenerationSolver::columngenerationsolver
-    KnapsackSolver::knapsack::dynamic_programming_primal_dual)
+    KnapsackSolver::dynamic_programming_primal_dual)
 add_library(PackingSolver::algorithms ALIAS PackingSolver_algorithms)

src/algorithms/dichotomic_search.hpp

@@ -17,8 +17,8 @@
 
 #include "packingsolver/algorithms/common.hpp"
 
-#include "knapsacksolver/knapsack/instance_builder.hpp"
-#include "knapsacksolver/knapsack/algorithms/dynamic_programming_primal_dual.hpp"
+#include "knapsacksolver/instance_builder.hpp"
+#include "knapsacksolver/algorithms/dynamic_programming_primal_dual.hpp"
 
 namespace packingsolver
 {
@@ -148,15 +148,15 @@ DichotomicSearchOutput<Instance, Solution> dichotomic_search(
 
         // Build knapsack instance.
         //std::cout << "Build Knapsack instance..." << std::endl;
-        knapsacksolver::knapsack::InstanceFromFloatProfitsBuilder kp_instance_builder;
+        knapsacksolver::InstanceFromFloatProfitsBuilder kp_instance_builder;
         // Set knapsack capacity.
         //std::cout << "bin_space " << bin_space << std::endl;
         //std::cout << "bin_min_space " << bin_min_space << std::endl;
         //std::cout << "item_space " << item_space << std::endl;
-        knapsacksolver::knapsack::Weight kp_capacity = bin_space
+        knapsacksolver::Weight kp_capacity = bin_space
             - bin_min_space
             - (item_space * (1 + output.waste_percentage));
-        kp_capacity = std::max(kp_capacity, (knapsacksolver::knapsack::Weight)0);
+        kp_capacity = std::max(kp_capacity, (knapsacksolver::Weight)0);
         kp_instance_builder.set_capacity(kp_capacity);
         // Add knapsack items which are PackingSolver bins.
         std::vector<BinTypeId> kp2ps;
@@ -171,15 +171,15 @@ DichotomicSearchOutput<Instance, Solution> dichotomic_search(
                 kp2ps.push_back(bin_type_id);
             }
         }
-        const knapsacksolver::knapsack::Instance kp_instance = kp_instance_builder.build();
+        const knapsacksolver::Instance kp_instance = kp_instance_builder.build();
         //std::cout << "kp2ps";
         //for (BinTypeId i: kp2ps)
         //    std::cout << " " << i;
         //std::cout << std::endl;
         // Solve knapsack instance.
-        knapsacksolver::knapsack::DynamicProgrammingPrimalDualParameters kp_parameters;
+        knapsacksolver::DynamicProgrammingPrimalDualParameters kp_parameters;
         kp_parameters.verbosity_level = 0;
-        auto kp_output = knapsacksolver::knapsack::dynamic_programming_primal_dual(
+        auto kp_output = knapsacksolver::dynamic_programming_primal_dual(
                 kp_instance,
                 kp_parameters);
 
@@ -206,7 +206,7 @@ DichotomicSearchOutput<Instance, Solution> dichotomic_search(
                 bin_type_id < instance.number_of_bin_types();
                 ++bin_type_id)
             bin_copies[bin_type_id] += instance.bin_type(bin_type_id).copies_min;
-        for (knapsacksolver::knapsack::ItemId kp_item_id = 0;
+        for (knapsacksolver::ItemId kp_item_id = 0;
                 kp_item_id < kp_instance.number_of_items();
                 ++kp_item_id) {
             //std::cout << "kp_item_id " << kp_item_id << " sol " << kp_output.solution.contains(kp_item_id) << std::endl;

src/box/CMakeLists.txt

@@ -16,7 +16,7 @@ target_link_libraries(PackingSolver_box PUBLIC
     PackingSolver_algorithms
     PackingSolver_rectangle
     PackingSolver_onedimensional
-    KnapsackSolver::multiple_choice_subset_sum::dynamic_programming_bellman
+    MultipleChoiceSubsetSumSolver::dynamic_programming_bellman
     Threads::Threads)
 add_library(PackingSolver::box ALIAS PackingSolver_box)
 

src/boxstacks/CMakeLists.txt

@@ -17,7 +17,7 @@ target_link_libraries(PackingSolver_boxstacks PUBLIC
     PackingSolver_algorithms
     PackingSolver_rectangle
     PackingSolver_onedimensional
-    KnapsackSolver::multiple_choice_subset_sum::dynamic_programming_bellman
+    MultipleChoiceSubsetSumSolver::dynamic_programming_bellman
     Threads::Threads)
 add_library(PackingSolver::boxstacks ALIAS PackingSolver_boxstacks)
 

src/boxstacks/branching_scheme.cpp

@@ -1,7 +1,7 @@
 #include "boxstacks/branching_scheme.hpp"
 
-#include "knapsacksolver/multiple_choice_subset_sum/instance_builder.hpp"
-#include "knapsacksolver/multiple_choice_subset_sum/algorithms/dynamic_programming_bellman.hpp"
+#include "multiplechoicesubsetsumsolver/instance_builder.hpp"
+#include "multiplechoicesubsetsumsolver/algorithms/dynamic_programming_bellman.hpp"
 
 #include <string>
 #include <cmath>
@@ -276,7 +276,7 @@ BranchingScheme::BranchingScheme(
     // Lift length.
     // Build Multiple-Choice Subset Sum instance.
     const BinType& bin_type = instance.bin_type(0);
-    knapsacksolver::multiple_choice_subset_sum::InstanceBuilder mcss_instance_builder;
+    multiplechoicesubsetsumsolver::InstanceBuilder mcss_instance_builder;
     mcss_instance_builder.set_capacity(bin_type.box.x);
     ItemPos mcss_pos = 0;
     for (ItemTypeId item_type_id = 0;
@@ -293,11 +293,11 @@ BranchingScheme::BranchingScheme(
             mcss_pos++;
         }
     }
-    knapsacksolver::multiple_choice_subset_sum::Instance mcss_instance = mcss_instance_builder.build();
+    multiplechoicesubsetsumsolver::Instance mcss_instance = mcss_instance_builder.build();
     //mcss_instance.print(std::cout, 2);
-    knapsacksolver::multiple_choice_subset_sum::Parameters mcss_parameters;
+    multiplechoicesubsetsumsolver::Parameters mcss_parameters;
     mcss_parameters.verbosity_level = 0;
-    auto mscc_output = knapsacksolver::multiple_choice_subset_sum::dynamic_programming_bellman_array(
+    auto mscc_output = multiplechoicesubsetsumsolver::dynamic_programming_bellman_array(
             mcss_instance,
             mcss_parameters);
     //auto mscc_output = multiple_choice_subset_sumsolver::dynamic_programming_bellman_word_ram(mcss_instance);

src/onedimensional/optimize.cpp

@@ -9,8 +9,8 @@
 
 #include "treesearchsolver/iterative_beam_search_2.hpp"
 
-#include "knapsacksolver/knapsack/instance_builder.hpp"
-#include "knapsacksolver/knapsack/algorithms/dynamic_programming_primal_dual.hpp"
+#include "knapsacksolver/instance_builder.hpp"
+#include "knapsacksolver/algorithms/dynamic_programming_primal_dual.hpp"
 
 #include <thread>
 
@@ -31,9 +31,9 @@ void optimize_dynamic_programming(
         return;
 
     const BinType& bin_type = instance.bin_type(0);
-    knapsacksolver::knapsack::InstanceFromFloatProfitsBuilder kp_instance_builder;
+    knapsacksolver::InstanceFromFloatProfitsBuilder kp_instance_builder;
     std::vector<std::pair<ItemTypeId, ItemPos>> kp2ps;
-    knapsacksolver::knapsack::Weight kp_capacity = bin_type.length;
+    knapsacksolver::Weight kp_capacity = bin_type.length;
     kp_instance_builder.set_capacity(kp_capacity);
     for (ItemTypeId item_type_id: bin_type.item_type_ids) {
         const ItemType& item_type = instance.item_type(item_type_id);
@@ -42,7 +42,7 @@ void optimize_dynamic_programming(
         while (total_copies < item_type.copies) {
             if (total_copies + copies > item_type.copies)
                 copies = item_type.copies - total_copies;
-            knapsacksolver::knapsack::Weight kp_weight = copies * (
+            knapsacksolver::Weight kp_weight = copies * (
                     item_type.length
                     - (std::max)(item_type.nesting_length, (Length)0));
             if (kp_weight > kp_capacity)
@@ -55,17 +55,17 @@ void optimize_dynamic_programming(
             copies *= 2;
         }
     }
-    knapsacksolver::knapsack::Instance kp_instance = kp_instance_builder.build();
+    knapsacksolver::Instance kp_instance = kp_instance_builder.build();
 
-    knapsacksolver::knapsack::DynamicProgrammingPrimalDualParameters kp_parameters;
+    knapsacksolver::DynamicProgrammingPrimalDualParameters kp_parameters;
     kp_parameters.verbosity_level = 0;
-    auto kp_output = knapsacksolver::knapsack::dynamic_programming_primal_dual(
+    auto kp_output = knapsacksolver::dynamic_programming_primal_dual(
             kp_instance,
             kp_parameters);
 
     Solution solution(instance);
     solution.add_bin(0, 1);
-    for (knapsacksolver::knapsack::ItemId kp_item_type_id = 0;
+    for (knapsacksolver::ItemId kp_item_type_id = 0;
             kp_item_type_id < kp_instance.number_of_items();
             ++kp_item_type_id) {
         if (kp_output.solution.contains(kp_item_type_id)) {