raj_mathe/logik2021
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

master > master: allgemeine Aufräumung

Browse Source
This commit is contained in:
RD
2021-05-10 14:32:52 +02:00
parent a0dee82659
commit 61ec2d7df3
17 changed files with 303 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
code/utests/u_rekursion.py → code/utests/rekursion_test.py
View File

@@ -9,11 +9,11 @@ import unittest;
from unittest import TestCase;
from aussagenlogik.schema import stringToSyntaxbaum;
from aussagenlogik.rekursion import rekursiv_atoms;
from aussagenlogik.rekursion import rekursiv_depth;
from aussagenlogik.rekursion import rekursiv_length;
from aussagenlogik.rekursion import rekursiv_parentheses;
from aussagenlogik.rekursion import rekursiv_eval;
from aussagenlogik.rekursion import rekursivEval;
from aussagenlogik.rekursion import rekursivAtoms;
from aussagenlogik.rekursion import rekursivDepth;
from aussagenlogik.rekursion import rekursivLength;
from aussagenlogik.rekursion import rekursivParentheses;
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# GLOBALE KONSTANTEN
@@ -29,34 +29,34 @@ from aussagenlogik.rekursion import rekursiv_eval;
class TestRekursivEval(TestCase):
def test_literale(self):
fml = stringToSyntaxbaum('A0');
val = rekursiv_eval(fml, [ 'A0' ]);
val = rekursivEval(fml, [ 'A0' ]);
assert val == 1;
fml = stringToSyntaxbaum('A0');
val = rekursiv_eval(fml, []);
val = rekursivEval(fml, []);
assert val == 0;
fml = stringToSyntaxbaum('! A0');
val = rekursiv_eval(fml, [ 'A0' ]);
val = rekursivEval(fml, [ 'A0' ]);
assert val == 0;
fml = stringToSyntaxbaum('! A0');
val = rekursiv_eval(fml, []);
val = rekursivEval(fml, []);
assert val == 1;
def test_complex1(self):
fml = stringToSyntaxbaum('( ! A0 || (( A0 && A3 ) || A2 ))');
val = rekursiv_eval(fml, [ 'A0', 'A2' ]);
val = rekursivEval(fml, [ 'A0', 'A2' ]);
assert val == 1;
val = rekursiv_eval(fml, [ 'A0', 'A3' ]);
val = rekursivEval(fml, [ 'A0', 'A3' ]);
assert val == 1;
val = rekursiv_eval(fml, [ 'A0' ]);
val = rekursivEval(fml, [ 'A0' ]);
assert val == 0;
val = rekursiv_eval(fml, [ 'A4', 'A8' ]);
val = rekursivEval(fml, [ 'A4', 'A8' ]);
assert val == 1;
def test_complex2(self):
fml = stringToSyntaxbaum('( ! A0 || (( A0 && A3 ) || ! A2 ))');
val = rekursiv_eval(fml, [ 'A0', 'A2' ]);
val = rekursivEval(fml, [ 'A0', 'A2' ]);
assert val == 0;
val = rekursiv_eval(fml, [ 'A0', 'A3' ]);
val = rekursivEval(fml, [ 'A0', 'A3' ]);
assert val == 1;
pass;
@@ -68,22 +68,22 @@ class TestRekursivEval(TestCase):
class TestRekursivAtoms(TestCase):
def test_noduplicates(self):
fml = stringToSyntaxbaum('( A4 && ( A4 || A4 ))');
val = sorted(rekursiv_atoms(fml));
val = sorted(rekursivAtoms(fml));
assert len([_ for _ in val if _ == 'A4']) == 1, 'Atome dürfen nicht mehrfach vorkommen!';
def test_nononatoms(self):
fml = stringToSyntaxbaum('( {F} || A3 )');
val = sorted(rekursiv_atoms(fml));
val = sorted(rekursivAtoms(fml));
assert 'F' not in val, 'Nichtatomare Formeln dürfen nicht vorkommen!';
def test_calc1(self):
fml = stringToSyntaxbaum('A0');
val = sorted(rekursiv_atoms(fml));
val = sorted(rekursivAtoms(fml));
assert val == ['A0'], 'computed {}'.format(val);
def test_calc2(self):
fml = stringToSyntaxbaum('((( ! A0 && A3 ) || A4 ) && A8 )');
val = sorted(rekursiv_atoms(fml));
val = sorted(rekursivAtoms(fml));
assert val == ['A0', 'A3', 'A4', 'A8'], 'computed {}'.format(val);
pass;
@@ -95,27 +95,27 @@ class TestRekursivAtoms(TestCase):
class TestRekursivDepth(TestCase):
def test_calc1(self):
fml = stringToSyntaxbaum('A0');
val = rekursiv_depth(fml);
val = rekursivDepth(fml);
assert val == 0, 'computed {}'.format(val);
def test_calc2(self):
fml = stringToSyntaxbaum('!! A8');
val = rekursiv_depth(fml);
val = rekursivDepth(fml);
assert val == 2, 'computed {}'.format(val);
def test_calc3(self):
fml = stringToSyntaxbaum('( ! A0 && A3 )');
val = rekursiv_depth(fml);
val = rekursivDepth(fml);
assert val == 2, 'computed {}'.format(val);
def test_calc4(self):
fml = stringToSyntaxbaum('((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_depth(fml);
val = rekursivDepth(fml);
assert val == 4, 'computed {}'.format(val);
def test_calc5(self):
fml = stringToSyntaxbaum('! ((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_depth(fml);
val = rekursivDepth(fml);
assert val == 5, 'computed {}'.format(val);
pass;
@@ -127,27 +127,27 @@ class TestRekursivDepth(TestCase):
class TestRekursivLength(TestCase):
def test_calc1(self):
fml = stringToSyntaxbaum('A0');
val = rekursiv_length(fml);
val = rekursivLength(fml);
assert val == 1, 'computed {}'.format(val);
def test_calc2(self):
fml = stringToSyntaxbaum('!! A8');
val = rekursiv_length(fml);
val = rekursivLength(fml);
assert val == 3, 'computed {}'.format(val);
def test_calc3(self):
fml = stringToSyntaxbaum('( ! A0 && A3 )');
val = rekursiv_length(fml);
val = rekursivLength(fml);
assert val == 4, 'computed {}'.format(val);
def test_calc4(self):
fml = stringToSyntaxbaum('((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_length(fml);
val = rekursivLength(fml);
assert val == 8, 'computed {}'.format(val);
def test_calc5(self):
fml = stringToSyntaxbaum('! ((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_length(fml);
val = rekursivLength(fml);
assert val == 9, 'computed {}'.format(val);
pass;
@@ -159,26 +159,26 @@ class TestRekursivLength(TestCase):
class TestRekursivParentheses(TestCase):
def test_calc1(self):
fml = stringToSyntaxbaum('A0');
val = rekursiv_parentheses(fml);
val = rekursivParentheses(fml);
assert val == 0, 'computed {}'.format(val);
def test_calc2(self):
fml = stringToSyntaxbaum('!! A8');
val = rekursiv_parentheses(fml);
val = rekursivParentheses(fml);
assert val == 0, 'computed {}'.format(val);
def test_calc3(self):
fml = stringToSyntaxbaum('( ! A0 && A3 )');
val = rekursiv_parentheses(fml);
val = rekursivParentheses(fml);
assert val == 2, 'computed {}'.format(val);
def test_calc4(self):
fml = stringToSyntaxbaum('((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_parentheses(fml);
val = rekursivParentheses(fml);
assert val == 6, 'computed {}'.format(val);
def test_calc5(self):
fml = stringToSyntaxbaum('! ((( ! A0 && A3 ) || A4 ) && A8 )');
val = rekursiv_parentheses(fml);
val = rekursivParentheses(fml);
assert val == 6, 'computed {}'.format(val);
pass;