packingsolver 0.1.1236__tar.gz → 0.1.1237__tar.gz

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: packingsolver
-Version: 0.1.1236
+Version: 0.1.1237
 Summary: A solver for geometrical packing and cutting-stock problems
 Author: Florian Fontan
 License-Expression: MIT

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/box/instance.hpp

@@ -140,11 +140,11 @@ struct Box
 };
 
 /**
- * Get the volume used in a bin of dimensions 'bin' whose items end at
- * 'x_max', 'y_max', 'z_max', for a leftover mode (see 'LeftoverMode'): the
- * leftover is the volume of the bin minus this volume.
+ * Get the box used in a bin of dimensions 'bin' whose items end at 'x_max',
+ * 'y_max', 'z_max', for a leftover mode (see 'LeftoverMode'): the leftover is
+ * the volume of the bin minus the volume of this box.
  */
-inline Volume leftover_mode_used_volume(
+inline Box leftover_mode_used_box(
         LeftoverMode leftover_mode,
         const Box& bin,
         Length x_max,
@@ -163,9 +163,10 @@ inline Volume leftover_mode_used_volume(
             || leftover_mode == LeftoverMode::XZ
             || leftover_mode == LeftoverMode::YZ
             || leftover_mode == LeftoverMode::XYZ);
-    return (Volume)(along_x? x_max: bin.x)
-        * (along_y? y_max: bin.y)
-        * (along_z? z_max: bin.z);
+    return {
+        (along_x? x_max: bin.x),
+        (along_y? y_max: bin.y),
+        (along_z? z_max: bin.z)};
 }
 
 inline bool operator==(const Box& box_1, const Box& box_2) { return box_1.x == box_2.x && box_1.y == box_2.y && box_1.z == box_2.z; }
@@ -326,6 +327,14 @@ struct Parameters
 
     /** Leftover mode (see 'LeftoverMode'). */
     LeftoverMode leftover_mode = LeftoverMode::XYZ;
+
+    /**
+     * For the BinPackingWithLeftovers objective, also compare the solutions
+     * on the sum of the leftover values of the bins and on the sum of their
+     * staircase leftover values, after the leftover value and the staircase
+     * leftover value of the last bin.
+     */
+    bool leftover_all_bins = true;
 };
 
 ////////////////////////////////////////////////////////////////////////////////

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/box/instance_builder.hpp

@@ -64,6 +64,9 @@ public:
     /** Set the leftover mode (see 'LeftoverMode'). */
     void set_leftover_mode(LeftoverMode leftover_mode) { instance_.parameters_.leftover_mode = leftover_mode; }
 
+    /** Set whether the leftover values of all the bins are compared. */
+    void set_leftover_all_bins(bool leftover_all_bins) { instance_.parameters_.leftover_all_bins = leftover_all_bins; }
+
     /** Set the feasibility callback. */
     void set_feasibility_callback(const FeasibilityCallback& feasibility_callback) { instance_.feasibility_callback_ = feasibility_callback; }
 
@@ -82,6 +85,16 @@ public:
             BinTypeId bin_type_id,
             Profit cost);
 
