master > master: codego - auslagern, erzeugungsmethode verbessert, SyntaxBaum -> Formula
This commit is contained in:
parent
d490406892
commit
73b7817dcd
283
codego/aussagenlogik/formulae/formulae.go
Normal file
283
codego/aussagenlogik/formulae/formulae.go
Normal file
@ -0,0 +1,283 @@
|
||||
package formulae
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TYPE Formula
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
type Formula struct {
|
||||
kind string
|
||||
expr string
|
||||
valence int
|
||||
subformulae [](*Formula)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* METHODS
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func (fml *Formula) SetKind(kind string) {
|
||||
fml.kind = kind
|
||||
}
|
||||
|
||||
func (fml Formula) GetKind() string {
|
||||
return fml.kind
|
||||
}
|
||||
|
||||
func (fml *Formula) SetExpr(expr string) {
|
||||
fml.expr = expr
|
||||
}
|
||||
|
||||
func (fml Formula) GetExpr() string {
|
||||
return fml.expr
|
||||
}
|
||||
|
||||
func (fml *Formula) SetSubformulae(children [](*Formula)) {
|
||||
fml.subformulae = children
|
||||
fml.valence = len(children)
|
||||
}
|
||||
|
||||
func (fml Formula) GetSubFormulae() []Formula {
|
||||
var n int = fml.valence
|
||||
var children = make([]Formula, n)
|
||||
for i, subfml := range fml.subformulae {
|
||||
children[i] = *subfml
|
||||
}
|
||||
return children
|
||||
}
|
||||
|
||||
func (fml Formula) GetChild(indexOpt ...int) Formula {
|
||||
var index int = 0
|
||||
if len(indexOpt) > 0 {
|
||||
index = indexOpt[0]
|
||||
}
|
||||
var subfml Formula
|
||||
if 0 <= index && index < fml.valence {
|
||||
subfml = *(fml.subformulae[index])
|
||||
} else {
|
||||
panic(fmt.Sprintf("Instance has no child of index %d !", index))
|
||||
}
|
||||
return subfml
|
||||
}
|
||||
|
||||
func (fml Formula) Pretty(preindentOpt ...string) string {
|
||||
var preindent string = ""
|
||||
if len(preindentOpt) > 0 {
|
||||
preindent = preindentOpt[0]
|
||||
}
|
||||
return fml.pretty(preindent, " ", "", 0)
|
||||
}
|
||||
|
||||
func (fml Formula) pretty(preindent string, tab string, prepend string, depth int) string {
|
||||
var indent string = preindent + strings.Repeat(tab, depth)
|
||||
switch fml.valence {
|
||||
case 0:
|
||||
switch kind := fml.kind; kind {
|
||||
case "atom", "generic":
|
||||
return indent + prepend + kind + " " + fml.expr
|
||||
default:
|
||||
return indent + prepend + kind
|
||||
}
|
||||
default:
|
||||
var lines string = indent + prepend + fml.kind
|
||||
prepend = "|__ "
|
||||
for _, subfml := range fml.subformulae {
|
||||
lines += "\n" + subfml.pretty(preindent, tab, prepend, depth+1)
|
||||
}
|
||||
return lines
|
||||
}
|
||||
}
|
||||
|
||||
func (fml Formula) Deepcopy() Formula {
|
||||
var children = make([](*Formula), len(fml.subformulae))
|
||||
for i, child := range fml.subformulae {
|
||||
childCopy := child.Deepcopy()
|
||||
children[i] = &childCopy
|
||||
}
|
||||
return Formula{
|
||||
expr: fml.expr,
|
||||
kind: fml.kind,
|
||||
valence: fml.valence,
|
||||
subformulae: children,
|
||||
}
|
||||
}
|
||||
|
||||
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *
|
||||
* METHODS: Basic constructions
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
var Tautology = Formula{
|
||||
kind: "taut",
|
||||
expr: "1",
|
||||
valence: 0,
|
||||
subformulae: [](*Formula){},
|
||||
}
|
||||
|
||||
var Contradiction = Formula{
|
||||
kind: "contradiction",
|
||||
expr: "0",
|
||||
valence: 0,
|
||||
subformulae: [](*Formula){},
|
||||
}
|
||||
|
||||
func Atom(expr string) Formula {
|
||||
return Formula{
|
||||
kind: "atom",
|
||||
expr: expr,
|
||||
valence: 0,
|
||||
subformulae: [](*Formula){},
|
||||
}
|
||||
}
|
||||
|
||||
func NegatedAtom(expr string) Formula {
|
||||
return Negation(Atom(expr))
|
||||
}
|
||||
|
||||
func Generic(expr string) Formula {
|
||||
return Formula{
|
||||
kind: "generic",
|
||||
expr: expr,
|
||||
valence: 0,
|
||||
subformulae: [](*Formula){},
|
||||
}
|
||||
}
|
||||
|
||||
func Negation(fml Formula) Formula {
|
||||
return Formula{
|
||||
kind: "not",
|
||||
expr: "!" + " " + fml.expr,
|
||||
valence: 1,
|
||||
subformulae: [](*Formula){&fml},
|
||||
}
|
||||
}
|
||||
|
||||
func Conjunction2(fml1 Formula, fml2 Formula) Formula {
|
||||
return Formula{
|
||||
kind: "and2",
|
||||
expr: "(" + fml1.expr + " && " + fml2.expr + ")",
|
||||
valence: 2,
|
||||
subformulae: [](*Formula){&fml1, &fml2},
|
||||
}
|
||||
}
|
||||
|
||||
func Conjunction(fmls []Formula) Formula {
|
||||
var expr string = ""
|
||||
var children = make([](*Formula), len(fmls))
|
||||
for i, fml := range fmls {
|
||||
if i > 0 {
|
||||
expr += " && "
|
||||
}
|
||||
expr += fml.expr
|
||||
children[i] = &fml
|
||||
}
|
||||
return Formula{
|
||||
kind: "and",
|
||||
expr: "(" + expr + ")",
|
||||
valence: len(children),
|
||||
subformulae: children,
|
||||
}
|
||||
}
|
||||
|
||||
func Disjunction2(fml1 Formula, fml2 Formula) Formula {
|
||||
return Formula{
|
||||
kind: "or2",
|
||||
expr: "(" + fml1.expr + " || " + fml2.expr + ")",
|
||||
valence: 2,
|
||||
subformulae: [](*Formula){&fml1, &fml2},
|
||||
}
|
||||
}
|
||||
|
||||
func Disjunction(fmls []Formula) Formula {
|
||||
var expr string = ""
|
||||
var children = make([](*Formula), len(fmls))
|
||||
for i, fml := range fmls {
|
||||
if i > 0 {
|
||||
expr += " || "
|
||||
}
|
||||
expr += fml.expr
|
||||
children[i] = &fml
|
||||
}
|
||||
return Formula{
|
||||
kind: "or",
|
||||
expr: "(" + expr + ")",
|
||||
valence: len(children),
|
||||
subformulae: children,
|
||||
}
|
||||
}
|
||||
|
||||
func Implies(fml1 Formula, fml2 Formula) Formula {
|
||||
return Formula{
|
||||
kind: "implies",
|
||||
expr: "(" + fml1.expr + " -> " + fml2.expr + ")",
|
||||
valence: 2,
|
||||
subformulae: [](*Formula){&fml1, &fml2},
|
||||
}
|
||||
}
|
||||
|
||||
/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *
|
||||
* METHODS: Recognition of Formula-Types
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func (fml Formula) IsIrreducible() bool {
|
||||
return fml.valence == 0
|
||||
}
|
||||
|
||||
func (fml Formula) IsAtom() bool {
|
||||
return fml.kind == "atom"
|
||||
}
|
||||
|
||||
func (fml Formula) IsPositiveLiteral() bool {
|
||||
return fml.IsAtom()
|
||||
}
|
||||
|
||||
func (fml Formula) IsNegativeLiteral() bool {
|
||||
return fml.IsNegation() && fml.GetChild().IsAtom()
|
||||
}
|
||||
|
||||
func (fml Formula) IsLiteral() bool {
|
||||
return fml.IsPositiveLiteral() || fml.IsNegativeLiteral()
|
||||
}
|
||||
|
||||
func (fml Formula) IsGeneric() bool {
|
||||
return fml.kind == "generic"
|
||||
}
|
||||
|
||||
func (fml Formula) IsTautologySymbol() bool {
|
||||
return fml.kind == "taut"
|
||||
}
|
||||
|
||||
func (fml Formula) IsContradictionSymbol() bool {
|
||||
return fml.kind == "contradiction"
|
||||
}
|
||||
|
||||
func (fml Formula) IsConnective() bool {
|
||||
return fml.valence > 0
|
||||
}
|
||||
|
||||
func (fml Formula) IsNegation() bool {
|
||||
return fml.kind == "not"
|
||||
}
|
||||
|
||||
func (fml Formula) IsConjunction2() bool {
|
||||
return fml.kind == "and2"
|
||||
}
|
||||
|
||||
func (fml Formula) IsConjunction() bool {
|
||||
return fml.kind == "and" || fml.kind == "and2"
|
||||
}
|
||||
|
||||
func (fml Formula) IsDisjunction2() bool {
|
||||
return fml.kind == "or2"
|
||||
}
|
||||
|
||||
func (fml Formula) IsDisjunction() bool {
|
||||
return fml.kind == "or" || fml.kind == "or2"
|
||||
}
|
||||
|
||||
func (fml Formula) IsImplication() bool {
|
||||
return fml.kind == "implies"
|
||||
}
|
165
codego/aussagenlogik/formulae/formulae_generate.go
Normal file
165
codego/aussagenlogik/formulae/formulae_generate.go
Normal file
@ -0,0 +1,165 @@
|
||||
package formulae
|
||||
|
||||
// NOTE: GoLang hat noch keine generics. Erst 2022.
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* Generate int-value FN from scheme
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func CreateFromSchemeIntValued(scheme func(fml Formula, prevValues []int) int) func(fml Formula) int {
|
||||
var fn func(fml Formula) int
|
||||
var subFn = func(ch chan int, subfml Formula) { ch <- fn(subfml) }
|
||||
fn = func(fml Formula) int {
|
||||
var subfmls = fml.GetSubFormulae()
|
||||
var n = len(subfmls)
|
||||
var subChan = make([](chan int), n)
|
||||
var prevValues = make([]int, len(subfmls))
|
||||
// start parallel computations on subformulas
|
||||
for i, subfml := range subfmls {
|
||||
subChan[i] = make(chan int) // create Channel, since currently nil
|
||||
go subFn(subChan[i], subfml)
|
||||
}
|
||||
// successively read values
|
||||
for i := 0; i < n; i++ {
|
||||
prevValues[i] = <-subChan[i]
|
||||
}
|
||||
// apply schema to get value for formula
|
||||
return scheme(fml, prevValues)
|
||||
}
|
||||
return fn
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* Generate string-value FN from scheme
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func CreateFromSchemeStringValued(scheme func(fml Formula, prevValues []string) string) func(fml Formula) string {
|
||||
var fn func(fml Formula) string
|
||||
var subFn = func(ch chan string, subfml Formula) { ch <- fn(subfml) }
|
||||
fn = func(fml Formula) string {
|
||||
var subfmls = fml.GetSubFormulae()
|
||||
var n = len(subfmls)
|
||||
var subChan = make([](chan string), n)
|
||||
var prevValues = make([]string, len(subfmls))
|
||||
// start parallel computations on subformulas
|
||||
for i, subfml := range subfmls {
|
||||
subChan[i] = make(chan string) // create Channel, since currently nil
|
||||
go subFn(subChan[i], subfml)
|
||||
}
|
||||
// successively read values
|
||||
for i := 0; i < n; i++ {
|
||||
prevValues[i] = <-subChan[i]
|
||||
}
|
||||
// apply schema to get value for formula
|
||||
return scheme(fml, prevValues)
|
||||
}
|
||||
return fn
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* Generate *[]string-value Fn from scheme
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func CreateFromSchemeStringsValued(scheme func(fml Formula, prevValues [][]string) []string) func(fml Formula) []string {
|
||||
var fn func(fml Formula) []string
|
||||
var subFn = func(ch chan []string, subfml Formula) { ch <- fn(subfml) }
|
||||
fn = func(fml Formula) []string {
|
||||
var subfmls = fml.GetSubFormulae()
|
||||
var n = len(subfmls)
|
||||
var subChan = make([](chan []string), n)
|
||||
var prevValues = make([][]string, len(subfmls))
|
||||
// start parallel computations on subformulas
|
||||
for i, subfml := range subfmls {
|
||||
subChan[i] = make(chan []string) // create Channel, since currently nil
|
||||
go subFn(subChan[i], subfml)
|
||||
}
|
||||
// successively read values
|
||||
for i := 0; i < n; i++ {
|
||||
prevValues[i] = <-subChan[i]
|
||||
}
|
||||
// apply schema to get value for formula
|
||||
return scheme(fml, prevValues)
|
||||
}
|
||||
return fn
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* Generate Formula-value Fn from scheme
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func CreateFromSchemeFmlValued(scheme func(fml Formula, prevValues []Formula) Formula) func(fml Formula) Formula {
|
||||
var fn func(fml Formula) Formula
|
||||
var subFn = func(ch chan Formula, subfml Formula) { ch <- fn(subfml) }
|
||||
fn = func(fml Formula) Formula {
|
||||
var subfmls = fml.GetSubFormulae()
|
||||
var n = len(subfmls)
|
||||
var subChan = make([](chan Formula), n)
|
||||
var prevValues = make([]Formula, len(subfmls))
|
||||
// start parallel computations on subformulas
|
||||
for i, subfml := range subfmls {
|
||||
subChan[i] = make(chan Formula) // create Channel, since currently nil
|
||||
go subFn(subChan[i], subfml)
|
||||
}
|
||||
// successively read values
|
||||
for i := 0; i < n; i++ {
|
||||
prevValues[i] = <-subChan[i]
|
||||
}
|
||||
// apply schema to get value for formula
|
||||
return scheme(fml, prevValues)
|
||||
}
|
||||
return fn
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* Generate *[]Formula-value Fn from scheme
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func CreateFromSchemeFmlsValued(scheme func(fml Formula, prevValues [](*[]Formula)) *[]Formula) func(fml Formula) *[]Formula {
|
||||
var fn func(fml Formula) *[]Formula
|
||||
var subFn = func(ch chan *[]Formula, subfml Formula) { ch <- fn(subfml) }
|
||||
fn = func(fml Formula) *[]Formula {
|
||||
var subfmls = fml.GetSubFormulae()
|
||||
var n = len(subfmls)
|
||||
var subChan = make([](chan *[]Formula), n)
|
||||
var prevValues = make([](*[]Formula), len(subfmls))
|
||||
// start parallel computations on subformulas
|
||||
for i, subfml := range subfmls {
|
||||
subChan[i] = make(chan *[]Formula) // create Channel, since currently nil
|
||||
go subFn(subChan[i], subfml)
|
||||
}
|
||||
// successively read values
|
||||
for i := 0; i < n; i++ {
|
||||
prevValues[i] = <-subChan[i]
|
||||
}
|
||||
// apply schema to get value for formula
|
||||
return scheme(fml, prevValues)
|
||||
}
|
||||
return fn
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* Generate {pos: Formula, ne: Formula}-value Fn from scheme
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func CreateFromSchemeFmlPairValued(scheme func(fml Formula, prevValues []FormulaPair) FormulaPair) func(fml Formula) FormulaPair {
|
||||
var fn func(fml Formula) FormulaPair
|
||||
var subFn = func(ch chan FormulaPair, subfml Formula) { ch <- fn(subfml) }
|
||||
fn = func(fml Formula) FormulaPair {
|
||||
var subfmls = fml.GetSubFormulae()
|
||||
var n = len(subfmls)
|
||||
var subChan = make([](chan FormulaPair), n)
|
||||
var prevValues = make([]FormulaPair, len(subfmls))
|
||||
// start parallel computations on subformulas
|
||||
for i, subfml := range subfmls {
|
||||
subChan[i] = make(chan FormulaPair) // create Channel, since currently nil
|
||||
go subFn(subChan[i], subfml)
|
||||
}
|
||||
// successively read values
|
||||
for i := 0; i < n; i++ {
|
||||
prevValues[i] = <-subChan[i]
|
||||
}
|
||||
// apply schema to get value for formula
|
||||
return scheme(fml, prevValues)
|
||||
}
|
||||
return fn
|
||||
}
|
34
codego/aussagenlogik/formulae/formulae_types.go
Normal file
34
codego/aussagenlogik/formulae/formulae_types.go
Normal file
@ -0,0 +1,34 @@
|
||||
package formulae
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TYPE FormulaPair, FormulaPairs
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
type FormulaPair struct {
|
||||
Pos Formula
|
||||
Neg Formula
|
||||
}
|
||||
|
||||
type FormulaPairs []FormulaPair
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* Methods for FormulaPairs
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func NewFormulaPairs(pairs []FormulaPair) FormulaPairs { return pairs }
|
||||
|
||||
func (pairs FormulaPairs) Pos() []Formula {
|
||||
var fmls = make([]Formula, len(pairs))
|
||||
for i, pair := range pairs {
|
||||
fmls[i] = pair.Pos
|
||||
}
|
||||
return fmls
|
||||
}
|
||||
|
||||
func (pairs FormulaPairs) Neg() []Formula {
|
||||
var fmls = make([]Formula, len(pairs))
|
||||
for i, pair := range pairs {
|
||||
fmls[i] = pair.Neg
|
||||
}
|
||||
return fmls
|
||||
}
|
20
codego/aussagenlogik/recursion/recursion_atoms.go
Normal file
20
codego/aussagenlogik/recursion/recursion_atoms.go
Normal file
@ -0,0 +1,20 @@
|
||||
package recursion
|
||||
|
||||
import (
|
||||
"logik/aussagenlogik/formulae"
|
||||
)
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* METHOD: Atoms
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func Atoms(tree formulae.Formula) []string {
|
||||
// Definiere Schema:
|
||||
var schema = func(tree formulae.Formula, prevValues [][]string) []string {
|
||||
// Herausforderung: schreibe diese Funktion!
|
||||
return []string{}
|
||||
}
|
||||
// Erzeuge Funktion aus Schema und berechne Wert:
|
||||
fn := formulae.CreateFromSchemeStringsValued(schema)
|
||||
return fn(tree)
|
||||
}
|
49
codego/aussagenlogik/recursion/recursion_count.go
Normal file
49
codego/aussagenlogik/recursion/recursion_count.go
Normal file
@ -0,0 +1,49 @@
|
||||
package recursion
|
||||
|
||||
import (
|
||||
"logik/aussagenlogik/formulae"
|
||||
)
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* METHOD: Formula Depth
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func FmlDepth(tree formulae.Formula) int {
|
||||
// Definiere Schema:
|
||||
var schema = func(tree formulae.Formula, prevValues []int) int {
|
||||
// Herausforderung: schreibe diese Funktion!
|
||||
return 0
|
||||
}
|
||||
// Erzeuge Funktion aus Schema und berechne Wert:
|
||||
fn := formulae.CreateFromSchemeIntValued(schema)
|
||||
return fn(tree)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* METHOD: Formula Length
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func FmlLength(tree formulae.Formula) int {
|
||||
// Definiere Schema:
|
||||
var schema = func(tree formulae.Formula, prevValues []int) int {
|
||||
// Herausforderung: schreibe diese Funktion!
|
||||
return 0
|
||||
}
|
||||
// Erzeuge Funktion aus Schema und berechne Wert:
|
||||
fn := formulae.CreateFromSchemeIntValued(schema)
|
||||
return fn(tree)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* METHOD: Number of Parentheses
|
||||
* ---------------------------------------------------------------- */
|
||||
func NrParentheses(tree formulae.Formula) int {
|
||||
// Definiere Schema:
|
||||
var schema = func(tree formulae.Formula, prevValues []int) int {
|
||||
// Herausforderung: schreibe diese Funktion!
|
||||
return 0
|
||||
}
|
||||
// Erzeuge Funktion aus Schema und berechne Wert:
|
||||
fn := formulae.CreateFromSchemeIntValued(schema)
|
||||
return fn(tree)
|
||||
}
|
42
codego/aussagenlogik/recursion/recursion_eval.go
Normal file
42
codego/aussagenlogik/recursion/recursion_eval.go
Normal file
@ -0,0 +1,42 @@
|
||||
package recursion
|
||||
|
||||
import (
|
||||
"logik/aussagenlogik/formulae"
|
||||
"logik/core/utils"
|
||||
)
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* METHOD: Evaluation of fomulae in models
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func Eval(tree formulae.Formula, I []string) int {
|
||||
// Definiere (parameterisiertes) Schema:
|
||||
var schema = func(_I []string) func(formulae.Formula, []int) int {
|
||||
return func(tree formulae.Formula, prevValues []int) int {
|
||||
if tree.IsAtom() || tree.IsGeneric() {
|
||||
return utils.BoolToInt(utils.StrListContains(_I, tree.GetExpr()))
|
||||
} else if tree.IsTautologySymbol() {
|
||||
return 1
|
||||
} else if tree.IsContradictionSymbol() {
|
||||
return 0
|
||||
} else if tree.IsNegation() {
|
||||
return 1 - prevValues[0]
|
||||
} else if tree.IsConjunction2() {
|
||||
return utils.Min2(prevValues[0], prevValues[1])
|
||||
} else if tree.IsConjunction() {
|
||||
return utils.MinList(prevValues)
|
||||
} else if tree.IsDisjunction2() {
|
||||
return utils.Max2(prevValues[0], prevValues[1])
|
||||
} else if tree.IsDisjunction() {
|
||||
return utils.MaxList(prevValues)
|
||||
} else if tree.IsImplication() {
|
||||
return utils.BoolToInt(prevValues[0] <= prevValues[1])
|
||||
} else {
|
||||
panic("Could not evaluate expression!")
|
||||
}
|
||||
}
|
||||
}
|
||||
// Erzeuge Funktion aus Schema und berechne Wert:
|
||||
fn := formulae.CreateFromSchemeIntValued(schema(I))
|
||||
return fn(tree)
|
||||
}
|
77
codego/aussagenlogik/recursion/recursion_nnf.go
Normal file
77
codego/aussagenlogik/recursion/recursion_nnf.go
Normal file
@ -0,0 +1,77 @@
|
||||
package recursion
|
||||
|
||||
import (
|
||||
"logik/aussagenlogik/formulae"
|
||||
)
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* METHOD: compute NNF
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
// NOTE: diese bedarf einer Art Doppeltrekursion
|
||||
func NNF(tree formulae.Formula) formulae.Formula {
|
||||
// Definiere Schema:
|
||||
var schema = func(tree formulae.Formula, prevValues []formulae.FormulaPair) formulae.FormulaPair {
|
||||
// separate out positive and negative parts:
|
||||
var pairs = formulae.NewFormulaPairs(prevValues)
|
||||
var prevPos = pairs.Pos()
|
||||
var prevNeg = pairs.Neg()
|
||||
// compute value from previous positive/negative parts:
|
||||
if tree.IsPositiveLiteral() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: tree.Deepcopy(),
|
||||
Neg: formulae.Negation(tree),
|
||||
}
|
||||
} else if tree.IsNegativeLiteral() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: tree.Deepcopy(),
|
||||
Neg: prevPos[0],
|
||||
}
|
||||
} else if tree.IsTautologySymbol() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: formulae.Tautology,
|
||||
Neg: formulae.Contradiction,
|
||||
}
|
||||
} else if tree.IsContradictionSymbol() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: formulae.Contradiction,
|
||||
Neg: formulae.Tautology,
|
||||
}
|
||||
} else if tree.IsNegation() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: prevNeg[0],
|
||||
Neg: prevPos[0],
|
||||
}
|
||||
} else if tree.IsConjunction2() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: formulae.Conjunction2(prevPos[0], prevPos[1]),
|
||||
Neg: formulae.Disjunction2(prevNeg[0], prevNeg[1]),
|
||||
}
|
||||
} else if tree.IsConjunction() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: formulae.Conjunction(prevPos),
|
||||
Neg: formulae.Disjunction(prevNeg),
|
||||
}
|
||||
} else if tree.IsDisjunction2() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: formulae.Disjunction2(prevPos[0], prevPos[1]),
|
||||
Neg: formulae.Conjunction2(prevNeg[0], prevNeg[1]),
|
||||
}
|
||||
} else if tree.IsDisjunction() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: formulae.Disjunction(prevPos),
|
||||
Neg: formulae.Conjunction(prevNeg),
|
||||
}
|
||||
} else if tree.IsImplication() {
|
||||
return formulae.FormulaPair{
|
||||
Pos: formulae.Implies(prevPos[0], prevPos[1]),
|
||||
Neg: formulae.Conjunction2(prevPos[0], prevNeg[1]),
|
||||
}
|
||||
} else {
|
||||
panic("Could not evaluate expression!")
|
||||
}
|
||||
}
|
||||
// Erzeuge Funktion aus Schema und berechne Wert:
|
||||
fn := formulae.CreateFromSchemeFmlPairValued(schema)
|
||||
return fn(tree).Pos
|
||||
}
|
359
codego/aussagenlogik/recursion/recursion_test.go
Normal file
359
codego/aussagenlogik/recursion/recursion_test.go
Normal file
@ -0,0 +1,359 @@
|
||||
package recursion_test
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* UNIT TESTING
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
import (
|
||||
"logik/aussagenlogik/formulae"
|
||||
"logik/aussagenlogik/recursion"
|
||||
"logik/aussagenlogik/schema"
|
||||
"logik/core/utils"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE eval(·, ·)
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestEvalLiteral(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
var I []string
|
||||
fml = schema.ParseExpr("A0")
|
||||
I = []string{"A0"}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(1, val)
|
||||
fml = schema.ParseExpr("A0")
|
||||
I = []string{}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(0, val)
|
||||
fml = schema.ParseExpr("! A0")
|
||||
I = []string{"A0"}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(0, val)
|
||||
fml = schema.ParseExpr("! A0")
|
||||
I = []string{}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(1, val)
|
||||
}
|
||||
|
||||
func TestEvalComplex1(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
var I []string
|
||||
fml = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || A2 ))")
|
||||
I = []string{"A0", "A2"}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(1, val)
|
||||
I = []string{"A0", "A3"}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(1, val)
|
||||
I = []string{"A0"}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(0, val)
|
||||
I = []string{"A4", "A8"}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(1, val)
|
||||
}
|
||||
|
||||
func TestEvalComplex2(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
var I []string
|
||||
fml = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || ! A2 ))")
|
||||
I = []string{"A0", "A2"}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(0, val)
|
||||
I = []string{"A0", "A3"}
|
||||
val = recursion.Eval(fml, I)
|
||||
assert.Equal(1, val)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE Atoms(·)
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestAtomsNoduplicates(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var fml formulae.Formula
|
||||
var val []string
|
||||
fml = schema.ParseExpr("( A4 && ( A4 || A4 ))")
|
||||
val = recursion.Atoms(fml)
|
||||
var n int = len(utils.FilterStrings(&val, func(x string) bool { return x == "A4" }))
|
||||
assert.Equal(1, n, "Atome dürfen nicht mehrfach vorkommen!")
|
||||
}
|
||||
|
||||
func TestAtomsNononatoms(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 fml formulae.Formula
|
||||
var val []string
|
||||
fml = schema.ParseExpr("( {F} || A3 )")
|
||||
val = recursion.Atoms(fml)
|
||||
utils.SortStrings(&val)
|
||||
assert.NotContains(val, "F", "Nichtatomare Formeln dürfen nicht vorkommen!")
|
||||
}
|
||||
|
||||
func TestAtomsCalc1(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var fml formulae.Formula
|
||||
var val []string
|
||||
fml = schema.ParseExpr("A0")
|
||||
val = recursion.Atoms(fml)
|
||||
utils.SortStrings(&val)
|
||||
assert.Equal([]string{"A0"}, val)
|
||||
}
|
||||
|
||||
func TestAtomsCalc2(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var fml formulae.Formula
|
||||
var val []string
|
||||
fml = schema.ParseExpr("((( ! A8 && A3 ) || A4 ) && A0 )")
|
||||
val = recursion.Atoms(fml)
|
||||
utils.SortStrings(&val)
|
||||
assert.Equal([]string{"A0", "A3", "A4", "A8"}, val)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE depth(·, ·)
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestDepthCalc1(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("A0")
|
||||
val = recursion.FmlDepth(fml)
|
||||
assert.Equal(0, val)
|
||||
}
|
||||
|
||||
func TestDepthCalc2(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("!! A8")
|
||||
val = recursion.FmlDepth(fml)
|
||||
assert.Equal(2, val)
|
||||
}
|
||||
|
||||
func TestDepthCalc3(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("( ! A0 && A3 )")
|
||||
val = recursion.FmlDepth(fml)
|
||||
assert.Equal(2, val)
|
||||
}
|
||||
|
||||
func TestDepthCalc4(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
val = recursion.FmlDepth(fml)
|
||||
assert.Equal(4, val)
|
||||
}
|
||||
|
||||
func TestDepthCalc5(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
val = recursion.FmlDepth(fml)
|
||||
assert.Equal(5, val)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE length(·)
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestLengthCalc1(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("A0")
|
||||
val = recursion.FmlLength(fml)
|
||||
assert.Equal(1, val)
|
||||
}
|
||||
|
||||
func TestLengthCalc2(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("!! A8")
|
||||
val = recursion.FmlLength(fml)
|
||||
assert.Equal(3, val)
|
||||
}
|
||||
|
||||
func TestLengthCalc3(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("( ! A0 && A3 )")
|
||||
val = recursion.FmlLength(fml)
|
||||
assert.Equal(4, val)
|
||||
}
|
||||
|
||||
func TestLengthCalc4(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
val = recursion.FmlLength(fml)
|
||||
assert.Equal(8, val)
|
||||
}
|
||||
|
||||
func TestLengthCalc5(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
val = recursion.FmlLength(fml)
|
||||
assert.Equal(9, val)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE #Parentheses(·)
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestParenthesesCalc1(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("A0")
|
||||
val = recursion.NrParentheses(fml)
|
||||
assert.Equal(0, val)
|
||||
}
|
||||
|
||||
func TestParenthesesCalc2(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("!! A8")
|
||||
val = recursion.NrParentheses(fml)
|
||||
assert.Equal(0, val)
|
||||
}
|
||||
|
||||
func TestParenthesesCalc3(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("( ! A0 && A3 )")
|
||||
val = recursion.NrParentheses(fml)
|
||||
assert.Equal(2, val)
|
||||
}
|
||||
|
||||
func TestParenthesesCalc4(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
val = recursion.NrParentheses(fml)
|
||||
assert.Equal(6, val)
|
||||
}
|
||||
|
||||
func TestParenthesesCalc5(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var val int
|
||||
var fml formulae.Formula
|
||||
fml = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
val = recursion.NrParentheses(fml)
|
||||
assert.Equal(6, val)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE NNF
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestNNFatoms(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var fml formulae.Formula
|
||||
var nnf_expected formulae.Formula
|
||||
|
||||
nnf_expected = formulae.Atom("A7")
|
||||
fml = schema.ParseExpr("A7")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
fml = schema.ParseExpr("!! A7")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
|
||||
nnf_expected = formulae.NegatedAtom("A7")
|
||||
fml = schema.ParseExpr("! A7")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
fml = schema.ParseExpr("!!! A7")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
}
|
||||
|
||||
func TestNNFconj(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var fml formulae.Formula
|
||||
var nnf_expected formulae.Formula
|
||||
|
||||
nnf_expected = formulae.Disjunction2(formulae.NegatedAtom("A0"), formulae.NegatedAtom("A1"))
|
||||
fml = schema.ParseExpr("! (A0 && A1)")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
|
||||
nnf_expected = formulae.Disjunction2(formulae.Atom("A0"), formulae.Atom("A1"))
|
||||
fml = schema.ParseExpr("! (! A0 && ! A1)")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
|
||||
nnf_expected = formulae.Conjunction2(formulae.Atom("A0"), formulae.NegatedAtom("A1"))
|
||||
fml = schema.ParseExpr("(A0 && ! A1)")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
}
|
||||
|
||||
func TestNNFdisj(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var fml formulae.Formula
|
||||
var nnf_expected formulae.Formula
|
||||
|
||||
nnf_expected = formulae.Conjunction2(formulae.NegatedAtom("A0"), formulae.NegatedAtom("A1"))
|
||||
fml = schema.ParseExpr("! (A0 || A1)")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
|
||||
nnf_expected = formulae.Conjunction2(formulae.Atom("A0"), formulae.Atom("A1"))
|
||||
fml = schema.ParseExpr("! (! A0 || ! A1)")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
|
||||
nnf_expected = formulae.Disjunction2(formulae.Atom("A0"), formulae.NegatedAtom("A1"))
|
||||
fml = schema.ParseExpr("(A0 || ! A1)")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
}
|
||||
|
||||
func TestNNFcalcComplex(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var fml formulae.Formula
|
||||
var nnf_expected formulae.Formula
|
||||
|
||||
fml = schema.ParseExpr("! (! (!A0 || A1) || ! ! A8)")
|
||||
nnf_expected = schema.ParseExpr("((!A0 || A1) && ! A8)")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
|
||||
fml = schema.ParseExpr("! (! (!A0 || !(A1 && ! A7)) && ! A8)")
|
||||
nnf_expected = schema.ParseExpr("((!A0 || (! A1 || A7)) || A8)")
|
||||
assert.Equal(nnf_expected.GetExpr(), recursion.NNF(fml).GetExpr())
|
||||
}
|
@ -1,70 +0,0 @@
|
||||
package rekursion
|
||||
|
||||
import (
|
||||
"logik/aussagenlogik/syntaxbaum"
|
||||
"logik/core/utils"
|
||||
)
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* EXPORTS
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
type RekursiveChannelInt struct {
|
||||
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() {
|
||||
ch <- utils.BoolToInt(utils.StrListContains(I, tree.GetExpr()))
|
||||
} else if tree.IsTautologySymbol() {
|
||||
ch <- 1
|
||||
} else if tree.IsContradictionSymbol() {
|
||||
ch <- 0
|
||||
} else if tree.IsNegation() {
|
||||
ch <- 1 - values[0]
|
||||
} else if tree.IsConjunction2() {
|
||||
ch <- utils.Min2(values[0], values[1])
|
||||
} else if tree.IsConjunction() {
|
||||
ch <- utils.MinList(values)
|
||||
} else if tree.IsDisjunction2() {
|
||||
ch <- utils.Max2(values[0], values[1])
|
||||
} else if tree.IsDisjunction() {
|
||||
ch <- utils.MaxList(values)
|
||||
} else if tree.IsImplication() {
|
||||
ch <- utils.BoolToInt(values[0] <= values[1])
|
||||
} else {
|
||||
panic("Could not evaluate expression!")
|
||||
}
|
||||
}
|
||||
|
||||
func RekursivAtoms(ch chan []string, tree syntaxbaum.SyntaxBaum) {
|
||||
// // Werte für Teilformeln rekursiv berechnen
|
||||
// var values = RekursiveCallStringList(RekursivAtoms, tree.GetChildren())
|
||||
// Herausforderung: schreibe diese Funktion!
|
||||
ch <- []string{}
|
||||
}
|
||||
|
||||
func RekursivDepth(ch chan int, tree syntaxbaum.SyntaxBaum) {
|
||||
// // Werte für Teilformeln rekursiv berechnen
|
||||
// var values = RekursiveCallInt(RekursivDepth, tree.GetChildren())
|
||||
// Herausforderung: schreibe diese Funktion!
|
||||
ch <- 0
|
||||
}
|
||||
|
||||
func RekursivLength(ch chan int, tree syntaxbaum.SyntaxBaum) {
|
||||
// // Werte für Teilformeln rekursiv berechnen
|
||||
// var values = RekursiveCallInt(RekursivLength, tree.GetChildren())
|
||||
// Herausforderung: schreibe diese Funktion!
|
||||
ch <- 0
|
||||
}
|
||||
|
||||
func RekursivParentheses(ch chan int, tree syntaxbaum.SyntaxBaum) {
|
||||
// // Werte für Teilformeln rekursiv berechnen
|
||||
// var values = RekursiveCallInt(RekursivParentheses, tree.GetChildren())
|
||||
// Herausforderung: schreibe diese Funktion!
|
||||
ch <- 0
|
||||
}
|
@ -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
|
||||
}
|
@ -1,295 +0,0 @@
|
||||
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 ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
var I []string
|
||||
tree = schema.ParseExpr("A0")
|
||||
I = []string{"A0"}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(1, <-ch)
|
||||
tree = schema.ParseExpr("A0")
|
||||
I = []string{}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(0, <-ch)
|
||||
tree = schema.ParseExpr("! A0")
|
||||
I = []string{"A0"}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(0, <-ch)
|
||||
tree = schema.ParseExpr("! A0")
|
||||
I = []string{}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(1, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivEvalComplex1(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
var I []string
|
||||
tree = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || A2 ))")
|
||||
I = []string{"A0", "A2"}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(1, <-ch)
|
||||
I = []string{"A0", "A3"}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(1, <-ch)
|
||||
I = []string{"A0"}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(0, <-ch)
|
||||
I = []string{"A4", "A8"}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(1, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivEvalComplex2(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
var I []string
|
||||
tree = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || ! A2 ))")
|
||||
I = []string{"A0", "A2"}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(0, <-ch)
|
||||
I = []string{"A0", "A3"}
|
||||
go rekursion.RekursivEval(ch, tree, I)
|
||||
assert.Equal(1, <-ch)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE Atoms(·)
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestRekursivAtomsNoduplicates(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan []string)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
var val []string
|
||||
tree = schema.ParseExpr("( A4 && ( A4 || A4 ))")
|
||||
go rekursion.RekursivAtoms(ch, tree)
|
||||
val = <-ch
|
||||
var n int = len(utils.FilterStrings(&val, func(x string) bool { return x == "A4" }))
|
||||
assert.Equal(1, n, "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 ch = make(chan []string)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
var val []string
|
||||
tree = schema.ParseExpr("( {F} || A3 )")
|
||||
go rekursion.RekursivAtoms(ch, tree)
|
||||
val = <-ch
|
||||
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 ch = make(chan []string)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
var val []string
|
||||
tree = schema.ParseExpr("A0")
|
||||
go rekursion.RekursivAtoms(ch, tree)
|
||||
val = <-ch
|
||||
utils.SortStrings(&val)
|
||||
assert.Equal([]string{"A0"}, val)
|
||||
}
|
||||
|
||||
func TestRekursivAtomsCalc2(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan []string)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
var val []string
|
||||
tree = schema.ParseExpr("((( ! A8 && A3 ) || A4 ) && A0 )")
|
||||
go rekursion.RekursivAtoms(ch, tree)
|
||||
val = <-ch
|
||||
utils.SortStrings(&val)
|
||||
assert.Equal([]string{"A0", "A3", "A4", "A8"}, val)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE depth(·, ·)
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestRekursivDepthCalc1(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("A0")
|
||||
go rekursion.RekursivDepth(ch, tree)
|
||||
assert.Equal(0, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivDepthCalc2(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("!! A8")
|
||||
go rekursion.RekursivDepth(ch, tree)
|
||||
assert.Equal(2, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivDepthCalc3(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("( ! A0 && A3 )")
|
||||
go rekursion.RekursivDepth(ch, tree)
|
||||
assert.Equal(2, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivDepthCalc4(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
go rekursion.RekursivDepth(ch, tree)
|
||||
assert.Equal(4, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivDepthCalc5(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
go rekursion.RekursivDepth(ch, tree)
|
||||
assert.Equal(5, <-ch)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE length(·)
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestRekursivLengthCalc1(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("A0")
|
||||
go rekursion.RekursivLength(ch, tree)
|
||||
assert.Equal(1, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivLengthCalc2(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("!! A8")
|
||||
go rekursion.RekursivLength(ch, tree)
|
||||
assert.Equal(3, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivLengthCalc3(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("( ! A0 && A3 )")
|
||||
go rekursion.RekursivLength(ch, tree)
|
||||
assert.Equal(4, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivLengthCalc4(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
go rekursion.RekursivLength(ch, tree)
|
||||
assert.Equal(8, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivLengthCalc5(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
go rekursion.RekursivLength(ch, tree)
|
||||
assert.Equal(9, <-ch)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE #Parentheses(·)
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestRekursivParenthesesCalc1(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("A0")
|
||||
go rekursion.RekursivParentheses(ch, tree)
|
||||
assert.Equal(0, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivParenthesesCalc2(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("!! A8")
|
||||
go rekursion.RekursivParentheses(ch, tree)
|
||||
assert.Equal(0, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivParenthesesCalc3(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("( ! A0 && A3 )")
|
||||
go rekursion.RekursivParentheses(ch, tree)
|
||||
assert.Equal(2, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivParenthesesCalc4(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
go rekursion.RekursivParentheses(ch, tree)
|
||||
assert.Equal(6, <-ch)
|
||||
}
|
||||
|
||||
func TestRekursivParenthesesCalc5(test *testing.T) {
|
||||
test.Skip("Methode noch nicht implementiert")
|
||||
var assert = assert.New(test)
|
||||
var ch = make(chan int)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )")
|
||||
go rekursion.RekursivParentheses(ch, tree)
|
||||
assert.Equal(6, <-ch)
|
||||
}
|
@ -1,9 +1,8 @@
|
||||
package schema
|
||||
|
||||
import (
|
||||
"logik/aussagenlogik/syntaxbaum"
|
||||
"logik/aussagenlogik/formulae"
|
||||
parser "logik/grammars/aussagenlogik"
|
||||
"strings"
|
||||
|
||||
"github.com/antlr/antlr4/runtime/Go/antlr"
|
||||
)
|
||||
@ -12,12 +11,12 @@ import (
|
||||
* EXPORTS
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func ParseExpr(u string) syntaxbaum.SyntaxBaum {
|
||||
func ParseExpr(u string) formulae.Formula {
|
||||
var lexer = createLexer(u)
|
||||
var tokenStream = lexerToTokenStream(lexer)
|
||||
var prs = parser.NewaussagenlogikParser(tokenStream)
|
||||
var t = prs.Start()
|
||||
tree := createSyntaxBaum(t, prs)
|
||||
tree := createFormula(t, prs)
|
||||
return tree
|
||||
}
|
||||
|
||||
@ -38,9 +37,9 @@ func createLexer(u string) antlr.Lexer {
|
||||
return parser.NewaussagenlogikLexer(stream)
|
||||
}
|
||||
|
||||
func createSyntaxBaum(tree antlr.Tree, parser antlr.Parser) syntaxbaum.SyntaxBaum {
|
||||
func createFormula(tree antlr.Tree, parser antlr.Parser) formulae.Formula {
|
||||
var ant = antlrTree{tree: tree, parser: &parser}
|
||||
return ant.toSyntaxBaum()
|
||||
return ant.toFormula()
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
@ -86,8 +85,7 @@ func (ant antlrTree) getTextContentLeaves() string {
|
||||
return expr
|
||||
}
|
||||
|
||||
func (ant antlrTree) toSyntaxBaum() syntaxbaum.SyntaxBaum {
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
func (ant antlrTree) toFormula() formulae.Formula {
|
||||
var label string = ant.getLabel()
|
||||
var subants = ant.getChildren()
|
||||
var nChildren = len(subants)
|
||||
@ -95,65 +93,73 @@ func (ant antlrTree) toSyntaxBaum() syntaxbaum.SyntaxBaum {
|
||||
switch label {
|
||||
case "start":
|
||||
if nChildren == 1 {
|
||||
return subants[0].toSyntaxBaum()
|
||||
return subants[0].toFormula()
|
||||
}
|
||||
case "open":
|
||||
if nChildren == 1 {
|
||||
return subants[0].toSyntaxBaum()
|
||||
return subants[0].toFormula()
|
||||
}
|
||||
case "closed":
|
||||
switch nChildren {
|
||||
case 1:
|
||||
return subants[0].toSyntaxBaum()
|
||||
return subants[0].toFormula()
|
||||
// expr = ( expr )
|
||||
case 3:
|
||||
return subants[1].toSyntaxBaum()
|
||||
return subants[1].toFormula()
|
||||
}
|
||||
case "atomic":
|
||||
if nChildren == 1 {
|
||||
subant := subants[0]
|
||||
tree = syntaxbaum.SyntaxBaum{}
|
||||
tree.SetKind(subant.getLabel())
|
||||
tree.SetExpr(subant.getTextContentLeaves())
|
||||
tree.SetChildren([](*syntaxbaum.SyntaxBaum){})
|
||||
return tree
|
||||
return subants[0].toFormula()
|
||||
}
|
||||
case "taut":
|
||||
return formulae.Tautology
|
||||
case "contradiction":
|
||||
return formulae.Contradiction
|
||||
case "atom":
|
||||
return formulae.Atom(ant.getTextContentLeaves())
|
||||
case "generic":
|
||||
return formulae.Generic(ant.getTextContentLeaves())
|
||||
case "not":
|
||||
// NOTE: expr = ! expr
|
||||
if nChildren == 2 {
|
||||
// NOTE: Children = [NotSymbol, Teilformel]
|
||||
subtree := subants[1].toSyntaxBaum()
|
||||
tree = syntaxbaum.SyntaxBaum{}
|
||||
tree.SetKind(label)
|
||||
tree.SetExpr(subants[0].getTextContent() + " " + subtree.GetExpr())
|
||||
tree.SetChildren([](*syntaxbaum.SyntaxBaum){&subtree})
|
||||
return tree
|
||||
return formulae.Negation(subants[1].toFormula())
|
||||
}
|
||||
case "and2", "and", "or2", "or", "implies":
|
||||
case "and2":
|
||||
// NOTE: expr = expr && expr
|
||||
if nChildren == 3 {
|
||||
return formulae.Conjunction2(subants[0].toFormula(), subants[2].toFormula())
|
||||
}
|
||||
case "or2":
|
||||
// NOTE: expr = expr || expr
|
||||
if nChildren == 3 {
|
||||
return formulae.Disjunction2(subants[0].toFormula(), subants[2].toFormula())
|
||||
}
|
||||
case "implies":
|
||||
// NOTE: expr = expr -> expr
|
||||
if nChildren == 3 {
|
||||
return formulae.Implies(subants[0].toFormula(), subants[2].toFormula())
|
||||
}
|
||||
case "and", "or":
|
||||
// NOTE: expr = expr op expr op ... op expr
|
||||
var n int = int((len(subants) + 1) / 2)
|
||||
if nChildren == 2*n-1 && n >= 2 {
|
||||
var isSymb bool = false
|
||||
var subtrees = make([](*syntaxbaum.SyntaxBaum), n)
|
||||
var subtrees = make([]formulae.Formula, n)
|
||||
var isSymb bool = true
|
||||
var i int = 0
|
||||
var expr string = ""
|
||||
for _, subant := range subants {
|
||||
if isSymb {
|
||||
expr += " " + subant.getTextContent()
|
||||
} else {
|
||||
subtree := subant.toSyntaxBaum()
|
||||
subtrees[i] = &subtree
|
||||
expr += " " + subtree.GetExpr()
|
||||
subtrees[i] = subant.toFormula()
|
||||
i++
|
||||
}
|
||||
// NOTE: infix notation: alternatives between expression and symbol
|
||||
isSymb = !isSymb
|
||||
}
|
||||
expr = strings.Trim(expr, " ")
|
||||
var lbrace string = "("
|
||||
var rbrace string = ")"
|
||||
tree = syntaxbaum.SyntaxBaum{}
|
||||
tree.SetKind(label)
|
||||
tree.SetExpr(lbrace + expr + rbrace)
|
||||
tree.SetChildren(subtrees)
|
||||
return tree
|
||||
switch label {
|
||||
case "and":
|
||||
return formulae.Conjunction(subtrees)
|
||||
case "or":
|
||||
return formulae.Disjunction(subtrees)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -5,8 +5,8 @@ package schema_test
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
import (
|
||||
"logik/aussagenlogik/formulae"
|
||||
"logik/aussagenlogik/schema"
|
||||
"logik/aussagenlogik/syntaxbaum"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
@ -18,25 +18,25 @@ import (
|
||||
|
||||
func TestParseExpr(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var tree syntaxbaum.SyntaxBaum
|
||||
var tree formulae.Formula
|
||||
|
||||
tree = schema.ParseExpr("A8712")
|
||||
assert.Equal("A8712", tree.GetExpr())
|
||||
assert.Equal("atom", tree.GetKind())
|
||||
assert.Equal(0, len(tree.GetChildren()))
|
||||
assert.Equal(0, len(tree.GetSubFormulae()))
|
||||
|
||||
tree = schema.ParseExpr(" ! A5 ")
|
||||
assert.Equal("! A5", tree.GetExpr())
|
||||
assert.Equal("not", tree.GetKind())
|
||||
assert.Equal(1, len(tree.GetChildren()))
|
||||
assert.Equal(1, len(tree.GetSubFormulae()))
|
||||
|
||||
tree = schema.ParseExpr("A0 -> A1")
|
||||
assert.Equal("(A0 -> A1)", tree.GetExpr())
|
||||
assert.Equal("implies", tree.GetKind())
|
||||
assert.Equal(2, len(tree.GetChildren()))
|
||||
assert.Equal(2, len(tree.GetSubFormulae()))
|
||||
|
||||
tree = schema.ParseExpr("( A0 && A1) || A2")
|
||||
assert.Equal("((A0 && A1) || A2)", tree.GetExpr())
|
||||
assert.Equal("or2", tree.GetKind())
|
||||
assert.Equal(2, len(tree.GetChildren()))
|
||||
assert.Equal(2, len(tree.GetSubFormulae()))
|
||||
}
|
||||
|
@ -1,154 +0,0 @@
|
||||
package syntaxbaum
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type SyntaxBaum struct {
|
||||
kind string
|
||||
expr string
|
||||
valence int
|
||||
children [](*SyntaxBaum)
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* 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 {
|
||||
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) IsIrreducible() bool {
|
||||
return tree.valence == 0
|
||||
}
|
||||
|
||||
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) IsGeneric() bool {
|
||||
return tree.kind == "generic"
|
||||
}
|
||||
|
||||
func (tree SyntaxBaum) IsTautologySymbol() bool {
|
||||
return tree.kind == "taut"
|
||||
}
|
||||
|
||||
func (tree SyntaxBaum) IsContradictionSymbol() bool {
|
||||
return tree.kind == "contradiction"
|
||||
}
|
||||
|
||||
func (tree SyntaxBaum) IsConnective() bool {
|
||||
return tree.valence > 0
|
||||
}
|
||||
|
||||
func (tree SyntaxBaum) IsNegation() bool {
|
||||
return tree.kind == "not"
|
||||
}
|
||||
|
||||
func (tree SyntaxBaum) IsConjunction2() bool {
|
||||
return tree.kind == "and2"
|
||||
}
|
||||
|
||||
func (tree SyntaxBaum) IsConjunction() bool {
|
||||
return tree.kind == "and" || tree.kind == "and2"
|
||||
}
|
||||
|
||||
func (tree SyntaxBaum) IsDisjunction2() bool {
|
||||
return tree.kind == "or2"
|
||||
}
|
||||
|
||||
func (tree SyntaxBaum) IsDisjunction() bool {
|
||||
return tree.kind == "or" || tree.kind == "or2"
|
||||
}
|
||||
|
||||
func (tree SyntaxBaum) IsImplication() bool {
|
||||
return tree.kind == "implies"
|
||||
}
|
@ -131,7 +131,7 @@ func UnionStrings2(list1 []string, list2 []string) []string {
|
||||
}
|
||||
|
||||
// assumes that listTo contains no duplicates
|
||||
func UnionStringsTo(listTo *[]string, listFrom []string) {
|
||||
func UnionStringsInPlace(listTo *[]string, listFrom []string) {
|
||||
var mark = make(map[string]bool)
|
||||
for _, item := range listFrom {
|
||||
mark[item] = true
|
||||
@ -149,7 +149,7 @@ func UnionStringsTo(listTo *[]string, listFrom []string) {
|
||||
func UnionStringsList(lists [][]string) []string {
|
||||
var list = []string{}
|
||||
for _, list_ := range lists {
|
||||
UnionStringsTo(&list, list_)
|
||||
UnionStringsInPlace(&list, list_)
|
||||
}
|
||||
return list
|
||||
}
|
||||
|
@ -89,7 +89,7 @@ func TestFilterStrings(test *testing.T) {
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- *
|
||||
* TESTCASE UnionStrings2, UnionStringsTo, UnionStringsList
|
||||
* TESTCASE UnionStrings2, UnionStringsInPlace, UnionStringsList
|
||||
* ---------------------------------------------------------------- */
|
||||
|
||||
func TestUnionStrings2(test *testing.T) {
|
||||
@ -101,11 +101,11 @@ func TestUnionStrings2(test *testing.T) {
|
||||
assert.Equal([]string{"black", "blue", "green", "grey", "lila", "orange", "red", "yellow"}, list)
|
||||
}
|
||||
|
||||
func TestUnionStringsTo(test *testing.T) {
|
||||
func TestUnionStringsInPlace(test *testing.T) {
|
||||
var assert = assert.New(test)
|
||||
var list1 = []string{"red", "blue", "green"}
|
||||
var list2 = []string{"yellow", "red", "blue", "red", "black"}
|
||||
utils.UnionStringsTo(&list1, list2)
|
||||
utils.UnionStringsInPlace(&list1, list2)
|
||||
utils.SortStrings(&list1)
|
||||
assert.Equal([]string{"black", "blue", "green", "red", "yellow"}, list1)
|
||||
}
|
||||
|
@ -2,9 +2,9 @@ package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"logik/aussagenlogik/rekursion"
|
||||
"logik/aussagenlogik/formulae"
|
||||
"logik/aussagenlogik/recursion"
|
||||
"logik/aussagenlogik/schema"
|
||||
"logik/aussagenlogik/syntaxbaum"
|
||||
env "logik/core/environment"
|
||||
"logik/core/utils"
|
||||
"strings"
|
||||
@ -21,6 +21,7 @@ type dataType struct {
|
||||
|
||||
type resultsType struct {
|
||||
eval int
|
||||
nnf formulae.Formula
|
||||
atoms []string
|
||||
depth int
|
||||
length int
|
||||
@ -50,28 +51,18 @@ func getData() {
|
||||
utils.JsonToArrayOfStrings(s, &data.interpretation)
|
||||
}
|
||||
|
||||
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:
|
||||
func getResults(tree formulae.Formula) resultsType {
|
||||
return resultsType{
|
||||
eval: <-ch1,
|
||||
atoms: <-ch2,
|
||||
depth: <-ch3,
|
||||
length: <-ch4,
|
||||
nParentheses: <-ch5,
|
||||
eval: recursion.Eval(tree, data.interpretation),
|
||||
nnf: recursion.NNF(tree),
|
||||
atoms: recursion.Atoms(tree),
|
||||
depth: recursion.FmlDepth(tree),
|
||||
length: recursion.FmlLength(tree),
|
||||
nParentheses: recursion.NrParentheses(tree),
|
||||
}
|
||||
}
|
||||
|
||||
func displayResults(tree syntaxbaum.SyntaxBaum, results resultsType) {
|
||||
func displayResults(tree formulae.Formula, results resultsType) {
|
||||
fmt.Println(fmt.Sprintf(
|
||||
dedent.Dedent(`
|
||||
Syntaxbaum von
|
||||
@ -81,10 +72,11 @@ func displayResults(tree syntaxbaum.SyntaxBaum, results resultsType) {
|
||||
|
||||
Für I = {%[3]s} und F wie oben gilt
|
||||
eval(F, I) = %[4]d;
|
||||
atoms(F) = {%[5]s}; <- *
|
||||
depth(F) = %[6]d; <- *
|
||||
length(F) = %[7]d; <- *
|
||||
#parentheses(F) = %[8]d; <- *
|
||||
F^NNF = %[5]s;
|
||||
atoms(F) = {%[6]s}; <- *
|
||||
depth(F) = %[7]d; <- *
|
||||
length(F) = %[8]d; <- *
|
||||
#parentheses(F) = %[9]d; <- *
|
||||
|
||||
* noch nicht implementiert!
|
||||
Challenge: schreibe diese Methoden! (siehe README.md)
|
||||
@ -93,6 +85,7 @@ func displayResults(tree syntaxbaum.SyntaxBaum, results resultsType) {
|
||||
tree.Pretty(" "),
|
||||
strings.Join(data.interpretation, ", "),
|
||||
results.eval,
|
||||
results.nnf.GetExpr(),
|
||||
// string(results.atoms),
|
||||
strings.Join(results.atoms, ", "),
|
||||
results.depth,
|
||||
|
Loading…
x
Reference in New Issue
Block a user