Avoid branching code for degenerate cases in Fibonacci generator I was writing a simple function that would return the Fibonacci sequence up to the nth term and for whatever reason started wasting a lot of time on it. Here's what I came up with:

static IEnumerable&lt;int&gt; Fibonacci(int n)
{
    int last = 0, 
        oneBefore = 0;

    if (n &gt; 0) yield return oneBefore = 0;
    if (n &gt; 1) yield return last = 1;
    if (n &gt; 2)
    {
        while (n-- - 2 &gt; 0)
        {
            yield return last = oneBefore + (oneBefore = last);
        }
    }
}


This is pretty close to what I want, but it has those three ugly if branches at the top level. Initially, I was trying to do something like this for the 0 and 1 case:

yield return (new[] { 0, 1 }).Take(n);


So that it would nicely handle cases where n was 0, 1 or greater. Unfortunately C# doesn't allow mixing of returning complete enumerables with yield statements, so that didn't work.

So here are my questions for what I want to improve:


Is there a way I can avoid the if branches there and somehow elegantly and concisely deal with both degenerate cases?
Is there a way I can avoid having that variable initialization statement at the beginning of the function, or even better, avoid having to keep the two variables at all?
Consider breaking it up into two methods: one, Fibonacci(), that represents the infinite* Fibonacci sequence, and another, Fibonacci(int), that just returns Fibonacci().Take(n). This removes the branching.

An implementation might look like this:

static IEnumerable&lt;int&gt; Fibonacci(int n)
{
    return Fibonacci().Take(n);
}

static IEnumerable&lt;int&gt; Fibonacci()
{
    int a = 0;
    int b = 1;
    while (true)
    {
        yield return a;
        int c = a + b;
        a = b;
        b = c;
    }
}


* Well, the first 47 values that fit in an int.