Movatterモバイル変換

Fibonacci sequence

From Rosetta Code

Fibonacci sequence
You are encouraged tosolve this task according to the task description, using any language you may know.

TheFibonacci 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, recursive (though recursive solutions are generally considered too slow and are mostly used as an exercise in recursion), or useBinet's algebraic formula.

The sequence is sometimes extended for negative numbers by using an alternating inverse of the positive values. Rewriting the definition as

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

leads to

 F_-n = (-1)ⁿ⁺¹ F_n.

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 fibL(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 registerSAVEAREA B     STM-SAVEAREA(R15) skip savearea         DC    17F'0'          savearea         DC    CL8'FIBONACC'   eyecatcherSTM      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           limitLOOP     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*        ----  DATANN       DC    H'46'           nn max nPW       DS    PL8             15numZW       DS    ZL16CW       DS    CL16ZN       DS    CL20*                  ' b 0 0 0 , 0 0 0 , 0 0 0 , 0 0 0 , 0 0 0'  15numEM       DC    XL20'402020206B2020206B2020206B2020206B202120'  maskWTOMSG   DS    0F         DC    H'80',XL2'0000'*                   fibo(46)=1836311903         WTOBUF   DC    CL80'fibo(12)=1234567890'         REGEQU         END   FIBONACC

Output:

...fibo(41)=   165,580,141fibo(42)=   267,914,296fibo(43)=   433,494,437fibo(44)=   701,408,733fibo(45)= 1,134,903,170fibo(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              limitLOOP     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*        ----   DATANN       DC     H'73'              nnFNM2     DS     PL8                f(n-2)FNM1     DS     PL8                f(n-1)FN       DS     PL8                f(n)PW       DS     PL8                15numZN       DS     CL20*                   ' b 0 0 0 , 0 0 0 , 0 0 0 , 0 0 0 , 0 0 0'  15numEM       DC     XL20'402020206B2020206B2020206B2020206B202120'  maskWTOMSG   DS     0F         DC     H'80',XL2'0000'*                    fibo(73)=806515533049393WTOBUF   DC     CL80'fibo(12)=123456789012345 '         REGEQU           END    FIBOWTOP

Output:

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

This subroutine stores the firstn—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  #0LOOP:  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 thisC 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.LD4-D5,-(SP)MOVE.LD0,D4MOVEQ#0,D5CMP.L#2,D0BCS.barMOVEQ#0,D5.foo:MOVE.LD4,D0SUBQ.L#1,D0JSRfibSUBQ.L#2,D4ADD.LD0,D5CMP.L#1,D4BHI.foo.bar:MOVE.LD5,D0ADD.LD4,D0MOVEM.L(SP)+,D4-D5RTS

8080 Assembly

This subroutine expects to be called with the value of ${\displaystyle n}$ in registerA, and returns ${\displaystyle f(n)}$ also inA. You may want to take steps to save the previous contents ofB,C, andD. The routine only works with fairly small values of ${\displaystyle n}$ .

FIBNCI: MOV  C,  A  ; C will store the counter        DCR  C      ; decrement, because we know f(1) already        MVI  A,  1        MVI  B,  0LOOP:   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. The code here assumes the CP/M operating system.

    ;-------------------------------------------------------    ; useful equates    ;-------------------------------------------------------bdosequ 5; BDOS entry cr    equ 13; ASCII carriage returnlf    equ 10; ASCII line feedspaceequ    32; ASCII space charconoutequ 2; BDOS console output functionputstrequ    9; BDOS print string functionntermsequ   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    callbdos    mvi a,0    ; start with Fib(0)mloop:pusha    ; save our count    call fib    callputdec    mvi    a,space; separate the numbers    callputchr    pop    a    ; get our count back    inr    a    ; increment it    cpi    nterms+1; have we reached our limit?    jnz    mloop; no, keep going    lhldoldstk; 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    retfib2: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 passfib3:ret    ;-------------------------------------------------------    ; console output of char in A register    ;-------------------------------------------------------putchr:pushh    pushd    pushb    mov    e,a    mvi    c,conout    callbdos    pop    b    pop    d    pop    h    ret    ;---------------------------------------------------------    ; Output decimal number to console    ; HL holds 16-bit unsigned binary number to print    ;---------------------------------------------------------putdec: pushb    pushd    pushh    lxi    b,-10    lxi    d,-1putdec2:    dad    b    inx    d    jc    putdec2    lxi    b,10    dad    b    xchg    mov    a,h    oral    cnz    putdec; recursive call    mov    a,e    adi    '0'    callputchr    pop    h    pop    d    pop    b    ret    ;-------------------------------------------------------    ; data area    ;-------------------------------------------------------signon: db    'Fibonacci number sequence:',cr,lf,'$'oldstk:dw    0stackequ    $+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 AXpushBPpushBXpushAXmovBX,DI;COPY INPUT TO BXxorAX,AX;MOV AX,0testBX,BX;SET FLAGS ACCORDING TO BXjeLBB0_4;IF BX == 0 RETURN 0cmpBX,1;IF BX == 1 RETURN 1jneLBB0_3movAX,1;ELSE, SET AX = 1 AND RETURNjmpLBB0_4LBB0_3:leaDI,WORDPTR[BX-1];DI = BX - 1callfib;RETURN FIB(BX-1)movBP,AX;STORE THIS IN BPaddBX,-2movDI,BXcallfib;GET FIB(DI - 2)addAX,BP;RETURN FIB(DI - 1) + FIB(DI - 2)LBB0_4:addsp,2popBXpopBPret

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 returnsthe 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)pushdscmpbx,41;bounds checkjaIndexOutOfBoundsshlbx,1shlbx,1;multiply by 4, since this is a table of dwordsmovax,@codemovds,axmovsi,offsetfibmovax,[ds:si];fetch the low word into AXmovdx,2[ds:si];fetch the high word into DXpopdsretIndexOutOfBounds:stc;set carry to indicate an errormovax,0FFFFh;return FFFF as the error codepopdsret;table of the first 41 fibonacci numbersfibdword0,1,1,2,3,5,8,13dword21,34,55,89,144,233,377,610dword987,1597,2584,4181,6765,10946,17711,28657dword46368,75025,121393,196418,317811,514229,832040,1346269dword2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986dword102334155

8th

An iterative solution:

:fibon\ n -- fib(n)>r01( tuck n:+ )\ fib(n-2) fib(n-1) -- fib(n-1) fib(n)r>n:1-times;:fib\ n -- fib(n)dup1n:=if1;;thenfibonnip;

AArch64 Assembly

Works with:as version Raspberry Pi 3B version Buster 64 bits
or android 64 bits with application Termux

/* ARM assembly AARCH64 Raspberry PI 3B *//*  program numfibo64.s   *//*******************************************//* Constantes                              *//*******************************************//* for this file see task include a file in language AArch64 assembly*/.include "../includeConstantesARM64.inc"/*********************************//* Initialized data              *//*********************************/.dataszMessDebutPgm:    .asciz "Program 64 bits start. \n"szCarriageReturn:  .asciz "\n"szMessFinOK:       .asciz "Program normal end. \n"szMessErreur:      .asciz "Error  !!!\n"szMessFibo:        .asciz "\nFibonaci numbers :\n".align 4/*********************************//* UnInitialized data            *//*********************************/.bss  sZoneConv:               .skip 24 .align 4/*********************************//*  code section                 *//*********************************/.text.global main main:    ldr x0,qAdrszMessDebutPgm    bl affichageMess            // start message         ldr x0,qAdrszMessFibo    bl affichageMess    mov x0,#0                   // rank    mov x1,#0                   // L(0)  or L(n-2)    mov x2,#1                   // L(1)  or L(n-1)            mov x3,#20                  // maxi    bl genererFibo        ldr x0,qAdrszMessFinOK    bl affichageMess           b 100f99:    ldr x0,qAdrszMessErreur        // error    bl affichageMess    mov x0, #1                     // return code error    b 100f100:     mov x8,EXIT     svc #0                         // system callqAdrszMessDebutPgm:          .quad szMessDebutPgmqAdrszMessFinOK:             .quad szMessFinOKqAdrszMessErreur:            .quad szMessErreur qAdrsZoneConv:               .quad sZoneConvqAdrszMessFibo:              .quad szMessFibo/***************************************************//*   Generation Fibonacci number                 *//***************************************************//* x0 contains n     *//* x1 contains L(0)  *//* x2 contains L(1)  *//* x3 contains limit number */genererFibo:    stp x4,lr,[sp,-16]!    stp x5,x6,[sp,-16]!     mov x4,x0    cmp x3,#0                    // end compute ?    ble 100f    cmp x0,#0                    // L(0) ?    bne 1f    mov x0,x1    bl displayNumber    add x0,x4,#1                // increment rank    sub x3,x3,#1                // decrement counter    bl genererFibo    b 100f1:    cmp x0,#1                   // L(1) ?    bne 2f    mov x0,x2    bl displayNumber    add x0,x4,#1    sub x3,x3,#1    bl genererFibo    b 100f2:    add x5,x2,x1                // add L(n-2) L(n-1)      mov x0,x5    bl displayNumber    add x0,x4,#1    sub x3,x3,#1    mov x1,x2                   // L(n-1) -> L(n-2)    mov x2,x5                   // number -> L(n-1)    bl genererFibo    b 100f    100:    ldp x5,x6,[sp],16     ldp x4,lr,[sp],16         // TODO: a completer     ret/***************************************************//*   display number                  *//***************************************************//* x0 contains number  */displayNumber:    stp x1,lr,[sp,-16]!       // TODO: a completer     ldr x1,qAdrsZoneConv    bl conversion10    ldr x0,qAdrsZoneConv    bl affichageMess    ldr x0,qAdrszCarriageReturn    bl affichageMess100:    ldp x1,lr,[sp],16         // TODO: a completer     retqAdrszCarriageReturn:         .quad szCarriageReturn/***************************************************//*      ROUTINES INCLUDE                 *//***************************************************//* for this file see task include a file in language AArch64 assembly*/.include "../includeARM64.inc"

Output:

Program 64 bits start.Fibonaci numbers :01123581321345589144233377610987159725844181Program normal end.

ABAP

Iterative

FORMfibonacci_iterUSINGindexTYPEiCHANGINGnumber_fibTYPEi.DATA:lv_oldtypei,lv_curtypei.Doindextimes.Ifsy-index=1orsy-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#(INITfibnm=VALUEstringtab((|0|)(|1|))nTYPEstringx=`0`y=`1`FORi=1WHILEi<=100NEXTn=(x+y)fibnm=VALUE#(BASEfibnm(n))x=yy=n)).

ACL2

Fast, tail recursive solution:

(defunfast-fib-r(nab)(if(or(zpn)(zp(1-n)))b(fast-fib-r(1-n)b(+ab))))(defunfast-fib(n)(fast-fib-rn11))(defunfirst-fibs-r(ni)(declare(xargs:measure(nfix(-ni))))(if(zp(-ni))nil(cons(fast-fibi)(first-fibs-rn(1+i)))))(defunfirst-fibs(n)(first-fibs-rn0))

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  FIRETURN (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  ODRETURN

Output:

Screenshot from Atari 8-bit computer

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

ActionScript

publicfunctionfib(n:uint):uint{if(n<2)returnn;returnfib(n-1)+fib(n-2);}

Ada

Recursive

withAda.Text_IO,Ada.Command_Line;procedureFibisX:Positive:=Positive'Value(Ada.Command_Line.Argument(1));functionFib(P:Positive)returnPositiveisbeginifP<=2thenreturn1;elsereturnFib(P-1)+Fib(P-2);endif;endFib;beginAda.Text_IO.Put("Fibonacci("&Integer'Image(X)&" ) = ");Ada.Text_IO.Put_Line(Integer'Image(Fib(X)));endFib;

Iterative, build-in integers

withAda.Text_IO;useAda.Text_IO;procedureTest_FibonacciisfunctionFibonacci(N:Natural)returnNaturalisThis:Natural:=0;That:Natural:=1;Sum:Natural;beginforIin1..NloopSum:=This+That;That:=This;This:=Sum;endloop;returnThis;endFibonacci;beginforNin0..10loopPut_Line(Positive'Image(Fibonacci(N)));endloop;endTest_Fibonacci;

Output:

 0 1 1 2 3 5 8 13 21 34 55

Iterative, long integers

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

withAda.Text_IO,Ada.Command_Line,Crypto.Types.Big_Numbers;procedureFibonacciisX: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.packageLNis newCrypto.Types.Big_Numbers(Bit_Length+(32- Bit_Length mod 32));-- the actual number of bits has to be a multiple of 32useLN;functionFib(P:Positive)returnBig_UnsignedisPrevious:Big_Unsigned:=Big_Unsigned_Zero;Result:Big_Unsigned:=Big_Unsigned_One;Tmp:Big_Unsigned;begin-- Result = 1 = Fibonacci(1)forIin1..P-1loopTmp:=Result;Result:=Previous+Result;Previous:=Tmp;-- Result = Fibonacci(I+1))endloop;returnResult;endFib;beginAda.Text_IO.Put("Fibonacci("&Integer'Image(X)&" ) = ");Ada.Text_IO.Put_Line(LN.Utils.To_String(Fib(X)));endFibonacci;

Output:

> ./fibonacci 777Fibonacci( 777 ) = 1081213530912648191985419587942084110095342850438593857649766278346130479286685742885693301250359913460718567974798268702550329302771992851392180275594318434818082

Fast method using fast matrix exponentiation

withada.text_io;useada.text_io;procedurefast_fibois-- We work with biggest natural integers in a 64 bits machinetypeBig_Intismod2**64;-- We provide an index type for accessing the fibonacci sequence termstypeIndexisnewBig_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)generictypering_elementismod<>;withfunction"*"(a,b:ring_element)returnring_elementis<>;functionfibo(n:Index)returnring_element;functionfibo(n:Index)returnring_elementistypematrixisarray(1..2,1..2)ofring_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 2f:constantmatrix:=(1=>(0,1),2=>(1,1));function"*"(a,b:matrix)returnmatrixis(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)));functionsquare(m:matrix)returnmatrixis(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)functionfast_pow(m:matrix;n:Index)returnmatrixis(ifn=0then(1=>(1,0),2=>(0,1))-- = identity matrixelsifnmod2=0thensquare(fast_pow(m,n/2))elsem*square(fast_pow(m,n/2)));beginreturnfast_pow(f,n)(2,1);endfibo;functionBig_Int_Fiboisnewfibo(Big_Int);begin-- calculate instantly F_n with n=10^15 (modulus 2^64 )put_line(Big_Int_Fibo(10**15)'img);endfast_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, tempfwhile (--n>0)tempf:=fnow+fnextfnow:=fnextfnext:=tempfend whilereturn(fnext)

Agda

moduleFibonacciSequencewhereopenimportData.Natusing(ℕ;zero;suc;_+_)rec_fib:(m:ℕ)->(a:ℕ)->(b:ℕ)->ℕrec_fibzeroab=arec_fib(suck)ab=rec_fibkb(a+b)fib:(n:ℕ)->ℕfibn=rec_fibnzero(suczero)

Aime

integerfibs(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 release1.18.0-9h.tiny

Works with:ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release1.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 release1.18.0-9h.tiny

Works with:ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release1.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 release1.18.0-9h.tiny

Works with:ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release1.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 originalPython coding style.

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

Works with:ALGOL 68G version Any - tested with release1.18.0-9h.tiny

Works with:ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release1.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 release1.18.0-9h.tiny

Works with:ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release1.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    getFibonaccinumberwithiterativemodeofBegin  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.EndSubrutinesfibonacci_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 )Returnfibonacci_iterative(n)  A=0  B=1  For Up( I:=2, n, 1 )    C=B    Let ( B: = var(A) Plus (B) )    A=C  NextReturn(B)

Output:

$ hopper src/fibo1.bas 25750257502575025

AntLang

/Sequencefib:{<0;1> {x,<x[-1]+x[-2]>}/ range[x]}/nthfibn:{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 sequencefinal 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

The idomatic array way:

fib←{⍵≤1:⍵⋄(+/∇¨⍵-12}

or the scalar way:

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

This naive solution requires Dyalog APL or April 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:

{\displaystyle {\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/⊂22⍴1110

Plugging in 4 for N gives the following result:

{\displaystyle {\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.TheFirst removes the shell from theEnclose.At this point we're basically done, but we need to pick out only ${\displaystyle F_{n}}$ in order to complete the task. Here's one way:

↑01↓↑+.×/N/⊂22⍴1110

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

setfibsto{}setxto(text returnedof(display dialog"What fibbonaci number do you want?"defaultanswer"3"))setxtoxasintegerrepeatwithyfrom1toxif(y=1ory=2)thencopy1totheendoffibselsecopy((item(y-1)offibs)+(item(y-2)offibs))totheendoffibsendifendrepeatreturnitemxoffibs

Functional

The simple recursive version is famously slow:

onfib(n)ifn<1then0elseifn<3then1elsefib(n-2)+fib(n-1)endifendfib

but we can combineenumFromTo(m, n) with the accumulator of a higher-orderfold/reduce function to memoize the series:

Translation of:JavaScript

(ES6 memoized fold example)

Translation of:Haskell

(Memoized fold example)

-------------------- FIBONACCI SEQUENCE ---------------------- fib :: Int -> Intonfib(n)-- lastTwo : (Int, Int) -> (Int, Int)scriptlastTwoon|λ|([a,b])[b,a+b]end|λ|endscriptitem1offoldl(lastTwo,{0,1},enumFromTo(1,n))endfib--------------------------- TEST ---------------------------onrunfib(32)--> 2178309endrun-------------------- GENERIC FUNCTIONS ----------------------- enumFromTo :: Int -> Int -> [Int]onenumFromTo(m,n)ifm≤nthensetlstto{}repeatwithifrommtonsetendoflsttoiendrepeatlstelse{}endifendenumFromTo-- foldl :: (a -> b -> a) -> a -> [b] -> aonfoldl(f,startValue,xs)tellmReturn(f)setvtostartValuesetlngtolengthofxsrepeatwithifrom1tolngsetvto|λ|(v,itemiofxs,i,xs)endrepeatreturnvendtellendfoldl-- Lift 2nd class handler function into 1st class script wrapper-- mReturn :: Handler -> ScriptonmReturn(f)ifclassoffisscriptthenfelsescriptproperty|λ|:fendscriptendifendmReturn

Output:

Arendelle

( fibonacci , 1; 1 )[ 98 , // 100 numbers of fibonacci( fibonacci[ @fibonacci? ] ,@fibonacci[ @fibonacci - 1 ] + @fibonacci[ @fibonacci - 2 ])"Index: | @fibonacci? | => | @fibonacci[ @fibonacci? - 1 ] |"]

ArkScript

Works with:ArkScript version 3.x

Recursive solution:

(let fibo (fun (n)  (if (< n 2)    n    (+ (fibo (- n 1)) (fibo (- n 2))))))(assert (= 6765 (fibo 20)) "(fibo 20) == 6765")

Iterative solution:

(let fibo (fun (n) {  (mut i 0)  (mut a 0)  (mut b 1)  (while (< i n) {    (let c (+ a b))    (set a b)    (set b c)    (set i (+ 1 i)) })  a }))(assert (= 6765 (fibo 20)) "(fibo 20) == 6765")

ARM Assembly

Expects to be called with ${\displaystyle n}$ in R0, and will return ${\displaystyle 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 SHOWTIMEHEY CHRISTMAS TREE f1YOU SET US UP @I LIEDTALK TO THE HAND f1HEY CHRISTMAS TREE f2YOU SET US UP @NO PROBLEMOHEY CHRISTMAS TREE f3YOU SET US UP @I LIEDSTICK AROUND @NO PROBLEMOGET TO THE CHOPPER f3HERE IS MY INVITATION f1GET UP f2ENOUGH TALKTALK TO THE HAND f3GET TO THE CHOPPER f1HERE IS MY INVITATION f2ENOUGH TALKGET TO THE CHOPPER f2HERE IS MY INVITATION f3ENOUGH TALKCHILLYOU HAVE BEEN TERMINATED

Arturo

Recursive

fib:$[x][switchx<2->1->(fibx-1)+(fibx-2)]loop1..25[x][print["Fibonacci of"x"="fibx]]

Iterative

fib:function[n][ifn<2->return1a:1b:1loop2..n'x[tmp:a+ba:bb:tmp]returnb]loop1..25'x[print["Fibonacci of"x"="fibx]]

Output:

Fibonacci of 1 = 1 Fibonacci of 2 = 2 Fibonacci of 3 = 3 Fibonacci of 4 = 5 Fibonacci of 5 = 8 Fibonacci of 6 = 13 Fibonacci of 7 = 21 Fibonacci of 8 = 34 Fibonacci of 9 = 55 Fibonacci of 10 = 89 Fibonacci of 11 = 144 Fibonacci of 12 = 233 Fibonacci of 13 = 377 Fibonacci of 14 = 610 Fibonacci of 15 = 987 Fibonacci of 16 = 1597 Fibonacci of 17 = 2584 Fibonacci of 18 = 4181 Fibonacci of 19 = 6765 Fibonacci of 20 = 10946 Fibonacci of 21 = 17711 Fibonacci of 22 = 28657 Fibonacci of 23 = 46368 Fibonacci of 24 = 75025 Fibonacci of 25 = 121393

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 *)funfib_trec(n: int): int =ifn > 0then (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]funfibats{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@ypeint3_t0ype =  (int, int, int)//typedef int3 = int3_t0ype//(* ****** ****** *)externfun int3 : (int, int, int) -<> int3externfun int3_1 : int3 -<> intexternfun mul_int3_int3: (int3, int3) -<> int3(* ****** ****** *)localassumeint3_t0ype = (int, int, int)in (* in-of-local *)//implementint3 (x, y, z) = @(x, y, z)//implement int3_1 (xyz) = xyz.1//implementmul_int3_int3(  @(a,b,c), @(d,e,f)) =  (a*d + b*e, a*e + b*f, b*e + c*f)//end // end of [local](* ****** ****** *)//implementgnumber_int<int3> (n) = int3(n, 0, n)//implement gmul_val<int3> = mul_int3_int3//(* ****** ****** *)//funfib (n: intGte(0)): int =  int3_1(gpow_int_val<int3> (n, int3(1, 1, 0)))//(* ****** ****** *)implementmain0 () ={//val N = 10val () = println! ("fib(", N, ") = ", fib(N))val N = 20val () = println! ("fib(", N, ") = ", fib(N))val N = 30val () = println! ("fib(", N, ") = ", fib(N))val N = 40val () = println! ("fib(", N, ") = ", fib(N))//} (* end of [main0] *)

AutoHotkey

Search autohotkey.com:sequence

Iterative

Translation of:C

Loop,5MsgBox%fib(A_Index)Returnfib(n){If(n<2)Returnni:=last:=this:=1While(i<=n){new:=last+thislast:=thisthis:=newi++}Returnthis}

Recursive and iterative

Source:AutoHotkey forum by Laszlo

/*Important note: the recursive version would be very slowwithout a global or static array. The iterative versionhandles also negative arguments properly.*/FibR(n){       ; n-th Fibonacci number (n>=0, recursive with static array Fibo)StaticReturnn<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:=1Loop%abs(n)-1c:=b,b+=a,a:=cReturnn=0?0:n>0||n&1?b:-b}

AutoIt

Iterative

#AutoItVersion:3.2.10.0$n0=0$n1=1$n=10MsgBox(0,"Iterative Fibonacci ",it_febo($n0,$n1,$n))Funcit_febo($n_0,$n_1,$N)$first=$n_0$second=$n_1$next=$first+$second$febo=0For$i=1To$N-3$first=$second$second=$next$next=$first+$secondNextif$n==0Then$febo=0ElseIf$n==1Then$febo=$n_0ElseIf$n==2Then$febo=$n_1Else$febo=$nextEndIfReturn$feboEndFunc

Recursive

#AutoItVersion:3.2.10.0$n0=0$n1=1$n=10MsgBox(0,"Recursive Fibonacci ",rec_febo($n0,$n1,$n))Funcrec_febo($r_0,$r_1,$R)if$R<3Thenif$R==2ThenReturn$r_1ElseIf$R==1ThenReturn$r_0ElseIf$R==0ThenReturn0EndIfReturn$RElseReturnrec_febo($r_0,$r_1,$R-1)+rec_febo($r_0,$r_1,$R-2)EndIfEndFunc

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)}'10fib(10)=55

Axe

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

Iterative solution:

Lbl FIBr₁→N0→I1→JFor(K,1,N) I+J→T J→I T→JEndJReturn

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));doecho$fib;((k=fib+j,fib=j,j=k));done

1123581321345589

Recursive

fib(){if[$1-le0]thenecho0return0fiif[$1-le2]thenecho1elsea=$(fib$[$1-1])b=$(fib$[$1-2])echo$(($a+$b))fi}

BASIC

ANSI BASIC

Translation of:MoonRock

Works with:Decimal BASIC

100REM Fibonacci sequence110DECLAREEXTERNALFUNCTIONFib120INPUTPROMPT"Enter n for fib(n): ":N130PRINTFib(N)140END150REM ***160EXTERNALFUNCTIONFib(N)170IFN=0THEN180LETFib=0190ELSEIFN=1THEN200LETFib=1210ELSE220LETPrev=0230LETCurr=1240FORI=2TON250LETT=Curr260LETCurr=Prev+Curr270LETPrev=T280NEXTI290LETFib=Curr300ENDIF310ENDFUNCTION

Output:

2 runs.

Enter n for fib(n): 9 34

Enter n for fib(n): 13 233

Applesoft BASIC

Iterative

Same code asCommodore BASIC. Entering a value of -184 < N > 183, produces an error message:

?OVERFLOW ERROR IN 220

Binet's Formula

0DEFFNF(N)=INT((((1+SQR(5))/2)^N-((1-SQR(5))/2)^N)/SQR(5)+0.5)1S=-38:FORI=STO-S:PRINTMID$(" ",(I=S)+1)FNF(I);:NEXT

-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 24157818 39088170

Entering a value of -38 < N > 38, produces an incorrect result due to inadequate precision in the calculation.The correct result for N = 39 should be 63245986.Entering a value of -44 < N > 44, produces a result in scientific notation.Entering a value of -182 < N > 182, produces an error message.

?FNF(39)" "FNF(45)" "FNF(183)

63245988 1.1349032E+09 ?OVERFLOW ERROR

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 numberinput "N = ",flimit = 500                        # set upper limit - can be changed, removedf = int(f)if f > limit then f = limit        a = 0 : b = 1 : c = 0 : n = 0      # initial valueswhile n < f    print n + chr(9) + c   # chr(9) = tab    a = b    b = c    c = a + b      n += 1        end whileprint " "print n + chr(9) + c

BBC BASIC

PRINTFNfibonacci_r(1),FNfibonacci_i(1)PRINTFNfibonacci_r(13),FNfibonacci_i(13)PRINTFNfibonacci_r(26),FNfibonacci_i(26)ENDDEFFNfibonacci_r(N)IFN<2THEN=N=FNfibonacci_r(N-1)+FNfibonacci_r(N-2)DEFFNfibonacci_i(N)LOCALF,I,P,TIFN<2THEN=NP=1FORI=1TONT=FF+=PP=TNEXT=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.

10print"Enter a ";20print"number ";30print"greater ";40print"than 1";50print" and less";60print" than 25";70inputz80b=190a=0100n=2110f=a+b120a=b130b=f140n=n+1150ifn-z-1goto110160print"The ";170printz;180print"th ";190print"Fibonacci ";200print"Number is ";210printf

CBASIC

Works with:CBASIC 2

Works with:CB80

Since CBASIC does not support recursion, only an iterative solution is possible

deffn.fib%(n%)p1%=0p2%=1ifn%=0then\f%=0\else\fori%=1ton%f%=p1%+p2%p2%=p1%p1%=f%nexti%fn.fib%=f%returnfendprint"First 20 Fibonacci numbers:"fork%=1to20printfn.fib%(k%);nextk%end

Output:

First 20 Fibonacci numbers 1 1 2 3 5 8 13 21 34 55 89 144 233 370 610 987 1597 2584 4181 6765

Chipmunk Basic

Works with:Chipmunk Basic version 3.6.4

100cls110fori=0to20:printfibor(i);:nexti120print130fori=0to20:printfiboi(i);:nexti140print150fori=0to20:printfiboa(i);:nexti160end170subfibor(n):'Recursive180ifn<2then190fibor=n200else210fibor=fibor(n-1)+fibor(n-2)220endif230endsub240subfiboi(n):'Iterative250n1=0260n2=1270fork=1toabs(n)280sum=n1+n2290n1=n2300n2=sum310nextk320ifn<0then330fiboi=n1*((-1)^((-n)+1))340else350fiboi=n1360endif370endsub380subfiboa(n):'Analytic390fiboa=int(0.5+(((sqr5+1)/2)^n)/sqr5)400endsub

Output:

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

Commodore BASIC

100PRINTCHR$(147);CHR$(18);"****      FIBONACCI GENERATOR       ****"110INPUT"MIN, MAX";N1,N2120IFN1>N2THENT=N1:N1=N2:N2=T130A=0:B=1:S=SGN(N1)140FORI=STON1STEPS150:IFS>0THENT=A+B:A=B:B=T160:IFS<0THENT=B-A:B=A:A=T170NEXTI180PRINT190PRINTSTR$(A);:REMSTR$()PREVENTSTRAILINGSPACE200IFN2=N1THEN250210FORI=N1+1TON2220:T=A+B:A=B:B=T230:PRINT",";STR$(A);240NEXTI250PRINT

Output:

****      FIBONACCI GENERATOR       ****MIN, MAX? -6,6-8, 5,-3, 2,-1, 1, 0, 1, 1, 2, 3, 5, 8READY.

Craft Basic

leta=1letb=1print"Fibonacci Sequence"fori=0to20lets=a+bleta=bletb=sprintsnexti

Output:

Fibonacci Sequence2 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  WindowsDimSharedADDQmod(0To19)AsUbyteDimSharedADDbool(0To19)AsUbyteForzAsInteger=0To19ADDQmod(z)=(zMod10+48)ADDbool(z)=(-(10<=z))NextzFunctionplusINT(NUM1AsString,NUM2AsString)AsStringDimAsByteflag#macrofinish()three=Ltrim(three,"0")Ifthree=""ThenReturn"0"Ifflag=1ThenSwapNUM2,NUM1ReturnthreeExitFunction#endmacrovarlenf=Len(NUM1)varlens=Len(NUM2)Iflens>lenfThenSwapNUM2,NUM1Swaplens,lenfflag=1EndIfvardiff=lenf-lens-Sgn(lenf-lens)varthree="0"+NUM1vartwo=String(lenf-lens,"0")+NUM2DimAsIntegern2DimAsUbyteaddup,addcarryaddcarry=0Forn2=lenf-1TodiffStep-1addup=two[n2]+NUM1[n2]-96three[n2+1]=addQmod(addup+addcarry)addcarry=addbool(addup+addcarry)Nextn2Ifaddcarry=0Thenfinish()EndIfIfn2=-1Thenthree[0]=addcarry+48finish()EndIfForn2=n2To0Step-1addup=two[n2]+NUM1[n2]-96three[n2+1]=addQmod(addup+addcarry)addcarry=addbool(addup+addcarry)Nextn2three[0]=addcarry+48finish()EndFunctionFunctionfibonacci(nAsInteger)AsStringDimAsStringsl,l,termsl="0":l="1"Ifn=1ThenReturn"0"Ifn=2ThenReturn"1"n=n-2ForxAsInteger=1Tonterm=plusINT(l,sl)sl=ll=termNextxFunction=termEndFunction'==============  EXAMPLE ===============print"THE SEQUENCE TO 10:"printFornAsInteger=1To10Print"term";n;": ";fibonacci(n)Nextnprintprint"Selected Fibonacci number"print"Fibonacci 500"printprintfibonacci(500)Sleep

Output:

THE SEQUENCE TO 10:term 1: 0term 2: 1term 3: 1term 4: 2term 5: 3term 6: 5term 7: 8term 8: 13term 9: 21term 10: 34Selected Fibonacci numberFibonacci 50086168291600238450732788312165664788095941068326060883324529903470149056115823592713458328176574447204501

FTCBASIC

definea=1,b=1,s=0,i=0clsprint"Fibonacci Sequence"dolets=a+bleta=bletb=s+1iprintsloopi<20pauseend

GFA Basic

'' Compute nth Fibonacci number'' open a window for displayOPENW 1CLEARW 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%  ENDSELECTENDFUNC

GW-BASIC

Works with:BASICA

Iterative

10' SAVE"FIBONA", A20' Secuencia de Fibonacci30' Var40DEFDBLD50IMAXFIBO%=7660DNUM1=1:DNUM2=DNUM170CLS80PRINT"Este programa calcula la serie de Fibonacci."90PRINTDNUM1;DNUM2;100FORI%=1TOIMAXFIBO%110DNUM3=DNUM1+DNUM2120PRINTDNUM3;130DNUM1=DNUM2:DNUM2=DNUM3140NEXTI%150PRINT160PRINT"Fin de la ejecución del programa."170END

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  8944394323791464Fin de la ejecución del programa.Ok

Binet formula

10' SAVE"FIBINF", A20' Secuencia de Fibonacci mediante la fórmula de Binet30' Var40DEFDBLD50IMAXFIBO%=7760DSQR5=SQR(5)70DPIV1=(1+DSQR5)/280DPIV2=(1-DSQR5)/290DNUM1=DPIV1:DNUM2=DPIV2100CLS110PRINT"Este programa calcula la serie de Fibonacci."120FORI%=1TOIMAXFIBO%130DNUM1=DNUM1*DPIV1140DNUM2=DNUM2*DPIV2150PRINTFIX(((DNUM1-DNUM2)/DSQR5)+.5);160NEXTI%170PRINT180PRINT"Fin de la ejecución del programa."190END

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  8944401270367342Fin de la ejecución del programa.Ok

Integer BASIC

Only works with quite small values of ${\displaystyle n}$ .

10INPUTN20A=030B=140FORI=2TON50C=B60B=A+B70A=C80NEXTI90PRINTB100END

IS-BASIC

100 PROGRAM "Fibonac.bas"110 FOR I=0 TO 20120   PRINT "F";I,FIB(I)130 NEXT140 DEF FIB(N)150   NUMERIC I160   LET A=0:LET B=1170   FOR I=1 TO N180     LET T=A+B:LET A=B:LET B=T190   NEXT200   LET FIB=A210 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 ifend function function fiboI(n)    a = 0    b = 1    for i = 1 to n        temp = a + b        a = b        b = temp    next i    fiboI = aend function

Output:

0             01             11             12             23             35             58             813            1321            2134            3455            5589            89144           144233           233377           377610           610

Iterative/Negative

Works with:Just BASIC

print "Rosetta Code - Fibonacci sequence": printprint "  n             Fn"for x=-12 to 12 '68 max    print using("### ", x); using("##############", FibonacciTerm(x))next xprint[start]input "Enter a term#: "; n$n$=lower$(trim$(n$))if n$="" then print "Program complete.": endprint 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 selectend 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            144Enter a term#: 12144Enter 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

110REM THE ARRAY F HOLDS THE FIBONACCI NUMBERS120DIMF(22)130LETF(0)=0140LETF(1)=1150LETN=1160REM COMPUTE THE NEXT FIBBONACCI NUMBER170LETF(N+1)=F(N)+F(N-1)180LETN=N+1190PRINTF(N-2);200REM STOP AFTER PRINTING  20 NUMBERS210IFN<22THEN170220END

MoonRock

Works with:MoonRock version 0.50

MoonRock 0.50 does not support functions. So, a subroutine is written.

' Fibonacci sequenceBEGINDEFpointerdwordFibPtr~' Why "pointer dword" must be in lower case?SUBCalcFib(N%,FibPtr~)BEGINCODEPRINT"Enter n for fib(n): "INPUTSN$N%=VAL(SN$)PRINT"\n"CALLCalcFib(N%,VARPTR(Fib&))PRINTFib&+"\n"ENDSUBCalcFib(N%,FibPtr~)IFN%=0THENFib&=0ELSEIFN%=1THENFib&=1ELSEPrev&=0Fib&=1FORI%=2TON%T&=Fib&Fib&=Prev&+Fib&Prev&=T&NEXTENDIFENDIF[FibPtr~]=Fib&ENDSUB

Output:

2 runs.

Enter n for fib(n): 934

Enter n for fib(n): 13233

MSX Basic

Works with:QBasic

Works with:Chipmunk Basic

Works with:GW-BASIC

100CLS110FORN=0TO15:GOSUB130:PRINTFIBOI;:NEXTN120END130REM Iterative Fibonacci sequence140N1=0150N2=1160FORK=1TOABS(N)170SUM=N1+N2180N1=N2190N2=SUM200NEXTK210IFN<0THENFIBOI=N1*((-1)^((-N)+1))ELSEFIBOI=N1220RETURN

Palo Alto Tiny BASIC

10REM FIBONACCI SEQUENCE20INPUT"ENTER N FOR FIB(N)"N30LETA=0,B=140FORI=2TON50LETT=B,B=A+B,A=T60NEXTI70PRINTB80STOP

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 1100087778366101930F(89) 1779979416004714189 1779979416004714190F(90) 2880067194370816120 2880067194370816120F(91) 4660046610375530309 4660046610375530310F(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 SELECTEND FUNCTIONFUNCTION 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    CLOSEEND FUNCTION

PureBasic

Macro based calculation

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

Recursive

ProcedureFibonacciReq(n)Ifn<2ProcedureReturnnElseProcedureReturnFibonacciReq(n-1)+FibonacciReq(n-2)EndIfEndProcedure

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) Speedup20           225          2330         21740       2584746     1156741

ProcedureFibonacci(n)StaticNewMapFib.i()ProtectedFirstRecursionIfMapSize(Fib())=0;InitthehashtablethefirstrunFib("0")=0:Fib("1")=1FirstRecursion=#TrueEndIfIfn>=2Protected.ss=Str(n)IfNotFindMapElement(Fib(),s);CalculateonlyneededpartsFib(s)=Fibonacci(n-1)+Fibonacci(n-2)EndIfn=Fib(s)EndIfIfFirstRecursion;FreethememorywhenfinalizingthefirstcallClearMap(Fib())EndIfProcedureReturnnEndProcedure

Example

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

QB64

CBTJD: 2020/03/13

_DEFINEFAS_UNSIGNED_INTEGER64CLSPRINTPRINT"Enter 40 to more easily see the difference in calculation speeds."PRINTINPUT"Enter n for Fibonacci(n): ",nPRINTPRINT" 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)FUNCTIONfA(n)fA=INT(0.5+(((SQR(5)+1)/2)^n)/SQR(5))ENDFUNCTION' === Iterative Fibonacci Function (Fast)FUNCTIONfI(n)FORi=1TOnIFi<3THENa=1:b=1t=fI+b:fI=b:b=tNEXTENDFUNCTION' === Recursive Fibonacci function (Slow)FUNCTIONfR(n)IFn<=1THENfR=nELSEfR=fR(n-1)+fR(n-2)ENDIFENDFUNCTION

Fibonacci from Russia

DIMF(80)ASDOUBLE'FibRus.bas DANILINF(1)=0:F(2)=1'OPEN "FibRus.txt" FOR OUTPUT AS #1FORi=3TO80F(i)=F(i-1)+F(i-2)NEXTiFORi=1TO80f$=STR$(F(i)):LF=22-LEN(f$)n$=""FORj=1TOLF:n$=" "+n$:NEXTf$=n$+f$PRINTi,f$:' PRINT #1, i, f$NEXTi

Output:

1                                 02                                 13                                 14                                 25                                 36                                 57                                 88                                139                                21...24                            2865725                            4636826                            75025...36                          922746537                         1493035238                         24157817...48                       297121507349                       480752697650                       7778742049...60                     95672202604161                    154800875592062                    2504730781961...76                 211148507797805077                 341645462290670778                 552793970088475779                 894439432379146480            1.447233402467622D+16

QBasic

Works with:QBasic

Works with:FreeBASIC

Iterative

FUNCTIONitFib(n)n1=0n2=1FORk=1TOABS(n)sum=n1+n2n1=n2n2=sumNEXTkIFn<0THENitFib=n1*((-1)^((-n)+1))ELSEitFib=n1ENDIFENDFUNCTION

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

DECLAREFUNCTIONfibonacci&(nASINTEGER)REDIMSHAREDfibNum(1)ASLONGfibNum(1)=1'*****sample inputs*****PRINTfibonacci(0)'no calculation neededPRINTfibonacci(13)'figure F(2)..F(13)PRINTfibonacci(-42)'figure F(14)..F(42)PRINTfibonacci(47)'error: too big'*****sample inputs*****FUNCTIONfibonacci&(nASINTEGER)DIMaASINTEGERa=ABS(n)SELECT CASEaCASE0TO46SHAREDfibNum()ASLONGDIMuASINTEGER,L0ASINTEGERu=UBOUND(fibNum)IFa>uTHENREDIMPRESERVEfibNum(a)ASLONGFORL0=u+1TOafibNum(L0)=fibNum(L0-1)+fibNum(L0-2)NEXTENDIFIFn<0THENfibonacci=fibNum(a)*((-1)^(a+1))ELSEfibonacci=fibNum(n)ENDIFCASEELSE'limited to signed 32-bit int (LONG)'F(47)=&hB11924E1ERROR6'overflowENDSELECTENDFUNCTION

Output:

(unhandled error in final input prevents output)

 0 233-267914296

Recursive

This example can't handle n < 0.

FUNCTIONrecFib(n)IF(n<2)THENrecFib=nELSErecFib=recFib(n-1)+recFib(n-2)ENDIFENDFUNCTION

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,-102334155DATA63245986,-39088169,24157817,-14930352,9227465,-5702887,3524578,-2178309DATA1346269,-832040,514229,-317811,196418,-121393,75025,-46368,28657,-17711DATA10946,-6765,4181,-2584,1597,-987,610,-377,233,-144,89,-55,34,-21,13,-8,5,-3DATA2,-1,1,0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765DATA10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269DATA2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986DATA102334155,165580141,267914296,433494437,701408733,1134903170,1836311903DIMfibNum(-46TO46)ASLONGFORn=-46TO46READfibNum(n)NEXT'*****sample inputs*****FORn=-46TO46PRINTfibNum(n),NEXTPRINT'*****sample inputs*****

Quite BASIC

100CLS110remThearrayFholdstheFibonaccinumbers120ARRAYf:remDIMf(22)paraQuiteBASICandMSX-BASIC130LETf(0)=0140LETf(1)=1150LETn=1160remComputetheNEXTFibbonaccinumber170LETf(n+1)=f(n)+f(n-1)180LETn=n+1190PRINTf(n-2);" ";200remSTOPafterprinting20numbers210IFn<22THENGOTO170

Run BASIC

for i = 0 to 10 print i;" ";fibR(i);" ";fibI(i)next iend  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 ifibI = aend 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-iterativefunctiontocalculatenthfibonaccinumberfunctionfibonacci(n=integer)=integervarf,i,p1,p2=integerp1=0p2=1ifn=0thenf=0elsefori=1tonf=p1+p2p2=p1p1=fnextiend=frem-exercisethefunctionvari=integerfori=0to10printfibonacci(i);nextiend

Output:

 0 1 1 2 3 5 8 13 21 34 55

Sinclair ZX81 BASIC

Analytic

10INPUTN20PRINTINT(0.5+(((SQR5+1)/2)**N)/SQR5)

Iterative

10INPUTN20LETA=030LETB=140FORI=2TON50LETC=B60LETB=A+B70LETA=C80NEXTI90PRINTB

Tail recursive

10INPUTN20LETA=030LETB=140GOSUB7050PRINTB60STOP70IFN=1THENRETURN80LETC=B90LETB=A+B100LETA=C110LETN=N-1120GOSUB70130RETURN

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

FORi=0TO15PRINTfibR(i),fibI(i),fibN(i)NEXTi/*RecursiveMethod*/DEFfibR(n)IFn<=1THENfibR=nELSEfibR=fibR(n-1)+fibR(n-2)ENDIFENDDEF/*IterativeMethod*/DEFfibI(n)a=0b=1FORi=1TOntemp=a+ba=bb=tempNEXTifibI=aENDDEF/*N-thTermMethod*/DEFfibN(n)uphi=.5+SQR(5)/2lphi=.5-SQR(5)/2fibN=(uphi^n-lphi^n)/SQR(5)ENDDEF

Softbridge BASIC

Iterative

FunctionFibonacci(n)x=0y=1i=0n=ABS(n)Ifn<2ThenFibonacci=nElseDoUntil(i=n)sum=x+yx=yy=sumi=i+1LoopFibonacci=xEndIfEndFunction

TI-83 BASIC

Sequence table

[Y=]nMin=0u(n)=u(n-1)+u(n-2)u(nMin)={1,0}[TABLE]nu(n)--------------001121324355687138219341055118912144

Iterative

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

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 forn 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)FuncLocal a,b,c,i0→a1→bFor i,1,n  a→c  b→a  c+b→bEndForaEndFunc

Tiny BASIC

Works with:TinyBasic

10LETA=020LETB=130PRINT"Which F_n do you want?"40INPUTN50IFN=0THENGOTO14060IFN=1THENGOTO12070LETC=B+A80LETA=B90LETB=C100LETN=N-1110GOTO60120PRINTB130END140PRINT0150END

True BASIC

FUNCTIONfibonacci(n)LETn1=0LETn2=1FORk=1TOABS(n)LETsum=n1+n2LETn1=n2LETn2=sumNEXTkIFn<0THENLETfibonacci=n1*((-1)^((-n)+1))ELSELETfibonacci=n1ENDIFENDFUNCTIONPRINTfibonacci(0)!0PRINTfibonacci(13)!233PRINTfibonacci(-42)!-267914296PRINTfibonacci(47)!2971215073END

VBA

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

PublicFunctionFib(ByValnAsInteger)AsVariantDimfib0AsVariant,fib1AsVariant,sumAsVariantDimiAsIntegerfib0=0fib1=1Fori=1Tonsum=fib0+fib1fib0=fib1fib1=sumNextiFib=fib0EndFunction

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:

classgeneratordimt1dimt2dimtndimcur_overflowPrivateSubClass_Initializecur_overflow=falset1=ccur(0)t2=ccur(1)tn=ccur(t1+t2)endsubpublicdefaultpropertygetgeneratedonerrorresumenextgenerated=ccur(tn)iferr.number<>0thengenerated=cdbl(tn)cur_overflow=trueendift1=ccur(t2)iferr.number<>0thent1=cdbl(t2)cur_overflow=trueendift2=ccur(tn)iferr.number<>0thent2=cdbl(tn)cur_overflow=trueendiftn=ccur(t1+t2)iferr.number<>0thentn=cdbl(t1)+cdbl(t2)cur_overflow=trueendifonerrorgoto0endpropertypublicpropertygetoverflowoverflow=cur_overflowendpropertyendclass

Invocation:

dimfibsetfib=newgeneratordimifori=1to100wscript.stdout.write" "&fibiffib.overflowthenwscript.echoexitforendifnext

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.

Subfibonacci()Constn=139DimiAsIntegerDimf1AsVariant,f2AsVariant,f3AsVariant'for Decimalf1=CDec(0):f2=CDec(1)'for Decimal settingDebug.Print"fibo(";0;")=";f1Debug.Print"fibo(";1;")=";f2Fori=2Tonf3=f1+f2Debug.Print"fibo(";i;")=";f3f1=f2f2=f3NextiEndSub'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).

FunctionFib(ByValnAsInteger)AsDecimalDimfib0,fib1,sumAsDecimalDimiAsIntegerfib0=0fib1=1Fori=1Tonsum=fib0+fib1fib0=fib1fib1=sumNextFib=fib0EndFunction

Recursive

Works with:Visual Basic .NET version 9.0+

FunctionSeq(ByValTermAsInteger)IfTerm<2ThenReturnTermReturnSeq(Term-1)+Seq(Term-2)EndFunction

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.

FunctionFiboBig(ByValnAsInteger)AsBigInteger' Fibonacci sequence with BigIntegerDimfibn2,fibn1,fibnAsBigIntegerDimiAsIntegerfibn=0fibn2=0fibn1=1Ifn=0ThenReturnfibn2ElseIfn=1ThenReturnfibn1ElseIfn>=2ThenFori=2Tonfibn=fibn2+fibn1fibn2=fibn1fibn1=fibnNextiReturnfibnEndIfReturn0EndFunction'FiboBigSubfibotest()DimiAsInteger,sAsStringi=2000000' 2 millionss=FiboBig(i).ToStringConsole.WriteLine("fibo("&i&")="&s&" - length="&Len(s))EndSub'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 fromhere, see section 3,Finding Fibonacci Numbers Fully.

ImportsSystemImportsSystem.Collections.GenericImportsBI=System.Numerics.BigIntegerModuleModule1' A sparse array of values calculated along the wayDimslAsSortedList(OfInteger,BI)=NewSortedList(OfInteger,BI)()' Square a BigIntegerFunctionsqr(ByValnAsBI)AsBIReturnn*nEndFunction' Helper routine for Fsl(). It adds an entry to the sorted list when necessarySubIfNec(nAsInteger)IfNotsl.ContainsKey(n)Thensl.Add(n,Fsl(n))EndSub' 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#section3FunctionFsl(ByValnAsInteger)AsBIIfn<2ThenReturnnDimn2AsInteger=n>>1,pmAsInteger=n2+((nAnd1)<<1)-1:IfNec(n2):IfNec(pm)ReturnIf(n2>pm,(2*sl(pm)+sl(n2))*sl(n2),sqr(sl(n2))+sqr(sl(pm)))EndFunction' Conventional iteration method (not used here)FunctionFm(ByValnAsBI)AsBIIfn<2ThenReturnnDimcurAsBI=0,preAsBI=1ForiAsInteger=0Ton-1DimsumAsBI=cur+pre:pre=cur:cur=sum:Next:ReturncurEndFunctionSubMain()DimvlenAsInteger,numAsInteger=2_000_000,digsAsInteger=35DimswAsSystem.Diagnostics.Stopwatch=System.Diagnostics.Stopwatch.StartNew()DimvAsBI=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)Ifvlen<10000Thensw.Restart():Console.WriteLine(v):sw.[Stop]()Console.WriteLine("{0:n3} ms to write it to the console.",sw.Elapsed.TotalMilliseconds)ElseConsole.Write("partial: {0}...{1}",v/BI.Pow(10,vlen-digs),vModBI.Pow(10,digs))EndIfEndSubEndModule

Output:

120.374 ms to calculate the 2,000,000th Fibonacci number, number of digits is 417975partial: 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.

Functionfibo(nAsInteger)AsUInt64DimnoOneAsUInt64=1DimnoTwoAsUInt64=1DimsumAsUInt64ForiAsInteger=3Tonsum=noOne+noTwonoTwo=noOnenoOne=sumNextReturnnoOneEndFunction

Yabasic

Iterative

subfibonacciI(n)localn1,n2,k,sumn1=0n2=1fork=1toabs(n)sum=n1+n2n1=n2n2=sumnextkifn<1thenreturnn1*((-1)^((-n)+1))elsereturnn1endifendsub

Recursive

Only positive numbers

subfibonacciR(n)ifn<=1thenreturnnelsereturnfibonacciR(n-1)+fibonacciR(n-2)endifendsub

Analytic

Only positive numbers

subfibonacciA(n)returnint(0.5+(((sqrt(5)+1)/2)^n)/sqrt(5))endsub

Binet's formula

Fibonacci sequence using the Binet formula

subfibonacciB(n)localsq5,phi1,phi2,dn1,dn2,ksq5=sqrt(5)phi1=(1+sq5)/2phi2=(1-sq5)/2dn1=phi1:dn2=phi2fork=0tondn1=dn1*phi1dn2=dn2*phi2printint(((dn1-dn2)/sq5)+.5);nextkendsub

ZX Spectrum Basic

Iterative

10REM Only positive numbers20LETn=1030LETn1=0:LETn2=140FORk=1TOn50LETsum=n1+n260LETn1=n270LETn2=sum80NEXTk90PRINTn1

Analytic

10DEF FNf(x)=INT(0.5+(((SQR5+1)/2)^x)/SQR5)

Batch File

Recursive version

::fibo.cmd@echo offif"%1"equ""goto:eofcall:fib%1echo%errorlevel%goto:eof:fibsetlocal enabledelayedexpansionif%1geq 2goto:ge2exit /b%1:ge2set/ar1=%1-1set/ar2=%1-2call:fib!r1!setr1=%errorlevel%call:fib!r2!setr2=%errorlevel%set/ar0=r1+r2exit /b!r0!

Output:

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

Battlestar

// Fibonacci sequence, recursive versionfunfibbloopa=funparam[0]break(a<2)a--// Save "a" while calling fibba->stack// Set the parameter and call fibbfunparam[0]=acallfibb// Handle the return value and restore "a"b=funparam[0]stack->a// Save "b" while calling fibb againb->stacka--// Set the parameter and call fibbfunparam[0]=acallfibb// Handle the return value and restore "b"c=funparam[0]stack->b// Sum the resultsb+=ca=bfunparam[0]=abreakendend// vim: set syntax=c ts=4 sw=4 et:

bc

iterative

#!/usr/bin/bc-qdefine fib(x){if(x<=0)return0;if(x==1)return1;    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     = 0F_1     = 1F_2     = 1F_3     = 2F_4     = 3F_5     = 5F_6     = 8F_7     = 13F_8     = 21F_9     = 34F_10    = 55

beeswax

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

Example output:

Notice the UInt64 wrap-around atFib(94)!

julia>beeswax("n-th Fibonacci number.bswx")Entern:i0Fib(0)=0Programfinished!julia>beeswax("n-th Fibonacci number.bswx")Entern:i10Fib(10)=55Programfinished!julia>beeswax("n-th Fibonacci number.bswx")Entern:i92Fib(92)=7540113804746346429Programfinished!julia>beeswax("n-th Fibonacci number.bswx")Entern:i93Fib(93)=12200160415121876738Programfinished!julia>beeswax("n-th Fibonacci number.bswx")Entern:i94Fib(94)=1293530146158671551Programfinished!

Befunge

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

Binary Lambda Calculus

Fibonacci on Church numerals in the lambda calculus isλn. n (λc λa λb.c b (λx.a (b x))) (λx λy.x) (λx.x) (seehttps://github.com/tromp/AIT/blob/master/numerals/fib.lam) which in BLC is the 52 bits

0001010110000000010111101000011110011101000001100010

BlitzMax

locala:int=0,b:int=1,c:int=1,n:intn=int(input("Enter n: "))ifn=0thenprint0endelseifn=1print1endendifwhilen>2a=bb=cc=a+bn=n-1wendprintc

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 containsn (10), the second cell will containfib(n) (55), and the third cell will containfib(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 asciiTo look at results you can pipe into a file and look with a hex editorCopying 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 #1Non 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.newfibonacci = { 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 fibsfibs 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 usingHigherOrder 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

longlongfibb(longlonga,longlongb,intn){return(--n>0)?(fibb(b,a+b,n)):(a);}

Iterative

longlongintfibb(intn){intfnow=0,fnext=1,tempf;while(--n>0){tempf=fnow+fnext;fnow=fnext;fnext=tempf;}returnfnext;}

Analytic

#include<tgmath.h>#define PHI ((1 + sqrt(5))/2)longlongunsignedfib(unsignedn){returnfloor((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>typedefenum{false=0,true=!0}bool;typedefvoiditerator;#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; } }staticvolatilevoid*yield_init;/* not thread safe */#define YIELDS(type) bool (*yield)(type) = yield_inititeratorfibonacci(intstop){YIELDS(int);intf[]={0,1};inti;for(i=0;i<stop;i++){YIELD(f[i%2]);f[i%2]=f[0]+f[1];}}main(){printf("fibonacci: ");FOR(inti,fibonacci(16))DOprintf("%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>typedefstructnodenode;structnode{intn;mpz_tv;node*next;};#define CSIZE 37node*cache[CSIZE];// very primitive linked hash tablenode*find_cache(intn){intidx=n%CSIZE;node*p;for(p=cache[idx];p&&p->n!=n;p=p->next);if(p)returnp;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 yetmpz_init(p->v);}returnp;}mpz_ttmp1,tmp2;mpz_t*fib(intn){intx;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;}intmain(intargc,char**argv){inti,n;if(argc<2)return1;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 printinggmp_printf("%Zd\n",*fib(n));}return0;}

Output:

% ./a.out 0 1 2 3 4 5112358% ./a.out 10000000 | wc -c    # count length of output, including the newline1919488

C#

Recursive

publicstaticulongFib(uintn){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 Russianamespace 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

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

NeedsSystem.Windows.Media.Matrix or similar Matrix class. Calculates in ${\displaystyle 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];}

NeedsSystem.Windows.Media.Matrix or similar Matrix class. Calculates in ${\displaystyle 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 417975partial: 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 6765Fibonacci(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., 2012int 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

Calcscript

(def fib (i)  (eq (any= i 0) 0      (any= i 1) 1      (+ (fib (-1 i)) (fib (- i 2)))))(def loop (r)  (eq (list? (cdr r))    (d (p (fib (car r)))       (loop (cdr r))))    (Same))(loop (range 1 12))

Output:

1123581321345589

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 last1 g this0 g new0 g inputMethod.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 herehttps://www.nayuki.io/page/fast-fibonacci-algorithmsImplementation 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 numbersfib = iter () yields (int)    a: int := 0    b: int := 1        while true do        yield (a)        a, b := b, a+b    endend 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    endend nth% Print a few valuesstart_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)))    endend start_up

Output:

F(0) = 0F(1) = 1F(2) = 1F(3) = 2F(4) = 3F(5) = 5F(6) = 8F(7) = 13F(8) = 21F(9) = 34F(10) = 55F(11) = 89F(12) = 144F(13) = 233F(14) = 377F(20) = 6765F(30) = 832040F(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 FREEIDENTIFICATION 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 = 6a = 1i = 1  # starta      # print resultfib  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 afor 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 useAllegro 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: 3410: 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 apositive 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 fromi-th toj-th element.

Options #2 and #3 can take negative parameters,buti (lowest index in range) must be greaterthanj (highest index in range).

Values are represented internally by a reversedlist that grows from the head (and that's whywe 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 ${\displaystyle n}$ th Fibonacci number, set the initial value ofcount equal to ${\displaystyle 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 ${\displaystyle 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  loopdone:   LDA  y        STPone:         1count:       8      ; n = 10x:           1y:           1temp:        0

Corescript

print Fibonacci Sequence:var previous = 1var number = 0var temp = (blank):fibif number > 50000000000:killprint (number)set temp = (add number previous)set previous = (number)set number = (temp)goto fib:killstop

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;# testvar 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  prevFibend

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_iend

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 +    99194853094755497I :   259695496911122585 <-   160500643816367088 +    99194853094755497O :   259695496911122585 <-   160500643816367088 +    991948530947554970: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-numbersBigInt 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

Basic

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));}

Iterative Approach

Iterable<int> fibonacci(int n) sync* {  int a = 1, b = 1;  for (int i = 0; i < n; i++) {    yield a;    int temp = a;    a = b;    b = temp + b;  }}void main() => print(fibonacci(20));

Output:

(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, ..., 4181, 6765)

Recursive Function

Iterable<int> fibonacci([int n = 1, int m = 1]) sync* {  yield n;  yield* fibonacci(m, n + m);}void main() => print(fibonacci().take(20));

Output:

(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, ..., 4181, 6765)

Generator Function

Iterable<int> fibonacci() sync* {  int a = 1, b = 1;  while (true) {    yield a;    int temp = a;    a = b;    b = temp + b;  }}void main() => print(fibonacci().take(20));

Output:

(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, ..., 4181, 6765)

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.;        RECORDFIB1,  D10FIB2,  D10FIBN,  D10J,     D5A2,    A2A5,    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 1END

Dc

This needs a modern Dc withr (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)  +] sF33 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

{\displaystyle {\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      begintmp[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

DuckDB

Works with:DuckDB version V1.1

Works with:DuckDB version V1.0

DuckDB cannot process any of the programs presented in the#SQL entry on thispage without alterations, but only small changes are typicallyrequired. For this entry, three of the snippets have beenadapted for DuckDB; in each case, a brief explanation of the required changesis also provided.

Part 1: Recursive CTE

The following is almost identical to the code shown in theRecursive section within the#SQL entry.The function signature had to be altered, and the keyword RECURSIVEadded; the `order by` was added to ensure the results have the expected order.

create or replace function fib_to(n) as table (  with recursive fib(e,f) as (  select 1, 1     union all    select e+f,e from fib    where e <= n)  select f from fib  order by f);from fib_to(55);

Output:

┌───────┐│   f   ││ int32 │├───────┤│     1 ││     1 ││     2 ││     3 ││     5 ││     8 ││    13 ││    21 ││    34 ││    55 │└───────┘

Part 2: Analytic formula

The first line of the SELECT statement given in the "As a power" subsectionof the "Analytic" section of the#SQL entry requires noalteration for the following adaptation, but the FROM and CONNECTlines must be altered as DuckDB has no DUAL table.

select round ( power( ( 1 + sqrt( 5 ) ) / 2, level ) / sqrt( 5 ) ) fibfrom range(1,11) t(level);

Output:

┌────────┐│  fib   ││ double │├────────┤│    1.0 ││    1.0 ││    2.0 ││    3.0 ││    5.0 ││    8.0 ││   13.0 ││   21.0 ││   34.0 ││   55.0 │└────────┘

Part 3: Recursive CTE for PostgreSQL

Only three lines of the program for PostgreSQL as shown in the#SQLentry had to be changed for DuckDB:

the signature of the function (the two lines with $$ signs);
the initialization line: `SELECT 0., 1.`

However, although the resulting program produces the correct result for fib(100), it would be better not to assumethe insertion order is preserved during construction of the recursive table.

At any rate, here is the modified program, minus the comments. Theinitalization line has been changed simply to:

SELECT 0::UHUGEINT, 1::UHUGEINT

but there are other possibilities, e.g. specifying the type as DOUBLEwould allow greater range.

# Warning: the following program has been naively adapted from the PostgresQL but # should be further modified to ensure correctness, e.g. by adding a counterCREATE or replace FUNCTION fib(n) AS (    WITH RECURSIVE fibonacci(current, previous) AS (    SELECT 0::UHUGEINT, 1::UHUGEINT    -- another possibility: SELECT 0::FLOAT, 1::FLOAT    UNION ALL        SELECT previous + current, current FROM fibonacci    )    SELECT current FROM fibonacci    LIMIT 1 OFFSET n);# Exampleselect fib(100);

Output:

┌───────────────────────┐│       fib(100)        ││        uint128        │├───────────────────────┤│ 354224848179261915075 │└───────────────────────┘

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 definesfib(0) = 0 becauseOEIS A000045 does.)

EasyLang

func fib n .   if n < 2 : return n   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

Usememoization 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 solutionFibFunction(UNSIGNED2 n) := FUNCTIONREAL 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 thenth—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

classAPPLICATIONcreatemakefeaturefibonacci (n: INTEGER): INTEGERrequirenon_negative: n >= 0locali, n2, n1, tmp: INTEGERdon2 := 0n1 := 1fromi := 1untili >= nlooptmp := n1n1 := n2 + n1n2 := tmpi := i + 1endResult := n1if n = 0 thenResult := 0endendfeature {NONE} -- Initializationmake-- Run application.doprint (fibonacci (0))print (" ")print (fibonacci (1))print (" ")print (fibonacci (2))print (" ")print (fibonacci (3))print (" ")print (fibonacci (4))print ("%N")endend

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:

011235813213455

Alternative version using yieldable method

import extensions;singleton FibonacciEnumerable : Enumerable{   Enumerator enumerator()      = FibonacciEnumerable.infinitEnumerator();   yield Enumerator infinitEnumerator()   {        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 := FibonacciEnumerable.enumerator();        if(!e.next())       InvalidOperationException.raise();        for(int i := 0; i < 10 && e.next(); i += 1) {        Console.printLine(*e)    };        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)    endendIO.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 -> Intfibonacci n = if n < 2 then        n    else        fibonacci(n - 2) + fibonacci(n - 1)

version 2

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

Output:

elm repl> fib 40102334155 : 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 problemEND PROGRAM

Output:

Number? 20FIB( 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 fend 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 ifend function-- example:? fibot(10) -- says 55

'Paper tape' version

Works with:Euphoria version 4.0.0

include std/mathcons.e -- for PINF constantenum ADD, MOVE, GOTO, OUT, TEST, TRUETOglobal 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 ipglobal integer testglobal atom accumprocedure eval( sequence cmd )atom i = 1while i <= length( cmd ) doswitch cmd[ i ] docase ADD thenaccum = tape[ cmd[ i + 1 ] ] + tape[ cmd[ i + 2 ] ]i += 2case OUT thenprintf( 1, cmd[ i + 2], tape[ cmd[ i + 1 ] ] ) i += 2case MOVE thenif cmd[ i + 1 ] = 0 thentape[ cmd[ i + 2 ] ] = accumelsetape[ cmd[ i + 2 ] ] = tape[ cmd[ i + 1 ] ]end ifi += 2case GOTO thenip = cmd[ i + 1 ] - 1 -- due to ip += 1 in main loopi += 1case TEST thenif tape[ cmd[ i + 1 ] ] = cmd[ i + 2 ] thentest = 1elsetest = 0end ifi += 2case TRUETO thenif test thenif cmd[ i + 1 ] = 0 thenabort(0)elseip = cmd[ i + 1 ] - 1end ifend ifend switchi += 1end whileend proceduretest = 0accum = 0ip = 1while 1 do-- embedded sequences (assumed to be code) are evaluated-- atoms (assumed to be data) are ignoredif sequence( tape[ ip ] ) theneval( tape[ ip ] ) end ifip += 1end while

Excel

LAMBDA

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

(SeeThe 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 Systemopen System.Diagnosticsopen 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

Combinatory

! produce the nth fib: fib ( n -- fib )     1 0 rot [ tuck + ]      times     drop ; inline! produce a list of the first n fibs: fibseq ( n -- fibs ) 1 0 rot [ [ + ] 2keep ] replicate 2nip ; inline

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 fibend

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)       endfunction fib_aux(n,a,b)   switch n      case 0 : return a      default: return fib_aux(n-1,a+b,a)   endend

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:

011235813213455891442333776109871597258441816765

Fish

Outputs Fibonacci numbers until stopped.

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

FOCAL

01.10 TYPE "FIBONACCI NUMBERS" !01.20 ASK "N =", N01.30 SET A=001.40 SET B=101.50 FOR I=2,N; DO 2.001.60 TYPE "F(N) ", %8, B, !01.70 QUIT02.10 SET T=B02.20 SET B=A+B02.30 SET A=T

Output:

FIBONACCI NUMBERSN =:20F(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 2drophere swap - cell/ Constant #F/64   \ # of fibonacci numbers generated16 fibonacci . 987  ok#F/64 . 93  ok92 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)      ENDC      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 90

function fibfc(n) result(f) ! integer forward count using 128 bit integers.    !   DOMAIN:  up to 184    !   uses 16 byte integers    integer(16), intent (in) :: n ! input    integer(16)              :: f ! output    integer(16)              :: i, fm2, fm1    if (n>184) then        PRINT *, "ERROR: 'a' must be in the domain 0 <= n <= 184 !"        STOP    end if    f=0    fm2=0    fm1=1    IF ( n > 0 ) f = 1    IF ( n < 3 ) return    do i = 2, n       f=fm2+fm1       fm2=fm1       fm1=f    enddoend function</syntaxhighlight lang="fortran">===FORTRAN 77===<syntaxhighlight lang="fortran">      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 fibonaccicontains    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 fibIend module fibonacci

Test program

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

Output:

0 01 11 12 23 35 58 813 1321 2134 3455 55

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 integersrelativePosition = (previous, current, next);var/// temporary iterator variablei: longword;/// holds preceding fibonacci valuesf: array[relativePosition] of nativeUInt;beginf[previous] := 0;f[current] := 1;// note, in Pascal for-loop-limits are inclusivefor i := 1 to n dobeginf[next] := f[previous] + f[current];f[previous] := f[current];f[current] := f[next];end;// assign to previous, bc f[current] = f[next] for next iterationfibonacci := 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,  R2FIB_LOOP    SUB    R0,  1, R0            JP_Z   FIB_DONE            MOVE   R2, R3            ADD    R1, R2, R2            MOVE   R3, R1            JP     FIB_LOOPFIB_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.sqrtdef 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:

011235813213455

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 ifend fn = s1long iCFTimeInterval tt = fn CACurrentMediaTimefor i = 0 to 40  print i;@".\t";fn Fibonacci(i)next iprint : printf @"Compute time: %.3f ms",(fn CACurrentMediaTime-t)*1000HandleEvents

Output:

0.01.12.13.24.35.56.87.138.219.3410.5511.8912.14413.23314.37715.61016.98717.159718.258419.418120.676521.1094622.1771123.2865724.4636825.7502526.12139327.19641828.31781129.51422930.83204031.134626932.217830933.352457834.570288735.922746536.1493035237.2415781738.3908816939.6324598640.102334155Compute time: 2.143 ms

Recursive

Cost is a time penalty

local fn Fibonacci( n as NSInteger ) as NSIntegerNSInteger resultif n < 2 then result = n : exit fnresult = fn Fibonacci( n-1 ) + fn Fibonacci( n-2 )end fn = resultwindow 1NSInteger iCFTimeInterval tt = fn CACurrentMediaTimefor i = 0 to 40print i;@".\t";fn Fibonacci(i)nextprint : printf @"Compute time: %.3f ms",(fn CACurrentMediaTime-t)*1000HandleEvents

Output:

0.01.12.13.24.35.56.87.138.219.3410.5511.8912.14413.23314.37715.61016.98717.159718.258419.418120.676521.1094622.1771123.2865724.4636825.7502526.12139327.19641828.31781129.51422930.83204031.134626932.217830933.352457834.570288735.922746536.1493035237.2415781738.3908816939.6324598640.102334155Compute 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 itswebsite.

Inthis 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...

Gleam

Recursive

pub fn fib(n: Int) -> Int {  case n {    0 -> 0    1 -> 1    n -> fib(n - 1) + fib(n - 2)  }}

Iterative

pub fn fib(n: Int) -> Int {  fib_helper(n, 0, 1)}fn fib_helper(n: Int, res: Int, next: Int) -> Int {  case n, res, next {    0, res, _ -> res    iter, res, next -> fib_helper(iter - 1, next, res + next)  }}

GML

///fibonacci(n)//Returns the nth fibonacci numbervar 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, 1return func() int {fib1, fib2 = fib2, fib1 + fib2return fib1}}func fibSequence(n int) int {f := fibNumber()fib := 0for i := 0; i < n; i++ {fib = f()}return fib}

Using a goroutine and channel

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

Golfscript

{1 0@{.@+}*\;}:f;20, {f p}/

Output:

01123581321345589144233377610987159725844181

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 bepre-declared.

def rFibrFib = {     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))/2def 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  55iterative (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, tempfwhile (--n>0)tempf:=fnow+fnextfnow:=fnextfnext:=tempfend whilereturn(fnext)

Haskell

Analytic

Works with:exact-real version 0.12.5.1

Using Binet's formula andexact real arithmetic library we can calculate arbitrary Fibonacci numberexactly.

import Data.CRealphi = (1 + sqrt 5) / 2fib :: (Integral b) => b -> CReal 0fib n = (phi^^n - (-phi)^^(-n))/sqrt 5

Let's try it for large numbers:

λ> fib 10 :: CReal 055(0.01 secs, 137,576 bytes)λ> fib 100 :: CReal 0354224848179261915075(0.01 secs, 253,152 bytes)λ> fib 10000 :: CReal 033644764876431783266621612005107543310302148460680063906564769974680081442166662368155595513633734025582065332680836159373734790483865268263040892463056431887354544369559827491606602099884183933864652731300088830269235673613135117579297437854413752130520504347701602264758318906527890855154366159582987279682987510631200575428783453215515103870818298969791613127856265033195487140214287532698187962046936097879900350962302291026368131493195275630227837628441540360584402572114334961180023091208287046088923962328835461505776583271252546093591128203925285393434620904245248929403901706233888991085841065183173360437470737908552631764325733993712871937587746897479926305837065742830161637408969178426378624212835258112820516370298089332099905707920064367426202389783111470054074998459250360633560933883831923386783056136435351892133279732908133732642652633989763922723407882928177953580570993691049175470808931841056146322338217465637321248226383092103297701648054726243842374862411453093812206564914032751086643394517512161526545361333111314042436854805106765843493523836959653428071768775328348234345557366719731392746273629108210679280784718035329131176778924659089938635459327894523777674406192240337638674004021330343297496902028328145933418826817683893072003634795623117103101291953169794607632737589253530772552375943788434504067715555779056450443016640119462580972216729758615026968443146952034614932291105970676243268515992834709891284706740862008587135016260312071903172086094081298321581077282076353186624611278245537208532365305775956430072517744315051539600905168603220349163222640885248852433158051534849622434848299380905070483482449327453732624567755879089187190803662058009594743150052402532709746995318770724376825907419939632265984147498193609285223945039707165443156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875(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.MemoTriefib :: Integer -> Integerfib = 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.MemoTriefib :: Integer -> Integerfib = 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.MemoTriefib :: Integer -> Integerfib = memo $ \case    0 -> 0   1 -> 1   n -> fib (n-1) + fib (n-2)

The version that supports negative numbers:

{-# Language LambdaCase #-}import Data.MemoTriefib :: Integer -> Integerfib = 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

Thenth Fibonacci number is then justfib !! 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 -> Integerfib n =  fst $  foldl' --'    (\(a, b) _ -> (b, a + b))    (0, 1)    [1 .. n]

As an unfold

Create an infinite list of integers using an unfold. The nth fibonacci number is the nth number in the list.

import Data.List (unfoldr)fibs :: [Integer]fibs = unfoldr (\(x, y) -> Just (x, (y, x + y))) (0, 1)fib n :: Integer -> Integerfib n = fibs !! n

With matrix exponentiation

Adapting the (rather slow) code fromMatrix exponentiation operator,we can simply write:

import Data.List (transpose)fib  :: (Integral b, Num a)  => b -> afib 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 1fib 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"

Generating Functions

Start by defining aNum instance for infinite power series:

import Data.Ratio (numerator)infixl 7 *.(*.) :: Num a => a -> [a] -> [a]x *. (p:ps) = x*p : x*.psinstance Num a => Num [a] where    negate = map negate    (+) = zipWith (+)    (*) (p:ps) (q:qs) = p*q : ((p*.qs) + ps*(q:qs))    fromInteger n = fromInteger n:repeat 0instance (Eq a, Fractional a) => Fractional [a] where    (/) (0:ps) (0:qs) = ps/qs    (/) (p:ps) (q:qs) = let r=p/q in r : (ps - r*.qs)/(q:qs)    fromRational q = fromRational q:repeat 0

The generating function for the Fibonacci numbers is

${\displaystyle \sum _{n}F_{n}x^{n}={\frac {1}{1-x-x^{2}}}}$

We can express this in Haskell with just the Prelude:

fibs :: [Integer]fibs = map numerator    (1/(1 : (-1) : (-1) : repeat 0))

ghci> take 15 fibs[1,1,2,3,5,8,13,21,34,55,89,144,233,377,610]

Escardó-Oliva Functional

We can use thehistory-dependent version of the Escardó-Oliva functional for course-of-value recursion, viz.

import Data.Functor.Identity (Identity (..))fibs :: [Integer]fibs = runIdentity (hsequence (repeat f))    where f []  = Identity 1          f [_] = Identity 1          f xs  = Identity ((xs !! (i-1)) + (xs !! i))              where i = length xs-1

wherehsequence is defined as in the paper,

hsequence :: Monad m => [[x] -> m x] -> m [x]hsequence []     = pure []hsequence (r:rs) = do    x <- r []    xs <- hsequence [ \ys -> g (x:ys) | g <- rs ]    pure (x:xs)

Notice thatfibs is not recursive; the recursion is handled by the higher-order functionalhsequence

ghci> take 17 fibs[1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597]

With recurrence relations

UsingFib[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 mfibN2 m = fibN2_next (n, r) (fibN2 n)  where    (n, r) = quotRem m 3fibN2_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 aboutn/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 arehere. 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

Hobbes

Recursive definition in a.hob script file:

fib :: int -> intfib n =  match n with  | 0 -> 0  | 1 -> 1  | _ -> fib(n - 1) + fib(n - 2)

Output:

> [fib(n) | n <- [1..20]][1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]

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);

Thenth Fibonacci number is then justfibs @ n.

Hy

Recursive implementation.

(defn fib [n]    (if (< n 2)        n        (+ (fib (- n 2)) (fib (- n 1)))))

IBM 1620 SPS

     START RCTY                ,,, RETURN CARRIAGE     LOOP  BT  FIBO,FIBN       ,,, PASS FIBN VALUE TO FUNCTION FIBO           AM  FIBN,1          ,,, ADD 1 TO FIBN           CM  FIBN,20         ,,, LOOP OVER THE FIRST 20 FIBONACCI NUMBERS           BNE LOOP            ,,, JUMP BACK TO LOOP IF 20 NOT YET REACHED           H                   ,,, HALT WHEN DONE     N     DC  5,0             ,,, INPUT VALUE N GOES HERE     FIBO  CM  FIBO-1,3        ,,, START OF FIBONACCI FUNCTION           BL  PRINT           ,,, JUMP TO PRINT AND OUTPUT 1 IF N LESS THAN 3           TFM L2,2            ,,, OTHERWISE SET UP VARIABLES FOR SUMMATION LOOP           TFM A,1           TFM B,1     LOOP2 TFM C,0             ,,, ITERATIVE LOOP FOR SUMMING VALUE           A   C,A           A   C,B           TF  A,B           TF  B,C           AM  L2,1           C   L2,FIBO-1           BL  LOOP2           WNTYB-3             ,,, OUTPUT B (SHOWING LAST 4 DIGITS)           RCTY           BB                  ,,, BRANCH BACK TO MAIN LOOP     PRINT WNTYONE-3           ,,, OUTPUT 1           RCTY           BB                  ,,, BRANCH BACK TO MAIN LOOP     FIBN  DC  5,1             ,,, WHICH FIBONACCI NUMBER TO PRINT     ONE   DC  5,1           DC  1,@             ,,, ADD A RECORD MARK SO ONE CAN BE PRINTED     L2    DC  5,0             ,,, LOOP 2 INDEX     A     DC  5,0     B     DC  5,0           DC  1,@             ,,, ADD A RECORD MARK SO B CAN BE PRINTED     C     DC  5,0           DENDSTART

Output:

0001000100020003000500080013002100340055008901440233037706100987159725844181

Icon andUnicon

Icon has built-in support for big numbers. First, a simple recursive solution augmented by caching for non-negative input. This examplescomputes fib(1000) if there is no integer argument.

procedure main(args)    write(fib(integer(!args) | 1000)endprocedure 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 providedfib 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))endprocedure fib(n)    return fibMat(n)[1]endprocedure 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,nsumend

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 -> DoublefibAnalytic 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 -> NatfibRecursive Z = ZfibRecursive (S Z) = (S Z)fibRecursive (S (S n)) = fibRecursive (S n) + fibRecursive n

Iterative

fibIterative : Nat -> NatfibIterative 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

TheFibonacci Sequence essay on the J Wiki presents a number of different ways of obtaining the nth Fibonacci number.

Recursive

This implementation is doubly recursive except that results are cached across function calls:

fibN=: (-&2 +&$: <:)^:(1&<) M."0

An amusing variant using an array operand to^::

fibN=: ([: +&$:/ <:^:1 2)^:(1&<) M."0

Iterative

fibN=: [: {."1 +/\@|.@]^:[&0 1

Examples:

   fibN 12144   fibN  i.310 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

Jactl

long fib(int n) { n <= 2 ? 1 : fib(n-1) + fib(n-2) }

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, andso 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)".

# Generatordef 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  xend

Matrix form

fib(n) = ([1 1 ; 1 0]^n)[1,2]

K

Works with:Kona

Recursive

{:[x<3;1;+/_f'x-1 2]}

Recursive with memoization

Using a (global) dictionary c.

{c::.();{v:c[a:`$$x];:[x<3;1;_n~v;c[a]:+/_f'x-1 2;v]}x}

Analytic

phi:(1+_sqrt(5))%2{_((phi^x)-((1-phi)^x))%_sqrt[5]}

Iterative

Works with:ngn/k

+/[;0;1]

Sequence to n

Works with:Kona

Works with:ngn/k

{(x(|+\)\1 1)[;1]}

{x{x,+/-2#x}/!2}

Works with:ngn/k

+\[;0;1]

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 timesif $i < $n; {$sequence = $sequence << ", ";goto calcnextnumber;}// Use the loop counter as the placeholder$i--;// Return the sequencereturn = "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 nlmsec 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 832040RECURSIVE:  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 832040CACHING   : 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 aVI Snippet, an executable image ofLabVIEW 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 = 2while($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 number:if(x < 2: x ; fn((x - 1)) + fn((x - 2)))writeln map(0..20, by=fibonacci)

val fibonacci = fn(x number) {    for[f=[0, 1]] of x-1 {        f ~= [f[-1]+f[-2]]    }}writeln fibonacci(20)

Output:

[0, 1, 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 falselocal(swap= 0,n1= 0,n2= 1)loop(#n) => {        #swap = #n1 + #n2;        #n2 = #n1;        #n1 = #swap;}return #n1}fibonacci(0) //->output falsefibonacci(1) //->output 1fibonacci(2) //->output 1fibonacci(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) adef fib2 : ℕ → ℕ | n := fib_aux n 1 0-- Use #eval to check computations:#eval fib1 20#eval fib2 20

It runs on Lean 4:

-- Naive versiondef fib1 (n : Nat) : Nat :=  match n with  | 0 => 0  | 1 => 1  | (k + 2) => fib1 k + fib1 (k + 1)-- More efficient versiondef 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 fibend

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 aaend fibi-- Recursivefunction fibr n     if n <= 1 then        return n    else        return fibr(n-1) + fibr(n-2)    end ifend 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 %looploop:    %5 = load i32, i32* %2, align 4     ;-- load n    %6 = icmp sgt i32 %5, 0             ;-- n > 0    br i1 %6, label %loop_body, label %exitloop_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 %loopexit:    %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 %looploop:    %2 = load i32, i32* %1, align 4     ;-- load index    %3 = icmp sle i32 %2, 12            ;-- index <= 12    br i1 %3, label %loop_body, label %exitloop_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 %loopexit:    ret i32 0                           ;-- return EXIT_SUCCESS}

Output:

01123581321345589144

Logo

to fib "loopmake   "fib1 0make   "fib2 1type [You requested\ ]type :loopprint [\ Fibonacci Numbers]   type :fib1   type [\  ]   type :fib2     type [\  ]   make "loop :loop - 2repeat :loop [ make "fibnew :fib1 + :fib2 type :fibnew type [\  ] make "fib1 :fib2 make "fib2 :fibnew ]   print [\  ]     end

LOLCODE

HAI 1.2HOW 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  OICIF U SAY SOKTHXBYE

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)=0Fibonacci(1)=1Fibonacci(2)=1Fibonacci(3)=2Fibonacci(4)=3Fibonacci(5)=5Fibonacci(6)=8Fibonacci(7)=13Fibonacci(8)=21Fibonacci(9)=34Fibonacci(10)=55Fibonacci(11)=89Fibonacci(12)=144Fibonacci(13)=233Fibonacci(14)=377Fibonacci(15)=610Fibonacci(16)=987Fibonacci(17)=1597Fibonacci(18)=2584Fibonacci(19)=4181Fibonacci(20)=6765Fibonacci(21)=10946Fibonacci(22)=17711Fibonacci(23)=28657Fibonacci(24)=46368Fibonacci(25)=75025Fibonacci(26)=121393Fibonacci(27)=196418Fibonacci(28)=317811Fibonacci(29)=514229Fibonacci(30)=832040Fibonacci(31)=1346269Fibonacci(32)=2178309Fibonacci(33)=3524578Fibonacci(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 nfunction 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)  endend

Tail Recursive

function a(n,u,s) if n<2 then return u+s end return a(n-1,u+s,u) endfunction 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 p0end

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:=1fib=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 139For 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 codeSet 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))))')')')dnldefine(`loop',`ifelse($1,$2,,`$3($1) loop(incr($1),$2,`$3')')')dnlloop(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 = BLOOP        B = C            FUNCTION RETURN A            END OF FUNCTION                        THROUGH SHOW, FOR I=0, 1, I.GE.20SHOW        PRINT FORMAT FNUM, I, FIB.(I)            VECTOR VALUES FNUM = $4HFIB(,I2,4H) = ,I4*$            END OF PROGRAM

Output:

FIB( 0) =    0FIB( 1) =    1FIB( 2) =    1FIB( 3) =    2FIB( 4) =    3FIB( 5) =    5FIB( 6) =    8FIB( 7) =   13FIB( 8) =   21FIB( 9) =   34FIB(10) =   55FIB(11) =   89FIB(12) =  144FIB(13) =  233FIB(14) =  377FIB(15) =  610FIB(16) =  987FIB(17) = 1597FIB(18) = 2584FIB(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 functionFibonacci, but a simple recursive implementation would be

fib[0] = 0fib[1] = 1fib[n_Integer] := fib[n - 1] + fib[n - 2]

An optimization is to cache the values already calculated:

fib[0] = 0fib[1] = 1fib[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 functionRSolve

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 functionFibonacci[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));    endend

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);0fib2(-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 predicatefib/2 and in the functionfib/1. The predicatemain/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: 0elseif n=1: 1else:  fibo(n-1) + fibo(n-2)fienddef;for i=0 upto 10: show fibo(i); endforend

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 ansend functionprint 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 functionprint 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.

.textmain:li$v0, 5# read integer from input. The read integer will be stroed in $v0syscallbeq$v0, 0, is1beq$v0, 1,is1li$s4, 1# the counter which has to equal to $v0li$s0, 1li$s1, 1loop:add$s2, $s0, $s1addi$s4, $s4, 1beq$v0, $s4, iss2add$s0, $s1, $s2addi$s4, $s4, 1beq$v0, $s4, iss0add$s1, $s2, $s0addi$s4, $s4, 1beq$v0, $s4, iss1b loopiss0:move$a0, $s0bprintiss1:move$a0, $s1bprintiss2:move$a0, $s2bprintis1:li$a0, 1b printprint:li$v0, 1syscallli$v0, 10syscall

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)endputs fibonacci 1puts fibonacci 2puts fibonacci 3puts fibonacci 4puts fibonacci 5puts fibonacci 6puts fibonacci 7

МК-61/52

П01lgВx<->+L003С/ПБП03

Instruction:n В/О С/П, wheren 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 =     letfun fib' (0,a,b) = a  | fib' (n,a,b) = fib' (n-1,a+b,a)    infib' (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 - recursiveMCSKIP 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 aEND 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;    ReadCharEND 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.

# MainLei ha clacsonatovoglio un nonnulla, Necchi mi porga un nonnullail 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 TOINTFOR :    a b + VAR c .    a PRINT .    b VAR a .    c VAR b .ENDFOR

Forth-style solution

def over    swap dup rot swapenddef|Enter a number to obtain Fibonacci sequence: | input nip var count .0 1FOR count    over out |, | out . + swapENDFOR. printinputclear

Simpler

|Enter a number to obtain Fibonacci sequence: | input nip 1 - var count .0 1FOR count    out |, | out . dup rot +ENDFORprintinput   /# 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 fibend

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 symbolsnumeric 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  endif 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 kexit/*-------------------------------------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 nlocal a = 1, b = 1# i is automatically local because of for()for(i=2; i<n; i=i+1) {local next = a + ba = bb = 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% slowerthan 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 + bvar f = fibfor i in 0.. <10:  echo f()

Nix

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

Nu

Works with:Nushell version 0.97.1

def 'seq fibonacci' [] {  generate { {out: $in.0, next: [$in.1 ($in | math sum)]} } [0 1]}seq fibonacci | get 7

Output:

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];  ENDEND Fibs;PROCEDURE FibsR(n: LONGREAL): LONGREAL;BEGIN  IF n < 2. THEN    RETURN n  ELSE    RETURN FibsR(n - 1) + FibsR(n - 2)  ENDEND 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.LnEND 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'sNum module.

open Numlet 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 00$ ./fib 1055$ ./fib 399108788617463475645289761992289049744844995705477812699099751202749393926359816304226$ ./fib -6-8

O(log(n)) with arbitrary precision

This performs log2(N) matrix multiplies. Each multiplication is not constant-time but increases sub-linearly, about O(log(N)).

open Numlet 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

% recursivefunction fibo = recfibo(n)  if ( n < 2 )    fibo = n;  else    fibo = recfibo(n-1) + recfibo(n-2);  endifendfunction

Testing

% testingfor i = 0 : 20  printf("%d %d\n", i, recfibo(i));endfor

Iterative

% iterativefunction 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);  endifendfunction

Testing

% testingfor 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);  endifendfunction

Odin

Fibinacci Sequence - Iterative Solution
Odin Build: dev-2023-07-nightly:3072479c

package fibimport "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 NumbersStarting n and n+1 from 0 and 1-------------------------------n: 0    Fib: 0n: 1    Fib: 1n: 2    Fib: 1n: 3    Fib: 2n: 4    Fib: 3n: 5    Fib: 5n: 6    Fib: 8n: 7    Fib: 13n: 8    Fib: 21n: 9    Fib: 34n: 10   Fib: 55n: 11   Fib: 89n: 12   Fib: 144n: 13   Fib: 233n: 14   Fib: 377n: 15   Fib: 610n: 16   Fib: 987n: 17   Fib: 1597n: 18   Fib: 2584n: 19   Fib: 4181n: 20   Fib: 6765-------------------------------

Oforth

: fib   0 1 rot #[ tuck + ] times drop ;

Ol

Same asScheme example(s).

Onyx (wasm)

use core.iteruse core { printf }// Procedural Simple For-Loop Stylefib_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 Stylefib_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 Stylefib_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 6765Functional Fold:0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765Custom 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,CA=1 :B=1 :C=1PRINT 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  @Aend

Recursive

Inefficient (blows up the stack).

fun{FibR N}  if N < 2 then N  else {FibR N-1} + {FibR N-2}  endend

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   endin       {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  endin  {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 ${\displaystyle \phi }$ and the number is stored in the form ${\displaystyle a+b\phi }$ .imag takes the coefficient of ${\displaystyle \phi }$ . This uses the relation

{\displaystyle \phi ^{n}=F_{n-1}+F_{n}\phi }

and hencereal(quadgen(5)^n) would give the (n-1)-th Fibonacci number.

fib(n)=imag(quadgen(5)^n)

A more direct translation (note that ${\displaystyle {\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

This is an efficient method (similar to the one used internally byfibonacci()), although running it without compilation won't give competitive speed.

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 usesself() 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};

Trigonometric

This solution uses the complex hyperbolic sine.

fib(n)=real(2/sqrt(5)/I^n*sinh(n*log(I*(1+sqrt(5))/2)))\/1;

Chebyshev

This solution uses Chebyshev polynomials of the second kind (Chyebyshev U-polynomials).

fib(n)=n--;polchebyshev(n,2,I/2)*I^n;

fib(n)=abs(polchebyshev(n-1,2,I/2));

Anti-Hadamard matrix

All n×n(0,1) lowerHessenberg 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 seenn 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

using FreePascal with GMP lib

Works with:Free Pascal version 3.2.2

Program FastFibonacciGMP;{$mode objfpc}{$H+}{$J-}// ============================================================================// Fast Fibonacci Calculator with Multiple Algorithms and GMP// ----------------------------------------------------------------------------// 2025.12.05// Author: jpd// AI Assistant: DeepSeek// Description: Multiple Fibonacci algorithms with arbitrary precision//              AI translated from my own 2016 python app ( the hybrid part )//// LICENSE & ATTRIBUTION:// ----------------------------------------------------------------------------// 1. This Pascal source file (`FastFibonacciGMP.pas`) is released to the//    PUBLIC DOMAIN for Rosetta Code contribution. Author waives all copyright.//// 2. This program uses the Free Pascal `GMP` unit, which is a binding to the//    GNU MP Library (GMP). The `GMP` unit is part of Free Pascal's RTL-extra//    package, licensed under the GNU Lesser General Public License (LGPL)//    with a static linking exception.//// 3. The underlying GNU MP Library (libgmp) itself is licensed under://    - GNU Lesser General Public License version 3 or later (LGPLv3+), OR//    - GNU General Public License version 2 or later (GPLv2+).//// 4. When compiled, this program links to the external GMP C library.//    For license compliance, users must have access to the GMP library//    source code (available at https://gmplib.org/).// ============================================================================// MATHEMATICAL FOUNDATION ATTRIBUTION:// ----------------------------------------------------------------------------// 1. Fast Doubling Formulas (Fibonacci Squaring)://    F(2k) = F(k) × [2×F(k+1) - F(k)]//    F(2k+1) = F(k+1)² + F(k)²//    Derived from Cassini's identity (1680) and Catalan's identity (1879).//    Modern algorithmic presentation: Dijkstra (1978), Cohn (1963).//// 2. Fibonacci Tripling Formulas://    F(3k) = 5×F(k)³ + 3×(-1)ᵏ×F(k)//    F(3k+1) = F(k+1)³ + 3×F(k+1)×F(k)² - F(k)³//    Derived from Binet's formula (1843).//    Algorithmic optimization: Various number theory sources.//// 3. Hybrid Decomposition Algorithm://    Recursive decomposition using factors 2 and 3 based on divisibility.//    Original implementation concept: jpd (2016 Python implementation).//    Ported to Pascal with algorithmic corrections: DeepSeek AI (2025).//// NOTE: These mathematical identities are in the public domain.//       This specific implementation is original work.// ----------------------------------------------------------------------------Uses    SysUtils,    DateUtils,    Gmp;// ----------------------------------------------------------------------------// Matrix type for 2x2 integer matrix using GMP arbitrary precision// ----------------------------------------------------------------------------Type    TMatrix = Record        a, b, c, d: mpz_t;    End;    // Enum for algorithm selection    TAlgorithm = (algMatrix, algFastDoubling, algIterative, algHybrid);// ----------------------------------------------------------------------------// Initialize matrix with four integer values// ----------------------------------------------------------------------------Procedure InitMatrix(Var m: TMatrix; a, b, c, d: Integer);Begin    mpz_init_set_si(m.a, a);    mpz_init_set_si(m.b, b);    mpz_init_set_si(m.c, c);    mpz_init_set_si(m.d, d);End;// ----------------------------------------------------------------------------// Clear GMP memory for matrix elements// ----------------------------------------------------------------------------Procedure ClearMatrix(Var m: TMatrix);Begin    mpz_clear(m.a);    mpz_clear(m.b);    mpz_clear(m.c);    mpz_clear(m.d);End;// ----------------------------------------------------------------------------// Multiply two matrices: R = A × B// Uses GMP for arbitrary precision arithmetic// ----------------------------------------------------------------------------Procedure MatrixMul(Var R, A, B: TMatrix);Var    temp1, temp2, temp3, temp4: mpz_t;Begin    // Initialize temporaries    mpz_init(temp1);    mpz_init(temp2);    mpz_init(temp3);    mpz_init(temp4);    // temp1 = A.a × B.a + A.b × B.c    mpz_mul(temp1, A.a, B.a);    mpz_mul(temp2, A.b, B.c);    mpz_add(temp1, temp1, temp2);    // temp2 = A.a × B.b + A.b × B.d    mpz_mul(temp2, A.a, B.b);    mpz_mul(temp3, A.b, B.d);    mpz_add(temp2, temp2, temp3);    // temp3 = A.c × B.a + A.d × B.c    mpz_mul(temp3, A.c, B.a);    mpz_mul(temp4, A.d, B.c);    mpz_add(temp3, temp3, temp4);    // temp4 = A.c × B.b + A.d × B.d    mpz_mul(temp4, A.c, B.b);    mpz_mul(R.d, A.d, B.d);  // Reuse R.d as temp    mpz_add(temp4, temp4, R.d);    // Store results    mpz_set(R.a, temp1);    mpz_set(R.b, temp2);    mpz_set(R.c, temp3);    mpz_set(R.d, temp4);    // Cleanup temporaries    mpz_clear(temp1);    mpz_clear(temp2);    mpz_clear(temp3);    mpz_clear(temp4);End;// ----------------------------------------------------------------------------// Compute Fibonacci number F(n) using matrix exponentiation// Supports both positive and negative indices using 64-bit integers// ----------------------------------------------------------------------------Procedure FibonacciMatrix(n: Int64; Var result: mpz_t);Var    Base, ResultMat, TempMat: TMatrix;    mask: QWord;    abs_n: QWord;    startTime, endTime: TDateTime;Begin    startTime := Now;    // Initialize matrices    If n >= 0 Then        InitMatrix(Base, 0, 1, 1, 1)      // [0 1; 1 1] for positive n    Else        InitMatrix(Base, -1, 1, 1, 0);    // [-1 1; 1 0] for negative n    // Identity matrix for exponentiation    InitMatrix(ResultMat, 1, 0, 0, 1);    InitMatrix(TempMat, 0, 0, 0, 0);    // Use absolute value for exponentiation    If n >= 0 Then        abs_n := QWord(n)    Else        abs_n := QWord(-n);    mask := 1;    // Fast exponentiation by squaring: O(log n) complexity    While mask <= abs_n Do    Begin        If (abs_n And mask) <> 0 Then        Begin            MatrixMul(TempMat, ResultMat, Base);            mpz_set(ResultMat.a, TempMat.a);            mpz_set(ResultMat.b, TempMat.b);            mpz_set(ResultMat.c, TempMat.c);            mpz_set(ResultMat.d, TempMat.d);        End;        // Square the base matrix        MatrixMul(TempMat, Base, Base);        mpz_set(Base.a, TempMat.a);        mpz_set(Base.b, TempMat.b);        mpz_set(Base.c, TempMat.c);        mpz_set(Base.d, TempMat.d);        mask := mask Shl 1;    End;    // Result is in the (0,1) position of the matrix    mpz_set(result, ResultMat.b);    // Cleanup    ClearMatrix(Base);    ClearMatrix(ResultMat);    ClearMatrix(TempMat);    endTime := Now;    WriteLn('Matrix method time: ', MilliSecondsBetween(endTime, startTime), ' ms');End;// ----------------------------------------------------------------------------// Iterative version of Fast Doubling (avoids recursion depth issues)*//// Process bits of n from most significant to least significant// ----------------------------------------------------------------------------Procedure FastDoublingIterative(n: QWord; Var result: mpz_t);Var    a, b, c, d, temp1, temp2: mpz_t;    mask: QWord;Begin    // Initialize GMP variables    mpz_init_set_ui(a, 0);  // F(0) = 0    mpz_init_set_ui(b, 1);  // F(1) = 1    mpz_init(c);    mpz_init(d);    mpz_init(temp1);    mpz_init(temp2);    // Find highest set bit    mask := 1;    While mask <= n Do        mask := mask Shl 1;    mask := mask Shr 1;  // Now mask is the highest set bit    // Process bits from most significant to least significant    While mask > 0 Do    Begin        // c = F(2k) = F(k) * [2 * F(k+1) - F(k)]        // where k = current value of a,b (representing F(k), F(k+1))        // Calculate 2*b - a        mpz_mul_ui(temp1, b, 2);    // 2 * F(k+1)        mpz_sub(temp1, temp1, a);   // 2 * F(k+1) - F(k)        // c = a * (2*b - a)        mpz_mul(c, a, temp1);        // d = F(k+1)² + F(k)²        mpz_mul(temp1, b, b);       // b²        mpz_mul(temp2, a, a);       // a²        mpz_add(d, temp1, temp2);   // a² + b²        // Update a, b based on current bit of n        If (n And mask) <> 0 Then        Begin            // Current bit is 1: (a,b) = (d, c+d)            // This corresponds to going from (F(k), F(k+1)) to (F(2k+1), F(2k+2))            mpz_add(temp1, c, d);   // c + d = F(2k+1) + F(2k) = F(2k+2)            mpz_set(a, d);          // a = F(2k+1)            mpz_set(b, temp1);      // b = F(2k+2)        End        Else        Begin            // Current bit is 0: (a,b) = (c, d)            // This corresponds to going from (F(k), F(k+1)) to (F(2k), F(2k+1))            mpz_set(a, c);          // a = F(2k)            mpz_set(b, d);          // b = F(2k+1)        End;        mask := mask Shr 1;    End;    // Result is in a    mpz_set(result, a);    // Cleanup    mpz_clear(a);    mpz_clear(b);    mpz_clear(c);    mpz_clear(d);    mpz_clear(temp1);    mpz_clear(temp2);End;// ----------------------------------------------------------------------------// Wrapper for Fast Doubling with timing// ----------------------------------------------------------------------------Procedure FibonacciFastDoubling(n: Int64; Var result: mpz_t);Var    startTime, endTime: TDateTime;    fn: mpz_t;    abs_n: QWord;Begin    startTime := Now;    // Handle negative n using F(-n) = (-1)^(n+1) * F(n)    If n >= 0 Then        abs_n := QWord(n)    Else        abs_n := QWord(-n);    mpz_init(fn);    FastDoublingIterative(abs_n, fn);    If n < 0 Then    Begin        // Apply sign for negative indices        If (abs_n Mod 2) = 0 Then            mpz_neg(fn, fn);    End;    mpz_set(result, fn);    mpz_clear(fn);    endTime := Now;    WriteLn('Fast doubling method time: ', MilliSecondsBetween(endTime, startTime), ' ms');End;// ----------------------------------------------------------------------------// Hybrid Doubling/Tripling Method (Fastest and most efficient)// Based on Python matfib.1.1.py algorithm with corrected logic*// ----------------------------------------------------------------------------Procedure FibonacciHybrid(n: Int64; Var result: mpz_t);Var    startTime, endTime: TDateTime;    FDict: array of record        key: QWord;        value: mpz_t;    end;    DivMap: array of record        key: QWord;        divisor: QWord;    end;    i, j, idx: Integer;    a, divBy, nextNum: QWord;    temp1, temp2, temp3: mpz_t;    sign: Boolean;    abs_n: QWord;    target: QWord;    sortedKeys: array of QWord;    // Find index of key in FDict array    Function FindF(key: QWord): Integer;    Var        i: Integer;    Begin        For i := 0 To Length(FDict) - 1 Do            If FDict[i].key = key Then            Begin                Result := i;                Exit;            End;        Result := -1;    End;    // Add new Fibonacci number to FDict array    Procedure AddF(key: QWord);    Begin        SetLength(FDict, Length(FDict) + 1);        FDict[Length(FDict) - 1].key := key;        mpz_init(FDict[Length(FDict) - 1].value);    End;    // Helper: Compute F(n+1) if not already in dictionary*    Procedure EnsureFPlusOne(n: QWord);    Var        idx1, idx2: Integer;    Begin        If FindF(n + 1) >= 0 Then            Exit;        // Compute F(n+1) = F(n) + F(n-1)        idx1 := FindF(n);        idx2 := FindF(n - 1);        If (idx1 < 0) or (idx2 < 0) Then        Begin            WriteLn('Error: Cannot compute F(', n+1, ')');            Halt(1);        End;        AddF(n + 1);        mpz_add(FDict[Length(FDict) - 1].value, FDict[idx1].value, FDict[idx2].value);    End;Begin    startTime := Now;    // Initialize GMP temporaries    mpz_init(temp1);    mpz_init(temp2);    mpz_init(temp3);    // Handle negative indices    If n >= 0 Then        abs_n := QWord(n)    Else        abs_n := QWord(-n);    target := abs_n;    sign := (n < 0) And ((abs_n Mod 2) = 0);    // Initialize base Fibonacci numbers (0-8)    SetLength(FDict, 9);    For i := 0 To 8 Do    Begin        FDict[i].key := QWord(i);        mpz_init(FDict[i].value);    End;    mpz_set_ui(FDict[0].value, 0);   // F(0) = 0    mpz_set_ui(FDict[1].value, 1);   // F(1) = 1    mpz_set_ui(FDict[2].value, 1);   // F(2) = 1    mpz_set_ui(FDict[3].value, 2);   // F(3) = 2    mpz_set_ui(FDict[4].value, 3);   // F(4) = 3    mpz_set_ui(FDict[5].value, 5);   // F(5) = 5    mpz_set_ui(FDict[6].value, 8);   // F(6) = 8    mpz_set_ui(FDict[7].value, 13);  // F(7) = 13    mpz_set_ui(FDict[8].value, 21);  // F(8) = 21    // If n is small, return directly    If abs_n <= 8 Then    Begin        idx := FindF(abs_n);        If idx >= 0 Then            mpz_set(result, FDict[idx].value);        If sign Then            mpz_neg(result, result);        // Cleanup        For i := 0 To 8 Do            mpz_clear(FDict[i].value);        mpz_clear(temp1);        mpz_clear(temp2);        mpz_clear(temp3);        endTime := Now;        WriteLn('Hybrid method time: ', MilliSecondsBetween(endTime, startTime), ' ms');        Exit;    End;    // Build division path    SetLength(DivMap, 0);    a := abs_n;    // Python: while a > 1:    While a > 1 Do    Begin        // Python: div = 3 if a % 3.0 == 0.0 else 2        If (a Mod 3) = 0 Then            divBy := 3        Else            divBy := 2;        a := a Div divBy;        // Python: _[a] = div        SetLength(DivMap, Length(DivMap) + 1);        DivMap[Length(DivMap) - 1].key := a;        DivMap[Length(DivMap) - 1].divisor := divBy;    End;    // Python: _[a] = div (final assignment)    SetLength(DivMap, Length(DivMap) + 1);    DivMap[Length(DivMap) - 1].key := a;    DivMap[Length(DivMap) - 1].divisor := divBy;    // Sort keys in increasing order    SetLength(sortedKeys, Length(DivMap));    For i := 0 To Length(DivMap) - 1 Do        sortedKeys[i] := DivMap[i].key;    // Simple bubble sort    For i := 0 To Length(sortedKeys) - 2 Do        For j := i + 1 To Length(sortedKeys) - 1 Do            If sortedKeys[i] > sortedKeys[j] Then            Begin                a := sortedKeys[i];                sortedKeys[i] := sortedKeys[j];                sortedKeys[j] := a;            End;    Write('Operations: ');    // Process each key in sorted order    For i := 0 To Length(sortedKeys) - 1 Do    Begin        a := sortedKeys[i];        // Find the divisor for this key        divBy := 0;        For j := 0 To Length(DivMap) - 1 Do            If DivMap[j].key = a Then            Begin                divBy := DivMap[j].divisor;                Break;            End;        If divBy = 0 Then            Continue;        nextNum := a * divBy;  // Python: i = _[n] * n        If divBy = 2 Then        Begin            Write('² ');            // Need F(a-1) and F(a)            j := FindF(a - 1);            idx := FindF(a);            If (j < 0) or (idx < 0) Then            Begin                WriteLn('Error: Missing base Fibonacci numbers for doubling at a=', a);                Halt(1);            End;            // F(i-1) = F(a-1)² + F(a)²            AddF(nextNum - 1);            mpz_mul(temp1, FDict[j].value, FDict[j].value);  // F(a-1)²            mpz_mul(temp2, FDict[idx].value, FDict[idx].value);  // F(a)²            mpz_add(FDict[Length(FDict) - 1].value, temp1, temp2);            // Check if we found target            If (nextNum - 1) = target Then                Break;            // F(i) = (2 * F(a-1) + F(a)) * F(a)            AddF(nextNum);            mpz_mul_ui(temp1, FDict[j].value, 2);  // 2 * F(a-1)            mpz_add(temp1, temp1, FDict[idx].value);  // 2*F(a-1) + F(a)            mpz_mul(FDict[Length(FDict) - 1].value, temp1, FDict[idx].value);            // Check if we found target            If nextNum = target Then                Break;            // CRITICAL FIX: Always compute F(i+1) and F(i+2)**            // F(i+1) = F(i-1) + F(i)            AddF(nextNum + 1);            j := FindF(nextNum - 1);            idx := FindF(nextNum);            mpz_add(FDict[Length(FDict) - 1].value, FDict[j].value, FDict[idx].value);            // Check if we found target            If (nextNum + 1) = target Then                Break;            // F(i+2) = F(i) + F(i+1)            AddF(nextNum + 2);            j := FindF(nextNum);            idx := FindF(nextNum + 1);            mpz_add(FDict[Length(FDict) - 1].value, FDict[j].value, FDict[idx].value);            // Check if we found target            If (nextNum + 2) = target Then                Break;        End        Else If divBy = 3 Then        Begin            Write('³ ');            // Need F(a) and ensure F(a+1) is available**            idx := FindF(a);            If idx < 0 Then            Begin                WriteLn('Error: Missing base Fibonacci number for tripling at a=', a);                Halt(1);            End;            // Ensure F(a+1) is available**            EnsureFPlusOne(a);            j := FindF(a + 1);            // F(i) = 5 * F(a)³ + 3 * (-1)^a * F(a)            AddF(nextNum);            // Compute F(a)² and F(a)³            mpz_mul(temp1, FDict[idx].value, FDict[idx].value);  // F(a)²            mpz_mul(temp2, temp1, FDict[idx].value);  // F(a)³            // 5 * F(a)³            mpz_mul_ui(temp3, temp2, 5);            // 3 * (-1)^a * F(a)            If (a Mod 2) = 0 Then            Begin                // (-1)^a = 1 for even a                mpz_mul_ui(temp1, FDict[idx].value, 3);                mpz_add(FDict[Length(FDict) - 1].value, temp3, temp1);            End            Else            Begin                // (-1)^a = -1 for odd a                mpz_mul_ui(temp1, FDict[idx].value, 3);                mpz_neg(temp1, temp1);                mpz_add(FDict[Length(FDict) - 1].value, temp3, temp1);            End;            // Check if we found target            If nextNum = target Then                Break;            // CRITICAL FIX: Always compute the window**            // F(i+1) = F(a+1)³ + 3 * F(a+1) * F(a)² - F(a)³            AddF(nextNum + 1);            // F(a+1)³            mpz_mul(temp1, FDict[j].value, FDict[j].value);            mpz_mul(temp1, temp1, FDict[j].value);            // 3 * F(a+1) * F(a)²            mpz_mul(temp2, FDict[idx].value, FDict[idx].value);  // F(a)²            mpz_mul_ui(temp3, FDict[j].value, 3);  // 3 * F(a+1)            mpz_mul(temp3, temp3, temp2);  // 3 * F(a+1) * F(a)²            // F(a)³            mpz_mul(temp2, temp2, FDict[idx].value);  // F(a)³            // F(i+1) = F(a+1)³ + 3*F(a+1)*F(a)² - F(a)³            mpz_add(FDict[Length(FDict) - 1].value, temp1, temp3);            mpz_sub(FDict[Length(FDict) - 1].value, FDict[Length(FDict) - 1].value, temp2);            // Check if we found target            If (nextNum + 1) = target Then                Break;            // F(i-1) = F(i+1) - F(i)            AddF(nextNum - 1);            j := FindF(nextNum + 1);            idx := FindF(nextNum);            mpz_sub(FDict[Length(FDict) - 1].value, FDict[j].value, FDict[idx].value);            // Check if we found target            If (nextNum - 1) = target Then                Break;            // F(i+2) = F(i) + F(i+1)            AddF(nextNum + 2);            j := FindF(nextNum);            idx := FindF(nextNum + 1);            mpz_add(FDict[Length(FDict) - 1].value, FDict[j].value, FDict[idx].value);            // Check if we found target            If (nextNum + 2) = target Then                Break;            // F(i+3) = F(i+1) + F(i+2)            AddF(nextNum + 3);            j := FindF(nextNum + 1);            idx := FindF(nextNum + 2);            mpz_add(FDict[Length(FDict) - 1].value, FDict[j].value, FDict[idx].value);            // Check if we found target            If (nextNum + 3) = target Then                Break;        End;    End;    WriteLn;    // Get the result    idx := FindF(target);    If idx < 0 Then    Begin        WriteLn('Error: Could not compute F(', n, ')');        Halt(1);    End;    mpz_set(result, FDict[idx].value);    // Apply sign for negative indices    If sign Then        mpz_neg(result, result);    // Cleanup    For i := 0 To Length(FDict) - 1 Do        mpz_clear(FDict[i].value);    mpz_clear(temp1);    mpz_clear(temp2);    mpz_clear(temp3);    endTime := Now;    WriteLn('Hybrid method time: ', MilliSecondsBetween(endTime, startTime), ' ms');End;// ----------------------------------------------------------------------------// Display Fibonacci number with first/last digits and total count// ----------------------------------------------------------------------------Procedure DisplayLargeFibonacci(n: Int64; Var fib: mpz_t);Var    s: AnsiString;    len: Integer;    first20, last20: AnsiString;Begin    s := mpz_get_str(Nil, 10, fib);    len := Length(s);    WriteLn('F(', n, ') has ', len, ' digits');    If len <= 40 Then        WriteLn('F(', n, ') = ', s)    Else    Begin        first20 := Copy(s, 1, 20);        last20 := Copy(s, len - 19, 20);        WriteLn('First 20 digits: ', first20);        WriteLn('Last 20 digits:  ', last20);        WriteLn('Full number saved to memory');    End;    WriteLn;End;// ----------------------------------------------------------------------------// Simple iterative Fibonacci (for comparison, limited to smaller n)// ----------------------------------------------------------------------------Procedure FibonacciIterative(n: Integer; Var result: mpz_t);Var    a, b, temp: mpz_t;    i: Integer;    abs_n: Integer;    startTime, endTime: TDateTime;Begin    startTime := Now;    mpz_init(a);    mpz_init(b);    mpz_init(temp);    abs_n := Abs(n);    If abs_n = 0 Then    Begin        mpz_set_si(result, 0);    End    Else    Begin        mpz_set_si(a, 0);        mpz_set_si(b, 1);        For i := 2 To abs_n Do        Begin            mpz_add(temp, a, b);            mpz_set(a, b);            mpz_set(b, temp);        End;        mpz_set(result, b);    End;    // Handle negative indices using: F(-n) = (-1)^(n+1) * F(n)    If n < 0 Then    Begin        If (abs_n Mod 2) = 0 Then            mpz_neg(result, result);    End;    mpz_clear(a);    mpz_clear(b);    mpz_clear(temp);    endTime := Now;    WriteLn('Iterative method time: ', MilliSecondsBetween(endTime, startTime), ' ms');End;// ----------------------------------------------------------------------------// Parse a string to Int64, handling large numbers// ----------------------------------------------------------------------------Function ParseLargeInt(Str: String): Int64;Var    ErrorCode: Integer;Begin    Val(Str, Result, ErrorCode);    If ErrorCode <> 0 Then        Raise EConvertError.Create('Invalid integer: ' + Str);End;// ----------------------------------------------------------------------------// Parse algorithm selection from string// ----------------------------------------------------------------------------Function ParseAlgorithm(Str: String): TAlgorithm;Var    lowerStr: String;Begin    lowerStr := LowerCase(Str);    If lowerStr = 'matrix' Then        Result := algMatrix    Else If lowerStr = 'fastdoubling' Then        Result := algFastDoubling    Else If lowerStr = 'iterative' Then        Result := algIterative    Else If lowerStr = 'hybrid' Then        Result := algHybrid    Else        Raise EConvertError.Create('Invalid algorithm: ' + Str + '. Use: matrix, fastdoubling, iterative, or hybrid');End;// ----------------------------------------------------------------------------// Benchmark all methods for a given n// ----------------------------------------------------------------------------Procedure BenchmarkMethods(n: Int64);Var    result1, result2, result3, result4: mpz_t;    s1, s2, s3, s4: AnsiString;    startTime, endTime: TDateTime;Begin    WriteLn('========================================');    WriteLn('Benchmarking F(', n, ')');    WriteLn('========================================');    mpz_init(result1);    mpz_init(result2);    mpz_init(result3);    mpz_init(result4);    // Benchmark Matrix method    WriteLn;    WriteLn('1. Matrix Exponentiation Method:');    startTime := Now;    FibonacciMatrix(n, result1);    endTime := Now;    s1 := mpz_get_str(Nil, 10, result1);    WriteLn('Result length: ', Length(s1), ' digits');    WriteLn('Total time: ', MilliSecondsBetween(endTime, startTime), ' ms');    // Benchmark Fast Doubling method    WriteLn;    WriteLn('2. Fast Doubling Method:');    startTime := Now;    FibonacciFastDoubling(n, result2);    endTime := Now;    s2 := mpz_get_str(Nil, 10, result2);    WriteLn('Result length: ', Length(s2), ' digits');    WriteLn('Total time: ', MilliSecondsBetween(endTime, startTime), ' ms');    // Benchmark Hybrid method    WriteLn;    WriteLn('3. Hybrid Doubling/Tripling Method:');    startTime := Now;    FibonacciHybrid(n, result3);    endTime := Now;    s3 := mpz_get_str(Nil, 10, result3);    WriteLn('Result length: ', Length(s3), ' digits');    WriteLn('Total time: ', MilliSecondsBetween(endTime, startTime), ' ms');    // Verify results match    If (mpz_cmp(result1, result2) = 0) and (mpz_cmp(result2, result3) = 0) Then        WriteLn('✓ All results match!')    Else        WriteLn('✗ ERROR: Results do not match!');    // Benchmark Iterative method if n is small enough    If (n >= Low(Integer)) And (n <= High(Integer)) And (Abs(n) <= 100000) Then    Begin        WriteLn;        WriteLn('4. Iterative Method (for comparison):');        startTime := Now;        FibonacciIterative(Integer(n), result4);        endTime := Now;        s4 := mpz_get_str(Nil, 10, result4);        WriteLn('Result length: ', Length(s4), ' digits');        WriteLn('Total time: ', MilliSecondsBetween(endTime, startTime), ' ms');        If mpz_cmp(result1, result4) = 0 Then            WriteLn('✓ Iterative result matches!')        Else            WriteLn('✗ ERROR: Iterative result does not match!');    End    Else    Begin        WriteLn;        WriteLn('4. Iterative Method: Skipped (n too large)');    End;    WriteLn;    mpz_clear(result1);    mpz_clear(result2);    mpz_clear(result3);    mpz_clear(result4);End;// ----------------------------------------------------------------------------// Main program with CLI argument handling// ----------------------------------------------------------------------------Var    fib_gmp: mpz_t;    n: Int64;    i: Integer;    algorithm: TAlgorithm;    benchmarkMode: Boolean;Begin    // Initialize GMP result    mpz_init(fib_gmp);    // Check command line arguments    If ParamCount >= 1 Then    Begin        // Parse first argument as 64-bit integer        Try            n := ParseLargeInt(ParamStr(1));            // Check for algorithm selection (second argument)            algorithm := algMatrix;  // Default            benchmarkMode := False;            For i := 2 To ParamCount Do            Begin                If LowerCase(ParamStr(i)) = '-benchmark' Then                    benchmarkMode := True                Else If Pos('-a=', LowerCase(ParamStr(i))) = 1 Then                Begin                    Try                        algorithm := ParseAlgorithm(Trim(Copy(ParamStr(i), 4, MaxInt)));                    Except                        On E: EConvertError Do                        Begin                            WriteLn('Warning: ', E.Message);                            WriteLn('Using default algorithm: matrix');                        End;                    End;                End;            End;            If benchmarkMode Then            Begin                BenchmarkMethods(n);            End            Else            Begin                // Compute Fibonacci number with selected algorithm                Case algorithm Of                    algMatrix:                    Begin                        WriteLn('Computing F(', n, ') using matrix exponentiation...');                        FibonacciMatrix(n, fib_gmp);                    End;                    algFastDoubling:                    Begin                        WriteLn('Computing F(', n, ') using fast doubling...');                        FibonacciFastDoubling(n, fib_gmp);                    End;                    algIterative:                    Begin                        // For iterative method, we need to check if n fits in 32-bit                        If (n < Low(Integer)) Or (n > High(Integer)) Then                        Begin                            WriteLn('Error: Iterative method only supports n between ',                                    Low(Integer), ' and ', High(Integer));                            WriteLn('Use matrix, fastdoubling, or hybrid method for larger values.');                            Halt(1);                        End;                        WriteLn('Computing F(', n, ') using iterative method...');                        FibonacciIterative(Integer(n), fib_gmp);                    End;                    algHybrid:                    Begin                        WriteLn('Computing F(', n, ') using hybrid (doubling/tripling) method...');                        FibonacciHybrid(n, fib_gmp);                    End;                End;                // Display result                DisplayLargeFibonacci(n, fib_gmp);            End;        Except            On E: EConvertError Do                WriteLn('Error: ', E.Message);        End;    End    Else    Begin        // No arguments: run demonstration        WriteLn('No command line argument provided. Running demonstration...');        WriteLn;        WriteLn('========================================');        WriteLn('Fibonacci Sequence Demonstration');        WriteLn('========================================');        WriteLn;        // Test from -10 to 10        WriteLn('Fibonacci numbers from -10 to 10 (using fast doubling):');        For i := -10 To 10 Do        Begin            FibonacciFastDoubling(i, fib_gmp);            WriteLn('F(', i:3, ') = ', mpz_get_str(Nil, 10, fib_gmp));        End;        WriteLn;        // Benchmark different methods for moderate n        WriteLn('Benchmark for n = 1,000,000:');        BenchmarkMethods(1000000);        // Benchmark for larger n        WriteLn('Benchmark for n = 10,000,000:');        BenchmarkMethods(10000000);        // Comparison with iterative method for small n        WriteLn('Comparison for small n (30):');        Write('Matrix method: ');        FibonacciMatrix(30, fib_gmp);        WriteLn(mpz_get_str(Nil, 10, fib_gmp));        Write('Hybrid method: ');        FibonacciHybrid(30, fib_gmp);        WriteLn(mpz_get_str(Nil, 10, fib_gmp));        Write('Iterative method: ');        FibonacciIterative(30, fib_gmp);        WriteLn(mpz_get_str(Nil, 10, fib_gmp));        WriteLn;        WriteLn('Usage examples:');        WriteLn('  ./FastFibonacciGMP 100                             # Compute F(100) with matrix (default)');        WriteLn('  ./FastFibonacciGMP 100 -a=fastdoubling             # Compute with fast doubling');        WriteLn('  ./FastFibonacciGMP 100 -a=hybrid                   # Compute with hybrid method (recommended)');        WriteLn('  ./FastFibonacciGMP 100 -a=iterative                # Compute with iterative (small n only)');        WriteLn('  ./FastFibonacciGMP 1000000 -benchmark              # Benchmark all methods');        WriteLn('  ./FastFibonacciGMP -50 -a=fastdoubling             # Compute negative Fibonacci');        WriteLn('  ./FastFibonacciGMP 18000000000 -a=hybrid # Compute large F(18^9) takes 11GB, 154701 ms to calculate/20 mins to write out');        WriteLn;        WriteLn('Available algorithms:');        WriteLn('  matrix         : Matrix exponentiation (O(log n))');        WriteLn('  fastdoubling   : Fast doubling iterative (O(log n), very fast)');        WriteLn('  hybrid         : Hybrid doubling/tripling (O(log n), fastest for large n) ★ RECOMMENDED');        WriteLn('  iterative      : Iterative method (O(n), for small n ≤ 100000 only)');    End;    // Cleanup    mpz_clear(fib_gmp);    WriteLn('Program completed.');End.(*)*)  AI means corrected logic for AI itself: the first attempts were mistranslations**) AI Finally understood what the algorithm is doing (after 12 sessions)(*)<PRE>

JPD 2021/05/15 Updated: 2025-12-06T07:11:11

./FastFibonacciGMPNo command line argument provided. Running demonstration...

============================

Fibonacci Sequence Demonstration

============================

Fibonacci numbers from -10 to 10 (using fast doubling):Fast doubling method time: 0 msF(-10) = -55Fast doubling method time: 0 msF( -9) = 34Fast doubling method time: 0 msF( -8) = -21Fast doubling method time: 0 msF( -7) = 13Fast doubling method time: 0 msF( -6) = -8Fast doubling method time: 0 msF( -5) = 5Fast doubling method time: 0 msF( -4) = -3Fast doubling method time: 0 msF( -3) = 2Fast doubling method time: 0 msF( -2) = -1Fast doubling method time: 0 msF( -1) = 1Fast doubling method time: 0 msF( 0) = 0Fast doubling method time: 0 msF( 1) = 1Fast doubling method time: 0 msF( 2) = 1Fast doubling method time: 0 msF( 3) = 2Fast doubling method time: 0 msF( 4) = 3Fast doubling method time: 0 msF( 5) = 5Fast doubling method time: 0 msF( 6) = 8Fast doubling method time: 0 msF( 7) = 13Fast doubling method time: 0 msF( 8) = 21Fast doubling method time: 0 msF( 9) = 34Fast doubling method time: 0 msF( 10) = 55

Benchmark for n = 1,000,000:

============================

Benchmarking F(1000000)

============================

1. Matrix Exponentiation Method:Matrix method time: 24 msResult length: 208988 digitsTotal time: 24 ms

2. Fast Doubling Method:Fast doubling method time: 4 msResult length: 208988 digitsTotal time: 4 ms

3. Hybrid Doubling/Tripling Method:Operations: ² ² ² ³ ³ ³ ² ² ² ³ ³ ² ² ² ² ² ² ² Hybrid method time: 3 msResult length: 208988 digitsTotal time: 3 ms✓ All results match!

4. Iterative Method: Skipped (n too large)

Benchmark for n = 10,000,000:

============================

Benchmarking F(10000000)

============================

1. Matrix Exponentiation Method:Matrix method time: 328 msResult length: 2089877 digitsTotal time: 328 ms

2. Fast Doubling Method:Fast doubling method time: 46 msResult length: 2089877 digitsTotal time: 46 ms

3. Hybrid Doubling/Tripling Method:Operations: ² ² ² ³ ³ ³ ² ² ² ³ ³ ² ² ² ² ² ² ² ² ² ² Hybrid method time: 43 msResult length: 2089877 digitsTotal time: 43 ms✓ All results match!

4. Iterative Method: Skipped (n too large)

Comparison for small n (30):Matrix method: Matrix method time: 0 ms832040Hybrid method: Operations: ² ² ² ² ³ Hybrid method time: 0 ms832040Iterative method: Iterative method time: 0 ms832040

Usage examples:

 ./fibonacci 100                             # Compute F(100) with matrix (default) ./fibonacci 100 -a=fastdoubling             # Compute with fast doubling ./fibonacci 100 -a=hybrid                   # Compute with hybrid method (recommended) ./fibonacci 100 -a=iterative                # Compute with iterative (small n only) ./fibonacci 1000000 -benchmark              # Benchmark all methods ./fibonacci -50 -a=fastdoubling             # Compute negative Fibonacci ./fibonacci 1000000000000000000             # Compute huge F(10^18)

Available algorithms:

 matrix         : Matrix exponentiation (O(log n)) fastdoubling   : Fast doubling iterative (O(log n), very fast) hybrid         : Hybrid doubling/tripling (O(log n), fastest for large n) ★ RECOMMENDED iterative      : Iterative method (O(n), for small n ≤ 100000 only)

Program completed.

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 := 0end;

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;  //maXboxbegin   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 formulaeto pass from F[k],F[k+1] to F[2k],F[2k+1]. If the current bit of n (startingfrom 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 caseend;// Main programvar  n : word;begin  for n := 0 to 93 do    WriteLn( SysUtils.Format( 'F[%2u] = %20u', [n, Fibonacci(n)]));end.

Output:

F[ 0] =                    0F[ 1] =                    1F[ 2] =                    1F[ 3] =                    2F[ 4] =                    3F[ 5] =                    5F[ 6] =                    8F[ 7] =                   13[...]F[90] =  2880067194370816120F[91] =  4660046610375530309F[92] =  7540113804746346429F[93] = 12200160415121876738

PascalABC.NET

Uses functionality fromFibonacci n-step number sequences#PascalABC.NET

// Fibonacci sequence. Nigel Galloway: August 30th., 2022begin  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 aremuch faster at large values.

# Uses GMP method so very fastuse Math::AnyNum qw/fibonacci/;say fibonacci(10000);# Uses GMP method, so also very fastuse Math::GMP;say Math::GMP::fibonacci(10000);# Binary ladder, GMP if available, Pure Perl otherwiseuse ntheory qw/lucasu/;say lucasu(1, -1, 10000);# All Perluse Math::NumSeq::Fibonacci;my $seq = Math::NumSeq::Fibonacci->new;say $seq->ith(10000);# All Perluse 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 ton into an array ofn+1 elements (to account for the zeroth Fibonacci number). When the loop reachesn, the function returns the last element of the array, i.e. then-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 aboven=93 and treats any number as infinite aboven=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) -> 0Fibonacci(1) -> 1Fibonacci(2) -> 1Fibonacci(3) -> 2Fibonacci(4) -> 3Fibonacci(5) -> 5Fibonacci(6) -> 8Fibonacci(7) -> 13Fibonacci(8) -> 21Fibonacci(9) -> 34Fibonacci(10) -> 55Fibonacci(11) -> 89Fibonacci(12) -> 144Fibonacci(13) -> 233Fibonacci(14) -> 377Fibonacci(15) -> 610Fibonacci(16) -> 987Fibonacci(17) -> 1597Fibonacci(18) -> 2584Fibonacci(19) -> 4181Fibonacci(20) -> 6765Fibonacci(50) -> 12586269025Fibonacci(93) -> 12200160415121876738Fibonacci(94) -> 1.97402742198682e+19Fibonacci(100) -> 3.54224848179262e+20Fibonacci(200) -> 2.8057117299251e+41Fibonacci(1000) -> 4.34665576869374e+208Fibonacci(1476) -> 1.3069892237634e+308Fibonacci(1477) -> Inf

Phix

functionfibonacci(integern)-- iterative, works for -ve numbersatoma=0,b=1ifn=0thenreturn0endififabs(n)>=79then?9/0endif-- inaccuracies creep in above 78fori=1toabs(n)-1do{a,b}={b,a+b}endforifn<0andremainder(n,2)=0thenreturn-bendifreturnbendfunctionfori=0to28doifithenputs(1,", ")endifprintf(1,"%d",fibonacci(i))endforputs(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.exwwithjavascript_semanticsincludempfr.empzres=NULL,prev,nextintegerlastnatomt0=time()functionfibonampz(integern)-- resumable, works for -ve numbers, yields mpzintegerabsn=abs(n)ifres=NULLorabsn!=abs(lastn)+1thenifres=NULLthenprev=mpz_init(0)res=mpz_init(1)next=mpz_init()elseifn==lastnthenreturnresendifendifmpz_fib2_ui(res,prev,absn)elseiflastn<0andremainder(lastn,2)=0thenmpz_mul_si(res,res,-1)endifmpz_add(next,res,prev){prev,res,next}={res,next,prev}endififn<0andremainder(n,2)=0thenmpz_mul_si(res,res,-1)endiflastn=nreturnresendfunctionfori=0to28doifithenputs(1,", ")endifprintf(1,"%s",{mpz_get_str(fibonampz(i))})endforputs(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:integerbig=iff(platform()==JS?478495:4784969)strings=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, 317811970066202977562212558683426760773016559904631977220423547980211057068777324159443678590358026859129109599109446646966713225742014317926940054191330{1000000,"107273956418004772293648135962250043219...407167474856539211500699706378405156269"}"2.1s"

Phixmonti

def Fibonacci    dup 0 < if        "Invalid argument: " print    else         1 1 rot 2 -        for            drop            over over +        endfor    endifenddef10 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.tablefib_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.tablefib_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-> 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875

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=0LOOP:   if counter > 20 goto DONE  f = fib(counter)  print f  print "\n"  inc counter  goto LOOPDONE:  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 = 2FIBLOOP:  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 FIBLOOPRETURN0:  .return( 0 )  endRETURN1:  .return( 1 )  endDONE:  f = pop fibs  .return( f )  end.end.sub main :main  .local int counter  .local int f  counter=0LOOP:   if counter > 20 goto DONE  f = fib(counter)  print f  print "\n"  inc counter  goto LOOPDONE:  end.end

PL/0

The program waits forn. Then it displaysn^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;  ! bend.

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.

Pluto

function fib(n)  local a, b = 0, 1  for _ = 1,n do    a,b = b,a+b  end  return aendfor i = 0,10 do  print(fib(i))end

Output:

011235813213455

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:

Recursive

%!PS% We want the 'n'th fibonacci number/n 13 def% Prepare output canvas:/Helvetica findfont 20 scalefont setfont100 100 moveto%define the function recursively:/fib {   dup 2 lt  { }  {     dup 1 sub fib     exch 2 sub fib    add   } ifelse} def    (Fib\() show n (....) cvs show (\) = ) show n fib (.....) cvs showshowpage

Output

Fib(13) = 233

Iterative

%!PS/Courier 16 selectfont/fibonacci {  dup 2 lt  { }  {    0 exch    1 exch    2 exch 1 exch {      pop      exch      1 index      add    } for    exch    pop  } ifelse} def/str 4 string def/n 10 def72 720 moveto0 1 n {  fibonacci str cvs  str show  pop} forshowpage

Output

0  1  1  2  3  5  8  13  21  34  55

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)= 165580141real0m2.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 ^2matrix = (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:

1123581321345589144233377

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 withSWI-Prolog and module lambda, written byUlrich Neumerkel found therehttp://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 withSWI-Prolog and others that supportfreeze/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 predicatefib(Xs) unifiesXs 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 generatorfib(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 Histodata 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):  assert isinstance(n,int), "n must be an integer."  assert n<=71 , "n must be <=71 due to floating point precision limitations."  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

Analytic with wider domain

Binet's formula for Fibonacci numbers up to 91, by using longdoubles:

def analytic_fibonacci91(m): """Binet's algebraic formula for the nth Fibonacci number. Good for up to n=91 Uses numpy longdoubles: See: https://artofproblemsolving.com/wiki/index.php/Binet%27s_Formula"""    import numpy as np    assert isinstance(m,int), "parameter must be an integer."    assert 0<=m<=91 , "n must be in the range 0 .. 91 due to double precision floating point precision limitations."    if m < 2: return m    # Make sure that nothing causes conversion to single    n=np.longdouble(m)    C1=np.longdouble(1)    C2=np.longdouble(2)    C5=np.longdouble(5)    Chalf=C1/C2    Cfifth=C1/C5    root5=C5**Chalf    t1=(C1+root5)/C2       t2=(C1-root5)/C2      f=(t1**n-t2**n)/root5        return int(f+0.1)# Usageprint(f:=[[i,analytic_fibonacci91(i)] for i in range(92)])

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], [41, 165580141], [42, 267914296], [43, 433494437], [44, 701408733], [45, 1134903170], [46, 1836311903], [47, 2971215073], [48, 4807526976], [49, 7778742049], [50, 12586269025], [51, 20365011074], [52, 32951280099], [53, 53316291173], [54, 86267571272], [55, 139583862445], [56, 225851433717], [57, 365435296162], [58, 591286729879], [59, 956722026041], [60, 1548008755920], [61, 2504730781961], [62, 4052739537881], [63, 6557470319842], [64, 10610209857723], [65, 17167680177565], [66, 27777890035288], [67, 44945570212853], [68, 72723460248141], [69, 117669030460994], [70, 190392490709135], [71, 308061521170129], [72, 498454011879264], [73, 806515533049393], [74, 1304969544928657], [75, 2111485077978050], [76, 3416454622906707], [77, 5527939700884757], [78, 8944394323791464], [79, 14472334024676221], [80, 23416728348467685], [81, 37889062373143906], [82, 61305790721611591], [83, 99194853094755497], [84, 160500643816367088], [85, 259695496911122585], [86, 420196140727489673], [87, 679891637638612258], [88, 1100087778366101931], [89, 1779979416004714189], [90, 2880067194370816120], [91, 4660046610375530309]]

Binomial

Binet's algebraic formula as an all integer binomial expansion.

NOTE: This implementation isNOT faster than simply progressing up to Fib(n) by addition, starting from Fib(1).

def fib4k(n): # FIBonacci's numbers, Binet's Formula, Barron's Binomial expansion, Kra's code.     # (c) 2025 David A. Kra GNUFDL1.3 and Copyleft Creative Commons CC BY-SA Attribution-ShareAlike    #     # ALL INTEGER. Tested up to Fib(4000).    # NOTE: This implementation is NOT faster than simply progressing up to Fib(n) by addition, starting from Fib(1).    # Thanks, Acknowledgement, and Appreciation to Barron https://stackexchange.com/users/9594318/barron     # No floats were exploited in the production of this function.    # References:    #   https://math.stackexchange.com/questions/674570/prove-that-binets-formula-gives-an-integer-using-the-binomial-theorem    #   https://math.stackexchange.com/questions/2002702/fibonacci-identity-with-binomial-coefficients    #   https://artofproblemsolving.com/wiki/index.php/Binet%27s_Formula    #       https://latex.artofproblemsolving.com/8/6/d/86d486c560727727342090b432e23ba85ac098b1.png     #   https://www.geeksforgeeks.org/find-nth-fibonacci-number-using-binets-formula/    #   https://discuss.geeksforgeeks.org/comment/540dc728-8cfc-41e3-853e-e920e0a85101/gfg     #    # Fn=(1/(2**(n-1))) * SUM(j=0,n//2,((5**j)*comb(n,2*j+1))    #     #   qc == Quick Combination. Instead of using comb, with its loop on each call,     #           derive the next (  comb(n,2*j+1)  ) by building up from what had already been calculated,     #           Given comb(n,2*j+1), then     #                 comb(n,2*(j+1)+1) = comb(n,2*j+1) *  (n-(2*j+1))*(n-2*j+1)-1) // ( (2*j+1)+1)*(2*j+1)+2) )    #   qp == Quick Power. Instead of using 5**j, derive the next fttj as fttj*=5     #    f=0    fttj=1    qc=n # = comb(n,1)    for j in range(0,int(n/2+1)):        f+=fttj*qc  # (5**k)*qc #  qc == comb(n,2*k+1)        j2p1=j*2+1          # calculate the 5**k and the combinations for the next iteration,        #   but for now, k and k2p1 have this iteration's values.        fttj*=5        qc=qc* (n-j2p1)*(n-j2p1-1) // ( (j2p1+1)*(j2p1+2) )   # for the next iteration    f=f//(2 ** (n-1) )    return f</syntaxhighlight lang="python"><pre>Testprint([[i,fib4k(i)] for i in [4,40,400,4000]])output[[4, 3], [40, 102334155], [400, 176023680645013966468226945392411250770384383304492191886725992896575345044216019675], [4000, 39909473435004422792081248094960912600792570982820257852628876326523051818641373433549136769424132442293969306537520118273879628025443235370362250955435654171592897966790864814458223141914272590897468472180370639695334449662650312874735560926298246249404168309064214351044459077749425236777660809226095151852052781352975449482565838369809183771787439660825140502824343131911711296392457138867486593923544177893735428602238212249156564631452507658603400012003685322984838488962351492632577755354452904049241294565662519417235020049873873878602731379207893212335423484873469083054556329894167262818692599815209582517277965059068235543139459375028276851221435815957374273143824422909416395375178739268544368126894240979135322176080374780998010657710775625856041594078495411724236560242597759185543824798332467919613598667003025993715274875]]</pre>===Iterative===<syntaxhighlight lang="python">def fib_iter(n):    if n < 2:        return n    fib_prev = 1    fib = 1    for _ in range(2, n):        fib_prev, fib = fib, fib + fib_prev    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 0for 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 fib_rec(n):    if n < 2:        return n    return fib_rec(n-1) + fib_rec(n-2)

Recursive with Memoization

def fib_memo():    pad = {0:0, 1:1}    def sub_func(n):        if not n in pad:            pad[n] = sub_func(n-1) + sub_func(n-2)        return pad[n]    return sub_funcfm = fib_memo()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 fib_fast_rec(n):    def inner_fib(prvprv, prv, c):        if c < 1:             return prvprv        return inner_fib(prv, prvprv + prv, c - 1)     return inner_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 fib_gen(n):    a, b = 0, 1    while n>0:        yield a        a, b, n = b, a+b, n-1

Example use

>>> [i for i in fib_gen(11)][0,1,1,2,3,5,8,13,21,34,55]

Matrix-Based

Translation of the matrix-based approach used in F#.

def prev_pow_two(n):    """Gets the power of two that is less than or equal to the given input    """    if ((n & -n) == n):        return n    n -= 1    n |= n >> 1    n |= n >> 2    n |= n >> 4    n |= n >> 8    n |= n >> 16    n += 1    return n//2def crazy_fib(n):    """Crazy fast fibonacci number calculation    """    pow_two = prev_pow_two(n)        q = r = i = 1    s = 0        while i < pow_two:        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    lhs, rhs = fib(), fib()    # move lhs one iteration ahead    yield next(lhs)    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 islicedef 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

def fibs(n):    """Fibonacci accumulation    An accumulation of the first n integers in the Fibonacci series. The accumulator is a    pair of the two preceding numbers.    """    # Local import is more efficient.    from itertools import accumulate    # Note: Numbers generated in range(1, n) [or range(n-1)] call will not be used.    return [a for a, b in accumulate(        range(1, n),        lambda acc, _: (acc[1],  sum(acc)),        initial = (0, 1)        )    ]# MAIN ---if __name__ == '__main__':    print(f'First twenty: {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

def nth_fib(n):    """Nth Fibonacci term (by folding)        Nth integer in the Fibonacci series.    """    from functools import reduce    return reduce(        lambda acc, _: (acc[1], sum(acc)),        range(1, n),        (0, 1)    )[0]# MAIN ---if __name__ == '__main__':    n = 1000    print(f'{n}th term: {nth_fib(n)}')

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 = 21for x in range(1,fiblength-1):xcount = fibseq[x-1] + fibseq[x]fibseq.append(xcount)print(xcount)

Output:

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

# recursiverecfibo <- function(n) {  if ( n < 2 ) n  else Recall(n-1) + Recall(n-2)}# print the first 21 elementsprint.table(lapply(0:20, recfibo))# iterativeiterfibo <- 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'ingfuncfibo <- 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 startargs := program argumentsif args emptyprint .fibonacci(8)elsetryprint .fibonacci(integer.parse(args[0]))catch FormatExceptionprint to Console.error made !, "Input must be an integer"exit program with error codecatch OverflowExceptionprint to Console.error made !, "Number too large"exit program with error codedefine fibonacci(n as integer) as integer is shared**Returns the nth fibonacci number**testassert fibonacci(0) = 0assert fibonacci(1) = 1assert fibonacci(2) = 1assert fibonacci(3) = 2assert fibonacci(4) = 3assert fibonacci(5) = 5assert fibonacci(6) = 8assert fibonacci(7) = 13assert fibonacci(8) = 21bodya, b := 0, 1for na, b := b, a + breturn 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, loopinteger*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)countnum1 = 0num2 = 1write(6,3,advance='no')num1write(6,3,advance='no')num2for (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: 0fn: 1loop 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 = nelseset f0 = 0set f1 = 1set k = 2while k <= nset result = f0 + f1set f0 = f1set f1 = resultset k = k + 1end whileend ifend 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

IncludeHow to use
IncludeSource code
Without special measures, the closed formula requires floating point calculations (exponentiation and root) in high precision if you want to calculate F1000 and on. For a given number, below program shows both running the whole sequence up to that number and using the formula.

-- 19 Sep 2025include Settingsay 'FIBONACCI SEQUENCE'say versionsaysay 'Fibonacci numbers up to F100 are...'call Fibonacci1 100saycall Timer 'r'say 'Selected Fibonacci numbers using recurrence...'call Fibonacci2 1e2call Fibonacci2 1e3call Fibonacci2 1e4call Fibonacci2 1e5call Fibonacci2 1e6saycall Timer 'r'say 'Selected Fibonacci numbers using closed formula...'call Fibonacci3 1e2call Fibonacci3 1e3call Fibonacci3 1e4call Fibonacci3 1e5saycall Timer 'r'exitFibonacci1:-- Show sequencearg xxnumeric digits 25call CharOut ,Right(0,22) Right(1,21)a=0; b=1do i=2 to xx   c=b+a; a=b; b=c   call CharOut ,Right(c,22)   if i//5=4 | i//5=9 then      sayendsayreturnFibonacci2:-- Get specific number sequencearg xxnumeric digits xx/4a=0; b=1do i=2 to xx   f=b+a; a=b; b=fendsay 'F'xx '=' Left(f,10)'...'Right(f,10) '('Xpon(f) 'digits)' elaps('r')'s'returnFibonacci3:-- Get specific number formulaarg xxnumeric digits xx/4f=Round(((0.5*(1+SqRt(5)))**xx-(0.5*(1-SqRt(5)))**xx)/SqRt(5))/1say 'F'xx '=' Left(f,10)'...'Right(f,10) '('Xpon(f) 'digits)' elaps('r')'s'returninclude Math

Output:

FIBONACCI SEQUENCEREXX-ooRexx_5.1.0(MT)_64-bit 6.05 2 May 2025Fibonacci numbers up to F100 are...                     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 3542248481792619150750.001 secondsSelected Fibonacci numbers using recurrence...F1E2 = 3542248481...9261915075 (20 digits) 0.001sF1E3 = 4346655768...6849228875 (208 digits) 0.001sF1E4 = 3364476487...9947366875 (2089 digits) 0.026sF1E5 = 2597406934...3428746875 (20898 digits) 2.818sF1E6 = 1953282128...8242546875 (208987 digits) 279.338s282.183 secondsSelected Fibonacci numbers using closed formula...F1E2 = 3542248481...9261915075 (20 digits) 0sF1E3 = 4346655768...6849228875 (208 digits) 0.004sF1E4 = 3364476487...9947366875 (2089 digits) 0.511sF1E5 = 2597406934...3428746875 (20898 digits) 60.319s60.834 seconds

Maybe a surprise, but in REXX running the whole sequence for getting 1 number is faster.

Rhombus

Recursive

#lang rhombus/staticfun fib:| fib(0): 1| fib(1): 1| fib(n): fib(n-2) + fib(n-1)

Recursive with Memoization

#lang rhombus/staticdef cache = MutableMap()fun fib:| fib(0): 1| fib(1): 1| fib(n):    guard n !in cache | cache[n]    let result = fib(n-2) + fib(n-1)    cache[n] := result    resultfib(100) // 573147844013817084101

Rhovas

Solutions support arbitrarily large numbers as Rhovas'sInteger type is arbitrary-precision (JavaBigInteger). Additional notes:

require num >= 0; asserts input range preconditions, throwing on negative numbers

Iterative

Standard iterative solution using afor 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 aconditional match, which works likeif/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 existingpositiveFibonacci 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 nx = fib(n)see n + " Fibonacci is : " + xfunc 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 FNextSay Fibonacci taking 1000 (prints out highest number in Fibonacci sequence less than 1000)

Iterative (idiomatic)

Love takes TimeMy love was addictionsPut my love into your heartBuild it upUntil my love is as strong as TimeWhisper my lovePut my love into a riverPut your heart into my lovePut it with a river into your heartShout; 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 promiselove is populationhate is informationIf a lover is loveGive back a kissIf a lover is hateGive back a promiseKnock a lover downPut a promise with a kiss into my heartGive back The Italian taking a lover, a promise, my heartListen to your heartyour mind is everythingyour soul is opportunityWhisper The Italian taking your heart, your mind, your soul

Rocq

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 .

RPL

Works with:Halcyon Calc version 4.2.7

Iterative, with n<0 support

≪IF DUP 0 <THEN NEG -1 OVER ^ELSE 1END   SWAP 0 1   0 4 ROLLSTART OVER + SWAPNEXT    SWAP DROP *≫ '→FIB' STO≪ { } 0 20FOR j j→FIB +NEXT ≫ EVAL

Recursive

≪IF DUP 2 >THEN      DUP 1 -→FIB      SWAP 2 -→FIB +ELSE SIGNEND ≫ '→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) andF(2k+1) = F(k)² + F(k+1)²

≪IF DUP 2 ≤THEN SIGNELSEIF DUP 2 MODTHEN 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  endendp (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]         endend# 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  endend

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  endend9.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}112358132134=> 9

Binet's Formula

def fib    phi = (1 + Math.sqrt(5)) / 2    ((phi**self - (-1 / phi)**self) / Math.sqrt(5)).to_iend

1.9.3p125 :001 > def fib1.9.3p125 :002?>   phi = (1 + Math.sqrt(5)) / 21.9.3p125 :003?>   ((phi**self - (-1 / phi)**self) / Math.sqrt(5)).to_i1.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 tablefib 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@tailrecfinal 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 numbersdef 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))

Schönhage Algorithm

(define (fast-fib-pair n)  ;; By Arnold Schönhage, personal communication, 2004  ;; returns f_n f_{n+1}  (case n    ((1) (values 1 1))    ((2) (values 1 2))    (else     (let ((m (quotient n 2)))       (call-with-values           (lambda () (fast-fib-pair m))         (lambda (f_m f_m+1)           (let ((f_m^2   (square f_m))                 (f_m+1^2 (square f_m+1)))             (if (even? n)                 (values (- (* 2 f_m+1^2)                            (* 3 f_m^2)                            (if (odd? m) -2 2))                         (+ f_m^2 f_m+1^2))                 (values (+ f_m^2 f_m+1^2)                         (- (* 3 f_m+1^2)                            (* 2 f_m^2)                            (if (odd? m) -2 2)))))))))))(call-with-values    (lambda ()      (fast-fib-pair 100000000))  (lambda (f_n f_n+1)    (display (list (modulo f_n 100000) (modulo f_n+1 100000)))    (newline)))

Output:

(46875 37501)

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)=433494437fibo(44)=701408733fibo(45)=1134903170fibo(46)=1836311903

sed

#!/bin/sed -f# First we need to convert each number into the right number of ticks # Start by marking digitss/[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/|||||/gs/6/||||||/g; s/7/|||||||/g; s/8/||||||||/g; s/9/|||||||||/g# Multiply by ten for each digit from the front.:tenss/|</<||||||||||/gt tens# Done with digit markerss/<//g# Now the actual work.:split# Convert each stretch of n >= 2 ticks into two of n-1, with a mark betweens/|\(|\+\)/\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:backs/||||||||||/</gs/<\([0-9]*\)$/<0\1/gs/|||||||||/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/</|/gt backs/^$/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 < 2elsefibonacci(n - 1) + fibonacci(n - 2);

Based on:[5]

Tail Recursive

fibonacci(n) := fibonacciHelper(0, 1, n);fibonacciHelper(prev, next, n) :=prev when n < 1elsenext when n = 1elsefibonacciHelper(next, next + prev, n - 1);

Matrix

fibonacci(n) := fibonacciHelper([[1,0],[0,1]], n);fibonacciHelper(M(2), n) := letN := [[1,1],[1,0]];inM[1,1] when n <= 1elsefibonacciHelper(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 functionproc 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 := hiEND;

SkookumScript

Built-in

SkookumScript'sInteger class has a fast built-infibonnaci() 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 withbenchmarking 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 same42.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 infibonacci(42) form.

// Assuming in fibonacci(n) procedure(Integer n) Integer  [  if n < 2 [n] else [fibonacci(n - 1) + fibonacci(n - 2)]  ]

Iterative

Iterative method in42.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 in42.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----555555.054.99999999999----100----354224848179261915075timeout3.54224848179262E+0203.54224848179263E+020----1000----43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875timeout4.34665576869373E+2084.34665576869373E+208----10000----336447648764317832666216120051075433103021...050562430701794976171121233066073310059947366875 (2089 digits)timeoutINF3.364476487643176087E+2089----100000----259740693472217241661550340212759154148804853...653428746875 (20898 digits)recursionINFINF----1000000----19532821287077577316320149475962563324435429965918733...2043347225419033684684301719893411568996526838242546875 (208987 digits)recursionINFINFTiming:-------1000 fibI: 94 µs (394736 cycles)timeout after 30000ms1000 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)fibfib = lt(a,2) a:s(return)fib = fib(a - 1) + fib(a - 2):(return)fib_endwhilea = 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 = 1if1     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 = s4end

Output:

1 1 2 3 5 8 13 21 34 551 1 2 3 5 8 13 21 34 551 1 2 3 5 8 13 21 34 551 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 ) ) fibofrom dualconnect by level <= 10;

       FIB----------         1         1         2         3         5         8        13        21        34        5510 rows selected.

As a power:

select round ( power( ( 1 + sqrt( 5 ) ) / 2, level ) / sqrt( 5 ) ) fibfrom dualconnect by level <= 10;

       FIB----------         1         1         2         3         5         8        13        21        34        5510 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        5510 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;

Works with:MariaDB

SET @row_count := 10;WITH RECURSIVE fibonacci_row (seq, current_value, next_value) AS(    (        SELECT            CAST(1 AS UNSIGNED INTEGER) AS seq,            CAST(0 AS UNSIGNED INTEGER) AS current_value,            CAST(1 AS UNSIGNED INTEGER) AS next_value    ) UNION ALL (        SELECT            seq + 1 AS seq,            next_value AS current_value,            current_value + next_value AS next_value        FROM fibonacci_row        WHERE seq + 1 <= @row_count    ))SELECT seq, current_value    FROM fibonacci_row;

SSEM

Calculates the tenth Fibonacci number. To calculate thenth, change the initial value of the counter ton-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 = -n01101000000001100000000000000000    1. c   to 22   temp = acc00101000000001010000000000000000    2. Sub. 20     acc -= m10101000000001100000000000000000    3. c   to 21   n = acc10101000000000100000000000000000    4. -21 to c    acc = -n10101000000001100000000000000000    5. c   to 21   n = acc01101000000000100000000000000000    6. -22 to c    acc = -temp00101000000001100000000000000000    7. c   to 20   m = acc11101000000000100000000000000000    8. -23 to c    acc = -count00011000000001010000000000000000    9. Sub. 24     acc -= -100000000000000110000000000000000   10. Test        skip next if acc<010011000000000000000000000000000   11. 25  to CI   goto (15 + 1)11101000000001100000000000000000   12. c   to 23   count = acc11101000000000100000000000000000   13. -23 to c    acc = -count11101000000001100000000000000000   14. c   to 23   count = acc00011000000000000000000000000000   15. 24  to CI   goto (-1 + 1)10101000000000100000000000000000   16. -21 to c    acc = -n10101000000001100000000000000000   17. c   to 21   n = acc10101000000000100000000000000000   18. -21 to c    acc = -n00000000000001110000000000000000   19. Stop00000000000000000000000000000000   20. 0           var m = 010000000000000000000000000000000   21. 1           var n = 100000000000000000000000000000000   22. 0           var temp = 010010000000000000000000000000000   23. 9           var count = 911111111111111111111111111111111   24. -1          const -111110000000000000000000000000000   25. 15          const 15

Stata

program fibargs nclearqui set obs `n'qui gen a=1qui replace a=a[_n-1]+a[_n-2] in 3/lend

An implementation usingdyngen.

program fibargs nclearqui set obs `n'qui gen a=.dyngen {update a=a[_n-1]+a[_n-2], missval(1)}endfib 10list

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

Stax

{v|5}

Non-builtin:

{01a{n+s}*d}YAFy!P

Output:

11235813213455

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 Cocoafunc 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

v0.5

nthFibonacci templates  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

v0.5 no longer has dot access

nthFibonacci templates  @ set {n0: 0"1", n1: 1"1"};  1..$ -> @ set {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

v0.5

nthFibonacci templates  @ set {n0: 0"1", n1: 1"1"};  sign is $ -> templates    when <|0..> do 1!    otherwise -1!  end;  1..$*$sign -> $sign -> !#  $@(n0:)!  when <|=1> do    @ set {n0: $@(n1:), n1: $@(n0:) + $@(n1:)};  when <|=-1> do    @ set {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

v0.5

nthFibonacci templates  { 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

Output:

21"1"5"1"-8"1"

TAV

\ Fibonacci numbers (iterative, with tuples)  main (parms):+  lim =: string parms[1] as integer else 100  fp =: 0, 1  ?# i =: from 1 upto lim    print i, fp.1    fp =: fp.2, fp.1 + fp.2  print i, fp.2

Output:

1 02 13 14 25 36 57 88 139 2110 34...94 1220016041512187673895 1974027421986822316796 3194043463499009990597 5168070885485832307298 8362114348984842297799 135301852344706746049100 218922995834555169026101 573147844013817084101

recursive

\ Fibonacci numbers (recursive)\+ stdlib fibo (n):  ? n < 2    :> n  :> (fibo n - 1) + fibo n - 2  \ not: fibo(n-1) + fibo(n-2) == fibo (n - 1 + fibo (n-2)   main (parms):+    lim =: string parms[1] as integer else 30    ?# i =: from 1 upto lim      print i, fibo i

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 inexpr expressions.

proc tcl::mathfunc::fib {n} {    if { $n < 2 } {        return $n    } else {        return [expr {fib($n-1) + fib($n-2)}]    }}# or, more terselyproc tcl::mathfunc::fib {n} {expr {$n<2 ? $n : fib($n-1) + fib($n-2)}}

E.g.:

expr {fib(7)} ;# ==> 13namespace path tcl::mathfunc #; or, interp alias {} fib {} tcl::mathfunc::fibfib 7 ;# ==> 13

Tail-Recursive

In Tcl 8.6 atailcall 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 100354224848179261915075

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 ;# ==> 5fibiter -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)} ;# ==> 5expr {fib(-6)} ;# ==> -8

For the Mathematically Inclined

This works up to ${\displaystyle 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 input1 STO 1      // Last term := 10            // Initial value: 0+ *EXC 1 =   // Calculate next term.*dsz 0 6     // Loop while R0 positiveR/S          // Done, show answerGTO 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	`INVSUM` `0`	R0 -= 1
04	`Lbl` `1`	loop
05	`+`
06	`x⮂t`	Swap Display with R7
07	`=`	Display += R7
08	`Dsz`	R0 -= 1
09	`GTO1`	until R0 == 0
10	`R/S`	Stop
11	`RST`	Go back to step 0

10RSTR/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 ) //ENDPROC 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 FALSEEND

Turing

% Recursivefunction fibb (n: int) : int    if n < 2 then        result n    else        result fibb (n-1) + fibb (n-2)    end ifend fibb% Iterativefunction ifibb (n: int) : int    var a := 0      var b := 1    for : 1 .. n        a := a + b        b := a - b    end for    result aend ifibbfor i : 0 .. 10    put fibb (i) : 4, ifibb (i) : 4end for

Output:

   0   0   1   1   1   1   2   2   3   3   5   5   8   8  13  13  21  21  34  34  55  55

TUSCRIPT

$$ MODE TUSCRIPTASK "What fibionacci number do you want?": searchfib=""IF (searchfib!='digits') STOPLoop 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,"=",fibENDLOOP

Output:

What fibionacci number do you want? >12fibionacci number 12=144

Output:

What fibionacci number do you want? >31fibionacci number 31=1346269

Output:

What fibionacci number do you want? >46fibionacci 46=1836311903

Uiua

Recursive

Works with:Uiua version 0.10.0-dev.1

Simple recursive example with memoisation.

F ← |1 memo⟨+⊃(F-1)(F-2)|∘⟩<2.F ⇡20

Iterative

Works with:Uiua version 0.17.0-dev.2

Simple iterative example:

15                # length of final array[1 1]             # starting two values in the sequence⊙◌⍢(⊂/+⊸↙2|>⧻) # do iteration while less than desired length

UNIX Shell

Works with:bash version 3

#!/bin/basha=0b=1max=$1for (( 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 isincorrect. Please fix the code and remove this message.

Details: There is a race between parallel commands.tee last might open and truncate the file beforecat last opens it. Thencat last pipes the empty file toxargs, andexpr reports a syntax error, and the script hangs forever.

echo 1 |tee last fib ; tail -f fib | while read xdo   cat last | tee -a fib | xargs -n 1 expr $x + |tee lastdone

Ursa

Translation of:Python

Iterative

def fibIter (int n)if (< n 2)return nend ifdecl int fib fibPrev numset fib (set fibPrev 1)for (set num 2) (< num n) (inc num)set fib (+ fib fibPrev)set fibPrev (- fib fibPrev)end forreturn fibend

Ursala

All three methods are shown here, and all have unlimited precision.

#import std#import natiterative_fib = ~&/(0,1); ~&r->ll ^|\predecessor ^/~&r sumrecursive_fib = {0,1}^?<a/~&a sum^|W/~& predecessor^~/~& predecessoranalytical_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 pointarithmetic from the mpfr library and then converts the result toa natural number. Sufficient precision for an exact result isalways chosen based on the argument. This test program computes the firsttwenty Fibonacci numbers by all three methods.

#cast %nLLexamples = <.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>>

Uxntal

%newline { [ LIT2 0a -Console/write ] DEO }|18 @Console/write|100 #1400 &loopDUP #00 SWP fibonacci print/dec newlineINC GTHk ?&loopPOP2BRK@fibonacci ( n* -- n!* )    ORAk ?{ JMP2r }    ORAk #01 NEQ ?{ JMP2r }     DUP2 #0001 SUB2 fibonacci STH2    #0002 SUB2 fibonacci    STH2r ADD2JMP2r@print/dec ( short* -- )#000a SWP2 [ LITr ff ]&get ( -- )SWP2k DIV2k MUL2 SUB2 STHPOP OVR2 DIV2 ORAk ?&getPOP2 POP2&put ( -- )STHr INCk ?{ POP JMP2r }[ LIT "0 ] ADD .Console/write DEO !&put

Output:

01123581321345589144233377610987159725844181

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;elsereturn 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 .entrymain,0                            7E 7CFD  0002     2 clro-(sp);result buffer                            5E   DD  0005     3 pushlsp;pointer to buffer                            10   DD  0007     4 pushl#16;descriptor: len of buffer                       5B   5E   D0  0009     5 movlsp, 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 addl34(sp), (sp), -(sp);next element on stack                            17   1D  0014    10 bvsret;vs - overflow set, exit                                     0016    11                             5B   DD  0016    12 pushlr11;-> descriptor by ref                         04 AE   DF  0018    13 pushal4(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 pushlr11;              00000000'GF   01   FB  0024    16 calls#1, g^lib$put_output;show result                            E2   11  002B    17 brbloop                                     002D    18 ret:                                 04  002D    19 ret                                     002E    20 .endmain$ 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 = 1Repeat(#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 addedbreak    }    #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        }BOFDel_Line(1)// Next nLine(1) EOLIns_Newline#10--    }    Goto_Line(2)// Results on line 2}// Copy the results to text register 10 in reverse orderReg_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) INreturn

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) =   0fibonacci( 1) =   1fibonacci( 2) =   1fibonacci( 3) =   2fibonacci( 4) =   3fibonacci( 5) =   5fibonacci( 6) =   8fibonacci( 7) =  13fibonacci( 8) =  21fibonacci( 9) =  34fibonacci(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 isforced to terminate.

It was generated from the following pseudo-Assembly.

push 0push 10:    swap    dup    onum    push 10    ochr    copy 1    add    jump 0

Output:

$ wspace fib.ws | head -n 6011235

Recursive

This program takes a numbern on standard input and outputs thenth member of the Fibonacci sequence.

; Read n.push 0dupinumload; Call fib(n), ouput the result and a newline, then exit.call 0onumpush 10ochrexit0:    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.ws55

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 fibRecfibRec = 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: 14930352Recursive: 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                                                                              .dataBEERCOUNT = 48;Fibs dd 0, 1, BEERCOUNT DUP(0);.codemain PROC; I am not responsible for this code.; They made me write it, against my will.;Here be dragonsmov 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+4294967295mov esi, offset FibsNextPlease:;mov eax, [esi]; ;//Get me the data from location at ESIadd 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 numberadd esi, 4;;//Update the pointerloop NextPlease;;//Thank you sir, may I have another?;Here be dragonsmov 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 systemmain ENDPEND 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  tjnf

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 aRANGE 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 iterationint 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 recursionint 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 2ret c; if n < 2 then doneld b,adec b; b = n - 1ld c,0; F0ld a,1; F1f8_l:ld d,aadd a,cld c,ddjnz f8_lret

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 setld h,0exx; now in regular setld hl,0cp 2ret c; if n < 2 then donedec a; loopcount = n - 1ld bc,0exx; now in alt setld bc,0ld hl,1f32_l:ld d,hld e,ladd hl,bcld b,dld c,eexx; now in reg setld d,hld e,ladc hl,bcld b,dld c,eexx; now in alt setdec ajr nz,f32_lexx; now in reg setret

YAMLScript

!YS-v0defn main(n=10):  loop a 0, b 1, i 1:    say: a    when i < n:      recur: b, (a + b), i.++

Output:

$ ys fibonacci-sequence.ys0112358132134

Zig

Translation of:C++

const std = @import("std");pub fn main() !void {    var a: u32 = 1;    var b: u32 = 1;    const target: u32 = 48;    for (3..target + 1) |n| {        const fib = a + b;        std.debug.print("F({}) = {}\n", .{n, fib});        a = b;        b = fib;    }}

Output:

F(3) = 2F(4) = 3F(5) = 5F(6) = 8F(7) = 13F(8) = 21F(9) = 34F(10) = 55F(11) = 89F(12) = 144F(13) = 233F(14) = 377F(15) = 610F(16) = 987F(17) = 1597F(18) = 2584F(19) = 4181F(20) = 6765F(21) = 10946F(22) = 17711F(23) = 28657F(24) = 46368F(25) = 75025F(26) = 121393F(27) = 196418F(28) = 317811F(29) = 514229F(30) = 832040F(31) = 1346269F(32) = 2178309F(33) = 3524578F(34) = 5702887F(35) = 9227465F(36) = 14930352F(37) = 24157817F(38) = 39088169F(39) = 63245986F(40) = 102334155F(41) = 165580141F(42) = 267914296F(43) = 433494437F(44) = 701408733F(45) = 1134903170F(46) = 1836311903F(47) = 2971215073

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.

Retrieved from "https://rosettacode.org/wiki/Fibonacci_sequence?oldid=396826"

Categories:

Hidden category:

Pages with syntax highlighting errors

Cookies help us deliver our services. By using our services, you agree to our use of cookies.

[8]ページ先頭