Dev 2

include/packingsolver/irregular/instance.hpp

@@ -21,7 +21,7 @@ struct Parameters
      * Quality rules.
      *
      * if 'quality_rules_[quality_rule][k] = 0' (resp. '1'), then defect 'k' is
-     * not allowed (resp. allowed) for qulity rule rule 'quality_rule'.
+     * not allowed (resp. allowed) for quality rule rule 'quality_rule'.
      */
     std::vector<std::vector<uint8_t>> quality_rules;
 
@@ -147,7 +147,7 @@ struct ItemShape
     std::vector<Shape> holes_deflated;
 
     /** Quality rule. */
-    QualityRule quality_rule = 0;
+    QualityRule quality_rule = -1;
 
     bool check() const;
 

include/packingsolver/onedimensional/instance_builder.hpp

@@ -66,7 +66,8 @@ class InstanceBuilder
      */
     void add_bin_type(
             const BinType& bin_type,
-            BinPos copies);
+            BinPos copies,
+            BinPos copies_min = 0);
 
     /**
      * Foe each bin type, set an infinite number of copies.

include/packingsolver/rectangle/instance_builder.hpp

@@ -85,7 +85,8 @@ class InstanceBuilder
      */
     void add_bin_type(
             const BinType& bin_type,
-            BinPos copies);
+            BinPos copies,
+            BinPos copies_min = 0);
 
     /**
      * For each bin type, set an infinite x.

src/algorithms/sequential_value_correction.hpp

@@ -448,6 +448,8 @@ SequentialValueCorrectionOutput<Instance, Solution> sequential_value_correction(
             //std::cout << "item_type_id " << item_type_id
             //    << " adjusted_space " << item_type_adjusted_space[item_type_id]
             //    << " profit " << profits[item_type_id];
+            item_type_adjusted_space[item_type_id]
+                += 100 * lbs * (item_type.copies - solution.item_copies(item_type_id));
             Profit profit_new = 0.0;
             if (instance.objective() == Objective::Knapsack) {
                 profit_new
@@ -456,8 +458,6 @@ SequentialValueCorrectionOutput<Instance, Solution> sequential_value_correction(
                     * item_type_adjusted_space[item_type_id]
                     / solution.item_copies(item_type_id);
             } else {
-                item_type_adjusted_space[item_type_id]
-                    += 100 * lbs * (item_type.copies - solution.item_copies(item_type_id));
                 profit_new
                     = item_type_adjusted_space[item_type_id]
                     / item_type.copies;

src/irregular/instance.cpp

@@ -279,6 +279,8 @@ bool Instance::can_contain(
         QualityRule quality_rule,
         DefectTypeId type) const
 {
+    if (quality_rule == -1)
+        return false;
     if (type < 0 || type > (QualityRule)parameters_.quality_rules[quality_rule].size())
         return false;
     return parameters_.quality_rules[quality_rule][type];

src/irregular/instance_builder.cpp

@@ -134,6 +134,11 @@ ItemTypeId InstanceBuilder::add_item_type(
         ItemPos copies,
         const std::vector<std::pair<Angle, Angle>>& allowed_rotations)
 {
+    if (shapes.empty()) {
+        throw std::invalid_argument(
+                "packingsolver::irregular::InstanceBuilder::add_item_type: "
+                "item 'shapes' must be non-empty.");
+    }
     for (const ItemShape& item_shape: shapes) {
         if (!item_shape.check()) {
             throw std::runtime_error(
@@ -530,6 +535,25 @@ Instance InstanceBuilder::build()
             if (!item_shape.shape_scaled.elements.empty())
                 continue;
 
+            if (item_shape.quality_rule < -1) {
+                throw std::invalid_argument(
+                        "packingsolver::irregular::InstanceBuilder::build: "
+                        "invalid quality rule; "
+                        "item_type_id: " + std::to_string(item_type_id) + "; "
+                        "item_shape_pos: " + std::to_string(shape_pos) + "; "
+                        "quality_rule: " + std::to_string(item_shape.quality_rule) + ".");
+            }
+            if (item_shape.quality_rule != -1
+                    && item_shape.quality_rule >= instance_.parameters_.quality_rules.size()) {
+                throw std::invalid_argument(
+                        "packingsolver::irregular::InstanceBuilder::build: "
+                        "invalid quality rule; "
+                        "item_type_id: " + std::to_string(item_type_id) + "; "
+                        "item_shape_pos: " + std::to_string(shape_pos) + "; "
+                        "quality_rule: " + std::to_string(item_shape.quality_rule) + "; "
+                        "parameters().quality_rules.size(): " + std::to_string(instance_.parameters().quality_rules.size()) + ".");
+            }
+
             auto res = process_shape_outer(instance_.parameters().scale_value * item_shape.shape_orig);
             item_shape.shape_scaled = res.first;
             for (const Shape& hole: res.second)

src/onedimensional/instance_builder.cpp

@@ -94,12 +94,14 @@ void InstanceBuilder::add_bin_type_eligibility(
 
 void InstanceBuilder::add_bin_type(
         const BinType& bin_type,
-        BinPos copies)
+        BinPos copies,
+        BinPos copies_min)
 {
     BinTypeId bin_type_id = add_bin_type(
             bin_type.length,
             bin_type.cost,
-            copies);
+            copies,
+            copies_min);
     set_bin_type_maximum_weight(
             bin_type_id,
             bin_type.maximum_weight);

src/rectangle/instance_builder.cpp

@@ -138,13 +138,15 @@ DefectId InstanceBuilder::add_defect(
 
 void InstanceBuilder::add_bin_type(
         const BinType& bin_type,
-        BinPos copies)
+        BinPos copies,
+        BinPos copies_min)
 {
     BinTypeId bin_type_id = add_bin_type(
             bin_type.rect.x,
             bin_type.rect.y,
             bin_type.cost,
-            copies);
+            copies,
+            copies_min);
     set_bin_type_maximum_weight(
             bin_type_id,
             bin_type.maximum_weight);