+    /**
+     * Set the dimensions of a bin type, overriding whatever 'add_bin_type'
+     * gave it. Used by the sequential feasibility algorithm to shrink a bin.
+     */
+    void set_bin_type_box(
+            BinTypeId bin_type_id,
+            Length x,
+            Length y,
+            Length z);
+
     /** Set the maximum weight of a bin type. */
     void set_bin_type_maximum_weight(
             BinTypeId bin_type_id,

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/box/optimize.hpp

@@ -214,12 +214,38 @@ struct OptimizeParameters: packingsolver::Parameters<Instance, Solution, Output>
     /** Guides used in the tree search algorithm. */
     std::vector<GuideId> tree_search_guides;
 
+    /** Directions used in the tree search algorithm; see 'TreeSearchParameters::directions'. */
+    std::vector<Direction> tree_search_directions;
+
+    /**
+     * Re-optimize the bins of the best solution at the end, for the
+     * BinPackingWithLeftovers objective in a not-anytime mode.
+     */
+    bool post_process = true;
+
+    /**
+     * The last bin is re-optimized in the post-process only if it contains
+     * (strictly) fewer items than this threshold.
+     */
+    ItemPos post_process_last_bin_maximum_number_of_items = 32;
+
     /** Threshold to consider that a bin contains "many" items. */
     Counter many_items_in_bins_threshold = 16;
 
     /** Threshold to consider that a bin contains "many" items. */
     Counter many_items_in_bins_threshold_2 = 64;
 
+    /**
+     * Threshold to consider that a bin x (resp. y, z) section - a slice of
+     * the bin as long along x (resp. y, z) as the mean item - contains
+     * "many" items, i.e. mean bin y-z (resp. x-z, x-y) area / mean item y-z
+     * (resp. x-z, x-y) area. Used to choose between 'tree_search' (whose
+     * skyline branching factor grows with how many items pack into a single
+     * such section) and 'tree_search_maximal_spaces' (higher overhead per
+     * node, but does not degrade the same way).
+     */
+    Counter many_items_in_section_threshold = 8;
+
     /** Factor to consider that the number of copies of items is "high". */
     Counter many_item_type_copies_factor = 1;
 

packingsolver-0.1.1237/include/packingsolver/box/post_process.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "packingsolver/box/optimize.hpp"
+
+namespace packingsolver
+{
+namespace box
+{
+
+struct GroupIdenticalBinsOutput: packingsolver::Output<Instance, Solution>
+{
+    GroupIdenticalBinsOutput(const Instance& instance):
+        packingsolver::Output<Instance, Solution>(instance) { }
+};
+
+/**
+ * Group identical bins of a solution together.
+ *
+ * Bins with the same bin type and the same items at the same positions are
+ * merged into a single entry with the combined copy count.
+ */
+GroupIdenticalBinsOutput group_identical_bins(const Solution& solution);
+
+/**
+ * Re-optimize the bin at 'bin_pos' of a solution, as its own single-bin
+ * BinPackingWithLeftovers instance, with 'optimize' and 'parameters' (its
+ * output and its post-process being disabled).
+ *
+ * Return the solution with that bin replaced by the re-optimized one, or the
+ * solution itself if the re-optimization didn't pack all the items of the
+ * bin.
+ */
+Solution reoptimize_bin(
+        const Solution& solution,
+        BinPos bin_pos,
+        const OptimizeParameters& parameters = {});
+
+/**
+ * Re-optimize each bin of a solution except the last one (see
+ * 'reoptimize_bin'), and keep a re-optimized bin if its leftover value is
+ * greater, or if its leftover value is the same and its staircase leftover
+ * value is greater.
+ *
+ * With the algorithms selected as for any instance, a bin with many items
+ * found quickly is re-optimized quickly too.
+ *
+ * The leftover values of the other bins only come after the ones of the last
+ * bin in the objective, so the algorithms hardly try to keep the free space
+ * of the other bins in a single region.
+ */
+Solution reoptimize_non_last_bins(
+        const Solution& solution,
+        const OptimizeParameters& parameters = {});
+
+}
+}

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/box/solution.hpp

@@ -41,6 +41,17 @@ struct SolutionBin
 
     /** Resource consumption, indexed by resource_id. */
     std::vector<double> resource_consumption;
+
+    /** Leftover value of the bin (see 'LeftoverMode'). */
+    Volume leftover_value = 0;
+
+    /**
+     * Staircase leftover value of the bin: the volume of the bin which is not
+     * dominated by an item. An item dominates the points of the box between
+     * the origin of the bin and its opposite corner (see 'LeftoverMode' for
+     * the dimensions of the bin which are not considered).
+     */
+    Volume staircase_leftover_value = 0;
 };
 
 bool operator==(const SolutionBin& solution_bin_1, const SolutionBin& solution_bin_2);
@@ -203,6 +214,18 @@ public:
     /** Get the area of the solution. */
     inline Profit leftover_value() const { return leftover_value_; }
 
