Added XOR, NAND, NOR, XNOR operators

tomc128 · tomc128 · commit d674bada47c3 · 2022-10-18T21:13:41.000Z
diff --git a/v2/BooleanExpressionParser/.vscode/launch.json b/v2/BooleanExpressionParser/.vscode/launch.json
@@ -8,11 +8,11 @@
             "preLaunchTask": "build",
             "program": "${workspaceFolder}/bin/Debug/net6.0/BooleanExpressionParser.dll",
             "args": [
-                "A.B",
-                "A+B",
-                "!(A+B+C)",
-                "(((A.B&C) OR A) AND (NOT B + !C)) AND NOT D",
-                "!S.D_0 + D_1 AND S",
+                // "A.B",
+                // "A+B",
+                // "!(A+B+C)",
+                // "(((A.B&C) OR A) AND (NOT B + !C)) AND NOT D",
+                // "!S.D_0 + D_1 AND S",
             ],
             "cwd": "${workspaceFolder}",
             "console": "integratedTerminal", // enables input (instead of internalConsole)
diff --git a/v2/BooleanExpressionParser/Evaluator.cs b/v2/BooleanExpressionParser/Evaluator.cs
@@ -43,6 +43,11 @@ private bool Evaluate(Node node, bool[] values)
 
             if (node is AndOperatorNode) return left && right;
             if (node is OrOperatorNode) return left || right;
