Parser.BuildExpressionTree

src/Expressions/FunctionCallExpression.fu

@@ -0,0 +1,36 @@
+abstract class FunctionCallExpression : IExpression
+{
+    IExpression X;
+
+    internal void Init!(IExpression x){
+        X = x;
+    }
+
+    internal abstract double FunctionImplementation(double x);
+
+    internal override double Calculate() => FunctionImplementation(X.Calculate());
+}
+
+class FunctionCallExpressionSin : FunctionCallExpression {
+    internal override double FunctionImplementation(double x) => Math.Sin(x);
+}
+class FunctionCallExpressionCos : FunctionCallExpression {
+    internal override double FunctionImplementation(double x) => Math.Cos(x);
+}
+class FunctionCallExpressionTan : FunctionCallExpression {
+    internal override double FunctionImplementation(double x) => Math.Tan(x);
+}
+
+class FunctionCallExpressionAsin : FunctionCallExpression {
+    internal override double FunctionImplementation(double x) => Math.Asin(x);
+}
+class FunctionCallExpressionAcos : FunctionCallExpression {
+    internal override double FunctionImplementation(double x) => Math.Acos(x);
+}
+class FunctionCallExpressionAtan : FunctionCallExpression {
+    internal override double FunctionImplementation(double x) => Math.Atan(x);
+}
+
+class FunctionCallExpressionLog : FunctionCallExpression{
+    internal override double FunctionImplementation(double x) => Math.Log(x);
+}

src/Expressions/IExpression.fu

@@ -0,0 +1,4 @@
+abstract class IExpression
+{
+    internal abstract double Calculate();
+}

src/Expressions/NumericalExpression.fu

@@ -0,0 +1,5 @@
+class NumericExpression : IExpression
+{
+    double N;
+    internal override double Calculate() => N;
+}

src/Expressions/OperatorExpression.fu

@@ -0,0 +1,51 @@
+abstract class OperatorExpression : IExpression
+{
+    IExpression A;
+    IExpression B;
+
+    internal void Init!(IExpression a, IExpression b) {
+        A = a;
+        B = b;
+    }
+
+    internal abstract double OperatorImplementation(double a, double b);
+
+    internal override double Calculate() => OperatorImplementation(A.Calculate(), B.Calculate());
+}
+
+class OperatorExpressionAdd : OperatorExpression {
+    internal override double OperatorImplementation(double a, double b) => a+b;
+}
+
+class OperatorExpressionSub : OperatorExpression {
+    internal override double OperatorImplementation(double a, double b) => a-b;
+}
+
+class OperatorExpressionMul : OperatorExpression {
+    internal override double OperatorImplementation(double a, double b) => a*b;
+}
+
+class OperatorExpressionDiv : OperatorExpression {
+    internal override double OperatorImplementation(double a, double b) => a/b;
+}
+
+class OperatorExpressionMod : OperatorExpression {
+    // returns if b>0 then returns a%b else returns a
+    internal override double OperatorImplementation(double a, double b) {
+        if(b <= 0)
+            return a;
+        if(a > 0){
+            while(a >= b)
+                a -= b;
+        }
+        else {
+            while(a <= b)
+                a += b;
+        }
+        return a;
+    }
+}
+
+class OperatorExpressionPow : OperatorExpression {
+    internal override double OperatorImplementation(double a, double b) => Math.Pow(a, b);
+}