[Exercise] Fibonacci sequence

I am revisiting these old threads and trying my hand at some of them in Perl6 for fun
This would be

> ( 0,1, {$^a+$^b} ... Inf )[100].say;
354224848179261915075

I could still shave off a dozen characters off of that... but this is not an golf contest :-)

using System;
using System.Collections.Generic;
using System.Numerics;

namespace tmp2
{
    class Program
    {
        static void Main(string[] args)
        {
            using (System.IO.FileStream fs = new System.IO.FileStream
                (System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop),"Fiblog.txt")
                , System.IO.FileMode.Create))
            using (System.IO.StreamWriter sw = new System.IO.StreamWriter(fs))
            {
                Console.SetOut(sw);
                foreach (BigInteger someint in Fibonacci(100))
                    Console.WriteLine(someint);
            }
        }

        static IEnumerable<BigInteger> Fibonacci(int limit)
        {
            int counter = 1;
            BigInteger current = 1;
            BigInteger previous = 1;
            yield return 1;
            while (counter < limit)
            {
                yield return current;
                BigInteger next = current + previous;
                previous = current;
                current = next;
                counter++;
            }
        }
    }
}

won't get any better than this, its Fibonacci with internal state utilizing bigInteger in the system.numerics name space (the bound of the number is theoretically the computer RAM = numbers can get astronomically huge), plus it uses Lazy enumeration which does have some benefits, particularly if you are dealing with very large quantities of information. Lazy enumeration makes it possible to start processing data as soon as the first item becomes available.
It's written by me, hope it's be helpfull

my new approach trying to retrieve the first 1k-digit Fibonacci number, it looks like this for f(100). It could compute f(100000) in less than 4seconds, recursion is not the best implementation for this exercice

f=[0]
i=0
while True:
    i+=1
    if i==1:
        f.append(1)
    elif i==2:
        f.append(1)
    else:
        f.append(f[i-1]+f[i-2])
    if len(f)==101:
        break
print f[i]

import java.math.*;
public class Main {
  public static void main(String [] args){
    System.out.print("the number is:"+fab(100));
  } 
  public static String fab(int number){
    BigDecimal a= new BigDecimal("0");
    BigDecimal[] fb= new BigDecimal[2];
    fb[0]=new BigDecimal("0");
    fb[1]=new BigDecimal("1");
    if (number == 1){
      return "1";
    }
    else{
      for(int i=1;i<number;i++){
        a=fb[0].add(fb[1]);
        fb[0]=fb[1];
        fb[1]=a;
      }
      return a.toString();
    }
  }
}

Java.
i had a problem with precision so i used "BigDecimal" to solve it,now the program gives exact results in form of strings(i can change that but since the only purpose here is printing so a string is fine),and i added the if statement since fab(1) was returning 0 (instead of 1),so now it's bugs free and precision perfect,the method can be used in other programs as well.it's pretty fast too,calculating fab(100) in 1 to 2 ms and fab(1000) in 4 to 5 ms.

li=[0,1]
while True:
    n=li[-2]+li[-1]
    li.append(n)
    if len(li)==101:
        break	

print li[-1]

I've checked other people's posts but wanted to share mine as I first wrote it before checking the solutions. I can see that I did a few unnecessary stuff.

#!/usr/bin/python
def fibbo():
	for i in xrange(0,100):
        i=??????????
        yield i

for i in fibbo():
	print i

Okay now I guess this is list-less, but I have to figure out what to put in there, or maybe it's just plain impossible this way.
Trying ...

I stole this one from Stackoverflow after understanding it. It doesn't contain lists, but it's too slow.

def F(n):
    if n == 0: return 0
    elif n == 1: return 1
    else: return F(n-1)+F(n-2)

print F(100)

And how about switching from list to tuple ?
I'll have to continue reading more documentations after I finish with schoolwork. But for now I'm trying to see what I can do with what I already know, and do some research for something when it's needed. I also read your answer on the other topic.

Many, many thanks to you and to NuclearVision, your help is really significant !

Posts of mine is missing, at least one.
@adnan your f(n) function, the slow one, uses a simple recursion.
It's slow because for f(n) it will store "big formulae to calculate " in the memory starting from the unkown f(n) and decrementing n, all the formulas that the compiler calculates only contains f(0) and f(1) (which are defined) or formulas leading to f(0) and f(1) and finally your f(n) will be returned.