+            if (node is XorOperatorNode) return left ^ right;
+            if (node is NandOperatorNode) return !(left && right);
+            if (node is NorOperatorNode) return !(left || right);
+            if (node is XnorOperatorNode) return !(left ^ right);
+
         }
         else
         {
diff --git a/v2/BooleanExpressionParser/Formatter.cs b/v2/BooleanExpressionParser/Formatter.cs
@@ -10,7 +10,9 @@ public static string FormatTokens(IEnumerable<Token> tokens)
 
         foreach (var token in tokens)
         {
-            sb.Append(token.ToString());
+            string s = token.ToString();
+            if (s.Length > 1) s = $"[{s}]";
+            sb.Append(s);
         }
 
         return sb.ToString();
@@ -52,7 +54,7 @@ public static string FormatTruthTable(Ast ast, List<bool[]> table, string label=
 
         sb.Append("┗━");
         sb.AppendJoin(null, variableLine);
-        sb.AppendLine($"━┻{resultLine}┛");
+        sb.Append($"━┻{resultLine}┛");
 
         return sb.ToString();
     }
diff --git a/v2/BooleanExpressionParser/Nodes/NandOperatorNode.cs b/v2/BooleanExpressionParser/Nodes/NandOperatorNode.cs
@@ -0,0 +1,4 @@
+class NandOperatorNode : OperatorNode
+{
+    public NandOperatorNode(Node left, Node right) : base(left, right) { }
+}
diff --git a/v2/BooleanExpressionParser/Nodes/NorOperatorNode.cs b/v2/BooleanExpressionParser/Nodes/NorOperatorNode.cs
@@ -0,0 +1,4 @@
+class NorOperatorNode : OperatorNode
+{
+    public NorOperatorNode(Node left, Node right) : base(left, right) { }
+}
diff --git a/v2/BooleanExpressionParser/Nodes/XnorOperatorNode.cs b/v2/BooleanExpressionParser/Nodes/XnorOperatorNode.cs
@@ -0,0 +1,4 @@
+class XnorOperatorNode : OperatorNode
+{
+    public XnorOperatorNode(Node left, Node right) : base(left, right) { }
+}
diff --git a/v2/BooleanExpressionParser/Nodes/XorOperatorNode.cs b/v2/BooleanExpressionParser/Nodes/XorOperatorNode.cs
@@ -0,0 +1,4 @@
+class XorOperatorNode : OperatorNode
+{
+    public XorOperatorNode(Node left, Node right) : base(left, right) { }
+}
diff --git a/v2/BooleanExpressionParser/Parser.cs b/v2/BooleanExpressionParser/Parser.cs
@@ -22,6 +22,10 @@ public IEnumerable<Token> ParseTokens(IEnumerable<Token> tokens)
                 case AndOperatorToken:
                 case OrOperatorToken:
                 case NotOperatorToken:
+                case XorOperatorToken:
+                case NandOperatorToken:
+                case NorOperatorToken:
+                case XnorOperatorToken:
                     while ((stack.Count > 0 && stack.Peek() is OperatorToken && stack.Peek() is not OpenParenToken) && ((stack.Peek() as OperatorToken)!.Precedence >= (token as OperatorToken)!.Precedence))
                     {
                         output.Enqueue(stack.Pop());
@@ -42,7 +46,8 @@ public IEnumerable<Token> ParseTokens(IEnumerable<Token> tokens)
                     if (stack.Peek() is OpenParenToken)
                     {
                         stack.Pop();
-                        if (stack.Count > 0 && (stack.Peek() is AndOperatorToken or OrOperatorToken or NotOperatorToken))
+                        // NOTE: Changed this check from several specific checks to 'is OperatorToken' 
+                        if (stack.Count > 0 && (stack.Peek() is OperatorToken))
                         {
                             output.Enqueue(stack.Pop());
                         }
@@ -79,12 +84,24 @@ public Ast GrowAst(IEnumerable<Token> tokens)
 
                 case AndOperatorToken:
                 case OrOperatorToken:
+                case XorOperatorToken:
+                case NandOperatorToken:
+                case NorOperatorToken:
+                case XnorOperatorToken:
                     if (stack.Count < 2) throw new Exception($"2 parameters needed for operator ${token}");
 
                     if (token is AndOperatorToken)
                         stack.Push(new AndOperatorNode(stack.Pop(), stack.Pop()));
                     else if (token is OrOperatorToken)
                         stack.Push(new OrOperatorNode(stack.Pop(), stack.Pop()));
+                    else if (token is NorOperatorToken)
+                        stack.Push(new NorOperatorNode(stack.Pop(), stack.Pop()));
+                    else if (token is NandOperatorToken)
+                        stack.Push(new NandOperatorNode(stack.Pop(), stack.Pop()));
+                    else if (token is XorOperatorToken)
+                        stack.Push(new XorOperatorNode(stack.Pop(), stack.Pop()));
+                    else if (token is XnorOperatorToken)
+                        stack.Push(new XnorOperatorNode(stack.Pop(), stack.Pop()));
                     break;
 
                 case NotOperatorToken:
diff --git a/v2/BooleanExpressionParser/Program.cs b/v2/BooleanExpressionParser/Program.cs
@@ -17,6 +17,11 @@ static void Main(params string[] args)
 
             var parser = new Parser();
             var prefixTokens = parser.ParseTokens(infixTokens);
+
+            Console.WriteLine(expression);
+            Console.WriteLine("Infix: " + Formatter.FormatTokens(infixTokens));
+            Console.WriteLine("Prefix: " + Formatter.FormatTokens(prefixTokens));
+
             var ast = parser.GrowAst(prefixTokens);
 
             var evaluator = new Evaluator(ast);
diff --git a/v2/BooleanExpressionParser/Tokeniser.cs b/v2/BooleanExpressionParser/Tokeniser.cs
@@ -32,6 +32,10 @@ public IEnumerable<Token> Tokenise()
                 "AND" or "." or "&" => new AndOperatorToken(),
                 "OR" or "+" or "|" => new OrOperatorToken(),
                 "NOT" or "!" or "¬" => new NotOperatorToken(),
+                "XOR" => new XorOperatorToken(),
+                "NAND" => new NandOperatorToken(),
+                "NOR" => new NorOperatorToken(),
+                "XNOR" => new XnorOperatorToken(),
                 _ => new VariableToken(token)
             };
         }
diff --git a/v2/BooleanExpressionParser/Tokens/NandOperatorToken.cs b/v2/BooleanExpressionParser/Tokens/NandOperatorToken.cs
@@ -0,0 +1,5 @@
+class NandOperatorToken : OperatorToken
+{
+    public NandOperatorToken() : base(2) { }
+    public override string ToString() => "NAND";
+}
diff --git a/v2/BooleanExpressionParser/Tokens/NorOperatorToken.cs b/v2/BooleanExpressionParser/Tokens/NorOperatorToken.cs
@@ -0,0 +1,6 @@
+class NorOperatorToken : OperatorToken
+{
+    public NorOperatorToken() : base(1) { }
+    public override string ToString() => "NOR";
+
+}
diff --git a/v2/BooleanExpressionParser/Tokens/XnorOperatorToken.cs b/v2/BooleanExpressionParser/Tokens/XnorOperatorToken.cs
@@ -0,0 +1,5 @@
+class XnorOperatorToken : OperatorToken
+{
+    public XnorOperatorToken() : base(3) { }
+    public override string ToString() => "XNOR";
+}
diff --git a/v2/BooleanExpressionParser/Tokens/XorOperatorToken.cs b/v2/BooleanExpressionParser/Tokens/XorOperatorToken.cs
@@ -0,0 +1,5 @@
+class XorOperatorToken : OperatorToken
+{
+    public XorOperatorToken() : base(1) { }
+    public override string ToString() => "XOR";
+}

Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,11 @@ private bool Evaluate(Node node, bool[] values)`
`43`	`43`
`44`	`44`	`if (node is AndOperatorNode) return left && right;`
`45`	`45`	`if (node is OrOperatorNode) return left \|\| right;`
	`46`	`+ if (node is XorOperatorNode) return left ^ right;`
	`47`	`+ if (node is NandOperatorNode) return !(left && right);`
	`48`	`+ if (node is NorOperatorNode) return !(left \|\| right);`
	`49`	`+ if (node is XnorOperatorNode) return !(left ^ right);`
	`50`	`+`
`46`	`51`	`}`
`47`	`52`	`else`
`48`	`53`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,9 @@ public static string FormatTokens(IEnumerable<Token> tokens)`
`10`	`10`
`11`	`11`	`foreach (var token in tokens)`
`12`	`12`	`{`
`13`		`- sb.Append(token.ToString());`
	`13`	`+ string s = token.ToString();`
	`14`	`+ if (s.Length > 1) s = $"[{s}]";`
	`15`	`+ sb.Append(s);`
`14`	`16`	`}`
`15`	`17`
`16`	`18`	`return sb.ToString();`
`@@ -52,7 +54,7 @@ public static string FormatTruthTable(Ast ast, List<bool[]> table, string label=`
`52`	`54`
`53`	`55`	`sb.Append("┗━");`
`54`	`56`	`sb.AppendJoin(null, variableLine);`
`55`		`- sb.AppendLine($"━┻{resultLine}┛");`
	`57`	`+ sb.Append($"━┻{resultLine}┛");`
`56`	`58`
`57`	`59`	`return sb.ToString();`
`58`	`60`	`}`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +class NandOperatorNode : OperatorNode
 +{
 +    public NandOperatorNode(Node left, Node right) : base(left, right) { }
 +}