// File RTCG5.cs --- evaluation of polynomials 
// sestoft@itu.dk * 2002

// Mobile Intel P3: The specialized code is faster even for
// polynomials of degree 5, and even though the function must be
// called through a delegate.

// AMD Athlon (1st generation): The specialized code is faster only
// for degree 12 and higher.

using System;
using System.Reflection;
using System.Reflection.Emit;

class RTCG5 {
  public static void Main(String [] args) {
    int order = args.Length-1;
    double[] cs = new double[order];
    for (int i=0; i<order; i++)
      cs[i] = double.Parse(args[i]);
    int count = int.Parse(args[order]);

    AssemblyName assemblyName = new AssemblyName();
    assemblyName.Name = "myassembly";
    // Build: run-only assembly
    AssemblyBuilder assemblyBuilder = 
      AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName,
                                                    AssemblyBuilderAccess.Run);
    // Build: module mymodule
    ModuleBuilder moduleBuilder = 
      assemblyBuilder.DefineDynamicModule("mymodule");
    // Build: public class MyClass { ... }
    TypeBuilder typeBuilder = 
      moduleBuilder.DefineType("MyClass", 
                               TypeAttributes.Class | TypeAttributes.Public, 
                               typeof(Object));
    {
      // Build: public static double MyEval(double x) { ... }
      MethodBuilder methodBuilder =
        typeBuilder.DefineMethod("MyEval", 
                                 MethodAttributes.Static | MethodAttributes.Public,
                                 typeof(double),
                                 new Type[] { typeof(double) });
      // Obtain an IL generator to build the method body
      ILGenerator ilg = methodBuilder.GetILGenerator();
      EvalGen(ilg, cs);
    }
    Type ty = typeBuilder.CreateType();
    double eps = 2.0/count;
    double res = 0.0;

    D2D eval_cs = (D2D)Delegate.CreateDelegate(typeof(D2D), 
                                               ty.GetMethod("MyEval"));
    Timer t1 = new Timer();
    for (double x=0; x < 2; x += eps)
      res += eval_cs(x);
    Console.WriteLine("Delegate call to specialized generated method: " 
                      + t1.Check() + " sec");
    Console.WriteLine(res);

    res = 0.0;
    Timer t2 = new Timer();
    for (double x=0; x < 2; x += eps)
      res += Eval(cs, x);
    Console.WriteLine("Static call to general compiled method: " 
                      + t2.Check() + " sec");
    Console.WriteLine(res);
  }

  // Evaluate polynomial cs[0] + cs[1] * x + cs[2] * x^2 + ...

  public static double Eval(double[] cs, double x) {
    double res = 0.0;
    for (int i=cs.Length-1; i>=0; i--) 
      res = res * x + cs[i];
    return res;
  }

  public static void EvalGen(ILGenerator ilg, double[] cs) { // x is arg_0
    ilg.Emit(OpCodes.Ldc_R8, 0.0);		// push res on stack
    for (int i=cs.Length-1; i>=0; i--) {
      ilg.Emit(OpCodes.Ldarg_0);		// load x
      ilg.Emit(OpCodes.Mul);			// compute res * x
      if (cs[i] != 0.0) {
	ilg.Emit(OpCodes.Ldc_R8, cs[i]);	// load cs[i]
	ilg.Emit(OpCodes.Add);			// compute x * res + cs[i]
      }
    }
    ilg.Emit(OpCodes.Ret);			// return res;
  }

  public delegate double D2D(double x);
}

// Crude timing utility ----------------------------------------
   
public class Timer {
  private DateTime start;

  public Timer() {
    start = DateTime.Now;
  }

  public double Check() {
    TimeSpan dur = DateTime.Now - start;
    return dur.TotalSeconds;
  }
}