codego/aussagenlogik/rekursion/rekursion.go

@@ -12,49 +12,50 @@ import (
 
 func RekursivEval(tree syntaxbaum.SyntaxBaum, I []string) int {
 	var children = tree.GetChildren()
-	if tree.IsAtom() || tree.IsGeneric() {
+	switch tree.Kind {
+	case "atom", "generic":
 		if utils.StrListContains(I, tree.Expr) {
 			return 1
 		}
 		return 0
-	} else if tree.IsTautologySymbol() {
+	case "taut":
 		return 1
-	} else if tree.IsContradictionSymbol() {
+	case "contradiction":
 		return 0
-	} else if tree.IsNegation() {
+	case "not":
 		subtree0, _ := tree.GetChild()
 		val0 := RekursivEval(subtree0, I)
 		return 1 - val0
-	} else if tree.IsConjunction2() {
+	case "and2":
 		val0 := RekursivEval(children[0], I)
 		val1 := RekursivEval(children[1], I)
 		return utils.Min2(val0, val1)
-	} else if tree.IsConjunction() {
+	case "and":
 		var val = 1
 		for _, subtree := range children {
 			var val_ = RekursivEval(subtree, I)
 			val = utils.Min2(val, val_)
 		}
 		return val
-	} else if tree.IsDisjunction2() {
+	case "or2":
 		val0 := RekursivEval(children[0], I)
 		val1 := RekursivEval(children[1], I)
 		return utils.Max2(val0, val1)
-	} else if tree.IsDisjunction() {
+	case "or":
 		var val = 0
 		for _, subtree := range children {
 			var val_ = RekursivEval(subtree, I)
 			val = utils.Max2(val, val_)
 		}
 		return val
-	} else if tree.IsImplication() {
+	case "implies":
 		val0 := RekursivEval(children[0], I)
 		val1 := RekursivEval(children[1], I)
 		if val0 <= val1 {
 			return 1
 		}
 		return 0
-	} else {
+	default:
 		log.Fatal("Could not evaluate expression!")
 		return 0
 	}

codego/aussagenlogik/syntaxbaum/syntaxbaum.go

@@ -73,62 +73,64 @@ func (tree SyntaxBaum) pretty(preindent string, tab string, prepend string, dept
 // METHODS: Recognitong of Formula-Types
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-func (tree SyntaxBaum) IsIrreducible() bool {
+func (tree SyntaxBaum) isAtom() bool {
-	return tree.Valence == 0
-}
-
-func (tree SyntaxBaum) IsAtom() bool {
 	return tree.Kind == "atom"
 }
 
-func (tree SyntaxBaum) IsLiteral() bool {
+func (tree SyntaxBaum) isLiteral() bool {
-	if tree.IsAtom() {
+	if tree.isAtom() {
 		return true
-	} else if tree.IsNegation() {
+	} else if tree.isNegation() {
 		subtree, err := tree.GetChild()
 		if err == nil {
-			return subtree.IsAtom()
+			return subtree.isAtom()
 		}
 	}
 	return false
 }
 
-func (tree SyntaxBaum) IsGeneric() bool {
+func (tree SyntaxBaum) isBeliebig() bool {
 	return tree.Kind == "generic"
 }
 
-func (tree SyntaxBaum) IsTautologySymbol() bool {
+func (tree SyntaxBaum) isTrueSymbol() bool {
 	return tree.Kind == "taut"
 }
 
-func (tree SyntaxBaum) IsContradictionSymbol() bool {
+func (tree SyntaxBaum) isFalseSymbol() bool {
 	return tree.Kind == "contradiction"
 }
 
-func (tree SyntaxBaum) IsConnective() bool {
+func (tree SyntaxBaum) isNegation() bool {
-	return tree.Valence > 0
-}
-
-func (tree SyntaxBaum) IsNegation() bool {
 	return tree.Kind == "not"
 }
 
-func (tree SyntaxBaum) IsConjunction2() bool {
+func (tree SyntaxBaum) isConjunction() bool {
 	return tree.Kind == "and2"
 }
 
-func (tree SyntaxBaum) IsConjunction() bool {
+func (tree SyntaxBaum) isLongConjunction() bool {
-	return tree.Kind == "and" || tree.Kind == "and2"
+	switch tree.Kind {
+	case "and", "and2":
+		return true
+	default:
+		return false
+	}
 }
 
-func (tree SyntaxBaum) IsDisjunction2() bool {
+func (tree SyntaxBaum) isDisjunction() bool {
 	return tree.Kind == "or2"
 }
 
-func (tree SyntaxBaum) IsDisjunction() bool {
+func (tree SyntaxBaum) isLongDisjunction() bool {
-	return tree.Kind == "or" || tree.Kind == "or2"
+	switch tree.Kind {
+	case "or", "or2":
+		return true
+	default:
+		return false
+	}
 }
 
-func (tree SyntaxBaum) IsImplication() bool {
+func (tree SyntaxBaum) isImplication() bool {
 	return tree.Kind == "implies"
 }

codego/test.sh

@@ -8,9 +8,6 @@
 # HILFSMETHODEN
 ################################
 
-export TEST_VERBOSE=false # <- true: unittest mit verbose output
-export TEST_TIMEOUT="60s"
-
 function call_go() {
     go $@;
 }
@@ -22,9 +19,7 @@ function check_requirements() {
 
 function run_unittests(){
     echo -e "\033[1mUNITTESTS\033[0m\n";
-    local verbose_opt="";
+    call_go test -v -timeout 60s -count 1 -run "^Test[A-Z].*" "logik" "./...";
-    ( $TEST_VERBOSE ) && verbose_opt="-v"
-    call_go test $verbose_opt -timeout $TEST_TIMEOUT -count 1 -run "^Test[A-Z].*" "logik" "./...";
 }
 
 ################################