master > master: codego initialisiert

codego/aussagenlogik/rekursion/rekursion.go

@@ -0,0 +1,82 @@
+package rekursion
+
+import (
+	"log"
+	"logik/aussagenlogik/syntaxbaum"
+	"logik/core/utils"
+)
+
+/* ---------------------------------------------------------------- *
+ * EXPORTS
+ * ---------------------------------------------------------------- */
+
+func RekursivEval(tree syntaxbaum.SyntaxBaum, I []string) int {
+	var children = tree.GetChildren()
+	switch tree.Kind {
+	case "atom", "generic":
+		if utils.StrListContains(I, tree.Expr) {
+			return 1
+		}
+		return 0
+	case "taut":
+		return 1
+	case "contradiction":
+		return 0
+	case "not":
+		subtree0, _ := tree.GetChild()
+		val0 := RekursivEval(subtree0, I)
+		return 1 - val0
+	case "and2":
+		val0 := RekursivEval(children[0], I)
+		val1 := RekursivEval(children[1], I)
+		return utils.Min2(val0, val1)
+	case "and":
+		var val = 1
+		for _, subtree := range children {
+			var val_ = RekursivEval(subtree, I)
+			val = utils.Min2(val, val_)
+		}
+		return val
+	case "or2":
+		val0 := RekursivEval(children[0], I)
+		val1 := RekursivEval(children[1], I)
+		return utils.Max2(val0, val1)
+	case "or":
+		var val = 0
+		for _, subtree := range children {
+			var val_ = RekursivEval(subtree, I)
+			val = utils.Max2(val, val_)
+		}
+		return val
+	case "implies":
+		val0 := RekursivEval(children[0], I)
+		val1 := RekursivEval(children[1], I)
+		if val0 <= val1 {
+			return 1
+		}
+		return 0
+	default:
+		log.Fatal("Could not evaluate expression!")
+		return 0
+	}
+}
+
+func RekursivAtoms(tree syntaxbaum.SyntaxBaum) []string {
+	// Herausforderung: schreibe diese Funktion!
+	return []string{}
+}
+
+func RekursivDepth(tree syntaxbaum.SyntaxBaum) int {
+	// Herausforderung: schreibe diese Funktion!
+	return 0
+}
+
+func RekursivLength(tree syntaxbaum.SyntaxBaum) int {
+	// Herausforderung: schreibe diese Funktion!
+	return 0
+}
+
+func RekursivParentheses(tree syntaxbaum.SyntaxBaum) int {
+	// Herausforderung: schreibe diese Funktion!
+	return 0
+}

codego/aussagenlogik/rekursion/rekursion_test.go

