code/python/assets/commands.yaml

@@ -80,7 +80,6 @@
   algorithm: GREEDY
   allow-fractional: true
   capacity: 10
-  items: [a, b, c, d, e]
   weights:
     [3, 4, 5, 2, 1]
   values:
@@ -89,6 +88,7 @@
   algorithm: BRANCH-AND-BOUND
 - name: RUCKSACK
   algorithm: BRANCH-AND-BOUND
+  allow-fractional: true
   capacity: 90
   items: [
     'Sonnenblumenkerne',

code/python/models/commands-schema.yaml

@@ -116,6 +116,7 @@ components:
       type: object
       required:
         - algorithm
+        - allow-fractional
         - capacity
         - weights
         - values

code/python/src/algorithms/rucksack/algorithms.py

@@ -9,7 +9,6 @@ from src.thirdparty.types import *;
 from src.thirdparty.maths import *;
 
 from models.generated.config import *;
-from src.core.utils import *;
 from src.models.rucksack import *;
 from src.models.stacks import *;
 from src.algorithms.rucksack.display import *;
@@ -44,11 +43,10 @@ def rucksack_greedy_algorithm(
     '''
     # sortiere daten:
     order = resort_by_value_per_weight(weights=weights, values=values, items=items);
-    uorder = iperm(order);
 
     # verbose output hier behandeln (irrelevant für Algorithmus):
     if verbose:
-        repr = display_order(order=order, weights=weights[uorder], values=values[uorder], items=items[uorder], one_based=True);
+        repr = display_order(order=order, weights=weights, values=values, items=items, one_based=True);
         print('');
         print('\x1b[1mRucksack Problem - Greedy\x1b[0m');
         print('');
@@ -59,19 +57,21 @@ def rucksack_greedy_algorithm(
     n = len(weights);
     weight_total = 0;
     vector = [ 0 for _ in range(n) ];
+    rucksack = [];
     for i in range(n):
         # füge Item i hinzu, solange das Gesamtgewicht noch <= Schranke
         if weight_total + weights[i] <= capacity:
             weight_total += weights[i];
+            rucksack.append(i);
             vector[i] = 1;
         # sonst abbrechen. Falls Bruchteile erlaubt, füge einen Bruchteil des i. Items hinzu
         else:
             if fractional:
+                rucksack.append(i);
                 vector[i] = (capacity - weight_total)/weights[i];
             break;
 
     # Aspekte der Lösung speichern:
-    rucksack = [i for i, v in enumerate(vector) if v > 0]; # Indexes von Items im Rucksack
     soln = Solution(
         vector = vector,
         items = items[rucksack].tolist(),
@@ -81,19 +81,13 @@ def rucksack_greedy_algorithm(
 
     # verbose output hier behandeln (irrelevant für Algorithmus):
     if verbose:
-        # Umsortierung rückgängig machen:
+        expr_value = display_sum(vector=soln.vector, values=values);
-        vector = [ soln.vector[i] for i in order ];
+        expr_weight = display_sum(vector=soln.vector, values=weights);
-        rucksack = [ uorder[r] for r in rucksack ];
+        print('\x1b[1mEingeschätztes Maximum\x1b[0m');
-        permute_data(weights=weights, values=values, items=items, perm=uorder);
-        # Ausdrücke bestimmen:
-        expr_value = display_sum(vector=vector, values=values);
-        expr_weight = display_sum(vector=vector, values=weights);
-        print('\x1b[1mEingeschätzte Lösung\x1b[0m');
         print('');
+        print(f'Rucksack: {", ".join(soln.items)}.');
         if fractional:
-            print(f'Mask: {soln.vector}');
+            print(f'Vector: {soln.vector_support}');
-            print(f'      ---> {vector} (unter urspr. Sortierung)');
-        print(f'Rucksack: {", ".join(items[rucksack])}.');
         print(f'max. Value ≈ {expr_value}');
         print(f'∑ Weights  = {expr_weight}');
         print('');
@@ -118,11 +112,10 @@ def rucksack_branch_and_bound_algorithm(
     '''
 
     order = resort_by_value_per_weight(weights=weights, values=values, items=items);
-    uorder = iperm(order);
 
     # verbose output hier behandeln (irrelevant für Algorithmus):
     if verbose:
-        repr = display_order(order=order, weights=weights[uorder], values=values[uorder], items=items[uorder], one_based=True);
+        repr = display_order(order=order, weights=weights, values=values, items=items, one_based=True);
         print('');
         print('\x1b[1mRucksack Problem - Branch & Bound\x1b[0m');
         print('');
@@ -165,22 +158,14 @@ def rucksack_branch_and_bound_algorithm(
 
     # verbose output hier behandeln (irrelevant für Algorithmus):
     if verbose:
-        # NOTE: Information in Tabelle gemäß permutierten Daten:
+        expr_value = display_sum(vector=soln.vector, values=values);
+        expr_weight = display_sum(vector=soln.vector, values=weights);
         repr = display_branch_and_bound(values=values, steps=logged_steps);
-        # Umsortierung rückgängig machen:
+        print('\x1b[1mMaximum\x1b[0m');
-        vector = [ soln.vector[i] for i in order ];
-        rucksack = [ uorder[r] for r in rucksack ];
-        permute_data(weights=weights, values=values, items=items, perm=uorder);
-        # Ausdrücke bestimmen:
-        expr_value = display_sum(vector=vector, values=values);
-        expr_weight = display_sum(vector=vector, values=weights);
-        print('\x1b[1mLösung\x1b[0m');
         print('');
         print(repr);
         print('');
-        print(f'Mask: {soln.vector}');
+        print(f'Rucksack: {", ".join(soln.items)}.');
-        print(f'      ---> {vector} (unter urspr. Sortierung)');
-        print(f'Rucksack: {", ".join(items[rucksack])}.');
         print(f'max. Value ≈ {expr_value}');
         print(f'∑ Weights  = {expr_weight}');
         print('');
@@ -203,20 +188,11 @@ def resort_by_value_per_weight(
     n = len(weights);
     indexes = list(range(n));
     order = sorted(indexes, key=lambda i: -values[i]/weights[i]);
-    permute_data(weights=weights, values=values, items=items, perm=order);
+    weights[:] = weights[order];
+    values[:] = values[order];
+    items[:] = items[order];
     return order;
 
-def permute_data(
-    weights: np.ndarray,
-    values: np.ndarray,
-    items: np.ndarray,
-    perm: List[int],
-):
-    weights[:] = weights[perm];
-    values[:] = values[perm];
-    items[:] = items[perm];
-    return;
-
 def estimate_lower_bound(
     mask: Mask,
     capacity: float,

code/python/src/algorithms/rucksack/display.py

@@ -9,6 +9,7 @@ from src.thirdparty.code import *;
 from src.thirdparty.maths import *;
 from src.thirdparty.types import *;
 
+from src.core.utils import *;
 from src.models.stacks import *;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -32,16 +33,18 @@ def display_order(
     items: np.ndarray,
     one_based: bool = False,
 ) -> str:
+    index = range(len(order));
+    uorder = iperm(order);
     table = pd.DataFrame({
         'items':   items,
-        'order':   order,
+        'index':   index,
         'values':  values,
         'weights': weights,
         'u':       (values/weights),
-    }) \
+    }, index=index) \
-    .reset_index(drop=True);
+    .reindex(uorder);
     if one_based:
-        table['order'] += 1;
+        table['index'] += 1;
     # benutze pandas-Dataframe + tabulate, um schöner darzustellen:
     repr = tabulate(
         pd.DataFrame(table),
@@ -59,17 +62,13 @@ def display_order(
 def display_sum(
     vector: Union[List[int], List[float]],
     values: np.ndarray,
-    as_maximum: bool = True,
 ) -> str:
     value = sum([ u*x for u, x in zip(vector,values)]);
     expr = '+'.join([
         f'{x:g}' if u == 1 else f'{Fraction(str(u))}·{x:g}'
         for u, x in zip(vector,values) if u > 0
     ]);
-    if as_maximum:
+    return f'{value:g} (={expr})';
-        return f'{value:g} = {expr}';
-    else:
-        return f'-{value:g} = -({expr})';
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # METHOD display result of branch and bound
@@ -87,7 +86,7 @@ def display_branch_and_bound(
             rows.append((f'{lb_estimate:g}', f'{lb:g}', S));
         else:
             used_vectors.append(u)
-            rows.append((f'{lb_estimate:g}', display_sum(vector=u, values=values, as_maximum=False), S));
+            rows.append((f'{lb_estimate:g}', display_sum(vector=u, values=values), S));
 
     table = pd.DataFrame(rows) \
         .rename(columns={0: 'b', 1: 'g(TOP(S))', 2: 'S'}) \