Merge pull request #23 from aneshodza/feature/allow-reruns

Make run revert correctly to allows reruns

Author: aneshodza

README.md

@@ -13,6 +13,7 @@ It only checks for these two things on the node it's currently on (while being i
 ---
 
 ## Usage
+**Important:** This just goes over creating an automaton using every configuration option. [Here](./tests/integration_tests/README.md) you can find real use-cases.
 Creating a pushdown automaton involves following steps:
 1. Creating the automaton instance
 2. Creating all the states
@@ -93,6 +94,7 @@ It holds a message, if it was sucessful and the return code. Following codes are
 |1         |The automaton didn't terminate in a valid end state                   |
 |2         |The automaton didn't find a valid transition, so went to a sink state |
 |Exception |The automaton isn't deterministic                                     |
+|Exception |The input word is undefined                                           |
 
 
 ## Other links
@@ -102,4 +104,4 @@ It holds a message, if it was sucessful and the return code. Following codes are
 - [Feature requests](./docs/FEATURE_REQUESTS.md)
 
 #### Credits
-This library was written and published by [Anes Hodza](aneshodza.ch)
+This library was written and published by [Anes Hodza](https://aneshodza.ch)

src/PushdownAutomaton.ts

@@ -7,37 +7,47 @@ import TerminationMessage from "./TerminationMessage";
  */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 class PushdownAutomaton {
-  stack: Stack = new Stack();
+  stack: Stack;
   startState: State | null = null;
   endStates: Array<State> = [];
 
   currentState: State | null = null;
-  inputWord: string = "";
+  inputWord: string | undefined;
+  defaultStackTocken: string = "$";
   operation: ((automata: PushdownAutomaton) => void) | null = null;
 
   /**
    * Creates an instance of `PushdownAutomaton`.
    * @param {string} inputWord - The input word to be processed by the automaton.
+   * @param {string} defaultStackTocken - The default token to be used as the initial value of the stack.
    */
-  constructor(inputWord: string, defaultStackTocken: string = "$") {
+  constructor(inputWord: string|undefined = undefined, defaultStackTocken: string = "$") {
     this.inputWord = inputWord;
-    this.stack.pop();
-    this.stack.push(defaultStackTocken);
+    this.defaultStackTocken = defaultStackTocken;
+    this.stack = new Stack(defaultStackTocken);
   }
 
   /**
    * Runs the automaton until the input word is fully processed or a failure occurs.
    * @returns {TerminationMessage} An object describing the result of the execution.
    */
-  run(): TerminationMessage {
+  run(inputWord: string|undefined = undefined): TerminationMessage {
+    if (inputWord !== undefined) {
+      this.inputWord = inputWord;
+    } else if (this.inputWord === undefined) {
+      throw new Error("No input word provided");
+    }
+
+    this.currentState = this.startState;
+    this.stack = new Stack(this.defaultStackTocken);
+
     while (this.inputWord.length > 0) {
       const returnValue = this.step();
 
+      this.operation?.call(this, this);
       if (!returnValue.successful) {
         return returnValue;
       }
-
-      this.operation?.call(this, this);
     }
 
     if (this.endStates.includes(this.currentState!)) {
@@ -59,8 +69,8 @@ class PushdownAutomaton {
    * @returns {TerminationMessage} An object detailing the outcome of the step.
    */
   step(): TerminationMessage {
-    const currentToken = this.inputWord.charAt(0);
-    this.inputWord = this.inputWord.slice(1);
+    const currentToken = this.inputWord!.charAt(0);
+    this.inputWord = this.inputWord!.slice(1);
 
     if (
       this.currentState!.allTransitionFunctions(currentToken, this.stack.last())
@@ -138,7 +148,7 @@ class PushdownAutomaton {
       `Current node: ${this.currentState!.name} \n\n` +
       `Stack: \n` +
       `${this.stack.stackClone().reverse().join("\n")}\n\n` +
-      `Ugly stack [${this.stack.stackClone().reverse().join(", ")}]`,
+      `Ugly stack [${this.stack.stackClone().join(", ")}]`,
     );
   }
 

src/Stack.ts

@@ -8,8 +8,8 @@ class Stack {
   /**
    * Constructs a stack instance with an initial symbol.
    */
-  constructor() {
-    this.stackValues = ["$"];
+  constructor(defaultValue: string = "$") {
+    this.stackValues = [defaultValue];
   }
 
   /**

tests/integration_tests/README.md

@@ -0,0 +1,40 @@
+# Real use-cases
+In this folder you can find tests of real applications of pushdown automata.
+
+## Balanced parantheses
+This pushdown automaton can check if the input word has balanced parantheses. This is how the language is defined:
+$$`
+L = \{ w \mid w \text{ is a string of balanced parentheses} \}
+`$$
+**Accepted words that are tested:**
+```
+-> (()())
+-> ()()()
+-> ((()))
+-> ()(()())
+```
+
+**Not accepted words that are tested:**
+```
+-> (()()
+-> ())
+-> ((())
+-> )()()
+```
+
+$$`
+\text{The automaton can be defined as such:} \newline
+M = (\{q_1, q_2\}, \{(, )\}, \{\$, 1, L\}, \delta, q_1, \$, F)
+`$$
+
+$$`
+\text{Following transition functions are defined:} \newline
+\delta(q_1, "(", "\$") = \{(q_1, "\$L")\} \newline
+\delta(q_1, "(", "L") = \{(q_1, "L1")\} \newline
+\delta(q_1, "(", "1") = \{(q_1, "11")\} \newline
+\delta(q_1, ")", "1") = \{(q_1, \epsilon)\} \newline
+\delta(q_1, ")", "L") = \{(q_2, \epsilon)\} \newline
+\delta(q_2, "(", "\$") = \{(q_1, "\$L")\}
+`$$
+
+

tests/integration_tests/balances_parantheses.test.ts

@@ -0,0 +1,64 @@
+import PushdownAutomaton from "../../src/PushdownAutomaton";
+import State from "../../src/State";
+import Transition from "../../src/TransitionFunction";
+
+/*
+ * In this test a pushdown automaton that checks following language is tested:
+ * L = { w | w contains balanced parentheses }
+ */
+
+let automaton: PushdownAutomaton;
+beforeEach(() => {
+  // Initialize the automaton
+  automaton = new PushdownAutomaton();
+
+  // Initialize the start and end states
+  let startState = new State("q1");
+  let endState = new State("q2");
+  automaton.setStartSate(startState);
+  automaton.addEndState(endState);
+
+  // Add transition functions to start state
+  let transition1 = new Transition("(", startState, "$", ["$", "L"]);
+  startState.addTransitionFunction(transition1);
+  let transition2 = new Transition("(", startState, "L", ["L", "1"]);
+  startState.addTransitionFunction(transition2);
+  let transition3 = new Transition("(", startState, "1", ["1", "1"]);
+  startState.addTransitionFunction(transition3);
+  let transition4 = new Transition(")", startState, "1", []);
+  startState.addTransitionFunction(transition4);
+  let transition5 = new Transition(")", endState, "L", []);
+  startState.addTransitionFunction(transition5);
+
+  // Add transition functions to end state
+  let transition6 = new Transition("(", startState, "$", ["$", "L"]);
+  endState.addTransitionFunction(transition6);
+});
+
+test("Balanced parentheses", () => {
+  let result = automaton.run("(()())");
+  expect(result.successful).toBe(true);
+
+  let result2 = automaton.run("()()()");
+  expect(result2.successful).toBe(true);
+
+  let result3 = automaton.run("((()))");
+  expect(result3.successful).toBe(true);
+
+  let result4 = automaton.run("()(()())");
+  expect(result4.successful).toBe(true);
+});
+
+test("Unbalanced parentheses", () => {
+  let result = automaton.run("(()()");
+  expect(result.successful).toBe(false);
+
+  let result2 = automaton.run("())");
+  expect(result2.successful).toBe(false);
+
+  let result3 = automaton.run("((())");
+  expect(result3.successful).toBe(false);
+
+  let result4 = automaton.run(")()()");
+  expect(result4.successful).toBe(false);
+});

tests/unit_tests/pushdown_automaton.test.ts

@@ -162,4 +162,41 @@ test("Throws an exception if it finds two matching transitions", () => {
 test("Allows the user to define a default stack token", () => {
   let automata = new PushdownAutomaton("test", "default");
   expect(automata.stack.stackValues).toStrictEqual(["default"]);
-})
+});
+
+test("Allows creating an automaton without any input parameters", () => {
+  automata = new PushdownAutomaton();
+  expect(automata).toBeDefined();
+  expect(automata.inputWord).toBeUndefined();
+});
+
+test("run() throws if no input word is provided", () => {
+  automata = new PushdownAutomaton();
+  expect(() => automata.run()).toThrow("No input word provided");
+});
+
+test("Allow run() to overwrite the input word", () => {
+  automata.run("new word");
+  expect(automata.inputWord).toBe("ew word");
+});
+
+test("run() in sucession works", () => {
+  let transition5 = new Transition("", otherState, "e", ["d"]);
+  let transition2 = new Transition("e", oneState, "d", ["d"]);
+  let transition3 = new Transition("s", otherState, "d", ["d"]);
+  let transition4 = new Transition("t", oneState, "d", ["e"]);
+
+  otherState.addTransitionFunction(transition2);
+  oneState.addTransitionFunction(transition3);
+  otherState.addTransitionFunction(transition4);
+
+  oneState.addTransitionFunction(transition5);
+
+  automata.run();
+
+  expect(automata.run("test")).toStrictEqual({
+    reason: "Word accepted",
+    successful: true,
+    code: 0,
+  });
+});

tests/unit_tests/stack.test.ts

@@ -9,6 +9,10 @@ test("Initializes the stack with a $", () => {
   expect(stack.stackValues).toEqual(["$"]);
 });
 
+test("Allows for a custom initial value", () => {
+  expect(new Stack("a").stackValues).toEqual(["a"]);
+});
+
 test("Pushes a value onto the stack", () => {
   stack.push("a");
   expect(stack.stackValues).toEqual(["$", "a"]);