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

master > master: codego Anwendung von Go's "channels" für Rekursion

Browse Source
This commit is contained in:
RD 2021-05-12 18:45:43 +02:00
parent 5e89d57dad
commit 8dcf781b96
1 changed files with 35 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
codego/aussagenlogik/rekursion/rekursion.go
View File

@ -1,7 +1,6 @@
package rekursion package rekursion
import ( import (
"log"
"logik/aussagenlogik/syntaxbaum" "logik/aussagenlogik/syntaxbaum"
"logik/core/utils" "logik/core/utils"
) )
@ -10,72 +9,62 @@ import (
* EXPORTS * EXPORTS
* ---------------------------------------------------------------- */ * ---------------------------------------------------------------- */
func RekursivEval(tree syntaxbaum.SyntaxBaum, I []string) int { type RekursiveChannelInt struct {
var children = tree.GetChildren() channel chan int
}
func RekursivEval(ch chan int, tree syntaxbaum.SyntaxBaum, I []string) {
// Werte für Teilformeln rekursiv berechnen
fn := func(_ch chan int, _tree syntaxbaum.SyntaxBaum) { RekursivEval(_ch, _tree, I) }
var values = RekursiveCallInt(fn, tree.GetChildren())
// Aus Werten für Teilformeln Wert für Formeln berechnen
if tree.IsAtom() || tree.IsGeneric() { if tree.IsAtom() || tree.IsGeneric() {
if utils.StrListContains(I, tree.Expr) { ch <- utils.BoolToInt(utils.StrListContains(I, tree.GetExpr()))
return 1
}
return 0
} else if tree.IsTautologySymbol() { } else if tree.IsTautologySymbol() {
return 1 ch <- 1
} else if tree.IsContradictionSymbol() { } else if tree.IsContradictionSymbol() {
return 0 ch <- 0
} else if tree.IsNegation() { } else if tree.IsNegation() {
subtree0, _ := tree.GetChild() ch <- 1 - values[0]
val0 := RekursivEval(subtree0, I)
return 1 - val0
} else if tree.IsConjunction2() { } else if tree.IsConjunction2() {
val0 := RekursivEval(children[0], I) ch <- utils.Min2(values[0], values[1])
val1 := RekursivEval(children[1], I)
return utils.Min2(val0, val1)
} else if tree.IsConjunction() { } else if tree.IsConjunction() {
var val = 1 ch <- utils.MinList(values)
for _, subtree := range children {
var val_ = RekursivEval(subtree, I)
val = utils.Min2(val, val_)
}
return val
} else if tree.IsDisjunction2() { } else if tree.IsDisjunction2() {
val0 := RekursivEval(children[0], I) ch <- utils.Max2(values[0], values[1])
val1 := RekursivEval(children[1], I)
return utils.Max2(val0, val1)
} else if tree.IsDisjunction() { } else if tree.IsDisjunction() {
var val = 0 ch <- utils.MaxList(values)
for _, subtree := range children {
var val_ = RekursivEval(subtree, I)
val = utils.Max2(val, val_)
}
return val
} else if tree.IsImplication() { } else if tree.IsImplication() {
val0 := RekursivEval(children[0], I) ch <- utils.BoolToInt(values[0] <= values[1])
val1 := RekursivEval(children[1], I)
if val0 <= val1 {
return 1
}
return 0
} else { } else {
log.Fatal("Could not evaluate expression!") panic("Could not evaluate expression!")
return 0
} }
} }
func RekursivAtoms(tree syntaxbaum.SyntaxBaum) []string { func RekursivAtoms(ch chan []string, tree syntaxbaum.SyntaxBaum) {
// // Werte für Teilformeln rekursiv berechnen
// var values = RekursiveCallStringList(RekursivAtoms, tree.GetChildren())
// Herausforderung: schreibe diese Funktion! // Herausforderung: schreibe diese Funktion!
return []string{} ch <- []string{}
} }
func RekursivDepth(tree syntaxbaum.SyntaxBaum) int { func RekursivDepth(ch chan int, tree syntaxbaum.SyntaxBaum) {
// // Werte für Teilformeln rekursiv berechnen
// var values = RekursiveCallInt(RekursivDepth, tree.GetChildren())
// Herausforderung: schreibe diese Funktion! // Herausforderung: schreibe diese Funktion!
return 0 ch <- 0
} }
func RekursivLength(tree syntaxbaum.SyntaxBaum) int { func RekursivLength(ch chan int, tree syntaxbaum.SyntaxBaum) {
// // Werte für Teilformeln rekursiv berechnen
// var values = RekursiveCallInt(RekursivLength, tree.GetChildren())
// Herausforderung: schreibe diese Funktion! // Herausforderung: schreibe diese Funktion!
return 0 ch <- 0
} }
func RekursivParentheses(tree syntaxbaum.SyntaxBaum) int { func RekursivParentheses(ch chan int, tree syntaxbaum.SyntaxBaum) {
// // Werte für Teilformeln rekursiv berechnen
// var values = RekursiveCallInt(RekursivParentheses, tree.GetChildren())
// Herausforderung: schreibe diese Funktion! // Herausforderung: schreibe diese Funktion!
return 0 ch <- 0
} }