.gitignore

@@ -15,6 +15,8 @@
 ################################################################
 
 !/notes
+!/notes/glossar.md
+!/notes/quellen.md
 
 !/protocol
 !/protocol/README.md

code/python/src/local/maths.py

@@ -6,7 +6,6 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 import math;
-import numpy as np;
 import random;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -15,6 +14,5 @@ import random;
 
 __all__ = [
     'math',
-    'np',
     'random',
 ];

code/python/src/local/typing.py

@@ -17,7 +17,6 @@ from typing import Tuple;
 from typing import Type;
 from typing import TypeVar;
 from typing import Union;
-from nptyping import NDArray;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # EXPORTS
@@ -35,5 +34,4 @@ __all__ = [
     'Type',
     'TypeVar',
     'Union',
-    'NDArray',
 ];

code/python/src/main.py

@@ -12,10 +12,8 @@ os.chdir(os.path.join(os.path.dirname(__file__), '..'));
 sys.path.insert(0, os.getcwd());
 
 from src.core.log import *;
-from src.local.maths import *;
 from src.graphs.graph import *;
 from src.graphs.tarjan import *;
-from src.travel.naive import *;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # GLOBAL CONSTANTS/VARIABLES
@@ -28,17 +26,28 @@ from src.travel.naive import *;
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def enter():
-    ## Beispiel aus Seminarblatt 8
+    ## Beispiel aus Seminarblatt 1
-    tsp_naive_algorithm(
+    nodes = [1,2,3,4,5,6,7,8];
-        dist = np.asarray([
+    edges = [
-            [0, 7, 2, 5],
+        (1,2),
-            [7, 0, 5, 6],
+        (1,3),
-            [2, 5, 0, 5],
+        (2,4),
-            [2, 7, 4, 0],
+        (2,5),
-        ], dtype=float),
+        (3,5),
-        optimise=max,
+        (3,6),
-        verbose=True,
+        (3,8),
-    );
+        (4,5),
+        (4,7),
+        (5,1),
+        (5,8),
+        (6,8),
+        (7,8),
+        (8,6),
+    ];
+    G = Graph(nodes=nodes, edges=edges);
+    components = tarjan_algorithm(G, debug=True);
+    for component in components:
+        log_debug(component);
     return;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

code/python/src/travel/naive.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# IMPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-from __future__ import annotations;
-from src.local.typing import *;
-from src.local.maths import *;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# EXPORTS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-__all__ = [
-    'tsp_naive_algorithm',
-];
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# METHOD tsp_naive_algorithm
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def tsp_naive_algorithm(
-    dist: NDArray[(Any, Any), float],
-    optimise = min,
-    verbose: bool = False,
-) -> tuple[float, list[list[int]]]:
-    m, n = dist.shape[:2];
-    assert m == n;
-    memory: Dict[tuple[int, tuple], tuple[float, list[list[int]]]] = dict();
-
-    def g(i: int, S: list[int]) -> tuple[float, list[list[int]]]:
-        # wenn g bereits für den Input definiert ist, gib diesen Wert zurück:
-        if (i, tuple(S)) not in memory.keys():
-            if len(S) == 0:
-                paths = [[i]] if i == 0 else [[i, 0]];
-                memory[(i, tuple(S))] = (dist[i,0], paths);
-            else:
-                values_and_paths = [ (j, *g(j, (*S[:index], *S[(index+1):]))) for index, j in enumerate(S) ];
-                # berechne d(i,j) + g(j, S \ {i}) for each j in S:
-                values_and_paths = [ (j, dist[i,j] + value, paths) for  j, value, paths in values_and_paths];
-                value = optimise([value for _, value, _  in values_and_paths]);
-                paths = [];
-                for j, value_, paths_ in values_and_paths:
-                    if value_ == value:
-                        paths += [ [i, *path] for path in paths_ ];
-                memory[(i, tuple(S))] = (value, paths);
-        return memory[(i, tuple(S))];
-
-    # berechne g(0, {1,2,...,n-1}):
-    optimal_wert = g(0, [i for i in range(1,n)]);
-
-    if verbose:
-        display_computation(n, memory);
-
-    return optimal_wert, [];
-
-def display_computation(n: int, memory: Dict[tuple[int, tuple], tuple[float, list[list[int]]]]):
-    keys = sorted(memory.keys(), key=lambda key: (len(key[1]), key[0], key[1]));
-    for k in range(0,n):
-        print(f'\x1b[4;1m|S| = {k}:\x1b[0m');
-        for (i, S) in keys:
-            if len(S) != k:
-                continue;
-            value, paths = memory[(i, S)];
-            print(f'g({i}, {list(S)}) = {value}');
-            if len(paths) == 1:
-                print(f'optimal path: {" -> ".join(map(str, paths[0]))}');
-            else:
-                print('optimal paths:');
-                for path in paths:
-                    print(f'* {" -> ".join(map(str, path))}');
-            print('');
-    return;

code/python/tests/conftest.py

@@ -6,8 +6,17 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from unittest import TestCase;
+from pytest import mark;
 from pytest import fixture;
 
+from tests.core.log import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# CONSTANTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#
+
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # FIXTURES
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -15,11 +24,3 @@ from pytest import fixture;
 @fixture(scope='module')
 def test():
     return TestCase();
-
-@fixture(scope='module')
-def debug():
-    def log(*lines: str):
-        with open('logs/debug.log', 'a') as fp:
-            for line in lines:
-                print(line, end='\n', file=fp);
-    return log;

code/python/tests/core/log.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# METHODS - logging
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def log(*lines: str):
+    with open('logs/debug.log', 'a') as fp:
+        for line in lines:
+            print(line, end='\n', file=fp);

code/python/tests/test_graphs/conftest.py

@@ -9,6 +9,8 @@ from unittest import TestCase;
 from pytest import mark;
 from pytest import fixture;
 
+from tests.core.log import *;
+
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # CONSTANTS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

code/python/tests/test_graphs/test_tarjan.py

@@ -5,12 +5,12 @@
 # IMPORTS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-import pytest;
+from contextlib import nullcontext as does_not_raise
+from collections import Counter;
 from pytest import mark;
 from pytest import fixture;
 from pytest import lazy_fixture;
 from unittest import TestCase;
-from unittest.mock import patch;
 
 from src.local.typing import *;
 from src.graphs.graph import *;
@@ -73,13 +73,6 @@ def test_tarjan(test, G, expected):
     components = tarjan_algorithm(G, False);
     assert_components_eq(test, components, expected);
 
-@patch(f'{__name__}.tarjan_algorithm', lambda *_: [])
-@mark.parametrize(('G', 'expected'), [ (lazy_fixture('graph1'), [[1], [3], [2,4]])])
-@mark.usefixtures('test')
-def test_failable_tarjan(test, G, expected):
-    with pytest.raises(AssertionError):
-        test_tarjan(test, G, expected);
-
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # AUXILIARY METHODS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

notes/.gitignore

@@ -1,24 +0,0 @@
-*
-!/.gitignore
-
-################################################################
-# MAIN FOLDER
-################################################################
-
-#
-
-################################################################
-# PROJECT FILES
-################################################################
-
-!/glossar.md
-!/quellen.md
-!/notes.tex
-!/notes.pdf
-!/woche*.pdf
-
-################################################################
-# Git Keep
-################################################################
-
-!/**/.gitkeep