+    /** Get the staircase leftover value of the last bin of the solution. */
+    inline Volume staircase_leftover_value() const { return staircase_leftover_value_; }
+
+    /** Get the sum of the leftover values of the bins of the solution. */
+    inline Volume total_leftover_value() const { return total_leftover_value_; }
+
+    /**
+     * Get the sum of the staircase leftover values of the bins of the
+     * solution.
+     */
+    inline Volume total_staircase_leftover_value() const { return total_staircase_leftover_value_; }
+
     /** Get the volume of the solution. */
     inline Volume volume() const { return volume_; }
 
@@ -306,6 +329,15 @@ private:
     /** Value of the leftover. */
     Profit leftover_value_ = 0.0;
 
+    /** Staircase leftover value of the last bin. */
+    Volume staircase_leftover_value_ = 0;
+
+    /** Sum of the leftover values of the bins. */
+    Volume total_leftover_value_ = 0;
+
+    /** Sum of the staircase leftover values of the bins. */
+    Volume total_staircase_leftover_value_ = 0;
+
     /** Total volume of the bins of the solution. */
     Volume bin_volume_ = 0;
 

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/boxstacks/instance.hpp

@@ -111,6 +111,23 @@ std::ostream& operator<<(
         std::ostream& os,
         Box box);
 
+/**
+ * Get the box used in a bin of dimensions 'bin' whose stacks end at 'x_max'
+ * and 'y_max', for a leftover mode (see 'LeftoverMode'): the leftover is the
+ * volume of the bin minus the volume of this box.
+ */
+inline Box leftover_mode_used_box(
+        LeftoverMode leftover_mode,
+        const Box& bin,
+        Length x_max,
+        Length y_max)
+{
+    return {
+        (leftover_mode == LeftoverMode::Y)? bin.x: x_max,
+        (leftover_mode == LeftoverMode::X)? bin.y: y_max,
+        bin.z};
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 ///////////////////////// Item type, Bin type, Defect //////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -357,6 +374,14 @@ struct Parameters
     /** Leftover mode (see 'LeftoverMode'). */
     LeftoverMode leftover_mode = LeftoverMode::XY;
 
+    /**
+     * For the BinPackingWithLeftovers objective, also compare the solutions
+     * on the sum of the leftover values of the bins and on the sum of their
+     * staircase leftover values, after the leftover value and the staircase
+     * leftover value of the last bin.
+     */
+    bool leftover_all_bins = true;
+
     /**
      * 'true' iff weight constraints must be satisfied for all items belonging
      * to a larger or equal group.

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/boxstacks/instance_builder.hpp

@@ -78,6 +78,9 @@ public:
     /** Set the leftover mode (see 'LeftoverMode'). */
     void set_leftover_mode(LeftoverMode leftover_mode) { instance_.parameters_.leftover_mode = leftover_mode; }
 
+    /** Set whether the leftover values of all the bins are compared. */
+    void set_leftover_all_bins(bool leftover_all_bins) { instance_.parameters_.leftover_all_bins = leftover_all_bins; }
+
     /*
      * Set bin types
      */

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/boxstacks/optimize.hpp

@@ -186,6 +186,18 @@ struct OptimizeParameters: packingsolver::Parameters<Instance, Solution, Output>
     /** Guides used in the tree search algorithm. */
     std::vector<GuideId> tree_search_guides;
 
+    /**
+     * Re-optimize the bins of the best solution at the end, for the
+     * BinPackingWithLeftovers objective in a not-anytime mode.
+     */
+    bool post_process = true;
+
+    /**
+     * The last bin is re-optimized in the post-process only if it contains
+     * (strictly) fewer items than this threshold.
+     */
+    ItemPos post_process_last_bin_maximum_number_of_items = 32;
+
     /**
      * Threshold to consider that a bin contains "many" items - see the
      * automatic selection between 'use_sequential_single_knapsack' and

packingsolver-0.1.1237/include/packingsolver/boxstacks/post_process.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "packingsolver/boxstacks/optimize.hpp"
+
+namespace packingsolver
+{
+namespace boxstacks
+{
+
+struct GroupIdenticalBinsOutput: packingsolver::Output<Instance, Solution>
+{
+    GroupIdenticalBinsOutput(const Instance& instance):
+        packingsolver::Output<Instance, Solution>(instance) { }
+};
+
+/**
+ * Group identical bins of a solution together.
+ *
+ * Bins with the same bin type and the same stacks at the same positions are
+ * merged into a single entry with the combined copy count.
+ */
+GroupIdenticalBinsOutput group_identical_bins(const Solution& solution);
+
+/**
+ * Re-optimize the bin at 'bin_pos' of a solution, as its own single-bin
+ * BinPackingWithLeftovers instance, with 'optimize' and 'parameters' (its
+ * output and its post-process being disabled).
+ *
+ * Return the solution with that bin replaced by the re-optimized one, or the
+ * solution itself if the re-optimization didn't pack all the items of the
+ * bin.
+ */
+Solution reoptimize_bin(
+        const Solution& solution,
+        BinPos bin_pos,
+        const OptimizeParameters& parameters = {});
+
+/**
+ * Re-optimize each bin of a solution except the last one (see
+ * 'reoptimize_bin'), and keep a re-optimized bin if its leftover value is
+ * greater, or if its leftover value is the same and its staircase leftover
+ * value is greater.
+ *
+ * With the algorithms selected as for any instance, a bin with many items
+ * found quickly is re-optimized quickly too.
+ *
+ * The leftover values of the other bins only come after the ones of the last
+ * bin in the objective, so the algorithms hardly try to keep the free space
+ * of the other bins in a single region.
+ */
+Solution reoptimize_non_last_bins(
+        const Solution& solution,
+        const OptimizeParameters& parameters = {});
+
+}
+}

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/boxstacks/solution.hpp

