---
# System prepended metadata

title: Blatt 9

---

# Blatt 9
Lukas Bruns 
Robin Faeseke



Aufgabe 1

```plantuml
skinparam shadowing false
hide circle
skinparam classAttributeIconSize 0
skinparam class {
  BackgroundColor white
  ArrowColor black
  BorderColor black
}
class Main{
    + main(args:String[]): void
    + start(primaryStage: Stage): void
    }

class Model{
    -a: int
    -b: int
    -c: int
    -result: String
    
    +getSide(sideName:String):int
    +setSide(sideName: String, side: int): void
    +allSidesSet(): boolean
    +getResult(): String
    +setResult(): void
    }


class Controller{
    - cli :CLI
    - model:Model
    - gui :GUI
    
    +Controller(stage: Stage)
    +updateView(view: String, side: String, sideValue:int): void
    +updateResults(): void
    +updateModel(view: String, side: String, sideValue: int): void
    }


class CLI{
    +updateValue(sideName:String, sideValue: int):void
    +awaitInput(controller: Controller):void
    +updateResult(result: String): void
    }

class GUI{
    -a: TextField
    -b: TextField
    -c: TextField
    -prevent: boolean
    -result: Text
    
    +updateValue(name: String, value: int): void
    +updateResult(s: String): void
    +display(stage: Stage, controller: Controller): void
    }
GUI --> Controller
Controller --> Model
CLI --> Controller

```
Aufgabe 2

1.
```plantuml
skinparam shadowing false
skinparam object {
  BackgroundColor white
  ArrowColor black
  BorderColor black
}
 
object "<u>phi1: And" as and
object "<u>: Not " as not
object "<u>: Variable" as a{
    name ="a"
}
object "<u>: Variable" as b{
    name ="b"
}

and -- b: rhs
and -- not: expr
not -- a: lhs
```
2.
phi2 = ¬(¬(p∧q)∧¬r)
Expression phi2 = new Not(new And(new Not(new And(new Variable("p"), new Variable("q"))), new Not(new Variable("r"))))

phi3 = ¬(a∧(¬b∧b))
Expression phi3 = new Not(new And(new Variable("a")),new And(new Not(new Variable("b")),"b"))

3.
```plantuml
hide circle
skinparam shadowing false
skinparam classAttributeIconSize 0
skinparam class {
  BackgroundColor white
  ArrowColor black
  BorderColor black
}
interface ExpressionVisitor <<interface>>{
    + visitAnd(T t): T
    + visitNot(T t): T
    + visitVariable(T t): T
}

interface Expression <<interface>>{
    + accept(ExpressionVisitor<T> visitor): T
}

class And implements Expression {
    + <<create>> And(lhs: Expression, rhs: Expression)
    + visitAnd(And and): T
    + accept(ExpressionVisitor<T> visitor): T
}

And *--> Expression: " ~lhs"
And *--> Expression: " ~rhs"

class Not implements Expression{
    <<create>> Not(expr: Expression)
    + visitNot(Not not): T
    + accept(ExpressionVisitor<T> visitor): T
}

Not *--> Expression: " ~expr"

class Variable implements Expression {
  + <<create>> Variable(name: String)
  ~ name: String
  + visitVariable(Variable variable): T
  + accept(ExpressionVisitor<T> visitor): T
}

class Printer implements ExpressionVisitor{
    + {static} print(Expression expr): String
}
Printer *--> Expression:"expr"

class Evaluator implements ExpressionVisitor{
    - world: String[]
    + <<create>> Evaluator(Set<String>: world)
    + {static} evaluate(Expression: expr, Set<String>: world) 
    
}
Evaluator *--> Expression:"expr"

```
4.
```plantuml
skinparam shadowing false
hide footbox

skinparam sequence {
ArrowColor black
ActorBorderColor black
LifeLineBorderColor black
ParticipantBorderColor black
ParticipantBackgroundColor white
ActorBackgroundColor white
}
participant "phi1: And" as and
participant "not: Not" as not
participant "a: Variable" as a
participant "b: Variable" as b
participant "evaluator: Evaluator" as eval
participant "Evaluator" as Eval

activate and
and -->> a **: Variable("a")
activate a
and -->> not **: Not()
a --> not ++: Not()
not -->> and :lhs
deactivate not
and -->> b **: Variable("b")
activate b
b -->> and : rhs
activate not
not ->> Eval ++: Evaluator("a")
deactivate not
b ->> Eval : Evaluator ("b")
Eval -->> eval **: evaluate (phi,world)
activate eval
deactivate and
deactivate a
deactivate b




```
Das Visitor-Pattern wird hier angewandt, indem die Klasse Evaluator das interface ExpressionVisitor implementiert und die Methode evaluate dann eine Instanz der Klasse Evaluator anlegt und die an die Methode accept von expr übergibt.


Aufgabe 3

1. Das Petri-Netz ist nicht lebendig, da beispielsweise in s4 alle Tokens liegen und nur t4 aktiv ist alle Tokens in s3 wandern und somit t3 nicht schalten kann, weil keine Tokens in s2 liegen. Damit bleibt der Vorgang stehen.

2. Es hat eine Verklemmung, da die Begründung aus 1 gilt.

3. Der Erreichbarkeitsgraph ist nicht unendlich groß, da das Petri-Netz nicht lebendig ist, damit gibt es auch ein Ende.
