code/python/assets/commands.yaml

@@ -89,8 +89,10 @@
   algorithm: BRANCH-AND-BOUND
   max-cost: 10
   items: [a, b, c, d, e]
-  costs: [3, 4, 5, 2, 1]
+  costs:
-  values: [8, 7, 8, 3, 2]
+    [3, 4, 5, 2, 1]
+  values:
+    [8, 7, 8, 3, 2]
 - name: RUCKSACK
   algorithm: BRANCH-AND-BOUND
   max-cost: 460
@@ -101,8 +103,10 @@
     'Schokolade',
     'Apfelringe',
   ]
-  costs: [220, 80, 140, 90, 100]
+  costs:
-  values: [100, 10, 70, 80, 100]
+    [220, 80, 140, 90, 100]
+  values:
+    [100, 10, 70, 80, 100]
 - name: RUCKSACK
   algorithm: BRANCH-AND-BOUND
   max-cost: 90
@@ -113,17 +117,7 @@
     'Hirse',
     'Sellerie',
   ]
-  costs: [30, 10, 50, 10, 80]
+  costs:
-  values: [17, 14, 17,  5, 25]
+    [30, 10, 50, 10, 80]
-
+  values:
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    [17, 14, 17,  5, 25]
-# Beispiele für Seminarwoche 12
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-- name: EUKLID
-  numbers:
-    - 2017
-    - 58
-- name: POLLARD-RHO
-  number: 534767
-  x-init: 5

code/python/assets/config.yaml

@@ -26,21 +26,13 @@ options:
     verbose:
       - COSTS
       - MOVES
-    show: []
+    # show: []
-    # show:
+    show:
-    #   - ATOMS
+      # - ATOMS
-    #   - TREE
+      - TREE
   rucksack:
-    verbose: *ref_verbose
+    verbose: true
-    show: []
+    # show: []
-    # show:
+    show:
-    #   - ALL-WEIGHTS
+      - ALL-WEIGHTS
-    #   - ALL-SUMS
+      - ALL-SUMS
-  genetic:
-    verbose: *ref_verbose
-  random-walk:
-    verbose: *ref_verbose
-  euklid:
-    verbose: *ref_verbose
-  pollard-rho:
-    verbose: *ref_verbose

code/python/dist/VERSION

@@ -1 +1 @@
-0.3.0
+0.2.0

code/python/docs/commands/Models/CommandEuklid.md

@@ -1,10 +0,0 @@
-# CommandEuklid
-## Properties
-
-Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
-**name** | [**EnumAlgorithmNames**](EnumAlgorithmNames.md) |  | [default to null]
-**numbers** | [**List**](integer.md) |  | [default to null]
-
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-

code/python/docs/commands/Models/CommandPollard.md

@@ -1,11 +0,0 @@
-# CommandPollard
-## Properties
-
-Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
-**name** | [**EnumAlgorithmNames**](EnumAlgorithmNames.md) |  | [default to null]
-**number** | [**Integer**](integer.md) |  | [default to null]
-**xMinusinit** | [**Integer**](integer.md) |  | [optional] [default to 2]
-
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-

code/python/docs/commands/Models/CommandRucksack.md

@@ -3,7 +3,6 @@
 
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
-**name** | [**EnumAlgorithmNames**](EnumAlgorithmNames.md) |  | [default to null]
 **algorithm** | [**EnumRucksackAlgorithm**](EnumRucksackAlgorithm.md) |  | [default to null]
 **allowMinusfractional** | [**Boolean**](boolean.md) |  | [optional] [default to false]
 **maxMinuscost** | [**BigDecimal**](number.md) | Upper bound for total cost of rucksack. | [default to null]

code/python/docs/commands/README.md