@@ -84,6 +84,18 @@ struct SolutionBin
 
     /** Profit. */
     Profit profit = 0.0;
+
+    /** Leftover value of the bin (see 'LeftoverMode'). */
+    Volume leftover_value = 0;
+
+    /**
+     * Staircase leftover value of the bin: the volume of the bin which is not
+     * dominated by a stack. A stack dominates the points of the box between
+     * the origin of the bin and its opposite corner, over the whole height
+     * of the bin (see 'LeftoverMode' for the dimensions of the bin which are
+     * not considered).
+     */
+    Volume staircase_leftover_value = 0;
 };
 
 bool operator==(const SolutionBin& solution_bin_1, const SolutionBin& solution_bin_2);
@@ -277,6 +289,18 @@ public:
      */
     inline Volume leftover_value() const { return bin_volume_ - volume_; }
 
+    /** Get the staircase leftover value of the last bin of the solution. */
+    inline Volume staircase_leftover_value() const { return staircase_leftover_value_; }
+
+    /** Get the sum of the leftover values of the bins of the solution. */
+    inline Volume total_leftover_value() const { return total_leftover_value_; }
+
+    /**
+     * Get the sum of the staircase leftover values of the bins of the
+     * solution.
+     */
+    inline Volume total_staircase_leftover_value() const { return total_staircase_leftover_value_; }
+
     /** Get the fraction of waste of the solution. */
     inline double waste_percentage() const { return (volume() == 0)? 0: (double)waste() / volume(); }
 
@@ -397,6 +421,15 @@ private:
     /** Total volume of the solution. */
     Volume volume_ = 0;
 
+    /** Staircase leftover value of the last bin. */
+    Volume staircase_leftover_value_ = 0;
+
+    /** Sum of the leftover values of the bins. */
+    Volume total_leftover_value_ = 0;
+
+    /** Sum of the staircase leftover values of the bins. */
+    Volume total_staircase_leftover_value_ = 0;
+
     /** Total volume of the bins of the solution. */
     Volume bin_volume_ = 0;
 

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/rectangle/instance.hpp

@@ -314,6 +314,14 @@ struct Parameters
     /** How the leftover value is defined for BinPackingWithLeftovers. */
     LeftoverMode leftover_mode = LeftoverMode::Area;
 
