Fix typo remaiing -> remaining

Author: fontanf

include/packingsolver/onedimensional/solution.hpp

@@ -40,7 +40,7 @@ struct SolutionBin
      * Remaining weight allowed in the bin to satisfy the maximum
      * weight after constraint.
      */
-    Weight remaiing_weight = -1;
+    Weight remaining_weight = -1;
 };
 
 /**

src/boxstacks/branching_scheme.cpp

@@ -554,8 +554,8 @@ BranchingScheme::Node BranchingScheme::child_tmp(
         node.uncovered_items[insertion.uncovered_item_pos].maximum_number_of_items = std::min(
                 parent.uncovered_items[insertion.uncovered_item_pos].maximum_number_of_items,
                 item_type.maximum_stackability);
-        node.uncovered_items[insertion.uncovered_item_pos].remaiing_weight = std::min(
-                parent.uncovered_items[insertion.uncovered_item_pos].remaiing_weight - item_type.weight,
+        node.uncovered_items[insertion.uncovered_item_pos].remaining_weight = std::min(
+                parent.uncovered_items[insertion.uncovered_item_pos].remaining_weight - item_type.weight,
                 item_type.maximum_weight_above);
     } else if (insertion.new_bin > 0) {  // New bin.
         if (ys > 0) {
@@ -571,7 +571,7 @@ BranchingScheme::Node BranchingScheme::child_tmp(
             uncovered_item.item_type_ids.push_back(insertion.item_type_id);
             uncovered_item.weight = item_type.weight;
             uncovered_item.maximum_number_of_items = item_type.maximum_stackability;
-            uncovered_item.remaiing_weight = item_type.maximum_weight_above;
+            uncovered_item.remaining_weight = item_type.maximum_weight_above;
             uncovered_item.ze = zj;
             uncovered_item.xs = xs;
             uncovered_item.xe = xe;
@@ -603,7 +603,7 @@ BranchingScheme::Node BranchingScheme::child_tmp(
                 new_uncovered_item_2.item_type_ids.push_back(insertion.item_type_id);
                 new_uncovered_item_2.weight = item_type.weight;
                 new_uncovered_item_2.maximum_number_of_items = item_type.maximum_stackability;
-                new_uncovered_item_2.remaiing_weight = item_type.maximum_weight_above;
+                new_uncovered_item_2.remaining_weight = item_type.maximum_weight_above;
                 new_uncovered_item_2.ze = zj;
                 new_uncovered_item_2.xs = xs;
                 new_uncovered_item_2.xe = xe;
@@ -988,7 +988,7 @@ void BranchingScheme::insertion_item_above(
         return;
     }
     // Check maximum weight above.
-    if (item_type.weight > uncovered_item.remaiing_weight) {
+    if (item_type.weight > uncovered_item.remaining_weight) {
         return;
     }
     // Check unloading constraints.

src/boxstacks/branching_scheme.hpp

@@ -45,7 +45,7 @@ class BranchingScheme
          * Remaining weight allowed in the stack to satisfy the maximum weight
          * above constraint.
          */
-        Weight remaiing_weight = -1;
+        Weight remaining_weight = -1;
 
         /** Start x-coordiante. */
         Length xs;
@@ -367,8 +367,8 @@ class BranchingScheme
             }
             if (uncovered_item_1.ze > uncovered_item_2.ze)
                 return false;
-            if (uncovered_item_1.remaiing_weight < instance().item_weight()
-                    && uncovered_item_1.remaiing_weight < uncovered_item_2.remaiing_weight)
+            if (uncovered_item_1.remaining_weight < instance().item_weight()
+                    && uncovered_item_1.remaining_weight < uncovered_item_2.remaining_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)

src/onedimensional/branching_scheme.cpp

@@ -39,7 +39,7 @@ BranchingScheme::Node BranchingScheme::child_tmp(
         node.last_bin_number_of_items = 1;
         node.last_bin_weight = item_type.weight;
         node.last_bin_maximum_number_of_items = item_type.maximum_stackability;
-        node.last_bin_remaiing_weight = item_type.maximum_weight_after;
+        node.last_bin_remaining_weight = item_type.maximum_weight_after;
     } else {  // Same bin.
         node.number_of_bins = parent.number_of_bins;
         node.last_bin_length = parent.last_bin_length + item_type.length - item_type.nesting_length;
@@ -49,8 +49,8 @@ BranchingScheme::Node BranchingScheme::child_tmp(
         node.last_bin_maximum_number_of_items = std::min(
                 parent.last_bin_maximum_number_of_items,
                 item_type.maximum_stackability);
-        node.last_bin_remaiing_weight = std::min(
-                parent.last_bin_remaiing_weight - item_type.weight,
+        node.last_bin_remaining_weight = std::min(
+                parent.last_bin_remaining_weight - item_type.weight,
                 item_type.maximum_weight_after);
     }
 
@@ -138,7 +138,7 @@ void BranchingScheme::insertion_item_same_bin(
     if (parent->last_bin_number_of_items + 1 > last_bin_maximum_number_of_items)
         return;
     // Check maximum weight above.
-    if (item_type.weight > parent->last_bin_remaiing_weight * PSTOL)
+    if (item_type.weight > parent->last_bin_remaining_weight * PSTOL)
         return;
 
     Insertion insertion;

src/onedimensional/branching_scheme.hpp

@@ -102,7 +102,7 @@ class BranchingScheme
          * Remaining weight allowed in the last bin to satisfy the maximum
          * weight after constraint.
          */
-        Weight last_bin_remaiing_weight = -1;
+        Weight last_bin_remaining_weight = -1;
 
     };
 

src/onedimensional/solution.cpp

@@ -70,19 +70,19 @@ void Solution::add_item(
     // Update bin.maximum_number_of_items and bin.maximum_number_of_items.
     if (bin.items.size() == 1) {
         bin.maximum_number_of_items = item_type.maximum_stackability;
-        bin.remaiing_weight = item_type.maximum_weight_after;
+        bin.remaining_weight = item_type.maximum_weight_after;
     } else {
         bin.maximum_number_of_items = std::min(
                 bin.maximum_number_of_items,
                 item_type.maximum_stackability);
-        bin.remaiing_weight = std::min(
-                bin.remaiing_weight - item_type.weight,
+        bin.remaining_weight = std::min(
+                bin.remaining_weight - item_type.weight,
                 item_type.maximum_weight_after);
     }
     if (bin.items.size() > bin.maximum_number_of_items) {
         feasible_ = false;
     }
-    if (bin.remaiing_weight < 0) {
+    if (bin.remaining_weight < 0) {
         feasible_ = false;
     }