@@ -13,9 +13,7 @@ Class | Method | HTTP request | Description
 ## Documentation for Models
 
  - [Command](.//Models/Command.md)
- - [CommandEuklid](.//Models/CommandEuklid.md)
  - [CommandHirschberg](.//Models/CommandHirschberg.md)
- - [CommandPollard](.//Models/CommandPollard.md)
  - [CommandRucksack](.//Models/CommandRucksack.md)
  - [CommandTarjan](.//Models/CommandTarjan.md)
  - [CommandTsp](.//Models/CommandTsp.md)

code/python/docs/config/Models/AppOptions.md

@@ -9,8 +9,6 @@ Name | Type | Description | Notes
 **tsp** | [**AppOptions_tarjan**](AppOptions_tarjan.md) |  | [default to null]
 **hirschberg** | [**AppOptions_hirschberg**](AppOptions_hirschberg.md) |  | [default to null]
 **rucksack** | [**AppOptions_rucksack**](AppOptions_rucksack.md) |  | [default to null]
-**euklid** | [**AppOptions_tarjan**](AppOptions_tarjan.md) |  | [default to null]
-**pollardMinusrho** | [**AppOptions_tarjan**](AppOptions_tarjan.md) |  | [default to null]
 
 [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
 

code/python/models/commands-schema.yaml

@@ -1,6 +1,6 @@
 openapi: 3.0.3
 info:
-  version: 0.3.0
+  version: 0.2.0
   title: Schemata for command instructions
 servers:
   - url: "."
@@ -115,14 +115,11 @@ components:
         Instructions for execution of Branch & Bound-Algorithm for the Rucksack-Problem
       type: object
       required:
-        - name
         - algorithm
         - max-cost
         - costs
         - values
       properties:
-        name:
-          $ref: '#/components/schemas/EnumAlgorithmNames'
         algorithm:
           $ref: '#/components/schemas/EnumRucksackAlgorithm'
         allow-fractional:
@@ -149,147 +146,6 @@ components:
           items:
             type: string
           default: []
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    # Algorithm: Random Walk
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    CommandRandomWalk:
-      description: |-
-        Instructions for execution of random walks to determine local extrema in a fitness landscape
-      type: object
-      required:
-        - name
-        - algorithm
-        - landscape
-        - optimise
-      properties:
-        name:
-          $ref: '#/components/schemas/EnumAlgorithmNames'
-        algorithm:
-          $ref: '#/components/schemas/EnumWalkMode'
-        landscape:
-          $ref: '#/components/schemas/DataTypeLandscapeGeometry'
-        optimise:
-          $ref: '#/components/schemas/EnumOptimiseMode'
-        coords-init:
-          description: Initial co-ordinates to start the algorithm.
-          type: array
-          items:
-            type: integer
-          minItems: 1
-        temperature-init:
-          type: float
-          default: 1.
-        annealing:
-          type: boolean
-          default: false
-        one-based:
-          type: boolean
-          default: false
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    # Algorithm: Genetic Algorithm
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    CommandGenetic:
-      description: |-
-        Instructions for execution of the Genetic algorithm
-      type: object
-      required:
-        - name
-        - population
-      properties:
-        name:
-          $ref: '#/components/schemas/EnumAlgorithmNames'
-        population:
-          type: array
-          items:
-            type: array
-            items:
-              type: string
-          minItems: 2
-          # maxItems: 2 # FIXME: does not work!
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    # Algorithm: Euklidean algorithm
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    CommandEuklid:
-      description: |-
-        Instructions for execution of the Euklidean gcd-algorithm
-      type: object
-      required:
-        - name
-        - numbers
-      properties:
-        name:
-          $ref: '#/components/schemas/EnumAlgorithmNames'
-        numbers:
-          type: array
-          items:
-            type: integer
-            exclusiveMinimum: 0
-          minItems: 2
-          maxItems: 2
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    # Algorithm: Pollard's rho
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    CommandPollard:
-      description: |-
-        Instructions for execution of the Pollard's rho algorithm
-      type: object
-      required:
-        - name
-        - number
-      properties:
-        name:
-          $ref: '#/components/schemas/EnumAlgorithmNames'
-        number:
-          type: integer
-          exclusiveMinimum: 0
-        x-init:
-          type: integer
-          default: 2
-          minimum: 2
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    # Data-type Landscape Geometry, Landscape Values
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    DataTypeLandscapeGeometry:
-      description: |-
-        Structure for the geometry of a fitness landscape
-      type: object
-      required:
-        - neighbourhoods
-        - labels
-        - values
-      properties:
-        neighbourhoods:
-          $ref: '#/components/schemas/DataTypeLandscapeNeighbourhoods'
-        labels:
-          type: array
-          items:
-            type: string
-          minItems: 1
-        values:
-          $ref: '#/components/schemas/DataTypeLandscapeValues'
-    DataTypeLandscapeNeighbourhoods:
-      description: |-
-        Options for the definition of discrete neighbourhoods of a fitness landscape
-      type: object
-      required:
-        - metric
-      properties:
-        radius:
-          type: number
-          minimum: 1
-          default: 1
-        metric:
-          $ref: '#/components/schemas/EnumLandscapeMetric'
-    DataTypeLandscapeValues:
-      description: |-
-        A (potentially multi-dimensional) array of values for the fitness landscape.
-      oneOf:
-        - type: array
-          items:
-            type: number
-        - type: array
-          items:
-            $ref: '#/components/schemas/DataTypeLandscapeValues'
     # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     # Enum Algorithm Names
     # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -302,10 +158,6 @@ components:
         - TSP
         - HIRSCHBERG
         - RUCKSACK
-        - RANDOM-WALK
-        - GENETIC
-        - EUKLID
-        - POLLARD-RHO
     # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     # Enum Optimise Mode
     # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -326,29 +178,3 @@ components:
       enum:
         - GREEDY
         - BRANCH-AND-BOUND
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    # Enum Type of walk mode for fitness walk algorithm
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    EnumWalkMode:
-      description: |-
-        Enumeration of walk mode for fitness walk algorithm
-        - `ADAPTIVE` - points uniformly randomly chosen from nbhd.
-        - `GRADIENT` - points uniformly randomly chosen amongst points in nbhd with steepest gradient.
-        - `METROPOLIS` - points uniformly randomly chosen from nbhd. or by entropy.
-      type: string
-      enum:
-        - ADAPTIVE
-        - GRADIENT
-        - METROPOLIS
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    # Enum for metric for neighbourhoods in fitness landscape
-    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    EnumLandscapeMetric:
-      description: |-
-        Enumeration of mode for Rucksack problem
-        - `MAXIMUM` - `Q` is a neighbour of `P` <==> `max_i d(P_i, Q_i) <= r`
-        - `MANHATTAN` - `Q` is a neighbour of `P` <==> `sum_i d(P_i, Q_i) <= r`
-      type: string
-      enum:
-        - MAXIMUM
-        - MANHATTAN

code/python/models/config-schema.yaml

@@ -1,6 +1,6 @@
 openapi: 3.0.3
 info:
-  version: 0.3.0
+  version: 0.2.0
   title: Schemata for config models
 servers:
   - url: "."
@@ -54,10 +54,6 @@ components:
         - tarjan
         - hirschberg
         - rucksack
-        - random-walk
-        - genetic
-        - euklid
-        - pollard-rho
       properties:
         log-level:
           $ref: '#/components/schemas/EnumLogLevel'
@@ -131,38 +127,6 @@ components:
               items:
                 $ref: '#/components/schemas/EnumRucksackShow'
               default: []
-        random-walk:
-          type: object
-          required:
-            - verbose
-          properties:
-            verbose:
-              type: boolean
-              default: false
-        genetic:
-          type: object
-          required:
-            - verbose
-          properties:
-            verbose:
-              type: boolean
-              default: false
-        euklid:
-          type: object
-          required:
-            - verbose
-          properties:
-            verbose:
-              type: boolean
-              default: false
-        pollard-rho:
-          type: object
-          required:
-            - verbose
-          properties:
-            verbose:
-              type: boolean
-              default: false
     # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     # Enum LogLevel
     # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

code/python/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uni-leipzig-ads-2-2022"
-version = "0.3.0"
+version = "0.2.0"
 description = "Zusatzcode, um Algorithmen und Datenstrukturen im Kurs ADS2 zu demonstrieren."
 authors = [ "Raj Dahya" ]
 maintainers = [ "raj_mathe" ]

code/python/src/algorithms/euklid/__init__.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.algorithms.euklid.algorithms import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'euklidean_algorithm',
-];

code/python/src/algorithms/euklid/algorithms.py

@@ -1,97 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.types import *;
-from src.thirdparty.maths import *;
-
-from models.generated.config import *;
-from src.core.utils import *;
-from src.models.euklid import *;
-from src.algorithms.euklid.display import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'euklidean_algorithm',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD euklidean algorithm
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def euklidean_algorithm(
-    a: int,
-    b: int,
-    verbose: bool = False,
-) -> Tuple[int, int, int]:
-    '''
-    Führt den Euklideschen Algorithmus aus, um den größten gemeinsamen Teiler (ggT, en: gcd)
-    von zwei positiven Zahlen zu berechnen.
-    '''
-    ################
-    # NOTE:
-    # Lemma: gcd(a,b) = gcd(mod(a, b), b)
-    # Darum immer weiter (a, b) durch (b, gcd(a,b)) ersetzen, bis b == 0.
-    ################
-    steps = [];
-    d = 0;
-    while True:
-        if b == 0:
-            d = a;
-            steps.append(Step(a=a, b=b, gcd=d, div=0, rem=a, coeff_a=1, coeff_b=0));
-            break;
-        else:
-            # Berechne k, r so dass a = k·b + r mit k ≥ 0, 0 ≤ r < b:
-            r = a % b;
-            k = math.floor(a / b);
-            # Speichere Berechnungen:
-            steps.append(Step(a=a, b=b, gcd=0, div=k, rem=r, coeff_a=0, coeff_b=0));
-            # ersetze a, b durch b, r:
-            a = b;
-            b = r;
-
-    ################
-    # NOTE:
-    # In jedem step gilt
-    #    a = k·b + r
-    # und im folgenden gilt:
-    #    d = coeff_a'·a' + coeff_b'·b'
-    # wobei
-    #    a' = b
-    #    b' = r
-    # Darum:
-    #    d = coeff_a'·b + coeff_b'·(a - k·b)
-    #      = coeff_b'·a + (coeff_a' - k·coeff_b)·b
-    # Darum:
-    #    coeff_a = coeff_b'
-    #    coeff_b = coeff_a' - k·coeff_b
-    ################
-    coeff_a = 1;
-    coeff_b = 0;
-    for step in steps[::-1][1:]:
-        (coeff_a, coeff_b) = (coeff_b, coeff_a - step.div * coeff_b);
-        step.coeff_a = coeff_a;
-        step.coeff_b = coeff_b;
-        step.gcd = d;
-
-    if verbose:
-        step = steps[0];
-        repr = display_table(steps=steps, reverse=True);
-        expr = display_sum(step=step);
-        print('');
-        print('\x1b[1mEuklidescher Algorithmus\x1b[0m');
-        print('');
-        print(repr);
-        print('');
-        print('\x1b[1mLösung\x1b[0m');
-        print('');
-        print(f'a=\x1b[1m{step.a}\x1b[0m; b=\x1b[1m{step.b}\x1b[0m; d = \x1b[1m{step.gcd}\x1b[0m = {expr}.');
-        print('');
-
-    return d, coeff_a, coeff_b;

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

@@ -1,56 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.code import *;
-from src.thirdparty.maths import *;
-from src.thirdparty.types import *;
-
-from src.models.euklid import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'display_table',
-    'display_sum',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD display table
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def display_table(
-    steps: List[Step],
-    reverse: bool = False,
-) -> str:
-    if reverse:
-        steps = steps[::-1];
-    table = pd.DataFrame({
-        'a':  [step.a for step in steps],
-        'b':  [step.b for step in steps],
-        'div':  ['-' if step.b == 0 else step.div for step in steps],
-        'gcd':  [step.gcd for step in steps],
-        'expr':  [f'= {display_sum(step=step)}' for step in steps],
-    }) \
-    .reset_index(drop=True);
-    # benutze pandas-Dataframe + tabulate, um schöner darzustellen:
-    repr = tabulate(
-        table,
-        headers=['a', 'b', 'floor(a/b)', 'gcd(a,b)', 'gcd(a,b)=x·a + y·b'],
-        showindex=False,
-        colalign=('right', 'right', 'right', 'center', 'left'),
-        tablefmt='simple'
-    );
-    return repr;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD display table
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def display_sum(step: Step) -> str:
-    return f'\x1b[1m{step.coeff_a}\x1b[0m·a + \x1b[1m{step.coeff_b}\x1b[0m·b' ;

code/python/src/algorithms/genetic/__init__.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.algorithms.genetic.algorithms import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'genetic_algorithm',
-];

code/python/src/algorithms/genetic/algorithms.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.types import *;
-from src.thirdparty.maths import *;
-
-from models.generated.config import *;
-from src.core.log import *;
-from src.core.utils import *;
-from src.models.genetic import *;
-from src.algorithms.genetic.display import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'genetic_algorithm',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD genetic algorithm
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def genetic_algorithm(
-    individual1: List[str],
-    individual2: List[str],
-    verbose: bool,
-):
-    '''
-    Führt den genetischen Algorithmus auf 2 Individuen aus.
-    '''
-    log_warn('Noch nicht implementiert!');
-    return;

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

@@ -1,30 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.code import *;
-from src.thirdparty.maths import *;
-from src.thirdparty.types import *;
-
-from src.core.log import *;
-from src.models.genetic import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'display_table',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD display table
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def display_table(
-) -> str:
-    log_warn('Noch nicht implementiert!');
-    return '';

code/python/src/algorithms/hirschberg/__init__.py

@@ -6,6 +6,7 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from src.algorithms.hirschberg.algorithms import *;
+from src.models.hirschberg.penalties import *;
 from src.algorithms.hirschberg.display import *;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

code/python/src/algorithms/pollard_rho/__init__.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.algorithms.pollard_rho.algorithms import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'pollard_rho_algorithm',
-];

code/python/src/algorithms/pollard_rho/algorithms.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.types import *;
-from src.thirdparty.maths import *;
-
-from models.generated.config import *;
-from src.core.utils import *;
-from src.models.pollard_rho import *;
-from src.algorithms.pollard_rho.display import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'pollard_rho_algorithm',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD pollard's rho algorithm
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def pollard_rho_algorithm(
-    n: int,
-    x_init: int = 2,
-    verbose: bool = False,
-):
-    steps = [];
-    success = False;
-    f = lambda _: fct(_, n=n);
-
-    d = 1;
-    x = y = x_init;
-    steps.append(Step(x=x));
-    k = 0;
-    k_next = 1;
-
-    while True:
-        # aktualisiere x: x = f(x_prev):
-        x = f(x);
-        # aktualisiere y, wenn k = 2^j: y = x[j] = f(y_prev):
-        if k == k_next:
-            k_next = 2*k_next;
-            y = f(y);
-
-        # ggT berechnen:
-        d = math.gcd(abs(x-y), n);
-        steps.append(Step(x=x, y=y, d=d));
-
-        # Abbruchkriterien prüfen:
-        if d == 1: # weitermachen, solange d == 1
-            k += 1;
-            continue;
-        elif d == n: # versagt
-            success = False;
-            break;
-        else:
-            success = True;
-            break;
-
-    if verbose:
-        repr = display_table(steps=steps);
-        print('');
-        print('\x1b[1mEuklidescher Algorithmus\x1b[0m');
-        print('');
-        print(repr);
-        print('');
-        if success:
-            print('\x1b[1mBerechneter Faktor:\x1b[0m');
-            print('');
-            print(f'd = \x1b[1m{d}\x1b[0m.');
-        else:
-            print('\x1b[91mKein (Prim)faktor erkannt!\x1b[0m');
-        print('');
-    return d;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# AUXILIARY METHOD function for Pollard's rho
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def fct(x: int, n: int) -> int:
-    return (x**2 - 1) % n;

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

@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.code import *;
-from src.thirdparty.maths import *;
-from src.thirdparty.types import *;
-
-from src.models.pollard_rho import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'display_table',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD display table
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def display_table(steps: List[Step]) -> str:
-    table = pd.DataFrame({
-        'i':  [i for i in range(len(steps))],
-        'x':  [step.x for step in steps],
-        'y':  [step.y or '-' for step in steps],
-        'd':  [step.d or '-' for step in steps],
-    }) \
-    .reset_index(drop=True);
-    # benutze pandas-Dataframe + tabulate, um schöner darzustellen:
-    repr = tabulate(
-        table,
-        headers=['i', 'x(i)', 'y(i) = x([log₂(i)])', 'gcd(|x - y|,n)'],
-        showindex=False,
-        colalign=('right', 'right', 'right', 'center'),
-        tablefmt='simple',
-    );
-    return repr;

code/python/src/algorithms/random_walk/__init__.py

@@ -1,18 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.algorithms.random_walk.algorithms import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'adaptive_walk_algorithm',
-    'gradient_walk_algorithm',
-    'metropolis_walk_algorithm',
-];

code/python/src/algorithms/random_walk/algorithms.py

@@ -1,247 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.maths import *;
-from src.thirdparty.plots import *;
-from src.thirdparty.types import *;
-
-from models.generated.config import *;
-from models.generated.commands import *;
-from src.core.log import *;
-from src.core.utils import *;
-from src.models.random_walk import *;
-from src.algorithms.random_walk.display import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'adaptive_walk_algorithm',
-    'gradient_walk_algorithm',
-    'metropolis_walk_algorithm',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# CONSTANTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-MAX_ITERATIONS = 1000; # um endlose Schleifen zu verhindern
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD adaptive walk
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def adaptive_walk_algorithm(
-    landscape: Landscape,
-    r: float,
-    coords_init: tuple,
-    optimise: EnumOptimiseMode,
-    verbose: bool,
-):
-    '''
-    Führt den Adapative-Walk Algorithmus aus, um ein lokales Minimum zu bestimmen.
-    '''
-
-    # lege Fitness- und Umgebungsfunktionen fest:
-    match optimise:
-        case EnumOptimiseMode.max:
-            f = lambda x: -landscape.fitness(*x);
-        case _:
-            f = lambda x: landscape.fitness(*x);
-    nbhd = lambda x: landscape.neighbourhood(*x, r=r, strict=True);
-    label = lambda x: landscape.label(*x);
-
-    # initialisiere
-    steps = [];
-    x = coords_init;
-    fx = f(x);
-    fy = fx;
-    N = nbhd(x);
-
-    # führe walk aus:
-    k = 0;
-    while k < MAX_ITERATIONS:
-        # Wähle zufälligen Punkt und berechne fitness-Wert:
-        y = uniform_random_choice(N);
-        fy = f(y);
-
-        # Nur dann aktualisieren, wenn sich f-Wert verbessert:
-        if fy < fx:
-            # Punkt + Umgebung + f-Wert aktualisieren
-            x = y;
-            fx = fy;
-            N = nbhd(x);
-            step = Step(coords=x, label=label(x), improved=True, changed=True);
-        else:
-            # Nichts (außer logging) machen!
-            step = Step(coords=x, label=label(x));
-
-        # Nur dann (erfolgreich) abbrechen, wenn f-Wert lokal Min:
-        if fx <= min([f(y) for y in N], default=fx):
-            step.stopped = True;
-            steps.append(step);
-            break;
-
-        steps.append(step);
-        k += 1;
-
-    return x;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD gradient walk
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def gradient_walk_algorithm(
-    landscape: Landscape,
-    r: float,
-    coords_init: tuple,
-    optimise: EnumOptimiseMode,
-    verbose: bool,
-):
-    '''
-    Führt den Gradient-Descent (bzw. Ascent) Algorithmus aus, um ein lokales Minimum zu bestimmen.
-    '''
-
-    # lege Fitness- und Umgebungsfunktionen fest:
-    match optimise:
-        case EnumOptimiseMode.max:
-            f = lambda x: -landscape.fitness(*x);
-        case _:
-            f = lambda x: landscape.fitness(*x);
-    nbhd = lambda x: landscape.neighbourhood(*x, r=r, strict=True);
-    label = lambda x: landscape.label(*x);
-
-    # initialisiere
-    steps = [];
-    x = coords_init;
-    fx = landscape.fitness(*x);
-    fy = fx;
-    N = nbhd(x);
-    f_values = [f(y) for y in N];
-    fmin = min(f_values);
-    Z = [y for y, fy in zip(N, f_values) if fy == fmin];
-
-    # führe walk aus:
-    k = 0;
-    while k < MAX_ITERATIONS:
-        # Wähle zufälligen Punkt mit steilstem Abstieg und berechne fitness-Wert:
-        y = uniform_random_choice(Z);
-        fy = fmin;
-
-        # Nur dann aktualisieren, wenn sich f-Wert verbessert:
-        if fy < fx:
-            # Punkt + Umgebung + f-Wert aktualisieren
-            x = y;
-            fx = fy;
-            N = nbhd(y);
-            f_values = [f(y) for y in N];
-            fmin = min(f_values);
-            Z = [y for y, fy in zip(N, f_values) if fy == fmin];
-            step = Step(coords=x, label=label(x), improved=True, changed=True);
-        else:
-            # Nichts (außer logging) machen!
-            step = Step(coords=x, label=label(x));
-
-        # Nur dann (erfolgreich) abbrechen, wenn f-Wert lokal Min:
-        if fx <= min([f(y) for y in N], default=fx):
-            step.stopped = True;
-            steps.append(step);
-            break;
-
-        steps.append(step);
-        k += 1;
-
-    return x;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD metropolis walk
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def metropolis_walk_algorithm(
-    landscape: Landscape,
-    r: float,
-    coords_init: tuple,
-    T: float,
-    annealing: bool,
-    optimise: EnumOptimiseMode,
-    verbose: bool,
-):
-    '''
-    Führt den Metropolis-Walk Algorithmus aus, um ein lokales Minimum zu bestimmen.
-    '''
-
-    # lege Fitness- und Umgebungsfunktionen fest:
-    match optimise:
-        case EnumOptimiseMode.max:
-            f = lambda x: -landscape.fitness(*x);
-        case _:
-            f = lambda x: landscape.fitness(*x);
-    nbhd = lambda x: landscape.neighbourhood(*x, r=r, strict=True);
-    label = lambda x: landscape.label(*x);
-
-    # definiere anzahl der hinreichenden Schritt für Stabilität:
-    n_stable = 2*(3**(landscape.dim) - 1);
-
-    # initialisiere
-    x = coords_init;
-    fx = f(x);
-    fy = fx;
-    nbhd_x = nbhd(x);
-    steps = [];
-    step = Step(coords=x, label=label(x));
-
-    # führe walk aus:
-    k = 0;
-    n_unchanged = 0;
-    while k < MAX_ITERATIONS:
-        # Wähle zufälligen Punkt und berechne fitness-Wert:
-        y = uniform_random_choice(nbhd_x);
-        fy = f(y);
-        p = math.exp(-abs(fy-fx)/T);
-        u = random_binary(p);
-
-        # Aktualisieren, wenn sich f-Wert verbessert
-        # oder mit einer Wahrscheinlichkeit von p:
-        if fy < fx or u:
-            # Punkt + Umgebung + f-Wert aktualisieren
-            x = y;
-            fx = fy;
-            nbhd_x = nbhd(x);
-            n_unchanged = 0;
-            step = Step(coords=x, label=label(x), improved=(fy < fx), chance=u, probability=p, changed=True);
-        else:
-            # Nichts (außer logging) machen!
-            n_unchanged += 1;
-            step = Step(coords=x, label=label(x));
-
-        # »Temperatur« ggf. abkühlen:
-        if annealing:
-            T = cool_temperature(T, k);
-
-        # Nur dann (erfolgreich) abbrechen, wenn f-Wert lokal Min:
-        if n_unchanged >= n_stable:
-            step.stopped = True;
-            steps.append(step);
-            break;
-
-        steps.append(step);
-        k += 1;
-
-    if verbose:
-        for step in steps:
-            print(step);
-
-    return x;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# AUXILIARY METHODS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def cool_temperature(T: float, k: int, const: float = 2.) -> float:
-    harm = const*(k + 1);
-    return T/(1 + T/harm);

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

@@ -1,30 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.code import *;
-from src.thirdparty.maths import *;
-from src.thirdparty.types import *;
-
-from src.core.log import *;
-from src.models.random_walk import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'display_table',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD display table
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def display_table(
-) -> str:
-    log_warn('Noch nicht implementiert!');
-    return '';

code/python/src/api.py

@@ -40,12 +40,4 @@ def run_command(command: Command) -> Result[CallResult, CallError]:
         return endpoint_hirschberg(command);
     elif isinstance(command, CommandRucksack):
         return endpoint_rucksack(command);
-    elif isinstance(command, CommandRandomWalk):
-        return endpoint_random_walk(command);
-    elif isinstance(command, CommandGenetic):
-        return endpoint_genetic(command);
-    elif isinstance(command, CommandEuklid):
-        return endpoint_euklid(command);
-    elif isinstance(command, CommandPollard):
-        return endpoint_pollard_rho(command);
     raise Exception(f'No endpoint set for `{command.name.value}`-command type.');

code/python/src/endpoints/__init__.py

@@ -9,10 +9,6 @@ from src.endpoints.ep_algorithm_hirschberg import *;
 from src.endpoints.ep_algorithm_tarjan import *;
 from src.endpoints.ep_algorithm_tsp import *;
 from src.endpoints.ep_algorithm_rucksack import *;
-from src.endpoints.ep_algorithm_genetic import *;
-from src.endpoints.ep_algorithm_random_walk import *;
-from src.endpoints.ep_algorithm_euklid import *;
-from src.endpoints.ep_algorithm_pollard_rho import *;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
@@ -23,8 +19,4 @@ __all__ = [
     'endpoint_tarjan',
     'endpoint_tsp',
     'endpoint_rucksack',
-    'endpoint_random_walk',
-    'endpoint_genetic',
-    'endpoint_euklid',
-    'endpoint_pollard_rho',
 ];

code/python/src/endpoints/ep_algorithm_euklid.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.code import *;
-
-from models.generated.commands import *;
-from src.core.calls import *;
-from src.setup import config;
-from src.algorithms.euklid import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'endpoint_euklid',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# ENDPOINT
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-@run_safely()
-def endpoint_euklid(command: CommandEuklid) -> Result[CallResult, CallError]:
-    result = euklidean_algorithm(
-        a = command.numbers[0].__root__,
-        b = command.numbers[1].__root__,
-        verbose = config.OPTIONS.euklid.verbose,
-    );
-    return Ok(CallResult(action_taken=True, message=result));

code/python/src/endpoints/ep_algorithm_genetic.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.code import *;
-
-from models.generated.commands import *;
-from src.core.calls import *;
-from src.setup import config;
-from src.algorithms.genetic import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'endpoint_genetic',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# ENDPOINT
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-@run_safely()
-def endpoint_genetic(command: CommandGenetic) -> Result[CallResult, CallError]:
-    result = genetic_algorithm(
-        individual1 = command.population[0],
-        individual2 = command.population[1],
-        verbose = config.OPTIONS.genetic.verbose,
-    );
-    return Ok(CallResult(action_taken=True, message=result));

code/python/src/endpoints/ep_algorithm_pollard_rho.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.code import *;
-
-from models.generated.commands import *;
-from src.core.calls import *;
-from src.setup import config;
-from src.algorithms.pollard_rho import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'endpoint_pollard_rho',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# ENDPOINT
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-@run_safely()
-def endpoint_pollard_rho(command: CommandPollard) -> Result[CallResult, CallError]:
-    result = pollard_rho_algorithm(
-        n = command.number,
-        x_init = command.x_init,
-        verbose = config.OPTIONS.pollard_rho.verbose,
-    );
-    return Ok(CallResult(action_taken=True, message=result));

code/python/src/endpoints/ep_algorithm_random_walk.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.code import *;
-
-from models.generated.commands import *;
-from src.core.calls import *;
-from src.setup import config;
-from src.models.random_walk import *;
-from src.algorithms.random_walk import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'endpoint_random_walk',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# ENDPOINT
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-@run_safely()
-def endpoint_random_walk(command: CommandRandomWalk) -> Result[CallResult, CallError]:
-    # Compute landscape (fitness fct + topology) + initial co-ordinates:
-    one_based = command.one_based;
-    landscape = Landscape(
-        values = command.landscape.values,
-        labels = command.landscape.labels,
-        metric = command.landscape.neighbourhoods.metric,
-        one_based = one_based,
-    );
-    if isinstance(command.coords_init, list):
-        coords_init = tuple(command.coords_init);
-        if one_based:
-            coords_init = tuple(xx - 1 for xx in coords_init);
-        assert len(coords_init) == landscape.dim, 'Dimension of initial co-ordinations inconsistent with landscape!';
-    else:
-        coords_init = landscape.coords_middle;
-
-    match command.algorithm:
-        case EnumWalkMode.adaptive:
-            result = adaptive_walk_algorithm(
-                landscape = landscape,
-                r = command.landscape.neighbourhoods.radius,
-                coords_init = coords_init,
-                optimise = command.optimise,
-                verbose = config.OPTIONS.random_walk.verbose
-            );
-        case EnumWalkMode.gradient:
-            result = gradient_walk_algorithm(
-                landscape = landscape,
-                r = command.landscape.neighbourhoods.radius,
-                coords_init = coords_init,
-                optimise = command.optimise,
-                verbose = config.OPTIONS.random_walk.verbose
-            );
-        case EnumWalkMode.metropolis:
-            result = metropolis_walk_algorithm(
-                landscape = landscape,
-                r = command.landscape.neighbourhoods.radius,
-                coords_init = coords_init,
-                T = command.temperature_init,
-                annealing = command.annealing,
-                optimise = command.optimise,
-                verbose = config.OPTIONS.random_walk.verbose
-            );
-        case _ as alg:
-            raise Exception(f'No algorithm implemented for {alg.value}.');
-    return Ok(CallResult(action_taken=True, message=result));

code/python/src/endpoints/ep_algorithm_rucksack.py

@@ -50,5 +50,5 @@ def endpoint_rucksack(command: CommandRucksack) -> Result[CallResult, CallError]
                 verbose = config.OPTIONS.rucksack.verbose,
             );
         case _ as alg:
-            raise Exception(f'No algorithm implemented for {alg.value}.');
+            raise Exception(f'No algorithm implemented for {alg.value}.')
     return Ok(CallResult(action_taken=True, message=result));

code/python/src/models/config/commands.py

@@ -44,12 +44,4 @@ def interpret_command(command: Command) -> Command:
             return CommandHirschberg(**command.dict());
         case EnumAlgorithmNames.rucksack:
             return CommandRucksack(**command.dict());
-        case EnumAlgorithmNames.random_walk:
+    raise command;
-            return CommandRandomWalk(**command.dict());
-        case EnumAlgorithmNames.genetic:
-            return CommandGenetic(**command.dict());
-        case EnumAlgorithmNames.euklid:
-            return CommandEuklid(**command.dict());
-        case EnumAlgorithmNames.pollard_rho:
-            return CommandPollard(**command.dict());
-    raise Exception(f'Command type `{command.name.value}` not recognised!');

code/python/src/models/euklid/__init__.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.models.euklid.logging import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'Step',
-];

code/python/src/models/euklid/logging.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.types import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'Step',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# CLASS Step
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-@dataclass
-class Step():
-    a: int = field();
-    b: int = field();
-    gcd: int = field();
-    div: int = field();
-    rem: int = field();
-    coeff_a: int = field();
-    coeff_b: int = field();

code/python/src/models/pollard_rho/__init__.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.models.pollard_rho.logging import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'Step',
-];

code/python/src/models/pollard_rho/logging.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.types import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'Step',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# CLASS Step
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-@dataclass
-class Step():
-    x: int = field();
-    y: Optional[int] = field(default=None);
-    d: Optional[int] = field(default=None);

code/python/src/models/random_walk/__init__.py

@@ -1,18 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.models.random_walk.landscape import *;
-from src.models.random_walk.logging import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'Landscape',
-    'Step',
-];