+    /**
+     * For the BinPackingWithLeftovers objective, also compare the solutions
+     * on the sum of the leftover values of the bins and on the sum of their
+     * staircase leftover values, after the leftover value and the staircase
+     * leftover value of the last bin.
+     */
+    bool leftover_all_bins = true;
+
     /**
      * 'true' iff weight constraints must be satisfied for all items belonging
      * to a larger or equal group.

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/rectangle/instance_builder.hpp

@@ -76,6 +76,9 @@ public:
 
     void set_leftover_mode(LeftoverMode leftover_mode) { instance_.parameters_.leftover_mode = leftover_mode; }
 
+    /** Set whether the leftover values of all the bins are compared. */
+    void set_leftover_all_bins(bool leftover_all_bins) { instance_.parameters_.leftover_all_bins = leftover_all_bins; }
+
     /*
      * Set bin types
      */

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/rectangle/optimize.hpp

@@ -226,6 +226,18 @@ struct OptimizeParameters: packingsolver::Parameters<Instance, Solution, Output>
     /** Guides used in the tree search algorithm. */
     std::vector<GuideId> tree_search_guides;
 
+    /**
+     * Re-optimize the bins of the best solution at the end, for the
+     * BinPackingWithLeftovers objective in a not-anytime mode.
+     */
+    bool post_process = true;
+
+    /**
+     * The last bin is re-optimized with the tree search in the post-process
+     * only if it contains (strictly) fewer items than this threshold.
+     */
+    ItemPos post_process_last_bin_maximum_number_of_items = 32;
+
     /** Directions used in the tree search algorithm; see 'TreeSearchParameters::directions'. */
     std::vector<Direction> tree_search_directions;
 

packingsolver-0.1.1237/include/packingsolver/rectangle/post_process.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "packingsolver/rectangle/optimize.hpp"
+
+namespace packingsolver
+{
+namespace rectangle
+{
+
+struct GroupIdenticalBinsOutput: packingsolver::Output<Instance, Solution>
+{
+    GroupIdenticalBinsOutput(const Instance& instance):
+        packingsolver::Output<Instance, Solution>(instance) { }
+};
+
+/**
+ * Group identical bins of a solution together.
+ *
+ * Bins with the same bin type and the same items at the same positions are
+ * merged into a single entry with the combined copy count.
+ */
+GroupIdenticalBinsOutput group_identical_bins(const Solution& solution);
+
+/**
+ * Re-optimize the bin at 'bin_pos' of a solution, as its own single-bin
+ * BinPackingWithLeftovers instance, with 'optimize' and 'parameters' (its
+ * output and its post-process being disabled).
+ *
+ * Return the solution with that bin replaced by the re-optimized one, or the
+ * solution itself if the re-optimization didn't pack all the items of the
+ * bin.
+ */
+Solution reoptimize_bin(
+        const Solution& solution,
+        BinPos bin_pos,
+        const OptimizeParameters& parameters = {});
+
+/**
+ * Re-optimize each bin of a solution except the last one (see
+ * 'reoptimize_bin'), and keep a re-optimized bin if its leftover value is
+ * greater, or if its leftover value is the same and its staircase leftover
+ * value is greater.
+ *
+ * With the algorithms selected as for any instance, a bin with many items
+ * found quickly is re-optimized quickly too.
+ *
+ * The leftover values of the other bins only come after the ones of the last
+ * bin in the objective, so the algorithms hardly try to keep the free space
+ * of the other bins in a single region.
+ */
+Solution reoptimize_non_last_bins(
+        const Solution& solution,
+        const OptimizeParameters& parameters = {});
+
+}
+}

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/include/packingsolver/rectangle/solution.hpp

@@ -46,6 +46,18 @@ struct SolutionBin
 
     /** Resource consumption, indexed by resource_id. */
     std::vector<double> resource_consumption;
+
+    /** Leftover value of the bin (see 'LeftoverMode'). */
+    Area leftover_value = 0;
+
+    /**
+     * Staircase leftover value of the bin: the area of the bin which is not
+     * dominated by an item. An item dominates the points of the rectangle
+     * between the bottom-left corner of the bin and its top-right corner
+     * (see 'LeftoverMode' for the sides of the bin which are not
+     * considered).
+     */
+    Area staircase_leftover_value = 0;
 };
 
 bool operator==(const SolutionBin& solution_bin_1, const SolutionBin& solution_bin_2);
