Fibonacci sequence: Difference between revisions

Content added Content deleted

Inline

Revision as of 10:28, 2 May 2024

The Fibonacci sequence is a sequence F_n of natural numbers defined recursively:

      F₀ = 0 
      F₁ = 1 
      F_n = F_n-1 + F_n-2, if n>1

Task

Write a function to generate the n^th Fibonacci number.

Solutions can be iterative or recursive (though recursive solutions are generally considered too slow and are mostly used as an exercise in recursion).

The sequence is sometimes extended into negative numbers by using a straightforward inverse of the positive definition:

      F_n = F_n+2 - F_n+1, if n<0

support for negative n in the solution is optional.

Related tasks

References

0815

%<:0D:>~$<:01:~%>=<:a94fad42221f2702:>~>
}:_s:{x{={~$x+%{=>~>x~-x<:0D:~>~>~^:_s:?

11l

Translation of: Python

F fib_iter(n)
   I n < 2
      R n
   V fib_prev = 1
   V fib = 1
   L 2 .< n
      (fib_prev, fib) = (fib, fib + fib_prev)
   R fib

L(i) 1..20
   print(fib_iter(i), end' ‘ ’)
print()

Output:

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

360 Assembly

For maximum compatibility, programs use only the basic instruction set.

using fullword integers

*        Fibonacci sequence    05/11/2014
*        integer (31 bits) = 10 decimals -> max fibo(46)
FIBONACC CSECT
         USING FIBONACC,R12    base register
SAVEAREA B     STM-SAVEAREA(R15) skip savearea
         DC    17F'0'          savearea
         DC    CL8'FIBONACC'   eyecatcher
STM      STM   R14,R12,12(R13) save previous context
         ST    R13,4(R15)      link backward
         ST    R15,8(R13)      link forward
         LR    R12,R15         set addressability
*        ----
         LA    R1,0            f(n-2)=0
         LA    R2,1            f(n-1)=1
         LA    R4,2            n=2 
         LA    R6,1            step
         LH    R7,NN           limit
LOOP     EQU   *               for n=2 to nn
         LR    R3,R2             f(n)=f(n-1)
         AR    R3,R1             f(n)=f(n-1)+f(n-2)
         CVD   R4,PW             n  convert binary to packed (PL8)
         UNPK  ZW,PW             packed (PL8) to zoned (ZL16)
         MVC   CW,ZW             zoned (ZL16) to  char (CL16)
         OI    CW+L'CW-1,X'F0'   zap sign
         MVC   WTOBUF+5(2),CW+14 output
         CVD   R3,PW             f(n) binary to packed decimal (PL8)
         MVC   ZN,EM             load mask
         ED    ZN,PW             packed dec (PL8) to char (CL20)
         MVC   WTOBUF+9(14),ZN+6 output
         WTO   MF=(E,WTOMSG)     write buffer
         LR    R1,R2             f(n-2)=f(n-1)
         LR    R2,R3             f(n-1)=f(n)
         BXLE  R4,R6,LOOP      endfor n
*        ----
         LM    R14,R12,12(R13) restore previous savearea pointer
         XR    R15,R15         return code set to 0
         BR    R14             return to caller
*        ----  DATA
NN       DC    H'46'           nn max n
PW       DS    PL8             15num
ZW       DS    ZL16
CW       DS    CL16
ZN       DS    CL20
*                  ' b 0 0 0 , 0 0 0 , 0 0 0 , 0 0 0 , 0 0 0'  15num
EM       DC    XL20'402020206B2020206B2020206B2020206B202120'  mask
WTOMSG   DS    0F
         DC    H'80',XL2'0000'
*                   fibo(46)=1836311903         
WTOBUF   DC    CL80'fibo(12)=1234567890'
         REGEQU
         END   FIBONACC

Output:

...
fibo(41)=   165,580,141
fibo(42)=   267,914,296
fibo(43)=   433,494,437
fibo(44)=   701,408,733
fibo(45)= 1,134,903,170
fibo(46)= 1,836,311,903

using packed decimals

*        Fibonacci sequence        31/07/2018
*        packed dec (PL8) = 15 decimals => max fibo(73)
FIBOWTOP CSECT
         USING  FIBOWTOP,R13       base register
         B      72(R15)            skip savearea
         DC     17F'0'             savearea
         SAVE   (14,12)            save previous context
         ST     R13,4(R15)         link backward
         ST     R15,8(R13)         link forward
         LR     R13,R15            set addressability
*        ----
         ZAP    FNM2,=P'0'         f(0)=0
         ZAP    FNM1,=P'1'         f(1)=1
         LA     R4,2               n=2 
         LA     R6,1               step
         LH     R7,NN              limit
LOOP     EQU    *                  for n=2 to nn
         ZAP    FN,FNM1              f(n)=f(n-2)
         AP     FN,FNM2              f(n)=f(n-1)+f(n-2)
         CVD    R4,PW                n 
         MVC    ZN,EM                load mask
         ED     ZN,PW                packed dec (PL8) to char (CL16)
         MVC    WTOBUF+5(2),ZN+L'ZN-2  output
         MVC    ZN,EM                load mask
         ED     ZN,FN                packed dec (PL8) to char (CL16)
         MVC    WTOBUF+9(L'ZN),ZN        output
         WTO    MF=(E,WTOMSG)        write buffer
         ZAP    FNM2,FNM1            f(n-2)=f(n-1)
         ZAP    FNM1,FN              f(n-1)=f(n)
         BXLE   R4,R6,LOOP         endfor n
*        ----
         L      R13,4(0,R13)       restore previous savearea pointer
         RETURN (14,12),RC=0       restore registers from calling sav
*        ----   DATA
NN       DC     H'73'              nn
FNM2     DS     PL8                f(n-2)
FNM1     DS     PL8                f(n-1)
FN       DS     PL8                f(n)
PW       DS     PL8                15num
ZN       DS     CL20
*                   ' b 0 0 0 , 0 0 0 , 0 0 0 , 0 0 0 , 0 0 0'  15num
EM       DC     XL20'402020206B2020206B2020206B2020206B202120'  mask
WTOMSG   DS     0F
         DC     H'80',XL2'0000'
*                    fibo(73)=806515533049393
WTOBUF   DC     CL80'fibo(12)=123456789012345 '
         REGEQU  
         END    FIBOWTOP

Output:

...
fibo(68)=  72,723,460,248,141
fibo(69)= 117,669,030,460,994
fibo(70)= 190,392,490,709,135
fibo(71)= 308,061,521,170,129
fibo(72)= 498,454,011,879,264
fibo(73)= 806,515,533,049,393

This subroutine stores the first n—by default the first ten—Fibonacci numbers in memory, beginning (because, why not?) at address 3867 decimal = F1B hex. Intermediate results are stored in three sequential addresses within the low 256 bytes of memory, which are the most economical to access.

The results are calculated and stored, but are not output to the screen or any other physical device: how to do that would depend on the hardware and the operating system.

       LDA  #0
       STA  $F0     ; LOWER NUMBER
       LDA  #1
       STA  $F1     ; HIGHER NUMBER
       LDX  #0
LOOP:  LDA  $F1
       STA  $0F1B,X
       STA  $F2     ; OLD HIGHER NUMBER
       ADC  $F0
       STA  $F1     ; NEW HIGHER NUMBER
       LDA  $F2
       STA  $F0     ; NEW LOWER NUMBER
       INX
       CPX  #$0A    ; STOP AT FIB(10)
       BMI  LOOP
       RTS          ; RETURN FROM SUBROUTINE

68000 Assembly

Translation of: ARM Assembly

Input is in D0, and the output is also in D0. There is no protection from 32-bit overflow, so use at your own risk. (I used this C compiler to create this in ARM Assembly and translated it manually into 68000 Assembly. It wasn't that difficult since both CPUs have similar architectures.)

fib:
	MOVEM.L D4-D5,-(SP)
		MOVE.L D0,D4
		MOVEQ #0,D5
		CMP.L #2,D0
		BCS .bar
		MOVEQ #0,D5
.foo:
		MOVE.L D4,D0
		SUBQ.L #1,D0
		JSR fib
		SUBQ.L #2,D4
		ADD.L D0,D5
		CMP.L #1,D4
		BHI .foo
.bar:
		MOVE.L D5,D0
		ADD.L D4,D0
	MOVEM.L (SP)+,D4-D5
	RTS

8080 Assembly

This subroutine expects to be called with the value of $n$ in register A, and returns $f(n)$ also in A. You may want to take steps to save the previous contents of B, C, and D. The routine only works with fairly small values of $n$ .

FIBNCI: MOV  C,  A  ; C will store the counter
        DCR  C      ; decrement, because we know f(1) already
        MVI  A,  1
        MVI  B,  0
LOOP:   MOV  D,  A
        ADD  B      ; A := A + B
        MOV  B,  D
        DCR  C
        JNZ  LOOP   ; jump if not zero
        RET         ; return from subroutine

The range may be easily be extended from the 13th (=233) to the 24th (=46368) Fibonacci number with 16-bit addition using DAD. The code here assumes the CP/M operating system.

	;-------------------------------------------------------
	; useful equates
	;-------------------------------------------------------
bdos	equ 	5	; BDOS entry 
cr	equ 	13	; ASCII carriage return
lf	equ 	10	; ASCII line feed
space	equ	32	; ASCII space char
conout	equ 	2	; BDOS console output function
putstr	equ	9	; BDOS print string function
nterms	equ	20	; number of terms (max=24) to display
	;-------------------------------------------------------
	; main code begins here
	;-------------------------------------------------------
	org	100h
	lxi	h,0		; save CP/M's stack
	dad	sp
	shld	oldstk
	lxi	sp,stack	; set our own stack
	lxi	d,signon	; print signon message
	mvi	c,putstr
	call	bdos
	mvi 	a,0		; start with Fib(0)
mloop:	push	a		; save our count	
	call 	fib
	call	putdec
	mvi	a,space		; separate the numbers
	call	putchr
	pop	a		; get our count back
	inr	a		; increment it
	cpi	nterms+1	; have we reached our limit?
	jnz	mloop		; no, keep going
	lhld	oldstk		; all done; get CP/M's stack back
	sphl			; restore it
	ret			; back to command processor
	;-------------------------------------------------------
	;  calculate nth Fibonacci number (max n = 24)
	;  entry: A = n 
	;  exit:  HL = Fib(n)
	;-------------------------------------------------------
fib:	mov 	c,a	; C holds n
	lxi 	d,0	; DE holds Fib(n-2)
	lxi 	h,1	; HL holds Fib(n-1)
	ana	a	; Fib(0) is a special case
	jnz	fib2	; n > 0 so calculate normally
	xchg		; otherwise return with HL=0
	ret
fib2:	dcr	c
	jz	fib3	; we're done
	push 	h	; save Fib(n-1)
	dad 	d	; HL = Fib(n), soon to be Fib(n-1) 
	pop 	d	; DE = old F(n-1), now Fib(n-2)
	jmp 	fib2	; ready for next pass
fib3:	ret
	;-------------------------------------------------------
	; console output of char in A register
	;-------------------------------------------------------
putchr:	push	h
	push	d
	push	b
	mov	e,a
	mvi	c,conout
	call	bdos
	pop	b
	pop	d
	pop	h
	ret
	;---------------------------------------------------------
	; Output decimal number to console
	; HL holds 16-bit unsigned binary number to print
	;---------------------------------------------------------
putdec: push	b
	push	d
	push	h
	lxi	b,-10
	lxi	d,-1
putdec2:
	dad	b
	inx	d
	jc	putdec2
	lxi	b,10
	dad	b
	xchg
	mov	a,h
	ora	l
	cnz	putdec		; recursive call
	mov	a,e
	adi	'0'
	call	putchr
	pop	h
	pop	d
	pop	b
	ret
	;-------------------------------------------------------
	; data area
	;-------------------------------------------------------
signon: db	'Fibonacci number sequence:',cr,lf,'$'
oldstk:	dw	0
stack	equ	$+128		; 64-level stack
	;
	end

Output:

Fibonacci number sequence:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

8086 Assembly

Calculating the values at runtime

Is it cheating to write it in C for 64-bit x86 then port it to 16-bit x86?

The max input is 24 before you start having 16-bit overflow.

fib:
; 	WRITTEN IN C WITH X86-64 CLANG 3.3 AND DOWNGRADED TO 16-BIT X86
; 	INPUT: DI = THE NUMBER YOU WISH TO CALC THE FIBONACCI NUMBER FOR.
;	OUTPUTS TO AX
                                 
        push    BP
        push    BX
        push    AX
        mov     BX, DI			;COPY INPUT TO BX
        xor     AX, AX			;MOV AX,0
        test    BX, BX			;SET FLAGS ACCORDING TO BX
        je      LBB0_4			;IF BX == 0 RETURN 0
        cmp     BX, 1			;IF BX == 1 RETURN 1
        jne     LBB0_3
        mov     AX, 1			;ELSE, SET AX = 1 AND RETURN
        jmp     LBB0_4
LBB0_3:
        lea     DI, WORD PTR [BX - 1]   ;DI = BX - 1
        call    fib			;RETURN FIB(BX-1)
        mov     BP, AX			;STORE THIS IN BP
        add     BX, -2
        mov     DI, BX	
        call    fib			;GET FIB(DI - 2)
        add     AX, BP		        ;RETURN FIB(DI - 1) + FIB(DI - 2)
LBB0_4:

	add sp,2
        pop     BX
        pop     BP
        ret

Using A Lookup Table

With old computers it was common to use lookup tables to fetch pre-calculated values that would otherwise take some time to compute. The elements of the table are ordered by index, so you can simply create a function that takes an offset as the parameter and returns the element of the array at that offset.

Although lookup tables are very fast, there are some drawbacks to using them. For one, you end up taking up a lot of space. We're wasting a lot of bytes to store very low numbers at the beginning (each takes up 4 bytes regardless of how many digits you see). Unfortunately, when using lookup tables you have very little choice, since trying to conditionally change the scaling of the index would more than likely take more code than encoding all data as the maximum size regardless of the contents, as was done here. This keeps it simple for the CPU, which isn't aware of the intended size of each entry of the table.

For the purpose of this example, assume that both this code and the table are in the .CODE segment.

getfib:
;input: BX = the desired fibonacci number (in other words, the "n" in "F(n)")
;       DS must point to the segment where the fibonacci table is stored
;outputs to DX:AX (DX = high word, AX = low word)
  push ds
    cmp bx,41  ;bounds check
    ja IndexOutOfBounds
    shl bx,1
    shl bx,1 ;multiply by 4, since this is a table of dwords
    mov ax,@code
    mov ds,ax
    mov si,offset fib
    mov ax,[ds:si]    ;fetch the low word into AX
    mov dx,2[ds:si]   ;fetch the high word into DX
  pop ds
  ret


IndexOutOfBounds:
     stc             ;set carry to indicate an error
     mov ax,0FFFFh   ;return FFFF as the error code
   pop ds
   ret

;table of the first 41 fibonacci numbers
fib dword 0, 1, 1, 2, 3, 5, 8, 13 
    dword 21, 34, 55, 89, 144, 233, 377, 610
    dword 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657
    dword 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269
    dword 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986
    dword 102334155

8th

An iterative solution:

: fibon \ n -- fib(n)
  >r 0 1 
  ( tuck n:+ ) \ fib(n-2) fib(n-1) -- fib(n-1) fib(n)
  r> n:1- times ;

: fib \ n -- fib(n)
  dup 1 n:= if 1 ;; then
  fibon nip ;

ABAP

Iterative

FORM fibonacci_iter USING index TYPE i
                    CHANGING number_fib TYPE i.
  DATA: lv_old type i,
        lv_cur type i.
  Do index times.
    If sy-index = 1 or sy-index = 2.
      lv_cur = 1.
      lv_old = 0.
    endif.
    number_fib = lv_cur + lv_old.
    lv_old = lv_cur.
    lv_cur = number_fib.
  enddo.
ENDFORM.

Impure Functional

Works with: ABAP version 7.4 SP08 Or above only

cl_demo_output=>display( REDUCE #( INIT fibnm = VALUE stringtab( ( |0| ) ( |1| ) )
                                        n TYPE string
                                        x = `0`
                                        y = `1`
                                      FOR i = 1 WHILE i <= 100
                                     NEXT n = ( x + y )
                                          fibnm = VALUE #( BASE fibnm ( n ) )
                                          x = y
                                          y = n ) ).

ACL2

Fast, tail recursive solution:

(defun fast-fib-r (n a b)
   (if (or (zp n) (zp (1- n)))
       b
       (fast-fib-r (1- n) b (+ a b))))

(defun fast-fib (n)
   (fast-fib-r n 1 1))

(defun first-fibs-r (n i)
   (declare (xargs :measure (nfix (- n i))))
   (if (zp (- n i))
       nil
       (cons (fast-fib i)
             (first-fibs-r n (1+ i)))))

(defun first-fibs (n)
   (first-fibs-r n 0))

Output:

>(first-fibs 20)
(1 1 2 3 5 8 13 21 34 55 89
   144 233 377 610 987 1597 2584 4181 6765)

Action!

Action! language does not support recursion. Therefore an iterative approach has been proposed.

INT FUNC Fibonacci(INT n)
  INT curr,prev,tmp

  IF n>=-1 AND n<=1 THEN
    RETURN (n)
  FI

  prev=0
  IF n>0 THEN
    curr=1
    DO
      tmp=prev
      prev=curr
      curr==+tmp
      n==-1
    UNTIL n=1
    OD
  ELSE
    curr=-1
    DO
      tmp=prev
      prev=curr
      curr==+tmp
      n==+1
    UNTIL n=-1
    OD
  FI
RETURN (curr)

PROC Main()
  BYTE n
  INT f

  Put(125) ;clear screen

  FOR n=0 TO 22
  DO
    f=Fibonacci(n)
    Position(2,n+1)
    PrintF("Fib(%I)=%I",n,f)

    IF n>0 THEN
      f=Fibonacci(-n)
      Position(21,n+1)
      PrintF("Fib(%I)=%I",-n,f)
    FI
  OD
RETURN

Output:

Screenshot from Atari 8-bit computer

Fib(0)=0
Fib(1)=1           Fib(-1)=-1
Fib(2)=1           Fib(-2)=-1
Fib(3)=2           Fib(-3)=-2
Fib(4)=3           Fib(-4)=-3
Fib(5)=5           Fib(-5)=-5
Fib(6)=8           Fib(-6)=-8
Fib(7)=13          Fib(-7)=-13
Fib(8)=21          Fib(-8)=-21
Fib(9)=34          Fib(-9)=-34
Fib(10)=55         Fib(-10)=-55
Fib(11)=89         Fib(-11)=-89
Fib(12)=144        Fib(-12)=-144
Fib(13)=233        Fib(-13)=-233
Fib(14)=377        Fib(-14)=-377
Fib(15)=610        Fib(-15)=-610
Fib(16)=987        Fib(-16)=-987
Fib(17)=1597       Fib(-17)=-1597
Fib(18)=2584       Fib(-18)=-2584
Fib(19)=4181       Fib(-19)=-4181
Fib(20)=6765       Fib(-20)=-6765
Fib(21)=10946      Fib(-21)=-10946
Fib(22)=17711      Fib(-22)=-17711

ActionScript

public function fib(n:uint):uint
{
    if (n < 2)
        return n;
    
    return fib(n - 1) + fib(n - 2);
}

Ada

Recursive

with Ada.Text_IO, Ada.Command_Line;

procedure Fib is

   X: Positive := Positive'Value(Ada.Command_Line.Argument(1));

   function Fib(P: Positive) return Positive is
   begin
      if P <= 2 then
         return 1;
      else
         return Fib(P-1) + Fib(P-2);
      end if;
   end Fib;

begin
   Ada.Text_IO.Put("Fibonacci(" & Integer'Image(X) & " ) = ");
   Ada.Text_IO.Put_Line(Integer'Image(Fib(X)));
end Fib;

Iterative, build-in integers

with Ada.Text_IO;  use Ada.Text_IO;

procedure Test_Fibonacci is
   function Fibonacci (N : Natural) return Natural is
      This : Natural := 0;
      That : Natural := 1;
      Sum  : Natural;
   begin
      for I in 1..N loop
         Sum  := This + That;
         That := This;
         This := Sum;
      end loop;
      return This;
   end Fibonacci;
begin
   for N in 0..10 loop
      Put_Line (Positive'Image (Fibonacci (N)));
   end loop;
end Test_Fibonacci;

Output:

Iterative, long integers

Using the big integer implementation from a cryptographic library [1].

with Ada.Text_IO, Ada.Command_Line, Crypto.Types.Big_Numbers;

procedure Fibonacci is

   X: Positive := Positive'Value(Ada.Command_Line.Argument(1));

   Bit_Length: Positive := 1 + (696 * X) / 1000;
   -- that number of bits is sufficient to store the full result.

   package LN is new Crypto.Types.Big_Numbers
     (Bit_Length + (32 - Bit_Length mod 32));
     -- the actual number of bits has to be a multiple of 32
   use LN;

   function Fib(P: Positive) return Big_Unsigned is
      Previous: Big_Unsigned := Big_Unsigned_Zero;
      Result:   Big_Unsigned := Big_Unsigned_One;
      Tmp:      Big_Unsigned;
   begin
      -- Result = 1 = Fibonacci(1)
      for I in 1 .. P-1 loop
         Tmp := Result;
         Result := Previous + Result;
         Previous := Tmp;
         -- Result = Fibonacci(I+1))
      end loop;
      return Result;
   end Fib;

begin
   Ada.Text_IO.Put("Fibonacci(" & Integer'Image(X) & " ) = ");
   Ada.Text_IO.Put_Line(LN.Utils.To_String(Fib(X)));
end Fibonacci;

Output:

> ./fibonacci 777
Fibonacci( 777 ) = 1081213530912648191985419587942084110095342850438593857649766278346130479286685742885693301250359913460718567974798268702550329302771992851392180275594318434818082

Fast method using fast matrix exponentiation

with ada.text_io;
use  ada.text_io;

procedure fast_fibo is 
	-- We work with biggest natural integers in a 64 bits machine 
	type Big_Int is mod 2**64;

	-- We provide an index type for accessing the fibonacci sequence terms 
	type Index is new Big_Int;

	-- fibo is a generic function that needs a modulus type since it will return
	-- the n'th term of the fibonacci sequence modulus this type (use Big_Int to get the	
	-- expected behaviour in this particular task)
	generic
		type ring_element is mod <>;
		with function "*" (a, b : ring_element) return ring_element is <>;
		function fibo (n : Index) return ring_element;
	function fibo (n : Index) return ring_element is

		type matrix is array (1 .. 2, 1 .. 2) of ring_element;

		-- f is the matrix you apply to a column containing (F_n, F_{n+1}) to get 
		-- the next one containing (F_{n+1},F_{n+2})
		-- could be a more general matrix (given as a generic parameter) to deal with 
		-- other linear sequences of order 2
		f : constant matrix := (1 => (0, 1), 2 => (1, 1));

		function "*" (a, b : matrix) return matrix is
		(1 => (a(1,1)*b(1,1)+a(1,2)*b(2,1), a(1,1)*b(1,2)+a(1,2)*b(2,2)),
		 2 => (a(2,1)*b(1,1)+a(2,2)*b(2,1), a(2,1)*b(1,2)+a(2,2)*b(2,2)));

		function square (m : matrix) return matrix is (m * m);

		-- Fast_Pow could be non recursive but it doesn't really matter since
		-- the number of calls is bounded up by the size (in bits) of Big_Int (e.g 64)
		function fast_pow (m : matrix; n : Index) return matrix is
		(if n = 0 then (1 => (1, 0), 2 => (0, 1)) -- = identity matrix
		 elsif n mod 2 = 0 then square (fast_pow (m, n / 2)) 
		 else m * square (fast_pow (m, n / 2)));

	begin
		return fast_pow (f, n)(2, 1);
	end fibo;

	function Big_Int_Fibo is new fibo (Big_Int);
begin
	-- calculate instantly F_n with n=10^15 (modulus 2^64 )
	put_line (Big_Int_Fibo (10**15)'img);
end fast_fibo;

AdvPL

Recursive

#include "totvs.ch"
User Function fibb(a,b,n)
return(if(--n>0,fibb(b,a+b,n),a))

Iterative

#include "totvs.ch"
User Function fibb(n) 
	local fnow:=0, fnext:=1, tempf
	while (--n>0)
		tempf:=fnow+fnext
		fnow:=fnext
		fnext:=tempf
	end while
return(fnext)

Agda

module FibonacciSequence where

open import Data.Nat using (ℕ ; zero ; suc ; _+_)

rec_fib : (m : ℕ) -> (a : ℕ) -> (b : ℕ) -> ℕ
rec_fib zero a b = a
rec_fib (suc k) a b = rec_fib k b (a + b)

fib : (n : ℕ) -> ℕ
fib n = rec_fib n zero (suc zero)

Aime

integer
fibs(integer n)
{
    integer w;

    if (n == 0) {
        w = 0;
    } elif (n == 1) {
        w = 1;
    } else {
        integer a, b, i;

        i = 1;
        a = 0;
        b = 1;
        while (i < n) {
            w = a + b;
            a = b;
            b = w;
            i += 1;
        }
    }

    return w;
}

ALGOL 60

Works with: A60

begin
    comment Fibonacci sequence;
    integer procedure fibonacci(n); value n; integer n;
    begin
        integer i, fn, fn1, fn2;
        fn2 := 1;
        fn1 := 0;
        fn  := 0;
        for i := 1 step 1 until n do begin
            fn  := fn1 + fn2;
            fn2 := fn1;
            fn1 := fn
        end;
        fibonacci := fn
    end fibonacci;
 
    integer i;
    for i := 0 step 1 until 20 do outinteger(1,fibonacci(i))
end

Output:

 0  1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181  6765

ALGOL 68

Analytic

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

PROC analytic fibonacci = (LONG INT n)LONG INT:(
  LONG REAL sqrt 5 = long sqrt(5);
  LONG REAL p = (1 + sqrt 5) / 2;
  LONG REAL q = 1/p;
  ROUND( (p**n + q**n) / sqrt 5 )
);

FOR i FROM 1 TO 30 WHILE
  print(whole(analytic fibonacci(i),0));
# WHILE # i /= 30 DO
  print(", ")
OD;
print(new line)

Output:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040

Iterative

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

PROC iterative fibonacci = (INT n)INT: 
  CASE n+1 IN
    0, 1, 1, 2, 3, 5
  OUT
    INT even:=3, odd:=5;
    FOR i FROM odd+1 TO n DO
      (ODD i|odd|even) := odd + even
    OD;
    (ODD n|odd|even)
  ESAC;

FOR i FROM 0 TO 30 WHILE
  print(whole(iterative fibonacci(i),0));
# WHILE # i /= 30 DO
  print(", ")
OD;
print(new line)

Output:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040

Recursive

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

PROC recursive fibonacci = (INT n)INT:
  ( n < 2 | n | fib(n-1) + fib(n-2));

Generative

Translation of: Python – Note: This specimen retains the original Python coding style.

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

MODE YIELDINT = PROC(INT)VOID;

PROC gen fibonacci = (INT n, YIELDINT yield)VOID: (
  INT even:=0, odd:=1;
  yield(even);
  yield(odd);
  FOR i FROM odd+1 TO n DO
    yield( (ODD i|odd|even) := odd + even )
  OD
);

main:(
  # FOR INT n IN # gen fibonacci(30, # ) DO ( #
  ##   (INT n)VOID:(
        print((" ",whole(n,0)))
  # OD # ));
    print(new line)
)

Output:

1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040

Array (Table) Lookup

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

This uses a pre-generated list, requiring much less run-time processor usage, but assumes that INT is only 31 bits wide.

[]INT const fibonacci = []INT( -1836311903, 1134903170,
  -701408733, 433494437, -267914296, 165580141, -102334155,
  63245986, -39088169, 24157817, -14930352, 9227465, -5702887,
  3524578, -2178309, 1346269, -832040, 514229, -317811, 196418,
  -121393, 75025, -46368, 28657, -17711, 10946, -6765, 4181,
  -2584, 1597, -987, 610, -377, 233, -144, 89, -55, 34, -21, 13,
  -8, 5, -3, 2, -1, 1, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89,
  144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711,
  28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040,
  1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817,
  39088169, 63245986, 102334155, 165580141, 267914296, 433494437,
  701408733, 1134903170, 1836311903
)[@-46];

PROC VOID value error := stop;

PROC lookup fibonacci = (INT i)INT: (
  IF LWB const fibonacci <= i AND i<= UPB const fibonacci THEN
    const fibonacci[i]
  ELSE
    value error; SKIP
  FI
);

FOR i FROM 0 TO 30 WHILE
  print(whole(lookup fibonacci(i),0));
# WHILE # i /= 30 DO
  print(", ")
OD;
print(new line)

Output:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040

ALGOL W

begin
    % return the nth Fibonacci number %
    integer procedure Fibonacci( integer value n ) ;
        begin
            integer fn, fn1, fn2;
            fn2 := 1;
            fn1 := 0;
            fn  := 0;
            for i := 1 until n do begin
                fn  := fn1 + fn2;
                fn2 := fn1;
                fn1 := fn
            end ;
            fn
        end Fibonacci ;

    for i := 0 until 10 do writeon( i_w := 3, s_w := 0, Fibonacci( i ) )

end.

Output:

  0  1  1  2  3  5  8 13 21 34 55

ALGOL-M

Note that the 21st Fibonacci number (= 10946) is the largest that can be calculated without overflowing ALGOL-M's integer data type.

Iterative

INTEGER FUNCTION FIBONACCI( X ); INTEGER X;
BEGIN
    INTEGER M, N, A, I;
    M := 0;
    N := 1;
    FOR I := 2 STEP 1 UNTIL X DO
    BEGIN
        A := N;
        N := M + N;
        M := A;
    END;
    FIBONACCI := N;
END;

Naively recursive

INTEGER FUNCTION FIBONACCI( X ); INTEGER X;
BEGIN
    IF X < 3 THEN
        FIBONACCI := 1
    ELSE
        FIBONACCI := FIBONACCI( X - 2 ) + FIBONACCI( X - 1 );
END;

Alore

def fib(n as Int) as Int
   if n < 2
      return 1
   end
   return fib(n-1) + fib(n-2)
end

Amazing Hopper

Analitic, Recursive and Iterative mode.

#include <hbasic.h>

#define TERM1    1.61803398874989
#define TERM2    -0.61803398874989

#context get Fibonacci number with analitic mode
  GetArgs(n) 
  get Inv of (M_SQRT5), Mul by( Pow (TERM 1, n), Minus( Pow(TERM 2, n) )  );
  then Return\\

#proto fibonacci_recursive(__X__)
#synon _fibonacci_recursive    getFibonaccinumberwithrecursivemodeof

#proto fibonacci_iterative(__X__)
#synon _fibonacci_iterative    getFibonaccinumberwithiterativemodeof

Begin
  Option Stack 1024

  get Arg Number(2, n), and Take( n );
  then, get Fibonacci number with analitic mode, and Print It with a Newl.
  secondly, get Fibonacci number with recursive mode of(n), and Print It with a Newl.
  finally, get Fibonacci number with iterative mode of (n), and Print It with a Newl.
End

Subrutines

fibonacci_recursive(n)
   Iif ( var(n) Is Le? (2), 1 , \
         get Fibonacci number with recursive mode of( var(n) Minus (1));\
         get Fibonacci number with recursive mode of( var(n) Minus (2)); and Add It )
Return

fibonacci_iterative(n)
  A=0
  B=1
  For Up( I:=2, n, 1 )
    C=B
    Let ( B: = var(A) Plus (B) )
    A=C
  Next
Return(B)

Output:

$ hopper src/fibo1.bas 25
75025
75025
75025

AntLang

/Sequence
fib:{<0;1> {x,<x[-1]+x[-2]>}/ range[x]}
/nth
fibn:{fib[x][x]}

Apex

/*
 author: snugsfbay
 date: March 3, 2016
 description: Create a list of x numbers in the Fibonacci sequence.
     - user may specify the length of the list 
     - enforces a minimum of 2 numbers in the sequence because any fewer is not a sequence
     - enforces a maximum of 47 because further values are too large for integer data type 
     - Fibonacci sequence always starts with 0 and 1 by definition
*/
public class FibNumbers{

final static Integer MIN = 2; //minimum length of sequence
final static Integer MAX = 47; //maximum length of sequence

/* 
  description: method to create a list of numbers in the Fibonacci sequence 
  param: user specified integer representing length of sequence should be 2-47, inclusive.
      - Sequence starts with 0 and 1 by definition so the minimum length could be as low as 2.
      - For 48th number in sequence or greater, code would require a Long data type rather than an Integer.
  return: list of integers in sequence.
*/
public static List<Integer> makeSeq(Integer len){

  List<Integer> fib = new List<Integer>{0,1}; // initialize list with first two values
  Integer i;
  
  if(len<MIN || len==null || len>MAX) {
      if (len>MAX){
          len=MAX; //set length to maximum if user entered too high a value
      }else{
          len=MIN; //set length to minimum if user entered too low a value or none
      }
  } //This could be refactored using teneray operator, but we want code coverage to be reflected for each condition
  
  //start with initial list size to find previous two values in the sequence, continue incrementing until list reaches user defined length
  for(i=fib.size(); i<len; i++){ 
    fib.add(fib[i-1]+fib[i-2]); //create new number based on previous numbers and add that to the list
  }

  return fib; 
  }
  
}

APL

Naive Recursive

Works with: Dyalog APL

fib←{⍵≤1:⍵ ⋄ (∇ ⍵-1)+∇ ⍵-2}

Read this as: In the variable "fib", store the function that says, if the argument is less than or equal to 1, return the argument. Else, calculate the value you get when you recursively call the current function with the argument of the current argument minus one and add that to the value you get when you recursively call the current function with the argument of the current function minus two.

This naive solution requires Dyalog APL because GNU APL does not support this syntax for conditional guards.

Array

Works with: Dyalog APL

Works with: GNU APL

Since APL is an array language we'll use the following identity:

{\begin{pmatrix}1&1\\1&0\end{pmatrix}}^{n}={\begin{pmatrix}F_{n+1}&F_{n}\\F_{n}&F_{n-1}\end{pmatrix}}.

In APL:

↑+.×/N/⊂2 2⍴1 1 1 0

Plugging in 4 for N gives the following result:

{\begin{pmatrix}5&3\\3&2\end{pmatrix}}

Here's what happens: We replicate the 2-by-2 matrix N times and then apply inner product-replication. The First removes the shell from the Enclose. At this point we're basically done, but we need to pick out only $F_{n}$ in order to complete the task. Here's one way:

↑0 1↓↑+.×/N/⊂2 2⍴1 1 1 0

Analytic

Works with: Dyalog APL

Works with: GNU APL

An alternative approach, using Binet's formula (which was apparently known long before Binet):

⌊.5+(((1+PHI)÷2)*⍳N)÷PHI←5*.5

AppleScript

Imperative

set fibs to {}
set x to (text returned of (display dialog "What fibbonaci number do you want?" default answer "3"))
set x to x as integer
repeat with y from 1 to x
	if (y = 1 or y = 2) then
		copy 1 to the end of fibs
	else
		copy ((item (y - 1) of fibs) + (item (y - 2) of fibs)) to the end of fibs
	end if
end repeat
return item x of fibs

Functional

The simple recursive version is famously slow:

on fib(n)
    if n < 1 then
        0
    else if n < 3 then
        1
    else
        fib(n - 2) + fib(n - 1)
    end if
end fib

but we can combine enumFromTo(m, n) with the accumulator of a higher-order fold/reduce function to memoize the series:

Translation of: JavaScript

(ES6 memoized fold example)

Translation of: Haskell

(Memoized fold example)

-------------------- FIBONACCI SEQUENCE --------------------

-- fib :: Int -> Int
on fib(n)
    
    -- lastTwo : (Int, Int) -> (Int, Int)
    script lastTwo
        on |λ|([a, b])
            [b, a + b]
        end |λ|
    end script
    
    item 1 of foldl(lastTwo, {0, 1}, enumFromTo(1, n))
end fib


--------------------------- TEST ---------------------------
on run
    
    fib(32)
    
    --> 2178309
end run

-------------------- GENERIC FUNCTIONS ---------------------

-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
    if m ≤ n then
        set lst to {}
        repeat with i from m to n
            set end of lst to i
        end repeat
        lst
    else
        {}
    end if
end enumFromTo

-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from 1 to lng
            set v to |λ|(v, item i of xs, i, xs)
        end repeat
        return v
    end tell
end foldl

-- Lift 2nd class handler function into 1st class script wrapper 
-- mReturn :: Handler -> Script
on mReturn(f)
    if class of f is script then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn

Output:

Arendelle

( fibonacci , 1; 1 )

[ 98 , // 100 numbers of fibonacci

	( fibonacci[ @fibonacci? ] ,

		@fibonacci[ @fibonacci - 1 ] + @fibonacci[ @fibonacci - 2 ]

	)

	"Index: | @fibonacci? | => | @fibonacci[ @fibonacci? - 1 ] |"
]

ARM Assembly

Expects to be called with $n$ in R0, and will return $f(n)$ in the same register.

fibonacci:
        push  {r1-r3}
        mov   r1,  #0
        mov   r2,  #1
        
fibloop:
        mov   r3,  r2
        add   r2,  r1,  r2
        mov   r1,  r3
        sub   r0,  r0,  #1
        cmp   r0,  #1
        bne   fibloop
        
        mov   r0,  r2
        pop   {r1-r3}
        mov   pc,  lr

ArnoldC

IT'S SHOWTIME

HEY CHRISTMAS TREE f1
YOU SET US UP @I LIED
TALK TO THE HAND f1

HEY CHRISTMAS TREE f2
YOU SET US UP @NO PROBLEMO

HEY CHRISTMAS TREE f3
YOU SET US UP @I LIED

STICK AROUND @NO PROBLEMO

GET TO THE CHOPPER f3
HERE IS MY INVITATION f1
GET UP f2
ENOUGH TALK
TALK TO THE HAND f3

GET TO THE CHOPPER f1
HERE IS MY INVITATION f2
ENOUGH TALK

GET TO THE CHOPPER f2
HERE IS MY INVITATION f3
ENOUGH TALK

CHILL

YOU HAVE BEEN TERMINATED

Arturo

Recursive

fib: $[x][
	if? x<2 [1]
	else [(fib x-1) + (fib x-2)]
]

loop 1..25 [x][
	print ["Fibonacci of" x "=" fib x]
]

AsciiDots

/--#$--\
|      |
>-*>{+}/
| \+-/
1  |
#  1
|  #
|  |
.  .

ATS

Recursive

fun fib_rec(n: int): int =
  if n >= 2 then fib_rec(n-1) + fib_rec(n-2) else n

Iterative

(*
** This one is also referred to as being tail-recursive 
*)
fun
fib_trec(n: int): int =
if
n > 0
then (fix loop (i:int, r0:int, r1:int): int => if i > 1 then loop (i-1, r1, r0+r1) else r1)(n, 0, 1)
else 0

Iterative and Verified

(*
** This implementation is verified!
*)

dataprop FIB (int, int) =
  | FIB0 (0, 0) | FIB1 (1, 1)
  | {n:nat} {r0,r1:int} FIB2 (n+2, r0+r1) of (FIB (n, r0), FIB (n+1, r1))
// end of [FIB] // end of [dataprop]

fun
fibats{n:nat}
  (n: int (n))
: [r:int] (FIB (n, r) | int r) = let
  fun loop
    {i:nat | i <= n}{r0,r1:int}
  (
    pf0: FIB (i, r0), pf1: FIB (i+1, r1)
  | ni: int (n-i), r0: int r0, r1: int r1
  ) : [r:int] (FIB (n, r) | int r) =
    if (ni > 0)
      then loop{i+1}(pf1, FIB2 (pf0, pf1) | ni - 1, r1, r0 + r1)
      else (pf0 | r0)
    // end of [if]
  // end of [loop]
in
  loop {0} (FIB0 (), FIB1 () | n, 0, 1)
end // end of [fibats]

Matrix-based

(* ****** ****** *)
//
// How to compile:
// patscc -o fib fib.dats
//
(* ****** ****** *)
//
#include
"share/atspre_staload.hats"
//
(* ****** ****** *)
//
abst@ype
int3_t0ype =
  (int, int, int)
//
typedef int3 = int3_t0ype
//
(* ****** ****** *)

extern
fun int3 : (int, int, int) -<> int3
extern
fun int3_1 : int3 -<> int
extern
fun mul_int3_int3: (int3, int3) -<> int3

(* ****** ****** *)

local

assume
int3_t0ype = (int, int, int)

in (* in-of-local *)
//
implement
int3 (x, y, z) = @(x, y, z)
//
implement int3_1 (xyz) = xyz.1
//
implement
mul_int3_int3
(
  @(a,b,c), @(d,e,f)
) =
  (a*d + b*e, a*e + b*f, b*e + c*f)
//
end // end of [local]

(* ****** ****** *)
//
implement
gnumber_int<int3> (n) = int3(n, 0, n)
//
implement gmul_val<int3> = mul_int3_int3
//
(* ****** ****** *)
//
fun
fib (n: intGte(0)): int =
  int3_1(gpow_int_val<int3> (n, int3(1, 1, 0)))
//
(* ****** ****** *)

implement
main0 () =
{
//
val N = 10
val () = println! ("fib(", N, ") = ", fib(N))
val N = 20
val () = println! ("fib(", N, ") = ", fib(N))
val N = 30
val () = println! ("fib(", N, ") = ", fib(N))
val N = 40
val () = println! ("fib(", N, ") = ", fib(N))
//
} (* end of [main0] *)

AutoHotkey

Search autohotkey.com: sequence

Iterative

Translation of: C

Loop, 5
  MsgBox % fib(A_Index)
Return

fib(n)
{
  If (n < 2) 
    Return n
  i := last := this := 1
  While (i <= n)
  {
    new := last + this
    last := this
    this := new
    i++
  }
  Return this
}

Recursive and iterative

Source: AutoHotkey forum by Laszlo

/*
Important note: the recursive version would be very slow
without a global or static array. The iterative version
handles also negative arguments properly.
*/

FibR(n) {       ; n-th Fibonacci number (n>=0, recursive with static array Fibo) 
   Static 
   Return n<2 ? n : Fibo%n% ? Fibo%n% : Fibo%n% := FibR(n-1)+FibR(n-2) 
} 

Fib(n) {        ; n-th Fibonacci number (n < 0 OK, iterative) 
   a := 0, b := 1 
   Loop % abs(n)-1 
      c := b, b += a, a := c 
   Return n=0 ? 0 : n>0 || n&1 ? b : -b 
}

AutoIt

Iterative

#AutoIt Version: 3.2.10.0
$n0 = 0
$n1 = 1
$n = 10
MsgBox (0,"Iterative Fibonacci ", it_febo($n0,$n1,$n))

Func it_febo($n_0,$n_1,$N)
   $first = $n_0
   $second = $n_1
   $next = $first + $second
   $febo = 0
   For $i = 1 To $N-3
      $first = $second
      $second = $next
      $next = $first + $second
   Next
   if $n==0 Then
      $febo = 0
   ElseIf $n==1 Then
      $febo = $n_0
   ElseIf $n==2 Then
      $febo = $n_1
   Else
      $febo = $next
   EndIf
   Return $febo
EndFunc

Recursive

#AutoIt Version: 3.2.10.0
$n0 = 0
$n1 = 1
$n = 10
MsgBox (0,"Recursive Fibonacci ", rec_febo($n0,$n1,$n))
Func rec_febo($r_0,$r_1,$R)
   if  $R<3 Then
      if $R==2 Then
	 Return $r_1
      ElseIf $R==1 Then
	 Return $r_0
      ElseIf $R==0 Then
	 Return 0
      EndIf
      Return $R
   Else
      Return rec_febo($r_0,$r_1,$R-1) + rec_febo($r_0,$r_1,$R-2)
   EndIf
EndFunc

AWK

As in many examples, this one-liner contains the function as well as testing with input from stdin, output to stdout.

$ awk 'func fib(n){return(n<2?n:fib(n-1)+fib(n-2))}{print "fib("$1")="fib($1)}'
10
fib(10)=55

Axe

A recursive solution is not practical in Axe because there is no concept of variable scope in Axe.

Iterative solution:

Lbl FIB
r₁→N
0→I
1→J
For(K,1,N)
 I+J→T
 J→I
 T→J
End
J
Return

Babel

In Babel, we can define fib using a stack-based approach that is not recursive:

fib { <- 0 1 { dup <- + -> swap } -> times zap } <

foo x < puts x in foo. In this case, x is the code list between the curly-braces. This is how you define callable code in Babel. The definition works by initializing the stack with 0, 1. On each iteration of the times loop, the function duplicates the top element. In the first iteration, this gives 0, 1, 1. Then it moves down the stack with the <- operator, giving 0, 1 again. It adds, giving 1. then it moves back up the stack, giving 1, 1. Then it swaps. On the next iteration this gives:

1, 1, 1 (dup)  
1, 1, (<-)  
2 (+)  
2, 1 (->)  
1, 2 (swap)

And so on. To test fib:

{19 iter - fib !} 20 times collect ! lsnum !

Output:

( 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 )

bash

Iterative

$ fib=1;j=1;while((fib<100));do echo $fib;((k=fib+j,fib=j,j=k));done

Recursive

fib()
{
  if [ $1 -le 0 ]
  then
    echo 0
    return 0
  fi
  if [ $1 -le 2 ]
  then
    echo 1
  else
    a=$(fib $[$1-1])
    b=$(fib $[$1-2])
    echo $(($a+$b))
  fi
}

BASIC

Applesoft BASIC

Same code as Commodore BASIC

Entering a value of N > 183, produces an error message:

?OVERFLOW ERROR IN 220

BASIC256

# Basic-256 ver 1.1.4
# iterative Fibonacci sequence
# Matches sequence A000045 in the OEIS, https://oeis.org/A000045/list

# Return the Nth Fibonacci number

input "N = ",f
limit = 500                        # set upper limit - can be changed, removed
f = int(f)
if f > limit then f = limit        
a = 0 : b = 1 : c = 0 : n = 0      # initial values


while n < f
    print n + chr(9) + c   # chr(9) = tab
    a = b
    b = c
    c = a + b  
    n += 1
        
end while

print " "
print n + chr(9) + c

BBC BASIC

      PRINT FNfibonacci_r(1),  FNfibonacci_i(1)
      PRINT FNfibonacci_r(13), FNfibonacci_i(13)
      PRINT FNfibonacci_r(26), FNfibonacci_i(26)
      END
      
      DEF FNfibonacci_r(N)
      IF N < 2 THEN = N
      = FNfibonacci_r(N-1) + FNfibonacci_r(N-2)
      
      DEF FNfibonacci_i(N)
      LOCAL F, I, P, T
      IF N < 2 THEN = N
      P = 1
      FOR I = 1 TO N
        T = F
        F += P
        P = T
      NEXT
      = F

Output:

         1         1
       233       233
    121393    121393

bootBASIC

Variables in bootBASIC are 2 byte unsigned integers that roll over if there is an overflow. Entering a number greater than 24 will result in an incorrect outcome.

10 print "Enter a ";
20 print "number ";
30 print "greater ";
40 print "than 1";
50 print " and less";
60 print " than 25";
70 input z
80 b=1
90 a=0
100 n=2
110 f=a+b
120 a=b
130 b=f
140 n=n+1
150 if n-z-1 goto 110
160 print "The ";
170 print z ;
180 print "th ";
190 print "Fibonacci ";
200 print "Number is ";
210 print f

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4

100 cls
110 for i = 0 to 20 : print fibor(i); : next i
120 print
130 for i = 0 to 20 : print fiboi(i); : next i
140 print
150 for i = 0 to 20 : print fiboa(i); : next i
160 end
170 sub fibor(n) : 'Recursive
180   if n < 2 then
190     fibor = n
200   else
210     fibor = fibor(n-1)+fibor(n-2)
220   endif
230 end sub
240 sub fiboi(n) : 'Iterative
250   n1 = 0
260   n2 = 1
270   for k = 1 to abs(n)
280     sum = n1+n2
290     n1 = n2
300     n2 = sum
310   next k
320   if n < 0 then
330     fiboi = n1*((-1)^((-n)+1))
340   else
350     fiboi = n1
360   endif
370 end sub
380 sub fiboa(n) : 'Analytic
390   fiboa = int(0.5+(((sqr 5+1)/2)^n)/sqr 5)
400 end sub

Output:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

Commodore BASIC

100 PRINT CHR$(147); CHR$(18); "****      FIBONACCI GENERATOR       ****"
110 INPUT "MIN, MAX"; N1, N2
120 IF N1 > N2 THEN T = N1: N1 = N2: N2 = T
130 A = 0: B = 1: S = SGN(N1)
140 FOR I = S TO N1 STEP S
150 : IF S > 0 THEN T = A + B: A = B: B = T
160 : IF S < 0 THEN T = B - A: B = A: A = T
170 NEXT I
180 PRINT
190 PRINT STR$(A); : REM STR$() PREVENTS TRAILING SPACE
200 IF N2 = N1 THEN 250
210 FOR I = N1 + 1 TO N2
220 : T = A + B: A = B: B = T
230 : PRINT ","; STR$(A);
240 NEXT I
250 PRINT

Output:

****      FIBONACCI GENERATOR       ****

MIN, MAX? -6,6

-8, 5,-3, 2,-1, 1, 0, 1, 1, 2, 3, 5, 8

READY.

Craft Basic

let a = 1
let b = 1

print "Fibonacci Sequence"

for i = 0 to 20

	let s = a + b
	let a = b
	let b = s

	print s

next i

Output:

Fibonacci Sequence
2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657

FreeBASIC

Extended sequence coded big integer.

'Fibonacci extended
'Freebasic version 24  Windows
Dim Shared ADDQmod(0 To 19) As Ubyte
Dim Shared ADDbool(0 To 19) As Ubyte

For z As Integer=0 To 19
    ADDQmod(z)=(z Mod 10+48)
    ADDbool(z)=(-(10<=z))
Next z 

Function plusINT(NUM1 As String,NUM2 As String) As String
    Dim As Byte flag
    #macro finish()
    three=Ltrim(three,"0")
    If three="" Then Return "0"
    If flag=1 Then Swap NUM2,NUM1
    Return three
    Exit Function
    #endmacro
    var lenf=Len(NUM1)
    var lens=Len(NUM2)
    If lens>lenf Then 
        Swap NUM2,NUM1
        Swap lens,lenf
        flag=1
    End If
    
    var diff=lenf-lens-Sgn(lenf-lens)
    var three="0"+NUM1
    var two=String(lenf-lens,"0")+NUM2
    Dim As Integer n2
    Dim As Ubyte addup,addcarry
    
    addcarry=0
    
    For n2=lenf-1 To diff Step -1 
        addup=two[n2]+NUM1[n2]-96
        three[n2+1]=addQmod(addup+addcarry)
        addcarry=addbool(addup+addcarry)
    Next n2 
    If addcarry=0 Then 
        finish()
    End If
    If n2=-1 Then 
        three[0]=addcarry+48
        finish()
    End If
    
    For n2=n2 To 0 Step -1 
        addup=two[n2]+NUM1[n2]-96
        three[n2+1]=addQmod(addup+addcarry)
        addcarry=addbool(addup+addcarry)
    Next n2
    three[0]=addcarry+48
    finish()
End Function

Function  fibonacci(n As Integer) As String
    Dim As String sl,l,term
    sl="0": l="1"
    If n=1 Then Return "0"
    If n=2 Then Return "1"
    n=n-2
    For x As Integer= 1 To n
        term=plusINT(l,sl)
        sl=l
        l=term
    Next x
    Function =term
End Function

'==============  EXAMPLE ===============
print "THE SEQUENCE TO 10:"
print
For n As Integer=1 To 10
    Print "term";n;": "; fibonacci(n)
Next n
print
print "Selected Fibonacci number"
print "Fibonacci 500"
print
print fibonacci(500)
Sleep

Output:

THE SEQUENCE TO 10:

term 1: 0
term 2: 1
term 3: 1
term 4: 2
term 5: 3
term 6: 5
term 7: 8
term 8: 13
term 9: 21
term 10: 34

Selected Fibonacci number
Fibonacci 500

86168291600238450732788312165664788095941068326060883324529903470149056115823592
713458328176574447204501

FTCBASIC

define a = 1, b = 1, s = 0, i = 0

cls

print "Fibonacci Sequence"

do

	let s = a + b
	let a = b
	let b = s
	+1 i

	print s

loop i < 20

pause
end

GFA Basic

'
' Compute nth Fibonacci number
'
' open a window for display
OPENW 1
CLEARW 1
' Display some fibonacci numbers
' Fib(46) is the largest number GFA Basic can reach
' (long integers are 4 bytes)
FOR i%=0 TO 46
  PRINT "fib(";i%;")=";@fib(i%)
NEXT i%
' wait for a key press and tidy up
~INP(2)
CLOSEW 1
'
' Function to compute nth fibonacci number
' n must be in range 0 to 46, inclusive
'
FUNCTION fib(n%)
  LOCAL n0%,n1%,nn%,i%
  n0%=0
  n1%=1
  SELECT n%
  CASE 0
    RETURN n0%
  CASE 1
    RETURN n1%
  DEFAULT
    FOR i%=2 TO n%
      nn%=n0%+n1%
      n0%=n1%
      n1%=nn%
    NEXT i%
    RETURN nn%
  ENDSELECT
ENDFUNC

GW-BASIC

Works with: BASICA

Iterative

10 ' SAVE"FIBONA", A
20 ' Secuencia de Fibonacci
30 ' Var
40 DEFDBL D
50 IMAXFIBO% = 76
60 DNUM1 = 1: DNUM2 = DNUM1
70 CLS
80 PRINT "Este programa calcula la serie de Fibonacci."
90 PRINT DNUM1; DNUM2;
100 FOR I% = 1 TO IMAXFIBO%
110   DNUM3 = DNUM1 + DNUM2
120   PRINT DNUM3;
130   DNUM1 = DNUM2: DNUM2 = DNUM3
140 NEXT I%
150 PRINT
160 PRINT "Fin de la ejecución del programa."
170 END

Output:

Este programa calcula la serie de Fibonacci.
 1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584
 4181  6765  10946  17711  28657  46368  75025  121393  196418  317811  514229
 832040  1346269  2178309  3524578  5702887  9227465  14930352  24157817
 39088169  63245986  102334155  165580141  267914296  433494437  701408733
 1134903170  1836311903  2971215073  4807526976  7778742049  12586269025
 20365011074  32951280099  53316291173  86267571272  139583862445  225851433717
 365435296162  591286729879  956722026041  1548008755920  2504730781961
 4052739537881  6557470319842  10610209857723  17167680177565  27777890035288
 44945570212853  72723460248141  117669030460994  190392490709135
 308061521170129  498454011879264  806515533049393  1304969544928657
 2111485077978050  3416454622906707  5527939700884757  8944394323791464
Fin de la ejecución del programa.
Ok

Binet formula

10 ' SAVE"FIBINF", A
20 ' Secuencia de Fibonacci mediante la fórmula de Binet
30 ' Var
40 DEFDBL D
50 IMAXFIBO% = 77
60 DSQR5 = SQR(5)
70 DPIV1 = (1 + DSQR5) / 2
80 DPIV2 = (1 - DSQR5) / 2
90 DNUM1 = DPIV1: DNUM2 = DPIV2
100 CLS
110 PRINT "Este programa calcula la serie de Fibonacci."
120 FOR I% = 1 TO IMAXFIBO%
130   DNUM1 = DNUM1 * DPIV1
140   DNUM2 = DNUM2 * DPIV2
150   PRINT FIX(((DNUM1 - DNUM2) / DSQR5)+.5);
160 NEXT I%
170 PRINT
180 PRINT "Fin de la ejecución del programa."
190 END

Output:

Este programa calcula la serie de Fibonacci.
 1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181
 6765  10946  17711  28657  46368  75025  121393  196418  317811  514229
 832040  1346269  2178310  3524579  5702889  9227468  14930357  24157826
 39088183  63246010  102334195  165580207  267914406  433494620  701409036
 1134903671  1836312733  2971216446  4807529247  7778745802  12586275225
 20365021312  32951296999  53316319058  86267617266  139583938281  225851558714
 365435502118  591287069122  956722584654  1548009675479  2504732295250
 4052742027550  6557474414738  10610216591046  17167691246479  27777908226979
 44945600103607  72723509350188  117669111103547  190392623123089
 308061738545741  498454368657289  806516118510594  1304970505463907
 2111486653578091  3416457206941612  5527943938022908  8944401270367342
Fin de la ejecución del programa.
Ok

Integer BASIC

Only works with quite small values of $n$ .

 10 INPUT N
 20 A=0
 30 B=1
 40 FOR I=2 TO N
 50 C=B
 60 B=A+B
 70 A=C
 80 NEXT I
 90 PRINT B
100 END

IS-BASIC

100 PROGRAM "Fibonac.bas"
110 FOR I=0 TO 20
120   PRINT "F";I,FIB(I)
130 NEXT
140 DEF FIB(N)
150   NUMERIC I
160   LET A=0:LET B=1
170   FOR I=1 TO N
180     LET T=A+B:LET A=B:LET B=T
190   NEXT
200   LET FIB=A
210 END DEF

Liberty BASIC

Iterative/Recursive

Works with: Just BASIC

for i = 0 to 15
    print fiboR(i),fiboI(i)
next i
 
function fiboR(n)
    if n <= 1 then
        fiboR = n
    else
        fiboR = fiboR(n-1) + fiboR(n-2)
    end if
end function
 
function fiboI(n)
    a = 0
    b = 1
    for i = 1 to n
        temp = a + b
        a = b
        b = temp
    next i
    fiboI = a
end function

Output:

0             0
1             1
1             1
2             2
3             3
5             5
8             8
13            13
21            21
34            34
55            55
89            89
144           144
233           233
377           377
610           610

Iterative/Negative

Works with: Just BASIC

print "Rosetta Code - Fibonacci sequence": print
print "  n             Fn"
for x=-12 to 12 '68 max
    print using("### ", x); using("##############", FibonacciTerm(x))
next x
print
[start]
input "Enter a term#: "; n$
n$=lower$(trim$(n$))
if n$="" then print "Program complete.": end
print FibonacciTerm(val(n$))
goto [start]

function FibonacciTerm(n)
    n=int(n)
    FTa=0: FTb=1: FTc=-1
    select case
        case n=0  : FibonacciTerm=0  : exit function
        case n=1  : FibonacciTerm=1  : exit function
        case n=-1 : FibonacciTerm=-1 : exit function
        case n>1
            for x=2 to n
                FibonacciTerm=FTa+FTb
                FTa=FTb: FTb=FibonacciTerm
            next x
            exit function
        case n<-1
            for x=-2 to n step -1
                FibonacciTerm=FTa+FTc
                FTa=FTc: FTc=FibonacciTerm
            next x
            exit function
    end select
end function

Output:

Rosetta Code - Fibonacci sequence

  n             Fn
-12           -144
-11            -89
-10            -55
 -9            -34
 -8            -21
 -7            -13
 -6             -8
 -5             -5
 -4             -3
 -3             -2
 -2             -1
 -1             -1
  0              0
  1              1
  2              1
  3              2
  4              3
  5              5
  6              8
  7             13
  8             21
  9             34
 10             55
 11             89
 12            144

Enter a term#: 12
144
Enter a term#:
Program complete.

Microsoft Small Basic

Iterative

' Fibonacci sequence - 31/07/2018
  n = 139
  f1 = 0
  f2 = 1
  TextWindow.WriteLine("fibo(0)="+f1)
  TextWindow.WriteLine("fibo(1)="+f2)
  For i = 2 To n
    f3 = f1 + f2
    TextWindow.WriteLine("fibo("+i+")="+f3)
    f1 = f2
    f2 = f3
  EndFor

Output:

fibo(139)=50095301248058391139327916261

Binet's Formula

' Fibonacci sequence - Binet's Formula - 31/07/2018
  n = 69
  sq5=Math.SquareRoot(5)
  phi1=(1+sq5)/2
  phi2=(1-sq5)/2
  phi1n=phi1
  phi2n=phi2
  For i = 2 To n
    phi1n=phi1n*phi1
    phi2n=phi2n*phi2
    TextWindow.Write(Math.Floor((phi1n-phi2n)/sq5)+" ")
  EndFor

Output:

1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073 4807526976 7778742049 12586269025 20365011074 32951280099 53316291173 86267571272 139583862445 225851433717 365435296162 591286729879 956722026041 1548008755920 2504730781961 4052739537881 6557470319842 10610209857723 17167680177565 27777890035288 44945570212853 72723460248141 117669030460994

Minimal BASIC

Works with: QBasic

Works with: BASICA

Works with: Chipmunk Basic

Works with: GW-BASIC

Works with: IS-BASIC

Works with: MSX Basic

110 REM THE ARRAY F HOLDS THE FIBONACCI NUMBERS
120 DIM F(22)
130 LET F(0) = 0
140 LET F(1) = 1
150 LET N = 1
160 REM COMPUTE THE NEXT FIBBONACCI NUMBER
170 LET F(N+1) = F(N)+F(N-1)
180 LET N = N+1
190 PRINT F(N-2);
200 REM STOP AFTER PRINTING  20 NUMBERS
210 IF N < 22 THEN 170
220 END

MSX Basic

Works with: QBasic

Works with: Chipmunk Basic

Works with: GW-BASIC

100 CLS
110 FOR N = 0 TO 15: GOSUB 130: PRINT FIBOI; : NEXT N
120 END
130 REM Iterative Fibonacci sequence
140 N1 = 0
150 N2 = 1
160 FOR K = 1 TO ABS(N)
170   SUM = N1 + N2
180   N1 = N2
190   N2 = SUM
200 NEXT K
210 IF N < 0 THEN FIBOI = N1 * ((-1) ^ ((-N) + 1)) ELSE FIBOI = N1
220 RETURN

Palo Alto Tiny BASIC

10 REM FIBONACCI SEQUENCE
20 INPUT "ENTER N FOR FIB(N)"N
30 LET A=0,B=1
40 FOR I=2 TO N
50 LET T=B,B=A+B,A=T
60 NEXT I
70 PRINT B
80 STOP

Output:

2 runs.

ENTER N FOR FIB(N):9
     34

ENTER N FOR FIB(N):13
    233

PowerBASIC

Translation of: BASIC

There seems to be a limitation (dare I say, bug?) in PowerBASIC regarding how large numbers are stored. 10E17 and larger get rounded to the nearest 10. For F(n), where ABS(n) > 87, is affected like this:

      actual:             displayed:
F(88) 1100087778366101931 1100087778366101930
F(89) 1779979416004714189 1779979416004714190
F(90) 2880067194370816120 2880067194370816120
F(91) 4660046610375530309 4660046610375530310
F(92) 7540113804746346429 7540113804746346430

FUNCTION fibonacci (n AS LONG) AS QUAD
    DIM u AS LONG, a AS LONG, L0 AS LONG, outP AS QUAD
    STATIC fibNum() AS QUAD

    u = UBOUND(fibNum)
    a = ABS(n)

    IF u < 1 THEN
        REDIM fibNum(1)
        fibNum(1) = 1
        u = 1
    END IF

    SELECT CASE a
        CASE 0 TO 92
            IF a > u THEN
                REDIM PRESERVE fibNum(a)
                FOR L0 = u + 1 TO a
                    fibNum(L0) = fibNum(L0 - 1) + fibNum(L0 - 2)
                    IF 88 = L0 THEN fibNum(88) = fibNum(88) + 1
                NEXT
            END IF
            IF n < 0 THEN
                fibonacci = fibNum(a) * ((-1)^(a+1))
            ELSE
                fibonacci = fibNum(a)
            END IF
        CASE ELSE
            'Even without the above-mentioned bug, we're still limited to
            'F(+/-92), due to data type limits. (F(93) = &hA94F AD42 221F 2702)
            ERROR 6
    END SELECT
END FUNCTION

FUNCTION PBMAIN () AS LONG
    DIM n AS LONG
    #IF NOT %DEF(%PB_CC32)
        OPEN "out.txt" FOR OUTPUT AS 1
    #ENDIF
    FOR n = -92 TO 92
        #IF %DEF(%PB_CC32)
            PRINT STR$(n); ": "; FORMAT$(fibonacci(n), "#")
        #ELSE
            PRINT #1, STR$(n) & ": " & FORMAT$(fibonacci(n), "#")
        #ENDIF
    NEXT
    CLOSE
END FUNCTION

PureBasic

Macro based calculation

Macro Fibonacci (n)
	Int((Pow(((1+Sqr(5))/2),n)-Pow(((1-Sqr(5))/2),n))/Sqr(5))
EndMacro

Recursive

Procedure FibonacciReq(n)
  If n<2
    ProcedureReturn n
  Else
    ProcedureReturn FibonacciReq(n-1)+FibonacciReq(n-2)
  EndIf
EndProcedure

Recursive & optimized with a static hash table

This will be much faster on larger n's, this as it uses a table to store known parts instead of recalculating them. On my machine the speedup compares to above code is

Fib(n) Speedup
20           2
25          23
30         217
40       25847
46     1156741

Procedure Fibonacci(n)
  Static NewMap Fib.i()
  Protected FirstRecursion
  
  If MapSize(Fib())= 0        ; Init the hash table the first run
    Fib("0")=0: Fib("1")=1
    FirstRecursion = #True
  EndIf
 
  If n >= 2
    Protected.s s=Str(n)
    If Not FindMapElement(Fib(),s)  ; Calculate only needed parts
      Fib(s)= Fibonacci(n-1)+Fibonacci(n-2)
    EndIf
    n = Fib(s)  
  EndIf
  If FirstRecursion ; Free the memory when finalizing the first call
    ClearMap(Fib())
  EndIf
  ProcedureReturn n
EndProcedure

Example

Fibonacci(0)= 0
Fibonacci(1)= 1
Fibonacci(2)= 1
Fibonacci(3)= 2
Fibonacci(4)= 3
Fibonacci(5)= 5

FibonacciReq(0)= 0
FibonacciReq(1)= 1
FibonacciReq(2)= 1
FibonacciReq(3)= 2
FibonacciReq(4)= 3
FibonacciReq(5)= 5

QB64

CBTJD: 2020/03/13

_DEFINE F AS _UNSIGNED _INTEGER64
CLS
PRINT
PRINT "Enter 40 to more easily see the difference in calculation speeds."
PRINT
INPUT "Enter n for Fibonacci(n): ", n
PRINT
PRINT " Analytic Method (Fastest): F("; LTRIM$(STR$(n)); ") ="; fA(n)
PRINT "Iterative Method    (Fast): F("; LTRIM$(STR$(n)); ") ="; fI(n)
PRINT "Recursive Method    (Slow): F("; LTRIM$(STR$(n)); ") ="; fR(n)
END

' === Analytic Fibonacci Function (Fastest)
FUNCTION fA (n)
  fA = INT(0.5 + (((SQR(5) + 1) / 2) ^ n) / SQR(5))
END FUNCTION

' === Iterative Fibonacci Function (Fast)
FUNCTION fI (n)
  FOR i = 1 TO n
    IF i < 3 THEN a = 1: b = 1
    t = fI + b: fI = b: b = t
  NEXT
END FUNCTION

' === Recursive Fibonacci function (Slow)
FUNCTION fR (n)
  IF n <= 1 THEN
    fR = n
  ELSE
    fR = fR(n - 1) + fR(n - 2)
  END IF
END FUNCTION

Fibonacci from Russia

DIM F(80) AS DOUBLE 'FibRus.bas DANILIN
F(1) = 0: F(2) = 1
'OPEN "FibRus.txt" FOR OUTPUT AS #1
FOR i = 3 TO 80
    F(i) = F(i-1)+F(i-2)
NEXT i

FOR i = 1 TO 80
    f$ = STR$(F(i)): LF = 22 - LEN(f$)
    n$ = ""
    FOR j = 1 TO LF: n$ = " " + n$: NEXT
    f$ = n$ + f$
    PRINT i, f$: ' PRINT #1, i, f$
NEXT i

Output:

1                                 0
2                                 1
3                                 1
4                                 2
5                                 3
6                                 5
7                                 8
8                                13
9                                21
...
24                            28657
25                            46368
26                            75025
...
36                          9227465
37                         14930352
38                         24157817
...
48                       2971215073
49                       4807526976
50                       7778742049
...
60                     956722026041
61                    1548008755920
62                    2504730781961
...
76                 2111485077978050
77                 3416454622906707
78                 5527939700884757
79                 8944394323791464
80            1.447233402467622D+16

QBasic

Works with: QBasic

Works with: FreeBASIC

Iterative

FUNCTION itFib (n)
    n1 = 0
    n2 = 1
    FOR k = 1 TO ABS(n)
        sum = n1 + n2
        n1 = n2
        n2 = sum
    NEXT k
    IF n < 0 THEN
        itFib = n1 * ((-1) ^ ((-n) + 1))
    ELSE
        itFib = n1
    END IF
END FUNCTION

Next version calculates each value once, as needed, and stores the results in an array for later retreival (due to the use of REDIM PRESERVE, it requires QuickBASIC 4.5 or newer):

DECLARE FUNCTION fibonacci& (n AS INTEGER)

REDIM SHARED fibNum(1) AS LONG

fibNum(1) = 1

'*****sample inputs*****
PRINT fibonacci(0)      'no calculation needed
PRINT fibonacci(13)     'figure F(2)..F(13)
PRINT fibonacci(-42)    'figure F(14)..F(42)
PRINT fibonacci(47)     'error: too big
'*****sample inputs*****

FUNCTION fibonacci& (n AS INTEGER)
    DIM a AS INTEGER
    a = ABS(n)
    SELECT CASE a
        CASE 0 TO 46
            SHARED fibNum() AS LONG
            DIM u AS INTEGER, L0 AS INTEGER
            u = UBOUND(fibNum)
            IF a > u THEN
                REDIM PRESERVE fibNum(a) AS LONG
                FOR L0 = u + 1 TO a
                    fibNum(L0) = fibNum(L0 - 1) + fibNum(L0 - 2)
                NEXT
            END IF
            IF n < 0 THEN
                fibonacci = fibNum(a) * ((-1) ^ (a + 1))
            ELSE
                fibonacci = fibNum(n)
            END IF
        CASE ELSE
            'limited to signed 32-bit int (LONG)
            'F(47)=&hB11924E1
            ERROR 6 'overflow
    END SELECT
END FUNCTION

Output:

(unhandled error in final input prevents output)

 0
 233
-267914296

Recursive

This example can't handle n < 0.

FUNCTION recFib (n)
    IF (n < 2) THEN
	recFib = n
    ELSE
	recFib = recFib(n - 1) + recFib(n - 2)
    END IF
END FUNCTION

Array (Table) Lookup

This uses a pre-generated list, requiring much less run-time processor usage. (Since the sequence never changes, this is probably the best way to do this in "the real world". The same applies to other sequences like prime numbers, and numbers like pi and e.)

DATA -1836311903,1134903170,-701408733,433494437,-267914296,165580141,-102334155
DATA 63245986,-39088169,24157817,-14930352,9227465,-5702887,3524578,-2178309
DATA 1346269,-832040,514229,-317811,196418,-121393,75025,-46368,28657,-17711
DATA 10946,-6765,4181,-2584,1597,-987,610,-377,233,-144,89,-55,34,-21,13,-8,5,-3
DATA 2,-1,1,0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765
DATA 10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269
DATA 2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986
DATA 102334155,165580141,267914296,433494437,701408733,1134903170,1836311903

DIM fibNum(-46 TO 46) AS LONG

FOR n = -46 TO 46
    READ fibNum(n)
NEXT

'*****sample inputs*****
FOR n = -46 TO 46
    PRINT fibNum(n),
NEXT
PRINT
'*****sample inputs*****

Quite BASIC

100 CLS
110 rem The array F holds the Fibonacci numbers
120 ARRAY f : rem DIM f(22) para Quite BASIC and MSX-BASIC
130 LET f(0) = 0
140 LET f(1) = 1
150 LET n = 1
160 rem Compute the NEXT Fibbonacci number
170 LET f(n+1) = f(n)+f(n-1)
180 LET n = n+1
190 PRINT f(n-2);" ";
200 rem STOP after printing  20 numbers
210 IF n < 22 THEN GOTO 170

Run BASIC

for i = 0 to 10
 print i;" ";fibR(i);" ";fibI(i)
next i
end
 
 function fibR(n)
 if n < 2 then fibR = n else fibR = fibR(n-1) + fibR(n-2)
 end function
 
 function fibI(n)
   b = 1
   for i = 1 to n
       t = a + b
       a = b
       b = t
   next i
fibI = a
end function

S-BASIC

Note that the 23rd Fibonacci number (=28657) is the largest that can be generated without overflowing S-BASIC's integer data type.

rem - iterative function to calculate nth fibonacci number
function fibonacci(n = integer) = integer
var f, i, p1, p2 = integer
p1 = 0    
p2 = 1
if n = 0 then
   f = 0
else
   for i = 1 to n
      f = p1 + p2
      p2 = p1
      p1 = f
   next i
end = f

rem - exercise the function
var i = integer
for i = 0 to 10
   print fibonacci(i);
next i

end

Output:

 0 1 1 2 3 5 8 13 21 34 55

Sinclair ZX81 BASIC

Analytic

 10 INPUT N
 20 PRINT INT (0.5+(((SQR 5+1)/2)**N)/SQR 5)

Iterative

 10 INPUT N
 20 LET A=0
 30 LET B=1
 40 FOR I=2 TO N
 50 LET C=B
 60 LET B=A+B
 70 LET A=C
 80 NEXT I
 90 PRINT B

Tail recursive

 10 INPUT N
 20 LET A=0
 30 LET B=1
 40 GOSUB 70
 50 PRINT B
 60 STOP
 70 IF N=1 THEN RETURN
 80 LET C=B
 90 LET B=A+B
100 LET A=C
110 LET N=N-1
120 GOSUB 70
130 RETURN

smart BASIC

The Iterative method is slow (relatively) and the Recursive method doubly so since it references the recursion function twice.

The N-th Term (fibN) function is much faster as it utilizes Binet's Formula.

fibR: Fibonacci Recursive
fibI: Fibonacci Iterative
fibN: Fibonacci N-th Term

FOR i = 0 TO 15
    PRINT fibR(i),fibI(i),fibN(i)
NEXT i

/* Recursive Method */
DEF fibR(n)
    IF n <= 1 THEN
        fibR = n
    ELSE
        fibR = fibR(n-1) + fibR(n-2)
    ENDIF
END DEF

/* Iterative Method */
DEF fibI(n)
    a = 0
    b = 1
    FOR i = 1 TO n
        temp = a + b
        a = b
        b = temp
    NEXT i
    fibI = a
END DEF

/* N-th Term Method */
DEF fibN(n)
    uphi = .5 + SQR(5)/2
    lphi = .5 - SQR(5)/2
    fibN = (uphi^n-lphi^n)/SQR(5)
END DEF

Softbridge BASIC

Iterative

Function Fibonacci(n)
   x = 0
   y = 1
   i = 0
   n = ABS(n)
   If n < 2 Then
   Fibonacci = n
   Else
   Do Until (i = n)
      sum = x+y
      x=y
      y=sum
      i=i+1
   Loop
   Fibonacci = x
   End If

End Function

TI-83 BASIC

Sequence table

[Y=]
nMin=0
u(n)=u(n-1)+u(n-2)
u(nMin)={1,0}
[TABLE]
n	u(n)
-------	-------
0	0
1	1
2	1
3	2
4	3
5	5
6	8
7	13
8	21
9	34
10	55
11	89
12	144

Iterative

{0,1
While 1
Disp Ans(1
{Ans(2),sum(Ans
End

Binet's formula

Prompt N
.5(1+√(5    //golden ratio
(Ans^N–(-Ans)^-N)/√(5

TI-89 BASIC

Recursive

Optimized implementation (too slow to be usable for n higher than about 12).

fib(n)
when(n<2, n, fib(n-1) + fib(n-2))

Iterative

Unoptimized implementation (I think the for loop can be eliminated, but I'm not sure).

fib(n)
Func
Local a,b,c,i
0→a
1→b
For i,1,n
  a→c
  b→a
  c+b→b
EndFor
a
EndFunc

Tiny BASIC

Works with: TinyBasic

10 LET A = 0
20 LET B = 1
30 PRINT "Which F_n do you want?"
40 INPUT N
50 IF N = 0 THEN GOTO 140
60 IF N = 1 THEN GOTO 120
70 LET C = B + A
80 LET A = B
90 LET B = C
100 LET N = N - 1
110 GOTO 60
120 PRINT B
130 END
140 PRINT 0
150 END

True BASIC

FUNCTION fibonacci (n)
    LET n1 = 0
    LET n2 = 1
    FOR k = 1 TO ABS(n)
        LET sum = n1 + n2
        LET n1 = n2
        LET n2 = sum
    NEXT k
    IF n < 0 THEN
       LET fibonacci = n1 * ((-1) ^ ((-n) + 1))
    ELSE
       LET fibonacci = n1
    END IF
END FUNCTION

PRINT fibonacci(0)      ! 0
PRINT fibonacci(13)     ! 233
PRINT fibonacci(-42)    !-267914296
PRINT fibonacci(47)     ! 2971215073
END

VBA

Like Visual Basic .NET, but with keyword "Public" and type Variant (subtype Currency) instead of Decimal:

Public Function Fib(ByVal n As Integer) As Variant
    Dim fib0 As Variant, fib1 As Variant, sum As Variant
    Dim i As Integer
    fib0 = 0
    fib1 = 1
    For i = 1 To n
        sum = fib0 + fib1
        fib0 = fib1
        fib1 = sum
    Next i
    Fib = fib0
End Function

With Currency type, maximum value is fibo(73).

The (slow) recursive version:

Public Function RFib(Term As Integer) As Long
  If Term < 2 Then RFib = Term Else RFib = RFib(Term - 1) + RFib(Term - 2)
End Function

With Long type, maximum value is fibo(46).

VBScript

Non-recursive, object oriented, generator

Defines a generator class, with a default Get property. Uses Currency for larger-than-Long values. Tests for overflow and switches to Double. Overflow information also available from class.

Class Definition:

class generator
	dim t1
	dim t2
	dim tn
	dim cur_overflow
	
	Private Sub Class_Initialize
		cur_overflow = false
		t1 = ccur(0)
		t2 = ccur(1)
		tn = ccur(t1 + t2)
	end sub
	
	public default property get generated
		on error resume next

		generated = ccur(tn)
		if err.number <> 0 then 
			generated = cdbl(tn)
			cur_overflow = true
		end if
		t1 = ccur(t2)
		if err.number <> 0 then 
			t1 = cdbl(t2)
			cur_overflow = true
		end if
		t2 = ccur(tn)
		if err.number <> 0 then 
			t2 = cdbl(tn)
			cur_overflow = true
		end if
		tn = ccur(t1+ t2)
		if err.number <> 0 then 
			tn = cdbl(t1) + cdbl(t2)
			cur_overflow = true
		end if
		on error goto 0
	end property
	
	public property get overflow
		overflow = cur_overflow
	end property
		
end class

Invocation:

dim fib
set fib = new generator
dim i
for i = 1 to 100
	wscript.stdout.write " " & fib 
	if fib.overflow then
		wscript.echo
		exit for
	end if
next

Output:

 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073 4807526976 7778742049 12586269025 20365011074 32951280099 53316291173 86267571272 139583862445 225851433717 365435296162 591286729879 956722026041 1548008755920 2504730781961 4052739537881 6557470319842 10610209857723 17167680177565 27777890035288 44945570212853 72723460248141 117669030460994 190392490709135 308061521170129 498454011879264 806515533049393

Visual Basic

Works with: Visual Basic version VB6 Standard

Maximum integer value (7*10^28) can be obtained by using decimal type, but decimal type is only a sub type of the variant type.

Sub fibonacci()
    Const n = 139 
    Dim i As Integer
    Dim f1 As Variant, f2 As Variant, f3 As Variant 'for Decimal
    f1 = CDec(0): f2 = CDec(1) 'for Decimal setting
    Debug.Print "fibo("; 0; ")="; f1
    Debug.Print "fibo("; 1; ")="; f2
    For i = 2 To n
        f3 = f1 + f2
        Debug.Print "fibo("; i; ")="; f3
        f1 = f2
        f2 = f3
    Next i
End Sub 'fibonacci

Output:

fibo( 0 )= 0 
fibo( 1 )= 1 
fibo( 2 )= 1 
...
fibo( 137 )= 19134702400093278081449423917 
fibo( 138 )= 30960598847965113057878492344 
fibo( 139 )= 50095301248058391139327916261

Visual Basic .NET

Platform: .NET

Iterative

Works with: Visual Basic .NET version 9.0+

With Decimal type, maximum value is fibo(139).

Function Fib(ByVal n As Integer) As Decimal
    Dim fib0, fib1, sum As Decimal
    Dim i As Integer
    fib0 = 0
    fib1 = 1
    For i = 1 To n
        sum = fib0 + fib1
        fib0 = fib1
        fib1 = sum
    Next
    Fib = fib0
End Function

Recursive

Works with: Visual Basic .NET version 9.0+

Function Seq(ByVal Term As Integer)
        If Term < 2 Then Return Term
        Return Seq(Term - 1) + Seq(Term - 2)
End Function

BigInteger

There is no real maximum value of BigInterger class, except the memory to store the number. Within a minute, fibo(2000000) is a number with 417975 digits.

    Function FiboBig(ByVal n As Integer) As BigInteger
        ' Fibonacci sequence with BigInteger
        Dim fibn2, fibn1, fibn As BigInteger
        Dim i As Integer
        fibn = 0
        fibn2 = 0
        fibn1 = 1
        If n = 0 Then
            Return fibn2
        ElseIf n = 1 Then
            Return fibn1
        ElseIf n >= 2 Then
            For i = 2 To n
                fibn = fibn2 + fibn1
                fibn2 = fibn1
                fibn1 = fibn
            Next i
            Return fibn
        End If
        Return 0
    End Function 'FiboBig

    Sub fibotest()
        Dim i As Integer, s As String
        i = 2000000  ' 2 millions
        s = FiboBig(i).ToString
        Console.WriteLine("fibo(" & i & ")=" & s & " - length=" & Len(s))
    End Sub 'fibotest

BigInteger, speedier method

Library: System.Numerics

This method doesn't need to iterate the entire list, and is much faster. The 2000000 (two millionth) Fibonacci number can be found in a fraction of a second.
Algorithm from here, see section 3, Finding Fibonacci Numbers Fully.

Imports System
Imports System.Collections.Generic
Imports BI = System.Numerics.BigInteger

Module Module1

    ' A sparse array of values calculated along the way
    Dim sl As SortedList(Of Integer, BI) = New SortedList(Of Integer, BI)()

    ' Square a BigInteger
    Function sqr(ByVal n As BI) As BI
        Return n * n
    End Function

    ' Helper routine for Fsl(). It adds an entry to the sorted list when necessary
    Sub IfNec(n As Integer)
        If Not sl.ContainsKey(n) Then sl.Add(n, Fsl(n))
    End Sub

    ' This routine is semi-recursive, but doesn't need to evaluate every number up to n.
    ' Algorithm from here: http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormula.html#section3
    Function Fsl(ByVal n As Integer) As BI
        If n < 2 Then Return n
        Dim n2 As Integer = n >> 1, pm As Integer = n2 + ((n And 1) << 1) - 1 : IfNec(n2) : IfNec(pm)
        Return If(n2 > pm, (2 * sl(pm) + sl(n2)) * sl(n2), sqr(sl(n2)) + sqr(sl(pm)))
    End Function

    ' Conventional iteration method (not used here)
    Function Fm(ByVal n As BI) As BI
        If n < 2 Then Return n
        Dim cur As BI = 0, pre As BI = 1
        For i As Integer = 0 To n - 1
            Dim sum As BI = cur + pre : pre = cur : cur = sum : Next : Return cur
    End Function

    Sub Main()
        Dim vlen As Integer, num As Integer = 2_000_000, digs As Integer = 35
        Dim sw As System.Diagnostics.Stopwatch = System.Diagnostics.Stopwatch.StartNew()
        Dim v As BI = Fsl(num) : sw.[Stop]()
        Console.Write("{0:n3} ms to calculate the {1:n0}th Fibonacci number, ", sw.Elapsed.TotalMilliseconds, num)
        vlen = CInt(Math.Ceiling(BI.Log10(v))) : Console.WriteLine("number of digits is {0}", vlen)
        If vlen < 10000 Then
            sw.Restart() : Console.WriteLine(v) : sw.[Stop]()
            Console.WriteLine("{0:n3} ms to write it to the console.", sw.Elapsed.TotalMilliseconds)
        Else
            Console.Write("partial: {0}...{1}", v / BI.Pow(10, vlen - digs), v Mod BI.Pow(10, digs))
        End If
    End Sub
End Module

Output:

120.374 ms to calculate the 2,000,000th Fibonacci number, number of digits is 417975
partial: 85312949175076415430516606545038251...91799493108960825129188777803453125

Xojo

Pass n to this function where n is the desired number of iterations. This example uses the UInt64 datatype which is as unsigned 64 bit integer. As such, it overflows after the 93rd iteration.

Function fibo(n As Integer) As UInt64

  Dim noOne As UInt64 = 1
  Dim noTwo As UInt64 = 1	
  Dim sum As UInt64

  For i As Integer = 3 To n
      sum = noOne + noTwo
      noTwo = noOne
      noOne = sum
  Next

  Return noOne
End Function

Yabasic

Iterative

sub fibonacciI (n)
    local n1, n2, k, sum

    n1 = 0
    n2 = 1
    for k = 1 to abs(n)
        sum = n1 + n2
        n1 = n2
        n2 = sum
    next k
    if n < 1 then
       return n1 * ((-1) ^ ((-n) + 1))
    else
       return n1
    end if
end sub

Recursive

Only positive numbers

sub fibonacciR(n)
    if n <= 1 then
        return n
    else
        return fibonacciR(n-1) + fibonacciR(n-2)
    end if
end sub

Analytic

Only positive numbers

sub fibonacciA (n)
    return int(0.5 + (((sqrt(5) + 1) / 2) ^ n) / sqrt(5))
end sub

Binet's formula

Fibonacci sequence using the Binet formula

sub fibonacciB(n)
    local sq5, phi1, phi2, dn1, dn2, k

    sq5 = sqrt(5)
    phi1 = (1 + sq5) / 2
    phi2 = (1 - sq5) / 2
    dn1 = phi1: dn2 = phi2
    for k = 0 to n
        dn1 = dn1 * phi1
        dn2 = dn2 * phi2
        print int(((dn1 - dn2) / sq5) + .5);
    next k
end sub

ZX Spectrum Basic

Iterative

10 REM Only positive numbers
20 LET n=10
30 LET n1=0: LET n2=1
40 FOR k=1 TO n
50 LET sum=n1+n2
60 LET n1=n2
70 LET n2=sum
80 NEXT k
90 PRINT n1

Analytic

10 DEF FN f(x)=INT (0.5+(((SQR 5+1)/2)^x)/SQR 5)

Batch File

Recursive version

::fibo.cmd
@echo off
if "%1" equ "" goto :eof
call :fib %1
echo %errorlevel%
goto :eof

:fib
setlocal enabledelayedexpansion
if %1 geq 2 goto :ge2 
exit /b %1

:ge2
set /a r1 = %1 - 1
set /a r2 = %1 - 2
call :fib !r1!
set r1=%errorlevel%
call :fib !r2!
set r2=%errorlevel%
set /a r0 = r1 + r2
exit /b !r0!

Output:

>for /L %i in (1,5,20) do fibo.cmd %i

>fibo.cmd 1
1

>fibo.cmd 6
8

>fibo.cmd 11
89

>fibo.cmd 16
987

Battlestar

// Fibonacci sequence, recursive version
fun fibb
    loop
        a = funparam[0]
        break (a < 2)

        a--

        // Save "a" while calling fibb
        a -> stack

        // Set the parameter and call fibb
        funparam[0] = a
        call fibb

        // Handle the return value and restore "a"
        b = funparam[0]
        stack -> a

        // Save "b" while calling fibb again
        b -> stack

        a--

        // Set the parameter and call fibb
        funparam[0] = a
        call fibb

        // Handle the return value and restore "b"
        c = funparam[0]
        stack -> b

        // Sum the results
        b += c
        a = b

        funparam[0] = a

        break
    end
end

// vim: set syntax=c ts=4 sw=4 et:

bc

iterative

#! /usr/bin/bc -q

define fib(x) {
    if (x <= 0) return 0;
    if (x == 1) return 1;

    a = 0;
    b = 1;
    for (i = 1; i < x; i++) {
        c = a+b; a = b; b = c;
    }
    return c;
}
fib(1000)
quit

BCPL

get "libhdr"

let fib(n) = n<=1 -> n, valof
$(  let a=0 and b=1
    for i=2 to n
    $(  let c=a
        a := b
        b := a+c
    $)
    resultis b
$)

let start() be
    for i=0 to 10 do
        writef("F_%N*T= %N*N", i, fib(i))

Output:

F_0     = 0
F_1     = 1
F_2     = 1
F_3     = 2
F_4     = 3
F_5     = 5
F_6     = 8
F_7     = 13
F_8     = 21
F_9     = 34
F_10    = 55

beeswax

                        #>'#{;
_`Enter n: `TN`Fib(`{`)=`X~P~K#{;
                         #>~P~L#MM@>+@'q@{;
                                    b~@M<

Example output:

Notice the UInt64 wrap-around at Fib(94)!

julia> beeswax("n-th Fibonacci number.bswx")
Enter n: i0

Fib(0)=0
Program finished!

julia> beeswax("n-th Fibonacci number.bswx")
Enter n: i10
         
Fib(10)=55
Program finished!

julia> beeswax("n-th Fibonacci number.bswx")
Enter n: i92

Fib(92)=7540113804746346429
Program finished!

julia> beeswax("n-th Fibonacci number.bswx")
Enter n: i93
                                                                             
Fib(93)=12200160415121876738                                                 
Program finished!                                                            

julia> beeswax("n-th Fibonacci number.bswx")
Enter n: i94                                                                 
                                                                             
Fib(94)=1293530146158671551                                                  
Program finished!

Befunge

00:.1:.>:"@"8**++\1+:67+`#@_v
       ^ .:\/*8"@"\%*8"@":\ <

BlitzMax

local a:int = 0, b:int = 1, c:int = 1, n:int

n = int(input( "Enter n: "))
if n = 0 then
    print 0
    end
else if n = 1
    print 1
    end
end if

while n>2
    a = b
    b = c
    c = a + b
    n = n - 1
wend
print c

Blue

: fib ( nth:ecx -- result:edi ) 1 0 
: compute ( times:ecx accum:eax scratch:edi -- result:edi ) xadd latest loop ;

: example ( -- ) 11 fib drop ;

BQN

All given functions return the nth element in the sequence.

Recursive

A primitive recursive can be done with predicates:

Fib ← {𝕩>1 ? (𝕊 𝕩-1) + 𝕊 𝕩-2; 𝕩}

Or, it can be done with the Choose(◶) modifier:

Fib2 ← {(𝕩-1) (𝕩>1)◶⟨𝕩, +○𝕊⟩ 𝕩-2}

Iterative

An iterative solution can be made with the Repeat(⍟) modifier:

{⊑(+`⌽)⍟𝕩 0‿1}

Bracmat

Recursive

fib=.!arg:<2|fib$(!arg+-2)+fib$(!arg+-1)

 fib$30
 832040

Iterative

(fib=
  last i this new
.   !arg:<2
  |   0:?last:?i
    & 1:?this
    &   whl
      ' ( !i+1:<!arg:?i
        & !last+!this:?new
        & !this:?last
        & !new:?this
        )
    & !this
)

 fib$777
 1081213530912648191985419587942084110095342850438593857649766278346130479286685742885693301250359913460718567974798268702550329302771992851392180275594318434818082

Brainf***

Works with: Brainf*** version implementations with unbounded cell size

The first cell contains n (10), the second cell will contain fib(n) (55), and the third cell will contain fib(n-1) (34).

++++++++++
>>+<<[->[->+>+<<]>[-<+>]>[-<+>]<<<]

The following generates n fibonacci numbers and prints them, though not in ascii. It does have a limit due to the cells usually being 1 byte in size.

+++++ +++++	#0 set to n
>> +		Init #2 to 1
<<
[
	-	#Decrement counter in #0
	>>.	Notice: This doesn't print it in ascii
		To look at results you can pipe into a file and look with a hex editor
	
		Copying sequence to save #2 in #4 using #5 as restore space
	>>[-]	Move to #4 and clear
	>[-]	Clear #5
	<<<	#2
	[	Move loop
		- >> + > + <<<	Subtract #2 and add #4 and #5
	]
	>>>
	[	Restore loop
		- <<< + >>>	Subtract from #5 and add to #2
	]

	<<<<	Back to #1
		Non destructive add sequence using #3 as restore value
	[	Loop to add
		- > + > + <<	Subtract #1 and add to value #2 and restore space #3
	]
	>>
	[	Loop to restore #1 from #3
		- << + >>	Subtract from restore space #3 and add in #1
	]
	
	<< [-]	Clear #1
	>>>
	[	Loop to move #4 to #1
		- <<< + >>>	Subtract from #4 and add to #1
	]
	<<<<	Back to #0
]

Brat

Recursive

fibonacci = { x |
        true? x < 2, x, { fibonacci(x - 1) + fibonacci(x - 2) }
}

Tail Recursive

fib_aux = { x, next, result |
        true? x == 0,
                result,
                { fib_aux x - 1, next + result, next }
}

fibonacci = { x |
  fib_aux x, 1, 0
}

Memoization

cache = hash.new

fibonacci = { x |
  true? cache.key?(x)
    { cache[x] }
    {true? x < 2, x, { cache[x] = fibonacci(x - 1) + fibonacci(x - 2) }}
}

Bruijn

:import std/Combinator .
:import std/Math .
:import std/List .

# unary/Church fibonacci (moderately fast but very high space complexity)
fib-unary [0 [[[2 0 [2 (1 0)]]]] k i]

:test (fib-unary (+6u)) ((+8u))

# ternary fibonacci using infinite list iteration (very fast)
fib-list \index fibs
	fibs head <$> (iterate &[[0 : (1 + 0)]] ((+0) : (+1)))

:test (fib-list (+6)) ((+8))

# recursive fib (very slow)
fib-rec y [[0 <? (+1) (+0) (0 <? (+2) (+1) rec)]]
	rec (1 --0) + (1 --(--0))

:test (fib-rec (+6)) ((+8))

Performance using HigherOrder reduction without optimizations:

> :time fib-list (+1000)
0.9 seconds
> :time fib-unary (+50u)
1.7 seconds
> :time fib-rec (+25)
5.1 seconds
> :time fib-list (+50)
0.0006 seconds

Burlesque

{0 1}{^^++[+[-^^-]\/}30.*\[e!vv

0 1{{.+}c!}{1000.<}w!

C

Recursive

long long fibb(long long a, long long b, int n) {
    return (--n>0)?(fibb(b, a+b, n)):(a);
}

Iterative

long long int fibb(int n) {
	int fnow = 0, fnext = 1, tempf;
	while(--n>0){
		tempf = fnow + fnext;
		fnow = fnext;
		fnext = tempf;
		}
		return fnext;	
}

Analytic

#include <tgmath.h>
#define PHI ((1 + sqrt(5))/2)

long long unsigned fib(unsigned n) {
    return floor( (pow(PHI, n) - pow(1 - PHI, n))/sqrt(5) );
}

Generative

Translation of: Python

Works with: gcc version version 4.1.2 20080704 (Red Hat 4.1.2-44)

#include <stdio.h>
typedef enum{false=0, true=!0} bool;
typedef void iterator;

#include <setjmp.h>
/* declare label otherwise it is not visible in sub-scope */
#define LABEL(label) jmp_buf label; if(setjmp(label))goto label;
#define GOTO(label) longjmp(label, true)

/* the following line is the only time I have ever required "auto" */
#define FOR(i, iterator) { auto bool lambda(i); yield_init = (void *)&lambda; iterator; bool lambda(i)
#define DO {
#define     YIELD(x) if(!yield(x))return
#define     BREAK    return false
#define     CONTINUE return true
#define OD CONTINUE; } }

static volatile void *yield_init; /* not thread safe */
#define YIELDS(type) bool (*yield)(type) = yield_init

iterator fibonacci(int stop){
    YIELDS(int);
    int f[] = {0, 1};
    int i;
    for(i=0; i<stop; i++){
        YIELD(f[i%2]);
        f[i%2]=f[0]+f[1];
    }
}

main(){
  printf("fibonacci: ");
  FOR(int i, fibonacci(16)) DO
    printf("%d, ",i);
  OD;
  printf("...\n");
}

Output:

fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, ...

Fast method for a single large value

#include <stdlib.h>
#include <stdio.h>
#include <gmp.h>

typedef struct node node;
struct node {
	int n;
	mpz_t v;
	node *next;
};

#define CSIZE 37
node *cache[CSIZE];

// very primitive linked hash table
node * find_cache(int n)
{
	int idx = n % CSIZE;
	node *p;

	for (p = cache[idx]; p && p->n != n; p = p->next);
	if (p) return p;

	p = malloc(sizeof(node));
	p->next = cache[idx];
	cache[idx] = p;

	if (n < 2) {
		p->n = n;
		mpz_init_set_ui(p->v, 1);
	} else {
		p->n = -1; // -1: value not computed yet
		mpz_init(p->v);
	}
	return p;
}

mpz_t tmp1, tmp2;
mpz_t *fib(int n)
{
	int x;
	node *p = find_cache(n);

	if (p->n < 0) {
		p->n = n;
		x = n / 2;

		mpz_mul(tmp1, *fib(x-1), *fib(n - x - 1));
		mpz_mul(tmp2, *fib(x), *fib(n - x));
		mpz_add(p->v, tmp1, tmp2);
	}
	return &p->v;
}

int main(int argc, char **argv)
{
	int i, n;
	if (argc < 2) return 1;

	mpz_init(tmp1);
	mpz_init(tmp2);

	for (i = 1; i < argc; i++) {
		n = atoi(argv[i]);
		if (n < 0) {
			printf("bad input: %s\n", argv[i]);
			continue;
		}

		// about 75% of time is spent in printing
		gmp_printf("%Zd\n", *fib(n));
	}
	return 0;
}

Output:

% ./a.out 0 1 2 3 4 5
1
1
2
3
5
8
% ./a.out 10000000 | wc -c    # count length of output, including the newline
1919488

C#

Recursive

public static ulong Fib(uint n) {
    return (n < 2)? n : Fib(n - 1) + Fib(n - 2);
}

Tail-Recursive

public static ulong Fib(uint n) {
    return Fib(0, 1, n);
}

private static ulong Fib(ulong a, ulong b, uint n) {
    return (n < 1)? a :(n == 1)?  b : Fib(b, a + b, n - 1);
}

Iterative

public static ulong Fib(uint x) {
    if (x == 0) return 0;

    ulong prev = 0;
    ulong next = 1;
    for (int i = 1; i < x; i++)
    {
        ulong sum = prev + next;
        prev = next;
        next = sum;
    }
    return next;
}

Iterative

using System; using System.Text; // FIBRUS.cs Russia
namespace Fibrus { class Program { static void Main() 
{ long fi1=1; long fi2=1; long fi3=1; int da; int i; int d; 
for (da=1; da<=78; da++) // rextester.com/MNGUV70257
    { d = 20-Convert.ToInt32((Convert.ToString(fi3)).Length);
    for (i=1; i<d; i++) Console.Write(".");
Console.Write(fi3); Console.Write(" "); Console.WriteLine(da);
    fi3 = fi2 + fi1;
    fi1 = fi2;
    fi2 = fi3;
}}}}

Output:

..................1 1
..................2 2
..................3 3
...
...5527939700884757 76
...8944394323791464 77
..14472334024676221 78

Eager-Generative

public static IEnumerable<long> Fibs(uint x) {
    IList<ulong> fibs = new List<ulong>();

    ulong prev = -1;
    ulong next = 1;
    for (int i = 0; i < x; i++)
    {
     long sum = prev + next;
        prev = next;
        next = sum;
        fibs.Add(sum); 
    }
    return fibs;
}

Lazy-Generative

public static IEnumerable<ulong> Fibs(uint x) {
    ulong prev = -1;
    ulong next = 1;
    for (uint i = 0; i < x; i++) {
        ulong sum = prev + next;
        prev = next;
        next = sum;
        yield return sum;
    }
}

Analytic

This returns digits up to the 93^rd Fibonacci number, but the digits become inaccurate past the 71^st. There is custom rounding applied to the result that allows the function to be accurate at the 71^st number instead of topping out at the 70^th.

static double r5 = Math.Sqrt(5.0), Phi = (r5 + 1.0) / 2.0;

static ulong fib(uint n) {
    if (n > 71) throw new ArgumentOutOfRangeException("n", n, "Needs to be smaller than 72."); 
    double r = Math.Pow(Phi, n) / r5; 
    return (ulong)(n < 64 ? Math.Round(r) : Math.Floor(r)); }

To get to the 93^rd Fibonacci number, one must use the decimal type, rather than the double type, like this:

static decimal Sqrt_dec(decimal x, decimal g) { decimal t, lg;
    do { t = x / g; lg = g; g = (t + g) / 2M; } while (lg != g);
    return g; }

static decimal Pow_dec (decimal bas, uint exp) {
    if (exp == 0) return 1M;
    decimal tmp = Pow_dec(bas, exp >> 1); tmp *= tmp;
    if ((exp & 1) == 1) tmp *= bas; return tmp; }

static decimal r5 = Sqrt_dec(5.0M, (decimal)Math.Sqrt(5.0)),
               Phi = (r5 + 1.0M) / 2.0M;

static ulong fib(uint n) {
    if (n > 93) throw new ArgumentOutOfRangeException("n", n, "Needs to be smaller than 94."); 
    decimal r = Pow_dec(Phi, n) / r5; 
    return (ulong)(n < 64 ? Math.Round(r) : Math.Floor(r)); }

Note that the Math.Pow() function and the Math.Sqrt() function must be replaced with ones returning the decimal type.

If one allows the fib() function to return the decimal type, one can reach the 138^th Fibonacci number. However, the accuracy is lost after the 128^th.

static decimal Sqrt_dec(decimal x, decimal g) { decimal t, lg;
    do { t = x / g; lg = g; g = (t + g) / 2M; } while (lg != g);
    return g; }

static decimal Pow_dec (decimal bas, uint exp) {
    if (exp == 0) return 1M;
    decimal tmp = Pow_dec(bas, exp >> 1); tmp *= tmp;
    if ((exp & 1) == 1) tmp *= bas; return tmp; }

static decimal r5 = Sqrt_dec(5.0M, (decimal)Math.Sqrt(5.0)),
               Phi = (r5 + 1.0M) / 2.0M;

static decimal fib(uint n) {
    if (n > 128) throw new ArgumentOutOfRangeException("n", n, "Needs to be smaller than 129."); 
    decimal r = Pow_dec(Phi, n) / r5; 
    return n < 64 ? Math.Round(r) : Math.Floor(r); }

Matrix

Algorithm is based on

{\begin{pmatrix}1&1\\1&0\end{pmatrix}}^{n}={\begin{pmatrix}F(n+1)&F(n)\\F(n)&F(n-1)\end{pmatrix}}

.

Needs System.Windows.Media.Matrix or similar Matrix class. Calculates in $O(n)$ .

public static ulong Fib(uint n) {
    var M = new Matrix(1,0,0,1);
    var N = new Matrix(1,1,1,0);
    for (uint i = 1; i < n; i++) M *= N;
    return (ulong)M[0][0];
}

Needs System.Windows.Media.Matrix or similar Matrix class. Calculates in $O(\log {n})$ .

private static Matrix M;
private static readonly Matrix N = new Matrix(1,1,1,0);

public static ulong Fib(uint n) {
    M = new Matrix(1,0,0,1);
    MatrixPow(n-1);
    return (ulong)M[0][0];
}

private static void MatrixPow(double n){
    if (n > 1) {
        MatrixPow(n/2);
        M *= M;
    }
    if (n % 2 == 0) M *= N;
}

Array (Table) Lookup

private static int[] fibs = new int[]{ -1836311903, 1134903170, 
  -701408733, 433494437, -267914296, 165580141, -102334155, 
  63245986, -39088169, 24157817, -14930352, 9227465, -5702887, 
  3524578, -2178309, 1346269, -832040, 514229, -317811, 196418, 
  -121393, 75025, -46368, 28657, -17711, 10946, -6765, 4181, 
  -2584, 1597, -987, 610, -377, 233, -144, 89, -55, 34, -21, 13, 
  -8, 5, -3, 2, -1, 1, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 
  144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711,
  28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040,
  1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817,
  39088169, 63245986, 102334155, 165580141, 267914296, 433494437,
  701408733, 1134903170, 1836311903};

public static int Fib(int n) {
    if(n < -46 || n > 46) throw new ArgumentOutOfRangeException("n", n, "Has to be between -46 and 47.")
    return fibs[n+46];
}

Arbitrary Precision

Library: System.Numerics

This large step recurrence routine can calculate the two millionth Fibonacci number in under 1 / 5 second at tio.run. This routine can generate the fifty millionth Fibonacci number in under 30 seconds at tio.run. The unused conventional iterative method times out at two million on tio.run, you can only go to around 1,290,000 or so to keep the calculation time (plus string conversion time) under the 60 second timeout limit there. When using this large step recurrence method, it takes around 5 seconds to convert the two millionth Fibonacci number (417975 digits) into a string (so that one may count those digits).

using System;
using System.Collections.Generic;
using BI = System.Numerics.BigInteger;
 
class Program
{
    // A sparse array of values calculated along the way
    static SortedList<int, BI> sl = new SortedList<int, BI>();
 
    // This routine is semi-recursive, but doesn't need to evaluate every number up to n.
    // Algorithm from here: http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormula.html#section3
    static BI Fsl(int n)
    {
        if (n < 2) return n;
        int n2 = n >> 1, pm = n2 + ((n & 1) << 1) - 1; IfNec(n2); IfNec(pm);
        return n2 > pm ? (2 * sl[pm] + sl[n2]) * sl[n2] : sqr(sl[n2]) + sqr(sl[pm]);
        // Helper routine for Fsl(). It adds an entry to the sorted list when necessary
        void IfNec(int x) { if (!sl.ContainsKey(x)) sl.Add(x, Fsl(x)); }
        // Helper function to square a BigInteger
        BI sqr(BI x) { return x * x; }
    }
 
    // Conventional iteration method (not used here)
    public static BI Fm(BI n)
    {
        if (n < 2) return n; BI cur = 0, pre = 1;
        for (int i = 0; i <= n - 1; i++) { BI sum = cur + pre; pre = cur; cur = sum; }
        return cur;
    }
 
    public static void Main()
    {
        int num = 2_000_000, digs = 35, vlen;
        var sw = System.Diagnostics.Stopwatch.StartNew(); var v = Fsl(num); sw.Stop();
        Console.Write("{0:n3} ms to calculate the {1:n0}th Fibonacci number, ",
          sw.Elapsed.TotalMilliseconds, num);
        Console.WriteLine("number of digits is {0}", vlen = (int)Math.Ceiling(BI.Log10(v)));
        if (vlen < 10000) {
            sw.Restart(); Console.WriteLine(v); sw.Stop();
            Console.WriteLine("{0:n3} ms to write it to the console.", sw.Elapsed.TotalMilliseconds);
        } else
            Console.Write("partial: {0}...{1}", v / BI.Pow(10, vlen - digs), v % BI.Pow(10, digs));
    }
}

Output:

137.209 ms to calculate the 2,000,000th Fibonacci number, number of digits is 417975
partial: 85312949175076415430516606545038251...91799493108960825129188777803453125

Shift PowerMod

Library: System.Numerics

Illustrated here is an algorithm to compute a Fibonacci number directly, without needing to calculate any of the Fibonacci numbers less than the desired result. It uses shifting and the power mod function (BigInteger.ModPow() in C#). It calculates more quickly than the large step recurrence routine (illustrated above) for smaller Fibonacci numbers (less than 2800 digits or so, around Fibonacci(13000)), but gets slower for larger ones, as the intermediate BigIntegers created are very large, much larger than the Fibonacci result.

Also included is a routine that returns an array of Fibonacci numbers (fibTab()). It reuses the intermediate large shifted BigIntegers on suceeding iterations, therfore it is a little more efficient than calling the oneshot (oneFib()) routine repeatedly from a loop.

using System;
using BI = System.Numerics.BigInteger;

class Program {
  
  // returns the nth Fibonacci number without calculating 0..n-1
  static BI oneFib(int n) {
    BI z = (BI)1 << ++n;
    return BI.ModPow(z, n, (z << n) - z - 1) % z;
  }

  // returns an array of Fibonacci numbers from the 0th to the nth
  static BI[] fibTab(int n) {
    var res = new BI[++n];
    BI z = (BI)1 << 1, zz = z << 1;
    for (int i = 0; i < n; ) {
      res[i] = BI.ModPow(z, ++i, zz - z - 1) % z;
      z <<= 1; zz <<= 2;
    }
    return res;
  }
  
  static void Main(string[] args) {
    int n = 20;
    Console.WriteLine("Fibonacci numbers 0..{0}: {1}", n, string.Join(" ",fibTab(n)));
    n = 1000;
    Console.WriteLine("Fibonacci({0}): {1}", n, oneFib(n));
  }
}

Output:

Fibonacci numbers 0..20: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
Fibonacci(1000): 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875

C++

Using unsigned int, this version only works up to 48 before fib overflows.

#include <iostream>

int main()
{
        unsigned int a = 1, b = 1;
        unsigned int target = 48;
        for(unsigned int n = 3; n <= target; ++n)
        {
                unsigned int fib = a + b;
                std::cout << "F("<< n << ") = " << fib << std::endl;
                a = b;
                b = fib;
        }

        return 0;
}

Library: GMP

This version does not have an upper bound.

#include <iostream>
#include <gmpxx.h>

int main()
{
        mpz_class a = mpz_class(1), b = mpz_class(1);
        mpz_class target = mpz_class(100);
        for(mpz_class n = mpz_class(3); n <= target; ++n)
        {
                mpz_class fib = b + a;
                if ( fib < b )
                {
                        std::cout << "Overflow at " << n << std::endl;
                        break;
                }
                std::cout << "F("<< n << ") = " << fib << std::endl;
                a = b;
                b = fib;
        }
        return 0;
}

Version using transform:

#include <algorithm>
#include <vector>
#include <functional>
#include <iostream>
 
unsigned int fibonacci(unsigned int n) {
  if (n == 0) return 0;
  std::vector<int> v(n+1);
  v[1] = 1;
  transform(v.begin(), v.end()-2, v.begin()+1, v.begin()+2, std::plus<int>());
  // "v" now contains the Fibonacci sequence from 0 up
  return v[n];
}

Far-fetched version using adjacent_difference:

#include <numeric>
#include <vector>
#include <functional>
#include <iostream>

unsigned int fibonacci(unsigned int n) {
  if (n == 0) return 0;
  std::vector<int> v(n, 1);
  adjacent_difference(v.begin(), v.end()-1, v.begin()+1, std::plus<int>());
  // "array" now contains the Fibonacci sequence from 1 up
  return v[n-1];
}

Version which computes at compile time with metaprogramming:

#include <iostream>

template <int n> struct fibo
{
    enum {value=fibo<n-1>::value+fibo<n-2>::value};
};
 
template <> struct fibo<0>
{
    enum {value=0};
};

template <> struct fibo<1>
{
    enum {value=1};
};


int main(int argc, char const *argv[])
{
    std::cout<<fibo<12>::value<<std::endl;
    std::cout<<fibo<46>::value<<std::endl;
    return 0;
}

The following version is based on fast exponentiation:

#include <iostream>

inline void fibmul(int* f, int* g)
{
  int tmp = f[0]*g[0] + f[1]*g[1];
  f[1] = f[0]*g[1] + f[1]*(g[0] + g[1]);
  f[0] = tmp;
}

int fibonacci(int n)
{
  int f[] = { 1, 0 };
  int g[] = { 0, 1 };
  while (n > 0)
  {
    if (n & 1) // n odd
    {
      fibmul(f, g);
      --n;
    }
    else
    {
      fibmul(g, g);
      n >>= 1;
    }
  }
  return f[1];
}

int main()
{
  for (int i = 0; i < 20; ++i)
    std::cout << fibonacci(i) << " ";
  std::cout << std::endl;
}

Output:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

Using Zeckendorf Numbers

The nth fibonacci is represented as Zeckendorf 1 followed by n-1 zeroes. Here I define a class N which defines the operations increment ++() and comparison <=(other N) for Zeckendorf Numbers.

// Use Zeckendorf numbers to display Fibonacci sequence.
// Nigel Galloway October 23rd., 2012
int main(void) {
  char NG[22] = {'1',0};
  int x = -1;
  N G;
  for (int fibs = 1; fibs <= 20; fibs++) {
   for (;G <= N(NG); ++G) x++;
   NG[fibs] = '0';
   NG[fibs+1] = 0;
   std::cout << x << " ";
  }
  std::cout << std::endl;
  return 0;
}

Output:

1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946

Using Standard Template Library

Possibly less "Far-fetched version".

// Use Standard Template Library to display Fibonacci sequence.
// Nigel Galloway March 30th., 2013
#include <algorithm>
#include <iostream>
#include <iterator>
int main()
{
   int x = 1, y = 1;
   generate_n(std::ostream_iterator<int>(std::cout, " "), 21, [&]{int n=x; x=y; y+=n; return n;});
   return 0;
}

Output:

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946

Cat

define fib {
  dup 1 <=
    []
    [dup 1 - fib swap 2 - fib +]
  if
}

Chapel

iter fib() {
        var a = 0, b = 1;

        while true {
                yield a;
                (a, b) = (b, b + a);
        }
}

Chef

Stir-Fried Fibonacci Sequence.

An unobfuscated iterative implementation.
It prints the first N + 1 Fibonacci numbers,
where N is taken from standard input.

Ingredients.
0 g last
1 g this
0 g new
0 g input

Method.
Take input from refrigerator.
Put this into 4th mixing bowl.
Loop the input.
Clean the 3rd mixing bowl.
Put last into 3rd mixing bowl.
Add this into 3rd mixing bowl.
Fold new into 3rd mixing bowl.
Clean the 1st mixing bowl.
Put this into 1st mixing bowl.
Fold last into 1st mixing bowl.
Clean the 2nd mixing bowl.
Put new into 2nd mixing bowl.
Fold this into 2nd mixing bowl.
Put new into 4th mixing bowl.
Endloop input until looped.
Pour contents of the 4th mixing bowl into baking dish.

Serves 1.

Chez Scheme

(define fib (lambda (n) (cond ((> n 1) (+ (fib (- n 1)) (fib (- n 2)))) 
                              ((= n 1) 1) 
                              ((= n 0) 0))))

Clio

Clio is pure and functions are lazy and memoized by default

fn fib n:
  if n < 2: n
  else: (n - 1 -> fib) + (n - 2 -> fib)

[0:100] -> * fib -> * print

Clojure

Lazy Sequence

This is implemented idiomatically as an infinitely long, lazy sequence of all Fibonacci numbers:

(defn fibs []
  (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))

Thus to get the nth one:

(nth (fibs) 5)

So long as one does not hold onto the head of the sequence, this is unconstrained by length.

The one-line implementation may look confusing at first, but on pulling it apart it actually solves the problem more "directly" than a more explicit looping construct.

(defn fibs []
  (map first ;; throw away the "metadata" (see below) to view just the fib numbers
       (iterate ;; create an infinite sequence of [prev, curr] pairs
         (fn [[a b]] ;; to produce the next pair, call this function on the current pair
           [b (+ a b)]) ;; new prev is old curr, new curr is sum of both previous numbers
         [0 1]))) ;; recursive base case: prev 0, curr 1

A more elegant solution is inspired by the Haskell implementation of an infinite list of Fibonacci numbers:

(def fib (lazy-cat [0 1] (map + fib (rest fib))))

Then, to see the first ten,

user> (take 10 fib)
(0 1 1 2 3 5 8 13 21 34)

Iterative

Here's a simple interative process (using a recursive function) that carries state along with it (as args) until it reaches a solution:

;; max is which fib number you'd like computed (0th, 1st, 2nd, etc.)
;; n is which fib number you're on for this call (0th, 1st, 2nd, etc.)
;; j is the nth fib number (ex. when n = 5, j = 5)
;; i is the nth - 1 fib number
(defn- fib-iter
  [max n i j]
  (if (= n max)
    j
    (recur max
           (inc n)
           j
           (+ i j))))

(defn fib
  [max]
  (if (< max 2)
    max
    (fib-iter max 1 0N 1N)))

"defn-" means that the function is private (for use only inside this library). The "N" suffixes on integers tell Clojure to use arbitrary precision ints for those.

Doubling Algorithm (Fast)

Based upon the doubling algorithm which computes in O(log (n)) time as described here https://www.nayuki.io/page/fast-fibonacci-algorithms Implementation credit: https://stackoverflow.com/questions/27466311/how-to-implement-this-fast-doubling-fibonacci-algorithm-in-clojure/27466408#27466408

(defn fib [n]
  (letfn [(fib* [n]
            (if (zero? n)
              [0 1]
              (let [[a b] (fib* (quot n 2))
                    c (*' a (-' (*' 2 b) a))
                    d (+' (*' b b) (*' a a))]
                (if (even? n)
                  [c d]
                  [d (+' c d)]))))]
    (first (fib* n))))

Recursive

A naive slow recursive solution:

(defn fib [n]
  (case n
    0 0
    1 1
    (+ (fib (- n 1))
       (fib (- n 2)))))

This can be improved to an O(n) solution, like the iterative solution, by memoizing the function so that numbers that have been computed are cached. Like a lazy sequence, this also has the advantage that subsequent calls to the function use previously cached results rather than recalculating.

(def fib
  (memoize
    (fn [n]
      (case n
        0 0
        1 1
        (+ (fib (- n 1))
           (fib (- n 2)))))))

Using core.async

(ns fib.core)
(require '[clojure.core.async
           :refer [<! >! >!! <!! timeout chan alt! go]])

(defn fib [c]
  (loop [a 0 b 1]
    (>!! c a)
    (recur b (+ a b))))


(defn -main []
  (let [c (chan)]
    (go (fib c))
    (dorun
      (for [i (range 10)]
        (println (<!! c))))))

CLU

% Generate Fibonacci numbers
fib = iter () yields (int)
    a: int := 0
    b: int := 1
    
    while true do
        yield (a)
        a, b := b, a+b
    end
end fib

% Grab the n'th value from an iterator 
nth = proc [T: type] (g: itertype () yields (T), n: int) returns (T)
    for v: T in g() do
        if n<=0 then return (v) end
        n := n-1
    end
end nth

% Print a few values
start_up = proc ()
    po: stream := stream$primary_output()
    
    % print values coming out of the fibonacci iterator
    % (which are generated one after the other without delay)
    count: int := 0
    for f: int in fib() do 
        stream$putl(po, "F(" || int$unparse(count) || ") = " || int$unparse(f))
        count := count + 1
        if count = 15 then break end
    end
    
    % print a few random fibonacci numbers
    % (to do this it has to restart at the beginning for each 
    % number, making it O(N))
    fibs: sequence[int] := sequence[int]$[20,30,50]
    for n: int in sequence[int]$elements(fibs) do
        stream$putl(po, "F(" || int$unparse(n) || ") = "
                             || int$unparse(nth[int](fib, n)))
    end
end start_up

Output:

F(0) = 0
F(1) = 1
F(2) = 1
F(3) = 2
F(4) = 3
F(5) = 5
F(6) = 8
F(7) = 13
F(8) = 21
F(9) = 34
F(10) = 55
F(11) = 89
F(12) = 144
F(13) = 233
F(14) = 377
F(20) = 6765
F(30) = 832040
F(50) = 12586269025

CMake

Iteration uses a while() loop. Memoization uses global properties.

set_property(GLOBAL PROPERTY fibonacci_0 0)
set_property(GLOBAL PROPERTY fibonacci_1 1)
set_property(GLOBAL PROPERTY fibonacci_next 2)

# var = nth number in Fibonacci sequence.
function(fibonacci var n)
  # If the sequence is too short, compute more Fibonacci numbers.
  get_property(next GLOBAL PROPERTY fibonacci_next)
  if(NOT next GREATER ${n})
    # a, b = last 2 Fibonacci numbers
    math(EXPR i "${next} - 2")
    get_property(a GLOBAL PROPERTY fibonacci_${i})
    math(EXPR i "${next} - 1")
    get_property(b GLOBAL PROPERTY fibonacci_${i})

    while(NOT next GREATER ${n})
      math(EXPR i "${a} + ${b}")  # i = next Fibonacci number
      set_property(GLOBAL PROPERTY fibonacci_${next} ${i})
      set(a ${b})
      set(b ${i})
      math(EXPR next "${next} + 1")
    endwhile()
    set_property(GLOBAL PROPERTY fibonacci_next ${next})
  endif()

  get_property(answer GLOBAL PROPERTY fibonacci_${n})
  set(${var} ${answer} PARENT_SCOPE)
endfunction(fibonacci)

# Test program: print 0th to 9th and 25th to 30th Fibonacci numbers.
set(s "")
foreach(i RANGE 0 9)
  fibonacci(f ${i})
  set(s "${s} ${f}")
endforeach(i)
set(s "${s} ... ")
foreach(i RANGE 25 30)
  fibonacci(f ${i})
  set(s "${s} ${f}")
endforeach(i)
message(${s})

 0 1 1 2 3 5 8 13 21 34 ... 75025 121393 196418 317811 514229 832040

COBOL

Iterative

Program-ID. Fibonacci-Sequence.
Data Division.
Working-Storage Section.
  01  FIBONACCI-PROCESSING.
    05  FIBONACCI-NUMBER  PIC 9(36)   VALUE 0.
    05  FIB-ONE           PIC 9(36)   VALUE 0.
    05  FIB-TWO           PIC 9(36)   VALUE 1.
  01  DESIRED-COUNT       PIC 9(4).
  01  FORMATTING.
    05  INTERM-RESULT     PIC Z(35)9.
    05  FORMATTED-RESULT  PIC X(36).
    05  FORMATTED-SPACE   PIC x(35).
Procedure Division.
  000-START-PROGRAM.
    Display "What place of the Fibonacci Sequence would you like (<173)? " with no advancing.
    Accept DESIRED-COUNT.
    If DESIRED-COUNT is less than 1
      Stop run.
    If DESIRED-COUNT is less than 2
      Move FIBONACCI-NUMBER to INTERM-RESULT
      Move INTERM-RESULT to FORMATTED-RESULT
      Unstring FORMATTED-RESULT delimited by all spaces into FORMATTED-SPACE,FORMATTED-RESULT
      Display FORMATTED-RESULT
      Stop run.
    Subtract 1 from DESIRED-COUNT.
    Move FIBONACCI-NUMBER to INTERM-RESULT.
    Move INTERM-RESULT to FORMATTED-RESULT.
    Unstring FORMATTED-RESULT delimited by all spaces into FORMATTED-SPACE,FORMATTED-RESULT.
    Display FORMATTED-RESULT.
    Perform 100-COMPUTE-FIBONACCI until DESIRED-COUNT = zero.
    Stop run.
  100-COMPUTE-FIBONACCI.
    Compute FIBONACCI-NUMBER = FIB-ONE + FIB-TWO.
    Move FIB-TWO to FIB-ONE.
    Move FIBONACCI-NUMBER to FIB-TWO.
    Subtract 1 from DESIRED-COUNT.
    Move FIBONACCI-NUMBER to INTERM-RESULT.
    Move INTERM-RESULT to FORMATTED-RESULT.
    Unstring FORMATTED-RESULT delimited by all spaces into FORMATTED-SPACE,FORMATTED-RESULT.
    Display FORMATTED-RESULT.

Recursive

Works with: GNU Cobol version 2.0

       >>SOURCE FREE
IDENTIFICATION DIVISION.
PROGRAM-ID. fibonacci-main.

DATA DIVISION.
WORKING-STORAGE SECTION.
01  num                                 PIC 9(6) COMP.
01  fib-num                             PIC 9(6) COMP.

PROCEDURE DIVISION.
    ACCEPT num
    CALL "fibonacci" USING CONTENT num RETURNING fib-num
    DISPLAY fib-num
    .
END PROGRAM fibonacci-main.

IDENTIFICATION DIVISION.
PROGRAM-ID. fibonacci RECURSIVE.

DATA DIVISION.
LOCAL-STORAGE SECTION.
01  1-before                            PIC 9(6) COMP.
01  2-before                            PIC 9(6) COMP.

LINKAGE SECTION.
01  num                                 PIC 9(6) COMP.

01  fib-num                             PIC 9(6) COMP BASED.

PROCEDURE DIVISION USING num RETURNING fib-num.
    ALLOCATE fib-num
    EVALUATE num
        WHEN 0
            MOVE 0 TO fib-num
        WHEN 1
            MOVE 1 TO fib-num
        WHEN OTHER
            SUBTRACT 1 FROM num
            CALL "fibonacci" USING CONTENT num RETURNING 1-before
            SUBTRACT 1 FROM num
            CALL "fibonacci" USING CONTENT num RETURNING 2-before
            ADD 1-before TO 2-before GIVING fib-num
    END-EVALUATE
    .
END PROGRAM fibonacci.

CoffeeScript

Analytic

fib_ana = (n) ->
    sqrt = Math.sqrt
    phi = ((1 + sqrt(5))/2)
    Math.round((Math.pow(phi, n)/sqrt(5)))

Iterative

fib_iter = (n) ->
    return n if n < 2
    [prev, curr] = [0, 1]
    [prev, curr] = [curr, curr + prev] for i in [1..n]
    curr

Recursive

fib_rec = (n) ->
  if n < 2 then n else fib_rec(n-1) + fib_rec(n-2)

Comefrom0x10

Recursion is is not possible in Comefrom0x10.

Iterative

stop = 6
a = 1
i = 1  # start
a      # print result

fib
  comefrom if i is 1  # start
  b = 1
  comefrom fib        # start of loop
  i = i + 1
  next_b = a + b
  a = b
  b = next_b

  comefrom fib if i > stop

Common Lisp

Note that Common Lisp uses bignums, so this will never overflow.

Iterative

(defun fibonacci-iterative (n &aux (f0 0) (f1 1))
  (case n
    (0 f0)
    (1 f1)
    (t (loop for n from 2 to n
             for a = f0 then b and b = f1 then result
             for result = (+ a b)
             finally (return result)))))

Simpler one:

(defun fibonacci (n)
  (let ((a 0) (b 1) (c n))
    (loop for i from 2 to n do
	 (setq c (+ a b)
	       a b
	       b c))
    c))

Not a function, just printing out the entire (for some definition of "entire") sequence with a for var = loop:

(loop for x = 0 then y and y = 1 then (+ x y) do (print x))

Recursive

(defun fibonacci-recursive (n)
  (if (< n 2)
      n
     (+ (fibonacci-recursive (- n 2)) (fibonacci-recursive (- n 1)))))

(defun fibonacci-tail-recursive ( n &optional (a 0) (b 1))
  (if (= n 0) 
      a 
      (fibonacci-tail-recursive (- n 1) b (+ a b))))

Tail recursive and squaring:

(defun fib (n &optional (a 1) (b 0) (p 0) (q 1))
    (if (= n 1) (+ (* b p) (* a q))
     (fib (ash n -1) 
          (if (evenp n) a (+ (* b q) (* a (+ p q))))
          (if (evenp n) b (+ (* b p) (* a q)))
          (+ (* p p) (* q q))
          (+ (* q q) (* 2 p q))))) ;p is Fib(2^n-1), q is Fib(2^n).

(print (fib 100000))

Alternate solution

I use Allegro CL 10.1

;; Project : Fibonacci sequence

(defun fibonacci (nr)
           (cond ((= nr 0) 1)
           ((= nr 1) 1)
           (t (+ (fibonacci (- nr 1))
           (fibonacci (- nr 2))))))
(format t "~a" "First 10 Fibonacci numbers") 
(dotimes (n 10) 
(if (< n 1) (terpri))
(if (< n 9) (format t "~a" " "))
(write(+ n 1)) (format t "~a" ": ")
(write (fibonacci n)) (terpri))

Output:

First 10 Fibonacci numbers
 1: 1
 2: 1
 3: 2
 4: 3
 5: 5
 6: 8
 7: 13
 8: 21
 9: 34
10: 55

Solution with methods and eql specializers

(defmethod fib (n)
  (declare ((integer 0 *) n))
  (+ (fib (- n 1))
     (fib (- n 2))))

(defmethod fib ((n (eql 0))) 0)

(defmethod fib ((n (eql 1))) 1)

List-based iterative

This solution uses a list to keep track of the Fibonacci sequence for 0 or a positive integer.

(defun fibo (n)
  (cond ((< n 0) nil)
        ((< n 2) n)
        (t (let ((leo '(1 0)))
             (loop for i from 2 upto n do
               (setf leo (cons (+ (first leo) 
                                  (second leo))
                               leo))
               finally (return (first leo)))))))

Output:

> (fibo 0)
0
> (fibo 1)
1
> (fibo 10)
55
> (fibo 100)
354224848179261915075
> (fibo 1000)
43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875
> (fibo -10)
NIL

List-based recursive

This solution computes Fibonacci numbers as either:

a list starting from the first element;
a single number;
an interval from i-th to j-th element.

Options #2 and #3 can take negative parameters, but i (lowest index in range) must be greater than j (highest index in range).

Values are represented internally by a reversed list that grows from the head (and that's why we reverse it back when we return it).

(defparameter *fibo-start* '(1 1)) ; elements 1 and 2

;;; Helper functions
(defun grow-fibo (fibo)
    (cons (+ (first fibo) (second fibo)) fibo))

(defun generate-fibo (fibo n) ; n must be > 1
    (if (equal (list-length fibo) n)
        fibo
        (generate-fibo (grow-fibo fibo)  n)))

;;; User functions
(defun fibo (n)
    (cond ((= n 0) 0)
          ((= (abs n) 1) 1)
          (t (let ((result (first (generate-fibo *fibo-start* (abs n)))))
               (if (and (< n -1) (evenp n))
                 (- result)
                 result)))))

(defun fibo-list (n)
    (cond ((< n 1) nil)
          ((= n 1) '(1))
          (t (reverse (generate-fibo *fibo-start* n)))))

(defun fibo-range (lower upper)
   (if (<= upper lower)
     nil
     (reverse (generate-fibo
                 (list
                    (fibo (1+ lower))
                    (fibo  lower))
                 (1+ (- upper lower))))))

Output:

> (fibo 100)
354224848179261915075
> (fibo -150)
-9969216677189303386214405760200
> (fibo-list 20)
(1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765)
> (fibo-range -10 15)
(-55 34 -21 13 -8 5 -3 2 -1 1 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610)
> (fibo-range 0 20)
(0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765)

Computer/zero Assembly

To find the $n$ th Fibonacci number, set the initial value of count equal to $n$ –2 and run the program. The machine will halt with the answer stored in the accumulator. Since Computer/zero's word length is only eight bits, the program will not work with values of $n$ greater than 13.

loop:   LDA  y      ; higher No.
        STA  temp
        ADD  x      ; lower No.
        STA  y
        LDA  temp
        STA  x

        LDA  count
        SUB  one
        BRZ  done

        STA  count
        JMP  loop

done:   LDA  y
        STP

one:         1
count:       8      ; n = 10
x:           1
y:           1
temp:        0

Coq

Fixpoint rec_fib (m : nat) (a : nat) (b : nat) : nat :=
  match m with
    | 0 => a
    | S k => rec_fib k b (a + b)
  end.

Definition fib (n : nat) : nat :=
  rec_fib n 0 1 .

Corescript

print Fibonacci Sequence:
var previous = 1
var number = 0
var temp = (blank)

:fib
if number > 50000000000:kill
print (number)
set temp = (add number previous)
set previous = (number)
set number = (temp)
goto fib

:kill
stop

Cowgol

include "cowgol.coh";

sub fibonacci(n: uint32): (a: uint32) is
    a := 0;
    var b: uint32 := 1;
    while n > 0 loop
        var c := a + b;
        a := b;
        b := c;
        n := n - 1;
    end loop;
end sub;

# test
var i: uint32 := 0;
while i < 20 loop
    print_i32(fibonacci(i));
    print_char(' ');
    i := i + 1;
end loop;
print_nl();

Output:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

Crystal

Recursive

def fib(n)
  n < 2 ? n : fib(n - 1) + fib(n - 2)
end

Iterative

def fibIterative(n, prevFib = 0, fib = 1)
  return n if n < 2

  n.times do
    prevFib, fib = fib, prevFib + fib
  end

  prevFib
end

Tail Recursive

def fibTailRecursive(n, prevFib = 0, fib = 1)
  n == 0 ? prevFib : fibTailRecursive(n - 1, fib, prevFib + fib)
end

Analytic

def fibBinet(n)
  (((5 ** 0.5 + 1) / 2) ** n / 5 ** 0.5).round.to_i
end

D

Here are four versions of Fibonacci Number calculating functions. FibD has an argument limit of magnitude 84 due to floating point precision, the others have a limit of 92 due to overflow (long).The traditional recursive version is inefficient. It is optimized by supplying a static storage to store intermediate results. A Fibonacci Number generating function is added. All functions have support for negative arguments.

import std.stdio, std.conv, std.algorithm, std.math;

long sgn(alias unsignedFib)(int n) { // break sign manipulation apart
    immutable uint m = (n >= 0) ? n : -n;
    if (n < 0 && (n % 2 == 0))
        return -unsignedFib(m);
    else
        return unsignedFib(m);
}

long fibD(uint m) { // Direct Calculation, correct for abs(m) <= 84
    enum sqrt5r =  1.0L / sqrt(5.0L);         //  1 / sqrt(5)
    enum golden = (1.0L + sqrt(5.0L)) / 2.0L; // (1 + sqrt(5)) / 2
    return roundTo!long(pow(golden, m) * sqrt5r);
}

long fibI(in uint m) pure nothrow { // Iterative
    long thisFib = 0;
    long nextFib = 1;
    foreach (i; 0 .. m) {
        long tmp = nextFib;
        nextFib += thisFib;
        thisFib  = tmp;
    }
    return thisFib;
}

long fibR(uint m) { // Recursive
    return (m < 2) ? m : fibR(m - 1) + fibR(m - 2);
}

long fibM(uint m) { // memoized Recursive
    static long[] fib = [0, 1];
    while (m >= fib.length )
        fib ~= fibM(m - 2) + fibM(m - 1);
    return fib[m];
}

alias sgn!fibD sfibD;
alias sgn!fibI sfibI;
alias sgn!fibR sfibR;
alias sgn!fibM sfibM;

auto fibG(in int m) { // generator(?)
    immutable int sign = (m < 0) ? -1 : 1;
    long yield;
    
    return new class {
        final int opApply(int delegate(ref int, ref long) dg) {
            int idx = -sign; // prepare for pre-increment
            foreach (f; this)
                if (dg(idx += sign, f))
                    break;
            return 0;
        }
        
        final int opApply(int delegate(ref long) dg) {
            long f0, f1 = 1;
            foreach (p; 0 .. m * sign + 1) {
                if (sign == -1 && (p % 2 == 0))
                    yield = -f0;
                else
                    yield = f0;
                if (dg(yield)) break;
                auto temp = f1;
                f1 = f0 + f1;
                f0 = temp;
            }
            return 0;
        }
    };
}

void main(in string[] args) {
    int k = args.length > 1 ? to!int(args[1]) : 10;
    writefln("Fib(%3d) = ", k);
    writefln("D : %20d <- %20d + %20d",
             sfibD(k), sfibD(k - 1), sfibD(k - 2));
    writefln("I : %20d <- %20d + %20d",
             sfibI(k), sfibI(k - 1), sfibI(k - 2));
    if (abs(k) < 36 || args.length > 2)
        // set a limit for recursive version
        writefln("R : %20d <- %20d + %20d",
                 sfibR(k), sfibM(k - 1), sfibM(k - 2));
    writefln("O : %20d <- %20d + %20d",
             sfibM(k), sfibM(k - 1), sfibM(k - 2));
    foreach (i, f; fibG(-9))
        writef("%d:%d | ", i, f);
}

Output:

for n = 85

Fib( 85) = 
D :   259695496911122586 <-   160500643816367088 +    99194853094755497
I :   259695496911122585 <-   160500643816367088 +    99194853094755497
O :   259695496911122585 <-   160500643816367088 +    99194853094755497
0:0 | -1:1 | -2:-1 | -3:2 | -4:-3 | -5:5 | -6:-8 | -7:13 | -8:-21 | -9:34 |

Matrix Exponentiation Version

import std.bigint;

T fibonacciMatrix(T=BigInt)(size_t n) {
    int[size_t.sizeof * 8] binDigits;
    size_t nBinDigits;
    while (n > 0) {
        binDigits[nBinDigits] = n % 2;
        n /= 2;
        nBinDigits++;
    }

    T x=1, y, z=1;
    foreach_reverse (b; binDigits[0 .. nBinDigits]) {
        if (b) {
            x = (x + z) * y;
            y = y ^^ 2 + z ^^ 2;
        } else {
            auto x_old = x;
            x = x ^^ 2 + y ^^ 2;
            y = (x_old + z) * y;
        }
        z = x + y;
    }

    return y;
}

void main() {
    10_000_000.fibonacciMatrix;
}

Faster Version

For N = 10_000_000 this is about twice faster (run-time about 2.20 seconds) than the matrix exponentiation version.

import std.bigint, std.math;

// Algorithm from: Takahashi, Daisuke,
// "A fast algorithm for computing large Fibonacci numbers".
// Information Processing Letters 75.6 (30 November 2000): 243-246.
// Implementation from:
// pythonista.wordpress.com/2008/07/03/pure-python-fibonacci-numbers
BigInt fibonacci(in ulong n)
in {
    assert(n > 0, "fibonacci(n): n must be > 0.");
} body {
    if (n <= 2)
        return 1.BigInt;
    BigInt F = 1;
    BigInt L = 1;
    int sign = -1;
    immutable uint n2 = cast(uint)n.log2.floor;
    auto mask = 2.BigInt ^^ (n2 - 1);
    foreach (immutable i; 1 .. n2) {
        auto temp = F ^^ 2;
        F = (F + L) / 2;
        F = 2 * F ^^ 2 - 3 * temp - 2 * sign;
        L = 5 * temp + 2 * sign;
        sign = 1;
        if (n & mask) {
            temp = F;
            F = (F + L) / 2;
            L = F + 2 * temp;
            sign = -1;
        }
        mask /= 2;
    }
    if ((n & mask) == 0) {
        F *= L;
    } else {
        F = (F + L) / 2;
        F = F * L - sign;
    }
    return F;
}

void main() {
    10_000_000.fibonacci;
}

Dart

int fib(int n) {
  if (n==0 || n==1) {
    return n;
  }
  var prev=1;
  var current=1;
  for (var i=2; i<n; i++) {
    var next = prev + current;
    prev = current;
    current = next;    
  }
  return current;
}

int fibRec(int n) => n==0 || n==1 ? n : fibRec(n-1) + fibRec(n-2);

main() {
  print(fib(11));
  print(fibRec(11));
}

Datalog

Simple recurive implementation for Souffle.

.decl Fib(i:number, x:number)
Fib(0, 0). 
Fib(1, 1). 
Fib(i+2,x+y) :- Fib(i+1, x), Fib(i, y), i+2<=40, i+2>=2.
Fib(i-2,y-x) :- Fib(i-1, x), Fib(i, y), i-2>=-40, i-2<0.

DBL

;
;       Fibonacci sequence for DBL version 4 by Dario B.
;
        RECORD

FIB1,  D10
FIB2,  D10
FIBN,  D10

J,     D5
A2,    A2
A5,    A5
                                PROC
;----------------------------------------------------------------
        XCALL FLAGS (0007000000,1)         ;Suppress STOP message

        OPEN (1,O,'TT:')
        DISPLAY (1,'First 10 Fibonacci Numbers:',10)
 
        FIB2=1

        FOR J=1 UNTIL 10
        DO BEGIN
                FIBN=FIB1+FIB2

                A2=J,'ZX'
                A5=FIBN,'ZZZZX'
                DISPLAY (1,A2,' : ',A5,10)

                FIB1=FIB2
                FIB2=FIBN
            END
 
        CLOSE 1
END

Dc

This needs a modern Dc with r (swap) and # (comment). It easily can be adapted to an older Dc, but it will impact readability a lot.

[               # todo: n(<2) -- 1 and break 2 levels
  d -           # 0
  1 +           # 1
  q
] s1

[               # todo: n(>-1) -- F(n)
  d 0=1         # n(!=0)
  d 1=1         # n(!in {0,1})
  2 - d 1 +     # (n-2) (n-1)
  lF x          # (n-2) F(n-1)
  r             # F(n-1) (n-2)
  lF x          # F(n-1)+F(n-2)
  +
] sF

33 lF x f

Output:

Delphi

Iterative

function FibonacciI(N: Word): UInt64;
var
  Last, New: UInt64;
  I: Word;
begin
  if N < 2 then
    Result := N
  else begin
    Last := 0;
    Result := 1;
    for I := 2 to N do
    begin
      New := Last + Result;
      Last := Result;
      Result := New;
    end;
  end;
end;

Recursive

function Fibonacci(N: Word): UInt64;
begin
  if N < 2 then
    Result := N
  else
   Result := Fibonacci(N - 1) + Fibonacci(N - 2);
end;

Matrix

Algorithm is based on

{\begin{pmatrix}1&1\\1&0\end{pmatrix}}^{n}={\begin{pmatrix}F(n+1)&F(n)\\F(n)&F(n-1)\end{pmatrix}}

.

function fib(n: Int64): Int64;

  type TFibMat = array[0..1] of array[0..1] of Int64;
	
  function FibMatMul(a,b: TFibMat): TFibMat;
  var i,j,k: integer;
      tmp: TFibMat;
  begin
    for i := 0 to 1 do
      for j := 0 to 1 do
      begin
	tmp[i,j] := 0;
	for k := 0 to 1 do tmp[i,j] := tmp[i,j] + a[i,k] * b[k,j];
      end;
    FibMatMul := tmp;
  end;
	
  function FibMatExp(a: TFibMat; n: Int64): TFibmat;
  begin
    if n <= 1 then fibmatexp := a
    else if (n mod 2 = 0) then FibMatExp := FibMatExp(FibMatMul(a,a), n div 2)
    else if (n mod 2 = 1) then FibMatExp := FibMatMul(a, FibMatExp(FibMatMul(a,a), n div 2));
  end;

var 
  matrix: TFibMat;
	
begin
  matrix[0,0] := 1;
  matrix[0,1] := 1;
  matrix[1,0] := 1;
  matrix[1,1] := 0;
  if n > 1 then
    matrix := fibmatexp(matrix,n-1);
  fib := matrix[0,0];
end;

DIBOL-11

    ;     Redone to include the first two values that
    ;     are noot computed.

      START    ;First 15 Fibonacci NUmbers


      RECORD
              FIB1,    D10,   0
              FIB2,    D10,   1
              FIBNEW,  D10
              LOOPCNT, D2,    3

       RECORD HEADER
,            A32, "First 15 Fibonacci Numbers."

       RECORD OUTPUT
             LOOPOUT, A2
,         A3, " : "
              FIBOUT, A10

      PROC

      OPEN(8,O,'TT:')

      WRITES(8,HEADER)

;   The First Two are given.

        FIBOUT = 0
        LOOPOUT = 1
      WRITES(8,OUTPUT)
        FIBOUT = 1
        LOOPOUT = 2
      WRITES(8,OUTPUT)

;   The Rest are Computed.
      
     LOOP,
             FIBNEW = FIB1 + FIB2
             LOOPOUT = LOOPCNT, 'ZX'
             FIBOUT = FIBNEW, 'ZZZZZZZZZX'

             WRITES(8,OUTPUT)

             FIB1 = FIB2
             FIB2 = FIBNEW
             
             LOOPCNT = LOOPCNT + 1
             IF LOOPCNT .LE. 15 GOTO LOOP

             CLOSE 8
             END

DWScript

function fib(N : Integer) : Integer;
begin
  if N < 2 then Result := 1
  else Result := fib(N-2) + fib(N-1);
End;

Dyalect

func fib(n) {
    if n < 2 {
        return n
    } else {
        return fib(n - 1) + fib(n - 2)
    }
}

print(fib(30))

E

def fib(n) {
    var s := [0, 1]
    for _ in 0..!n { 
        def [a, b] := s
        s := [b, a+b]
    }
    return s[0]
}

(This version defines fib(0) = 0 because OEIS A000045 does.)

EasyLang

func fib n .
   if n < 2
      return n
   .
   prev = 0
   val = 1
   for i = 2 to n
      h = prev + val
      prev = val
      val = h
   .
   return val
.
print fib 36

Recursive (inefficient):

func fib n .
   if n < 2
      return n
   .
   return fib (n - 2) + fib (n - 1)
.
print fib 36

EchoLisp

Use memoization with the recursive version.

(define (fib n) 
    (if (< n 2) n 
    (+ (fib (- n 2)) (fib (1- n)))))

(remember 'fib #(0 1))

(for ((i 12)) (write (fib i)))
0 1 1 2 3 5 8 13 21 34 55 89

ECL

Analytic

//Calculates Fibonacci sequence up to n steps using Binet's closed form solution


FibFunction(UNSIGNED2 n) := FUNCTION
	REAL Sqrt5 := Sqrt(5); 
	REAL Phi := (1+Sqrt(5))/2;
	REAL Phi_Inv := 1/Phi; 
	UNSIGNED FibValue := ROUND( ( POWER(Phi,n)-POWER(Phi_Inv,n) ) /Sqrt5); 
	RETURN FibValue; 
	END;  

 FibSeries(UNSIGNED2 n) := FUNCTION
 
 Fib_Layout := RECORD
 UNSIGNED5 FibNum;
 UNSIGNED5 FibValue; 
 END; 
 
 FibSeq := DATASET(n+1,
  TRANSFORM 
 ( Fib_Layout 
 , SELF.FibNum := COUNTER-1
 , SELF.FibValue := IF(SELF.FibNum<2,SELF.FibNum, FibFunction(SELF.FibNum) )
 ) 
 ); 
 
 RETURN FibSeq; 
 
 END; }

EDSAC order code

This program calculates the nth—by default the tenth—number in the Fibonacci sequence and displays it (in binary) in the first word of storage tank 3.

[ Fibonacci sequence
  ==================
  
  A program for the EDSAC
  
  Calculates the nth Fibonacci
  number and displays it at the
  top of storage tank 3
  
  The default value of n is 10
  
  To calculate other Fibonacci
  numbers, set the starting value
  of the count to n-2
  
  Works with Initial Orders 2 ]


        T56K  [ set load point  ]
        GK    [ set theta       ]
        
[ Orders ]

[  0 ]  T20@  [ a = 0           ]
        A17@  [ a += y          ]
        U18@  [ temp = a        ]
        A16@  [ a += x          ]
        T17@  [ y = a; a = 0    ]
        A18@  [ a += temp       ]
        T16@  [ x = a; a = 0    ]
        
        A19@  [ a = count       ]
        S15@  [ a -= 1          ]
        U19@  [ count = a       ]
        E@    [ if a>=0 go to θ ]
        
        T20@  [ a = 0           ]
        A17@  [ a += y          ]
        T96F  [ C(96) = a; a = 0]
        
        ZF    [ halt ]
        
[ Data ]
        
[ 15 ]  P0D   [ const: 1        ]
[ 16 ]  P0F   [ var: x = 0      ]
[ 17 ]  P0D   [ var: y = 1      ]
[ 18 ]  P0F   [ var: temp = 0   ]
[ 19 ]  P4F   [ var: count = 8  ]
[ 20 ]  P0F   [ used to clear a ]

        EZPF  [ begin execution ]

Output:

00000000000110111

Eiffel

class
	APPLICATION

create
	make

feature

	fibonacci (n: INTEGER): INTEGER
		require
			non_negative: n >= 0
		local
			i, n2, n1, tmp: INTEGER
		do
			n2 := 0
			n1 := 1
			from
				i := 1
			until
				i >= n
			loop
				tmp := n1
				n1 := n2 + n1
				n2 := tmp
				i := i + 1
			end
			Result := n1
			if n = 0 then
				Result := 0
			end
		end

feature {NONE} -- Initialization

	make
			-- Run application.
		do
			print (fibonacci (0))
			print (" ")
			print (fibonacci (1))
			print (" ")
			print (fibonacci (2))
			print (" ")
			print (fibonacci (3))
			print (" ")
			print (fibonacci (4))
			print ("%N")
		end

end

Ela

Tail-recursive function:

fib = fib' 0 1           
      where fib' a b 0 = a                 
            fib' a b n = fib' b (a + b) (n - 1)

Infinite (lazy) list:

fib = fib' 1 1
      where fib' x y = & x :: fib' y (x + y)

Elena

Translation of: Smalltalk

ELENA 6.x :

import extensions;
 
fibu(n)
{
    int[] ac := new int[]{ 0,1 };
    if (n < 2) 
    {
        ^ ac[n] 
    }
    else
    {
        for(int i := 2; i <= n; i+=1)
        {
            int t := ac[1];
            ac[1] := ac[0] + ac[1];
            ac[0] := t
        };
 
        ^ ac[1]
    }
}
 
public program()
{
    for(int i := 0; i <= 10; i+=1)
    {
        console.printLine(fibu(i))
    }
}

Output:

Alternative version using yieldable method

import extensions;

public FibonacciGenerator
{
    yieldable next()
    {
        long n_2 := 1l; 
        long n_1 := 1l;

        $yield n_2;             
        $yield n_1;

        while(true)
        {
            long n := n_2 + n_1;

            $yield n;

            n_2 := n_1;
            n_1 := n
        }
    }
}

public program()
{
    auto e := new FibonacciGenerator();
    
    for(int i := 0; i < 10; i += 1) {
        console.printLine(e.next())
    };
    
    console.readChar()
}

Elixir

defmodule Fibonacci do
    def fib(0), do: 0
    def fib(1), do: 1
    def fib(n), do: fib(0, 1, n-2)
    
    def fib(_, prv, -1), do: prv
    def fib(prvprv, prv, n) do
        next = prv + prvprv
        fib(prv, next, n-1)
    end
end

IO.inspect Enum.map(0..10, fn i-> Fibonacci.fib(i) end)

Using Stream:

Stream.unfold({0,1}, fn {a,b} -> {a,{b,a+b}} end) |> Enum.take(10)

Output:

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Elm

Naïve recursive implementation.

fibonacci : Int -> Int
fibonacci n = if n < 2 then
        n
    else
        fibonacci(n - 2) + fibonacci(n - 1)

version 2

fib : Int -> number
fib n =
   case n of
      0 -> 0
      1 -> 1
      _ -> fib (n-1) + fib (n-2)

Output:

elm repl
> fib 40
102334155 : number

> List.map (\elem -> fib elem) (List.range 1 40)
[1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,
4181,6765,10946,17711,28657,46368,75025,121393,196418,
317811,514229,832040,1346269,2178309,3524578,5702887,
9227465,14930352,24157817,39088169,63245986,102334155]
    : List number

Emacs Lisp

version 1

(defun fib (n a b c)
  (cond
   ((< c n) (fib n b (+ a b) (+ 1 c)))
   ((= c n) b)
   (t a)))

(defun fibonacci (n)
  (if (< n 2)
      n
    (fib n 0 1 1)))

version 2

(defun fibonacci (n)
  (let (vec i j k)
    (if (< n 2)
        n
      (setq vec (make-vector (+ n 1) 0)
            i 0
            j 1
            k 2)
      (setf (aref vec 1) 1)
      (while (<= k n)
        (setf (aref vec k) (+ (elt vec i) (elt vec j)))
        (setq i (1+ i)
              j (1+ j)
              k (1+ k)))
      (elt vec n))))

Eval:

(insert
 (mapconcat (lambda (n) (format "%d" (fibonacci n)))
            (number-sequence 0 15) " "))

Output:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610

Erlang

Recursive

-module(fib).
-export([fib/1]).

fib(0) -> 0;
fib(1) -> 1;
fib(N) -> fib(N-1) + fib(N-2).

Iterative

-module(fiblin).
-export([fib/1])

fib(0) -> 0;
fib(1) -> 1;
fib(2) -> 1;
fib(3) -> 2;
fib(4) -> 3;
fib(5) -> 5;

fib(N) when is_integer(N) -> fib(N - 6, 5, 8).
fib(N, A, B) -> if N < 1 -> B; true -> fib(N-1, B, A+B) end.

Evaluate:

io:write([fiblin:fib(X) || X <- lists:seq(1,10) ]).

Output:

   
[1,1,2,3,5,8,13,21,34,55]ok

Iterative 2

fib(N) -> fib(N, 0, 1).

fib(0, Result, _Next) -> Result;
fib(Iter, Result, Next) -> fib(Iter-1, Next, Result+Next).

ERRE

!-------------------------------------------
! derived from my book "PROGRAMMARE IN ERRE"
! iterative solution
!-------------------------------------------

PROGRAM FIBONACCI

!$DOUBLE

!VAR F1#,F2#,TEMP#,COUNT%,N%

BEGIN    !main
   INPUT("Number",N%)
   F1=0
   F2=1
   REPEAT
      TEMP=F2
      F2=F1+F2
      F1=TEMP
      COUNT%=COUNT%+1
   UNTIL COUNT%=N%
   PRINT("FIB(";N%;")=";F2)

   ! Obviously a FOR loop or a WHILE loop can
   ! be used to solve this problem

END PROGRAM

Output:

Number? 20
FIB( 20 )= 6765

Euphoria

'Recursive' version

Works with: Euphoria version any version

function fibor(integer n)
  if n<2 then return n end if
  return fibor(n-1)+fibor(n-2)
end function

'Iterative' version

Works with: Euphoria version any version

function fiboi(integer n)
integer f0=0, f1=1, f  
  if n<2 then return n end if
  for i=2 to n do
    f=f0+f1
    f0=f1
    f1=f   
  end for
  return f
end function

'Tail recursive' version

Works with: Euphoria version 4.0.0

function fibot(integer n, integer u = 1, integer s = 0)
  if n < 1 then
    return s
  else
    return fibot(n-1,u+s,u)
  end if
end function

-- example:
? fibot(10) -- says 55

'Paper tape' version

Works with: Euphoria version 4.0.0

include std/mathcons.e -- for PINF constant

enum ADD, MOVE, GOTO, OUT, TEST, TRUETO

global sequence tape = { 0, 
			 1, 
		       { ADD, 2, 1 }, 
		       { TEST, 1, PINF }, 
		       { TRUETO, 0 }, 
		       { OUT, 1, "%.0f\n" }, 
		       { MOVE, 2, 1 }, 
		       { MOVE, 0, 2 }, 
		       { GOTO, 3  } }

global integer ip
global integer test
global atom accum

procedure eval( sequence cmd )
	atom i = 1
	while i <= length( cmd ) do
		switch cmd[ i ] do
			case ADD then
				accum = tape[ cmd[ i + 1 ] ] + tape[ cmd[ i + 2 ] ]
				i += 2

			case OUT then
				printf( 1, cmd[ i + 2], tape[ cmd[ i + 1 ] ] ) 
				i += 2

			case MOVE then
				if cmd[ i + 1 ] = 0 then
					tape[ cmd[ i + 2 ] ] = accum
				else
					tape[ cmd[ i + 2 ] ] = tape[ cmd[ i + 1 ] ]
				end if
				i += 2

			case GOTO then
				ip = cmd[ i + 1 ] - 1 -- due to ip += 1 in main loop
				i += 1

			case TEST then
				if tape[ cmd[ i + 1 ] ] = cmd[ i + 2 ] then
					test = 1
				else
					test = 0
				end if
				i += 2

			case TRUETO then
				if test then
					if cmd[ i + 1 ] = 0 then
						abort(0)
					else
						ip = cmd[ i + 1 ] - 1
					end if
				end if

		end switch
		i += 1
	end while
end procedure

test = 0
accum = 0
ip = 1

while 1 do

	-- embedded sequences (assumed to be code) are evaluated
	-- atoms (assumed to be data) are ignored

	if sequence( tape[ ip ] ) then
		eval( tape[ ip ] ) 
	end if
	ip += 1
end while

Excel

LAMBDA

Binding the name FIBONACCI to the following lambda in the Excel worksheet Name Manager:

(See The LAMBDA worksheet function)

Works with: Office 365 Betas 2021

FIBONACCI
=LAMBDA(n,
    APPLYN(n - 2)(
        LAMBDA(xs,
            APPENDROWS(xs)(
                SUM(
                    LASTNROWS(2)(xs)
                )
            )
        )
    )({1;1})
)

And assuming that the following names are also bound to reusable generic lambdas in the Name manager:

APPENDROWS
=LAMBDA(xs,
    LAMBDA(ys,
        LET(
            nx, ROWS(xs),
            rowIndexes, SEQUENCE(nx + ROWS(ys)),
            colIndexes, SEQUENCE(
                1,
                MAX(COLUMNS(xs), COLUMNS(ys))
            ),

            IFERROR(
                IF(rowIndexes <= nx,
                    INDEX(xs, rowIndexes, colIndexes),
                    INDEX(ys, rowIndexes - nx, colIndexes)
                ),
                NA()
            )
        )
    )
)


APPLYN
=LAMBDA(n,
    LAMBDA(f,
        LAMBDA(x,
            IF(0 < n,
                APPLYN(n - 1)(f)(
                    f(x)
                ),
                x
            )
        )
    )
)

LASTNROWS
=LAMBDA(n,
    LAMBDA(xs,
        LET(
            nRows, COUNTA(xs),
            x, MIN(nRows, n),

            IF(0 < n,
                INDEX(
                    xs,
                    SEQUENCE(
                        x, 1,
                        1 + nRows - x,  1
                    )
                ),
                NA()
            )
        )
    )
)

Output:

The FIBONACCI(n) lambda defines a column of integers.

Here we obtain a row, by composing FIBONACCI with the built-in TRANSPOSE function:

	fx	=TRANSPOSE(FIBONACCI(15))
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P
1
2	15 Fibonacci terms:	1	1	2	3	5	8	13	21	34	55	89	144	233	377	610

Or as a fold, obtaining just the Nth term of the Fibonacci series:

FIBONACCI2
=LAMBDA(n,
    INDEX(
        FOLDL(
            LAMBDA(ab,
                LAMBDA(_,
                    APPEND(INDEX(ab, 2))(SUM(ab))
                )
            )
        )({0;1})(
            ENUMFROMTO(1)(n)
        ),
        1
    )
)

Assuming the following generic bindings in the Excel worksheet Name manager:

APPEND
=LAMBDA(xs,
    LAMBDA(ys,
        LET(
            nx, ROWS(xs),
            rowIndexes, SEQUENCE(nx + ROWS(ys)),
            colIndexes, SEQUENCE(
                1,
                MAX(COLUMNS(xs), COLUMNS(ys))
            ),
            IF(rowIndexes <= nx,
                INDEX(xs, rowIndexes, colIndexes),
                INDEX(ys, rowIndexes - nx, colIndexes)
            )
        )
    )
)


ENUMFROMTO
=LAMBDA(a,
    LAMBDA(z,
        SEQUENCE(1 + z - a, 1, a, 1)
    )
)


FOLDL
=LAMBDA(op,
    LAMBDA(a,
        LAMBDA(xs,
            IF(
                2 > ROWS(xs),
                op(a)(xs),
                FOLDL(op)(
                    op(a)(
                        HEAD(xs)
                    )
                )(
                    TAIL(xs)
                )
            )
        )
    )
)


HEAD
=LAMBDA(xs,
    INDEX(xs, 1, SEQUENCE(1, COLUMNS(xs)))
)


TAIL
=LAMBDA(xs,
    INDEX(
        xs,
        SEQUENCE(ROWS(xs) - 1, 1, 2, 1),
        SEQUENCE(1, COLUMNS(xs))
    )
)

Output:

	fx	=FIBONACCI2(A2)
	A	B
1	N	Fibonacci
2	32	2178309
3	64	10610209857723

F#

This is a fast [tail-recursive] approach using the F# big integer support:

let fibonacci n : bigint =
  let rec f a b n =
    match n with
    | 0 -> a
    | 1 -> b
    | n -> (f b (a + b) (n - 1))
  f (bigint 0) (bigint 1) n
> fibonacci 100;;
val it : bigint = 354224848179261915075I

Lazy evaluated using sequence workflow:

let rec fib = seq { yield! [0;1];
                    for (a,b) in Seq.zip fib (Seq.skip 1 fib) -> a+b}

The above is extremely slow due to the nested recursions on sequences, which aren't very efficient at the best of times. The above takes seconds just to compute the 30th Fibonacci number!

Lazy evaluation using the sequence unfold anamorphism is much much better as to efficiency:

let fibonacci = Seq.unfold (fun (x, y) -> Some(x, (y, x + y))) (0I,1I)
fibonacci |> Seq.nth 10000

Approach similar to the Matrix algorithm in C#, with some shortcuts involved. Since it uses exponentiation by squaring, calculations of fib(n) where n is a power of 2 are particularly quick. Eg. fib(2^20) was calculated in a little over 4 seconds on this poster's laptop.

open System
open System.Diagnostics
open System.Numerics

/// Finds the highest power of two which is less than or equal to a given input.
let inline prevPowTwo (x : int) =
    let mutable n = x
    n <- n - 1
    n <- n ||| (n >>> 1)
    n <- n ||| (n >>> 2)
    n <- n ||| (n >>> 4)
    n <- n ||| (n >>> 8)
    n <- n ||| (n >>> 16)
    n <- n + 1
    match x with
    | x when x = n -> x
    | _ -> n/2

/// Evaluates the nth Fibonacci number using matrix arithmetic and
/// exponentiation by squaring.
let crazyFib (n : int) =
    let powTwo = prevPowTwo n

    /// Applies 2n rule repeatedly until another application of the rule would
    /// go over the target value (or the target value has been reached).
    let rec iter1 i q r s =
        match i with
        | i when i < powTwo ->
            iter1 (i*2) (q*q + r*r) (r * (q+s)) (r*r + s*s)
        | _ -> i, q, r, s

    /// Applies n+1 rule until the target value is reached.
    let rec iter2 (i, q, r, s) =
        match i with
        | i when i < n -> 
            iter2 ((i+1), (q+r), q, r)
        | _ -> q

    match n with
    | 0 -> 1I
    | _ ->
        iter1 1 1I 1I 0I
        |> iter2

Factor

Iterative

: fib ( n -- m )
    dup 2 < [
        [ 0 1 ] dip [ swap [ + ] keep ] times
        drop
    ] unless ;

Recursive

: fib ( n -- m )
    dup 2 < [
        [ 1 - fib ] [ 2 - fib ] bi +
    ] unless ;

Tail-Recursive

: fib2 ( x y n -- a )
  dup 1 <
    [ 2drop ]
    [ [ swap [ + ] keep ] dip 1 - fib2 ]
  if ;
: fib ( n -- m ) [ 0 1 ] dip fib2 ;

Matrix

Translation of: Ruby

USE: math.matrices

: fib ( n -- m )
    dup 2 < [
        [ { { 0 1 } { 1 1 } } ] dip 1 - m^n
        second second
    ] unless ;

Falcon

Iterative

function fib_i(n)

    if n < 2: return n

    fibPrev = 1
    fib = 1
    for i in [2:n]
        tmp = fib
        fib += fibPrev
        fibPrev = tmp
    end
    return fib
end

Recursive

function fib_r(n)
    if n < 2 :  return n
    return fib_r(n-1) + fib_r(n-2)
end

Tail Recursive

function fib_tr(n)
    return fib_aux(n,0,1)       
end
function fib_aux(n,a,b)
   switch n
      case 0 : return a
      default: return fib_aux(n-1,a+b,a)
   end
end

FALSE

[[$0=~][1-@@\$@@+\$44,.@]#]f:
20n: {First 20 numbers}
0 1 n;f;!%%44,. {Output: "0,1,1,2,3,5..."}

Fancy

class Fixnum {
  def fib {
    match self -> {
      case 0 -> 0
      case 1 -> 1
      case _ -> self - 1 fib + (self - 2 fib)
    }
  }
}

15 times: |x| {
  x fib println
}

Fantom

Ints have a limit of 64-bits, so overflow errors occur after computing Fib(92) = 7540113804746346429.

class Main
{
  static Int fib (Int n) 
  {
    if (n < 2) return n
    fibNums := [1, 0]
    while (fibNums.size <= n)
    {
      fibNums.insert (0, fibNums[0] + fibNums[1])
    }
    return fibNums.first
  }

  public static Void main ()
  {
    20.times |n| 
    {
      echo ("Fib($n) is ${fib(n)}")
    }
  }
}

Fe

Recursive:

(= fib (fn (n)
  (if (< n 2) n
    (+ (fib (- n 1)) (fib (- n 2))))))

Iterative:

(= fib (fn (n)
  (let p0 0)
  (let p1 1)
  (while (< 0 n)
    (= n (- n 1))
    (let tmp (+ p0 p1)) 
    (= p0 p1)
    (= p1 tmp))
  p0))

Fermat

Func Fibonacci(n) = if n<0 then -(-1)^n*Fibonacci(-n) else if n<2 then n else 
    Array fib[n+1];
    fib[1] := 0;
    fib[2] := 1;
    for i = 2, n do 
    fib[i+1]:=fib[i]+fib[i-1]
    od;
    Return(fib[n+1]);
    fi;
    fi;
    .

Fexl

# (fib n) = the nth Fibonacci number
\fib=
    (
    \loop==
        (\x\y\n
        le n 0 x;
        \z=(+ x y)
        \n=(- n 1)
        loop y z n
        )
    loop 0 1
    )


# Now test it:
for 0 20 (\n say (fib n))

Output:

Fish

Outputs Fibonacci numbers until stopped.

10::n' 'o&+&$10.

FOCAL

01.10 TYPE "FIBONACCI NUMBERS" !
01.20 ASK "N =", N
01.30 SET A=0
01.40 SET B=1
01.50 FOR I=2,N; DO 2.0
01.60 TYPE "F(N) ", %8, B, !
01.70 QUIT

02.10 SET T=B
02.20 SET B=A+B
02.30 SET A=T

Output:

FIBONACCI NUMBERS
N =:20
F(N) =    6765

Forth

: fib ( n -- fib )
  0 1 rot 0 ?do  over + swap  loop drop ;

Or, for negative-index support:

: fib ( n -- Fn ) 0 1 begin
  rot dup 0 = if drop drop exit then
  dup 0 > if   1 - rot rot dup rot +
          else 1 + rot rot over - swap then 
again ;

Since there are only a fixed and small amount of Fibonacci numbers that fit in a machine word, this FORTH version creates a table of Fibonacci numbers at compile time. It stops compiling numbers when there is arithmetic overflow (the number turns negative, indicating overflow.)

: F-start,  here 1 0 dup , ;
: F-next,   over + swap
            dup 0> IF  dup , true  ELSE  false  THEN ;

: computed-table  ( compile: 'start 'next / run: i -- x )
   create
      >r execute
      BEGIN  r@ execute not  UNTIL  rdrop
   does> 
       swap cells + @ ;

' F-start, ' F-next,  computed-table fibonacci 2drop
here swap - cell/ Constant #F/64   \ # of fibonacci numbers generated

16 fibonacci . 987  ok
#F/64 . 93  ok
92 fibonacci . 7540113804746346429  ok   \ largest number generated.

Fortran

FORTRAN IV

C     FIBONACCI SEQUENCE - FORTRAN IV
      NN=46
      DO 1 I=0,NN
    1 WRITE(*,300) I,IFIBO(I)
  300 FORMAT(1X,I2,1X,I10)
      END
C
      FUNCTION IFIBO(N)
      IF(N) 9,1,2
    1 IFN=0
      GOTO 9
    2 IF(N-1) 9,3,4
    3 IFN=1
      GOTO 9
    4 IFNM1=0
      IFN=1
      DO 5 I=2,N
      IFNM2=IFNM1
      IFNM1=IFN
    5 IFN=IFNM1+IFNM2
    9 IFIBO=IFN
      END

Output:

  0          0
  1          1
  2          1
  3          2
  4          3
  5          5
  6          8
  7         13
  8         21
  9         34
 10         55
...
 45 1134903170
 46 1836311903

FORTRAN 77

      FUNCTION IFIB(N)
      IF (N.EQ.0) THEN
        ITEMP0=0
      ELSE IF (N.EQ.1) THEN
        ITEMP0=1
      ELSE IF (N.GT.1) THEN
        ITEMP1=0
        ITEMP0=1
        DO 1 I=2,N
          ITEMP2=ITEMP1
          ITEMP1=ITEMP0
          ITEMP0=ITEMP1+ITEMP2
    1   CONTINUE
      ELSE
        ITEMP1=1
        ITEMP0=0
        DO 2 I=-1,N,-1
          ITEMP2=ITEMP1
          ITEMP1=ITEMP0
          ITEMP0=ITEMP2-ITEMP1
    2   CONTINUE
      END IF
      IFIB=ITEMP0
      END

Test program

      EXTERNAL IFIB
      CHARACTER*10 LINE
      PARAMETER ( LINE = '----------' )
      WRITE(*,900) 'N', 'F[N]', 'F[-N]'
      WRITE(*,900) LINE, LINE, LINE
      DO 1 N = 0, 10
        WRITE(*,901) N, IFIB(N), IFIB(-N)
    1 CONTINUE
  900 FORMAT(3(X,A10))
  901 FORMAT(3(X,I10))
      END

Output:

          N       F[N]      F[-N]
 ---------- ---------- ----------
          0          0          0
          1          1          1
          2          1         -1
          3          2          2
          4          3         -3
          5          5          5
          6          8         -8
          7         13         13
          8         21        -21
          9         34         34
         10         55        -55

Recursive

In ISO Fortran 90 or later, use a RECURSIVE function:

module fibonacci
contains
    recursive function fibR(n) result(fib)
        integer, intent(in) :: n
        integer             :: fib
        
        select case (n)
            case (:0);      fib = 0
            case (1);       fib = 1
            case default;   fib = fibR(n-1) + fibR(n-2)
        end select
    end function fibR

Iterative

In ISO Fortran 90 or later:

    function fibI(n)
        integer, intent(in) :: n
        integer, parameter :: fib0 = 0, fib1 = 1
        integer            :: fibI, back1, back2, i
 
        select case (n)
            case (:0);      fibI = fib0
            case (1);       fibI = fib1
     
            case default
                fibI = fib1
                back1 = fib0
                do i = 2, n
                    back2 = back1
                    back1 = fibI
                    fibI   = back1 + back2
                end do
         end select
    end function fibI
end module fibonacci

Test program

program fibTest
    use fibonacci
    
    do i = 0, 10
        print *, fibr(i), fibi(i)
    end do 
end program fibTest

Output:

Free Pascal

See also: Pascal

type
	/// domain for Fibonacci function
	/// where result is within nativeUInt
	// You can not name it fibonacciDomain,
	// since the Fibonacci function itself
	// is defined for all whole numbers
	// but the result beyond F(n) exceeds high(nativeUInt).
	fibonacciLeftInverseRange =
		{$ifdef CPU64} 0..93 {$else} 0..47 {$endif};

{**
	implements Fibonacci sequence iteratively
	
	\param n the index of the Fibonacci number to calculate
	\returns the Fibonacci value at n
}
function fibonacci(const n: fibonacciLeftInverseRange): nativeUInt;
type
	/// more meaningful identifiers than simple integers
	relativePosition = (previous, current, next);
var
	/// temporary iterator variable
	i: longword;
	/// holds preceding fibonacci values
	f: array[relativePosition] of nativeUInt;
begin
	f[previous] := 0;
	f[current] := 1;
	
	// note, in Pascal for-loop-limits are inclusive
	for i := 1 to n do
	begin
		f[next] := f[previous] + f[current];
		f[previous] := f[current];
		f[current] := f[next];
	end;
	
	// assign to previous, bc f[current] = f[next] for next iteration
	fibonacci := f[previous];
end;

Frink

All of Frink's integers can be arbitrarily large.

fibonacciN[n] :=
{
   a = 0
   b = 1
   count = 0
   while count < n
   {
      [a,b] = [b, a + b]
      count = count + 1
   }
   return a
}

FRISC Assembly

To find the nth Fibonacci number, call this subroutine with n in register R0: the answer will be returned in R0 too. Contents of other registers are preserved.

FIBONACCI   PUSH   R1
            PUSH   R2
            PUSH   R3

            MOVE   0,  R1
            MOVE   1,  R2

FIB_LOOP    SUB    R0,  1, R0
            JP_Z   FIB_DONE

            MOVE   R2, R3
            ADD    R1, R2, R2
            MOVE   R3, R1

            JP     FIB_LOOP

FIB_DONE    MOVE   R2, R0

            POP    R3
            POP    R2
            POP    R1

            RET

FunL

Recursive

def
  fib( 0 ) = 0
  fib( 1 ) = 1
  fib( n ) = fib( n - 1 ) + fib( n - 2 )

Tail Recursive

def fib( n ) =
  def
    _fib( 0, prev, _ )    = prev
    _fib( 1, _,    next ) = next
    _fib( n, prev, next ) = _fib( n - 1, next, next + prev )

  _fib( n, 0, 1 )

Lazy List

val fib =
  def _fib( a, b ) = a # _fib( b, a + b )

  _fib( 0, 1 )

println( fib(10000) )

Output:

33644764876431783266621612005107543310302148460680063906564769974680081442166662368155595513633734025582065332680836159373734790483865268263040892463056431887354544369559827491606602099884183933864652731300088830269235673613135117579297437854413752130520504347701602264758318906527890855154366159582987279682987510631200575428783453215515103870818298969791613127856265033195487140214287532698187962046936097879900350962302291026368131493195275630227837628441540360584402572114334961180023091208287046088923962328835461505776583271252546093591128203925285393434620904245248929403901706233888991085841065183173360437470737908552631764325733993712871937587746897479926305837065742830161637408969178426378624212835258112820516370298089332099905707920064367426202389783111470054074998459250360633560933883831923386783056136435351892133279732908133732642652633989763922723407882928177953580570993691049175470808931841056146322338217465637321248226383092103297701648054726243842374862411453093812206564914032751086643394517512161526545361333111314042436854805106765843493523836959653428071768775328348234345557366719731392746273629108210679280784718035329131176778924659089938635459327894523777674406192240337638674004021330343297496902028328145933418826817683893072003634795623117103101291953169794607632737589253530772552375943788434504067715555779056450443016640119462580972216729758615026968443146952034614932291105970676243268515992834709891284706740862008587135016260312071903172086094081298321581077282076353186624611278245537208532365305775956430072517744315051539600905168603220349163222640885248852433158051534849622434848299380905070483482449327453732624567755879089187190803662058009594743150052402532709746995318770724376825907419939632265984147498193609285223945039707165443156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875

Iterative

def fib( n ) =
  a, b = 0, 1

  for i <- 1..n
    a, b = b, a+b

  a

Binet's Formula

import math.sqrt

def fib( n ) =
  phi = (1 + sqrt( 5 ))/2
  int( (phi^n - (-phi)^-n)/sqrt(5) + .5 )

Matrix Exponentiation

def mul( a, b ) =
  res = array( a.length(), b(0).length() )

  for i <- 0:a.length(), j <- 0:b(0).length()
    res( i, j ) = sum( a(i, k)*b(k, j) | k <- 0:b.length() )

  vector( res )

def
  pow( _, 0 ) = ((1, 0), (0, 1))
  pow( x, 1 ) = x
  pow( x, n )
    | 2|n = pow( mul(x, x), n\2 )
    | otherwise = mul(x, pow( mul(x, x), (n - 1)\2 ) )

def fib( n ) = pow( ((0, 1), (1, 1)), n )(0, 1)

for i <- 0..10
  println( fib(i) )

Output:

Futhark

Iterative

fun main(n: int): int =
  loop((a,b) = (0,1)) = for _i < n do
    (b, a + b)
  in a

FutureBasic

Iterative

window 1, @"Fibonacci Sequence", (0,0,480,620)

local fn Fibonacci( n as long ) as long
  static long s1
  static long s2
  long        temp
  
  if ( n < 2 )
    s1 = n
    exit fn
  else
    temp = s1 + s2
    s2 = s1
    s1 = temp
    exit fn
  end if
end fn = s1

long i
CFTimeInterval t

t = fn CACurrentMediaTime

for i = 0 to 40
  print i;@".\t";fn Fibonacci(i)
next i

print : printf @"Compute time: %.3f ms",(fn CACurrentMediaTime-t)*1000

HandleEvents

Output:

0.	0
1.	1
2.	1
3.	2
4.	3
5.	5
6.	8
7.	13
8.	21
9.	34
10.	55
11.	89
12.	144
13.	233
14.	377
15.	610
16.	987
17.	1597
18.	2584
19.	4181
20.	6765
21.	10946
22.	17711
23.	28657
24.	46368
25.	75025
26.	121393
27.	196418
28.	317811
29.	514229
30.	832040
31.	1346269
32.	2178309
33.	3524578
34.	5702887
35.	9227465
36.	14930352
37.	24157817
38.	39088169
39.	63245986
40.	102334155

Compute time: 2.143 ms

Recursive

Cost is a time penalty

local fn Fibonacci( n as NSInteger ) as NSInteger
NSInteger result
if n < 2 then result = n : exit fn
result = fn Fibonacci( n-1 ) + fn Fibonacci( n-2 )
end fn = result

window 1

NSInteger i
CFTimeInterval t

t = fn CACurrentMediaTime
for i = 0 to 40
print i;@".\t";fn Fibonacci(i)
next
print : printf @"Compute time: %.3f ms",(fn CACurrentMediaTime-t)*1000

HandleEvents

Output:

0.	0
1.	1
2.	1
3.	2
4.	3
5.	5
6.	8
7.	13
8.	21
9.	34
10.	55
11.	89
12.	144
13.	233
14.	377
15.	610
16.	987
17.	1597
18.	2584
19.	4181
20.	6765
21.	10946
22.	17711
23.	28657
24.	46368
25.	75025
26.	121393
27.	196418
28.	317811
29.	514229
30.	832040
31.	1346269
32.	2178309
33.	3524578
34.	5702887
35.	9227465
36.	14930352
37.	24157817
38.	39088169
39.	63245986
40.	102334155

Compute time: 2844.217 ms

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website.

In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.

Recursive

Recursive version is slow, it is O(2ⁿ), or of exponential order.

It is because it makes a lot of recursive calls.

To illustrate this, the following is a functions that makes a tree or the recursive calls:

Iterative (3 variables)

It is O(n), or of linear order.

Iterative (2 variables)

It is O(n), or of linear order.

Iterative, using a list

It is O(n), or of linear order.

Using matrix multiplication

Divide and conquer

It is an optimized version of the matrix multiplication algorithm, with an order of O(lg(n))

Closed-form

It has an order of O(lg(n))

GAP

fib := function(n)
  local a;
  a := [[0, 1], [1, 1]]^n;
  return a[1][2];
end;

GAP has also a buit-in function for that.

Fibonacci(n);

Gecho

0 1 dup wover + dup wover + dup wover + dup wover +

Prints the first several fibonacci numbers...

GML

///fibonacci(n)
//Returns the nth fibonacci number

var n, numb;
n = argument0;

if (n == 0)
    {
    numb = 0;
    }
else
    {
    var fm2, fm1;
    fm2 = 0;
    fm1 = 1;
    numb = 1;
    repeat(n-1)
        {
        numb = fm2+fm1;
        fm2 = fm1;
        fm1 = numb;
        }
    }

return numb;

Go

Recursive

func fib(a int) int {
  if a < 2 {
    return a
  }
  return fib(a - 1) + fib(a - 2)
}

Iterative

import (
	"math/big"
)

func fib(n uint64) *big.Int {
	if n < 2 {
		return big.NewInt(int64(n))
	}
	a, b := big.NewInt(0), big.NewInt(1)
	for n--; n > 0; n-- {
		a.Add(a, b)
		a, b = b, a
	}
	return b
}

Iterative using a closure

func fibNumber() func() int {
	fib1, fib2 := 0, 1
	return func() int {
		fib1, fib2 = fib2, fib1 + fib2
		return fib1
	}
}

func fibSequence(n int) int {
	f := fibNumber()
	fib := 0
	for i := 0; i < n; i++ {
		fib = f()
	}
	return fib
}

Using a goroutine and channel

func fib(c chan int) {
	a, b := 0, 1
	for {
		c <- a
		a, b = b, a+b
	}
}

func main() {
	c := make(chan int)
	go fib(c)
	for i := 0; i < 10; i++ {
		fmt.Println(<-c)
	}
}

Grain

Recursive

import String from "string"
import File from "sys/file"
let rec fib = n => if (n < 2) {
  n
} else {
  fib(n - 1) + fib(n - 2)
}
for (let mut i = 0; i <= 20; i += 1) {
  File.fdWrite(File.stdout, Pervasives.toString(fib(i)))
  ignore(File.fdWrite(File.stdout, " "))
}

Iterative

import File from "sys/file"
let fib = j => {
  let mut fnow = 0, fnext = 1
  for (let mut n = 0; n <= j; n += 1) {
    if (n == 0 || n == 1) {
      let output1 = " " ++ toString(n)
      ignore(File.fdWrite(File.stdout, output1))
    } else {
      let tempf = fnow + fnext
      fnow = fnext
      fnext = tempf
      let output2 = " " ++ toString(fnext)
      ignore(File.fdWrite(File.stdout, output2))
    }
  }
}
fib(20)

Output:

Iterative with Buffer

import Buffer from "buffer"
import String from "string"
let fib = j => {
  // set-up minimal, growable buffer
  let buf = Buffer.make(j * 2)
  let mut fnow = 0, fnext = 1
  for (let mut n = 0; n <= j; n += 1) {
    if (n == 0 || n == 1) {
      Buffer.addChar(' ', buf)
      Buffer.addString(toString(n), buf)
    } else {
      let tempf = fnow + fnext
      fnow = fnext
      fnext = tempf
      Buffer.addChar(' ', buf)
      Buffer.addString(toString(fnext), buf)
    }
  }
  // stringify buffer and return
  Buffer.toString(buf)
}
let output = fib(20)
print(output)

Output:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

Groovy

Full "extra credit" solutions.

Recursive

A recursive closure must be pre-declared.

def rFib
rFib = { 
    it == 0   ? 0 
    : it == 1 ? 1 
    : it > 1  ? rFib(it-1) + rFib(it-2)
    /*it < 0*/: rFib(it+2) - rFib(it+1)
    
}

Iterative

def iFib = { 
    it == 0   ? 0 
    : it == 1 ? 1 
    : it > 1  ? (2..it).inject([0,1]){i, j -> [i[1], i[0]+i[1]]}[1]
    /*it < 0*/: (-1..it).inject([0,1]){i, j -> [i[1]-i[0], i[0]]}[0]
}

Analytic

final φ = (1 + 5**(1/2))/2
def aFib = { (φ**it - (-φ)**(-it))/(5**(1/2)) as BigInteger }

Test program:

def time = { Closure c ->
    def start = System.currentTimeMillis()
    def result = c()
    def elapsedMS = (System.currentTimeMillis() - start)/1000
    printf '(%6.4fs elapsed)', elapsedMS
    result
}

print "  F(n)      elapsed time   "; (-10..10).each { printf ' %3d', it }; println()
print "--------- -----------------"; (-10..10).each { print ' ---' }; println()
[recursive:rFib, iterative:iFib, analytic:aFib].each { name, fib ->
    printf "%9s ", name
    def fibList = time { (-10..10).collect {fib(it)} }
    fibList.each { printf ' %3d', it }
    println()
}

Output:

  F(n)      elapsed time    -10  -9  -8  -7  -6  -5  -4  -3  -2  -1   0   1   2   3   4   5   6   7   8   9  10
--------- ----------------- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
recursive (0.0080s elapsed) -55  34 -21  13  -8   5  -3   2  -1   1   0   1   1   2   3   5   8  13  21  34  55
iterative (0.0040s elapsed) -55  34 -21  13  -8   5  -3   2  -1   1   0   1   1   2   3   5   8  13  21  34  55
 analytic (0.0030s elapsed) -55  34 -21  13  -8   5  -3   2  -1   1   0   1   1   2   3   5   8  13  21  34  55

Harbour

Recursive

#include "harbour.ch"
Function fibb(a,b,n)
return(if(--n>0,fibb(b,a+b,n),a))

Iterative

#include "harbour.ch"
Function fibb(n) 
	local fnow:=0, fnext:=1, tempf
	while (--n>0)
		tempf:=fnow+fnext
		fnow:=fnext
		fnext:=tempf
	end while
return(fnext)

Haskell

Analytic

Works with: exact-real version 0.12.5.1

Using Binet's formula and exact real arithmetic library we can calculate arbitrary Fibonacci number exactly.

import Data.CReal

phi = (1 + sqrt 5) / 2

fib :: (Integral b) => b -> CReal 0
fib n = (phi^^n - (-phi)^^(-n))/sqrt 5

Let's try it for large numbers:

λ> fib 10 :: CReal 0
55
(0.01 secs, 137,576 bytes)
λ> fib 100 :: CReal 0
354224848179261915075
(0.01 secs, 253,152 bytes)
λ> fib 10000 :: CReal 0
33644764876431783266621612005107543310302148460680063906564769974680081442166662368155595513633734025582065332680836159373734790483865268263040892463056431887354544369559827491606602099884183933864652731300088830269235673613135117579297437854413752130520504347701602264758318906527890855154366159582987279682987510631200575428783453215515103870818298969791613127856265033195487140214287532698187962046936097879900350962302291026368131493195275630227837628441540360584402572114334961180023091208287046088923962328835461505776583271252546093591128203925285393434620904245248929403901706233888991085841065183173360437470737908552631764325733993712871937587746897479926305837065742830161637408969178426378624212835258112820516370298089332099905707920064367426202389783111470054074998459250360633560933883831923386783056136435351892133279732908133732642652633989763922723407882928177953580570993691049175470808931841056146322338217465637321248226383092103297701648054726243842374862411453093812206564914032751086643394517512161526545361333111314042436854805106765843493523836959653428071768775328348234345557366719731392746273629108210679280784718035329131176778924659089938635459327894523777674406192240337638674004021330343297496902028328145933418826817683893072003634795623117103101291953169794607632737589253530772552375943788434504067715555779056450443016640119462580972216729758615026968443146952034614932291105970676243268515992834709891284706740862008587135016260312071903172086094081298321581077282076353186624611278245537208532365305775956430072517744315051539600905168603220349163222640885248852433158051534849622434848299380905070483482449327453732624567755879089187190803662058009594743150052402532709746995318770724376825907419939632265984147498193609285223945039707165443156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875
(0.02 secs, 4,847,128 bytes)
λ> fib (-10) :: CReal 0
-55
(0.01 secs, 138,408 bytes)

Recursive

Simple definition, very inefficient.

fib x =
  if x < 1
    then 0
    else if x < 2
           then 1
           else fib (x - 1) + fib (x - 2)

Recursive with Memoization

Very fast.

fib x =
  if x < 1
    then 0
    else if x == 1
           then 1
           else fibs !! (x - 1) + fibs !! (x - 2)
  where
    fibs = map fib [0 ..]

Recursive with Memoization using memoized library

Even faster and simpler is to use a defined memoizer (e.g. from MemoTrie package):

import Data.MemoTrie
fib :: Integer -> Integer
fib = memo f where
   f 0 = 0
   f 1 = 1
   f n = fib (n-1) + fib (n-2)

You can rewrite this without introducing f explicitly

import Data.MemoTrie
fib :: Integer -> Integer
fib = memo $ \x -> case x of
   0 -> 0
   1 -> 1
   n -> fib (n-1) + fib (n-2)

Or using LambdaCase extension you can write it even shorter:

{-# Language LambdaCase #-}
import Data.MemoTrie
fib :: Integer -> Integer
fib = memo $ \case 
   0 -> 0
   1 -> 1
   n -> fib (n-1) + fib (n-2)

The version that supports negative numbers:

{-# Language LambdaCase #-}
import Data.MemoTrie
fib :: Integer -> Integer
fib = memo $ \case 
   0 -> 0
   1 -> 1
   n | n>0 -> fib (n-1) + fib (n-2)
     | otherwise -> fib (n+2) - fib (n+1)

Iterative

fib n = go n 0 1
  where
    go n a b
      | n == 0 = a
      | otherwise = go (n - 1) b (a + b)

With lazy lists

This is a standard example how to use lazy lists. Here's the (infinite) list of all Fibonacci numbers:

fib = 0 : 1 : zipWith (+) fib (tail fib)

Or alternatively:

fib = 0 : 1 : (zipWith (+) <*> tail) fib

The nth Fibonacci number is then just fib !! n. The above is equivalent to

fib = 0 : 1 : next fib where next (a: t@(b:_)) = (a+b) : next t

Also

fib = 0 : scanl (+) 1 fib

As a fold

Accumulator holds last two members of the series:

import Data.List (foldl') --'

fib :: Integer -> Integer
fib n =
  fst $
  foldl' --'
    (\(a, b) _ -> (b, a + b))
    (0, 1)
    [1 .. n]

With matrix exponentiation

Adapting the (rather slow) code from Matrix exponentiation operator, we can simply write:

import Data.List (transpose)

fib
  :: (Integral b, Num a)
  => b -> a
fib 0 = 0 -- this line is necessary because "something ^ 0" returns "fromInteger 1", which unfortunately
-- in our case is not our multiplicative identity (the identity matrix) but just a 1x1 matrix of 1
fib n = (last . head . unMat) (Mat [[1, 1], [1, 0]] ^ n)

-- Code adapted from Matrix exponentiation operator task ---------------------
(<+>)
  :: Num c
  => [c] -> [c] -> [c]
(<+>) = zipWith (+)

(<*>)
  :: Num a
  => [a] -> [a] -> a
(<*>) = (sum .) . zipWith (*)

newtype Mat a = Mat
  { unMat :: [[a]]
  } deriving (Eq)

instance Show a =>
         Show (Mat a) where
  show xm = "Mat " ++ show (unMat xm)

instance Num a =>
         Num (Mat a) where
  negate xm = Mat $ map (map negate) $ unMat xm
  xm + ym = Mat $ zipWith (<+>) (unMat xm) (unMat ym)
  xm * ym =
    Mat
      [ [ xs Main.<*> ys -- to distinguish from standard applicative operator
        | ys <- transpose $ unMat ym ]
      | xs <- unMat xm ]
  fromInteger n = Mat [[fromInteger n]]
  abs = undefined
  signum = undefined

-- TEST ----------------------------------------------------------------------
main :: IO ()
main = (print . take 10 . show . fib) (10 ^ 5)

So, for example, the hundred-thousandth Fibonacci number starts with the digits:

Output:

"2597406934"

With recurrence relations

Using Fib[m=3n+r] recurrence identities:

import Control.Arrow ((&&&))

fibstep :: (Integer, Integer) -> (Integer, Integer)
fibstep (a, b) = (b, a + b)

fibnums :: [Integer]
fibnums = map fst $ iterate fibstep (0, 1)

fibN2 :: Integer -> (Integer, Integer)
fibN2 m
  | m < 10 = iterate fibstep (0, 1) !! fromIntegral m
fibN2 m = fibN2_next (n, r) (fibN2 n)
  where
    (n, r) = quotRem m 3

fibN2_next (n, r) (f, g)
  | r == 0 = (a, b) -- 3n  ,3n+1
  | r == 1 = (b, c) -- 3n+1,3n+2
  | r == 2 = (c, d) -- 3n+2,3n+3   (*)
  where
    a =
      5 * f ^ 3 +
      if even n
        then 3 * f
        else (-3 * f) -- 3n
    b = g ^ 3 + 3 * g * f ^ 2 - f ^ 3 -- 3n+1
    c = g ^ 3 + 3 * g ^ 2 * f + f ^ 3 -- 3n+2
    d =
      5 * g ^ 3 +
      if even n
        then (-3 * g)
        else 3 * g -- 3(n+1)   (*)

main :: IO ()
main = print $ (length &&& take 20) . show . fst $ fibN2 (10 ^ 2)

Output:

(21,"35422484817926191507")

(fibN2 n) directly calculates a pair (f,g) of two consecutive Fibonacci numbers, (Fib[n], Fib[n+1]), from recursively calculated such pair at about n/3:

 *Main> (length &&& take 20) . show . fst $ fibN2 (10^6)
(208988,"19532821287077577316")

The above should take less than 0.1s to calculate on a modern box.

Other identities that could also be used are here. In particular, for (n-1,n) ---> (2n-1,2n) transition which is equivalent to the matrix exponentiation scheme, we have

f (n,(a,b)) = (2*n,(a*a+b*b,2*a*b+b*b))     -- iterate f (1,(0,1)) ; b is nth

and for (n,n+1) ---> (2n,2n+1) (derived from d'Ocagne's identity, for example),

g (n,(a,b)) = (2*n,(2*a*b-a*a,a*a+b*b))     -- iterate g (1,(1,1)) ; a is nth

Haxe

Iterative

static function fib(steps:Int, handler:Int->Void)
{
	var current = 0;
	var next = 1;
		
	for (i in 1...steps)
	{
		handler(current);

		var temp = current + next;
		current = next;
		next = temp;
	}
	handler(current);
}

As Iterator

class FibIter
{
	private var current = 0;
	private var nextItem = 1;
	private var limit:Int;
	
	public function new(limit) this.limit = limit;

	public function hasNext() return limit > 0;
	
	public function next() {
		limit--;
		var ret = current;
		var temp = current + nextItem;
		current = nextItem;
		nextItem = temp;
		return ret;
	}
}

Used like:

for (i in new FibIter(10))
	Sys.println(i);

HicEst

REAL :: Fibonacci(10)

Fibonacci = ($==2) + Fibonacci($-1) + Fibonacci($-2)
WRITE(ClipBoard) Fibonacci ! 0 1 1 2 3 5 8 13 21 34

Hoon

|=  n=@ud
=/  a=@ud  0
=/  b=@ud  1
|-
?:  =(n 0)  a
$(a b, b (add a b), n (dec n))

Hope

Recursive

dec f : num -> num;
--- f 0 <= 0;
--- f 1 <= 1;
--- f(n+2) <= f n + f(n+1);

Tail-recursive

dec fib : num -> num;
--- fib n <= l (1, 0, n)
    whererec l == \(a,b,succ c) => if c<1 then a else l((a+b),a,c)
                  |(a,b,0) => 0;

With lazy lists

This language, being one of Haskell's ancestors, also has lazy lists. Here's the (infinite) list of all Fibonacci numbers:

dec fibs : list num;
--- fibs <= fs whererec fs == 0::1::map (+) (tail fs||fs);

The nth Fibonacci number is then just fibs @ n.

Hy

Recursive implementation.

(defn fib [n]
    (if (< n 2)
        n
        (+ (fib (- n 2)) (fib (- n 1)))))

Icon and Unicon

Icon has built-in support for big numbers. First, a simple recursive solution augmented by caching for non-negative input. This examples computes fib(1000) if there is no integer argument.

procedure main(args)
    write(fib(integer(!args) | 1000)
end

procedure fib(n)
    static fCache
    initial {
        fCache := table()
        fCache[0] := 0
        fCache[1] := 1
        }
    /fCache[n] := fib(n-1) + fib(n-2)
    return fCache[n]
end

Library: Icon Programming Library

The above solution is similar to the one provided fib in memrfncs

Now, an O(logN) solution. For large N, it takes far longer to convert the result to a string for output than to do the actual computation. This example computes fib(1000000) if there is no integer argument.

procedure main(args)
    write(fib(integer(!args) | 1000000))
end

procedure fib(n)
    return fibMat(n)[1]
end

procedure fibMat(n)
    if n <= 0 then return [0,0]
    if n  = 1 then return [1,0]
    fp := fibMat(n/2)
    c := fp[1]*fp[1] + fp[2]*fp[2]
    d := fp[1]*(fp[1]+2*fp[2])
    if n%2 = 1 then return [c+d, d]
    else return [d, c]
end

IDL

Recursive

function fib,n
   if n lt 3 then return,1L else return, fib(n-1)+fib(n-2)
end

Execution time O(2^n) until memory is exhausted and your machine starts swapping. Around fib(35) on a 2GB Core2Duo.

Iterative

function fib,n
  psum = (csum = 1uL)
  if n lt 3 then return,csum
  for i = 3,n do begin
    nsum = psum + csum
    psum = csum
    csum = nsum
  endfor
  return,nsum
end

Execution time O(n). Limited by size of uLong to fib(49)

Analytic

function fib,n
  q=1/( p=(1+sqrt(5))/2 ) 
  return,round((p^n+q^n)/sqrt(5))
end

Execution time O(1), only limited by the range of LongInts to fib(48).

Idris

Analytic

fibAnalytic : Nat -> Double
fibAnalytic n = 
    floor $ ((pow goldenRatio n) - (pow (-1.0/goldenRatio) n))  / sqrt(5)
  where goldenRatio : Double 
        goldenRatio = (1.0 + sqrt(5)) / 2.0

Recursive

fibRecursive : Nat -> Nat
fibRecursive Z = Z
fibRecursive (S Z) = (S Z)
fibRecursive (S (S n)) = fibRecursive (S n) + fibRecursive n

Iterative

fibIterative : Nat -> Nat
fibIterative n = fibIterative' n Z (S Z)
  where fibIterative' : Nat -> Nat -> Nat -> Nat
        fibIterative' Z a _ = a
        fibIterative' (S n) a b = fibIterative' n b (a + b)

Lazy

fibLazy : Lazy (List Nat)
fibLazy = 0 :: 1 :: zipWith (+) fibLazy (
              case fibLazy of
                (x::xs) => xs
                [] => [])

J

The Fibonacci Sequence essay on the J Wiki presents a number of different ways of obtaining the nth Fibonacci number.

This implementation is doubly recursive except that results are cached across function calls:

fibN=: (-&2 +&$: <:)^:(1&<) M."0

Iteration:

fibN=: [: {."1 +/\@|.@]^:[&0 1

Examples:

   fibN 12
144
   fibN  i.31
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040

Java

Iterative

public static long itFibN(int n)
{
 if (n < 2)
  return n;
 long ans = 0;
 long n1 = 0;
 long n2 = 1;
 for(n--; n > 0; n--)
 {
  ans = n1 + n2;
  n1 = n2;
  n2 = ans;
 }
 return ans;
}

/**
 * O(log(n))
 */
public static long fib(long n) {
    if (n <= 0)
	return 0;

    long i = (int) (n - 1);
    long a = 1, b = 0, c = 0, d = 1, tmp1,tmp2;

    while (i > 0) {
	if (i % 2 != 0) {
            tmp1 = d * b + c * a;
	    tmp2 = d * (b + a) + c * b;
	    a = tmp1;
	    b = tmp2;
	}

        tmp1 = (long) (Math.pow(c, 2) + Math.pow(d, 2));
        tmp2 = d * (2 * c + d);
			
        c = tmp1;
        d = tmp2;

        i = i / 2;
    }
    return a + b;
}

Recursive

public static long recFibN(final int n)
{
 return (n < 2) ? n : recFibN(n - 1) + recFibN(n - 2);
}

Caching-recursive

A variant on recursive, that caches previous results, reducing complexity from O(n²) to simply O(n). Leveraging Java’s Map.computeIfAbsent makes this thread-safe, and the implementation pretty trivial.

public class Fibonacci {

    static final Map<Integer, Long> cache = new HashMap<>();
    static {
        cache.put(1, 1L);
        cache.put(2, 1L);
    }

    public static long get(int n)
    {
        return (n < 2) ? n : impl(n);
    }
    
    private static long impl(int n)
    {
        return cache.computeIfAbsent(n, k -> impl(k-1) + impl(k-2));
    }
}

Analytic

This method works up to the 92^nd Fibonacci number. After that, it goes out of range.

public static long anFibN(final long n)
{
 double p = (1 + Math.sqrt(5)) / 2;
 double q = 1 / p;
 return (long) ((Math.pow(p, n) + Math.pow(q, n)) / Math.sqrt(5));
}

Tail-recursive

public static long fibTailRec(final int n)
{
 return fibInner(0, 1, n);
}

private static long fibInner(final long a, final long b, final int n)
{
 return n < 1 ? a : n == 1 ?  b : fibInner(b, a + b, n - 1);
}

Streams

import java.util.function.LongUnaryOperator;
import java.util.stream.LongStream;

public class FibUtil {
 public static LongStream fibStream() {
  return LongStream.iterate( 1l, new LongUnaryOperator() {
   private long lastFib = 0;
   @Override public long applyAsLong( long operand ) {
    long ret = operand + lastFib;
    lastFib = operand;
    return ret;
   }
  });
 }
 public static long fib(long n) {
  return fibStream().limit( n ).reduce((prev, last) -> last).getAsLong();
 }
}

JavaScript

ES5

Recursive

Basic recursive function:

function fib(n) {
  return n<2?n:fib(n-1)+fib(n-2);
}

Can be rewritten as:

function fib(n) {
 if (n<2) { return n; } else { return fib(n-1)+fib(n-2); }
}

One possibility familiar to Scheme programmers is to define an internal function for iteration through anonymous tail recursion:

function fib(n) {
  return function(n,a,b) {
    return n>0 ? arguments.callee(n-1,b,a+b) : a;
  }(n,0,1);
}

Iterative

function fib(n) {
  var a = 0, b = 1, t;
  while (n-- > 0) {
    t = a;
    a = b;
    b += t;
    console.log(a);
  }
  return a;
}

Memoization

With the keys of a dictionary,

var fib = (function(cache){
    return cache = cache || {}, function(n){
        if (cache[n]) return cache[n];
        else return cache[n] = n == 0 ? 0 : n < 0 ? -fib(-n)
            : n <= 2 ? 1 : fib(n-2) + fib(n-1);
    };
})();

with the indices of an array,

(function () {
    'use strict';

    function fib(n) {
        return Array.apply(null, Array(n + 1))
            .map(function (_, i, lst) {
                return lst[i] = (
                    i ? i < 2 ? 1 :
                    lst[i - 2] + lst[i - 1] :
                    0
                );
            })[n];
    }

    return fib(32);

})();

Output:

Y-Combinator

function Y(dn) {
    return (function(fn) {
        return fn(fn);
    }(function(fn) {
        return dn(function() {
            return fn(fn).apply(null, arguments);
        });
    }));
}
var fib = Y(function(fn) {
    return function(n) {
        if (n === 0 || n === 1) {
            return n;
        }
        return fn(n - 1) + fn(n - 2);
    };
});

Generators

function* fibonacciGenerator() {
    var prev = 0;
    var curr = 1;
    while (true) {
        yield curr;
        curr = curr + prev;
        prev = curr - prev;
    }
}
var fib = fibonacciGenerator();

ES6

Memoized

If we want access to the whole preceding series, as well as a memoized route to a particular member, we can use an accumulating fold.

(() => {
    'use strict';

    // Nth member of fibonacci series

    // fib :: Int -> Int
    function fib(n) {
        return mapAccumL(([a, b]) => [
            [b, a + b], b
        ], [0, 1], range(1, n))[0][0];
    };

    // GENERIC FUNCTIONS

    // mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
    let mapAccumL = (f, acc, xs) => {
        return xs.reduce((a, x) => {
            let pair = f(a[0], x);

            return [pair[0], a[1].concat(pair[1])];
        }, [acc, []]);
    }

    // range :: Int -> Int -> Maybe Int -> [Int]
    let range = (m, n) =>
        Array.from({
            length: Math.floor(n - m) + 1
        }, (_, i) => m + i);


    // TEST
    return fib(32);

    // --> 2178309
})();

Otherwise, a simple fold will suffice.

Translation of: Haskell

(Memoized fold example)

(() => {
    'use strict';

    // fib :: Int -> Int
    let fib = n => range(1, n)
        .reduce(([a, b]) => [b, a + b], [0, 1])[0];


    // GENERIC [m..n]

    // range :: Int -> Int -> [Int]
    let range = (m, n) =>
        Array.from({
            length: Math.floor(n - m) + 1
        }, (_, i) => m + i);


    // TEST
    return fib(32);

    // --> 2178309
})();

Output:

Joy

Recursive

DEFINE fib == [small] [] [pred dup pred] [+] binrec.

Iterative

DEFINE fib == [1 0] dip [swap [+] unary] times popd.

jq

Works with: jq

Works with gojq, the Go implementation of jq

The C implementation of jq does not (yet) have infinite-precision integer arithmetic, and so using it, the following algorithms only give exact answers up to fib(78). By contrast, using the Go implementation of jq and the definition of nth_fib given below:

nth_fib(pow(2;20)) | tostring | [length, .[:10], .[-10:]]

yields

[219140,"1186800606","0691163707"]

in about 20 seconds on a 3GHz machine.

Using either the C or Go implementations, at a certain point, integers are converted to floats, but floating point precision for fib(n) fails after n = 1476: in jq, fib(1476) evaluates to 1.3069892237633987e+308

Recursive

def nth_fib_naive(n):
  if (n < 2) then n
  else nth_fib_naive(n - 1) + nth_fib_naive(n - 2)
  end;

Tail Recursive

Recent versions of jq (after July 1, 2014) include basic optimizations for tail recursion, and nth_fib is defined here to take advantage of TCO. For example, nth_fib(10000000) completes with only 380KB (that's K) of memory. However nth_fib can also be used with earlier versions of jq.

def nth_fib(n):
  # input: [f(i-2), f(i-1), countdown]
  def fib: (.[0] + .[1]) as $sum
    | .[2] as $n
    | if ($n <= 0) then $sum
      else [ .[1], $sum, $n - 1 ]
    | fib end;
  [-1, 1, n] | fib;

Example:

(range(0;5), 50) | [., nth_fib(.)]

yields:

[0,0]
[1,1]
[2,1]
[3,2]
[4,3]
[50,12586269025]

Binet's Formula

def fib_binet(n):
  (5|sqrt) as $rt
  | ((1 + $rt)/2) as $phi
  | (($phi | log) * n | exp) as $phin
  | (if 0 == (n % 2) then 1 else -1 end) as $sign
  | ( ($phin - ($sign / $phin) ) / $rt ) + .5
  | floor;

Generator

The following is a jq generator which produces the first n terms of the Fibonacci sequence efficiently, one by one. Notice that it is simply a variant of the above tail-recursive function. The function is in effect turned into a generator by changing "( _ | fib )" to "$sum, (_ | fib)".

# Generator
def fibonacci(n):
  # input: [f(i-2), f(i-1), countdown]
  def fib: (.[0] + .[1]) as $sum
           | if .[2] == 0 then $sum
             else $sum, ([ .[1], $sum, .[2] - 1 ] | fib)
             end;
  [-1, 1, n] | fib;

Julia

Recursive

fib(n) = n < 2 ? n : fib(n-1) + fib(n-2)

Iterative

function fib(n)
  x,y = (0,1)
  for i = 1:n x,y = (y, x+y) end
  x
end

Matrix form

fib(n) = ([1 1 ; 1 0]^n)[1,2]

K

Works with: Kona

Recursive

{:[x<3;1;_f[x-1]+_f[x-2]]}

Recursive with memoization

Using a (global) dictionary c.

{c::.();{v:c[a:`$$x];:[x<3;1;:[_n~v;c[a]:_f[x-1]+_f[x-2];v]]}x}

Analytic

phi:(1+_sqrt(5))%2
{_((phi^x)-((1-phi)^x))%_sqrt[5]}

Sequence to n

Works with: Kona

Works with: ngn/k

{(x(|+\)\1 1)[;1]}

{x{x,+/-2#x}/!2}

Kabap

Sequence to n

// Calculate the $n'th Fibonacci number

// Set this to how many in the sequence to generate
$n = 10;

// These are what hold the current calculation
$a = 0;
$b = 1;

// This holds the complete sequence that is generated
$sequence = "";

// Prepare a loop
$i = 0;
:calcnextnumber;
	$i = $i++;

	// Do the calculation for this loop iteration
	$b = $a + $b;
	$a = $b - $a;

	// Add the result to the sequence
	$sequence = $sequence << $a;

	// Make the loop run a fixed number of times
	if $i < $n; {
		$sequence = $sequence << ", ";
		goto calcnextnumber;
	}

// Use the loop counter as the placeholder
$i--;

// Return the sequence
return = "Fibonacci number " << $i << " is " << $a << " (" << $sequence << ")";

Klingphix

:Fibonacci
    dup 0 less
    ( ["Invalid argument"]
      [1 1 rot 2 sub [drop over over add] for]
    ) if
;

30 Fibonacci pstack print nl

msec print nl
"bertlham " input

Kotlin

enum class Fibonacci {
    ITERATIVE {
        override fun get(n: Int): Long = if (n < 2) {
            n.toLong()
        } else {
            var n1 = 0L
            var n2 = 1L
            repeat(n) {
                val sum = n1 + n2
                n1 = n2
                n2 = sum
            }
            n1
        }
    },
    RECURSIVE {
        override fun get(n: Int): Long = if (n < 2) n.toLong() else this[n - 1] + this[n - 2]
    },
    CACHING {
        val cache: MutableMap<Int, Long> = mutableMapOf(0 to 0L, 1 to 1L)
        override fun get(n: Int): Long = if (n < 2) n.toLong() else impl(n)
        private fun impl(n: Int): Long = cache.computeIfAbsent(n) { impl(it-1) + impl(it-2) }
    },
    ;
 
    abstract operator fun get(n: Int): Long
}
 
fun main() {
    val r = 0..30
    for (fib in Fibonacci.values()) {
        print("${fib.name.padEnd(10)}:")
        for (i in r) { print(" " + fib[i]) }
        println()
    }
}

Output:

ITERATIVE:  0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040
RECURSIVE:  0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040
CACHING   : 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040

L++

(defn int fib (int n) (return (? (< n 2) n (+ (fib (- n 1)) (fib (- n 2))))))
(main (prn (fib 30)))

LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Lambdatalk

1) basic version 
{def fib1 
 {lambda {:n}
  {if {< :n 3}
   then 1
   else {+ {fib1 {- :n 1}} {fib1 {- :n 2}}} }}}

{fib1 16} -> 987   (CPU ~ 16ms)
{fib1 30} = 832040 (CPU > 12000ms)

2) tail-recursive version
{def fib2
 {def fib2.r 
  {lambda {:a :b :i}
   {if {< :i 1} 
    then :a 
    else {fib2.r :b {+ :a :b} {- :i 1}} }}}
 {lambda {:n} {fib2.r 0 1 :n}}}

{fib2 16} -> 987    (CPU ~ 1ms)
{fib2 30} -> 832040 (CPU ~2ms)
{fib2 1000} -> 4.346655768693743e+208 (CPU ~ 22ms)  

3) Dijkstra Algorithm
{def fib3
 {def fib3.r
  {lambda {:a :b :p :q :count}
   {if {= :count 0}
    then :b
    else {if {= {% :count 2} 0}
    then {fib3.r :a :b
                {+ {* :p :p} {* :q :q}}
                {+ {* :q :q} {* 2 :p :q}}
                {/ :count 2}}
    else {fib3.r {+ {* :b :q} {* :a :q} {* :a :p}}
                {+ {* :b :p} {* :a :q}}
                :p :q
                {- :count 1}} }}}}
 {lambda {:n}
  {fib3.r 1 0 0 1 :n} }}

{fib3 16} -> 987    (CPU ~ 2ms)
{fib3 30} -> 832040 (CPU ~ 2ms)
{fib3 1000} -> 4.346655768693743e+208 (CPU ~ 3ms)  

4) memoization
{def fib4
 {def fib4.m {array.new}}    // init an empty array
 {def fib4.r {lambda {:n}
  {if {< :n 2}
   then {array.get {array.set! {fib4.m} :n 1} :n}      // init with 1,1
   else {if {equal? {array.get {fib4.m} :n} undefined} // if not exists
   then {array.get {array.set! {fib4.m} :n
                        {+ {fib4.r {- :n 1}}
                           {fib4.r {- :n 2}}}} :n}   // compute it
   else {array.get {fib4.m} :n} }}}}                   // else get it
 {lambda {:n}
  {fib4.r :n} 
  {fib4.m} }} // display the number AND all its predecessors
-> fib4
{fib4 90}  
-> 4660046610375530000 
[1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,
317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,
165580141,267914296,433494437,701408733,1134903170,1836311903,2971215073,4807526976,7778742049,12586269025,
20365011074,32951280099,53316291173,86267571272,139583862445,225851433717,365435296162,591286729879,956722026041,
1548008755920,2504730781961,4052739537881,6557470319842,10610209857723,17167680177565,27777890035288,44945570212853,
72723460248141,117669030460994,190392490709135,308061521170129,498454011879264,806515533049393,1304969544928657,
2111485077978050,3416454622906707,5527939700884757,8944394323791464,14472334024676220,23416728348467684,
37889062373143900,61305790721611580,99194853094755490,160500643816367070,259695496911122560,420196140727489660,
679891637638612200,1100087778366101900,1779979416004714000,2880067194370816000,4660046610375530000]

5) Binet's formula (non recursive)
{def fib5 
 {lambda {:n}
  {let { {:n :n} {:sqrt5 {sqrt 5}} }
   {round {/ {- {pow {/ {+ 1 :sqrt5} 2} :n} 
                {pow {/ {- 1 :sqrt5} 2} :n}} :sqrt5}}} }}

{fib5 16} -> 987    (CPU ~ 1ms) 
{fib5 30} -> 832040 (CPU ~ 1ms)
{fib5 1000} -> 4.346655768693743e+208 (CPU ~ 1ms)

Lang

Iterative

fp.fib = ($n) -> {
	if($n < 2) {
		return $n
	}
	
	$prev = 1
	$cur = 1
	$i = 2
	while($i < $n) {
		$tmp = $cur
		$cur += $prev
		$prev = $tmp
		
		$i += 1
	}
	
	return $cur
}

Recursive

fp.fib = ($n) -> {
	if($n < 2) {
		return $n
	}
	
	return parser.op(fp.fib($n - 1) + fp.fib($n - 2))
}

Lang5

[] '__A set : dip swap __A swap 2 compress collapse '__A set execute
    __A -1 extract nip ;  : nip swap drop ;  : tuck swap over ;
: -rot rot rot ; : 0= 0 == ; : 1+ 1 + ; : 1- 1 - ; : sum '+ reduce ;
: bi 'keep dip execute ;  : keep over 'execute dip ;

: fib dup 1 > if dup 1- fib swap 2 - fib + then ;
: fib  dup 1 > if "1- fib" "2 - fib" bi + then ;

langur

val .fibonacci = fn(.x) { if(.x < 2: .x ; self(.x - 1) + self(.x - 2)) }

writeln map .fibonacci, series 2..20

Output:

[1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

Lasso

define fibonacci(n::integer) => {

	#n < 1 ? return false

	local(
		swap	= 0,
		n1		= 0,
		n2		= 1
	)

	loop(#n) => {
        #swap = #n1 + #n2;
        #n2 = #n1;
        #n1 = #swap;
	}
	return #n1

}

fibonacci(0) //->output false
fibonacci(1) //->output 1
fibonacci(2) //->output 1
fibonacci(3) //->output 2

Latitude

Recursive

fibo := {
  takes '[n].
  if { n <= 1. } then {
    n.
  } else {
    fibo (n - 1) + fibo (n - 2).
  }.
}.

Memoization

fibo := {
  takes '[n].
  cache := here cache.
  { cache slot? (n ordinal). } ifFalse {
    cache slot (n ordinal) =
      if { n <= 1. } then {
        n.
      } else {
        fibo (n - 1) + fibo (n - 2).
      }.
  }.
  cache slot (n ordinal).
} tap {
  ;; Attach the cache to the method object itself.
  #'self cache := Object clone.
}.

Lean

It runs on Lean 3.4.2:

-- Our first implementation is the usual recursive definition:
def fib1 : ℕ → ℕ 
| 0       := 0
| 1       := 1
| (n + 2) := fib1 n + fib1 (n + 1)


-- We can give a second more efficient implementation using an auxiliary function:
def fib_aux : ℕ → ℕ → ℕ → ℕ 
| 0 a b       := b
| (n + 1) a b := fib_aux n (a + b) a

def fib2 : ℕ → ℕ 
| n := fib_aux n 1 0


-- Use #eval to check computations:
#eval fib1 20
#eval fib2 20

It runs on Lean 4:

-- Naive version
def fib1 (n : Nat) : Nat :=
  match n with
  | 0 => 0
  | 1 => 1
  | (k + 2) => fib1 k + fib1 (k + 1)

-- More efficient version
def fib_aux (n : Nat) (a : Nat) (b : Nat) : Nat :=
  match n with
  | 0 => b
  | (k + 1) => fib_aux k (a + b) a
 
def fib2 (n : Nat) : Nat :=
  fib_aux n 1 0

-- Examples
#eval fib1 20
#eval fib2 20

LFE

Recursive

(defun fib
  ((0) 0)
  ((1) 1)
  ((n)
    (+ (fib (- n 1))
       (fib (- n 2)))))

Iterative

(defun fib
  ((n) (when (>= n 0))
    (fib n 0 1)))

(defun fib
  ((0 result _)
    result)
  ((n result next)
    (fib (- n 1) next (+ result next))))

Lingo

Recursive

on fib (n)
  if n<2 then return n
  return fib(n-1)+fib(n-2)
end

Iterative

on fib (n)
  if n<2 then return n    
  fibPrev = 0
  fib = 1
  repeat with i = 2 to n
    tmp = fib
    fib = fib + fibPrev
    fibPrev = tmp
  end repeat
  return fib
end

Analytic

on fib (n)
  sqrt5 = sqrt(5.0)
  p = (1+sqrt5)/2
  q = 1 - p
  return integer((power(p,n)-power(q,n))/sqrt5)
end

Lisaac

- fib(n : UINTEGER_32) : UINTEGER_64 <- (
  + result : UINTEGER_64;
  (n < 2).if {
    result := n;
  } else {
    result := fib(n - 1) + fib(n - 2);
  };
  result
);

LiveCode

-- Iterative, translation of the basic version.
function fibi n
    put 0 into aa
    put 1 into b
    repeat with i = 1 to n
        put aa + b into temp
        put b into aa
        put temp into b
    end repeat
    return aa
end fibi

-- Recursive
function fibr n
     if n <= 1 then
        return n
    else
        return fibr(n-1) + fibr(n-2)
    end if
end fibr

LLVM

; This is not strictly LLVM, as it uses the C library function "printf".
; LLVM does not provide a way to print values, so the alternative would be
; to just load the string into memory, and that would be boring.

; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps

$"PRINT_LONG" = comdat any
@"PRINT_LONG" = linkonce_odr unnamed_addr constant [5 x i8] c"%ld\0A\00", comdat, align 1

;--- The declaration for the external C printf function.
declare i32 @printf(i8*, ...)

;--------------------------------------------------------------------
;-- Function for calculating the nth fibonacci numbers
;--------------------------------------------------------------------
define i32 @fibonacci(i32) {
    %2 = alloca i32, align 4            ;-- allocate local copy of n
    %3 = alloca i32, align 4            ;-- allocate a
    %4 = alloca i32, align 4            ;-- allocate b
    store i32 %0, i32* %2, align 4      ;-- store copy of n
    store i32 0, i32* %3, align 4       ;-- a := 0
    store i32 1, i32* %4, align 4       ;-- b := 1
    br label %loop

loop:
    %5 = load i32, i32* %2, align 4     ;-- load n
    %6 = icmp sgt i32 %5, 0             ;-- n > 0
    br i1 %6, label %loop_body, label %exit

loop_body:
    %7 = load i32, i32* %3, align 4     ;-- load a
    %8 = load i32, i32* %4, align 4     ;-- load b
    %9 = add nsw i32 %7, %8             ;-- t = a + b
    store i32 %8, i32* %3, align 4      ;-- store a = b
    store i32 %9, i32* %4, align 4      ;-- store b = t
    %10 = load i32, i32* %2, align 4    ;-- load n
    %11 = add nsw i32 %10, -1           ;-- decrement n
    store i32 %11, i32* %2, align 4     ;-- store n
    br label %loop

exit:
    %12 = load i32, i32* %3, align 4    ;-- load a
    ret i32 %12                         ;-- return a
}

;--------------------------------------------------------------------
;-- Main function for printing successive fibonacci numbers
;--------------------------------------------------------------------
define i32 @main() {
    %1 = alloca i32, align 4            ;-- allocate index
    store i32 0, i32* %1, align 4       ;-- index := 0
    br label %loop

loop:
    %2 = load i32, i32* %1, align 4     ;-- load index
    %3 = icmp sle i32 %2, 12            ;-- index <= 12
    br i1 %3, label %loop_body, label %exit

loop_body:
    %4 = load i32, i32* %1, align 4     ;-- load index
    %5 = call i32 @fibonacci(i32 %4)
    %6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @"PRINT_LONG", i32 0, i32 0), i32 %5)
    %7 = load i32, i32* %1, align 4     ;-- load index
    %8 = add nsw i32 %7, 1              ;-- increment index
    store i32 %8, i32* %1, align 4      ;-- store index
    br label %loop

exit:
    ret i32 0                           ;-- return EXIT_SUCCESS
}

Output:

Logo

to fib "loop
make   "fib1 0
make   "fib2 1

type [You requested\ ]
type :loop
print [\ Fibonacci Numbers]
   type :fib1
   type [\  ]
   type :fib2  
   type [\  ]
   
make "loop :loop - 2
repeat :loop [ make "fibnew :fib1 + :fib2 type :fibnew type [\  ] make "fib1 :fib2 make "fib2 :fibnew ]
   print [\  ]
     
end

LOLCODE

HAI 1.2
HOW DUZ I fibonacci YR N
  EITHER OF BOTH SAEM N AN 1 AN BOTH SAEM N AN 0
  O RLY?
    YA RLY, FOUND YR 1
    NO WAI
      I HAS A N1
      I HAS A N2
      N1 R DIFF OF N AN 1
      N2 R DIFF OF N AN 2
      N1 R fibonacci N1
      N2 R fibonacci N2
      FOUND YR SUM OF N1 AN N2
  OIC
IF U SAY SO
KTHXBYE

LSL

Rez a box on the ground, and add the following as a New Script.

integer Fibonacci(integer n) {
	if(n<2) {
		return n;
	} else {
		return Fibonacci(n-1)+Fibonacci(n-2);
	}
}
default {
	state_entry() {
		integer x = 0;
		for(x=0 ; x<35 ; x++) {
			llOwnerSay("Fibonacci("+(string)x+")="+(string)Fibonacci(x));
		}
	}
}

Output:

Fibonacci(0)=0
Fibonacci(1)=1
Fibonacci(2)=1
Fibonacci(3)=2
Fibonacci(4)=3
Fibonacci(5)=5
Fibonacci(6)=8
Fibonacci(7)=13
Fibonacci(8)=21
Fibonacci(9)=34
Fibonacci(10)=55
Fibonacci(11)=89
Fibonacci(12)=144
Fibonacci(13)=233
Fibonacci(14)=377
Fibonacci(15)=610
Fibonacci(16)=987
Fibonacci(17)=1597
Fibonacci(18)=2584
Fibonacci(19)=4181
Fibonacci(20)=6765
Fibonacci(21)=10946
Fibonacci(22)=17711
Fibonacci(23)=28657
Fibonacci(24)=46368
Fibonacci(25)=75025
Fibonacci(26)=121393
Fibonacci(27)=196418
Fibonacci(28)=317811
Fibonacci(29)=514229
Fibonacci(30)=832040
Fibonacci(31)=1346269
Fibonacci(32)=2178309
Fibonacci(33)=3524578
Fibonacci(34)=5702887

Lua

Recursive

--calculates the nth fibonacci number. Breaks for negative or non-integer n.
function fibs(n) 
  return n < 2 and n or fibs(n - 1) + fibs(n - 2) 
end

Pedantic Recursive

--more pedantic version, returns 0 for non-integer n
function pfibs(n)
  if n ~= math.floor(n) then return 0
  elseif n < 0 then return pfibs(n + 2) - pfibs(n + 1)
  elseif n < 2 then return n
  else return pfibs(n - 1) + pfibs(n - 2)
  end
end

Tail Recursive

function a(n,u,s) if n<2 then return u+s end return a(n-1,u+s,u) end
function trfib(i) return a(i-1,1,0) end

Table Recursive

fib_n = setmetatable({1, 1}, {__index = function(z,n) return n<=0 and 0 or z[n-1] + z[n-2] end})

Table Recursive 2

-- table recursive done properly (values are actually saved into table;
-- also the first element of Fibonacci sequence is 0, so the initial table should be {0, 1}).
fib_n = setmetatable({0, 1}, {
  __index = function(t,n)
    if n <= 0 then return 0 end
    t[n] = t[n-1] + t[n-2]
    return t[n]
  end
})

Iterative

function ifibs(n)
  local p0,p1=0,1
  for _=1,n do p0,p1 = p1,p0+p1 end
  return p0
end

Luck

function fib(x: int): int = (
   let cache = {} in
   let fibc x = if x<=1 then x else (
      if x not in cache then
      cache[x] = fibc(x-1) + fibc(x-2);
      cache[x]
   ) in fibc(x)
);;
for x in range(10) do print(fib(x))

Lush

(de fib-rec (n)
  (if (< n 2)
      n
     (+ (fib-rec (- n 2)) (fib-rec (- n 1)))))

M2000 Interpreter

Return decimal type and use an Inventory (as closure) to store known return values. All closures are in scope in every recursive call (we use here lambda(), but we can use fib(), If we make Fib1=fib then we have to use lambda() for recursion.

Inventory K=0:=0,1:=1
fib=Lambda K (x as decimal)-> {
      If Exist(K, x) Then =Eval(K) :Exit
      Def Ret as Decimal
      Ret=If(x>1->Lambda(x-1)+Lambda(x-2), x)
      Append K, x:=Ret
      =Ret
}
\\ maximum 139
For i=1 to 139 {
      Print Fib(i)
}

Here an example where we use a BigNum class to make a Group which hold a stack of values, and take 14 digits per item in stack. We can use inventory to hold groups, so we use the fast fib() function from code above, where we remove the type definition of Ret variable, and set two first items in inventory as groups.

Class BigNum {
      a=stack
      Function Digits {
            =len(.a)*14-(14-len(str$(stackitem(.a,len(.a)) ,"")))
      }
      Operator "+" (n) {
            \\ we get a copy, but .a is pointer
             \\ we make a copy, and get a new pointer
            .a<=stack(.a)
            acc=0
            carry=0
            const d=100000000000000@
                  k=min.data(Len(.a), len(n.a))
                  i=each(.a, 1,k )
                  j=each(n.a, 1,k)
                  while  i, j {
                        acc=stackitem(i)+stackitem(j)+carry
                        carry= acc div d
                        return .a, i^+1:=acc mod d
                  } 
                  if len(.a)<len(n.a) Then  {
                        i=each(n.a, k+1, -1)
                        while i {
                              acc=stackitem(i)+carry
                              carry= acc div d
                              stack .a  {data acc mod d}
                        }
                  } ELse.if len(.a)>len(n.a) Then  {
                        i=each(.a, k+1, -1)
                        while i {
                              acc=stackitem(i)+carry
                              carry= acc div d
                              Return .a, i^+1:=acc mod d
                              if carry else exit
                        }     
                  }
                  if carry then stack .a { data carry}
      }
      Function tostring$ {
            if len(.a)=0 then ="0" : Exit
            if len(.a)=1 then =str$(Stackitem(.a),"") : Exit
            document buf$=str$(Stackitem(.a, len(.a)),"")
            for i=len(.a)-1 to  1 {
                  Stack .a {
                        buf$=str$(StackItem(i), "00000000000000")
                  }
            }
            =buf$
      }
      class:
      Module BigNum (s$) {
            s$=filter$(s$,"+-.,")
            if s$<>""  Then {
                  repeat {
                        If len(s$)<14 then Stack .a { Data  val(s$) }: Exit
                        Stack .a { Data  val(Right$(s$, 14)) }
                        S$=Left$(S$, len(S$)-14)
                  } Until S$=""
            }
      }
} 

Inventory K=0:=BigNum("0"),1:=BigNum("1")
fib=Lambda K (x as decimal)-> {
      If Exist(K, x) Then =Eval(K) :Exit
      Ret=If(x>1->Lambda(x-1)+Lambda(x-2), bignum(str$(x,"")))
      Append K, x:=Ret
      =Ret
}
\\ Using this to handle form  refresh by code
Set Fast!
For i=1 to 4000 {
      N=Fib(i)
      Print i
      Print N.tostring$()
      Refresh
}

M4

define(`fibo',`ifelse(0,$1,0,`ifelse(1,$1,1,
`eval(fibo(decr($1)) + fibo(decr(decr($1))))')')')dnl
define(`loop',`ifelse($1,$2,,`$3($1) loop(incr($1),$2,`$3')')')dnl
loop(0,15,`fibo')

MAD

            NORMAL MODE IS INTEGER
            
            INTERNAL FUNCTION(N)
            ENTRY TO FIB.
            A = 0
            B = 1
            THROUGH LOOP, FOR N=N, -1, N.E.0
            C = A + B
            A = B
LOOP        B = C
            FUNCTION RETURN A
            END OF FUNCTION
            
            THROUGH SHOW, FOR I=0, 1, I.GE.20
SHOW        PRINT FORMAT FNUM, I, FIB.(I)
            VECTOR VALUES FNUM = $4HFIB(,I2,4H) = ,I4*$
            END OF PROGRAM

Output:

FIB( 0) =    0
FIB( 1) =    1
FIB( 2) =    1
FIB( 3) =    2
FIB( 4) =    3
FIB( 5) =    5
FIB( 6) =    8
FIB( 7) =   13
FIB( 8) =   21
FIB( 9) =   34
FIB(10) =   55
FIB(11) =   89
FIB(12) =  144
FIB(13) =  233
FIB(14) =  377
FIB(15) =  610
FIB(16) =  987
FIB(17) = 1597
FIB(18) = 2584
FIB(19) = 4181

Maple

> f := n -> ifelse(n<3,1,f(n-1)+f(n-2));
> f(2);
  1
> f(3);
  2

Mathematica / Wolfram Language

The Wolfram Language already has a built-in function Fibonacci, but a simple recursive implementation would be

fib[0] = 0
fib[1] = 1
fib[n_Integer] := fib[n - 1] + fib[n - 2]

An optimization is to cache the values already calculated:

fib[0] = 0
fib[1] = 1
fib[n_Integer] := fib[n] = fib[n - 1] + fib[n - 2]

The above implementations may be too simplistic, as the first is incredibly slow for any reasonable range due to nested recursions and while the second is faster it uses an increasing amount of memory. The following uses recursion much more effectively while not using memory:

fibi[prvprv_Integer, prv_Integer, rm_Integer] :=
  If[rm < 1, prvprv, fibi[prv, prvprv + prv, rm - 1]]
fib[n_Integer] := fibi[0, 1, n]

However, the recursive approaches in Mathematica are limited by the limit set for recursion depth (default 1024 or 4096 for the above cases), limiting the range for 'n' to about 1000 or 2000. The following using an iterative approach has an extremely high limit (greater than a million):

fib[n_Integer] := Block[{tmp, prvprv = 0, prv = 1},
  For[i = 0, i < n, i++, tmp = prv; prv += prvprv; prvprv = tmp];
  Return[prvprv]]

If one wanted a list of Fibonacci numbers, the following is quite efficient:

fibi[{prvprv_Integer, prv_Integer}] := {prv, prvprv + prv}
fibList[n_Integer] := Map[Take[#, 1] &, NestList[fibi, {0, 1}, n]] // Flatten

Output from the last with "fibList[100]":

{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, \
1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, \
196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, \
9227465, 14930352, 24157817, 39088169, 63245986, 102334155, \
165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, \
2971215073, 4807526976, 7778742049, 12586269025, 20365011074, \
32951280099, 53316291173, 86267571272, 139583862445, 225851433717, \
365435296162, 591286729879, 956722026041, 1548008755920, \
2504730781961, 4052739537881, 6557470319842, 10610209857723, \
17167680177565, 27777890035288, 44945570212853, 72723460248141, \
117669030460994, 190392490709135, 308061521170129, 498454011879264, \
806515533049393, 1304969544928657, 2111485077978050, \
3416454622906707, 5527939700884757, 8944394323791464, \
14472334024676221, 23416728348467685, 37889062373143906, \
61305790721611591, 99194853094755497, 160500643816367088, \
259695496911122585, 420196140727489673, 679891637638612258, \
1100087778366101931, 1779979416004714189, 2880067194370816120, \
4660046610375530309, 7540113804746346429, 12200160415121876738, \
19740274219868223167, 31940434634990099905, 51680708854858323072, \
83621143489848422977, 135301852344706746049, 218922995834555169026, \
354224848179261915075}

The Wolfram Language can also solve recurrence equations using the built-in function RSolve

fib[n] /. RSolve[{fib[n] == fib[n - 1] + fib[n - 2], fib[0] == 0, 
    fib[1] == 1}, fib[n], n][[1]]

which evaluates to the built-in function Fibonacci[n]

This function can also be expressed as

Fibonacci[n] // FunctionExpand // FullSimplify

which evaluates to

(2^-n ((1 + Sqrt[5])^n - (-1 + Sqrt[5])^n Cos[n π]))/Sqrt[5]

and is defined for all real or complex values of n.

MATLAB

Matrix

Translation of: Julia

function f = fib(n)
	
	f = [1 1 ; 1 0]^(n-1);
	f = f(1,1);
	
end

Iterative

function F = fibonacci(n)
    
    Fn = [1 0]; %Fn(1) is F_{n-2}, Fn(2) is F_{n-1} 
    F = 0; %F is F_{n}
    
    for i = (1:abs(n))
        Fn(2) = F;
        F = sum(Fn);
        Fn(1) = Fn(2);
    end
        
    if n < 0
        F = F*((-1)^(n+1));
    end   

end

Dramadah Matrix Method

The MATLAB help file suggests an interesting method of generating the Fibonacci numbers. Apparently the determinate of the Dramadah Matrix of type 3 (MATLAB designation) and size n-by-n is the nth Fibonacci number. This method is implimented below.

function number = fibonacci2(n)
    
    if n == 1
        number = 1;
    elseif n == 0
        number = 0;
    elseif n < 0
        number = ((-1)^(n+1))*fibonacci2(-n);;
    else
        number = det(gallery('dramadah',n,3));
    end

end

Tartaglia/Pascal Triangle Method

function number = fibonacci(n)
%construct the Tartaglia/Pascal Triangle
    pt=tril(ones(n));
    for r = 3 : n
    % Every element is the addition of the two elements
    % on top of it. That means the previous row.
        for c = 2 : r-1
            pt(r, c) = pt(r-1, c-1) + pt(r-1, c);
        end   
    end
    number=trace(rot90(pt));
end

Maxima

/* fib(n) is built-in; here is an implementation */
fib2(n) := (matrix([0, 1], [1, 1])^^n)[1, 2]$

fib2(100)-fib(100);
0

fib2(-10);
-55

MAXScript

Iterative

fn fibIter n =
(
    if n < 2 then
    (
        n
    )
    else
    (
        fib = 1
        fibPrev = 1
        for num in 3 to n do
        (
            temp = fib
            fib += fibPrev
            fibPrev = temp
        )
        fib
    ) 
)

Recursive

fn fibRec n =
(
    if n < 2 then
    (
        n
    )
    else
    (
        fibRec (n - 1) + fibRec (n - 2)
    )
)

Mercury

Mercury is both a logic language and a functional language. As such there are two possible interfaces for calculating a Fibonacci number. This code shows both styles. Note that much of the code here is ceremony put in place to have this be something which can actually compile. The actual Fibonacci number generation is contained in the predicate fib/2 and in the function fib/1. The predicate main/2 illustrates first the unification semantics of the predicate form and the function call semantics of the function form.

The provided code uses a very naive form of generating a Fibonacci number. A more realistic implementation would use memoization to cache previous results, exchanging time for space. Also, in the case of supplying both a function implementation and a predicate implementation, one of the two would be implemented in terms of the other. Examples of this are given as comments below.

fib.m

% The following code is derived from the Mercury Tutorial by Ralph Becket.
% http://www.mercury.csse.unimelb.edu.au/information/papers/book.pdf
:- module fib.
 
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
 
:- implementation.
:- import_module int.
 
:- pred fib(int::in, int::out) is det.
fib(N, X) :-
    ( if N =< 2
          then X = 1
          else fib(N - 1, A), fib(N - 2, B), X = A + B ).
 
:- func fib(int) = int is det.
fib(N) = X :- fib(N, X).
 
main(!IO) :-
    fib(40, X),
    write_string("fib(40, ", !IO),
    write_int(X, !IO),
    write_string(")\n", !IO),
 
    write_string("fib(40) = ", !IO),
    write_int(fib(40), !IO),
    write_string("\n", !IO).

Iterative algorithm

The much faster iterative algorithm can be written as:

:- pred fib_acc(int::in, int::in, int::in, int::in, int::out) is det.

fib_acc(N, Limit, Prev2, Prev1, Res) :-
    ( N < Limit ->
        % limit not reached, continue computation.
        ( N =< 2 ->
            Res0 = 1
        ;
            Res0 = Prev2 + Prev1
        ),
        fib_acc(N+1, Limit, Prev1, Res0, Res)
    ;
        % Limit reached, return the sum of the two previous results.
        Res = Prev2 + Prev1
    ).

This predicate can be called as

fib_acc(1, 40, 1, 1, Result)

It has several inputs which form the loop, the first is the current number, the second is a limit, ie when to stop counting. And the next two are accumulators for the last and next-to-last results.

Memoization

But what if you want the speed of the fib_acc with the recursive (more declarative) definition of fib? Then use memoization, because Mercury is a pure language fib(N, F) will always give the same F for the same N, guaranteed. Therefore memoization asks the compiler to use a table to remember the value for F for any N, and it's a one line change:

:- pragma memo(fib/2).
:- pred fib(int::in, int::out) is det.
fib(N, X) :-
    ( if N =< 2
          then X = 1
          else fib(N - 1, A), fib(N - 2, B), X = A + B ).

We've shown the definition of fib/2 again, but the only change here is the memoization pragma (see the reference manual). This is not part of the language specification and different Mercury implementations are allowed to ignore it, however there is only one implementation so in practice memoization is fully supported.

Memoization trades speed for space, a table of results is constructed and kept in memory. So this version of fib consumes more memory than than fib_acc. It is also slightly slower than fib_acc since it must manage its table of results but it is much much faster than without memoization. Memoization works very well for the Fibonacci sequence because in the naive version the same results are calculated over and over again.

Metafont

vardef fibo(expr n) =
if n=0: 0
elseif n=1: 1
else:
  fibo(n-1) + fibo(n-2)
fi
enddef;

for i=0 upto 10: show fibo(i); endfor
end

min

Works with: min version 0.37.0

(
  (2 <)
  (pred (1 0 (over + swap)) dip times pop)
  unless
) ^fib

MiniScript

An efficient solution (for n >= 0):

fibonacci = function(n)
    if n < 2 then return n
    n1 = 0
    n2 = 1
    for i in range(n-1, 1)
        ans = n1 + n2
        n1 = n2
        n2 = ans
    end for
    return ans
end function

print fibonacci(6)

And for comparison, a recursive solution (also for n >= 0):

rfib = function(n)
    if n < 1 then return 0
    if n == 1 then return 1
    return rfib(n-1) + rfib(n-2)
end function

print rfib(6)

MiniZinc

function var int: fibonacci(int: n) =
  let {
    array[0..n] of var int: fibonacci;
    constraint forall(a in 0..n)(
      fibonacci[a] = if (a == 0 \/ a == 1) then
        a
      else
        fibonacci[a-1]+fibonacci[a-2]
      endif
    )
  } in fibonacci[n];
 
var int: fib = fibonacci(6);
solve satisfy;
output [show(fib),"\n"];

MIPS Assembly

This is the iterative approach to the Fibonacci sequence.

	.text
main:	li	$v0, 5		# read integer from input. The read integer will be stroed in $v0
	syscall
	
	beq	$v0, 0, is1
	beq	$v0, 1,	is1	
	
	li	$s4, 1		# the counter which has to equal to $v0	
		
	li	$s0, 1
	li	$s1, 1

loop:	add	$s2, $s0, $s1
	addi	$s4, $s4, 1
	beq	$v0, $s4, iss2
	
	add	$s0, $s1, $s2
	addi	$s4, $s4, 1
	beq	$v0, $s4, iss0
	
	add	$s1, $s2, $s0
	addi	$s4, $s4, 1
	beq	$v0, $s4, iss1

	b 	loop

iss0:	move	$a0, $s0	
	b	print

iss1:	move	$a0, $s1	
	b	print

iss2:	move	$a0, $s2	
	b	print
	
	
is1:	li	$a0, 1
	b 	print
	
print:	li	$v0, 1
	syscall
	li	$v0, 10
	syscall

Mirah

def fibonacci(n:int)
    return n if n < 2
    fibPrev = 1
    fib = 1
    3.upto(Math.abs(n)) do 
        oldFib = fib
        fib = fib + fibPrev
        fibPrev = oldFib
    end
    fib * (n<0 ? int(Math.pow(n+1, -1)) : 1)
end

puts fibonacci 1
puts fibonacci 2
puts fibonacci 3
puts fibonacci 4
puts fibonacci 5
puts fibonacci 6
puts fibonacci 7

МК-61/52

П0	1	lg	Вx	<->	+	L0	03	С/П	БП
03

Instruction: n В/О С/П, where n is serial number of the number of Fibonacci sequence; С/П for the following numbers.

ML

Standard ML

Tail Recursion

This version is tail recursive.

fun fib n = 
    let
	fun fib' (0,a,b) = a
	  | fib' (n,a,b) = fib' (n-1,a+b,a)
    in
	fib' (n,0,1)
    end

Recursion

fun fib n = if n < 2 then n else fib (n - 1) + fib (n - 2)

MLite

Recursion

Tail recursive.

fun fib 
        (0, x1, x2) = x2
      | (n, x1, x2) = fib (n-1, x2, x1+x2)
      | n = fib (n, 0, 1)

ML/I

MCSKIP "WITH" NL
"" Fibonacci - recursive
MCSKIP MT,<>
MCINS %.
MCDEF FIB WITHS ()
AS <MCSET T1=%A1.
MCGO L1 UNLESS 2 GR T1
%T1.<>MCGO L0
%L1.%FIB(%T1.-1)+FIB(%T1.-2).>
fib(0) is FIB(0)
fib(1) is FIB(1)
fib(2) is FIB(2)
fib(3) is FIB(3)
fib(4) is FIB(4)
fib(5) is FIB(5)

Modula-2

MODULE Fibonacci;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

PROCEDURE Fibonacci(n : LONGINT) : LONGINT;
VAR
    a,b,c : LONGINT;
BEGIN
    IF n<0 THEN RETURN 0 END;

    a:=1;
    b:=1;

    WHILE n>0 DO
        c := a + b;
        a := b;
        b := c;
        DEC(n)
    END;

    RETURN a
END Fibonacci;

VAR
    buf : ARRAY[0..63] OF CHAR;
    i : INTEGER;
    r : LONGINT;
BEGIN
    FOR i:=0 TO 10 DO
        r := Fibonacci(i);

        FormatString("%l\n", buf, r);
        WriteString(buf);
    END;

    ReadChar
END Fibonacci.

Modula-3

Recursive

PROCEDURE Fib(n: INTEGER): INTEGER =
  BEGIN
    IF n < 2 THEN
      RETURN n;
    ELSE
      RETURN Fib(n-1) + Fib(n-2);
    END;
  END Fib;

Iterative (with negatives)

PROCEDURE IterFib(n: INTEGER): INTEGER =

VAR

  limit := ABS(n);
  prev := 0;
  curr, next: INTEGER;

BEGIN

  (* trivial case *)
  IF n = 0 THEN RETURN 0; END;

  IF n > 0 THEN (* positive case *)

    curr := 1;
    FOR i := 2 TO limit DO
      next := prev + curr;
      prev := curr;
      curr := next;
    END;

  ELSE (* negative case *)

    curr := -1;
    FOR i := 2 TO limit DO
      next := prev - curr;
      prev := curr;
      curr := next;
    END;

  END;

  RETURN curr;

END IterFib;

Monicelli

Recursive version. It includes a main that reads a number N from standard input and prints the Nth Fibonacci number.

# Main
Lei ha clacsonato
voglio un nonnulla, Necchi mi porga un nonnulla
il nonnulla come se fosse brematurata la supercazzola bonaccia con il nonnulla o scherziamo?
un nonnulla a posterdati

# Fibonacci function 'bonaccia'
blinda la supercazzola Necchi bonaccia con antani Necchi o scherziamo? che cos'è l'antani? 
minore di 3: vaffanzum 1! o tarapia tapioco: voglio unchiamo, Necchi come se fosse brematurata 
la supercazzola bonaccia con antani meno 1 o scherziamo? voglio duechiamo, 
Necchi come se fosse brematurata la supercazzola bonaccia con antani meno 2 o scherziamo? vaffanzum 
unchiamo più duechiamo! e velocità di esecuzione

MontiLang

Reads number from standard input and prints to that number in the fibonacci sequence

0 VAR a .
1 VAR b .
INPUT TOINT
FOR :
    a b + VAR c .
    a PRINT .
    b VAR a .
    c VAR b .
ENDFOR

Forth-style solution

def over
    swap dup rot swap
enddef

|Enter a number to obtain Fibonacci sequence: | input nip var count .
0 1
FOR count
    over out |, | out . + swap
ENDFOR
. print
input
clear

Simpler

|Enter a number to obtain Fibonacci sequence: | input nip 1 - var count .
0 1
FOR count
    out |, | out . dup rot +
ENDFOR
print
input   /# wait until press ENTER #/
clear   /# empties the stack #/

MUMPS

Iterative

FIBOITER(N)
 ;Iterative version to get the Nth Fibonacci number
 ;N must be a positive integer
 ;F is the tree containing the values
 ;I is a loop variable.
 QUIT:(N\1'=N)!(N<0) "Error: "_N_" is not a positive integer."
 NEW F,I
 SET F(0)=0,F(1)=1
 QUIT:N<2 F(N)
 FOR I=2:1:N SET F(I)=F(I-1)+F(I-2)
 QUIT F(N)

USER>W $$FIBOITER^ROSETTA(30)
832040

Nanoquery

Iterative

def fibIter(n)
        if (n < 2)
                return n
        end if
 
        $fib = 1
        $fibPrev = 1
 
	for num in range(2, n - 1)
                fib += fibPrev
                fibPrev = fib - fibPrev
        end for
 
        return fib
end

Nemerle

Recursive

using System;
using System.Console;

module Fibonacci
{
    Fibonacci(x : long) : long
    {
        |x when x < 2 => x
        |_ => Fibonacci(x - 1) + Fibonacci(x - 2)
    }
    
    Main() : void
    {
        def num = Int64.Parse(ReadLine());
        foreach (n in $[0 .. num])
            WriteLine("{0}: {1}", n, Fibonacci(n));
    }
}

Tail Recursive

Fibonacci(x : long, current : long, next : long) : long
{
    match(x)
    {
        |0 => current
        |_ => Fibonacci(x - 1, next, current + next)
    }
}
  
Fibonacci(x : long) : long
{
    Fibonacci(x, 0, 1)
}

NESL

Recursive

function fib(n) = if n < 2 then n else fib(n - 2) + fib(n - 1);

NetRexx

Translation of: REXX

/* NetRexx */

options replace format comments java crossref savelog symbols

numeric digits 210000                  /*prepare for some big 'uns.     */
parse arg x y .                        /*allow a single number or range.*/
if x == '' then do                     /*no input? Then assume -30-->+30*/
  x = -30
  y = -x
  end

if y == '' then y = x             /*if only one number, show fib(n)*/
loop k = x to y                   /*process each Fibonacci request.*/
  q = fib(k)
  w = q.length                    /*if wider than 25 bytes, tell it*/
  say 'Fibonacci' k"="q
  if w > 25 then say 'Fibonacci' k "has a length of" w
  end k
exit

/*-------------------------------------FIB subroutine (non-recursive)---*/
method fib(arg) private static
  parse arg n
  na = n.abs

  if na < 2 then return na             /*handle special cases.          */
  a = 0
  b = 1

  loop j = 2 to na
    s = a + b
    a = b
    b = s
    end j

  if n > 0 | na // 2 == 1 then return  s /*if positive or odd negative... */
                          else return -s /*return a negative Fib number.  */

NewLISP

Iterative

(define (fibonacci n)
    (let (L '(0 1))
        (dotimes (i n)
            (setq L (list (L 1) (apply + L))))
        (L 1)) )

Recursive

(define (fibonacci n)
(if (< n 2) 1
    (+ (fibonacci (- n 1))  
       (fibonacci (- n 2)))))

Matrix multiplication

(define (fibonacci n)
  (letn (f '((0 1) (1 1)) fib f)
    (dotimes (i n)
        (set 'fib (multiply fib f)))
    (fib 0 1)) )

(print(fibonacci 10)) ;;89

With a stack

;;;	Global variable (bigints); can be isolated in a namespace if need be
(setq stack '(0L 1L))
;
;;;	If the stack is too short, complete it; then read from it
;;;	Adding at the end of a list is optimized in NewLisp
(define (fib n)
	(while (<= (length stack) n)
		(push (+ (stack -1) (stack -2)) stack -1))
	(stack n))
;
;;; Test (~ 7+ s on my mediocre laptop)
;(println (time (fib 50000)))
;;;	or
(println (length (fib 50000)))
;;;	outputs 10450 (digits)

NGS

Iterative

Translation of: Python

F fib(n:Int) {
	n < 2 returns n
	local a = 1, b = 1
	# i is automatically local because of for()
	for(i=2; i<n; i=i+1) {
		local next = a + b
		a = b
		b = next
	}
	b
}

Nial

Iterative

On my machine, about 1.7s for 100,000 iterations, n=92. Maybe a few percent faster than iterative Python. Note that n>92 produces overflow; Python keeps going - single iteration with n=1,000,000 takes it about 15s.

fibi is op n {
  if n<2 then 
    n
  else 
    x1:=0; x2:=1; 
    for i with tell (n - 1) do 
      x:=x1+x2;
      x1:=x2;
      x2:=x;
    endfor;
    x2
  endif};

Iterative using fold. Slightly faster, <1.6s:

fibf is op n {1 pick ((n- 1) fold [1 pick, +] 0 1)};

Tacit verion of above. Slightly faster still, <1.4s:

fibf2 is 1 pick fold [1 pick, +] reverse (0 1 hitch) (-1+);

Recursive

Really slow (over 8s for single iteration, n=33). (Similar to time for recursive python version with n=37.)

fibr is op n {fork [2>, +, + [fibr (-1 +), fibr (-2 +)]] n};

...or tacit version. More than twice as fast (?) but still slow:

fibr2 is fork [2>, +, + [fibr2 (-1 +), fibr2 (-2 +)]];

Matrix

Matrix inner product (ip). This appears to be the fastest, about 1.0s for 100,000 iterations, n=92: Note that n>92 produces negative result.

fibm is op n {floor (0 1 pick (reduce ip (n reshape [2 2 reshape 1 1 1 0])))};

Could it look a little more like J? (Maybe 5% slower than above.)

$ is reshape;
~ is tr f op a b {b f a}; % Goes before verb, rather than after like in J;
_ is floor; % Not really J, but J-ish? (Cannot redefine "<.".);

fibm2 is _(0 1 pick reduce ip([2 2$1 1 1 0](~$)));

Alternate, not involving replicating matrix n times, but maybe 50% slower than the fastest matrix version above - similar speed to iterative:

fibm3 is op n {a:=2 2$1 1 1 0; _(0 1 pick ((n- 1) fold (a ip) a))};

Nim

Analytic

proc Fibonacci(n: int): int64 =
  var fn = float64(n)
  var p: float64 = (1.0 + sqrt(5.0)) / 2.0
  var q: float64 = 1.0 / p
  return int64((pow(p, fn) + pow(q, fn)) / sqrt(5.0))

Iterative

proc Fibonacci(n: int): int =
  var
    first = 0
    second = 1

  for i in 0 .. <n:
    swap first, second
    second += first

  result = first

Recursive

proc Fibonacci(n: int): int64 =
  if n <= 2:
    result = 1
  else:
    result = Fibonacci(n - 1) + Fibonacci(n - 2)

Tail-recursive

proc Fibonacci(n: int, current: int64, next: int64): int64 =
  if n == 0:
    result = current
  else:
    result = Fibonacci(n - 1, next, current + next)
proc Fibonacci(n: int): int64 =
  result = Fibonacci(n, 0, 1)

Continuations

iterator fib: int {.closure.} =
  var a = 0
  var b = 1
  while true:
    yield a
    swap a, b
    b = a + b

var f = fib
for i in 0.. <10:
  echo f()

Nix

fibonacci = n:
    if n <= 1 then n else (fibonacci (n - 1) + fibonacci (n - 2));

Oberon-2

Works with: oo2c Version 2

MODULE Fibonacci;
IMPORT
  Out := NPCT:Console;

PROCEDURE Fibs(VAR r: ARRAY OF LONGREAL);
VAR
  i: LONGINT;
BEGIN
  r[0] := 1.0; r[1] := 1.0;
  FOR i := 2 TO LEN(r) - 1 DO
    r[i] := r[i - 2] + r[i - 1];
  END
END Fibs;

PROCEDURE FibsR(n: LONGREAL): LONGREAL;
BEGIN
  IF n < 2. THEN
    RETURN n
  ELSE
    RETURN FibsR(n - 1) + FibsR(n - 2)
  END
END FibsR;

PROCEDURE Show(r: ARRAY OF LONGREAL);
VAR
  i: LONGINT;
BEGIN
  Out.String("First ");Out.Int(LEN(r),0);Out.String(" Fibonacci numbers");Out.Ln;
  FOR i := 0 TO LEN(r) - 1 DO
    Out.LongRealFix(r[i],8,0)
  END;
  Out.Ln
END Show;

PROCEDURE Gen(s: LONGINT);
VAR
  x: POINTER TO ARRAY OF LONGREAL;
BEGIN
  NEW(x,s);
  Fibs(x^);
  Show(x^)  
END Gen;

PROCEDURE GenR(s: LONGINT);
VAR
  i: LONGINT;
BEGIN
  Out.String("First ");Out.Int(s,0);Out.String(" Fibonacci numbers (Recursive)");Out.Ln;
  FOR i := 1 TO s DO  
    Out.LongRealFix(FibsR(i),8,0)
  END;
  Out.Ln  
END GenR;

BEGIN 
  Gen(10);
  Gen(20);
  GenR(10);
  GenR(20);
END Fibonacci.

Output:

First 10 Fibonacci numbers
      1.      1.      2.      3.      5.      8.     13.     21.     34.     55.
First 20 Fibonacci numbers
      1.      1.      2.      3.      5.      8.     13.     21.     34.     55.     89.    144.    233.    377.    610.    987.   1597.   2584.   4181.   6765.
First 10 Fibonacci numbers (Recursive)
      1.      1.      2.      3.      5.      8.     13.     21.     34.     55.
First 20 Fibonacci numbers (Recursive)
      1.      1.      2.      3.      5.      8.     13.     21.     34.     55.     89.    144.    233.    377.    610.    987.   1597.   2584.   4181.   6765.

Objeck

Recursive

bundle Default {
  class Fib {
    function : Main(args : String[]), Nil {
      for(i := 0; i <= 10; i += 1;) {
        Fib(i)->PrintLine();
      };
    }
    
    function : native : Fib(n : Int), Int {
      if(n < 2) {
        return n;
      };
      
      return Fib(n-1) + Fib(n-2);
    }
  }
}

Objective-C

Recursive

-(long)fibonacci:(int)position
{
    long result = 0;
    if (position < 2) {
        result = position;
    } else {
        result = [self fibonacci:(position -1)] + [self fibonacci:(position -2)];
    }
    return result;    
}

Iterative

+(long)fibonacci:(int)index {
    long beforeLast = 0, last = 1;
    while (index > 0) {
        last += beforeLast;
        beforeLast = last - beforeLast;
        --index;
    }
    return last;
}

OCaml

Tail-Recursive (fast)

let fib n =
  let rec aux i a b =
    if i = 0 then a else aux (pred i) b (a + b)
  in
  aux n 0 1

Iterative

let fib_iter n =
  if n < 2 then
    n
  else let fib_prev = ref 1
  and fib = ref 1 in
    for num = 2 to n - 1 do
      let temp = !fib in
        fib := !fib + !fib_prev;
        fib_prev := temp
    done;
    !fib

Recursive

let rec fib_rec n =
  if n < 2 then
    n
  else
    fib_rec (n - 1) + fib_rec (n - 2)

let rec fib = function 
    0 -> 0
  | 1 -> 1
  | n -> if n > 0 then fib (n-1) + fib (n-2)
         else fib (n+2) - fib (n+1)

Arbitrary Precision

Using OCaml's Num module.

open Num

let fib =
  let rec fib_aux f0 f1 = function
    | 0 -> f0
    | 1 -> f1
    | n -> fib_aux f1 (f1 +/ f0) (n - 1)
  in
  fib_aux (num_of_int 0) (num_of_int 1)

(* support for negatives *)
let fib n = 
      if n < 0 && n mod 2 = 0 then minus_num (fib (abs n))  
      else fib (abs n)
;;
(* It can be called from the command line with an argument *)
(* Result is send to standart output *)
let n = int_of_string Sys.argv.(1) in 
print_endline (string_of_num (fib n))

compile with:

ocamlopt nums.cmxa -o fib fib.ml

Output:

$ ./fib 0
0
$ ./fib 10
55
$ ./fib 399
108788617463475645289761992289049744844995705477812699099751202749393926359816304226
$ ./fib -6
-8

O(log(n)) with arbitrary precision

This performs log2(N) matrix multiplys. Each multiplication is not constant-time but increases sub-linearly, about O(log(N)).

open Num

let mul (a,b,c) (d,e,f) = let bxe = b*/e in
  (a*/d +/ bxe, a*/e +/ b*/f, bxe +/ c*/f)

let id = (Int 1, Int 0, Int 1)
let rec pow a n =
  if n=0 then id else
    let b = pow a (n/2) in
    if (n mod 2) = 0 then mul b b else mul a (mul b b)

let fib n =
  let (_,y,_) = (pow (Int 1, Int 1, Int 0) n) in
  string_of_num y
;;
Printf.printf "fib %d = %s\n" 300 (fib 300)

Output:

fib 300 = 222232244629420445529739893461909967206666939096499764990979600

Matrix Exponentiation

open List
;;
let rec bin n =
  if n < 2 then [n mod 2 = 1]
  else bin (n/2) @ [n mod 2 = 1]
;;
let cut = function
  | [] -> [] 
  | _ :: x -> x
;;
let multiply a b =
  let ((p, q), (r, s)) = a in
  let ((t, u), (v, w)) = b in
  ((p*t+q*v, p*u+q*w), (r*t+s*v, r*u+s*w))
;;
let fib n =
  let rec f p q r =
    if length r = 1 then
      if nth r 0 then (multiply p q, q)
      else (p, q)
    else
      let (pp, qq) = f p q (cut r) in
      let qqq = multiply qq qq in
      if nth r 0 then (multiply pp qqq, qqq)
      else (pp, qqq) in
  f ((1L, 0L), (0L, 1L)) ((1L, 1L), (1L, 0L)) (bin n) |> fst |> fst |> snd
;;

Octave

Recursive

% recursive
function fibo = recfibo(n)
  if ( n < 2 )
    fibo = n;
  else
    fibo = recfibo(n-1) + recfibo(n-2);
  endif
endfunction

Testing

% testing
for i = 0 : 20
  printf("%d %d\n", i, recfibo(i));
endfor

Iterative

% iterative
function fibo = iterfibo(n)
  if ( n < 2 )
    fibo = n;
  else
    f = zeros(2,1);
    f(1) = 0; 
    f(2) = 1;
    for i = 2 : n
      t = f(2);
      f(2) = f(1) + f(2);
      f(1) = t;
    endfor
    fibo = f(2);
  endif
endfunction

Testing

% testing
for i = 0 : 20
  printf("%d %d\n", i, iterfibo(i));
endfor

Analytic

function retval = fibanalytic(n)
  retval = round(((5 .^ 0.5 + 1) / 2) .^ n / 5 .^ 0.5);
endfunction

Tail Recursive

function retval = fibtailrecursive(n, prevfib = 0, fib = 1)
  if (n == 0)
    retval = prevfib;
  else
    retval = fibtailrecursive(n - 1, fib, prevfib + fib);
  endif
endfunction

Odin

Fibinacci Sequence - Iterative Solution
Odin Build: dev-2023-07-nightly:3072479c

package fib
import "core:fmt"

main :: proc() {
	fmt.println("\nFibonacci Seq - starting n and n+1 from 0 and 1:")
	fmt.println("------------------------------------------------")
	for j: u128 = 0; j <= 20; j += 1 {
		fmt.println("n:", j, "\tFib:", fibi(j))
	}
}

fibi :: proc(n: u128) -> u128 {
    if n < 2 {
        return n
    }
    a, b: u128 = 0, 1
    for _ in 2..=n {
        a += b
        a, b = b, a
    }
    return b
}

Output:

First 20 Fibonacci Numbers
Starting n and n+1 from 0 and 1
-------------------------------
n: 0    Fib: 0
n: 1    Fib: 1
n: 2    Fib: 1
n: 3    Fib: 2
n: 4    Fib: 3
n: 5    Fib: 5
n: 6    Fib: 8
n: 7    Fib: 13
n: 8    Fib: 21
n: 9    Fib: 34
n: 10   Fib: 55
n: 11   Fib: 89
n: 12   Fib: 144
n: 13   Fib: 233
n: 14   Fib: 377
n: 15   Fib: 610
n: 16   Fib: 987
n: 17   Fib: 1597
n: 18   Fib: 2584
n: 19   Fib: 4181
n: 20   Fib: 6765
-------------------------------

Oforth

: fib   0 1 rot #[ tuck + ] times drop ;

Ol

Same as Scheme example(s).

Onyx (wasm)

use core.iter
use core { printf }

// Procedural Simple For-Loop Style
fib_for_loop :: (n: i32) -> i32 {
    a: i32 = 0;
    b: i32 = 1;
    for 0 .. n {
        tmp := a;
        a = b;
        b = tmp + b;
    }
    return a;
}

FibState :: struct { a, b: u64 }

// Functional Folding Style
fib_by_fold :: (n: i32) => {
    end_state := 
        iter.counter()
        |> iter.take(n)
        |> iter.fold(
            FibState.{ a = 0, b = 1 },
            (_, state) => FibState.{
                a = state.b,
                b = state.a + state.b
            }
        );
    return end_state.a;
}

// Custom Iterator Style
fib_iterator :: (n: i32) => 
    iter.generator(
        &.{ a = cast(u64) 0, b = cast(u64) 1, counter = n },
        (state: & $Ctx) -> (u64, bool) {
            if state.counter <= 0 {
                return 0, false;
            }
            tmp := state.a;
            state.a = state.b;
            state.b = state.b + tmp;
            state.counter -= 1;
            return tmp, true;
        }
    );

main :: () {
    printf("\nBy For Loop:\n");
    for i in 0 .. 21 {
        printf("{} ", fib_for_loop(i));
    }

    printf("\n\nBy Iterator:\n");
    for i in 0 .. 21 {
        printf("{} ", fib_by_fold(i));
    }

    printf("\n\nBy Fold:\n");
    for value, index in fib_iterator(21) {
        printf("{} ", value);
    }
}

Output:

For-Loop:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

Functional Fold:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

Custom Iterator:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

OPL

FIBON:
REM Fibonacci sequence is generated to the Organiser II floating point variable limit.
REM CLEAR/ON key quits.
REM Mikesan - http://forum.psion2.org/
LOCAL A,B,C
A=1 :B=1 :C=1
PRINT A,
DO
  C=A+B
  A=B
  B=C
  PRINT A,
UNTIL GET=1

Order

Recursive

#include <order/interpreter.h>

#define ORDER_PP_DEF_8fib_rec                     \
ORDER_PP_FN(8fn(8N,                               \
                8if(8less(8N, 2),                 \
                    8N,                           \
                    8add(8fib_rec(8sub(8N, 1)),   \
                         8fib_rec(8sub(8N, 2))))))

ORDER_PP(8fib_rec(10))

Tail recursive version (example supplied with language):

#include <order/interpreter.h>
 
#define ORDER_PP_DEF_8fib                                         \
ORDER_PP_FN(8fn(8N,                                               \
                8fib_iter(8N, 0, 1)))
 
#define ORDER_PP_DEF_8fib_iter                                    \
ORDER_PP_FN(8fn(8N, 8I, 8J,                                       \
                8if(8is_0(8N),                                    \
                    8I,                                           \
                    8fib_iter(8dec(8N), 8J, 8add(8I, 8J)))))
 
ORDER_PP(8to_lit(8fib(8nat(5,0,0))))

Memoization

#include <order/interpreter.h>

#define ORDER_PP_DEF_8fib_memo                                    \
ORDER_PP_FN(8fn(8N,                                               \
                8tuple_at(0, 8fib_memo_inner(8N, 8seq))))
                

#define ORDER_PP_DEF_8fib_memo_inner                                            \
ORDER_PP_FN(8fn(8N, 8M,                                                         \
                8cond((8less(8N, 8seq_size(8M)), 8pair(8seq_at(8N, 8M), 8M))    \
                      (8equal(8N, 0), 8pair(0, 8seq(0)))                        \
                      (8equal(8N, 1), 8pair(1, 8seq(0, 1)))                     \
                      (8else,                                                   \
                        8lets((8S, 8fib_memo_inner(8sub(8N, 2), 8M))            \
                              (8T, 8fib_memo_inner(8dec(8N), 8tuple_at(1, 8S))) \
                              (8U, 8add(8tuple_at(0, 8S), 8tuple_at(0, 8T))),   \
                              8pair(8U,                                         \
                                    8seq_append(8tuple_at(1, 8T), 8seq(8U))))))))
                    

ORDER_PP(
8for_each_in_range(8fn(8N,
                       8print(8to_lit(8fib_memo(8N)) (,) 8space)),
                   1, 21)
)

Oz

Iterative

Using mutable references (cells).

fun{FibI N}
  Temp = {NewCell 0}
  A = {NewCell 0}
  B = {NewCell 1}
in    
  for I in 1..N do
    Temp := @A + @B
    A := @B
    B := @Temp
  end
  @A
end

Recursive

Inefficient (blows up the stack).

fun{FibR N}
  if N < 2 then N
  else {FibR N-1} + {FibR N-2}
  end
end

Tail-recursive

Using accumulators.

fun{Fib N}
   fun{Loop N A B}
      if N == 0 then
	 B
      else
	 {Loop N-1 A+B A}
      end
   end
in    
   {Loop N 1 0}
end

Lazy-recursive

declare
  fun lazy {FiboSeq}
     {LazyMap
      {Iterate fun {$ [A B]} [B A+B] end [0 1]}
      Head}
  end

  fun {Head A|_} A end

  fun lazy {Iterate F I}
     I|{Iterate F {F I}}
  end

  fun lazy {LazyMap Xs F}
     case Xs of X|Xr then {F X}|{LazyMap Xr F}
     [] nil then nil
     end
  end
in
  {Show {List.take {FiboSeq} 8}}

PARI/GP

Built-in

fibonacci(n)

Matrix

fib(n)=([1,1;1,0]^n)[1,2]

Analytic

This uses the Binet form.

fib(n)=my(phi=(1+sqrt(5))/2);round((phi^n-phi^-n)/sqrt(5))

The second term can be dropped since the error is always small enough to be subsumed by the rounding.

fib(n)=round(((1+sqrt(5))/2)^n/sqrt(5))

Algebraic

This is an exact version of the above formula. quadgen(5) represents $\phi$ and the number is stored in the form $a+b\phi$ . imag takes the coefficient of $\phi$ . This uses the relation

\phi ^{n}=F_{n-1}+F_{n}\phi

and hence real(quadgen(5)^n) would give the (n-1)-th Fibonacci number.

fib(n)=imag(quadgen(5)^n)

A more direct translation (note that ${\sqrt {5}}=2\phi -1$ ) would be

fib(n)=my(phi=quadgen(5));(phi^n-(-1/phi)^n)/(2*phi-1)

Combinatorial

This uses the generating function. It can be trivially adapted to give the first n Fibonacci numbers.

fib(n)=polcoeff(x/(1-x-x^2)+O(x^(n+1)),n)

Binary powering

fib(n)={
  if(n<=0,
    if(n,(-1)^(n+1)*fib(n),0)
  ,
    my(v=lucas(n-1));
    (2*v[1]+v[2])/5
  )
};
lucas(n)={
  if (!n, return([2,1]));
  my(v=lucas(n >> 1), z=v[1], t=v[2], pr=v[1]*v[2]);
  n=n%4;
  if(n%2,
    if(n==3,[v[1]*v[2]+1,v[2]^2-2],[v[1]*v[2]-1,v[2]^2+2])
  ,
    if(n,[v[1]^2+2,v[1]*v[2]+1],[v[1]^2-2,v[1]*v[2]-1])
  )
};

Recursive

fib(n)={
  if(n<2,
    n
  ,
    fib(n-1)+fib(n)
  )
};

Anonymous recursion

Works with: PARI/GP version 2.8.0+

This uses self() which gives a self-reference.

fib(n)={
  if(n<2,
    n
  ,
    my(s=self());
    s(n-2)+s(n-1)
  )
};

It can be used without being named:

apply(n->if(n<2,n,my(s=self());s(n-2)+s(n-1)), [1..10])

gives

Output:

%1 = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Memoization

F=[];
fib(n)={
  if(n>#F,
    F=concat(F, vector(n-#F));
    F[n]=fib(n-1)+fib(n-2)
  ,
    if(n<2,
      n
    ,
      if(F[n],F[n],F[n]=fib(n-1)+fib(n-2))
    )
  );
}

Iterative

fib(n)={
  if(n<0,return((-1)^(n+1)*fib(n)));
  my(a=0,b=1,t);
  while(n,
    t=a+b;
    a=b;
    b=t;
    n--
  );
  a
};

Chebyshev

This solution uses Chebyshev polynomials of the second kind (Chyebyshev U-polynomials).

fib(n)=n--;polchebyshev(n,2,I/2)*I^n;

or

fib(n)=abs(polchebyshev(n-1,2,I/2));

Anti-Hadamard matrix

All n×n (0,1) lower Hessenberg matrices have determinant at most F(n). The n×n anti-Hadamard matrix^[1] matches this upper bound, and hence can be used as an inefficient method for computing Fibonacci numbers of positive index. These matrices are the same as Matlab's type-3 "Dramadah" matrices, following a naming suggestion of C. L. Mallows according to Graham & Sloane.

matantihadamard(n)={
  matrix(n,n,i,j,
    my(t=j-i+1);
    if(t<1,t%2,t<3)
  );
}
fib(n)=matdet(matantihadamard(n))

Testing adjacent bits

The Fibonacci numbers can be characterized (for n > 0) as the number of n-bit strings starting and ending with 1 without adjacent 0s. This inefficient, exponential-time algorithm demonstrates:

fib(n)=
{
  my(g=2^(n+1)-1);
  sum(i=2^(n-1),2^n-1,
    bitor(i,i<<1)==g
  );
}

One-by-one

This code is purely for amusement and requires n > 1. It tests numbers in order to see if they are Fibonacci numbers, and waits until it has seen n of them.

fib(n)=my(k=0);while(n--,k++;while(!issquare(5*k^2+4)&&!issquare(5*k^2-4),k++));k

ParaCL

fibbonachi = func(x) : fibb
{
  res = 1;
  if (x > 1)
    res = fibb(x - 1) + fibb(x - 2);
  res;
}

Pascal

Analytic

function fib(n: integer):longInt;
const
  Sqrt5 = sqrt(5.0);
  C1 = ln((Sqrt5+1.0)*0.5);//ln( 1.618..)
//C2 = ln((1.0-Sqrt5)*0.5);//ln(-0.618 )) tsetsetse
  C2 = ln((Sqrt5-1.0)*0.5);//ln(+0.618 ))
begin
  IF n>0 then
  begin
    IF odd(n) then
      fib := round((exp(C1*n) + exp(C2*n) )/Sqrt5)
    else
      fib := round((exp(C1*n) - exp(C2*n) )/Sqrt5)
  end
  else
    Fibdirekt := 0
end;

Recursive

function fib(n: integer): integer;
 begin
  if (n = 0) or (n = 1)
   then
    fib := n
   else
    fib := fib(n-1) + fib(n-2)
 end;

Iterative

function fib(n: integer): integer;
var
  f0, f1, tmpf0, k: integer;
begin
  f1 := n;
  IF f1 >1 then
  begin
    k := f1-1;
    f0 := 0;
    f1 := 1;
    repeat
      tmpf0 := f0;
      f0 := f1;
      f1 := f1+tmpf0;
      dec(k);
    until k = 0;
  end
  else
    IF f1 < 0 then
      f1 := 0;
  fib := f1;
end;

Analytic2

function FiboMax(n: integer):Extended;  //maXbox
begin
   result:= (pow((1+SQRT5)/2,n)-pow((1-SQRT5)/2,n))/SQRT5   
end;

function Fibo_BigInt(n: integer): string;  //maXbox
  var tbig1, tbig2, tbig3: TInteger;
  begin 
    result:= '0'
    tbig1:= TInteger.create(1);  //temp
    tbig2:= TInteger.create(0);  //result (a)
    tbig3:= Tinteger.create(1);  //b
    for it:= 1 to n do begin
    	tbig1.assign(tbig2)
	   tbig2.assign(tbig3);
	   tbig1.add(tbig3);
	   tbig3.assign(tbig1);
	 end; 
    result:= tbig2.toString(false)
    tbig3.free;
    tbig2.free;
    tbig1.free; 
  end;

writeln(floattoStr(FiboMax(555))) >>>4.3516638122555E115

writeln(Fibo_BigInt(555)) >>>43516638122555047989641805373140394725407202037260729735885664398655775748034950972577909265605502785297675867877570

Doubling (iterative)

The Clojure solution gives a recursive version of the Fibonacci doubling algorithm. The code below is an iterative version, written in Free Pascal. The unsigned 64-bit integer type can hold Fibonacci numbers up to F[93].

program Fibonacci_console;

{$mode objfpc}{$H+}

uses SysUtils;

function Fibonacci( n : word) : uint64;
{
Starts with the pair F[0],F[1]. At each iteration, uses the doubling formulae
to pass from F[k],F[k+1] to F[2k],F[2k+1]. If the current bit of n (starting
from the high end) is 1, there is a further step to F[2k+1],F[2k+2].
}
var
  marker, half_n : word;
  f, g : uint64; // pair of consecutive Fibonacci numbers
  t, u : uint64; // -----"-----
begin
  // The values of F[0], F[1], F[2]  are assumed to be known
  case n of
    0 : result := 0;
    1, 2 : result := 1;
    else begin
      half_n := n shr 1;
      marker := 1;
      while marker <= half_n do marker := marker shl 1;

      // First time: current bit is 1 by construction,
      //   so go straight from F[0],F[1] to F[1],F[2].
      f := 1; // = F[1]
      g := 1; // = F[2]
      marker := marker shr 1;

      while marker > 1 do begin
        t := f*(2*g - f);
        u := f*f + g*g;
        if (n and marker = 0) then begin
          f := t;
          g := u;
        end
        else begin
          f := u;
          g := t + u;
        end;
        marker := marker shr 1;
      end;

      // Last time: we need only one of the pair.
      if (n and marker = 0) then
        result := f*(2*g - f)
      else
        result := f*f + g*g;
    end; // end else (i.e. n > 2)
  end; // end case
end;

// Main program
var
  n : word;
begin
  for n := 0 to 93 do
    WriteLn( SysUtils.Format( 'F[%2u] = %20u', [n, Fibonacci(n)]));
end.

Output:

F[ 0] =                    0
F[ 1] =                    1
F[ 2] =                    1
F[ 3] =                    2
F[ 4] =                    3
F[ 5] =                    5
F[ 6] =                    8
F[ 7] =                   13
[...]
F[90] =  2880067194370816120
F[91] =  4660046610375530309
F[92] =  7540113804746346429
F[93] = 12200160415121876738

PascalABC.NET

Uses functionality from Fibonacci n-step number sequences#PascalABC.NET

// Fibonacci sequence. Nigel Galloway: August 30th., 2022
begin
  unfold(nFib,0bi,1bi).ElementAt(1000).Println;
end.

43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875

Perl

Iterative

sub fib_iter {
  my $n = shift;
  use bigint try => "GMP,Pari";
  my ($v2,$v1) = (-1,1);
  ($v2,$v1) = ($v1,$v2+$v1) for 0..$n;
  $v1;
}

Recursive

sub fibRec {
    my $n = shift;
    $n < 2 ? $n : fibRec($n - 1) + fibRec($n - 2);
}

Modules

Quite a few modules have ways to do this. Performance is not typically an issue with any of these until 100k or so. With GMP available, the first three are much faster at large values.

# Uses GMP method so very fast
use Math::AnyNum qw/fibonacci/;
say fibonacci(10000);

# Uses GMP method, so also very fast
use Math::GMP;
say Math::GMP::fibonacci(10000);

# Binary ladder, GMP if available, Pure Perl otherwise
use ntheory qw/lucasu/;
say lucasu(1, -1, 10000);

# All Perl
use Math::NumSeq::Fibonacci;
my $seq = Math::NumSeq::Fibonacci->new;
say $seq->ith(10000);

# All Perl
use Math::Big qw/fibonacci/;
say 0+fibonacci(10000);  # Force scalar context

# Perl, gives floating point *approximation*
use Math::Fibonacci qw/term/;
say term(10000);

Array accumulation

This solution accumulates all Fibonacci numbers up to n into an array of n+1 elements (to account for the zeroth Fibonacci number). When the loop reaches n, the function returns the last element of the array, i.e. the n-th Fibonacci number. This function only works for positive integers, but it can be easily extended into negatives.

Note that, without the use of big integer libraries, pure Perl switches to floats in scientific notation above n=93 and treats any number as infinite above n=1476 (see output). This behaviour could vary across Perl implementations.

sub fibonacci {
    my $n = shift;    
    
    return 0 if $n <  1;
    return 1 if $n == 1;
        
    my @numbers = (0, 1);

    push @numbers, $numbers[-1] + $numbers[-2] foreach 2 .. $n;
    
    return $numbers[-1];
}

print "Fibonacci($_) -> ", (fibonacci $_), "\n"
    foreach (0 .. 20, 50, 93, 94, 100, 200, 1000, 1476, 1477);

Output:

Fibonacci(0) -> 0
Fibonacci(1) -> 1
Fibonacci(2) -> 1
Fibonacci(3) -> 2
Fibonacci(4) -> 3
Fibonacci(5) -> 5
Fibonacci(6) -> 8
Fibonacci(7) -> 13
Fibonacci(8) -> 21
Fibonacci(9) -> 34
Fibonacci(10) -> 55
Fibonacci(11) -> 89
Fibonacci(12) -> 144
Fibonacci(13) -> 233
Fibonacci(14) -> 377
Fibonacci(15) -> 610
Fibonacci(16) -> 987
Fibonacci(17) -> 1597
Fibonacci(18) -> 2584
Fibonacci(19) -> 4181
Fibonacci(20) -> 6765
Fibonacci(50) -> 12586269025
Fibonacci(93) -> 12200160415121876738
Fibonacci(94) -> 1.97402742198682e+19
Fibonacci(100) -> 3.54224848179262e+20
Fibonacci(200) -> 2.8057117299251e+41
Fibonacci(1000) -> 4.34665576869374e+208
Fibonacci(1476) -> 1.3069892237634e+308
Fibonacci(1477) -> Inf

Phix

function fibonacci(integer n)     -- iterative, works for -ve numbers
atom a=0, b=1
    if n=0 then return 0 end if
    if abs(n)>=79 then ?9/0 end if  -- inaccuracies creep in above 78
    for i=1 to abs(n)-1 do
        {a,b} = {b,a+b}
    end for
    if n<0 and remainder(n,2)=0 then return -b end if
    return b
end function
 
for i=0 to 28 do
    if i then puts(1,", ") end if
    printf(1,"%d", fibonacci(i))
end for
puts(1,"\n")

Output:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811

Using native integers/atoms, errors creep in above 78, so the same program converted to use mpfr:

Library: Phix/mpfr

-- demo\rosetta\fibonacci.exw
with javascript_semantics
include mpfr.e

mpz res = NULL, prev, next
integer lastn
atom t0 = time()
function fibonampz(integer n) -- resumable, works for -ve numbers, yields mpz
    integer absn = abs(n)
    if res=NULL or absn!=abs(lastn)+1 then
        if res=NULL then
            prev = mpz_init(0)
            res = mpz_init(1)
            next = mpz_init()
        else
            if n==lastn then return res end if
        end if
        mpz_fib2_ui(res,prev,absn)
    else
        if lastn<0 and remainder(lastn,2)=0 then
            mpz_mul_si(res,res,-1)
        end if
        mpz_add(next,res,prev)
        {prev,res,next} = {res,next,prev}
    end if
    if n<0 and remainder(n,2)=0 then
        mpz_mul_si(res,res,-1)
    end if
    lastn = n
    return res
end function

for i=0 to 28 do
    if i then puts(1,", ") end if
    printf(1,"%s", {mpz_get_str(fibonampz(i))})
end for
puts(1,"\n")
printf(1,"%s\n", {mpz_get_str(fibonampz(705))})

-- not surprisingly JavaScript BigInt takes a bit
-- longer for 0.1M digits that gmp does for 1.0M:
integer big = iff(platform()==JS?478495:4784969)
string s = mpz_get_str(fibonampz(big))
?shorten(s)
?elapsed(time()-t0)

Output:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811
970066202977562212558683426760773016559904631977220423547980211057068777324159443678590358026859129109599109446646966713225742014317926940054191330
{1000000,"107273956418004772293648135962250043219...407167474856539211500699706378405156269"}
"2.1s"

Phixmonti

def Fibonacci
    dup 0 < if
        "Invalid argument: " print
    else 
        1 1 rot 2 -
        for
            drop
            over over +
        endfor
    endif
enddef

10 Fibonacci pstack print nl
-10 Fibonacci print

PHP

Iterative

function fibIter($n) {
    if ($n < 2) {
        return $n;
    }
    $fibPrev = 0;
    $fib = 1;
    foreach (range(1, $n-1) as $i) {
        list($fibPrev, $fib) = array($fib, $fib + $fibPrev);
    }
    return $fib;
}

Recursive

function fibRec($n) {
    return $n < 2 ? $n : fibRec($n-1) + fibRec($n-2);
}

Picat

Function

tabling for speed.

go =>
  println([fib_fun(I) : I in 1..10]),
  F1=fib_fun(2**10),
  println(f1=F1),
  nl.

table
fib_fun(0) = 0.
fib_fun(1) = 1.
fib_fun(N) = fib_fun(N-1) + fib_fun(N-2).

Output:

[1,1,2,3,5,8,13,21,34,55]
f1 = 4506699633677819813104383235728886049367860596218604830803023149600030645708721396248792609141030396244873266580345011219530209367425581019871067646094200262285202346655868899711089246778413354004103631553925405243

Array

fib_array(0,[0]).
fib_array(1,[0,1]).
fib_array(N,A) :-
   N > 1,
   A = new_array(N),
   A[1] = 1,
   A[2] = 1,
   foreach(I in 3..N)
     A[I] = A[I-1] + A[I-2]
   end.

Loop

fib_loop(N) = Curr =>
  Curr = 0,
  Prev = 1,
  foreach(_I in 1..N)
    Tmp = Curr,
    Curr := Curr + Prev,
    Prev := Tmp
  end.

Formula

Translation of: Tcl

Works for n <= 70.

fib_formula(N) = round((0.5 + 0.5*sqrt(5))**N / sqrt(5)).

"Lazy lists"

Translation of: Prolog

go =>fib_lazy(X),
  A = new_list(15),
  append(A,_,X),
  println(A),

fib_lazy([0,1|X]) :-
    ffib(0,1,X).
ffib(A,B,X) :-
    freeze(X, (C is A+B, X=[C|Y], ffib(B,C,Y)) ).

Output:

[0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]

Generators idiom

Translation of: Prolog

go =>
  take(15, $fib_gen(0,1), $T-[], _G),
  println(T).

take( 0, Next, Z-Z, Next).
take( N, Next, [A|B]-Z, NZ):- N>0, !, next( Next, A, Next1),
  N1 is N-1,
  take( N1, Next1, $B-Z, NZ).
 
next( fib_gen(A,B), A, fib_gen(B,C)):- C is A+B.

Output:

[0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]

Reversible

This is a reversible variant using constraint modelling.

fib_rev(N,F) has these two usages:

find F given a value N (this is the normal usage)
find N given a value F (backward usage)

Note: In general, Picat supports arbitrary precision for integers. However, the constraint solvers only supports integer domains of -2**56..2**56 so the largest Fibonacci number that can be found by this predicate is N = 81.

import cp.

go =>
  N1 = 30,
  fib_rev(30,F1),
  println([n1=N1,fib1=F1]),
  
  F2 #= 20365011074,
  fib_rev(N2,F2),
  println([n2=N2,f2=F2]),
  
  F3 = 61305790721611591,
  fib_rev(N3,F3),
  println([n3=N3,F3]),
  nl.

table
fib_rev(0,1).
fib_rev(1,1).
fib_rev(N,F) :-
  N #> 0,
  F #> 0,
  N1 #= N-1, 
  N2 #= N-2,
  fib_rev(N1,F1), 
  fib_rev(N2,F2),  
  F #= F1+F2.

Output:

[n1 = 30,fib1 = 1346269]
[n2 = 50,f2 = 20365011074]
[n3 = 81,61305790721611591]

PicoLisp

Recursive

(de fibo (N)
   (if (>= 2 N)
      1
      (+ (fibo (dec N)) (fibo (- N 2))) ) )

Recursive with Cache

Using a recursive version doesn't need to be slow, as the following shows:

(de fibo (N)
   (cache '(NIL) N  # Use a cache to accelerate
      (if (>= 2 N)
         N
         (+ (fibo (dec N)) (fibo (- N 2))) ) ) )

(bench (fibo 1000))

Output:

0.012 sec
-> 43466557686937456435688527675040625802564660517371780402481729089536555417949
05189040387984007925516929592259308032263477520968962323987332247116164299644090
6533187938298969649928516003704476137795166849228875

Iterative

(de fib (N)
   (let (A 0  B 1)
      (do N
         (prog1 B (setq B (+ A B) A @)) ) ) )

Coroutines

(co 'fibo
   (let (A 0  B 1)
      (yield 'ready)
      (while
         (yield
            (swap 'B (+ (swap 'A B) B)) ) ) ) )

(do 15
   (printsp (yield 'next 'fibo)) )
(prinl)
(yield NIL 'fibo)

Output:

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610

Pike

Iterative

int     
fibIter(int n) {
    int fibPrev, fib, i;
    if (n < 2) {
        return 1;
    }
    fibPrev = 0;
    fib = 1;
    for (i = 1; i < n; i++) {
        int oldFib = fib;
        fib += fibPrev;
        fibPrev = oldFib;
    }
    return fib;
}

Recursive

int 
fibRec(int n) {
    if (n < 2) {
        return(1);
    }
    return( fib(n-2) + fib(n-1) );
}

PIR

Recursive:

Works with: Parrot version tested with 2.4.0

.sub fib
  .param int n
  .local int nt
  .local int ft
  if n < 2 goto RETURNN
  nt = n - 1
  ft = fib( nt )
  dec nt
  nt = fib(nt)
  ft = ft + nt
  .return( ft )
RETURNN:
  .return( n )
  end
.end

.sub main :main
  .local int counter
  .local int f
  counter=0
LOOP: 
  if counter > 20 goto DONE
  f = fib(counter)
  print f
  print "\n"
  inc counter
  goto LOOP
DONE:
  end
.end

Iterative (stack-based):

Works with: Parrot version tested with 2.4.0

.sub fib
  .param int n
  .local int counter
  .local int f
  .local pmc fibs
  .local int nmo
  .local int nmt

  fibs = new 'ResizableIntegerArray'
  if n == 0 goto RETURN0
  if n == 1 goto RETURN1
  push fibs, 0
  push fibs, 1
  counter = 2
FIBLOOP:
  if counter > n goto DONE
  nmo = pop fibs
  nmt = pop fibs
  f = nmo + nmt
  push fibs, nmt
  push fibs, nmo
  push fibs, f
  inc counter
  goto FIBLOOP
RETURN0:
  .return( 0 )
  end
RETURN1:
  .return( 1 )
  end
DONE:
  f = pop fibs
  .return( f )
  end
.end

.sub main :main
  .local int counter
  .local int f
  counter=0
LOOP: 
  if counter > 20 goto DONE
  f = fib(counter)
  print f
  print "\n"
  inc counter
  goto LOOP
DONE:
  end
.end

PL/0

The program waits for n. Then it displays n^th Fibonacci number.

var n, a, b, i, tmp;
begin
  ? n;
  a := 0; b := 1;
  i := 2;
  while i <= n do
  begin
    tmp := b; b := a + b; a := tmp;
    i := i + 1
  end;
  ! b
end.

4 runs.

Input:

Output:

Input:

Output:

Input:

Output:

Input:

Output:

PL/I

/* Form the n-th Fibonacci number, n > 1.    12 March 2022 */
Fib: procedure (n) returns (fixed binary (31));
   declare (i, n, f1, f2, f3) fixed binary (31);

   f1 = 0; f2 = 1;
   do i = 1 to n-2;
      f3 = f1 + f2;
      f1 = f2;
      f2 = f3;
   end;
   return (f3);

end Fib;

PL/M

100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;

PRINT$NUMBER: PROCEDURE (N);
    DECLARE S (6) BYTE INITIAL ('.....$');
    DECLARE (N, P) ADDRESS, C BASED P BYTE;
    P = .S(5);
DIGIT:
    P = P - 1;
    C = N MOD 10 + '0';
    N = N / 10;
    IF N > 0 THEN GO TO DIGIT;
    CALL PRINT(P);
END PRINT$NUMBER;

FIBONACCI: PROCEDURE (N) ADDRESS;
    DECLARE (N, A, B, C, I) ADDRESS;
    IF N<=1 THEN RETURN N;
    A = 0;
    B = 1;
    DO I=2 TO N;
        C = A;
        A = B;
        B = A + C;
    END;
    RETURN B;
END FIBONACCI;

DECLARE I ADDRESS;
DO I=0 TO 20;
    CALL PRINT$NUMBER(FIBONACCI(I));
    CALL PRINT(.' $');
END;
CALL EXIT;
EOF

Output:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

PL/pgSQL

Recursive

CREATE OR REPLACE FUNCTION fib(n INTEGER) RETURNS INTEGER AS $$
BEGIN
  IF (n < 2) THEN
    RETURN n;
  END IF;
  RETURN fib(n - 1) + fib(n - 2);
END;
$$ LANGUAGE plpgsql;

Calculated

CREATE OR REPLACE FUNCTION fibFormula(n INTEGER) RETURNS INTEGER AS $$
BEGIN
  RETURN round(pow((pow(5, .5) + 1) / 2, n) / pow(5, .5));
END;
$$ LANGUAGE plpgsql;

Linear

CREATE OR REPLACE FUNCTION fibLinear(n INTEGER) RETURNS INTEGER AS $$
DECLARE
  prevFib INTEGER := 0;
  fib INTEGER := 1;
BEGIN
  IF (n < 2) THEN
    RETURN n;
  END IF;

  WHILE n > 1 LOOP
    SELECT fib, prevFib + fib INTO prevFib, fib;
    n := n - 1;
  END LOOP;

  RETURN fib;
END;
$$ LANGUAGE plpgsql;

Tail recursive

CREATE OR REPLACE FUNCTION fibTailRecursive(n INTEGER, prevFib INTEGER DEFAULT 0, fib INTEGER DEFAULT 1)
RETURNS INTEGER AS $$
BEGIN
  IF (n = 0) THEN
    RETURN prevFib;
  END IF;
  RETURN fibTailRecursive(n - 1, fib, prevFib + fib);
END;
$$ LANGUAGE plpgsql;

PL/SQL

create or replace function fnu_fibonacci(p_num integer) return integer is
  f integer;
  p integer;
  q integer;
begin
  case when p_num < 0 or p_num != trunc(p_num) 
                            then raise_application_error(-20001, 'Invalid input: ' || p_num, true);
       when p_num in (0, 1) then f := p_num;
       else
            p := 0;
            q := 1;
            for i in 2 .. p_num loop
              f := p + q;
              p := q;
              q := f;
            end loop;
  end case;
  return(f);
end fnu_fibonacci;
/

Plain English

To find a fibonacci number given a count:
Put 0 into a number.
Put 1 into another number.
Loop.
If a counter is past the count, put the number into the fibonacci number; exit.
Add the number to the other number.
Swap the number with the other number.
Repeat.

Pop11

define fib(x);
lvars a , b;
    1 -> a;
    1 -> b;
    repeat x - 1 times
         (a + b, b) -> (b, a);
    endrepeat;
    a;
enddefine;

PostScript

Enter the desired number for "n" and run through your favorite postscript previewer or send to your postscript printer:

%!PS

% We want the 'n'th fibonacci number
/n 13 def

% Prepare output canvas:
/Helvetica findfont 20 scalefont setfont
100 100 moveto

%define the function recursively:
/fib { dup 
       3 lt
         { pop 1 }
         { dup 1 sub fib exch 2 sub fib add }
       ifelse
    } def
    
    (Fib\() show n (....) cvs show (\)=) show n fib (.....) cvs show

showpage

Potion

Recursive

Starts with int and upgrades on-the-fly to doubles.

recursive = (n):
  if (n <= 1): 1. else: recursive (n - 1) + recursive (n - 2)..

n = 40
("fib(", n, ")= ", recursive (n), "\n") join print

recursive(40)= 165580141
real	0m2.851s

Iterative

iterative = (n) :
   curr = 0
   prev = 1
   tmp = 0
   n times:
      tmp = curr
      curr = curr + prev
      prev = tmp
   .
   curr
.

Matrix based

sqr = (x): x * x.

# Based on the fact that
# F2n = Fn(2Fn+1 - Fn)
# F2n+1 = Fn ^2 + Fn+1 ^2
matrix = (n) :
   algorithm = (n) :
      "computes (Fn, Fn+1)"
      if (n < 2): return ((0, 1), (1, 1)) at(n).
      
      # n = e + {0, 1}
      q = algorithm(n / 2)  # q = (Fe/2, Fe/2+1)
      q = (q(0) * (2 * q(1) - q(0)), sqr(q(0)) + sqr(q(1)))  # q => (Fe, Fe+1)
      if (n % 2 == 1) :  # q => (Fe+{0, 1}, Fe+1+{0,1}) = (Fn, Fn+1)
         q = (q(1), q(1) + q(0))
      .
      q
   .
   algorithm(n)(0)
.

Handling negative values

fibonacci = (n) :
   myFavorite = matrix
   if (n >= 0) :
      myFavorite(n)
   .  else :
      n = n * -1
      if (n % 2 == 1) :
         myFavorite(n)
      . else :
         myFavorite(n) * -1
      .
   .
.

PowerShell

Iterative

function FibonacciNumber ( $count )
{
    $answer = @(0,1)
    while ($answer.Length -le $count)
    {
        $answer += $answer[-1] + $answer[-2]
    }
    return $answer
}

An even shorter version that eschews function calls altogether:

$count = 8
$answer = @(0,1)
0..($count - $answer.Length) | Foreach { $answer += $answer[-1] + $answer[-2] }
$answer

Recursive

function fib($n) {
    switch ($n) {
        0            { return 0 }
        1            { return 1 }
        { $_ -lt 0 } { return [Math]::Pow(-1, -$n + 1) * (fib (-$n)) }
        default      { return (fib ($n - 1)) + (fib ($n - 2)) }
    }
}

Processing

Translation of: Java

void setup() {
  size(400, 400);
  fill(255, 64);
  frameRate(2);
}
void draw() {
  int num = fibonacciNum(frameCount);
  println(frameCount, num);
  rect(0,0,num, num);
  if(frameCount==14) frameCount = -1; // restart
}
int fibonacciNum(int n) {
  return (n < 2) ? n : fibonacciNum(n - 1) + fibonacciNum(n - 2);
}

On the nth frame, the nth Fibonacci number is printed to the console and a square of that size is drawn on the sketch surface. The sketch restarts to keep drawing within the window size.

Output:

Prolog

Works with: SWI Prolog

Works with: GNU Prolog

Works with: YAP

fib(1, 1) :- !.
fib(0, 0) :- !.
fib(N, Value) :-
  A is N - 1, fib(A, A1),
  B is N - 2, fib(B, B1),
  Value is A1 + B1.

This naive implementation works, but is very slow for larger values of N. Here are some simple measurements (in SWI-Prolog):

?- time(fib(0,F)).
% 2 inferences, 0.000 CPU in 0.000 seconds (88% CPU, 161943 Lips)
F = 0.

?- time(fib(10,F)).
% 265 inferences, 0.000 CPU in 0.000 seconds (98% CPU, 1458135 Lips)
F = 55.

?- time(fib(20,F)).
% 32,836 inferences, 0.016 CPU in 0.016 seconds (99% CPU, 2086352 Lips)
F = 6765.

?- time(fib(30,F)).
% 4,038,805 inferences, 1.122 CPU in 1.139 seconds (98% CPU, 3599899 Lips)
F = 832040.

?- time(fib(40,F)).
% 496,740,421 inferences, 138.705 CPU in 140.206 seconds (99% CPU, 3581264 Lips)
F = 102334155.

As you can see, the calculation time goes up exponentially as N goes higher.

Poor man's memoization

Works with: SWI Prolog

Works with: YAP

Works with: GNU Prolog

The performance problem can be readily fixed by the addition of two lines of code (the first and last in this version):

%:- dynamic fib/2.  % This is ISO, but GNU doesn't like it.
:- dynamic(fib/2).  % Not ISO, but works in SWI, YAP and GNU unlike the ISO declaration.
fib(1, 1) :- !.
fib(0, 0) :- !.
fib(N, Value) :-
  A is N - 1, fib(A, A1),
  B is N - 2, fib(B, B1),
  Value is A1 + B1,
  asserta((fib(N, Value) :- !)).

Let's take a look at the execution costs now:

?- time(fib(0,F)).
% 2 inferences, 0.000 CPU in 0.000 seconds (90% CPU, 160591 Lips)
F = 0.

?- time(fib(10,F)).
% 37 inferences, 0.000 CPU in 0.000 seconds (96% CPU, 552610 Lips)
F = 55.

?- time(fib(20,F)).
% 41 inferences, 0.000 CPU in 0.000 seconds (96% CPU, 541233 Lips)
F = 6765.

?- time(fib(30,F)).
% 41 inferences, 0.000 CPU in 0.000 seconds (95% CPU, 722722 Lips)
F = 832040.

?- time(fib(40,F)).
% 41 inferences, 0.000 CPU in 0.000 seconds (96% CPU, 543572 Lips)
F = 102334155.

In this case by asserting the new N,Value pairing as a rule in the database we're making the classic time/space tradeoff. Since the space costs are (roughly) linear by N and the time costs are exponential by N, the trade-off is desirable. You can see the poor man's memoizing easily:

?- listing(fib).
:- dynamic fib/2.

fib(40, 102334155) :- !.
fib(39, 63245986) :- !.
fib(38, 39088169) :- !.
fib(37, 24157817) :- !.
fib(36, 14930352) :- !.
fib(35, 9227465) :- !.
fib(34, 5702887) :- !.
fib(33, 3524578) :- !.
fib(32, 2178309) :- !.
fib(31, 1346269) :- !.
fib(30, 832040) :- !.
fib(29, 514229) :- !.
fib(28, 317811) :- !.
fib(27, 196418) :- !.
fib(26, 121393) :- !.
fib(25, 75025) :- !.
fib(24, 46368) :- !.
fib(23, 28657) :- !.
fib(22, 17711) :- !.
fib(21, 10946) :- !.
fib(20, 6765) :- !.
fib(19, 4181) :- !.
fib(18, 2584) :- !.
fib(17, 1597) :- !.
fib(16, 987) :- !.
fib(15, 610) :- !.
fib(14, 377) :- !.
fib(13, 233) :- !.
fib(12, 144) :- !.
fib(11, 89) :- !.
fib(10, 55) :- !.
fib(9, 34) :- !.
fib(8, 21) :- !.
fib(7, 13) :- !.
fib(6, 8) :- !.
fib(5, 5) :- !.
fib(4, 3) :- !.
fib(3, 2) :- !.
fib(2, 1) :- !.
fib(1, 1) :- !.
fib(0, 0) :- !.
fib(A, D) :-
	B is A+ -1,
	fib(B, E),
	C is A+ -2,
	fib(C, F),
	D is E+F,
	asserta((fib(A, D):-!)).

All of the interim N/Value pairs have been asserted as facts for quicker future use, speeding up the generation of the higher Fibonacci numbers.

Continuation passing style

Works with SWI-Prolog and module lambda, written by Ulrich Neumerkel found there http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl

:- use_module(lambda).
fib(N, FN) :-
	cont_fib(N, _, FN, \_^Y^_^U^(U = Y)).

cont_fib(N, FN1, FN, Pred) :-
	(   N < 2 ->
	    call(Pred, 0, 1, FN1, FN)
	;
	    N1 is N - 1,
	    P = \X^Y^Y^U^(U is X + Y),
	    cont_fib(N1, FNA, FNB, P),
	    call(Pred, FNA, FNB, FN1, FN)
	).

With lazy lists

Works with SWI-Prolog and others that support freeze/2.

fib([0,1|X]) :-
    ffib(0,1,X).
ffib(A,B,X) :-
    freeze(X, (C is A+B, X=[C|Y], ffib(B,C,Y)) ).

The predicate fib(Xs) unifies Xs with an infinite list whose values are the Fibonacci sequence. The list can be used like this:

?- fib(X), length(A,15), append(A,_,X), writeln(A).
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]

Generators idiom

take( 0, Next, Z-Z, Next).
take( N, Next, [A|B]-Z, NZ):- N>0, !, next( Next, A, Next1),
  N1 is N-1,
  take( N1, Next1, B-Z, NZ).

next( fib(A,B), A, fib(B,C)):- C is A+B.

%% usage: ?- take(15, fib(0,1), _X-[], G), writeln(_X).
%% [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
%% G = fib(610, 987)

Yet another implementation

One of my favorites; loosely similar to the first example, but without the performance penalty, and needs nothing special to implement. Not even a dynamic database predicate. Attributed to M.E. for the moment, but simply because I didn't bother to search for the many people who probably did it like this long before I did. If someone knows who came up with it first, please let us know.

% Fibonacci sequence generator
fib(C, [P,S], C, N)  :- N is P + S.
fib(C, [P,S], Cv, V) :- succ(C, Cn), N is P + S, !, fib(Cn, [S,N], Cv, V).

fib(0, 0).
fib(1, 1).
fib(C, N) :- fib(2, [0,1], C, N). % Generate from 3rd sequence on

Looking at performance:

 ?- time(fib(30,X)).
% 86 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 832040 
 ?- time(fib(40,X)).
% 116 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 102334155
 ?- time(fib(100,X)).
% 296 inferences, 0.000 CPU in 0.001 seconds (0% CPU, Infinite Lips)
X = 354224848179261915075

What I really like about this one, is it is also a generator- i.e. capable of generating all the numbers in sequence needing no bound input variables or special Prolog predicate support (such as freeze/3 in the previous example):

?- time(fib(X,Fib)).
% 0 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = Fib, Fib = 0 ;
% 1 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = Fib, Fib = 1 ;
% 3 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 2,
Fib = 1 ;
% 5 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 3,
Fib = 2 ;
% 5 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 4,
Fib = 3 ;
% 5 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = Fib, Fib = 5 ;
% 5 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 6,
Fib = 8
...etc.

It stays at 5 inferences per iteration after X=3. Also, quite useful:

 ?- time(fib(100,354224848179261915075)).
% 296 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
true .

?- time(fib(X,354224848179261915075)).
% 394 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 100 .

Efficient implementation

% John Devou: 26-Nov-2021
% Efficient program to calculate n-th Fibonacci number.
% Works fast for n ≤ 1 000 000 000.

b(0,Bs,Bs).
b(N,Bs,Res):- N > 0, B is mod(N,2), M is div(N,2), b(M,[B|Bs],Res).

f([],A,_,_,A).
f([X|Xs],A,B,C,Res):- AA is A^2, BB is B^2, A_ is 2*BB-3*AA-C, B_ is AA+BB,
    (X =:= 1 -> T is A_+B_, f(Xs,B_,T,-2,Res); f(Xs,A_,B_,2,Res)).

fib(N,F):- b(N,[],Bs), f(Bs,0,1,2,F), !.

Output:

?- time(fib(30,X)).
% 59 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 832040.

?- time(fib(100,X)).
% 80 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 354224848179261915075.

?- time(fib(500,X)). 
% 102 inferences, 0.000 CPU in 0.000 seconds (?% CPU, Infinite Lips)
X = 139423224561697880139724382870407283950070256587697307264108962948325571622863290691557658876222521294125.

?- time(fib(1000000000,_)). 
% 334 inferences, 7.078 CPU in 7.526 seconds (94% CPU, 47 Lips)
true.

Pure

Tail Recursive

fib n = loop 0 1 n with
  loop a b n = if n==0 then a else loop b (a+b) (n-1);
end;

Purity

The following takes a natural number and generates an initial segment of the Fibonacci sequence of that length:

data Fib1 = FoldNat 
            <
              const (Cons One (Cons One Empty)),
              (uncurry Cons) . ((uncurry Add) . (Head, Head . Tail), id)
            >

This following calculates the Fibonacci sequence as an infinite stream of natural numbers:

type (Stream A?,,,Unfold) = gfix X. A? . X?
data Fib2 = Unfold ((outl, (uncurry Add, outl))) ((curry id) One One)

As a histomorphism:

import Histo

data Fib3 = Histo . Memoize 
            <
              const One, 
              (p1 => 
              <
                const One, 
                (p2 => Add (outl $p1) (outl $p2)). UnmakeCofree
              > (outr $p1)) . UnmakeCofree
            >

Python

Analytic

Binet's formula:

from math import *

def analytic_fibonacci(n):
  sqrt_5 = sqrt(5);
  p = (1 + sqrt_5) / 2;
  q = 1/p;
  return int( (p**n + q**n) / sqrt_5 + 0.5 )

for i in range(1,31):
  print analytic_fibonacci(i),

Output:

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040

Iterative

def fibIter(n):
    if n < 2:
        return n
    fibPrev = 1
    fib = 1
    for _ in range(2, n):
        fibPrev, fib = fib, fib + fibPrev
    return fib

Iterative positive and negative

def fib(n,x=[0,1]):
   for i in range(abs(n)-1): x=[x[1],sum(x)]
   return x[1]*pow(-1,abs(n)-1) if n<0 else x[1] if n else 0

for i in range(-30,31): print fib(i),

Output:

-832040 514229 -317811 196418 -121393 75025 -46368 28657 -17711 10946 -6765 4181 -2584 1597 -987 
610 -377 233 -144 89 -55 34 -21 13 -8 5 -3 2 -1 1 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 
1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040

Recursive

def fibRec(n):
    if n < 2:
        return n
    else:
        return fibRec(n-1) + fibRec(n-2)

Recursive with Memoization

def fibMemo():
    pad = {0:0, 1:1}
    def func(n):
        if n not in pad:
            pad[n] = func(n-1) + func(n-2)
        return pad[n]
    return func

fm = fibMemo()
for i in range(1,31):
    print fm(i),

Output:

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040

Better Recursive doesn't need Memoization

The recursive code as written two sections above is incredibly slow and inefficient due to the nested recursion calls. Although the memoization above makes the code run faster, it is at the cost of extra memory use. The below code is syntactically recursive but actually encodes the efficient iterative process, and thus doesn't require memoization:

def fibFastRec(n):
    def fib(prvprv, prv, c):
        if c < 1: 
            return prvprv
        else: 
            return fib(prv, prvprv + prv, c - 1) 
    return fib(0, 1, n)

However, although much faster and not requiring memory, the above code can only work to a limited 'n' due to the limit on stack recursion depth by Python; it is better to use the iterative code above or the generative one below.

Generative

def fibGen(n):
    a, b = 0, 1
    while n>0:
        yield a
        a, b, n = b, a+b, n-1

Example use

>>> [i for i in fibGen(11)]

[0,1,1,2,3,5,8,13,21,34,55]

Matrix-Based

Translation of the matrix-based approach used in F#.

def prevPowTwo(n):
    'Gets the power of two that is less than or equal to the given input'
    if ((n & -n) == n):
        return n
    else:
        n -= 1
        n |= n >> 1
        n |= n >> 2
        n |= n >> 4
        n |= n >> 8
        n |= n >> 16
        n += 1
        return (n/2)

def crazyFib(n):
    'Crazy fast fibonacci number calculation'
    powTwo = prevPowTwo(n)
    
    q = r = i = 1
    s = 0
    
    while(i < powTwo):
        i *= 2
        q, r, s = q*q + r*r, r * (q + s), (r*r + s*s)
        
    while(i < n):
        i += 1
        q, r, s = q+r, q, r
        
    return q

Large step recurrence

This is much faster for a single, large value of n:

def fib(n, c={0:1, 1:1}):
    if n not in c:
        x = n // 2
        c[n] = fib(x-1) * fib(n-x-1) + fib(x) * fib(n - x)
    return c[n]

fib(10000000)  # calculating it takes a few seconds, printing it takes eons

Same as above but slightly faster

Putting the dictionary outside the function makes this about 2 seconds faster, could just make a wrapper:

F = {0: 0, 1: 1, 2: 1}
def fib(n):
    if n in F:
        return F[n]
    f1 = fib(n // 2 + 1)
    f2 = fib((n - 1) // 2)
    F[n] = (f1 * f1 + f2 * f2 if n & 1 else f1 * f1 - f2 * f2)
    return F[n]

Generative with Recursion

This can get very slow and uses a lot of memory. Can be sped up by caching the generator results.

def fib():
    """Yield fib[n+1] + fib[n]"""
    yield 1  # have to start somewhere
    lhs, rhs = fib(), fib()
    yield next(lhs) # move lhs one iteration ahead
    while True:
        yield next(lhs)+next(rhs)

f=fib()
print [next(f) for _ in range(9)]

Output:

[1, 1, 2, 3, 5, 8, 13, 21, 34]

Another version of recursive generators solution, starting from 0

from itertools import islice

def fib():
    yield 0
    yield 1
    a, b = fib(), fib()
    next(b)
    while True:
        yield next(a)+next(b)
 
print(tuple(islice(fib(), 10)))

As a scan or a fold

itertools.accumulate

The Fibonacci series can be defined quite simply and efficiently as a scan or accumulation, in which the accumulator is a pair of the two last numbers.

Works with: Python version 3.7

'''Fibonacci accumulation'''

from itertools import accumulate, chain
from operator import add


# fibs :: Integer :: [Integer]
def fibs(n):
    '''An accumulation of the first n integers in
       the Fibonacci series. The accumulator is a
       pair of the two preceding numbers.
    '''
    def go(ab, _):
        return ab[1], add(*ab)

    return [xy[1] for xy in accumulate(
        chain(
            [(0, 1)],
            range(1, n)
        ),
        go
    )]


# MAIN ---
if __name__ == '__main__':
    print(
        'First twenty: ' + repr(
            fibs(20)
        )
    )

Output:

First twenty: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

functools.reduce

A fold can be understood as an amnesic scan, and functools.reduce can provide a useful and efficient re-write of the scanning version above, if we only need the Nth term in the series:

Works with: Python version 3.7

'''Nth Fibonacci term (by folding)'''

from functools import reduce
from operator import add


# nthFib :: Integer -> Integer
def nthFib(n):
    '''Nth integer in the Fibonacci series.'''
    def go(ab, _):
        return ab[1], add(*ab)
    return reduce(go, range(1, n), (0, 1))[1]


# MAIN ---
if __name__ == '__main__':
    print(
        '1000th term: ' + repr(
            nthFib(1000)
        )
    )

Output:

1000th term: 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875

Works with: Python version 3.9

def fib(n):
    from functools import reduce
    return reduce(lambda x, y: (x[1], x[0] + x[1]), range(n), (0, 1))[0]

Array and Range

fibseq = [1,1,]
fiblength = 21
for x in range(1,fiblength-1):
	xcount = fibseq[x-1] + fibseq[x]
	fibseq.append(xcount)
print(xcount)

Output:

Minimal from Russia

fi1=fi2=fi3=1 # FIB Russia rextester.com/FEEJ49204
for da in range(1, 88): # Danilin
    print("."*(20-len(str(fi3))), end=' ')
    print(fi3)
    fi3 = fi2+fi1
    fi1 = fi2
    fi2 = fi3

Output:

................... 1
................... 2
................... 3

....... 6557470319842
...... 10610209857723
...... 17167680177565

.. 420196140727489673
.. 679891637638612258
. 1100087778366101931

Qi

Recursive

(define fib
  0 -> 0
  1 -> 1
  N -> (+ (fib-r (- N 1))
          (fib-r (- N 2))))

Iterative

(define fib-0
  V2 V1 0 -> V2
  V2 V1 N -> (fib-0 V1 (+ V2 V1) (1- N)))

(define fib
  N -> (fib-0 0 1 N))

Quackery

  [ 0 1 rot times [ tuck + ] drop ] is fibo ( n --> n )

  100 fibo echo

Output:

354224848179261915075

R

Iterative positive and negative

fib=function(n,x=c(0,1)) {
   if (abs(n)>1) for (i in seq(abs(n)-1)) x=c(x[2],sum(x))
   if (n<0) return(x[2]*(-1)^(abs(n)-1)) else if (n) return(x[2]) else return(0)
}  

sapply(seq(-31,31),fib)

Output:

 [1] 1346269 -832040  514229 -317811  196418 -121393   75025  -46368   28657
[10]  -17711   10946   -6765    4181   -2584    1597    -987     610    -377
[19]     233    -144      89     -55      34     -21      13      -8       5
[28]      -3       2      -1       1       0       1       1       2       3
[37]       5       8      13      21      34      55      89     144     233
[46]     377     610     987    1597    2584    4181    6765   10946   17711
[55]   28657   46368   75025  121393  196418  317811  514229  832040 1346269

Other methods

# recursive
recfibo <- function(n) {
  if ( n < 2 ) n
  else Recall(n-1) + Recall(n-2)
}

# print the first 21 elements
print.table(lapply(0:20, recfibo))

# iterative
iterfibo <- function(n) {
  if ( n < 2 )
    n
  else {
    f <- c(0, 1)
    for (i in 2:n) {
      t <- f[2]
      f[2] <- sum(f)
      f[1] <- t
    }
    f[2]
  }
}

print.table(lapply(0:20, iterfibo))

# iterative but looping replaced by map-reduce'ing
funcfibo <- function(n) {
  if (n < 2) 
    n
  else {
    generator <- function(f, ...) {
      c(f[2], sum(f))
    }
    Reduce(generator, 2:n, c(0,1))[2]
  }
}

print.table(lapply(0:20, funcfibo))

Note that an idiomatic way to implement such low level, basic arithmethic operations in R is to implement them C and then call the compiled code.

Output:

All three solutions print

 [1] 0    1    1    2    3    5    8    13   21   34   55   89   144  233  377 
[16] 610  987  1597 2584 4181 6765

Ra

class FibonacciSequence
	**Prints the nth fibonacci number**
	
	on start
		
		args := program arguments
		
		if args empty
			print .fibonacci(8)
		
		else
			
			try
				print .fibonacci(integer.parse(args[0]))
			
			catch FormatException
				print to Console.error made !, "Input must be an integer"
				exit program with error code
			
			catch OverflowException
				print to Console.error made !, "Number too large"
				exit program with error code
	
	define fibonacci(n as integer) as integer is shared
		**Returns the nth fibonacci number**
		
		test
			assert fibonacci(0) = 0
			assert fibonacci(1) = 1
			assert fibonacci(2) = 1
			assert fibonacci(3) = 2
			assert fibonacci(4) = 3
			assert fibonacci(5) = 5
			assert fibonacci(6) = 8
			assert fibonacci(7) = 13
			assert fibonacci(8) = 21

		
		body
			a, b := 0, 1
		
			for n
				a, b := b, a + b
		
			return a

Racket

Tail Recursive

(define (fib n)
  (let loop ((cnt 0) (a 0) (b 1))
    (if (= n cnt)
        a
        (loop (+ cnt 1) b (+ a b)))))

(define (fib n (a 0) (b 1))
  (if (< n 2)
      1
      (+ a (fib (- n 1) b (+ a b)))))

Matrix Form

#lang racket

(require math/matrix)

(define (fibmat n) (matrix-ref 
                    (matrix-expt (matrix ([1 1]
                                          [1 0])) 
                                 n) 
                    1 0))

(fibmat 1000)

Foldl Form

(define (fib n)
  (car (foldl (lambda (y x)
                (let ((a (car x)) (b (cdr x)))
                  (cons b (+ a b)))) (cons 0 1) (range n))))

Raku

(formerly Perl 6)

List Generator

This constructs the fibonacci sequence as a lazy infinite list.

constant @fib = 0, 1, *+* ... *;

If you really need a function for it:

sub fib ($n) { @fib[$n] }

To support negative indices:

constant @neg-fib = 0, 1, *-* ... *;
sub fib ($n) { $n >= 0 ?? @fib[$n] !! @neg-fib[-$n] }

Iterative

sub fib (Int $n --> Int) {
    $n > 1 or return $n;
    my ($prev, $this) = 0, 1;
    ($prev, $this) = $this, $this + $prev for 1 ..^ $n;
    return $this;
}

Recursive

proto fib (Int $n --> Int) {*}
multi fib (0)  { 0 }
multi fib (1)  { 1 }
multi fib ($n) { fib($n - 1) + fib($n - 2) }

Rapira

Iterative

fun fibonacci(n)
    if n = 0 then
        return 0
    fi
    if n = 1 then
        return 1
    fi
    return fibonacci(n - 1) + fibonacci(n - 2)
end

RASEL

1&-:?v2\:2\01\--2\
     >$.@

RATFOR

program Fibonacci
#
integer*4 count, loop
integer*4 num1, num2, fib 

1 format(A)
2 format(I4)
3 format(I6,' ')
4 format(' ')
write(6,1,advance='no')'How Many: '
read(5,2)count

num1 = 0
num2 = 1
write(6,3,advance='no')num1
write(6,3,advance='no')num2

for (loop = 3; loop<=count; loop=loop+1)
      {
          fib = num1 + num2
          write(6,3,advance='no')fib
          num1 = num2
          num2 = fib
       }
write(6,4)
end

Red

(unnecessarily, but pleasantly palindromic)

Red []

palindrome: [fn: fn-1 + fn-1: fn]
fibonacci: func [n][
	fn-1: 0
	fn: 1
	loop n palindrome
]

Refal

$ENTRY Go {
    = <Prout <Repeat 18 Fibonacci 1 1>>
} ;

Repeat {
    0   s.F e.X = e.X;
    s.N s.F e.X = <Repeat <- s.N 1> s.F <Mu s.F e.X>>;
};

Fibonacci {
    e.X s.A s.B = e.X s.A s.B <+ s.A s.B>;
};

Output:

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

Relation

function fibonacci (n)
if n < 2 
set result = n
else
set f0 = 0
set f1 = 1
set k = 2
while k <= n
set result = f0 + f1
set f0 = f1
set f1 = result
set k = k + 1
end while
end if
end function

Retro

Recursive

: fib ( n-m ) dup [ 0 = ] [ 1 = ] bi or if; [ 1- fib ] sip [ 2 - fib ] do + ;

Iterative

: fib ( n-N )
  [ 0 1 ] dip [ over + swap ] times drop ;

REXX

With 210,000 numeric decimal digits, this REXX program can handle Fibonacci numbers past one million.
[Generally speaking, some REXX interpreters can handle up to around eight million decimal digits.]

This version of the REXX program can also handle negative Fibonacci numbers.

/*REXX program calculates the  Nth  Fibonacci number,   N   can be  zero  or  negative. */
numeric digits 210000                            /*be able to handle ginormous numbers. */
parse  arg  x y .                                /*allow a  single number  or  a range. */
if x=='' | x==","  then do;  x=-40;  y=+40;  end /*No input?  Then use range -40 ──► +40*/
if y=='' | y==","  then y=x                      /*if only one number, display   fib(X).*/
w= max(length(x),  length(y) )                   /*W:  used for making formatted output.*/
fw= 10                                           /*Minimum maximum width. Sounds ka─razy*/
      do j=x  to y;          q= fib(j)           /*process all of the Fibonacci requests*/
      L= length(q)                               /*obtain the length (decimal digs) of Q*/
      fw= max(fw, L)                             /*fib number length, or the max so far.*/
      say 'Fibonacci('right(j,w)") = "  right(q,fw)                   /*right justify Q.*/
      if L>10  then  say    'Fibonacci('right(j, w)") has a length of"     L
      end   /*j*/                                /* [↑]  list a Fib. sequence of  x──►y */
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
fib:  procedure; parse arg n;        an= abs(n)  /*use  │n│   (the absolute value of N).*/
      a= 0;    b= 1;   if an<2  then return an   /*handle two special cases: zero & one.*/
                                                 /* [↓]   this method is non─recursive. */
         do k=2  to an;   $= a+b;   a= b;   b= $ /*sum  the numbers  up to   │n│        */
         end   /*k*/                             /* [↑]  (only positive Fibs nums used).*/
                                                 /* [↓]  an//2   [same as]   (an//2==1).*/
      if n>0 | an//2   then  return  $           /*Positive or even?   Then return sum. */
                             return -$           /*Negative and odd? Return negative sum*/

output when using the default inputs:

Fibonacci(-40) =  -102334155
Fibonacci(-39) =    63245986
Fibonacci(-38) =   -39088169
Fibonacci(-37) =    24157817
Fibonacci(-36) =   -14930352
Fibonacci(-35) =     9227465
Fibonacci(-34) =    -5702887
Fibonacci(-33) =     3524578
Fibonacci(-32) =    -2178309
Fibonacci(-31) =     1346269
Fibonacci(-30) =     -832040
Fibonacci(-29) =      514229
Fibonacci(-28) =     -317811
Fibonacci(-27) =      196418
Fibonacci(-26) =     -121393
Fibonacci(-25) =       75025
Fibonacci(-24) =      -46368
Fibonacci(-23) =       28657
Fibonacci(-22) =      -17711
Fibonacci(-21) =       10946
Fibonacci(-20) =       -6765
Fibonacci(-19) =        4181
Fibonacci(-18) =       -2584
Fibonacci(-17) =        1597
Fibonacci(-16) =        -987
Fibonacci(-15) =         610
Fibonacci(-14) =        -377
Fibonacci(-13) =         233
Fibonacci(-12) =        -144
Fibonacci(-11) =          89
Fibonacci(-10) =         -55
Fibonacci( -9) =          34
Fibonacci( -8) =         -21
Fibonacci( -7) =          13
Fibonacci( -6) =          -8
Fibonacci( -5) =           5
Fibonacci( -4) =          -3
Fibonacci( -3) =           2
Fibonacci( -2) =          -1
Fibonacci( -1) =           1
Fibonacci(  0) =           0
Fibonacci(  1) =           1
Fibonacci(  2) =           1
Fibonacci(  3) =           2
Fibonacci(  4) =           3
Fibonacci(  5) =           5
Fibonacci(  6) =           8
Fibonacci(  7) =          13
Fibonacci(  8) =          21
Fibonacci(  9) =          34
Fibonacci( 10) =          55
Fibonacci( 11) =          89
Fibonacci( 12) =         144
Fibonacci( 13) =         233
Fibonacci( 14) =         377
Fibonacci( 15) =         610
Fibonacci( 16) =         987
Fibonacci( 17) =        1597
Fibonacci( 18) =        2584
Fibonacci( 19) =        4181
Fibonacci( 20) =        6765
Fibonacci( 21) =       10946
Fibonacci( 22) =       17711
Fibonacci( 23) =       28657
Fibonacci( 24) =       46368
Fibonacci( 25) =       75025
Fibonacci( 26) =      121393
Fibonacci( 27) =      196418
Fibonacci( 28) =      317811
Fibonacci( 29) =      514229
Fibonacci( 30) =      832040
Fibonacci( 31) =     1346269
Fibonacci( 32) =     2178309
Fibonacci( 33) =     3524578
Fibonacci( 34) =     5702887
Fibonacci( 35) =     9227465
Fibonacci( 36) =    14930352
Fibonacci( 37) =    24157817
Fibonacci( 38) =    39088169
Fibonacci( 39) =    63245986
Fibonacci( 40) =   102334155

output when the following was used as input: 10000

Fibonacci(10000) =  3364476487643178326662161200510754331030214846068006390656476997468008144216666236815559551363373402558206533268083615937373479048386526826304089246305643188735454436955982749160660209988418393386465273130008883026923567361313511757929743785441375213052050434770160226475831890652789085515436615958298727968298751063120057542878345321551510387081829896979161312785626503319548714021428753269818796204693609787990035096230229102636813149319527563022783762844154036058440257211433496118002309120828704608892396232883546150577658327125254609359112820392528539343462090424524892940390
170623388899108584106518317336043747073790855263176432573399371287193758774689747992630583706574283016163740896917842637862421283525811282051637029808933209990570792006436742620238978311147005407499845925036063356093388383192338678305613643535189213327973290813373264265263398976392272340788292817795358057099369104917547080893184105614632233821746563732124822638309210329770164805472624384237486241145309381220656491403275108664339451751216152654536133311131404243685480510676584349352383695965342807176877532834823434555736671973139274627362910821067928078471803532913117677892465908993863545932789
452377767440619224033763867400402133034329749690202832814593341882681768389307200363479562311710310129195316979460763273758925353077255237594378843450406771555577905645044301664011946258097221672975861502696844314695203461493229110597067624326851599283470989128470674086200858713501626031207190317208609408129832158107728207635318662461127824553720853236530577595643007251774431505153960090516860322034916322264088524885243315805153484962243484829938090507048348244932745373262456775587908918719080366205800959474315005240253270974699531877072437682590741993963226598414749819360928522394503970716544
3156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875
Fibonacci(10000) has a length of  2090  decimal digits

Rhovas

Solutions support arbitrarily large numbers as Rhovas's Integer type is arbitrary-precision (Java BigInteger). Additional notes:

require num >= 0; asserts input range preconditions, throwing on negative numbers

Iterative

Standard iterative solution using a for loop:

range(1, num, :incl) creates an inclusive range (1 <= i <= num) for iteration.
- The loop uses _ as the variable name since the value is unused.

func fibonacci(num: Integer): Integer {
    require num >= 0;
    var previous = 1;
    var current = 0;
    for (val _ in range(1, num, :incl)) {
        val next = current + previous;
        previous = current;
        current = next;
    }
    return current;
}

Recursive

Standard recursive solution using a pattern matching approach:

match without arguments is a conditional match, which works like if/else chains.
Rhovas doesn't perform tail-call optimization yet, hence why this solution isn't tail recursive.

func fibonacci(num: Integer): Integer {
    require num >= 0;
    match {
        num == 0: return 0;
        num == 1: return 1;
        else: return fibonacci(num - 1) + fibonacci(num - 2);
    }
}

Negatives

Standard solution using a pattern matching approach, delegating to an existing positiveFibonacci solution (as shown above). For negative fibonacci numbers, odd inputs return positive results while evens return negatives.

func fibonacci(num: Integer): Integer {
    match {
        num >= 0: return positiveFibonacci(num);
        num.mod(2) != 0: return positiveFibonacci(-num);
        else: return -positiveFibonacci(-num);
    }
}

Ring

give n
x = fib(n)
see n + " Fibonacci is : " + x

func fib nr if nr = 0 return 0 ok
            if nr = 1 return 1 ok 
            if nr > 1 return fib(nr-1) + fib(nr-2) ok

Rockstar

Iterative (minimized)

Fibonacci takes Number
  FNow is 0
  FNext is 1
  While FNow is less than Number
    Say FNow
    Put FNow into Temp
    Put FNow into FNext
    Put FNext plus Temp into FNext

Say Fibonacci taking 1000 (prints out highest number in Fibonacci sequence less than 1000)

Iterative (idiomatic)

Love takes Time
My love was addictions
Put my love into your heart
Build it up
Until my love is as strong as Time
Whisper my love
Put my love into a river
Put your heart into my love
Put it with a river into your heart


Shout; Love taking 1000 (years, years)

The semicolon and the comment (years, years) in this version are there only for poetic effect

Recursive

The Italian takes a lover, a kiss, a promise
love is population
hate is information
If a lover is love
Give back a kiss

If a lover is hate
Give back a promise

Knock a lover down
Put a promise with a kiss into my heart
Give back The Italian taking a lover, a promise, my heart

Listen to your heart
your mind is everything
your soul is opportunity
Whisper The Italian taking your heart, your mind, your soul

RPL

Works with: Halcyon Calc version 4.2.7

Iterative

≪ 0 1
   0 4 ROLL START 
      OVER + SWAP 
   NEXT SWAP DROP
≫ '→FIB' STO

≪ { } 0 20 FOR j j →FIB + NEXT ≫ EVAL

Recursive

≪ IF DUP 2 > THEN 
     DUP 1 - →FIB 
     SWAP 2 - →FIB + 
   ELSE SIGN END 
≫ '→FIB' STO

Output:

1: { 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 }

Fast recursive

A much better recursive approach, based on the formulas: F(2k) = [2*F(k-1) + F(k)]*F(k) and F(2k+1) = F(k)² + F(k+1)²

≪ IF DUP 2 ≤ THEN SIGN ELSE
     IF DUP 2 MOD
     THEN 1 - 2 / DUP →FIB SQ SWAP 1 + →FIB SQ +
     ELSE 2 / DUP →FIB DUP ROT 1 - →FIB 2 * + *
   END END
≫ '→FIB' STO

Ruby

Iterative

def fib(n)
  if n < 2
    n
  else
    prev, fib = 0, 1
    (n-1).times do
      prev, fib = fib, fib + prev
    end
    fib
  end
end

p (0..10).map { |i| fib(i) }

Output:

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Recursive

def fib(n, sequence=[1])
  return sequence.last if n == 0

  current_number, last_number = sequence.last(2)
  sequence << current_number + (last_number or 0)

  fib(n-1, sequence)
end

Recursive with Memoization

# Use the Hash#default_proc feature to
# lazily calculate the Fibonacci numbers.

fib = Hash.new do |f, n|
  f[n] = if n <= -2
           (-1)**(n + 1) * f[n.abs]
         elsif n <= 1
           n.abs
         else
           f[n - 1] + f[n - 2]
         end
end
# examples: fib[10] => 55, fib[-10] => (-55/1)

Matrix

require 'matrix'

# To understand why this matrix is useful for Fibonacci numbers, remember
# that the definition of Matrix.**2 for any Matrix[[a, b], [c, d]] is
# is [[a*a + b*c, a*b + b*d], [c*a + d*b, c*b + d*d]].  In other words, the
# lower right element is computing F(k - 2) + F(k - 1) every time M is multiplied
# by itself (it is perhaps easier to understand this by computing M**2, 3, etc, and
# watching the result march up the sequence of Fibonacci numbers).

M = Matrix[[0, 1], [1,1]]

# Matrix exponentiation algorithm to compute Fibonacci numbers.
# Let M be Matrix [[0, 1], [1, 1]].  Then, the lower right element of M**k is
# F(k + 1).  In other words, the lower right element of M is F(2) which is 1, and the
# lower right element of M**2 is F(3) which is 2, and the lower right element
# of M**3 is F(4) which is 3, etc.
#
# This is a good way to compute F(n) because the Ruby implementation of Matrix.**(n)
# uses O(log n) rather than O(n) matrix multiplications.  It works by squaring squares
# ((m**2)**2)... as far as possible
# and then multiplying that by by M**(the remaining number of times).  E.g., to compute
# M**19, compute partial = ((M**2)**2) = M**16, and then compute partial*(M**3) = M**19.
# That's only 5 matrix multiplications of M to compute M*19. 
def self.fib_matrix(n)
  return 0 if n <= 0 # F(0)
  return 1 if n == 1 # F(1)
  # To get F(n >= 2), compute M**(n - 1) and extract the lower right element.
  return CS::lower_right(M**(n - 1))
end

# Matrix utility to return
# the lower, right-hand element of a given matrix.
def self.lower_right matrix
  return nil if matrix.row_size == 0
  return matrix[matrix.row_size - 1, matrix.column_size - 1]
end

Generative

fib = Enumerator.new do |y|
  f0, f1 = 0, 1
  loop do
    y <<  f0
    f0, f1 = f1, f0 + f1
  end
end

Usage:

p fib.lazy.drop(8).next # => 21

Works with: Ruby version 1.9

"Fibers are primitives for implementing light weight cooperative concurrency in Ruby. Basically they are a means of creating code blocks that can be paused and resumed, much like threads. The main difference is that they are never preempted and that the scheduling must be done by the programmer and not the VM." [2]

fib = Fiber.new do
  a,b = 0,1
  loop do
    Fiber.yield a
    a,b = b,a+b
  end
end
9.times {puts fib.resume}

using a lambda

def fib_gen
    a, b = 1, 1
    lambda {ret, a, b = a, b, a+b; ret}
end

irb(main):034:0> fg = fib_gen
=> #<Proc:0xb7cdf750@(irb):22>
irb(main):035:0> 9.times { puts fg.call}
1
1
2
3
5
8
13
21
34
=> 9

Binet's Formula

def fib
    phi = (1 + Math.sqrt(5)) / 2
    ((phi**self - (-1 / phi)**self) / Math.sqrt(5)).to_i
end

1.9.3p125 :001 > def fib
1.9.3p125 :002?>   phi = (1 + Math.sqrt(5)) / 2
1.9.3p125 :003?>   ((phi**self - (-1 / phi)**self) / Math.sqrt(5)).to_i
1.9.3p125 :004?>   end
 => nil 
1.9.3p125 :005 > (0..10).map(&:fib)
 => [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Rust

Iterative

fn main() {
    let mut prev = 0;
    // Rust needs this type hint for the checked_add method
    let mut curr = 1usize;

    while let Some(n) = curr.checked_add(prev) {
        prev = curr;
        curr = n;
        println!("{}", n);
    }
}

Recursive

use std::mem;
fn main() {
    fibonacci(0,1);
}

fn fibonacci(mut prev: usize, mut curr: usize) {
    mem::swap(&mut prev, &mut curr);
    if let Some(n) = curr.checked_add(prev) {
        println!("{}", n);
        fibonacci(prev, n);
    }
}

Recursive (with pattern matching)

fn fib(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        n => fib(n - 1) + fib(n - 2),
    }
}

Tail recursive (with pattern matching)

fn fib_tail_recursive(nth: usize) -> usize {
  fn fib_tail_iter(n: usize, prev_fib: usize, fib: usize) -> usize {
    match n {
      0 => prev_fib,
      n => fib_tail_iter(n - 1, fib, prev_fib + fib),
    }
  }
  fib_tail_iter(nth, 0, 1)
}

Analytic

fn main() {
    for num in fibonacci_sequence() {
        println!("{}", num);
    }
}

fn fibonacci_sequence() -> impl Iterator<Item = u64> {
    let sqrt_5 = 5.0f64.sqrt();
    let p = (1.0 + sqrt_5) / 2.0;
    let q = 1.0 / p;
    // The range is sufficient up to 70th Fibonacci number
    (0..1).chain((1..70).map(move |n| ((p.powi(n) + q.powi(n)) / sqrt_5 + 0.5) as u64))
}

Using an Iterator

Iterators are very idiomatic in rust, though they may be overkill for such a simple problem.

use std::mem;

struct Fib {
    prev: usize,
    curr: usize,
} 

impl Fib {
    fn new() -> Self {
        Fib {prev: 0, curr: 1}
    }
}

impl Iterator for Fib {
    type Item = usize;
    fn next(&mut self) -> Option<Self::Item>{
        mem::swap(&mut self.curr, &mut self.prev);
        self.curr.checked_add(self.prev).map(|n| { 
            self.curr = n;
            n
        })
    }
}

fn main() {
    for num in Fib::new() {
        println!("{}", num);
    }
}

Iterator "Successors"

fn main() {
    std::iter::successors(Some((1u128, 0)), |&(a, b)| a.checked_add(b).map(|s| (b, s)))
        .for_each(|(_, u)| println!("{}", u));
}

SAS

Iterative

This code builds a table fib holding the first few values of the Fibonacci sequence.

data fib;
    a=0;
    b=1;
    do n=0 to 20;
       f=a;
       output;
       a=b;
       b=f+a;
    end;
    keep n f;
run;

Naive recursive

This code provides a simple example of defining a function and using it recursively. One of the members of the sequence is written to the log.

options cmplib=work.f;

proc fcmp outlib=work.f.p;
    function fib(n);
    if n = 0 or n = 1
        then return(1);
        else return(fib(n - 2) + fib(n - 1));
    endsub;
run;

data _null_;
    x = fib(5);
    put 'fib(5) = ' x;
run;

Sather

The implementations use the arbitrary precision class INTI.

class MAIN is

  -- RECURSIVE --
  fibo(n :INTI):INTI
    pre n >= 0
  is
    if n < 2.inti then return n; end;
    return fibo(n - 2.inti) + fibo(n - 1.inti);
  end;

  -- ITERATIVE --
  fibo_iter(n :INTI):INTI
    pre n >= 0
  is
    n3w :INTI;

    if n < 2.inti then return n; end;
    last ::= 0.inti; this ::= 1.inti;
    loop (n - 1.inti).times!;
      n3w := last + this;
      last := this;
      this := n3w;
    end;   
    return this;
  end;

  main is
    loop i ::= 0.upto!(16);
      #OUT + fibo(i.inti) + " ";
      #OUT + fibo_iter(i.inti) + "\n";
    end;
  end;

end;

Scala

Recursive

def fib(i: Int): Int = i match {
  case 0 => 0
  case 1 => 1
  case _ => fib(i - 1) + fib(i - 2)
}

Lazy sequence

lazy val fib: LazyList[Int] = 0 #:: 1 #:: fib.zip(fib.tail).map { case (a, b) => a + b }

Tail recursive

import scala.annotation.tailrec
@tailrec
final def fib(x: Int, prev: BigInt = 0, next: BigInt = 1): BigInt = x match {
  case 0 => prev
  case _ => fib(x - 1, next, next + prev)
}

foldLeft

// Fibonacci using BigInt with LazyList.foldLeft optimized for GC (Scala v2.13 and above)
// Does not run out of memory for very large Fibonacci numbers
def fib(n: Int): BigInt = {

  def series(i: BigInt, j: BigInt): LazyList[BigInt] = i #:: series(j, i + j)

  series(1, 0).take(n).foldLeft(BigInt("0"))(_ + _)
}

// Small test
(0 to 13) foreach {n => print(fib(n).toString + " ")}

// result: 0 1 1 2 3 5 8 13 21 34 55 89 144 233

Iterator

val it: Iterator[Int] = Iterator.iterate((0, 1)) { case (a, b) => (b, a + b) }.map(_._1)

def fib(n: Int): Int = it.drop(n).next()

// example:
println(it.take(13).mkString(",")) // prints: 0,1,1,2,3,5,8,13,21,34,55,89,144

Scheme

Iterative

(define (fib-iter n)
  (do ((num 2 (+ num 1))
       (fib-prev 1 fib)
       (fib 1 (+ fib fib-prev)))
      ((>= num n) fib)))

Recursive

(define (fib-rec n)
  (if (< n 2)
      n
      (+ (fib-rec (- n 1))
         (fib-rec (- n 2)))))

This version is tail recursive:

(define (fib n)
  (let loop ((a 0) (b 1) (n n))
    (if (= n 0) a
        (loop b (+ a b) (- n 1)))))

Recursive Sequence Generator

Although the tail recursive version above is quite efficient, it only generates the final nth Fibonacci number and not the sequence up to that number without wasteful repeated calls to the procedure/function.

The following procedure generates the sequence of Fibonacci numbers using a simplified version of a lazy list/stream - since no memoization is requried, it just implements future values by using a zero parameter lambda "thunk" with a closure containing the last and the pre-calculated next value of the sequence; in this way it uses almost no memory during the sequence generation other than as required for the last and the next values of the sequence (note that the test procedure does not generate a linked list to contain the elements of the sequence to show, but rather displays each one by one in sequence):

(define (fib)
  (define (nxt lv nv) (cons nv (lambda () (nxt nv (+ lv nv)))))
  (cons 0 (lambda () (nxt 0 1))))

;;; test...
(define (show-stream-take n strm)
  (define (shw-nxt n strm) (begin (display (car strm))
                                  (if (> n 1) (begin (display " ") (shw-nxt (- n 1) ((cdr strm)))) (display ")"))))
  (begin (display "(") (shw-nxt n strm)))
(show-stream-take 30 (fib))

Output:

(0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229)

Dijkstra Algorithm

;;; Fibonacci numbers using Edsger Dijkstra's algorithm
;;; http://www.cs.utexas.edu/users/EWD/ewd06xx/EWD654.PDF

(define (fib n)
  (define (fib-aux a b p q count)
    (cond ((= count 0) b)
          ((even? count)
           (fib-aux a
                    b
                    (+ (* p p) (* q q))
                    (+ (* q q) (* 2 p q))
                    (/ count 2)))
          (else
           (fib-aux (+ (* b q) (* a q) (* a p))
                    (+ (* b p) (* a q))
                    p
                    q
                    (- count 1)))))
  (fib-aux 1 0 0 1 n))

Scilab

    clear
    n=46
    f1=0; f2=1
    printf("fibo(%d)=%d\n",0,f1)
    printf("fibo(%d)=%d\n",1,f2)
    for i=2:n
        f3=f1+f2
        printf("fibo(%d)=%d\n",i,f3)
        f1=f2
        f2=f3
    end

Output:

...
fibo(43)=433494437
fibo(44)=701408733
fibo(45)=1134903170
fibo(46)=1836311903

sed

#!/bin/sed -f

# First we need to convert each number into the right number of ticks 
# Start by marking digits
s/[0-9]/<&/g

# We have to do the digits manually.
s/0//g; s/1/|/g; s/2/||/g; s/3/|||/g; s/4/||||/g; s/5/|||||/g
s/6/||||||/g; s/7/|||||||/g; s/8/||||||||/g; s/9/|||||||||/g

# Multiply by ten for each digit from the front.
:tens
s/|</<||||||||||/g
t tens

# Done with digit markers
s/<//g

# Now the actual work.
:split
# Convert each stretch of n >= 2 ticks into two of n-1, with a mark between
s/|\(|\+\)/\1-\1/g
# Convert the previous mark and the first tick after it to a different mark
# giving us n-1+n-2 marks.
s/-|/+/g
# Jump back unless we're done.
t split
# Get rid of the pluses, we're done with them.
s/+//g

# Convert back to digits
:back
s/||||||||||/</g
s/<\([0-9]*\)$/<0\1/g
s/|||||||||/9/g;
s/|||||||||/9/g; s/||||||||/8/g; s/|||||||/7/g; s/||||||/6/g;
s/|||||/5/g; s/||||/4/g; s/|||/3/g; s/||/2/g; s/|/1/g;
s/</|/g
t back
s/^$/0/

Seed7

Recursive

const func integer: fib (in integer: number) is func
  result
    var integer: result is 1;
  begin
    if number > 2 then
      result := fib(pred(number)) + fib(number - 2);
    elsif number = 0 then
      result := 0;
    end if;
  end func;

Original source: [3]

Iterative

This funtion uses a bigInteger result:

const func bigInteger: fib (in integer: number) is func
  result
    var bigInteger: result is 1_;
  local
    var integer: i is 0;
    var bigInteger: a is 0_;
    var bigInteger: c is 0_;
  begin
    for i range 1 to pred(number) do
      c := a;
      a := result;
      result +:= c;
    end for;
  end func;

Original source: [4]

SequenceL

Recursive

fibonacci(n) := 
		n when n < 2
	else
		fibonacci(n - 1) + fibonacci(n - 2);

Based on: [5]

Tail Recursive

fibonacci(n) := fibonacciHelper(0, 1, n);
		
fibonacciHelper(prev, next, n) :=
		prev when n < 1
	else
		next when n = 1
	else
		fibonacciHelper(next, next + prev, n - 1);

Matrix

fibonacci(n) := fibonacciHelper([[1,0],[0,1]], n);

fibonacciHelper(M(2), n) := 
	let
		N := [[1,1],[1,0]];
	in
		M[1,1] when n <= 1
	else
		fibonacciHelper(matmul(M, N), n - 1);

matmul(A(2), B(2)) [i,j] := sum( A[i,all] * B[all,j] );

Based on the C# version: [6]

Using the SequenceL Matrix Multiply solution: [7]

SETL

$ Print out the first ten Fibonacci numbers
$ This uses Set Builder Notation, it roughly means
$ 'collect fib(n) forall n in {0,1,2,3,4,5,6,7,8,9,10}'
print({fib(n) : n in {0..10}});

$ Iterative Fibonacci function
proc fib(n);
    A := 0; B := 1; C := n;
    for i in {0..n} loop
        C := A + B;
        A := B;
        B := C;
    end loop;
    return C;
end proc;

Shen

(define fib
  0 -> 0
  1 -> 1
  N -> (+ (fib (+ N 1)) (fib (+ N 2))) 
       where (< N 0)
  N -> (+ (fib (- N 1)) (fib (- N 2))))

Sidef

Iterative

func fib_iter(n) {
    var (a, b) = (0, 1)
    { (a, b) = (b, a+b) } * n
    return a
}

Recursive

func fib_rec(n) {
    n < 2 ? n : (__FUNC__(n-1) + __FUNC__(n-2))
}

Recursive with memoization

func fib_mem (n) is cached {
    n < 2 ? n : (__FUNC__(n-1) + __FUNC__(n-2))
}

Closed-form

func fib_closed(n) {
    define S = (1.25.sqrt + 0.5)
    define T = (-S + 1)
    (S**n - T**n) / (-T + S) -> round
}

Built-in

say fib(12)    #=> 144

Simula

Straightforward iterative implementation.

INTEGER PROCEDURE fibonacci(n);
INTEGER n;
BEGIN
    INTEGER lo, hi, temp, i;
    lo := 0;
    hi := 1;
    FOR i := 1 STEP 1 UNTIL n - 1 DO
    BEGIN
        temp := hi;
        hi := hi + lo;
        lo := temp
    END;
    fibonacci := hi
END;

SkookumScript

Built-in

SkookumScript's Integer class has a fast built-in fibonnaci() method.

42.fibonacci

SkookumScript is designed to work in tandem with C++ and its strength is at the high-level stage-direction of things. So when confronted with benchmarking scripting systems it is genrally better to make a built-in call. Though in most practical cases this isn't necessary.

Recursive

Simple recursive method in same 42.fibonacci form as built-in form above.

// Assuming code is in Integer.fibonacci() method
() Integer
  [
  if this < 2 [this] else [[this - 1].fibonacci + [this - 2].fibonacci]
  ]

Recursive procedure in fibonacci(42) form.

// Assuming in fibonacci(n) procedure
(Integer n) Integer
  [
  if n < 2 [n] else [fibonacci(n - 1) + fibonacci(n - 2)]
  ]

Iterative

Iterative method in 42.fibonacci form.

// Assuming code is in Integer.fibonacci() method
() Integer
  [
  if this < 2
    [this]
  else
    [
    !prev: 1
    !next: 1
    2.to_pre this
      [
      !sum :  prev + next
      prev := next
      next := sum
      ]
      
    next
    ]    
  ]

Optimized iterative method in 42.fibonacci form. Though the best optimiation is to write it in C++ as with the built-in form that comes with SkookumScript.

// Bind : is faster than assignment :=
// loop is faster than to_pre (which uses a closure)
() Integer
  [
  if this < 2
    [this]
  else
    [
    !prev: 1
    !next: 1
    !sum
    !count: this - 2
    loop
      [
      if count = 0 [exit]
      count--
      sum  : prev + next
      prev : next
      next : sum
      ]
      
    next
    ]    
  ]

Slate

n@(Integer traits) fib
[
  n <= 0 ifTrue: [^ 0].
  n = 1 ifTrue: [^ 1].
  (n - 1) fib + (n - 2) fib
].

slate[15]> 10 fib = 55.
True

Smalltalk

Smalltalk already has a builtin fib in the Integer class (so I call them fibI and fibR in the code below, to not overwrite it). The integer algorithms below are all naive; there are faster ways to do it (see benchmark at the end). I gave the recursive version roughly 100Mb of stack. The analytical computation generates inexact results and fails for arguments somewhere above 1470 due to floating point overflow (with extended precision, the overflow appears a bit later).

iterative (slow):

Integer >> fibI
    |aNMinus1 an t|

    aNMinus1 := 1.
    an := 0.
    self timesRepeat:[
        t := an.
        an := an + aNMinus1 .
        aNMinus1 := t.
    ].
    ^ an

The recursive version although nice to read is the worst; it suffers from a huge stack requirement and a super poor performance (an anti-example for recursion):

Integer >> fibR
    (self > 1) ifTrue:[
        ^ (self - 1) fibR + (self - 2) fibR
    ].
    ^ self

analytic (fast, but inexact, and limited to small n below 1475 if we use double precision IEEE floats):

Integer >> fibBinet
    |phi rPhi|

    phi := Float phi.
    rPhi := 1 / phi.

    ^ (1 / 5 sqrt) * ((phi raisedTo:self) - (rPhi raisedTo:self))

using more bits in the exponent, we can compute larger fibs (up to 23599 with x86 extended precision floats), but still inexact:

Integer >> fibBinetFloatE
    |phi rPhi|

    phi := FloatE phi.
    rPhi := 1 / phi.

    ^ (1 / 5 sqrt) * ((phi raisedTo:self) - (rPhi raisedTo:self))

(10 to:1e6 byFactor:10) do:[:n |
  Transcript printCR:'----',n,'----'.
  Transcript printCR: n fibI.
  Transcript printCR: ([[n fibR] on:RecursionError do:['recursion']] valueWithTimeout:30 seconds) ? 'timeout'.
  Transcript printCR: n fibBinet.
  Transcript printCR: n fibBinetFloatE.
].

Transcript cr; showCR:'Timing:'; showCR:'------'.
[ 1000 fibI ] benchmark:'1000 fibI'.
[ 1000 fibR ] benchmark:'1000 fibR' timeLimit:30 seconds.
[ 1000 fibBinet ] benchmark:'1000 fibBinet'.
[ 1000 fibBinetFloatE] benchmark:'1000 fibBinetFloatE'.
[ 1000 fib ] benchmark:'1000 fib (builtin)'.

[ 10000 fibI ] benchmark:'10000 fibI'.
[ 10000 fib ] benchmark:'10000 fib (builtin)'.

[ 100000 fibI ] benchmark:'100000 fibI'.
[ 100000 fib ] benchmark:'100000 fib (builtin)'.

[ 1000000 fibI ] benchmark:'100000 fibI'.
[ 1000000 fib ] benchmark:'1000000 fib (builtin)'.
[ 2000000 fib ] benchmark:'2000000 fib (builtin)'.
[ 10000000 fib ] benchmark:'10000000 fib (builtin)'

Output:

----10----
55
55
55.0
54.99999999999
----100----
354224848179261915075
timeout
3.54224848179262E+020
3.54224848179263E+020
----1000----
43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875
timeout
4.34665576869373E+208
4.34665576869373E+208
----10000----
336447648764317832666216120051075433103021...050562430701794976171121233066073310059947366875 (2089 digits)
timeout
INF
3.364476487643176087E+2089
----100000----
259740693472217241661550340212759154148804853...653428746875 (20898 digits)
recursion
INF
INF
----1000000----
19532821287077577316320149475962563324435429965918733...2043347225419033684684301719893411568996526838242546875 (208987 digits)
recursion
INF
INF

Timing:
-------
1000 fibI: 94 µs (394736 cycles)
timeout after 30000ms
1000 fibBinet: 5500 ns (21746 cycles)
1000 fibBinetFloatE: 12 µs (43444 cycles)
1000 fib (builtin): 37 µs (130842 cycles)
10000 fibI: 2.44 ms (8775334 cycles)
10000 fib (builtin): 49 µs (175466 cycles)
100000 fibI: 156ms (563848550 cycles)
100000 fib (builtin): 1.66 ms (5970368 cycles)
1000000 fibI: 14.3s (51676292910 cycles)
1000000 fib (builtin): 71.95 ms (259023588 cycles)
2000000 fib (builtin): 229ms (827461038 cycles)
10000000 fib (builtin): 2.769s (9970686190 cycles)

SNOBOL4

Recursive

	define("fib(a)")	:(fib_end)
fib	fib = lt(a,2) a	:s(return)
	fib = fib(a - 1) + fib(a - 2)	:(return)
fib_end

while	a = trim(input)	:f(end)
	output = a " " fib(a)	:(while)
end

Tail-recursive

        define('trfib(n,a,b)') :(trfib_end)
trfib   trfib = eq(n,0) a :s(return)
        trfib = trfib(n - 1, a + b, a) :(return)
trfib_end

Iterative

        define('ifib(n)f1,f2') :(ifib_end)
ifib    ifib = le(n,2) 1 :s(return)
        f1 = 1; f2 = 1
if1     ifib = gt(n,2) f1 + f2 :f(return)
        f1 = f2; f2 = ifib; n = n - 1 :(if1)
ifib_end

Analytic

Works with: Macro Spitbol

Works with: CSnobol

Note: Snobol4+ lacks built-in sqrt( ) function.

        define('afib(n)s5') :(afib_end)
afib    s5 = sqrt(5)
        afib = (((1 + s5) / 2) ^ n - ((1 - s5) / 2) ^ n) / s5
        afib = convert(afib,'integer') :(return)
afib_end

Test and display all, Fib 1 .. 10

loop    i = lt(i,10) i + 1 :f(show)
        s1 = s1 fib(i) ' ' ; s2 = s2 trfib(i,0,1) ' '
        s3 = s3 ifib(i) ' '; s4 = s4 afib(i) ' ' :(loop)
show    output = s1; output = s2; output = s3; output = s4
end

Output:

1 1 2 3 5 8 13 21 34 55
1 1 2 3 5 8 13 21 34 55
1 1 2 3 5 8 13 21 34 55
1 1 2 3 5 8 13 21 34 55

SNUSP

This is modular SNUSP (which introduces @ and # for threading).

Iterative

 @!\+++++++++#  /<<+>+>-\       
fib\==>>+<<?!/>!\      ?/\      
  #<</?\!>/@>\?-<<</@>/@>/>+<-\ 
     \-/  \       !\ !\ !\   ?/#

Recursive

             /========\    />>+<<-\  />+<-\
fib==!/?!\-?!\->+>+<<?/>>-@\=====?/<@\===?/<#
      |  #+==/     fib(n-2)|+fib(n-1)|
      \=====recursion======/!========/

Spin

Iterative

Works with: BST/BSTC

Works with: FastSpin/FlexSpin

Works with: HomeSpun

Works with: OpenSpin

con
  _clkmode = xtal1 + pll16x
  _clkfreq = 80_000_000
 
obj
  ser : "FullDuplexSerial.spin"
 
pub main | i
  ser.start(31, 30, 0, 115200)

  repeat i from 0 to 10
    ser.dec(fib(i))
    ser.tx(32)

  waitcnt(_clkfreq + cnt)
  ser.stop
  cogstop(0)

pub fib(i) : b | a 
  b := a := 1 
  repeat i 
    a := b + (b := a)

Output:

1 1 2 3 5 8 13 21 34 55 89

SPL

Analytic

fibo(n)=
  s5 = #.sqrt(5)
  <= (((1+s5)/2)^n-((1-s5)/2)^n)/s5
.

Iterative

fibo(n)=
  ? n<2, <= n
  f2 = 0
  f1 = 1
  > i, 2..n
    f = f1+f2
    f2 = f1
    f1 = f
  <
  <= f
.

Recursive

fibo(n)=
  ? n<2, <= n
  <= fibo(n-1)+fibo(n-2)
.

SQL

Analytic

As a running sum:

select round ( exp ( sum (ln ( ( 1 + sqrt( 5 ) ) / 2)
        ) over ( order by level ) ) / sqrt( 5 ) ) fibo
from dual
connect by level <= 10;

       FIB
----------
         1
         1
         2
         3
         5
         8
        13
        21
        34
        55

10 rows selected.

As a power:

select round ( power( ( 1 + sqrt( 5 ) ) / 2, level ) / sqrt( 5 ) ) fib
from dual
connect by level <= 10;

       FIB
----------
         1
         1
         2
         3
         5
         8
        13
        21
        34
        55

10 rows selected.

Recursive

Works with: Oracle

Oracle 12c required

SQL> with fib(e,f) as (select 1, 1 from dual union all select e+f,e from fib where e <= 55) select f from fib;

         F
----------
         1
         1
         2
         3
         5
         8
        13
        21
        34
        55

10 rows selected.

Works with: PostgreSQL

CREATE FUNCTION fib(n int) RETURNS numeric AS $$
    -- This recursive with generates endless list of Fibonacci numbers.
    WITH RECURSIVE fibonacci(current, previous) AS (
        -- Initialize the current with 0, so the first value will be 0.
        -- The previous value is set to 1, because its only goal is not
        -- special casing the zero case, and providing 1 as the second
        -- number in the sequence.
        --
        -- The numbers end with dots to make them numeric type in
        -- Postgres. Numeric type has almost arbitrary precision
        -- (technically just 131,072 digits, but that's good enough for
        -- most purposes, including calculating huge Fibonacci numbers)
        SELECT 0., 1.
    UNION ALL
        -- To generate Fibonacci number, we need to add together two
        -- previous Fibonacci numbers. Current number is saved in order
        -- to be accessed in the next iteration of recursive function.
        SELECT previous + current, current FROM fibonacci
    )
    -- The user is only interested in current number, not previous.
    SELECT current FROM fibonacci
    -- We only need one number, so limit to 1
    LIMIT 1
    -- Offset the query by the requested argument to get the correct
    -- position in the list.
    OFFSET n
$$ LANGUAGE SQL RETURNS NULL ON NULL INPUT IMMUTABLE;

SSEM

Calculates the tenth Fibonacci number. To calculate the nth, change the initial value of the counter to n-1 (subject to the restriction that the answer must be small enough to fit in a signed 32-bit integer, the SSEM's only data type). The algorithm is basically straightforward, but the absence of an Add instruction makes the implementation a little more complicated than it would otherwise be.

10101000000000100000000000000000    0. -21 to c    acc = -n
01101000000001100000000000000000    1. c   to 22   temp = acc
00101000000001010000000000000000    2. Sub. 20     acc -= m
10101000000001100000000000000000    3. c   to 21   n = acc
10101000000000100000000000000000    4. -21 to c    acc = -n
10101000000001100000000000000000    5. c   to 21   n = acc
01101000000000100000000000000000    6. -22 to c    acc = -temp
00101000000001100000000000000000    7. c   to 20   m = acc
11101000000000100000000000000000    8. -23 to c    acc = -count
00011000000001010000000000000000    9. Sub. 24     acc -= -1
00000000000000110000000000000000   10. Test        skip next if acc<0
10011000000000000000000000000000   11. 25  to CI   goto (15 + 1)
11101000000001100000000000000000   12. c   to 23   count = acc
11101000000000100000000000000000   13. -23 to c    acc = -count
11101000000001100000000000000000   14. c   to 23   count = acc
00011000000000000000000000000000   15. 24  to CI   goto (-1 + 1)
10101000000000100000000000000000   16. -21 to c    acc = -n
10101000000001100000000000000000   17. c   to 21   n = acc
10101000000000100000000000000000   18. -21 to c    acc = -n
00000000000001110000000000000000   19. Stop
00000000000000000000000000000000   20. 0           var m = 0
10000000000000000000000000000000   21. 1           var n = 1
00000000000000000000000000000000   22. 0           var temp = 0
10010000000000000000000000000000   23. 9           var count = 9
11111111111111111111111111111111   24. -1          const -1
11110000000000000000000000000000   25. 15          const 15

Stata

program fib
args n
clear
qui set obs `n'
qui gen a=1
qui replace a=a[_n-1]+a[_n-2] in 3/l
end

An implementation using dyngen.

program fib
args n
clear
qui set obs `n'
qui gen a=.
dyngen {
	update a=a[_n-1]+a[_n-2], missval(1)
}
end

fib 10
list

Output

     +----+
     |  a |
     |----|
  1. |  1 |
  2. |  1 |
  3. |  2 |
  4. |  3 |
  5. |  5 |
     |----|
  6. |  8 |
  7. | 13 |
  8. | 21 |
  9. | 34 |
 10. | 55 |
     +----+

Mata

. mata
: function fib(n) {
        return((((1+sqrt(5))/2):^n-((1-sqrt(5))/2):^n)/sqrt(5))
}

: fib(0..10)
        1    2    3    4    5    6    7    8    9   10   11
    +--------------------------------------------------------+
  1 |   0    1    1    2    3    5    8   13   21   34   55  |
    +--------------------------------------------------------+

: end

StreamIt

void->int feedbackloop Fib {
    join roundrobin(0,1);
    body in->int filter {
        work pop 1 push 1 peek 2 { push(peek(0) + peek(1)); pop(); }
    };
    loop Identity<int>;
    split duplicate;
    enqueue(0);
    enqueue(1);
}

SuperCollider

Recursive

nth fibonacci term for positive n

f = { |n| if(n < 2) { n } { f.(n-1) + f.(n-2) } };
(0..20).collect(f)

nth fibonacci term for positive and negative n.

f = { |n| var u = neg(sign(n)); if(abs(n) < 2) { n } { f.(2 * u + n) + f.(u + n) } };
(-20..20).collect(f)

Analytic

(
	f = { |n|
		var sqrt5 = sqrt(5);
		var p = (1 + sqrt5) / 2;
		var q = reciprocal(p);
		((p ** n) + (q ** n) / sqrt5 + 0.5).trunc
	};
	(0..20).collect(f)
)

Iterative

f = { |n| var a = [1, 1]; n.do { a = a.addFirst(a[0] + a[1]) }; a.reverse };
f.(18)

Swift

Analytic

import Cocoa

func fibonacci(n: Int) -> Int {
    let square_root_of_5 = sqrt(5.0)
    let p = (1 + square_root_of_5) / 2
    let q = 1 / p
    return Int((pow(p,CDouble(n)) + pow(q,CDouble(n))) / square_root_of_5 + 0.5)
}

for i in 1...30 {
    println(fibonacci(i))
}

Iterative

func fibonacci(n: Int) -> Int {
    if n < 2 {
        return n
    }
    var fibPrev = 1
    var fib = 1
    for num in 2...n {
        (fibPrev, fib) = (fib, fib + fibPrev)
    }
    return fib
}

Sequence:

func fibonacci() -> SequenceOf<UInt> {
  return SequenceOf {() -> GeneratorOf<UInt> in
    var window: (UInt, UInt, UInt) = (0, 0, 1)
    return GeneratorOf {
      window = (window.1, window.2, window.1 + window.2)
      return window.0
    }
  }
}

Recursive

func fibonacci(n: Int) -> Int {
    if n < 2 {
        return n
    } else {
        return fibonacci(n-1) + fibonacci(n-2)
    }
}

println(fibonacci(30))

Tailspin

Recursive simple

The simplest exponential-time recursive algorithm only handling positive N. Note that the "#" is the tailspin internal recursion which sends the value to the matchers. In this case where there is no initial block and no templates state, we could equivalently write the templates name "nthFibonacci" in place of the "#" to do a normal recursion.

templates nthFibonacci
  when <=0|=1> do $ !
  otherwise ($ - 1 -> #) + ($ - 2 -> #) !
end nthFibonacci

Iterative, mutable state

We could use the templates internal mutable state, still only positive N.

templates nthFibonacci
  @: {n0: 0"1", n1: 1"1"};
  1..$ -> @: {n0: $@.n1, n1: $@.n0 + $@.n1};
  $@.n0!
end nthFibonacci

To handle negatives, we can keep track of the sign and send it to the matchers.

templates nthFibonacci
  @: {n0: 0"1", n1: 1"1"};
  def sign: $ -> \(<0..> 1! <> -1!\);
  1..$*$sign -> $sign -> #
  $@.n0!
  <=1>
    @: {n0: $@.n1, n1: $@.n0 + $@.n1};
  <=-1>
    @: {n0: $@.n1 - $@.n0, n1: $@.n0};
end nthFibonacci

State machine

Instead of mutating state, we could just recurse internally on a state structure.

templates nthFibonacci
  { N: ($)"1", n0: 0"1", n1: 1"1" } -> #
  when <{ N: <=0"1"> }> do
    $.n0 !
  when <{ N: <1"1"..>}> do
    { N: $.N - 1"1", n0: $.n1, n1: $.n0 + $.n1} -> #
  otherwise
    { N: $.N + 1"1", n1: $.n0, n0: $.n1 - $.n0} -> #
end nthFibonacci
 
8 -> nthFibonacci -> '$;
' -> !OUT::write
-5 -> nthFibonacci -> '$;
' -> !OUT::write
-6 -> nthFibonacci -> '$;
' -> !OUT::write

Output:

21"1"
5"1"
-8"1"

Tcl

Simple Version

These simple versions do not handle negative numbers -- they will return N for N < 2

Iterative

Translation of: Perl

proc fibiter n {
    if {$n < 2} {return $n}
    set prev 1
    set fib 1
    for {set i 2} {$i < $n} {incr i} {
        lassign [list $fib [incr fib $prev]] prev fib
    }
    return $fib
}

Recursive

proc fib {n} {
    if {$n < 2} then {expr {$n}} else {expr {[fib [expr {$n-1}]]+[fib [expr {$n-2}]]} }
}

The following

Works with: Tcl version 8.5

: defining a procedure in the ::tcl::mathfunc namespace allows that proc to be used as a function in expr expressions.

proc tcl::mathfunc::fib {n} {
    if { $n < 2 } {
        return $n
    } else {
        return [expr {fib($n-1) + fib($n-2)}]
    }
}

# or, more tersely

proc tcl::mathfunc::fib {n} {expr {$n<2 ? $n : fib($n-1) + fib($n-2)}}

E.g.:

expr {fib(7)} ;# ==> 13

namespace path tcl::mathfunc #; or, interp alias {} fib {} tcl::mathfunc::fib
fib 7 ;# ==> 13

Tail-Recursive

In Tcl 8.6 a tailcall function is available to permit writing tail-recursive functions in Tcl. This makes deeply recursive functions practical. The availability of large integers also means no truncation of larger numbers.

proc fib-tailrec {n} {
    proc fib:inner {a b n} {
        if {$n < 1} {
            return $a
        } elseif {$n == 1} {
            return $b
        } else {
            tailcall fib:inner $b [expr {$a + $b}] [expr {$n - 1}]
        }
    }
    return [fib:inner 0 1 $n]
}

% fib-tailrec 100
354224848179261915075

Handling Negative Numbers

Iterative

proc fibiter n {
    if {$n < 0} {
        set n [expr {abs($n)}]
        set sign [expr {-1**($n+1)}]
    } else {
        set sign 1
    }
    if {$n < 2} {return $n}
    set prev 1
    set fib 1
    for {set i 2} {$i < $n} {incr i} {
        lassign [list $fib [incr fib $prev]] prev fib
    }
    return [expr {$sign * $fib}]
}
fibiter -5 ;# ==> 5
fibiter -6 ;# ==> -8

Recursive

proc tcl::mathfunc::fib {n} {expr {$n<-1 ? -1**($n+1) * fib(abs($n)) : $n<2 ? $n : fib($n-1) + fib($n-2)}}
expr {fib(-5)} ;# ==> 5
expr {fib(-6)} ;# ==> -8

For the Mathematically Inclined

This works up to $fib(70)$ , after which the limited precision of IEEE double precision floating point arithmetic starts to show.

Works with: Tcl version 8.5

proc fib n {expr {round((.5 + .5*sqrt(5)) ** $n / sqrt(5))}}

Tern

Recursive

func fib(n) {
   if (n < 2) {
      return 1;
   }
   return fib(n - 1) + fib(n - 2);
}

Coroutine

func fib(n) {
   let a = 1;
   let b = 2;
   
   until(n-- <= 0) {
      yield a;
      (a, b) = (b, a + b);
   }
}

TI SR-56

Texas Instruments SR-56 Program Listing for "Fibonacci Sequence"
Display	Key	Display	Display	Display
00 33	STO	25	50	75
01 00	0	26	51	76
02 01	1	27	52	77
03 33	STO	28	53	78
04 01	1	29	54	79
05 00	0	30	55	80
06 84	+	31	56	81
07 39	*EXC	32	57	82
08 01	1	33	58	83
09 94	=	34	59	84
10 27	*dsz	35	60	85
11 00	0	36	61	86
12 06	6	37	62	87
13 41	R/S	38	63	88
14 22	GTO	39	64	89
15 00	0	40	65	90
16 06	6	41	66	91
17		42	67	92
18		43	68	93
19		44	69	94
20		45	70	95
21		46	71	96
22		47	72	97
23		48	73	98
24		49	74	99

Asterisk denotes 2nd function key.

Register allocation
0: Nth term requested	1: Last term	2: Unused	3: Unused	4: Unused
5: Unused	6: Unused	7: Unused	8: Unused	9: Unused

Annotated listing:

STO 0        // Nth term requested := User input
1 STO 1      // Last term := 1
0            // Initial value: 0
+ *EXC 1 =   // Calculate next term.
*dsz 0 6     // Loop while R0 positive
R/S          // Done, show answer
GTO 0 6      // If user hits R/S calculate next term

Usage:

At the keypad enter a number N, then press RST R/S to calculate and display the Nth Fibonacci number. R/S for the following numbers.

Input:

1 RST R/S

Output:

Input:

2 RST R/S

Output:

Input:

3 RST R/S

Output:

Input:

10 RST R/S

Output:

R/S -> 89

R/S -> 144

TI-57

Step	Function	Comment
00	`STO` `0`	R0 = n
01	`C.t`	R7 = 0
02	`1`	Display = 1
03	`INV` `SUM` `1`	R0 -= 1
04	`Lbl` `1`	loop
05	`+`
06	`x⮂t`	Swap Display with R7
07	`=`	Display += R7
08	`Dsz`	R0 -= 1
09	`GTO` `1`	until R0 == 0
10	`R/S`	Stop
11	`RST`	Go back to step 0

10  RST R/S

Output:

55.

TSE SAL

// library: math: get: series: fibonacci <description></description> <version control></version control> <version>1.0.0.0.3</version> <version control></version control> (filenamemacro=getmasfi.s) [<Program>] [<Research>] [kn, ri, su, 20-01-2013 22:04:02]
INTEGER PROC FNMathGetSeriesFibonacciI( INTEGER  nI )
 //
 // Method:
 //
 // 1. Take the sum of the last 2 terms
 //
 // 2. Let the sum be the last term
 //    and goto step 1
 //
 INTEGER I = 0
 INTEGER minI = 1
 INTEGER maxI = nI
 INTEGER term1I = 0
 INTEGER term2I = 1
 INTEGER term3I = 0
 //
 FOR I = minI TO maxI
  //
  // make value 3 equal to sum of two previous values 1 and 2
  //
  term3I = term1I + term2I
  //
  // make value 1 equal to next value 2
  //
  term1I = term2I
  //
  // make value 2 equal to next value 3
  //
  term2I = term3I
  //
  ENDFOR
  //
 RETURN( term3I )
 //
END

PROC Main()
 STRING s1[255] = "3"
 REPEAT
  IF ( NOT ( Ask( " = ", s1, _EDIT_HISTORY_ ) ) AND ( Length( s1 ) > 0 ) ) RETURN() ENDIF
  Warn( FNMathGetSeriesFibonacciI( Val( s1 ) ) ) // gives e.g. 3
 UNTIL FALSE
END

Turing

% Recursive
function fibb (n: int) : int
    if n < 2 then
        result n
    else
        result fibb (n-1) + fibb (n-2)
    end if
end fibb

% Iterative
function ifibb (n: int) : int
    var a := 0  
    var b := 1
    for : 1 .. n
        a := a + b
        b := a - b
    end for
    result a
end ifibb

for i : 0 .. 10
    put fibb (i) : 4, ifibb (i) : 4
end for

Output:

TUSCRIPT

$$ MODE TUSCRIPT
ASK "What fibionacci number do you want?": searchfib=""
IF (searchfib!='digits') STOP
Loop n=0,{searchfib}
 IF (n==0) THEN
   fib=fiba=n
 ELSEIF (n==1) THEN
   fib=fibb=n
 ELSE
   fib=fiba+fibb, fiba=fibb, fibb=fib
 ENDIF
 IF (n!=searchfib) CYCLE
 PRINT "fibionacci number ",n,"=",fib
ENDLOOP

Output:

What fibionacci number do you want? >12
fibionacci number 12=144

Output:

What fibionacci number do you want? >31
fibionacci number 31=1346269

Output:

What fibionacci number do you want? >46
fibionacci 46=1836311903

Uiua

Works with: Uiua version 0.10.0-dev.1

Simple recursive example with memoisation.

F ← |1 memo⟨+⊃(F-1)(F-2)|∘⟩<2.
F ⇡20

UNIX Shell

Works with: bash version 3

#!/bin/bash

a=0
b=1
max=$1

for (( n=1; "$n" <= "$max"; $((n++)) ))
do
  a=$(($a + $b))
  echo "F($n): $a"
  b=$(($a - $b))
done

Recursive:

Works with: bash version 3

fib() {
  local n=$1
  [ $n -lt 2 ] && echo -n $n || echo -n $(( $( fib $(( n - 1 )) ) + $( fib $(( n - 2 )) ) ))
}

UnixPipes

This example is incorrect. Please fix the code and remove this message.

Details: There is a race between parallel commands. tee last might open and truncate the file before cat last opens it. Then cat last pipes the empty file to xargs, and expr reports a syntax error, and the script hangs forever.

echo 1 |tee last fib ; tail -f fib | while read x
do
   cat last | tee -a fib | xargs -n 1 expr $x + |tee last
done

Ursa

Translation of: Python

Iterative

def fibIter (int n)
	if (< n 2)
		return n
	end if
	decl int fib fibPrev num
	set fib (set fibPrev 1)
	for (set num 2) (< num n) (inc num)
		set fib (+ fib fibPrev)
		set fibPrev (- fib fibPrev)
	end for
	return fib
end

Ursala

All three methods are shown here, and all have unlimited precision.

#import std
#import nat

iterative_fib = ~&/(0,1); ~&r->ll ^|\predecessor ^/~&r sum

recursive_fib = {0,1}^?<a/~&a sum^|W/~& predecessor^~/~& predecessor

analytical_fib =

%np+ -+
   mp..round; ..mp2str; sep`+; ^CNC/~&hh take^\~&htt %np@t,
   (mp..div^|\~& mp..sub+ ~~ @rlX mp..pow_ui)^lrlPGrrPX/~& -+
      ^\~& ^(~&,mp..sub/1.E0)+ mp..div\2.E0+ mp..add/1.E0,
      mp..sqrt+ ..grow/5.E0+-+-

The analytical method uses arbitrary precision floating point arithmetic from the mpfr library and then converts the result to a natural number. Sufficient precision for an exact result is always chosen based on the argument. This test program computes the first twenty Fibonacci numbers by all three methods.

#cast %nLL

examples = <.iterative_fib,recursive_fib,analytical_fib>* iota20

output:

<
   <0,0,0>,
   <1,1,1>,
   <1,1,1>,
   <2,2,2>,
   <3,3,3>,
   <5,5,5>,
   <8,8,8>,
   <13,13,13>,
   <21,21,21>,
   <34,34,34>,
   <55,55,55>,
   <89,89,89>,
   <144,144,144>,
   <233,233,233>,
   <377,377,377>,
   <610,610,610>,
   <987,987,987>,
   <1597,1597,1597>,
   <2584,2584,2584>,
   <4181,4181,4181>>

V

Generate n'th fib by using binary recursion

[fib
   [small?] []
     [pred dup pred]
     [+]
   binrec].

Vala

Recursive

Using int, but could easily replace with double, long, ulong, etc.

int fibRec(int n){
	if (n < 2)
		return n;
	else
		return fibRec(n - 1) + fibRec(n - 2);
}

Iterative

Using int, but could easily replace with double, long, ulong, etc.

int fibIter(int n){
	if (n < 2)
		return n;
	
	int last = 0;
	int cur = 1;
	int next;
	
	for (int i = 1; i < n; ++i){
		next = last + cur;
		last = cur;
		cur = next;
	}
	
	return cur;
}

VAX Assembly

                               0000  0000     1 .entry	main,0
                            7E 7CFD  0002     2 	clro	-(sp)			;result buffer
                            5E   DD  0005     3 	pushl	sp			;pointer to buffer
                            10   DD  0007     4 	pushl	#16			;descriptor: len of buffer
                       5B   5E   D0  0009     5 	movl	sp, r11			;-> descriptor
                                     000C     6 
                       7E   01   7D  000C     7 	movq	#1, -(sp)		;init 0,1
                                     000F     8 loop:
               7E   6E   04 AE   C1  000F     9 	addl3	4(sp), (sp), -(sp)	;next element on stack
                            17   1D  0014    10 	bvs	ret			;vs - overflow set, exit
                                     0016    11 
                            5B   DD  0016    12 	pushl	r11			;-> descriptor by ref
                         04 AE   DF  0018    13 	pushal	4(sp)			;-> fib on stack by ref
              00000000'GF   02   FB  001B    14 	calls	#2, g^ots$cvt_l_ti	;convert integer to string
                            5B   DD  0022    15 	pushl	r11			;
              00000000'GF   01   FB  0024    16 	calls	#1, g^lib$put_output	;show result
                            E2   11  002B    17 	brb	loop
                                     002D    18 ret:
                                 04  002D    19 	ret
                                     002E    20 .end	main
$ run fib
...
        14930352
        24157817
        39088169
        63245986
       102334155
       165580141
       267914296
       433494437
       701408733
      1134903170
      1836311903
$

Vedit macro language

Iterative

Calculate fibonacci(#1). Negative values return 0.

:FIBONACCI:
#11 = 0
#12 = 1
Repeat(#1) {
    #10 = #11 + #12
    #11 = #12
    #12 = #10
}
Return(#11)

Unlimited precision

// Fibonacci, unlimited precision.
//  input: #1 = n
//  return: fibonacci(n) in text register 10
//
:fibo_unlimited:
if (#1 < 2) {
    Num_Str(#1, 10)
    return
} else {
    Buf_Switch(Buf_Free)
    IC('0') IN
    IC('1') IN
    #10 = #1
    While (#10 > 1) {
        #12 = 0			// carry out
	#15 = 1			// column (ones, tens, hundreds...)
	Repeat (ALL) {		// Sum all columns
	    Line(-1)			// n-1
	    Goto_col(#15)
	    if (At_EOL) {		// all digits added
		break
	    }
	    #11 = Cur_Char - '0' + #12	// digit of (n-1) + carry
	    Line(-1)			// n-2
	    Goto_Col(#15)
	    if (!At_EOL) {		// may contain fewer digits than n-1
		#11 += Cur_Char - '0'
	    }
	    Goto_Line(3)		// sum
	    EOL
	    #12 = #11 / 10		// carry out
	    Ins_Char((#11 % 10) + '0')
	    #15++			// next column
	}
	if (#12) {			
	    Goto_Line(3)
	    EOL
	    Ins_Char(#12 + '0')		// any extra digit from carry
        }
	BOF
	Del_Line(1)			// Next n
	Line(1) EOL
	Ins_Newline
	#10--
    }
    Goto_Line(2)		// Results on line 2
}
// Copy the results to text register 10 in reverse order
Reg_Empty(10)
While(!At_EOL) {
    Reg_Copy_Block(10, CP, CP+1, INSERT)
    Char()
}
Buf_Quit(OK)
return

Test:

#1 = Get_Num("n: ", STATLINE)
Ins_Text("fibonacci(") Num_Ins(#1, LEFT+NOCR) Ins_Text(") = ")
Call("fibo_unlimited")
Reg_Ins(10) IN
return

Output:

fibonacci(1000) = 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875

V (Vlang)

Update V (Vlang) to version 0.2.2

Iterative

fn fib_iter(n int) int {
    if n < 2 {
      return n
    }

    mut prev, mut fib := 0, 1
    for _ in 0..(n - 1){
        prev, fib = fib, prev + fib
    }
    return fib
}

fn main() {
    for val in 0..11 {
        println('fibonacci(${val:2d}) = ${fib_iter(val):3d}')
    }
}

Recursive

fn fib_rec(n int) int {
    if n < 2 {
      return n
    }
    return fib_rec(n - 2) + fib_rec(n - 1)
}

fn main() {
    for val in 0..11 {
        println('fibonacci(${val:2d}) = ${fib_rec(val):3d}')
    }
}

Output:

fibonacci( 0) =   0
fibonacci( 1) =   1
fibonacci( 2) =   1
fibonacci( 3) =   2
fibonacci( 4) =   3
fibonacci( 5) =   5
fibonacci( 6) =   8
fibonacci( 7) =  13
fibonacci( 8) =  21
fibonacci( 9) =  34
fibonacci(10) =  55

Wart

Recursive, all at once

def (fib n)
  if (n < 2)
    n
    (+ (fib n-1) (fib n-2))

Recursive, using cases

def (fib n)
  (+ (fib n-1) (fib n-2))

def (fib n) :case (n < 2)
  n

Recursive, using memoization

def (fib n saved)
  # all args in Wart are optional, and we expect callers to not provide `saved`
  default saved :to (table 0 0 1 1)  # pre-populate base cases
  default saved.n :to
    (+ (fib n-1 saved) (fib n-2 saved))
  saved.n

WDTE

Memoized Recursive

let memo fib n => n { > 1 => + (fib (- n 1)) (fib (- n 2)) };

Iterative

let s => import 'stream';
let a => import 'arrays';

let fib n => (
	let reducer p n => [a.at p 1; + (a.at p 0) (a.at p 1)];
	s.range 1 n
	-> s.reduce [0; 1] reducer
	-> a.at 1
	;
);

WebAssembly

(func $fibonacci_nth (param $n i32) (result i32)

    ;;Declare some local registers
    (local $i i32)
    (local $a i32)
    (local $b i32)
 
    ;;Handle first 2 numbers as special cases
    (if (i32.eq (get_local $n) (i32.const 0))
        (return (i32.const 0))
    )
    (if (i32.eq (get_local $n) (i32.const 1))
        (return (i32.const 1))
    )
 
    ;;Initialize first two values
    (set_local $i (i32.const 1))
    (set_local $a (i32.const 0))
    (set_local $b (i32.const 1))
 
    (block 
        (loop 
            ;;Add two previous numbers and store the result
            local.get $a
            local.get $b
            i32.add 
            (set_local $a (get_local $b))
            set_local $b
 
            ;;Increment counter i by one
            (set_local $i                 
                (i32.add 
                    (get_local $i)
                    (i32.const 1)
                )
            )
 
            ;;Check if loop is done
            (br_if 1 (i32.ge_u (get_local $i) (get_local $n)))
            (br 0)
        )
    )
 
    ;;The result is stored in b, so push that to the stack
    get_local $b
)

Whitespace

Iterative

This program generates Fibonacci numbers until it is forced to terminate.

It was generated from the following pseudo-Assembly.

push 0
push 1

0:
    swap
    dup
    onum
    push 10
    ochr
    copy 1
    add
    jump 0

Output:

$ wspace fib.ws | head -n 6
0
1
1
2
3
5

Recursive

This program takes a number n on standard input and outputs the nth member of the Fibonacci sequence.

; Read n.
push 0
dup
inum
load

; Call fib(n), ouput the result and a newline, then exit.
call 0
onum
push 10
ochr
exit

0:
    dup
    push 2
    sub
    jn 1   ; Return if n < 2.
    dup
    push 1
    sub
    call 0 ; Call fib(n - 1).
    swap   ; Get n back into place.
    push 2
    sub
    call 0 ; Call fib(n - 2).
    add    ; Leave the sum on the stack.
1:
    ret

Output:

$ echo 10 | wspace fibrec.ws
55

Wrapl

Generator

DEF fib() (
    VAR seq <- [0, 1]; EVERY SUSP seq:values;
    REP SUSP seq:put(seq:pop + seq[1])[-1];
);

To get the 17th number:

16 SKIP fib();

To get the list of all 17 numbers:

ALL 17 OF fib();

Iterator

Using type match signature to ensure integer argument:

TO fib(n @ Integer.T) (
    VAR seq <- [0, 1];
    EVERY 3:to(n) DO seq:put(seq:pop + seq[1]);
    RET seq[-1];
);

Wren

// iterative (quick)
var fibItr = Fn.new { |n|
    if (n < 2) return n
    var a = 0
    var b = 1
    for (i in 2..n) {
        var c = a + b
        a = b
        b = c
    }
    return b
}

// recursive (slow)
var fibRec
fibRec = Fn.new { |n|
    if (n < 2) return n
    return fibRec.call(n-1) + fibRec.call(n-2)
}

System.print("Iterative: %(fibItr.call(36))")
System.print("Recursive: %(fibRec.call(36))")

Output:

Iterative: 14930352
Recursive: 14930352

x86 Assembly

Works with: MASM

TITLE i hate visual studio 4			(Fibs.asm)
;       __         __/--------\
;      >__ \      /  |        |\
;         \  \___/ @  \      /   \__________________
;           \____       \  /                         \\\
;                \____         Coded with love by:    |||
;                      \      Alexander Alvonellos    |||
;                       |          9/29/2011         / ||
;                       |                           |  MM
;                       |      |--------------|     |
;                       |<     |              |<    |
;                       |      |              |     |
;                       |mmmmmm|              |mmmmm|
;; Epic Win. 

INCLUDE Irvine32.inc
                                                                              
.data
	BEERCOUNT = 48;
	Fibs dd 0, 1, BEERCOUNT DUP(0);

.code
main PROC
; I am not responsible for this code.
; They made me write it, against my will.
	;Here be dragons
	mov esi, offset Fibs; offset array;  ;;were to start (start)
	mov ecx, BEERCOUNT; 		;;count of items (how many)
	mov ebx, 4; 		;;size (in number of bytes)
	call DumpMem;
	
	mov ecx, BEERCOUNT; 	;//http://www.wolframalpha.com/input/?i=F ib%5B47%5D+%3E+4294967295
	mov esi, offset Fibs
	NextPlease:;
		mov eax, [esi]; 	;//Get me the data from location at ESI
		add eax, [esi+4];	;//add into the eax the data at esi + another double (next mem loc)
		mov [esi+8], eax;	;//Move that data into the memory location after the second number
		add esi, 4;			;//Update the pointer
	loop NextPlease;	;//Thank you sir, may I have another?
	
	
	;Here be dragons
	mov esi, offset Fibs; offset array;  ;;were to start (start)
	mov ecx, BEERCOUNT; 		;;count of items (how many)
	mov ebx, 4; 		;;size (in number of bytes)
	call DumpMem;

	exit		; exit to operating system
main ENDP

END main

xEec

This will display the first 93 numbers of the sequence.

h#1 h#1 h#1 o# 
h#10 o$ p 
>f 
  o# h#10 o$ p 
  ma h? jnext p
  t
jnf

XLISP

Analytic

Uses Binet's method, based on the golden ratio, which almost feels like cheating—but the task specification doesn't require any particular algorithm, and this one is straightforward and fast.

(DEFUN FIBONACCI (N)
    (FLOOR (+ (/ (EXPT (/ (+ (SQRT 5) 1) 2) N) (SQRT 5)) 0.5)))

To test it, we'll define a RANGE function and ask for the first 50 numbers in the sequence:

(DEFUN RANGE (X Y)
    (IF (<= X Y)
        (CONS X (RANGE (+ X 1) Y))))

(PRINT (MAPCAR FIBONACCI (RANGE 1 50)))

Output:

(1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073 4807526976 7778742049 12586269025)

Tail recursive

Alternatively, this approach is reasonably efficient:

(defun fibonacci (x)
    (defun fib (a b n)
        (if (= n 2)
            b
            (fib b (+ a b) (- n 1)) ) )
    (if (< x 2)
        x
        (fib 1 1 x) ) )

XPL0

func Fib1(N);   \Return Nth Fibonacci number using iteration
int N;
int Fn, F0, F1;
[F0:= 0;  F1:= 1;  Fn:= N;
while N > 1 do
        [Fn:= F0 + F1;
        F0:= F1;
        F1:= Fn;
        N:= N-1;
        ];
return Fn;
];

func Fib2(N);   \Return Nth Fibonacci number using recursion
int N;
return if N < 2 then N else Fib2(N-1) + Fib2(N-2);

int N;
[for N:= 0 to 20 do [IntOut(0, Fib1(N));  ChOut(0, ^ )];
 CrLf(0);
 for N:= 0 to 20 do [IntOut(0, Fib2(N));  ChOut(0, ^ )];
 CrLf(0);
]

Output:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765

XQuery

declare function local:fib($n as xs:integer) as xs:integer {
  if($n < 2)
  then $n
  else local:fib($n - 1) + local:fib($n - 2)
};

Z80 Assembly

; 8 bit version
; IN : a = n  (n <= 13, otherwise overflows)
; OUT: a = FIB(n)

fib8:	cp 2
	ret c	; if n < 2 then done

	ld b,a
	dec b	; b = n - 1
	ld c,0	; F0
	ld a,1	; F1

f8_l:	ld d,a
	add a,c
	ld c,d
	djnz f8_l

	ret

8 bits only? That's so 80's!

Let's go 32 bits...

; 32 bit version
; IN : a = n  (n <= 47, otherwise overflows)
; OUT: hlh'l' = FIB(n)

fib32:	ld l,a	; lower bytes in the alt set
	ld h,0
	exx	; now in regular set
	ld hl,0
	cp 2
	ret c	; if n < 2 then done

	dec a	; loopcount = n - 1
	ld bc,0
	exx	; now in alt set
	ld bc,0
	ld hl,1

f32_l:	ld d,h
	ld e,l
	add hl,bc
	ld b,d
	ld c,e
	exx	; now in reg set
	ld d,h
	ld e,l
	adc hl,bc
	ld b,d
	ld c,e
	exx	; now in alt set
	dec a
	jr nz,f32_l

	exx	; now in reg set
	ret

YAMLScript

!yamlscript/v0

defn main(n=10):
  loop [a 0, b 1, i 1]:
    say: a
    if (i < n):
      recur: b, (a + b), (i + 1)

zkl

A slight tweak to the task; creates a function that continuously generates fib numbers

var fibShift=fcn(ab){ab.append(ab.sum()).pop(0)}.fp(L(0,1));

zkl: do(15){ fibShift().print(",") }
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,

zkl: do(5){ fibShift().print(",") }
610,987,1597,2584,4181,

↑ R. L. Graham and N. J. A. Sloane, Anti-Hadamard matrices, Linear Algebra Appl. 62 (1984), 113–137.

[1] R. L. Graham and N. J. A. Sloane, Anti-Hadamard matrices, Linear Algebra Appl. 62 (1984), 113–137.

[1]