code/python/src/models/random_walk/landscape.py

@@ -1,124 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from __future__ import annotations;
-
-from src.thirdparty.maths import *;
-from src.thirdparty.misc import *;
-from src.thirdparty.types import *;
-
-from models.generated.commands import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'Landscape',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD fitness function -> Array
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-class Landscape():
-    _fct: np.ndarray;
-    _labels: list[str];
-    _metric: EnumLandscapeMetric;
-    _radius: float;
-    _one_based: bool;
-
-    def __init__(
-        self,
-        values: DataTypeLandscapeValues,
-        labels: List[str],
-        metric: EnumLandscapeMetric = EnumLandscapeMetric.maximum,
-        one_based: bool = False,
-    ):
-        self._fct = convert_to_nparray(values);
-        assert len(labels) == self.dim, 'A label is required for each axis/dimension!';
-        self._labels = labels;
-        self._metric = metric;
-        self._one_based = one_based;
-        return;
-
-    @property
-    def shape(self) -> tuple:
-        return self._fct.shape;
-
-    @property
-    def dim(self) -> int:
-        return len(self._fct.shape);
-
-    @property
-    def coords_middle(self) -> tuple:
-        return tuple(math.floor(s/2) for s in self.shape);
-
-    @property
-    def values(self) -> np.ndarray:
-        return self._fct;
-
-    def fitness(self, *x: int) -> float:
-        return self._fct[x];
-
-    def axis_label(self, i: int, x: int) -> str:
-        if self._one_based:
-            x = x + 1;
-        name = self._labels[i];
-        return f'{name}{x}';
-
-    def axis_labels(self, i: int) -> str:
-        s = self.shape[i];
-        return [ self.axis_label(i, x) for x in range(s) ];
-
-    def label(self, *x: int) -> str:
-        if self._one_based:
-            x = tuple(xx + 1 for xx in x);
-        expr = ','.join([ f'{name}{xx}' for name, xx in zip(self._labels, x)]);
-        if self.dim > 1:
-            expr = f'({expr})';
-        return expr;
-
-    def neighbourhood(self, *x: int, r: float, strict: bool = False) -> List[tuple]:
-        r = int(r);
-        sides = [
-            [ xx - j for j in range(1, r+1) if xx - j in range(s) ]
-            + ([ xx ] if xx in range(s) else [])
-            + [ xx + j for j in range(1, r+1) if xx + j in range(s) ]
-            for xx, s in zip(x, self.shape)
-        ];
-        match self._metric:
-            case EnumLandscapeMetric.maximum:
-                umg = list(itertools_product(*sides));
-            case EnumLandscapeMetric.manhattan:
-                umg = [
-                    (*x[:i], xx, *x[(i+1):])
-                    for i, side in enumerate(sides)
-                    for xx in side
-                ];
-            case _:
-                umg = [ x ];
-        if strict:
-            umg = [ p for p in umg if p != x ];
-        return umg;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# AUXILIARY METHODS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def convert_to_array(values: DataTypeLandscapeValues) -> list:
-    return [
-        x if isinstance(x, float) else convert_to_array(x)
-        for x in values.__root__
-    ];
-
-def convert_to_nparray(values: DataTypeLandscapeValues) -> np.ndarray:
-    try:
-        list_of_lists = convert_to_array(values);
-        return np.asarray(list_of_lists, dtype=float);
-    except:
-        raise ValueError('Could not convert to a d-dimensional array! Ensure that the dimensions are consistent.');

