Added support for exponentation

Jace.Benchmark/Program.cs

@@ -49,7 +49,7 @@ static void Main(string[] args)
             Console.WriteLine("Number Of Variables Of Each Function: {0}", 3);
             Console.WriteLine("Number Of Executions For Each Function: {0}", 10000.ToString("N0"));
             Console.WriteLine("Total Number Of Executions: {0}", (10000 * 1000).ToString("N0"));
-            Console.WriteLine("Parallell: {0}", true);
+            Console.WriteLine("Parallel: {0}", true);
             Console.WriteLine();
 
             List<string> functions = GenerateRandomFunctions(1000);

Jace.DemoApp/MainWindow.xaml.cs

@@ -112,6 +112,13 @@ private TreeViewItem CreateTreeViewItem(Operation operation)
                 item.Items.Add(CreateTreeViewItem(division.Dividend));
                 item.Items.Add(CreateTreeViewItem(division.Divisor));
             }
+            else if (operation.GetType() == typeof(Exponentiation))
+            {
+                Exponentiation exponentiation = (Exponentiation)operation;
+
+                item.Items.Add(CreateTreeViewItem(exponentiation.Base));
+                item.Items.Add(CreateTreeViewItem(exponentiation.Exponent));
+            }
 
             return item;
         }

Jace.Tests/AstBuilderTests.cs

@@ -78,6 +78,18 @@ public void TestMultiplication()
             Assert.AreEqual(new FloatingPointConstant(2.0), multiplication.Argument2);
         }
 
+        [TestMethod]
+        public void TestExponentiation()
+        {
+            AstBuilder builder = new AstBuilder();
+            Operation operation = builder.Build(new List<object>() { 2, '^', 3 });
+
+            Exponentiation exponentiation = (Exponentiation)operation;
+
+            Assert.AreEqual(new IntegerConstant(2), exponentiation.Base);
+            Assert.AreEqual(new IntegerConstant(3), exponentiation.Exponent);
+        }
+
         [TestMethod]
         public void TestVariable()
         {

Jace.Tests/CalculationEngineTests.cs

@@ -38,6 +38,24 @@ public void TestCalculateFormula1()
             Assert.AreEqual(5.0, result);
         }
 
+        [TestMethod]
+        public void TestCalculatePowCompiled()
+        {
+            CalculationEngine engine = new CalculationEngine(CultureInfo.InvariantCulture, ExecutionMode.Compiled);
+            double result = engine.Calculate("2^3.0");
+
+            Assert.AreEqual(8.0, result);
+        }
+
+        [TestMethod]
+        public void TestCalculatePowInterpreted()
+        {
+            CalculationEngine engine = new CalculationEngine(CultureInfo.InvariantCulture, ExecutionMode.Interpreted);
+            double result = engine.Calculate("2^3.0");
+
+            Assert.AreEqual(8.0, result);
+        }
+
         [TestMethod]
         public void TestCalculateFormulaWithVariables()
         {

Jace/AstBuilder.cs

@@ -19,6 +19,7 @@ public AstBuilder()
             operationPrecedence.Add('-', 1);
             operationPrecedence.Add('*', 2);
             operationPrecedence.Add('/', 2);
+            operationPrecedence.Add('^', 3);
         }
 
         public Operation Build(IList<object> tokens)
@@ -122,6 +123,11 @@ private Operation Convert(char operation)
                     Operation divident = resultStack.Pop();
 
                     return new Division(DataType.FloatingPoint, divident, divisor);
+                case '^':
+                    Operation exponent = resultStack.Pop();
+                    Operation @base = resultStack.Pop();
+
+                    return new Exponentiation(DataType.FloatingPoint, @base, exponent);
                 default:
                     throw new ArgumentException(string.Format("Unknown operation \"{0}\".", operation), "operation");
             }

Jace/DynamicCompiler.cs

@@ -127,6 +127,14 @@ private void GenerateMethodBody(ILGenerator generator, Operation operation)
 
                 generator.Emit(OpCodes.Div);
             }
+            else if (operation.GetType() == typeof(Exponentiation))
+            {
+                Exponentiation exponentation = (Exponentiation)operation;
+                GenerateMethodBody(generator, exponentation.Base);
+                GenerateMethodBody(generator, exponentation.Exponent);
+
+                generator.Emit(OpCodes.Call, typeof(Math).GetMethod("Pow"));
+            }
             else
             {
                 throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation");

Jace/Interpreter.cs

@@ -70,6 +70,11 @@ public double Execute(Operation operation, Dictionary<string, double> variables)
                 Division division = (Division)operation;
                 return Execute(division.Dividend, variables) / Execute(division.Divisor, variables);
             }
+            else if (operation.GetType() == typeof(Exponentiation))
+            {
+                Exponentiation exponentiation = (Exponentiation)operation;
+                return Math.Pow(Execute(exponentiation.Base, variables), Execute(exponentiation.Exponent, variables));
+            }
             else
             {
                 throw new ArgumentException(string.Format("Unsupported operation \"{0}\".", operation.GetType().FullName), "operation");

Jace/Jace.csproj

@@ -57,6 +57,7 @@
     <Compile Include="Operations\Constant.cs" />
     <Compile Include="Operations\ConversionToFloatingPoint.cs" />
     <Compile Include="Operations\Division.cs" />
+    <Compile Include="Operations\Exponentiation.cs" />
     <Compile Include="Operations\Operation.cs" />
     <Compile Include="Operations\Multiplication.cs" />
     <Compile Include="Operations\Substraction.cs" />

Jace/Operations/Exponentiation.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Jace.Operations
+{
+    public class Exponentiation : Operation
+    {
+        public Exponentiation(DataType dataType, Operation @base, Operation exponent)
+            : base(dataType)
+        {
+            Base = @base;
+            Exponent = exponent;
+        }
+
+        public Operation Base { get; private set; }
+        public Operation Exponent { get; private set; }
+    }
+}

Jace/Tokenizer/TokenReader.cs

@@ -101,6 +101,7 @@ public List<object> Read(string formula)
                     case '-':
                     case '*':
                     case '/':
+                    case '^':
                     case '(':
                     case ')':
                         tokens.Add(characters[i]);