Improve SOR algorithm (#24)

* Update boxstacks code

* Add missing include

* Improve boxstacks branching scheme

* Improve SOR algorithm

* Fix fixed_items in rectangle branching scheme

* Improve rectangle branching scheme

* Improve SOR algorithm

* Fix rectangle branching scheme tests

* Clean SOR code

* Fix SOR algorithm

* Clean SOR code

Author: fontanf

data/box/BUILD

@@ -1,6 +1,15 @@
 # Enable FetchContent.
 include(FetchContent)
 
+# Fetch fontanf/optimizationtools.
+FetchContent_Declare(
+    optimizationtools
+    GIT_REPOSITORY https://github.com/fontanf/optimizationtools.git
+    GIT_TAG e96ddbe225c006911855a6c1ec31aa44fdacde2b
+    #SOURCE_DIR "${PROJECT_SOURCE_DIR}/../optimizationtools/"
+    EXCLUDE_FROM_ALL)
+FetchContent_MakeAvailable(optimizationtools)
+
 # Fetch boost.
 set(BOOST_INCLUDE_LIBRARIES thread filesystem system program_options dynamic_bitset)
 set(BOOST_ENABLE_CMAKE ON)

extern/CMakeLists.txt

@@ -341,35 +341,30 @@ class BranchingScheme
     {
         if (node_1->last_bin_middle_axle_weight > node_2->last_bin_middle_axle_weight)
             return false;
-
-        ItemPos pos_1 = 0;
-        ItemPos pos_2 = 0;
-        ItemPos size_1 = node_1->uncovered_items.size();
-        ItemPos size_2 = node_2->uncovered_items.size();
-        for (;;) {
-            //std::cout << "pos_1 " << pos_1 << " / " << node_1->uncovered_items.size() << std::endl;
-            //std::cout << "pos_2 " << pos_2 << " / " << node_2->uncovered_items.size() << std::endl;
-            if (node_1->uncovered_items[pos_1].xe
-                    > node_2->uncovered_items[pos_2].xe)
+        if (node_1->uncovered_items.size() != node_2->uncovered_items.size())
+            return false;
+        for (ItemPos pos = 0; pos < (ItemPos)node_1->uncovered_items.size(); ++pos) {
+            UncoveredItem& uncovered_item_1 = node_1->uncovered_items[pos];
+            UncoveredItem& uncovered_item_2 = node_2->uncovered_items[pos];
+            if (uncovered_item_1.xs != uncovered_item_2.xs
+                    || uncovered_item_1.ys != uncovered_item_2.ys
+                    || uncovered_item_1.xe != uncovered_item_2.xe
+                    || uncovered_item_1.ye != uncovered_item_2.ye) {
+                return false;
+            }
+            if (uncovered_item_1.ze > uncovered_item_2.ze)
                 return false;
-            if (node_1->uncovered_items[pos_1].ze
-                    > node_2->uncovered_items[pos_2].ze)
+            if (uncovered_item_1.remaiing_weight < instance().item_weight()
+                    && uncovered_item_1.remaiing_weight < uncovered_item_2.remaiing_weight)
+                return false;
+            if (uncovered_item_1.maximum_number_of_items < instance().number_of_items()
+                    && uncovered_item_1.maximum_number_of_items < uncovered_item_2.maximum_number_of_items)
+                return false;
+            if (!uncovered_item_1.item_type_ids.empty()
+                    && !uncovered_item_2.item_type_ids.empty()
+                    && instance().item_type(uncovered_item_1.item_type_ids.back()).stackability_id
+                    != instance().item_type(uncovered_item_2.item_type_ids.back()).stackability_id) {
                 return false;
-            if (pos_1 == size_1 - 1 && pos_2 == size_2 - 1)
-                return true;
-            if (node_1->uncovered_items[pos_1].ye
-                    == node_2->uncovered_items[pos_2].ye) {
-                pos_1++;
-                pos_2++;
-                assert(pos_1 < size_1);
-                assert(pos_2 < size_2);
-            } else if (node_1->uncovered_items[pos_1].ye
-                    > node_2->uncovered_items[pos_2].ye) {
-                pos_2++;
-                assert(pos_2 < size_2);
-            } else {
-                pos_1++;
-                assert(pos_1 < size_1);
             }
         }
         return true;
@@ -397,7 +392,7 @@ class BranchingScheme
     /** Parameters. */
     Parameters parameters_;
 
-    std::vector<ItemTypeId> predecessors_;
+    std::vector<std::vector<ItemTypeId>> predecessors_;
 
     ItemPos number_of_selected_items_ = 0;
 
@@ -470,6 +465,14 @@ class BranchingScheme
             ItemPos uncovered_item_pos,
             DefectId defect_id) const;
 
+    /** Insertion of one item in a new stack. */
+    void insertion_item_left(
+            const std::shared_ptr<Node>& father,
+            std::vector<Insertion>& insertions,
+            ItemTypeId item_type_id,
+            int rotation,
+            ItemPos uncovered_item_pos) const;
+
 };
 
 std::ostream& operator<<(

include/packingsolver/boxstacks/branching_scheme.hpp

@@ -146,9 +146,11 @@ struct ItemType
     /** Get the volume of the item type. */
     inline Volume volume() const { return box.volume(); }
 
+    inline Area area() const { return box.x * box.y; }
+
     inline Volume space() const { return volume(); }
 
-    bool can_rotate(int rotation) const { return ((rotations >> rotation) & 1); }
+    inline bool can_rotate(int rotation) const { return ((rotations >> rotation) & 1); }
 };
 
 std::ostream& operator<<(
@@ -195,7 +197,8 @@ struct BinType
      * Computed attributes
      */
 
-    Area area() const { return box.x * box.y; }
+    /** Get the floor area of the bin type. */
+    inline Area area() const { return box.x * box.y; }
 
     /** Get the volume of the bin type. */
     inline Volume volume() const { return box.volume(); }
@@ -273,6 +276,9 @@ class Instance
     /** Get the total volume of the bins. */
     inline Volume bin_volume() const { return bin_volume_; }
 
+    /** Get the total floor area of the bins. */
+    inline Area bin_area() const { return bin_area_; }
+
     /** Get the total weight of the bins. */
     inline Weight bin_weight() const { return bin_weight_; }
 
@@ -461,6 +467,9 @@ class Instance
     /** Total bin volume. */
     Volume bin_volume_ = 0;
 
+    /** Total bin floor area. */
+    Area bin_area_ = 0;
+
     /** Total weight of the bins. */
     Weight bin_weight_ = 0.0;
 

include/packingsolver/boxstacks/instance.hpp

@@ -3,7 +3,6 @@
 #include "packingsolver/boxstacks/solution.hpp"
 
 #include "packingsolver/boxstacks/sequential_onedimensional_rectangle.hpp"
-#include "packingsolver/algorithms/sequential_value_correction.hpp"
 
 #include "columngenerationsolver/linear_programming_solver.hpp"
 
@@ -12,62 +11,6 @@ namespace packingsolver
 namespace boxstacks
 {
 
-struct OptimizeParameters: packingsolver::Parameters<Instance, Solution>
-{
-    /** Optimization mode. */
-    OptimizationMode optimization_mode = OptimizationMode::Anytime;
-
-
-    /** Parameters of the sequential_onedimensional_rectangle algorithm. */
-    SequentialOneDimensionalRectangleParameters sequential_onedimensional_rectangle_parameters;
-
-    /** Size of the queue in the tree search algorithm. */
-    NodeId tree_search_queue_size = -1;
-
-    /** Guides used in the tree search algorithm. */
-    std::vector<GuideId> tree_search_guides;
-
-
-    /**
-     * Time limit for the VbppToBpp bin packing sub-problem of the column
-     * generation algorithm.
-     */
-    double column_generation_vbpp_to_bpp_time_limit = -1;
-
-    /**
-     * Size of the queue for the VbppToBpp bin packing sub-problem of the
-     * column generation algorithm.
-     */
-    NodeId column_generation_vbpp_to_bpp_queue_size = 256;
-
-    /**
-     * Size of the queue for the pricing knapsack sub-problem of the column
-     * generation algorithm.
-     */
-    NodeId column_generation_pricing_queue_size = 256;
-
-    /** Linear programming solver. */
-    columngenerationsolver::LinearProgrammingSolver linear_programming_solver
-        = columngenerationsolver::LinearProgrammingSolver::CLP;
-
-
-    /**
-     * Size of the queue for the bin packing sub-problem of the dichotomic
-     * search algorithm.
-     */
-    NodeId dichotomic_search_queue_size = 32;
-
-
-    /** Parameters for the Sequential Value Correction algorithm. */
-    SequentialValueCorrectionParameters<Instance, Solution> sequential_value_correction_parameters;
-
-    /**
-     * Size of the queue for the knapsack sub-problem of the sequential value
-     * correction algorithm.
-     */
-    NodeId sequential_value_correction_queue_size = 1024;
-};
-
 struct Output: packingsolver::Output<Instance, Solution>
 {
     Output(const Instance& instance):
@@ -101,6 +44,8 @@ struct Output: packingsolver::Output<Instance, Solution>
      */
     double sequential_onedimensional_rectangle_rectangle_time = 0.0;
 
+    bool sequential_onedimensional_rectangle_failed = false;
+
     /** Time spent in the 'boxstacks' branching scheme. */
     double tree_search_time = 0.0;
 
@@ -135,6 +80,61 @@ struct Output: packingsolver::Output<Instance, Solution>
     Counter number_of_tree_search_better = 0;
 };
 
+using NewSolutionCallback = std::function<void(const Output&)>;
+
+struct OptimizeParameters: packingsolver::Parameters<Instance, Solution>
+{
+    /** Optimization mode. */
+    OptimizationMode optimization_mode = OptimizationMode::Anytime;
+
+    /** New solution callback. */
+    NewSolutionCallback new_solution_callback = [](const Output&) { };
+
+    /** Linear programming solver. */
+    columngenerationsolver::LinearProgrammingSolver linear_programming_solver
+        = columngenerationsolver::LinearProgrammingSolver::CLP;
+
+    /** Use tree search algorithm. */
+    bool use_tree_search = false;
+
+    /** Use sequential single knapsack algorithm. */
+    bool use_sequential_single_knapsack = false;
+
+    /** Parameters of the sequential_onedimensional_rectangle algorithm. */
+    SequentialOneDimensionalRectangleParameters sequential_onedimensional_rectangle_parameters;
+
+    /** Guides used in the tree search algorithm. */
+    std::vector<GuideId> tree_search_guides;
+
+    /**
+     * Size of the queue for the pricing knapsack subproblem of the sequential
+     * value correction algorithm.
+     */
+    NodeId sequential_value_correction_subproblem_queue_size = 512;
+
+    /**
+     * Size of the queue for the pricing knapsack subproblem of the column
+     * generation algorithm.
+     */
+    NodeId column_generation_subproblem_queue_size = 512;
+
+    /*
+     * Parameters for non-anytime mode
+     */
+
+    /** Size of the queue in the tree search algorithm. */
+    NodeId not_anytime_tree_search_queue_size = 512;
+
+    /**
+     * Size of the queue in the single knapsack subproblem of the sequential
+     * single knapsack algorithm.
+     */
+    NodeId not_anytime_sequential_single_knapsack_subproblem_queue_size = 512;
+
+    /** Number of iterations of the sequential value correction algorithm. */
+    Counter not_anytime_sequential_value_correction_number_of_iterations = 32;
+};
+
 const Output optimize(
         const Instance& instance,
         const OptimizeParameters& parameters = {});

include/packingsolver/boxstacks/optimize.hpp

@@ -16,7 +16,6 @@
 #include "packingsolver/boxstacks/solution.hpp"
 
 #include "packingsolver/onedimensional/optimize.hpp"
-#include "packingsolver/rectangle/optimize.hpp"
 
 namespace packingsolver
 {
@@ -30,6 +29,12 @@ struct SequentialOneDimensionalRectangleOutput: packingsolver::Output<Instance,
         packingsolver::Output<Instance, Solution>(instance) { }
 
 
+    /** Number of iterations. */
+    Counter number_of_iterations = 0;
+
+    /** Number of stack splits. */
+    Counter number_of_stack_splits = 0;
+
     /**
      * Number of items in the solution found by the algorithm, before the
      * repair step.

include/packingsolver/boxstacks/sequential_onedimensional_rectangle.hpp

@@ -2,8 +2,6 @@
 
 #include "packingsolver/boxstacks/instance.hpp"
 
-#include <sstream>
-
 namespace packingsolver
 {
 namespace boxstacks
@@ -165,9 +163,22 @@ class Solution
     /** Get the total volume of the bins of the solution. */
     inline Volume bin_volume() const { return bin_volume_; }
 
+    /** Get the total floor area of the bins of the solution. */
+    inline Area bin_area() const { return bin_area_; }
+
     /** Get the total weight of the bins of the solution. */
     inline Weight bin_weight() const { return bin_weight_; }
 
+    /*
+     * Getters: stacks
+     */
+
+    /** Get the number of stacks in the solution. */
+    inline ItemPos number_of_stacks() const { return number_of_stacks_; }
+
+    /** Get the total area of the stacks of the solution. */
+    inline Area stack_area() const { return stack_area_; }
+
     /*
      * Getters: items
      */
@@ -210,6 +221,9 @@ class Solution
     /** Get the volume load of the solution. */
     inline double volume_load() const { return (double)item_volume() / instance().bin_volume(); }
 
+    /** Get the area load of the solution. */
+    inline double area_load() const { return (double)stack_area() / instance().bin_area(); }
+
     /** Get the weight load of the solution. */
     inline double weight_load() const { return (double)item_weight() / instance().bin_weight(); }
 
@@ -241,6 +255,20 @@ class Solution
             const std::vector<Weight>& weight,
             const std::vector<Weight>& weight_weighted_sum) const;
 
+    Weight compute_middle_axle_weight_constraints_violation() const;
+
+    Weight compute_middle_axle_weight_constraints_violation(
+            BinTypeId bin_type_id,
+            const std::vector<Weight>& weight,
+            const std::vector<Weight>& weight_weighted_sum) const;
+
+    Weight compute_rear_axle_weight_constraints_violation() const;
+
+    Weight compute_rear_axle_weight_constraints_violation(
+            BinTypeId bin_type_id,
+            const std::vector<Weight>& weight,
+            const std::vector<Weight>& weight_weighted_sum) const;
+
     /**
      * Return 'true' iff the input stack is feasible.
      *
@@ -292,6 +320,9 @@ class Solution
     /** Number of bins. */
     BinPos number_of_bins_ = 0;
 
+    /** Number of stacks. */
+    BinPos number_of_stacks_ = 0;
+
     /** Number of items. */
     BinPos number_of_items_ = 0;
 
@@ -301,6 +332,12 @@ class Solution
     /** Total volume of the bins of the solution. */
     Volume bin_volume_ = 0;
 
+    /** Total floor area of the bins of the solution. */
+    Area bin_area_ = 0;
+
+    /** Total area of the stacks of the solution. */
+    Area stack_area_ = 0;
+
     /** Total weight of the bins of the solution. */
     Volume bin_weight_ = 0;