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

Compare commits

base: raj_mathe:45821fc85d113a6ceae6b76356ebc72761461991
Branches Tags
raj_mathe:master
..
compare: raj_mathe:44b0ee41bf71a3f740d5c4387c57ca88e4e4e70b
Branches Tags
raj_mathe:master

No commits in common. "45821fc85d113a6ceae6b76356ebc72761461991" and "44b0ee41bf71a3f740d5c4387c57ca88e4e4e70b" have entirely different histories.
45821fc85d ... 44b0ee41bf

10 changed files with 253 additions and 426 deletions
Show Stats Expand all files Collapse all files

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

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

51
codego/aussagenlogik/rekursion/rekursion_aux.go
View File

@ -1,51 +0,0 @@
package rekursion
import (
"logik/aussagenlogik/syntaxbaum"
)
/* ---------------------------------------------------------------- *
* EXPORTS
* ---------------------------------------------------------------- */
func RekursiveCallInt(fn func(ch chan int, tree syntaxbaum.SyntaxBaum), children []syntaxbaum.SyntaxBaum) []int {
subChannel := make(chan int)
values := make([]int, len(children))
// start parallel computations on subformulae
for _, subtree := range children {
go fn(subChannel, subtree)
}
// successively read values
for i := 0; i < len(children); i++ {
values[i] = <-subChannel
}
return values
}
func RekursiveCallString(fn func(ch chan string, tree syntaxbaum.SyntaxBaum), children []syntaxbaum.SyntaxBaum) []string {
subChannel := make(chan string)
values := make([]string, len(children))
// start parallel computations
for _, subtree := range children {
go fn(subChannel, subtree)
}
// successively read values
for i := 0; i < len(children); i++ {
values[i] = <-subChannel
}
return values
}
func RekursiveCallStringList(fn func(ch chan []string, tree syntaxbaum.SyntaxBaum), children []syntaxbaum.SyntaxBaum) [][]string {
subChannel := make(chan []string)
values := make([][]string, len(children))
// start parallel computations
for _, subtree := range children {
go fn(subChannel, subtree)
}
// successively read values
for i := 0; i < len(children); i++ {
values[i] = <-subChannel
}
return values
}

202
codego/aussagenlogik/rekursion/rekursion_test.go
View File

