Recursive Lambda with Fixed Point Generator

Reading Mads Torgersen old blog post on Recursive Lambda Expressions, I decided it was time for me to seriously play with his code and try out the fixed point generator to create recursive lambda expressions (together with the fact that I was sick and felt bored).

Taking lessons from that blog post, I created a reusable fixed point generator which we can use for anything that uses recursion. Here's the code, simply.

   1:  public static Func<T, T> Fix<T>(Func<Func<T, T>, Func<T, T>> F)
   2:  {
   3:     return x => F(Fix<T>(F))(x);
   4:  }
   5:   
   6:  public static Func<T, T, T> Fix<T>(Func<Func<T, T, T>, Func<T, T, T>> F)
   7:  {
   8:     return (x, n) => F(Fix<T>(F))(x, n);
   9:  }
  10:   
  11:  public static Func<T1, T2, T1> Fix<T1, T2>(Func<Func<T1, T2, T1>, Func<T1, T2, T1>> F)
  12:  {
  13:     return (x, n) => F(Fix<T1, T2>(F))(x, n);
  14:  }
  15:   
  16:  public static Func<T, T, T, T> Fix<T>(Func<Func<T, T, T, T>, Func<T, T, T, T>> F)
  17:  {
  18:     return (x, n, k) => F(Fix<T>(F))(x, n, k);
  19:  }

Static Fix methods are the actual Fixed Point Generator as described in Mads' blog. This simplifies the code and makes it reusable. The method at lines 11-14 shows how 2 different input can be used. I will be using this method for the sine and cosine lambda expressions I've written.

   1:  Func<double, double> factorial = Fix<double>(fac => x => x == 0 ? 1 : x * fac(x - 1));
   2:  Func<double, int, double> sine = Fix<double, int>(sin => (x, n) => n == 0 ? x : 
   3:      sin(x, n - 1) + Math.Pow(-1, n) * Math.Pow(x, 2 * n + 1) / factorial(2 * n + 1));
   4:  Func<double, int, double> cosine = Fix<double, int>(cos => (x, n) => n == 0 ? 1 : 
   5:      cos(x, n - 1) + Math.Pow(-1, n) * Math.Pow(x, 2 * n) / factorial(2 * n));

The factorial lambda expression is the same as in Mads' blog. I've created both sine and cosine lambda expressions learning from how the fixed point generator works. I have to keep factorial as double instead of int because it'll make the precision wrong.

I used the Taylor Series in order to generate the sine and cosine function. x is the angle in radians, and n is the number of recursion to do (i.e. the more recursion, the more precision).

The basic recursion is as follows:

So that's that! Plug in your lambda expression into the Fix static method and you're done, you've got recursion.

Further testing out whether if it actually works, here's a simple testing code:

   1:  for (int i = 0; i < 20; i++)
   2:  {
   3:     Console.WriteLine(factorial(i));
   4:  }
   5:   
   6:  Console.WriteLine(sine(Math.PI / 4, 10));
   7:  Console.WriteLine(Math.Sin(Math.PI / 4));
   8:   
   9:  Console.WriteLine(cosine(Math.PI / 3, 10));
  10:  Console.WriteLine(Math.Cos(Math.PI / 3));
  11:  Console.ReadKey();

Here, what I do is I check my sine and cosine output with the actual Math.Sin and Math.Cos methods from the framework. It looks like it works well with n = 10 or higher, achieving the same precision as the framework.

That's that. I will play around with more of this, and create more methods out of this.

I tried generalizing the method itself to make it look better and easier to read, but the limits of Generics in C# stopped me from doing anything further. Here's what I tried to do, but failed of course.

   1:  // I need a constraint operator- to make this work, but Generics does not support this
   2:  public static Func<T, T> Factorial<T>() where T : struct, IEquatable<T>, operator-
   3:  {         
   4:      return Fix<T>(fac => x => x.Equals(0) ? 1 : x * fac(x - 1));
   5:  }

If that was successful, then the code would have been reduced to simply like this.

   1:  Factorial(5)

Doesn't that look better? If only, but there must be come other way to do this.