@@ -192,6 +204,18 @@ public:
      */
     inline Profit leftover_value() const { return leftover_value_; }
 
+    /** Get the staircase leftover value of the last bin of the solution. */
+    inline Area staircase_leftover_value() const { return staircase_leftover_value_; }
+
+    /** Get the sum of the leftover values of the bins of the solution. */
+    inline Area total_leftover_value() const { return total_leftover_value_; }
+
+    /**
+     * Get the sum of the staircase leftover values of the bins of the
+     * solution.
+     */
+    inline Area total_staircase_leftover_value() const { return total_staircase_leftover_value_; }
+
     /**
      * Get the area used by the solution: the area of the bins minus the
      * leftover.
@@ -293,6 +317,15 @@ private:
     /** Value of the leftover: an area (see 'LeftoverMode'). */
     Profit leftover_value_ = 0.0;
 
+    /** Staircase leftover value of the last bin. */
+    Area staircase_leftover_value_ = 0;
+
+    /** Sum of the leftover values of the bins. */
+    Area total_leftover_value_ = 0;
+
+    /** Sum of the staircase leftover values of the bins. */
+    Area total_staircase_leftover_value_ = 0;
+
     /** Total area of the bins of the solution. */
     Area bin_area_ = 0;
 

packingsolver-0.1.1237/python/packingsolver/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.1237"

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/python/src/box.cpp

@@ -145,6 +145,7 @@ void bind_box(nb::module_& m)
         .def("read_item_types", &InstanceBuilder::read_item_types, nb::arg("items_path"))
         .def("set_weight_tolerance", &InstanceBuilder::set_weight_tolerance, nb::arg("weight_tolerance"))
         .def("set_leftover_mode", &InstanceBuilder::set_leftover_mode, nb::arg("leftover_mode"))
+        .def("set_leftover_all_bins", &InstanceBuilder::set_leftover_all_bins, nb::arg("leftover_all_bins"))
         // Bin types.
         .def("add_bin_type",
                 [](InstanceBuilder& instance_builder,

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/python/src/boxstacks.cpp

@@ -214,6 +214,7 @@ void bind_boxstacks(nb::module_& m)
                 nb::arg("group_id"), nb::arg("check_weight_constraints"))
         .def("set_unloading_constraint", &InstanceBuilder::set_unloading_constraint, nb::arg("unloading_constraint"))
         .def("set_leftover_mode", &InstanceBuilder::set_leftover_mode, nb::arg("leftover_mode"))
+        .def("set_leftover_all_bins", &InstanceBuilder::set_leftover_all_bins, nb::arg("leftover_all_bins"))
         // Bin types.
         .def("add_bin_type",
                 [](InstanceBuilder& instance_builder,

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/python/src/rectangle.cpp

@@ -115,6 +115,7 @@ void bind_rectangle(nb::module_& m)
                 nb::arg("group_id"), nb::arg("check_weight_constraints"))
         .def("set_unloading_constraint", &InstanceBuilder::set_unloading_constraint, nb::arg("unloading_constraint"))
         .def("set_leftover_mode", &InstanceBuilder::set_leftover_mode, nb::arg("leftover_mode"))
+        .def("set_leftover_all_bins", &InstanceBuilder::set_leftover_all_bins, nb::arg("leftover_all_bins"))
         // Bin types.
         .def("add_bin_type",
                 [](InstanceBuilder& instance_builder,

{packingsolver-0.1.1236 → packingsolver-0.1.1237}/python/tests/test_box.py

@@ -217,6 +217,8 @@ RENAMED = {
 NOT_BOUND = {
     "add_bin_type_resource":
         "creates a resource with its own id; kept as a builder method",
+    "set_bin_type_box":
+        "the dimensions are the positional arguments of add_bin_type",
     "set_item_type_box":
         "the dimensions are the positional arguments of add_item_type",
 }