Fix column generation algorithm with multiple bin sizes (#5)

Author: fontanf

packingsolver/algorithms/column_generation.hpp

@@ -162,14 +162,6 @@ std::vector<ColIdx> VariableSizeBinPackingPricingSolver<Instance, InstanceBuilde
     return {};
 }
 
-template <typename Solution>
-struct VariableSizeBinPackingColumnExtra
-{
-    Solution solution;
-    BinTypeId bin_type_id;
-    std::vector<ItemTypeId> kp2vbpp;
-};
-
 template <typename Solution>
 std::vector<Column> solution2column(
         const Solution& solution)
@@ -178,23 +170,22 @@ std::vector<Column> solution2column(
     BinPos m = solution.instance().number_of_bin_types();
     for (BinPos bin_pos = 0; bin_pos < solution.number_of_different_bins(); ++bin_pos) {
         BinTypeId bin_type_id = solution.bin(bin_pos).bin_type_id;
-        Solution solution_i(solution.instance());
-        solution_i.append(solution, bin_pos, 1);
-        VariableSizeBinPackingColumnExtra<Solution> extra {solution_i, bin_type_id, {}};
+        Solution extra_solution(solution.instance());
+        extra_solution.append(solution, bin_pos, 1);
         Column column;
         column.objective_coefficient = solution.instance().bin_type(bin_type_id).cost;
         column.row_indices.push_back(bin_type_id);
         column.row_coefficients.push_back(1);
         for (ItemTypeId item_type_id = 0;
                 item_type_id < solution.instance().number_of_item_types();
                 ++item_type_id) {
-            if (extra.solution.item_copies(item_type_id) > 0) {
+            if (extra_solution.item_copies(item_type_id) > 0) {
                 column.row_indices.push_back(m + item_type_id);
                 column.row_coefficients.push_back(
-                        extra.solution.item_copies(item_type_id));
+                        extra_solution.item_copies(item_type_id));
             }
         }
-        column.extra = std::shared_ptr<void>(new VariableSizeBinPackingColumnExtra<Solution>(extra));
+        column.extra = std::shared_ptr<void>(new Solution(extra_solution));
         columns.push_back(column);
     }
     return columns;
@@ -243,7 +234,9 @@ std::vector<Column> VariableSizeBinPackingPricingSolver<Instance, InstanceBuilde
 
         // Retrieve column.
         for (const Solution& kp_solution: kp_solution_pool.solutions()) {
-            VariableSizeBinPackingColumnExtra<Solution> extra {kp_solution, bin_type_id, kp2vbpp};
+            if (kp_solution.number_of_bins() == 0)
+                continue;
+
             Column column;
             column.objective_coefficient = instance_.bin_type(bin_type_id).cost;
             column.row_indices.push_back(bin_type_id);
@@ -253,13 +246,20 @@ std::vector<Column> VariableSizeBinPackingPricingSolver<Instance, InstanceBuilde
             for (ItemTypeId kp_item_type_id = 0;
                     kp_item_type_id < kp_instance.number_of_item_types();
                     ++kp_item_type_id) {
-                if (extra.solution.item_copies(kp_item_type_id) > 0) {
-                    column.row_indices.push_back(m + extra.kp2vbpp[kp_item_type_id]);
-                    column.row_coefficients.push_back(extra.solution.item_copies(kp_item_type_id));
+                if (kp_solution.item_copies(kp_item_type_id) > 0) {
+                    column.row_indices.push_back(m + kp2vbpp[kp_item_type_id]);
+                    column.row_coefficients.push_back(kp_solution.item_copies(kp_item_type_id));
                     //std::cout << duals[m + extra->kp2vbpp[kp_j]] << std::endl;
                 }
             }
-            column.extra = std::shared_ptr<void>(new VariableSizeBinPackingColumnExtra<Solution>(extra));
+            Solution extra_solution(instance_);
+            extra_solution.append(
+                    kp_solution,
+                    0,
+                    1,
+                    {bin_type_id},
+                    kp2vbpp);
+            column.extra = std::shared_ptr<void>(new Solution(extra_solution));
             //std::cout << column << std::endl;
             columns.push_back(column);
         }

packingsolver/onedimensional/optimize.cpp

@@ -161,22 +161,23 @@ Output packingsolver::onedimensional::optimize(
         if (parameters.column_generation_maximum_discrepancy >= 0)
             lds_parameters.discrepancy_limit = parameters.column_generation_maximum_discrepancy;
         lds_parameters.new_bound_callback = [&instance, &parameters, &output](
-                const columngenerationsolver::LimitedDiscrepancySearchOutput& o)
+                const columngenerationsolver::LimitedDiscrepancySearchOutput& lds_output)
         {
-            if (o.solution.size() > 0) {
+            if (lds_output.solution.size() > 0) {
                 Solution solution(instance);
-                for (const auto& pair: o.solution) {
+                for (const auto& pair: lds_output.solution) {
                     const Column& column = pair.first;
                     BinPos value = std::round(pair.second);
                     if (value < 0.5)
                         continue;
                     //std::cout << "append val " << value << " col " << column << std::endl;
-                    std::shared_ptr<VariableSizeBinPackingColumnExtra<Solution>> extra
-                        = std::static_pointer_cast<VariableSizeBinPackingColumnExtra<Solution>>(column.extra);
-                    solution.append(extra->solution, 0, value, {extra->bin_type_id}, extra->kp2vbpp);
+                    solution.append(
+                            *std::static_pointer_cast<Solution>(column.extra),
+                            0,
+                            value);
                 }
                 std::stringstream ss;
-                ss << "discrepancy " << o.solution_discrepancy;
+                ss << "discrepancy " << lds_output.solution_discrepancy;
                 output.solution_pool.add(solution, ss, parameters.info);
             }
         };

packingsolver/onedimensional/solution.cpp

@@ -62,6 +62,16 @@ void Solution::append(
         const std::vector<ItemTypeId>& item_type_ids)
 {
     const SolutionBin& bin = solution.bins_[bin_pos];
+
+    if (!bin_type_ids.empty()) {
+        if (bin.bin_type_id >= (BinPos)bin_type_ids.size()) {
+            throw std::runtime_error(
+                    "onedimensional::Solution::append"
+                    "; bin.bin_type_id: " + std::to_string(bin.bin_type_id)
+                    + "; bin_type_ids.size(): " + std::to_string(bin_type_ids.size()));
+        }
+    }
+
     BinTypeId bin_type_id = (bin_type_ids.empty())?
         solution.bins_[bin_pos].bin_type_id:
         bin_type_ids[bin.bin_type_id];

packingsolver/rectangle/optimize.cpp

@@ -188,9 +188,10 @@ Output packingsolver::rectangle::optimize(
                     BinPos value = std::round(pair.second);
                     if (value < 0.5)
                         continue;
-                    std::shared_ptr<VariableSizeBinPackingColumnExtra<Solution>> extra
-                        = std::static_pointer_cast<VariableSizeBinPackingColumnExtra<Solution>>(column.extra);
-                    solution.append(extra->solution, 0, value, {extra->bin_type_id}, extra->kp2vbpp);
+                    solution.append(
+                            *std::static_pointer_cast<Solution>(column.extra),
+                            0,
+                            value);
                 }
                 std::stringstream ss;
                 ss << "discrepancy " << o.solution_discrepancy;

packingsolver/rectangleguillotine/optimize.cpp

@@ -166,9 +166,10 @@ Output packingsolver::rectangleguillotine::optimize(
                     if (value < 0.5)
                         continue;
                     //std::cout << "append val " << value << " col " << column << std::endl;
-                    std::shared_ptr<VariableSizeBinPackingColumnExtra<Solution>> extra
-                        = std::static_pointer_cast<VariableSizeBinPackingColumnExtra<Solution>>(column.extra);
-                    solution.append(extra->solution, 0, value, {extra->bin_type_id}, extra->kp2vbpp);
+                    solution.append(
+                            *std::static_pointer_cast<Solution>(column.extra),
+                            0,
+                            value);
                 }
                 std::stringstream ss;
                 ss << "discrepancy " << o.solution_discrepancy;