@ -20,59 +20,59 @@ import (
func TestRekursivEvalLiteral(test *testing.T) { func TestRekursivEvalLiteral(test *testing.T) {
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
var I []string var I []string
tree = schema.ParseExpr("A0") var val int
tree, _ = schema.ParseExpr("A0")
I = []string{"A0"} I = []string{"A0"}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 1) assert.Equal(val, 1)
tree = schema.ParseExpr("A0") tree, _ = schema.ParseExpr("A0")
I = []string{} I = []string{}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 0) assert.Equal(val, 0)
tree = schema.ParseExpr("! A0") tree, _ = schema.ParseExpr("! A0")
I = []string{"A0"} I = []string{"A0"}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 0) assert.Equal(val, 0)
tree = schema.ParseExpr("! A0") tree, _ = schema.ParseExpr("! A0")
I = []string{} I = []string{}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 1) assert.Equal(val, 1)
} }
func TestRekursivEvalComplex1(test *testing.T) { func TestRekursivEvalComplex1(test *testing.T) {
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
var I []string var I []string
tree = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || A2 ))") var val int
tree, _ = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || A2 ))")
I = []string{"A0", "A2"} I = []string{"A0", "A2"}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 1) assert.Equal(val, 1)
I = []string{"A0", "A3"} I = []string{"A0", "A3"}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 1) assert.Equal(val, 1)
I = []string{"A0"} I = []string{"A0"}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 0) assert.Equal(val, 0)
I = []string{"A4", "A8"} I = []string{"A4", "A8"}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 1) assert.Equal(val, 1)
} }
func TestRekursivEvalComplex2(test *testing.T) { func TestRekursivEvalComplex2(test *testing.T) {
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
var I []string var I []string
tree = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || ! A2 ))") var val int
tree, _ = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || ! A2 ))")
I = []string{"A0", "A2"} I = []string{"A0", "A2"}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 0) assert.Equal(val, 0)
I = []string{"A0", "A3"} I = []string{"A0", "A3"}
go rekursion.RekursivEval(ch, tree, I) val = rekursion.RekursivEval(tree, I)
assert.Equal(<-ch, 1) assert.Equal(val, 1)
} }
/* ---------------------------------------------------------------- * /* ---------------------------------------------------------------- *
@ -82,12 +82,10 @@ func TestRekursivEvalComplex2(test *testing.T) {
func TestRekursivAtomsNoduplicates(test *testing.T) { func TestRekursivAtomsNoduplicates(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan []string)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
var val []string var val []string
tree = schema.ParseExpr("( A4 && ( A4 || A4 ))") tree, _ = schema.ParseExpr("( A4 && ( A4 || A4 ))")
go rekursion.RekursivAtoms(ch, tree) val = rekursion.RekursivAtoms(tree)
val = <-ch
var n int = len(utils.FilterStrings(&val, func(x string) bool { return x == "A4" })) var n int = len(utils.FilterStrings(&val, func(x string) bool { return x == "A4" }))
assert.Equal(n, 1, "Atome dürfen nicht mehrfach vorkommen!") assert.Equal(n, 1, "Atome dürfen nicht mehrfach vorkommen!")
} }
@ -96,12 +94,10 @@ func TestRekursivAtomsNononatoms(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
test.Skip("Syntax for generic expressions in ANTLR4 g4 needs to be implemented.") test.Skip("Syntax for generic expressions in ANTLR4 g4 needs to be implemented.")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan []string)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
var val []string var val []string
tree = schema.ParseExpr("( {F} || A3 )") tree, _ = schema.ParseExpr("( {F} || A3 )")
go rekursion.RekursivAtoms(ch, tree) val = rekursion.RekursivAtoms(tree)
val = <-ch
utils.SortStrings(&val) utils.SortStrings(&val)
assert.NotContains(val, "F", "Nichtatomare Formeln dürfen nicht vorkommen!") assert.NotContains(val, "F", "Nichtatomare Formeln dürfen nicht vorkommen!")
} }
@ -109,12 +105,10 @@ func TestRekursivAtomsNononatoms(test *testing.T) {
func TestRekursivAtomsCalc1(test *testing.T) { func TestRekursivAtomsCalc1(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan []string)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
var val []string var val []string
tree = schema.ParseExpr("A0") tree, _ = schema.ParseExpr("A0")
go rekursion.RekursivAtoms(ch, tree) val = rekursion.RekursivAtoms(tree)
val = <-ch
utils.SortStrings(&val) utils.SortStrings(&val)
assert.Equal(val, []string{"A0"}) assert.Equal(val, []string{"A0"})
} }
@ -122,12 +116,10 @@ func TestRekursivAtomsCalc1(test *testing.T) {
func TestRekursivAtomsCalc2(test *testing.T) { func TestRekursivAtomsCalc2(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan []string)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
var val []string var val []string
tree = schema.ParseExpr("((( ! A8 && A3 ) || A4 ) && A0 )") tree, _ = schema.ParseExpr("((( ! A8 && A3 ) || A4 ) && A0 )")
go rekursion.RekursivAtoms(ch, tree) val = rekursion.RekursivAtoms(tree)
val = <-ch
utils.SortStrings(&val) utils.SortStrings(&val)
assert.Equal(val, []string{"A0", "A3", "A4", "A8"}) assert.Equal(val, []string{"A0", "A3", "A4", "A8"})
} }
@ -139,51 +131,51 @@ func TestRekursivAtomsCalc2(test *testing.T) {
func TestRekursivDepthCalc1(test *testing.T) { func TestRekursivDepthCalc1(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("A0") var val int
go rekursion.RekursivDepth(ch, tree) tree, _ = schema.ParseExpr("A0")
assert.Equal(<-ch, 0) val = rekursion.RekursivDepth(tree)
assert.Equal(val, 0)
} }
func TestRekursivDepthCalc2(test *testing.T) { func TestRekursivDepthCalc2(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("!! A8") var val int
go rekursion.RekursivDepth(ch, tree) tree, _ = schema.ParseExpr("!! A8")
assert.Equal(<-ch, 2) val = rekursion.RekursivDepth(tree)
assert.Equal(val, 2)
} }
func TestRekursivDepthCalc3(test *testing.T) { func TestRekursivDepthCalc3(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("( ! A0 && A3 )") var val int
go rekursion.RekursivDepth(ch, tree) tree, _ = schema.ParseExpr("( ! A0 && A3 )")
assert.Equal(<-ch, 2) val = rekursion.RekursivDepth(tree)
assert.Equal(val, 2)
} }
func TestRekursivDepthCalc4(test *testing.T) { func TestRekursivDepthCalc4(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )") var val int
go rekursion.RekursivDepth(ch, tree) tree, _ = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
assert.Equal(<-ch, 4) val = rekursion.RekursivDepth(tree)
assert.Equal(val, 4)
} }
func TestRekursivDepthCalc5(test *testing.T) { func TestRekursivDepthCalc5(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )") var val int
go rekursion.RekursivDepth(ch, tree) tree, _ = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
assert.Equal(<-ch, 5) val = rekursion.RekursivDepth(tree)
assert.Equal(val, 5)
} }
/* ---------------------------------------------------------------- * /* ---------------------------------------------------------------- *
@ -193,51 +185,51 @@ func TestRekursivDepthCalc5(test *testing.T) {
func TestRekursivLengthCalc1(test *testing.T) { func TestRekursivLengthCalc1(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("A0") var val int
go rekursion.RekursivLength(ch, tree) tree, _ = schema.ParseExpr("A0")
assert.Equal(<-ch, 1) val = rekursion.RekursivLength(tree)
assert.Equal(val, 1)
} }
func TestRekursivLengthCalc2(test *testing.T) { func TestRekursivLengthCalc2(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("!! A8") var val int
go rekursion.RekursivLength(ch, tree) tree, _ = schema.ParseExpr("!! A8")
assert.Equal(<-ch, 3) val = rekursion.RekursivLength(tree)
assert.Equal(val, 3)
} }
func TestRekursivLengthCalc3(test *testing.T) { func TestRekursivLengthCalc3(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("( ! A0 && A3 )") var val int
go rekursion.RekursivLength(ch, tree) tree, _ = schema.ParseExpr("( ! A0 && A3 )")
assert.Equal(<-ch, 4) val = rekursion.RekursivLength(tree)
assert.Equal(val, 4)
} }
func TestRekursivLengthCalc4(test *testing.T) { func TestRekursivLengthCalc4(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )") var val int
go rekursion.RekursivLength(ch, tree) tree, _ = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
assert.Equal(<-ch, 8) val = rekursion.RekursivLength(tree)
assert.Equal(val, 8)
} }
func TestRekursivLengthCalc5(test *testing.T) { func TestRekursivLengthCalc5(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )") var val int
go rekursion.RekursivLength(ch, tree) tree, _ = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
assert.Equal(<-ch, 9) val = rekursion.RekursivLength(tree)
assert.Equal(val, 9)
} }
/* ---------------------------------------------------------------- * /* ---------------------------------------------------------------- *
@ -247,49 +239,49 @@ func TestRekursivLengthCalc5(test *testing.T) {
func TestRekursivParenthesesCalc1(test *testing.T) { func TestRekursivParenthesesCalc1(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("A0") var val int
go rekursion.RekursivParentheses(ch, tree) tree, _ = schema.ParseExpr("A0")
assert.Equal(<-ch, 0) val = rekursion.RekursivParentheses(tree)
assert.Equal(val, 0)
} }
func TestRekursivParenthesesCalc2(test *testing.T) { func TestRekursivParenthesesCalc2(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("!! A8") var val int
go rekursion.RekursivParentheses(ch, tree) tree, _ = schema.ParseExpr("!! A8")
assert.Equal(<-ch, 0) val = rekursion.RekursivParentheses(tree)
assert.Equal(val, 0)
} }
func TestRekursivParenthesesCalc3(test *testing.T) { func TestRekursivParenthesesCalc3(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("( ! A0 && A3 )") var val int
go rekursion.RekursivParentheses(ch, tree) tree, _ = schema.ParseExpr("( ! A0 && A3 )")
assert.Equal(<-ch, 2) val = rekursion.RekursivParentheses(tree)
assert.Equal(val, 2)
} }
func TestRekursivParenthesesCalc4(test *testing.T) { func TestRekursivParenthesesCalc4(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )") var val int
go rekursion.RekursivParentheses(ch, tree) tree, _ = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
assert.Equal(<-ch, 6) val = rekursion.RekursivParentheses(tree)
assert.Equal(val, 6)
} }
func TestRekursivParenthesesCalc5(test *testing.T) { func TestRekursivParenthesesCalc5(test *testing.T) {
test.Skip("Methode noch nicht implementiert") test.Skip("Methode noch nicht implementiert")
var assert = assert.New(test) var assert = assert.New(test)
var ch = make(chan int)
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )") var val int
go rekursion.RekursivParentheses(ch, tree) tree, _ = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
assert.Equal(<-ch, 6) val = rekursion.RekursivParentheses(tree)
assert.Equal(val, 6)
} }

64
codego/aussagenlogik/schema/schema.go
View File

@ -1,6 +1,7 @@
package schema package schema
import ( import (
"errors"
"logik/aussagenlogik/syntaxbaum" "logik/aussagenlogik/syntaxbaum"
parser "logik/grammars/aussagenlogik" parser "logik/grammars/aussagenlogik"
"strings" "strings"
@ -12,13 +13,13 @@ import (
* EXPORTS * EXPORTS
* ---------------------------------------------------------------- */ * ---------------------------------------------------------------- */
func ParseExpr(u string) syntaxbaum.SyntaxBaum { func ParseExpr(u string) (syntaxbaum.SyntaxBaum, error) {
var lexer = createLexer(u) var lexer = createLexer(u)
var tokenStream = lexerToTokenStream(lexer) var tokenStream = lexerToTokenStream(lexer)
var prs = parser.NewaussagenlogikParser(tokenStream) var prs = parser.NewaussagenlogikParser(tokenStream)
var t = prs.Start() var t = prs.Start()
tree := createSyntaxBaum(t, prs) tree, err := createSyntaxBaum(t, prs)
return tree return tree, err
} }
/* ---------------------------------------------------------------- * /* ---------------------------------------------------------------- *
@ -38,7 +39,7 @@ func createLexer(u string) antlr.Lexer {
return parser.NewaussagenlogikLexer(stream) return parser.NewaussagenlogikLexer(stream)
} }
func createSyntaxBaum(tree antlr.Tree, parser antlr.Parser) syntaxbaum.SyntaxBaum { func createSyntaxBaum(tree antlr.Tree, parser antlr.Parser) (syntaxbaum.SyntaxBaum, error) {
var ant = antlrTree{tree: tree, parser: &parser} var ant = antlrTree{tree: tree, parser: &parser}
return ant.toSyntaxBaum() return ant.toSyntaxBaum()
} }
@ -86,8 +87,9 @@ func (ant antlrTree) getTextContentLeaves() string {
return expr return expr
} }
func (ant antlrTree) toSyntaxBaum() syntaxbaum.SyntaxBaum { func (ant antlrTree) toSyntaxBaum() (syntaxbaum.SyntaxBaum, error) {
var tree syntaxbaum.SyntaxBaum var tree syntaxbaum.SyntaxBaum
var err error
var label string = ant.getLabel() var label string = ant.getLabel()
var subants = ant.getChildren() var subants = ant.getChildren()
var nChildren = len(subants) var nChildren = len(subants)
@ -112,20 +114,21 @@ func (ant antlrTree) toSyntaxBaum() syntaxbaum.SyntaxBaum {
if nChildren == 1 { if nChildren == 1 {
subant := subants[0] subant := subants[0]
tree = syntaxbaum.SyntaxBaum{} tree = syntaxbaum.SyntaxBaum{}
tree.SetKind(subant.getLabel()) tree.Expr = subant.getTextContentLeaves()
tree.SetExpr(subant.getTextContentLeaves()) tree.Kind = subant.getLabel()
tree.SetChildren([](*syntaxbaum.SyntaxBaum){}) tree.Children = [](*syntaxbaum.SyntaxBaum){}
return tree tree.Valence = 0
return tree, nil
} }
case "not": case "not":
if nChildren == 2 { if nChildren == 2 { // Children: [NotSymbol, Teilformel]
// NOTE: Children = [NotSymbol, Teilformel] subtree, err := subants[1].toSyntaxBaum()
subtree := subants[1].toSyntaxBaum()
tree = syntaxbaum.SyntaxBaum{} tree = syntaxbaum.SyntaxBaum{}
tree.SetKind(label) tree.Expr = subants[0].getTextContent() + " " + subtree.Expr
tree.SetExpr(subants[0].getTextContent() + " " + subtree.GetExpr()) tree.Kind = label
tree.SetChildren([](*syntaxbaum.SyntaxBaum){&subtree}) tree.Children = [](*syntaxbaum.SyntaxBaum){&subtree}
return tree tree.Valence = 1
return tree, err
} }
case "and2", "and", "or2", "or", "implies": case "and2", "and", "or2", "or", "implies":
var n int = int((len(subants) + 1) / 2) var n int = int((len(subants) + 1) / 2)
@ -136,26 +139,37 @@ func (ant antlrTree) toSyntaxBaum() syntaxbaum.SyntaxBaum {
var expr string = "" var expr string = ""
for _, subant := range subants { for _, subant := range subants {
if isSymb { if isSymb {
expr += " " + subant.getTextContent() expr += " " + subant.getTextContent() + " "
} else { } else {
subtree := subant.toSyntaxBaum() subtree, err_ := subant.toSyntaxBaum()
if err_ != nil {
err = err_
}
subtrees[i] = &subtree subtrees[i] = &subtree
expr += " " + subtree.GetExpr() expr += " " + subtree.Expr + " "
i++ i++
} }
// NOTE: infix notation: alternatives between expression and symbol
isSymb = !isSymb isSymb = !isSymb
} }
expr = strings.Trim(expr, " ") expr = strings.Trim(expr, " ")
var lbrace string = "(" var lbrace string = "("
var rbrace string = ")" var rbrace string = ")"
// var lbrace string = "( "
// var rbrace string = " )"
// if strings.HasPrefix(expr, "(") {
// lbrace = "("
// }
// if strings.HasSuffix(expr, ")") {
// rbrace = ")"
// }
tree = syntaxbaum.SyntaxBaum{} tree = syntaxbaum.SyntaxBaum{}
tree.SetKind(label) tree.Expr = lbrace + expr + rbrace
tree.SetExpr(lbrace + expr + rbrace) tree.Kind = label
tree.SetChildren(subtrees) tree.Children = subtrees
return tree tree.Valence = n
return tree, err
} }
} }
panic("Could not parse expression") return tree, errors.New("Could not parse expression")
} }

24
codego/aussagenlogik/schema/schema_test.go
View File

@ -6,7 +6,6 @@ package schema_test
import ( import (
"logik/aussagenlogik/schema" "logik/aussagenlogik/schema"
"logik/aussagenlogik/syntaxbaum"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
@ -18,25 +17,6 @@ import (
func TestParseExpr(test *testing.T) { func TestParseExpr(test *testing.T) {
var assert = assert.New(test) var assert = assert.New(test)
var tree syntaxbaum.SyntaxBaum assert.Equal(0, 0)
schema.ParseExpr("A0")
tree = schema.ParseExpr("A8712")
assert.Equal("A8712", tree.GetExpr())
assert.Equal("atom", tree.GetKind())
assert.Equal(0, len(tree.GetChildren()))
tree = schema.ParseExpr(" ! A5 ")
assert.Equal("! A5", tree.GetExpr())
assert.Equal("not", tree.GetKind())
assert.Equal(1, len(tree.GetChildren()))
tree = schema.ParseExpr("A0 -> A1")
assert.Equal("(A0 -> A1)", tree.GetExpr())
assert.Equal("implies", tree.GetKind())
assert.Equal(2, len(tree.GetChildren()))
tree = schema.ParseExpr("( A0 && A1) || A2")
assert.Equal("((A0 && A1) || A2)", tree.GetExpr())
assert.Equal("or2", tree.GetKind())
assert.Equal(2, len(tree.GetChildren()))
} }

70
codego/aussagenlogik/syntaxbaum/syntaxbaum.go
View File

@ -7,40 +7,20 @@ import (
) )
type SyntaxBaum struct { type SyntaxBaum struct {
kind string Kind string
expr string Expr string
valence int Valence int
children [](*SyntaxBaum) Children [](*SyntaxBaum)
} }
/* ---------------------------------------------------------------- * /* ---------------------------------------------------------------- *
* METHODS * METHODS
* ---------------------------------------------------------------- */ * ---------------------------------------------------------------- */
func (tree *SyntaxBaum) SetKind(kind string) {
tree.kind = kind
}
func (tree SyntaxBaum) GetKind() string {
return tree.kind
}
func (tree *SyntaxBaum) SetExpr(expr string) {
tree.expr = expr
}
func (tree SyntaxBaum) GetExpr() string {
return tree.expr
}
func (tree *SyntaxBaum) SetChildren(children [](*SyntaxBaum)) {
tree.children = children
tree.valence = len(children)
}
func (tree SyntaxBaum) GetChildren() []SyntaxBaum { func (tree SyntaxBaum) GetChildren() []SyntaxBaum {
var n int = tree.valence var n int = tree.Valence
var children = make([]SyntaxBaum, n) var children = make([]SyntaxBaum, n)
for i, subtreePtr := range tree.children { for i, subtreePtr := range tree.Children {
children[i] = *subtreePtr children[i] = *subtreePtr
} }
return children return children
@ -53,8 +33,8 @@ func (tree SyntaxBaum) GetChild(indexOpt ...int) (SyntaxBaum, error) {
} }
var subtree SyntaxBaum var subtree SyntaxBaum
var err error var err error
if 0 <= index && index < tree.valence { if 0 <= index && index < tree.Valence {
subtree = *(tree.children[index]) subtree = *(tree.Children[index])
} else { } else {
err = errors.New(fmt.Sprintf("Instance has no child of index %d !", index)) err = errors.New(fmt.Sprintf("Instance has no child of index %d !", index))
} }
@ -71,18 +51,18 @@ func (tree SyntaxBaum) Pretty(preindentOpt ...string) string {
func (tree SyntaxBaum) pretty(preindent string, tab string, prepend string, depth int) string { func (tree SyntaxBaum) pretty(preindent string, tab string, prepend string, depth int) string {
var indent string = preindent + strings.Repeat(tab, depth) var indent string = preindent + strings.Repeat(tab, depth)
switch tree.valence { switch tree.Valence {
case 0: case 0:
switch kind := tree.kind; kind { switch kind := tree.Kind; kind {
case "atom", "generic": case "atom", "generic":
return indent + prepend + kind + " " + tree.expr return indent + prepend + kind + " " + tree.Expr
default: default:
return indent + prepend + kind return indent + prepend + kind
} }
default: default:
var lines string = indent + prepend + tree.kind var lines string = indent + prepend + tree.Kind
prepend = "|__ " prepend = "|__ "
for _, subtree := range tree.children { for _, subtree := range tree.Children {
lines += "\n" + subtree.pretty(preindent, tab, prepend, depth+1) lines += "\n" + subtree.pretty(preindent, tab, prepend, depth+1)
} }
return lines return lines
@ -94,11 +74,11 @@ func (tree SyntaxBaum) pretty(preindent string, tab string, prepend string, dept
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
func (tree SyntaxBaum) IsIrreducible() bool { func (tree SyntaxBaum) IsIrreducible() bool {
return tree.valence == 0 return tree.Valence == 0
} }
func (tree SyntaxBaum) IsAtom() bool { func (tree SyntaxBaum) IsAtom() bool {
return tree.kind == "atom" return tree.Kind == "atom"
} }
func (tree SyntaxBaum) IsLiteral() bool { func (tree SyntaxBaum) IsLiteral() bool {
@ -114,41 +94,41 @@ func (tree SyntaxBaum) IsLiteral() bool {
} }
func (tree SyntaxBaum) IsGeneric() bool { func (tree SyntaxBaum) IsGeneric() bool {
return tree.kind == "generic" return tree.Kind == "generic"
} }
func (tree SyntaxBaum) IsTautologySymbol() bool { func (tree SyntaxBaum) IsTautologySymbol() bool {
return tree.kind == "taut" return tree.Kind == "taut"
} }
func (tree SyntaxBaum) IsContradictionSymbol() bool { func (tree SyntaxBaum) IsContradictionSymbol() bool {
return tree.kind == "contradiction" return tree.Kind == "contradiction"
} }
func (tree SyntaxBaum) IsConnective() bool { func (tree SyntaxBaum) IsConnective() bool {
return tree.valence > 0 return tree.Valence > 0
} }
func (tree SyntaxBaum) IsNegation() bool { func (tree SyntaxBaum) IsNegation() bool {
return tree.kind == "not" return tree.Kind == "not"
} }
func (tree SyntaxBaum) IsConjunction2() bool { func (tree SyntaxBaum) IsConjunction2() bool {
return tree.kind == "and2" return tree.Kind == "and2"
} }
func (tree SyntaxBaum) IsConjunction() bool { func (tree SyntaxBaum) IsConjunction() bool {
return tree.kind == "and" || tree.kind == "and2" return tree.Kind == "and" || tree.Kind == "and2"
} }
func (tree SyntaxBaum) IsDisjunction2() bool { func (tree SyntaxBaum) IsDisjunction2() bool {
return tree.kind == "or2" return tree.Kind == "or2"
} }
func (tree SyntaxBaum) IsDisjunction() bool { func (tree SyntaxBaum) IsDisjunction() bool {
return tree.kind == "or" || tree.kind == "or2" return tree.Kind == "or" || tree.Kind == "or2"
} }
func (tree SyntaxBaum) IsImplication() bool { func (tree SyntaxBaum) IsImplication() bool {
return tree.kind == "implies" return tree.Kind == "implies"
} }

80
codego/core/utils/utils.go
View File

@ -1,38 +1,22 @@
package utils package utils
import ( import (
"encoding/json"
"log"
"sort" "sort"
"strings" "strings"
) )
/* ---------------------------------------------------------------- * /* ---------------------------------------------------------------- *
* METHODS: json * EXPORTS
* ---------------------------------------------------------------- */ * ---------------------------------------------------------------- */
func JsonToArrayOfStrings(s string, value *[]string) { func StrListContains(list []string, x string) bool {
var err error for _, obj := range list {
err = json.Unmarshal([]byte(s), &value) if obj == x {
if err != nil { return true
panic(err)
} }
} }
return false
/* ---------------------------------------------------------------- *
* METHODS: conversion
* ---------------------------------------------------------------- */
func BoolToInt(cond bool) int {
if cond {
return 1
} }
return 0
}
/* ---------------------------------------------------------------- *
* METHODS: for integer lists
* ---------------------------------------------------------------- */
func Min2(x int, y int) int { func Min2(x int, y int) int {
if x <= y { if x <= y {
@ -48,49 +32,6 @@ func Max2(x int, y int) int {
return y return y
} }
func MinList(x []int) int {
var val int
if len(x) == 0 {
log.Fatal("Cannot compute the maximum of an empty array.")
return 0
}
val = x[0]
for i, val_ := range x {
if i > 0 {
val = Min2(val, val_)
}
}
return val
}
func MaxList(x []int) int {
var val int
if len(x) == 0 {
log.Fatal("Cannot compute the maximum of an empty array.")
return 0
}
val = x[0]
for i, val_ := range x {
if i > 0 {
val = Max2(val, val_)
}
}
return val
}
/* ---------------------------------------------------------------- *
* METHODS: for string lists
* ---------------------------------------------------------------- */
func StrListContains(list []string, x string) bool {
for _, obj := range list {
if obj == x {
return true
}
}
return false
}
func SortStrings(list *[]string) { func SortStrings(list *[]string) {
sort.Slice(*list, func(i int, j int) bool { sort.Slice(*list, func(i int, j int) bool {
u := strings.ToLower((*list)[i]) u := strings.ToLower((*list)[i])
@ -127,7 +68,6 @@ func UnionStrings2(list1 []string, list2 []string) []string {
return list return list
} }
// assumes that listTo contains no duplicates
func UnionStringsTo(listTo *[]string, listFrom []string) { func UnionStringsTo(listTo *[]string, listFrom []string) {
var mark = make(map[string]bool) var mark = make(map[string]bool)
for _, item := range listFrom { for _, item := range listFrom {
@ -142,11 +82,3 @@ func UnionStringsTo(listTo *[]string, listFrom []string) {
} }
} }
} }
func UnionStringsList(lists [][]string) []string {
var list = []string{}
for _, list_ := range lists {
UnionStringsTo(&list, list_)
}
return list
}

48
codego/core/utils/utils_test.go
View File

@ -12,28 +12,6 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
/* ---------------------------------------------------------------- *
* TESTCASE Min2, Max2, MinList, MaxList
* ---------------------------------------------------------------- */
func TestMin(test *testing.T) {
var assert = assert.New(test)
assert.Equal(3, utils.Min2(3, 8))
assert.Equal(8, utils.Min2(100, 8))
assert.Equal(50, utils.MinList([]int{50}))
assert.Equal(1, utils.MinList([]int{50, 1}))
assert.Equal(2, utils.MinList([]int{50, 34, 10, 2, 8, 89}))
}
func TestMax(test *testing.T) {
var assert = assert.New(test)
assert.Equal(8, utils.Max2(3, 8))
assert.Equal(100, utils.Max2(100, 8))
assert.Equal(50, utils.MaxList([]int{50}))
assert.Equal(50, utils.MaxList([]int{50, 1}))
assert.Equal(89, utils.MaxList([]int{50, 34, 10, 2, 8, 89}))
}
/* ---------------------------------------------------------------- * /* ---------------------------------------------------------------- *
* TESTCASE SortStrings * TESTCASE SortStrings
* ---------------------------------------------------------------- */ * ---------------------------------------------------------------- */
@ -42,7 +20,7 @@ func TestSortStrings(test *testing.T) {
var assert = assert.New(test) var assert = assert.New(test)
var list = []string{"katze", "Hund", "baby", "Pluto", "Saturn", "Mond"} var list = []string{"katze", "Hund", "baby", "Pluto", "Saturn", "Mond"}
utils.SortStrings(&list) utils.SortStrings(&list)
assert.Equal([]string{"baby", "Hund", "katze", "Mond", "Pluto", "Saturn"}, list) assert.Equal(list, []string{"baby", "Hund", "katze", "Mond", "Pluto", "Saturn"})
} }
/* ---------------------------------------------------------------- * /* ---------------------------------------------------------------- *
@ -53,11 +31,11 @@ func TestFilterStrings(test *testing.T) {
var assert = assert.New(test) var assert = assert.New(test)
var list = []string{"abram", "aaron", "aardvark", "aarhus", "alaska", "eel", "aal"} var list = []string{"abram", "aaron", "aardvark", "aarhus", "alaska", "eel", "aal"}
var list2 = utils.FilterStrings(&list, func(x string) bool { return strings.HasPrefix(x, "aa") }) var list2 = utils.FilterStrings(&list, func(x string) bool { return strings.HasPrefix(x, "aa") })
assert.Equal([]string{"aaron", "aardvark", "aarhus", "aal"}, list2) assert.Equal(list2, []string{"aaron", "aardvark", "aarhus", "aal"})
} }
/* ---------------------------------------------------------------- * /* ---------------------------------------------------------------- *
* TESTCASE UnionStrings2, UnionStringsTo, UnionStringsList * TESTCASE UnionStrings2, UnionStringsTo
* ---------------------------------------------------------------- */ * ---------------------------------------------------------------- */
func TestUnionStrings2(test *testing.T) { func TestUnionStrings2(test *testing.T) {
@ -66,24 +44,14 @@ func TestUnionStrings2(test *testing.T) {
var list2 = []string{"yellow", "orange", "lila", "red"} var list2 = []string{"yellow", "orange", "lila", "red"}
var list = utils.UnionStrings2(list1, list2) var list = utils.UnionStrings2(list1, list2)
utils.SortStrings(&list) utils.SortStrings(&list)
assert.Equal([]string{"black", "blue", "green", "grey", "lila", "orange", "red", "yellow"}, list) assert.Equal(list, []string{"black", "blue", "green", "grey", "lila", "orange", "red", "yellow"})
} }
func TestUnionStringsTo(test *testing.T) { func UnionStringsTo(test *testing.T) {
var assert = assert.New(test) var assert = assert.New(test)
var list1 = []string{"red", "blue", "green"} var list1 = []string{"red", "blue", "blue", "green"}
var list2 = []string{"yellow", "red", "blue", "red", "black"} var list2 = []string{"yellow", "red", "black"}
utils.UnionStringsTo(&list1, list2) utils.UnionStringsTo(&list1, list2)
utils.SortStrings(&list1) utils.SortStrings(&list1)
assert.Equal([]string{"black", "blue", "green", "red", "yellow"}, list1) assert.Equal(list1, []string{"black", "blue", "green", "red", "yellow"})
}
func TestUnionStringsList(test *testing.T) {
var assert = assert.New(test)
var list []string
var lists [][]string
lists = [][]string{{"red", "blue", "blue", "green"}, {"yellow", "red", "black"}}
list = utils.UnionStringsList(lists)
utils.SortStrings(&list)
assert.Equal([]string{"black", "blue", "green", "red", "yellow"}, list)
} }

8
codego/go.sum
View File

@ -12,19 +12,25 @@ github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
@ -32,6 +38,8 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.0 h1:po9/4sTYwZU9lPhi1tOrb4hCv3qrhiQ77LZfGa2OjwY=
golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
golang.org/x/tools v0.1.1 h1:wGiQel/hW0NnEkJUk8lbzkX2gFJU6PFxf1v5OlCfuOs= golang.org/x/tools v0.1.1 h1:wGiQel/hW0NnEkJUk8lbzkX2gFJU6PFxf1v5OlCfuOs=
golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

49
codego/main.go
View File

@ -1,12 +1,12 @@
package main package main
import ( import (
"encoding/json"
"fmt" "fmt"
"logik/aussagenlogik/rekursion" "logik/aussagenlogik/rekursion"
"logik/aussagenlogik/schema" "logik/aussagenlogik/schema"
"logik/aussagenlogik/syntaxbaum" "logik/aussagenlogik/syntaxbaum"
env "logik/core/environment" env "logik/core/environment"
"logik/core/utils"
"strings" "strings"
"github.com/lithammer/dedent" "github.com/lithammer/dedent"
@ -31,10 +31,23 @@ var data dataType
func main() { func main() {
// Extrahiere Daten // Extrahiere Daten
getData() err := getData()
if err != nil {
return
}
// Ausdruck -> Syntaxbaum // Ausdruck -> Syntaxbaum
tree := schema.ParseExpr(data.expr) tree, err := schema.ParseExpr(data.expr)
results := getResults(tree) if err != nil {
return
}
// Methoden ausführen:
results := resultsType{
eval: rekursion.RekursivEval(tree, data.interpretation),
atoms: rekursion.RekursivAtoms(tree),
depth: rekursion.RekursivDepth(tree),
length: rekursion.RekursivLength(tree),
nParentheses: rekursion.RekursivParentheses(tree),
}
// Resultate anzeigen: // Resultate anzeigen:
displayResults(tree, results) displayResults(tree, results)
} }
@ -43,32 +56,12 @@ func main() {
// SONSTIGE METHODEN // SONSTIGE METHODEN
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
func getData() { func getData() error {
env.ENV_FILE_NAME = DATA_ENV env.ENV_FILE_NAME = DATA_ENV
data.expr = env.ReadEnvKey("expr") data.expr = env.ReadEnvKey("expr")
s := env.ReadEnvKey("interpretation") s := env.ReadEnvKey("interpretation")
utils.JsonToArrayOfStrings(s, &data.interpretation) err := json.Unmarshal([]byte(s), &data.interpretation)
} return err
func getResults(tree syntaxbaum.SyntaxBaum) resultsType {
ch1 := make(chan int)
ch2 := make(chan []string)
ch3 := make(chan int)
ch4 := make(chan int)
ch5 := make(chan int)
go rekursion.RekursivEval(ch1, tree, data.interpretation)
go rekursion.RekursivAtoms(ch2, tree)
go rekursion.RekursivDepth(ch3, tree)
go rekursion.RekursivLength(ch4, tree)
go rekursion.RekursivParentheses(ch5, tree)
// Methoden ausführen:
return resultsType{
eval: <-ch1,
atoms: <-ch2,
depth: <-ch3,
length: <-ch4,
nParentheses: <-ch5,
}
} }
func displayResults(tree syntaxbaum.SyntaxBaum, results resultsType) { func displayResults(tree syntaxbaum.SyntaxBaum, results resultsType) {
@ -89,7 +82,7 @@ func displayResults(tree syntaxbaum.SyntaxBaum, results resultsType) {
* noch nicht implementiert! * noch nicht implementiert!
Challenge: schreibe diese Methoden! (siehe README.md) Challenge: schreibe diese Methoden! (siehe README.md)
`), `),
tree.GetExpr(), tree.Expr,
tree.Pretty(" "), tree.Pretty(" "),
strings.Join(data.interpretation, ", "), strings.Join(data.interpretation, ", "),
results.eval, results.eval,