using System;
using System.Diagnostics;

class Test {
    static void rate(int mf,Action act) {
        long n=1,tau=0, tau_min=160, mg=10;
        for(;;) {
            var sw = Stopwatch.StartNew();
            for (long i = n; i > 0; --i) {
                act(); act(); act(); act(); act(); 
                act(); act(); act(); act(); act();
            }
            sw.Stop(); 
            tau = sw.ElapsedMilliseconds; 
            if (tau > tau_min) break;
            n = n * 10;
        }
        n *= mg;
        Console.WriteLine("rate={0:G3}MHz dt={1:G5}ns x{2}", n * mf * 1e-3 / tau,tau * 1e6 / n / mf, mf);
    }
    static void rate_group(Action act) {
        rate(1,act);
        rate(1,() => { act();  });
        rate(10,() => { for (int i = 0; i < 10; i++) act(); });
        rate(100,() => { for (int i = 0; i < 100; i++) act(); });
        rate(1000,() => { for (int i = 0; i < 1000; i++) act(); });
    }
    static string fn(string a,string b) {
        a = a.ToLower();
        b = b.ToUpper();
        return string.Format("{0}{1}",a,b);
    }
    static double fn(double a,double b) {
        return 2 + a * Math.Pow(Math.Sin(Math.E),2)  + Math.Pow(Math.Cos(Math.E), 2) * b;
    }
    public static void Main() {

        rate(1,() => { });

        /*
        int x = 0;
        rate(1,() => { x++;  });
        rate(10,() => { for (int i = 0; i < 10; i++) x++; });
        rate(100,() => { for (int i = 0; i < 100; i++) x++; });
        rate(1000,() => { for (int i = 0; i < 1000; i++) x++; });

        rate_group(() => { x++; });
        */

        var p = new Parser("2+2*sin(e)^2+cos(e)^2*2");
        var e = new Expression().init();
        var dc = new DynamicCode();
        dc.load();

        var mi=dc.CompileMethod("A.fn",@"
using System;
public class A {
public static double fn(double a,double b) {
    double r= 2 + a * Math.Pow(Math.Sin(Math.E),2)  + Math.Pow(Math.Cos(Math.E), 2) * b;
    return r;
}
}
");

        var mi100 = dc.CompileMethod("A.fn",@"
using System;
public class A {
public static double fn(double a,double b) {
    double r=0;
    for(int i=0;i<100;i++) {
        r = 2 + a * Math.Pow(Math.Sin(Math.E),2)  + Math.Pow(Math.Cos(Math.E), 2) * b;
    }
    return r;
}
}
");
        Console.WriteLine("native");
        rate_group(() => { var r = fn(2,2); });

        Console.WriteLine("parsed");
        rate_group(() => { var r = e.Eval(p.reset()); });

        Console.WriteLine("compiled");
        rate_group(() => { var r = (double)mi.Invoke(null,new object[] { 2, 2 } );  });

        Console.WriteLine("compiled batch");
        rate(100,() => { var r = (double)mi100.Invoke(null,new object[] { 2,2 }); });

        dc.unload();
    }
}

using System;
using System.CodeDom.Compiler;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using Microsoft.CSharp;

public class DynamicCode {
    AppDomain domain;
    string DomainName = "MyDomain";
    string References = "System.dll System.Data.dll";
    public void load() {
        domain = AppDomain.CreateDomain(DomainName);
        domain.DomainUnload += (s,a) => Console.WriteLine("unload domain");
    }
    public void unload() {
        AppDomain.Unload(domain);
        domain = null;
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
    public Module Compile(string code) {
        var prm = new CompilerParameters();
        prm.GenerateInMemory = true;
        prm.TreatWarningsAsErrors = false;
        prm.GenerateExecutable = false;
        prm.CompilerOptions = "/optimize";
        prm.OutputAssembly = DomainName;
        prm.ReferencedAssemblies.AddRange(References.Split(' '));

        var provider = new CSharpCodeProvider();
        var compile = provider.CompileAssemblyFromSource(prm,new string[] { code });

        if (compile.Errors.HasErrors) {
            var sb = new StringBuilder();
            sb.Append("Compile error: ");
            foreach (var ce in compile.Errors) {
                sb.Append("\r\n");
                sb.Append(ce.ToString());
            }
            throw new Exception(sb.ToString());
        }
        var modules = compile.CompiledAssembly.GetModules();
        return modules[0];
    }
    public MethodInfo CompileMethod(string name,string code) {
        var parts = name.Split('.'); if (parts.Length != 2) throw new Exception("invalid name");
        var mod = Compile(code); if (mod == null) throw new Exception("no module");
        var mt = mod.GetType(parts[0]); if (mt == null) throw new Exception("no type " + parts[0]);
        var mi = mt.GetMethod(parts[1]); if (mi == null) throw new Exception("no method " + parts[1]);
        RuntimeHelpers.PrepareMethod(mi.MethodHandle);
        return mi;
    }
}

using System;
using System.Collections.Generic;

public class Expression {
    Parser p;
    public Parser parser { get { return p; } }
    public Dictionary<string,Func<double[],double>> functions = new Dictionary<string,Func<double[],double>>();
    public Dictionary<string,double> constants = new Dictionary<string,double>();
    public Expression init() {
        functions["abs"] = x => Math.Abs(x[0]);
        functions["sin"] = x => Math.Sin(x[0]);
        functions["asin"] = x => Math.Asin(x[0]);
        functions["cos"] = x => Math.Cos(x[0]);
        functions["acos"] = x => Math.Acos(x[0]);
        functions["tan"] = x => Math.Tan(x[0]);
        functions["log"] = x => Math.Log(x[0]);
        functions["exp"] = x => Math.Exp(x[0]);
        functions["pow"] = x => Math.Pow(x[0],x[1]);
        functions["round"] = x => Math.Round(x[0]);
        functions["ceil"] = x => Math.Ceiling(x[0]);
        functions["floor"] = x => Math.Floor(x[0]);
        constants["pi"] = Math.PI;
        constants["e"] = Math.E;
        return this;
    }
    public double Eval(Parser p) {
        this.p = p; double res = L0();
        if (p.anyError) throw new Exception(p.ErrorMessage);
        return res;
    }
    double L0() {
        double r = L1();
        while ((!p.eos) && (!p.anyError)) {
            p.skipSpace();
            if (p.chk('+')) { r += L1(); continue; }
            if (p.chk('-')) { r -= L1(); continue; }
            break;
        }
        return r;
    }
    double L1() {
        double r = L2();
        while (!p.eos && !p.anyError) {
            p.skipSpace();
            if (p.chk('*')) { r *= L2(); continue; }
            if (p.chk('/')) {
                double r1 = L2();
                if (r1 == 0) { p.error("divide by zero"); return 0; }
                r /= r1;
                continue;
            }
            break;
        }
        return r;
    }
    double L2() {
        double r = L3(); if (p.anyError) return r;
        if (p.skipSpace().chk('^')) r = Math.Pow(r,L3());
        return r;
    }
    double L3() {
        double r;
        if (p.skipSpace().chk('(')) {
            r = L0();
            if (!p.skipSpace().chk(')')) { p.error("no closing bracket"); return 0; }
        } else {
            r = L4();
        }
        return r;
    }
    double L4() {
        if (!Parser.isAlpha(p.skipSpace().peek())) return L5();
        string name; double r;
        p.getName(out name).skipSpace();
        if (p.chk('(')) {
            Func<double[],double> fn;
            if (!functions.TryGetValue(name,out fn)) { p.error("unknown function " + name); return 0; }
            List<double> args = new List<double>();
            for (; ; ) {
                p.skipSpace();
                if (p.eos) { p.error("unexpected end of expression"); return 0; }
                if (p.chk(')')) break;
                double arg = L0(); if (p.anyError) return 0;
                args.Add(arg);
            }
            r = fn(args.ToArray());
        } else {
            if (!constants.TryGetValue(name,out r)) { p.error("unknown constant " + name); return 0; }
        }
        return r;
    }
    double L5() {
        if (p.skipSpace().chk('-')) return -L6();
        return L6();
    }
    double L6() {
        double r;
        p.skipSpace().getDouble(out r);
        return r;
    }
}

using System;
using System.Collections.Generic;
using System.Text;

public class Parser {
    string src,err_msg; int pos,head,tail,err;
    public Parser(string text) {
        src = text;
        head = 0; tail = src.Length;
        pos = 0; err = -1;
    }
    public string ErrorMessage {
        get {
            if (err < 0) return "";
            return String.Format("{0} {1}",err,err_msg);
        }
    }
    public Parser error(string msg) { if (err < 0) { err = pos; err_msg = msg; } return this; }
    public Parser clearError() { err = -1; return this; }
    public bool anyError { get { return err >= 0; } }
    static public bool isSpace(char c) { return c > (char)0 && c <= ' '; }
    static public bool isDigit(char c) { return c >= '0' && c <= '9'; }
    static public bool isLetter(char c) { return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); }
    static public bool isHex(char c) { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); }
    static public bool isAlpha(char c) { return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_'); }
    static public bool isAlphaDigit(char c) { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_'); }
    public Parser reset() { pos = head; err = -1; return this; }
    public bool eos { get { return pos >= tail; } }
    public char peek() { return pos < tail ? src[pos] : (char)0; }
    public char get() { return pos < tail ? src[pos++] : (char)0; }
    public bool chk(char c) { if (pos < tail && src[pos] == c) { pos++; return true; } return false; }
    public Parser skipSpace() { while (pos < tail && isSpace(src[pos])) pos++; return this; }
    public Parser getName(out string name) {
        name = "";
        if (!isAlpha(peek())) return error("invalid name format");
        var sb = new StringBuilder();
        while (isAlphaDigit(peek())) sb.Append(get());
        name = sb.ToString();
        return this;
    }
    public Parser getUint(out uint value) {
        value = 0;
        if (!isDigit(peek())) return error("invalid digit format");
        uint r1 = 0,r2 = 0;
        while (isDigit(peek())) {
            r1 = r2;
            r2 = r2 * 10 + (uint)get() - (uint)'0';
            if (r2 < r1) return error("integer overflow");
        }
        value = r2;
        return this;
    }
    public Parser getInt(out int value) {
        value = 0;
        bool sign = chk('-');
        uint r1; int r2;
        if (getUint(out r1).anyError) return this;
        r2 = (int)r1; if (r2 < 0) return error("integer overflow");
        if (sign) r2 = -r2;
        value = r2;
        return this;
    }
    public Parser getDouble(out double value) {
        value = 0;
        bool sign = chk('-'); if (!sign) chk('+');
        if (!isDigit(peek())) return error("invalid double format");
        double r1 = 0;
        while (isDigit(peek())) { r1 = r1 * 10 + (int)get() - (int)'0'; }
        if (chk('.')) {
            double r2 = 0,r3 = 1;
            while (isDigit(peek())) { r3 = r3 / 10; r2 += r3 * ((int)get() - (int)'0'); }
            r1 += r2;
        }
        if (chk('e') || chk('E') || chk('d') || chk('D')) {
            bool esign = chk('-'); if (!esign) chk('+');
            if (!isDigit(peek())) return error("invalid double exponent format");
            double r4 = 0;
            while (isDigit(peek())) { r4 = r4 * 10 + (int)get() - (int)'0'; }
            if (esign) r4 = -r4;
            r1 *= Math.Pow(10,r4);
        }
        value = r1;
        return this;
    }
}