code/python/src/models/random_walk/logging.py

@@ -1,32 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from src.thirdparty.types import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'Step',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# CLASS Step
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-@dataclass
-class Step():
-    coords: tuple = field();
-    label: str = field();
-
-    improved: bool = field(default=False);
-    chance: bool = field(default=False);
-    probability: float = field(default=0.);
-
-    changed: bool = field(default=False);
-    stopped: bool = field(default=False);

code/python/src/thirdparty/maths.py

@@ -8,12 +8,8 @@
 from fractions import Fraction;
 import math;
 import numpy as np;
-from numpy.random import binomial as random_binomial;
-random_binary = lambda p: (random_binomial(1, p) == 1);
 import pandas as pd;
 import random;
-from random import uniform;
-from random import choice as uniform_random_choice;
 from tabulate import tabulate;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -24,11 +20,7 @@ __all__ = [
     'Fraction',
     'math',
     'np',
-    'random_binomial',
-    'random_binary',
     'pd',
     'random',
-    'uniform',
-    'uniform_random_choice',
     'tabulate',
 ];

code/python/src/thirdparty/misc.py

@@ -7,7 +7,6 @@
 
 from datetime import datetime;
 from datetime import timedelta;
-from itertools import product as itertools_product;
 import lorem;
 import re;
 from textwrap import dedent;
@@ -17,10 +16,9 @@ from textwrap import dedent;
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 __all__ = [
+    'lorem',
     'datetime',
     'timedelta',
-    'itertools_product',
-    'lorem',
     're',
     'dedent',
 ];

code/python/src/thirdparty/plots.py

@@ -1,22 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from matplotlib import pyplot as mplt;
-from matplotlib import animation as mplt_animation;
-from matplotlib import colors as mplt_colours;
-from matplotlib import patches as mplt_patches;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'mplt',
-    'mplt_colours',
-    'mplt_patches',
-    'mplt_animation',
-];