master > master: codego initialisiert

codego/aussagenlogik/syntaxbaum/syntaxbaum.go

@@ -0,0 +1,136 @@
+package syntaxbaum
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+type SyntaxBaum struct {
+	Kind     string
+	Expr     string
+	Valence  int
+	Children [](*SyntaxBaum)
+}
+
+/* ---------------------------------------------------------------- *
+ * METHODS
+ * ---------------------------------------------------------------- */
+
+func (tree SyntaxBaum) GetChildren() []SyntaxBaum {
+	var n int = tree.Valence
+	var children = make([]SyntaxBaum, n)
+	for i, subtreePtr := range tree.Children {
+		children[i] = *subtreePtr
+	}
+	return children
+}
+
+func (tree SyntaxBaum) GetChild(indexOpt ...int) (SyntaxBaum, error) {
+	var index int = 0
+	if len(indexOpt) > 0 {
+		index = indexOpt[0]
+	}
+	var subtree SyntaxBaum
+	var err error
+	if 0 <= index && index < tree.Valence {
+		subtree = *(tree.Children[index])
+	} else {
+		err = errors.New(fmt.Sprintf("Instance has no child of index %d !", index))
+	}
+	return subtree, err
+}
+
+func (tree SyntaxBaum) Pretty(preindentOpt ...string) string {
+	var preindent string = ""
+	if len(preindentOpt) > 0 {
+		preindent = preindentOpt[0]
+	}
+	return tree.pretty(preindent, "  ", "", 0)
+}
+
+func (tree SyntaxBaum) pretty(preindent string, tab string, prepend string, depth int) string {
+	var indent string = preindent + strings.Repeat(tab, depth)
+	switch tree.Valence {
+	case 0:
+		switch kind := tree.Kind; kind {
+		case "atom", "generic":
+			return indent + prepend + kind + " " + tree.Expr
+		default:
+			return indent + prepend + kind
+		}
+	default:
+		var lines string = indent + prepend + tree.Kind
+		prepend = "|__ "
+		for _, subtree := range tree.Children {
+			lines += "\n" + subtree.pretty(preindent, tab, prepend, depth+1)
+		}
+		return lines
+	}
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// METHODS: Recognitong of Formula-Types
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+func (tree SyntaxBaum) isAtom() bool {
+	return tree.Kind == "atom"
+}
+
+func (tree SyntaxBaum) isLiteral() bool {
+	if tree.isAtom() {
+		return true
+	} else if tree.isNegation() {
+		subtree, err := tree.GetChild()
+		if err == nil {
+			return subtree.isAtom()
+		}
+	}
+	return false
+}
+
+func (tree SyntaxBaum) isBeliebig() bool {
+	return tree.Kind == "generic"
+}
+
+func (tree SyntaxBaum) isTrueSymbol() bool {
+	return tree.Kind == "taut"
+}
+
+func (tree SyntaxBaum) isFalseSymbol() bool {
+	return tree.Kind == "contradiction"
+}
+
+func (tree SyntaxBaum) isNegation() bool {
+	return tree.Kind == "not"
+}
+
+func (tree SyntaxBaum) isConjunction() bool {
+	return tree.Kind == "and2"
+}
+
+func (tree SyntaxBaum) isLongConjunction() bool {
+	switch tree.Kind {
+	case "and", "and2":
+		return true
+	default:
+		return false
+	}
+}
+
+func (tree SyntaxBaum) isDisjunction() bool {
+	return tree.Kind == "or2"
+}
+
+func (tree SyntaxBaum) isLongDisjunction() bool {
+	switch tree.Kind {
+	case "or", "or2":
+		return true
+	default:
+		return false
+	}
+}
+
+func (tree SyntaxBaum) isImplication() bool {
+	return tree.Kind == "implies"
+}