@@ -0,0 +1,287 @@
+package rekursion_test
+
+/* ---------------------------------------------------------------- *
+ * UNIT TESTING
+ * ---------------------------------------------------------------- */
+
+import (
+	"logik/aussagenlogik/rekursion"
+	"logik/aussagenlogik/schema"
+	"logik/aussagenlogik/syntaxbaum"
+	"logik/core/utils"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+/* ---------------------------------------------------------------- *
+ * TESTCASE eval(·, ·)
+ * ---------------------------------------------------------------- */
+
+func TestRekursivEvalLiteral(test *testing.T) {
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var I []string
+	var val int
+	tree, _ = schema.ParseExpr("A0")
+	I = []string{"A0"}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 1)
+	tree, _ = schema.ParseExpr("A0")
+	I = []string{}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 0)
+	tree, _ = schema.ParseExpr("! A0")
+	I = []string{"A0"}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 0)
+	tree, _ = schema.ParseExpr("! A0")
+	I = []string{}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 1)
+}
+
+func TestRekursivEvalComplex1(test *testing.T) {
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var I []string
+	var val int
+	tree, _ = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || A2 ))")
+	I = []string{"A0", "A2"}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 1)
+	I = []string{"A0", "A3"}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 1)
+	I = []string{"A0"}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 0)
+	I = []string{"A4", "A8"}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 1)
+}
+
+func TestRekursivEvalComplex2(test *testing.T) {
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var I []string
+	var val int
+	tree, _ = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || ! A2 ))")
+	I = []string{"A0", "A2"}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 0)
+	I = []string{"A0", "A3"}
+	val = rekursion.RekursivEval(tree, I)
+	assert.Equal(val, 1)
+}
+
+/* ---------------------------------------------------------------- *
+ * TESTCASE Atoms(·)
+ * ---------------------------------------------------------------- */
+
+func TestRekursivAtomsNoduplicates(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val []string
+	tree, _ = schema.ParseExpr("( A4 && ( A4 || A4 ))")
+	val = rekursion.RekursivAtoms(tree)
+	var n int = len(utils.FilterStrings(&val, func(x string) bool { return x == "A4" }))
+	assert.Equal(n, 1, "Atome dürfen nicht mehrfach vorkommen!")
+}
+
+func TestRekursivAtomsNononatoms(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	test.Skip("Syntax for generic expressions in ANTLR4 g4 needs to be implemented.")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val []string
+	tree, _ = schema.ParseExpr("( {F} || A3 )")
+	val = rekursion.RekursivAtoms(tree)
+	utils.SortStrings(&val)
+	assert.NotContains(val, "F", "Nichtatomare Formeln dürfen nicht vorkommen!")
+}
+
+func TestRekursivAtomsCalc1(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val []string
+	tree, _ = schema.ParseExpr("A0")
+	val = rekursion.RekursivAtoms(tree)
+	utils.SortStrings(&val)
+	assert.Equal(val, []string{"A0"})
+}
+
+func TestRekursivAtomsCalc2(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val []string
+	tree, _ = schema.ParseExpr("((( ! A8 && A3 ) || A4 ) && A0 )")
+	val = rekursion.RekursivAtoms(tree)
+	utils.SortStrings(&val)
+	assert.Equal(val, []string{"A0", "A3", "A4", "A8"})
+}
+
+/* ---------------------------------------------------------------- *
+ * TESTCASE depth(·, ·)
+ * ---------------------------------------------------------------- */
+
+func TestRekursivDepthCalc1(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("A0")
+	val = rekursion.RekursivDepth(tree)
+	assert.Equal(val, 0)
+}
+
+func TestRekursivDepthCalc2(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("!! A8")
+	val = rekursion.RekursivDepth(tree)
+	assert.Equal(val, 2)
+}
+
+func TestRekursivDepthCalc3(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("( ! A0 && A3 )")
+	val = rekursion.RekursivDepth(tree)
+	assert.Equal(val, 2)
+}
+
+func TestRekursivDepthCalc4(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
+	val = rekursion.RekursivDepth(tree)
+	assert.Equal(val, 4)
+}
+
+func TestRekursivDepthCalc5(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
+	val = rekursion.RekursivDepth(tree)
+	assert.Equal(val, 5)
+}
+
+/* ---------------------------------------------------------------- *
+ * TESTCASE length(·)
+ * ---------------------------------------------------------------- */
+
+func TestRekursivLengthCalc1(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("A0")
+	val = rekursion.RekursivLength(tree)
+	assert.Equal(val, 1)
+}
+
+func TestRekursivLengthCalc2(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("!! A8")
+	val = rekursion.RekursivLength(tree)
+	assert.Equal(val, 3)
+}
+
+func TestRekursivLengthCalc3(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("( ! A0 && A3 )")
+	val = rekursion.RekursivLength(tree)
+	assert.Equal(val, 4)
+}
+
+func TestRekursivLengthCalc4(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
+	val = rekursion.RekursivLength(tree)
+	assert.Equal(val, 8)
+}
+
+func TestRekursivLengthCalc5(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
+	val = rekursion.RekursivLength(tree)
+	assert.Equal(val, 9)
+}
+
+/* ---------------------------------------------------------------- *
+ * TESTCASE #Parentheses(·)
+ * ---------------------------------------------------------------- */
+
+func TestRekursivParenthesesCalc1(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("A0")
+	val = rekursion.RekursivParentheses(tree)
+	assert.Equal(val, 0)
+}
+
+func TestRekursivParenthesesCalc2(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("!! A8")
+	val = rekursion.RekursivParentheses(tree)
+	assert.Equal(val, 0)
+}
+
+func TestRekursivParenthesesCalc3(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("( ! A0 && A3 )")
+	val = rekursion.RekursivParentheses(tree)
+	assert.Equal(val, 2)
+}
+
+func TestRekursivParenthesesCalc4(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
+	val = rekursion.RekursivParentheses(tree)
+	assert.Equal(val, 6)
+}
+
+func TestRekursivParenthesesCalc5(test *testing.T) {
+	test.Skip("Methode noch nicht implementiert")
+	var assert = assert.New(test)
+	var tree syntaxbaum.SyntaxBaum
+	var val int
+	tree, _ = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
+	val = rekursion.RekursivParentheses(tree)
+	assert.Equal(val, 6)
+}