@jetta/blocks-allocator 0.1.0-0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jetta/blocks-allocator",
-    "version": "0.1.0-0",
+    "version": "0.2.0",
     "description": "Blocks wall allocation library",
     "main": "src/index.js",
     "exports": {

package/src/Allocation_Optimization/lp_model/model_builder/restrictions/Container_Supported_Weight_Restriction.js

@@ -1,42 +1,86 @@
 const { VariableType, create_variable, create_restriction } = require('@jetta/lp-framework')
-const {
-    get_dimension_to_max_weight_map,
-    calculate_block_potential_weight
-} = require('../../../Block_Potential_Weight')
+const create_item_assignment_variables = require('../Item_Assignment_Variables')
 
 /**
- * Creates a single LP restriction to ensure the total weight of items in the chosen blocks
- * does not exceed the container's supported weight.
- * @param {object} container - The container object, with a supported_weight() method.
- * @param {object[]} block_list - An array of Block objects.
- * @param {object[]} item_list - An array of Item objects.
- * @returns {Restriction[]} An array containing the single weight restriction.
+ * Creates one LP restriction so the weight of items assigned to chosen blocks
+ * stays within the container supported weight.
+ * Each assignment variable is weighted by that item's own weight.
+ * @param {object} container - Container with supported_weight() or a supported_weight number.
+ * @param {object[]} block_list - Block objects.
+ * @param {object[]} item_list - Item objects with get_id() and get_weight().
+ * @returns {object[]} One restriction, or an empty list when no positive item weight applies.
  */
 module.exports = function create_container_supported_weight_restriction(container, block_list, item_list)
 {
-    const dimension_to_max_weight_map = get_dimension_to_max_weight_map(item_list)
+    const assignment = create_item_assignment_variables(block_list, item_list)
+    const variable_list = build_item_weight_variables(assignment.slot_demand_list, item_list)
+    if (variable_list.length === 0)
+    {
+        return []
+    }
+    return [create_restriction(
+        'container_supported_weight',
+        variable_list,
+        {lower_limit: 0, upper_limit: read_supported_weight(container)}
+    )]
+}
+
+/**
+ * @param {Array<{compatibility_list: Array<{item_id: string, variable_name: string}>}>} slot_demand_list
+ * @param {object[]} item_list
+ * @returns {object[]}
+ */
+function build_item_weight_variables(slot_demand_list, item_list)
+{
+    const weight_by_item_id = map_item_weight(item_list)
     const variable_list = []
+    for (const slot_demand of slot_demand_list)
+    {
+        append_slot_item_weights(variable_list, slot_demand.compatibility_list, weight_by_item_id)
+    }
+    return variable_list
+}
 
-    for (const block of block_list)
+/**
+ * @param {object[]} item_list
+ * @returns {Map<string, number>}
+ */
+function map_item_weight(item_list)
+{
+    const weight_by_item_id = new Map()
+    for (const item of item_list)
     {
-        const block_potential_weight = calculate_block_potential_weight(block, dimension_to_max_weight_map)
+        weight_by_item_id.set(item.get_id(), item.get_weight())
+    }
+    return weight_by_item_id
+}
 
-        if (block_potential_weight > 0)
+/**
+ * @param {object[]} variable_list
+ * @param {Array<{item_id: string, variable_name: string}>} compatibility_list
+ * @param {Map<string, number>} weight_by_item_id
+ */
+function append_slot_item_weights(variable_list, compatibility_list, weight_by_item_id)
+{
+    for (const entry of compatibility_list)
+    {
+        const item_weight = weight_by_item_id.get(entry.item_id) || 0
+        if (item_weight > 0)
         {
-            variable_list.push(create_variable(block.get_id(), block_potential_weight, VariableType.INTEGER))
+            variable_list.push(create_variable(entry.variable_name, item_weight, VariableType.INTEGER))
         }
     }
+}
 
-    if (variable_list.length === 0)
+/**
+ * @param {object} container
+ * @returns {number}
+ */
+function read_supported_weight(container)
+{
+    if (typeof container.supported_weight === 'function')
     {
-        return []
+        return container.supported_weight()
     }
-
-    const supported_weight = typeof container.supported_weight === 'function'
-        ? container.supported_weight()
-        : container.supported_weight
-
-    const name = 'container_supported_weight'
-    const restriction = create_restriction(name, variable_list, {lower_limit: 0, upper_limit: supported_weight})
-    return [restriction]
+    return container.supported_weight
 }