Fibonacci sequence: Difference between revisions
m
FutureBasic entry moved out of the Basic group
PatGarrett (talk | contribs) (→{{header|VBA}}: Variant is better than Long) |
m (FutureBasic entry moved out of the Basic group) |
||
| (333 intermediate revisions by more than 100 users not shown) | |||
Line 38:
=={{header|0815}}==
<
%<:0D:>~$<:01:~%>=<:a94fad42221f2702:>~>
}:_s:{x{={~$x+%{=>~>x~-x<:0D:~>~>~^:_s:?
</syntaxhighlight>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F fib_iter(n)
I n < 2
R n
V fib_prev = 1
V fib = 1
L 2 .< n
(fib_prev, fib) = (fib, fib + fib_prev)
R fib
L(i) 1..20
print(fib_iter(i), end' ‘ ’)
print()</syntaxhighlight>
{{out}}
<pre>
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
</pre>
=={{header|360 Assembly}}==
For maximum compatibility, programs use only the basic instruction set.
===using fullword integers===
<
* integer (31 bits) = 10 decimals -> max fibo(46)
FIBONACC CSECT
Line 96 ⟶ 117:
WTOBUF DC CL80'fibo(12)=1234567890'
REGEQU
END FIBONACC</
{{out}}
<pre>
Line 108 ⟶ 129:
</pre>
===using packed decimals===
<
* packed dec (PL8) = 15 decimals => max fibo(73)
FIBOWTOP CSECT
Line 155 ⟶ 176:
WTOBUF DC CL80'fibo(12)=123456789012345 '
REGEQU
END FIBOWTOP</
{{out}}
<pre>
Line 171 ⟶ 192:
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.
<
STA $F0 ; LOWER NUMBER
LDA #1
Line 186 ⟶ 207:
CPX #$0A ; STOP AT FIB(10)
BMI LOOP
RTS ; RETURN FROM SUBROUTINE</
=={{header|68000 Assembly}}==
{{trans|ARM Assembly}}
Input is in D0, and the output is also in D0. There is no protection from 32-bit overflow, so use at your own risk. (I used this [https://godbolt.org/ C compiler] to create this in ARM Assembly and translated it manually into 68000 Assembly. It wasn't that difficult since both CPUs have similar architectures.)
<syntaxhighlight lang="68000devpac">fib:
MOVEM.L D4-D5,-(SP)
MOVE.L D0,D4
MOVEQ #0,D5
CMP.L #2,D0
BCS .bar
MOVEQ #0,D5
.foo:
MOVE.L D4,D0
SUBQ.L #1,D0
JSR fib
SUBQ.L #2,D4
ADD.L D0,D5
CMP.L #1,D4
BHI .foo
.bar:
MOVE.L D5,D0
ADD.L D4,D0
MOVEM.L (SP)+,D4-D5
RTS</syntaxhighlight>
=={{header|8080 Assembly}}==
This subroutine expects to be called with the value of <math>n</math> in register <tt>A</tt>, and returns <math>f(n)</math> also in <tt>A</tt>. You may want to take steps to save the previous contents of <tt>B</tt>, <tt>C</tt>, and <tt>D</tt>. The routine only works with fairly small values of <math>n</math>.
<
DCR C ; decrement, because we know f(1) already
MVI A, 1
Line 199 ⟶ 244:
DCR C
JNZ LOOP ; jump if not zero
RET ; return from subroutine</
The range may be easily be extended from the 13th (=233) to the 24th (=46368) Fibonacci number with 16-bit addition using DAD. The code here assumes the CP/M operating system.
<syntaxhighlight>
;-------------------------------------------------------
; useful equates
;-------------------------------------------------------
bdos equ 5 ; BDOS entry
cr equ 13 ; ASCII carriage return
lf equ 10 ; ASCII line feed
space equ 32 ; ASCII space char
conout equ 2 ; BDOS console output function
putstr equ 9 ; BDOS print string function
nterms equ 20 ; number of terms (max=24) to display
;-------------------------------------------------------
; main code begins here
;-------------------------------------------------------
org 100h
lxi h,0 ; save CP/M's stack
dad sp
shld oldstk
lxi sp,stack ; set our own stack
lxi d,signon ; print signon message
mvi c,putstr
call bdos
mvi a,0 ; start with Fib(0)
mloop: push a ; save our count
call fib
call putdec
mvi a,space ; separate the numbers
call putchr
pop a ; get our count back
inr a ; increment it
cpi nterms+1 ; have we reached our limit?
jnz mloop ; no, keep going
lhld oldstk ; all done; get CP/M's stack back
sphl ; restore it
ret ; back to command processor
;-------------------------------------------------------
; calculate nth Fibonacci number (max n = 24)
; entry: A = n
; exit: HL = Fib(n)
;-------------------------------------------------------
fib: mov c,a ; C holds n
lxi d,0 ; DE holds Fib(n-2)
lxi h,1 ; HL holds Fib(n-1)
ana a ; Fib(0) is a special case
jnz fib2 ; n > 0 so calculate normally
xchg ; otherwise return with HL=0
ret
fib2: dcr c
jz fib3 ; we're done
push h ; save Fib(n-1)
dad d ; HL = Fib(n), soon to be Fib(n-1)
pop d ; DE = old F(n-1), now Fib(n-2)
jmp fib2 ; ready for next pass
fib3: ret
;-------------------------------------------------------
; console output of char in A register
;-------------------------------------------------------
putchr: push h
push d
push b
mov e,a
mvi c,conout
call bdos
pop b
pop d
pop h
ret
;---------------------------------------------------------
; Output decimal number to console
; HL holds 16-bit unsigned binary number to print
;---------------------------------------------------------
putdec: push b
push d
push h
lxi b,-10
lxi d,-1
putdec2:
dad b
inx d
jc putdec2
lxi b,10
dad b
xchg
mov a,h
ora l
cnz putdec ; recursive call
mov a,e
adi '0'
call putchr
pop h
pop d
pop b
ret
;-------------------------------------------------------
; data area
;-------------------------------------------------------
signon: db 'Fibonacci number sequence:',cr,lf,'$'
oldstk: dw 0
stack equ $+128 ; 64-level stack
;
end
</syntaxhighlight>
{{out}}
<pre>
Fibonacci number sequence:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
</pre>
=={{header|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.
<syntaxhighlight lang="asm">fib:
; WRITTEN IN C WITH X86-64 CLANG 3.3 AND DOWNGRADED TO 16-BIT X86
; INPUT: DI = THE NUMBER YOU WISH TO CALC THE FIBONACCI NUMBER FOR.
; OUTPUTS TO AX
push BP
push BX
push AX
mov BX, DI ;COPY INPUT TO BX
xor AX, AX ;MOV AX,0
test BX, BX ;SET FLAGS ACCORDING TO BX
je LBB0_4 ;IF BX == 0 RETURN 0
cmp BX, 1 ;IF BX == 1 RETURN 1
jne LBB0_3
mov AX, 1 ;ELSE, SET AX = 1 AND RETURN
jmp LBB0_4
LBB0_3:
lea DI, WORD PTR [BX - 1] ;DI = BX - 1
call fib ;RETURN FIB(BX-1)
mov BP, AX ;STORE THIS IN BP
add BX, -2
mov DI, BX
call fib ;GET FIB(DI - 2)
add AX, BP ;RETURN FIB(DI - 1) + FIB(DI - 2)
LBB0_4:
add sp,2
pop BX
pop BP
ret</syntaxhighlight>
===Using A Lookup Table===
With old computers it was common to use lookup tables to fetch pre-calculated values that would otherwise take some time to compute.
The elements of the table are ordered by index, so you can simply create a function that takes an offset as the parameter and returns
the element of the array at that offset.
Although lookup tables are very fast, there are some drawbacks to using them. For one, you end up taking up a lot of space. We're wasting a lot of bytes to store very low numbers at the beginning (each takes up 4 bytes regardless of how many digits you see). Unfortunately, when using lookup tables you have very little choice, since trying to conditionally change the scaling of the index would more than likely take more code than encoding all data as the maximum size regardless of the contents, as was done here. This keeps it simple for the CPU, which isn't aware of the intended size of each entry of the table.
For the purpose of this example, assume that both this code and the table are in the <code>.CODE</code> segment.
<syntaxhighlight lang="asm">getfib:
;input: BX = the desired fibonacci number (in other words, the "n" in "F(n)")
; DS must point to the segment where the fibonacci table is stored
;outputs to DX:AX (DX = high word, AX = low word)
push ds
cmp bx,41 ;bounds check
ja IndexOutOfBounds
shl bx,1
shl bx,1 ;multiply by 4, since this is a table of dwords
mov ax,@code
mov ds,ax
mov si,offset fib
mov ax,[ds:si] ;fetch the low word into AX
mov dx,2[ds:si] ;fetch the high word into DX
pop ds
ret
IndexOutOfBounds:
stc ;set carry to indicate an error
mov ax,0FFFFh ;return FFFF as the error code
pop ds
ret
;table of the first 41 fibonacci numbers
fib dword 0, 1, 1, 2, 3, 5, 8, 13
dword 21, 34, 55, 89, 144, 233, 377, 610
dword 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657
dword 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269
dword 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986
dword 102334155 </syntaxhighlight>
=={{header|8th}}==
An iterative solution:
<
: fibon \ n -- fib(n)
>r 0 1
Line 212 ⟶ 442:
dup 1 n:= if 1 ;; then
fibon nip ;
</syntaxhighlight>
=={{header|ABAP}}==
===Iterative===
<
CHANGING number_fib TYPE i.
DATA: lv_old type i,
Line 229 ⟶ 459:
lv_cur = number_fib.
enddo.
ENDFORM.</
===Impure Functional===
{{works with|ABAP|7.4 SP08 Or above only}}
<
n TYPE string
x = `0`
Line 241 ⟶ 471:
fibnm = VALUE #( BASE fibnm ( n ) )
x = y
y = n ) ).</
=={{header|ACL2}}==
Fast, tail recursive solution:
<
(if (or (zp n) (zp (1- n)))
b
Line 261 ⟶ 491:
(defun first-fibs (n)
(first-fibs-r n 0))</
{{out}}
Line 267 ⟶ 497:
(1 1 2 3 5 8 13 21 34 55 89
144 233 377 610 987 1597 2584 4181 6765)
</pre>
=={{header|Action!}}==
Action! language does not support recursion. Therefore an iterative approach has been proposed.
<syntaxhighlight lang="action!">INT FUNC Fibonacci(INT n)
INT curr,prev,tmp
IF n>=-1 AND n<=1 THEN
RETURN (n)
FI
prev=0
IF n>0 THEN
curr=1
DO
tmp=prev
prev=curr
curr==+tmp
n==-1
UNTIL n=1
OD
ELSE
curr=-1
DO
tmp=prev
prev=curr
curr==+tmp
n==+1
UNTIL n=-1
OD
FI
RETURN (curr)
PROC Main()
BYTE n
INT f
Put(125) ;clear screen
FOR n=0 TO 22
DO
f=Fibonacci(n)
Position(2,n+1)
PrintF("Fib(%I)=%I",n,f)
IF n>0 THEN
f=Fibonacci(-n)
Position(21,n+1)
PrintF("Fib(%I)=%I",-n,f)
FI
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Fibonacci_sequence.png Screenshot from Atari 8-bit computer]
<pre>
Fib(0)=0
Fib(1)=1 Fib(-1)=-1
Fib(2)=1 Fib(-2)=-1
Fib(3)=2 Fib(-3)=-2
Fib(4)=3 Fib(-4)=-3
Fib(5)=5 Fib(-5)=-5
Fib(6)=8 Fib(-6)=-8
Fib(7)=13 Fib(-7)=-13
Fib(8)=21 Fib(-8)=-21
Fib(9)=34 Fib(-9)=-34
Fib(10)=55 Fib(-10)=-55
Fib(11)=89 Fib(-11)=-89
Fib(12)=144 Fib(-12)=-144
Fib(13)=233 Fib(-13)=-233
Fib(14)=377 Fib(-14)=-377
Fib(15)=610 Fib(-15)=-610
Fib(16)=987 Fib(-16)=-987
Fib(17)=1597 Fib(-17)=-1597
Fib(18)=2584 Fib(-18)=-2584
Fib(19)=4181 Fib(-19)=-4181
Fib(20)=6765 Fib(-20)=-6765
Fib(21)=10946 Fib(-21)=-10946
Fib(22)=17711 Fib(-22)=-17711
</pre>
=={{header|ActionScript}}==
<
{
if (n < 2)
Line 276 ⟶ 584:
return fib(n - 1) + fib(n - 2);
}</
=={{header|Ada}}==
===Recursive===
<
procedure Fib is
Line 299 ⟶ 607:
Ada.Text_IO.Put("Fibonacci(" & Integer'Image(X) & " ) = ");
Ada.Text_IO.Put_Line(Integer'Image(Fib(X)));
end Fib;</
===Iterative, build-in integers===
<
procedure Test_Fibonacci is
Line 321 ⟶ 629:
Put_Line (Positive'Image (Fibonacci (N)));
end loop;
end Test_Fibonacci;</
{{out}}
<pre>
Line 341 ⟶ 649:
Using the big integer implementation from a cryptographic library [https://github.com/cforler/Ada-Crypto-Library/].
<
procedure Fibonacci is
Line 373 ⟶ 681:
Ada.Text_IO.Put("Fibonacci(" & Integer'Image(X) & " ) = ");
Ada.Text_IO.Put_Line(LN.Utils.To_String(Fib(X)));
end Fibonacci;</
{{out}}
Line 379 ⟶ 687:
Fibonacci( 777 ) = 1081213530912648191985419587942084110095342850438593857649766278346130479286685742885693301250359913460718567974798268702550329302771992851392180275594318434818082</pre>
===Fast method using fast matrix exponentiation===
<syntaxhighlight lang="ada">
with ada.text_io;
use ada.text_io;
procedure fast_fibo is
-- We work with biggest natural integers in a 64 bits machine
type Big_Int is mod 2**64;
-- We provide an index type for accessing the fibonacci sequence terms
type Index is new Big_Int;
-- fibo is a generic function that needs a modulus type since it will return
-- the n'th term of the fibonacci sequence modulus this type (use Big_Int to get the
-- expected behaviour in this particular task)
generic
type ring_element is mod <>;
with function "*" (a, b : ring_element) return ring_element is <>;
function fibo (n : Index) return ring_element;
function fibo (n : Index) return ring_element is
type matrix is array (1 .. 2, 1 .. 2) of ring_element;
-- f is the matrix you apply to a column containing (F_n, F_{n+1}) to get
-- the next one containing (F_{n+1},F_{n+2})
-- could be a more general matrix (given as a generic parameter) to deal with
-- other linear sequences of order 2
f : constant matrix := (1 => (0, 1), 2 => (1, 1));
function "*" (a, b : matrix) return matrix is
(1 => (a(1,1)*b(1,1)+a(1,2)*b(2,1), a(1,1)*b(1,2)+a(1,2)*b(2,2)),
2 => (a(2,1)*b(1,1)+a(2,2)*b(2,1), a(2,1)*b(1,2)+a(2,2)*b(2,2)));
function square (m : matrix) return matrix is (m * m);
-- Fast_Pow could be non recursive but it doesn't really matter since
-- the number of calls is bounded up by the size (in bits) of Big_Int (e.g 64)
function fast_pow (m : matrix; n : Index) return matrix is
(if n = 0 then (1 => (1, 0), 2 => (0, 1)) -- = identity matrix
elsif n mod 2 = 0 then square (fast_pow (m, n / 2))
else m * square (fast_pow (m, n / 2)));
begin
return fast_pow (f, n)(2, 1);
end fibo;
function Big_Int_Fibo is new fibo (Big_Int);
begin
-- calculate instantly F_n with n=10^15 (modulus 2^64 )
put_line (Big_Int_Fibo (10**15)'img);
end fast_fibo; </syntaxhighlight>
=={{header|AdvPL}}==
===Recursive===
<syntaxhighlight lang="advpl">
#include "totvs.ch"
User Function fibb(a,b,n)
return(if(--n>0,fibb(b,a+b,n),a))
</syntaxhighlight>
===Iterative===
<syntaxhighlight lang="advpl">
#include "totvs.ch"
User Function fibb(n)
Line 399 ⟶ 759:
end while
return(fnext)
</syntaxhighlight>
=={{header|Agda}}==
<syntaxhighlight lang="agda">
module FibonacciSequence where
open import Data.Nat using (ℕ ; zero ; suc ; _+_)
rec_fib : (m : ℕ) -> (a : ℕ) -> (b : ℕ) -> ℕ
rec_fib zero a b = a
rec_fib (suc k) a b = rec_fib k b (a + b)
fib : (n : ℕ) -> ℕ
fib n = rec_fib n zero (suc zero)
</syntaxhighlight>
=={{header|Aime}}==
<
fibs(integer n)
{
Line 427 ⟶ 801:
return w;
}
</syntaxhighlight>
=={{header|ALGOL 60}}==
{{works with|A60}}
<syntaxhighlight lang="algol60">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 </syntaxhighlight>
{{out}}
<pre>
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
</pre>
=={{header|ALGOL 68}}==
Line 435 ⟶ 836:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}
<
LONG REAL sqrt 5 = long sqrt(5);
LONG REAL p = (1 + sqrt 5) / 2;
Line 447 ⟶ 848:
print(", ")
OD;
print(new line)</
{{out}}
<pre>
Line 457 ⟶ 858:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}
<
CASE n+1 IN
0, 1, 1, 2, 3, 5
Line 473 ⟶ 874:
print(", ")
OD;
print(new line)</
{{out}}
<pre>
Line 482 ⟶ 883:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}
<
( n < 2 | n | fib(n-1) + fib(n-2));</
===Generative===
{{trans|Python|Note: This specimen retains the original [[Prime decomposition#Python|Python]] coding style.}}
Line 489 ⟶ 890:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}
<
PROC gen fibonacci = (INT n, YIELDINT yield)VOID: (
Line 506 ⟶ 907:
# OD # ));
print(new line)
)</
{{out}}
<pre>
Line 518 ⟶ 919:
This uses a pre-generated list, requiring much less run-time processor usage, but assumes that INT is only 31 bits wide.
<
-701408733, 433494437, -267914296, 165580141, -102334155,
63245986, -39088169, 24157817, -14930352, 9227465, -5702887,
Line 547 ⟶ 948:
print(", ")
OD;
print(new line)</
{{out}}
<pre>
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
</pre>
=={{header|ALGOL W}}==
<
% return the nth Fibonacci number %
integer procedure Fibonacci( integer value n ) ;
Line 598 ⟶ 973:
for i := 0 until 10 do writeon( i_w := 3, s_w := 0, Fibonacci( i ) )
end.</
{{out}}
<pre>
0 1 1 2 3 5 8 13 21 34 55
</pre>
=={{header|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====
<syntaxhighlight lang="algol">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;</syntaxhighlight>
====Naively recursive====
<syntaxhighlight lang="algol">INTEGER FUNCTION FIBONACCI( X ); INTEGER X;
BEGIN
IF X < 3 THEN
FIBONACCI := 1
ELSE
FIBONACCI := FIBONACCI( X - 2 ) + FIBONACCI( X - 1 );
END;</syntaxhighlight>
=={{header|Alore}}==
<
if n < 2
return 1
end
return fib(n-1) + fib(n-2)
end</
=={{header|Amazing Hopper}}==
Analitic, Recursive and Iterative mode.
<syntaxhighlight lang="amazing hopper">
#include <hbasic.h>
#define TERM1 1.61803398874989
#define TERM2 -0.61803398874989
#context get Fibonacci number with analitic mode
GetArgs(n)
get Inv of (M_SQRT5), Mul by( Pow (TERM 1, n), Minus( Pow(TERM 2, n) ) );
then Return\\
#proto fibonacci_recursive(__X__)
#synon _fibonacci_recursive getFibonaccinumberwithrecursivemodeof
#proto fibonacci_iterative(__X__)
#synon _fibonacci_iterative getFibonaccinumberwithiterativemodeof
Begin
Option Stack 1024
get Arg Number(2, n), and Take( n );
then, get Fibonacci number with analitic mode, and Print It with a Newl.
secondly, get Fibonacci number with recursive mode of(n), and Print It with a Newl.
finally, get Fibonacci number with iterative mode of (n), and Print It with a Newl.
End
Subrutines
fibonacci_recursive(n)
Iif ( var(n) Is Le? (2), 1 , \
get Fibonacci number with recursive mode of( var(n) Minus (1));\
get Fibonacci number with recursive mode of( var(n) Minus (2)); and Add It )
Return
fibonacci_iterative(n)
A=0
B=1
For Up( I:=2, n, 1 )
C=B
Let ( B: = var(A) Plus (B) )
A=C
Next
Return(B)
</syntaxhighlight>
{{out}}
<pre>
$ hopper src/fibo1.bas 25
75025
75025
75025
</pre>
=={{header|AntLang}}==
<
fib:{<0;1> {x,<x[-1]+x[-2]>}/ range[x]}
/nth
fibn:{fib[x][x]}</
=={{header|Apex}}==
<syntaxhighlight lang="apex">
/*
author: snugsfbay
Line 665 ⟶ 1,120:
}
</syntaxhighlight>
=={{header|APL}}==
====Naive Recursive====
{{works with|Dyalog APL}}
<syntaxhighlight lang="apl">
fib←{⍵≤1:⍵ ⋄ (∇ ⍵-1)+∇ ⍵-2}
</syntaxhighlight>
Read this as: In the variable "fib", store the function that says, if the argument is less than or equal to 1, return the argument. Else, calculate the value you get when you recursively call the current function with the argument of the current argument minus one and add that to the value you get when you recursively call the current function with the argument of the current function minus two.
This naive solution requires Dyalog APL because GNU APL does not support this syntax for conditional guards.
====Array====
{{works with|Dyalog APL}}
{{works with|GNU APL}}
Since APL is an array language we'll use the following identity:
:<math>\begin{pmatrix} 1 & 1 \\ 1 & 0 \end{pmatrix}^n = \begin{pmatrix} F_{n+1} & F_n \\ F_n & F_{n-1} \end{pmatrix}.</math>
In APL:
<syntaxhighlight lang="apl">
↑+.×/N/⊂2 2⍴1 1 1 0
</syntaxhighlight>
Plugging in 4 for N gives the following result:
:<math>\begin{pmatrix} 5 & 3 \\ 3 & 2 \end{pmatrix}</math>
Line 680 ⟶ 1,151:
The ''First'' removes the shell from the ''Enclose''.
At this point we're basically done, but we need to pick out only <math>F_n</math> in order to complete the task. Here's one way:
<syntaxhighlight lang="apl">
↑0 1↓↑+.×/N/⊂2 2⍴1 1 1 0
</syntaxhighlight>
====Analytic====
{{works with|Dyalog APL}}
{{works with|GNU APL}}
An alternative approach, using Binet's formula (which was apparently known long before Binet):
<
=={{header|AppleScript}}==
Line 693 ⟶ 1,166:
===Imperative===
<
set x to (text returned of (display dialog "What fibbonaci number do you want?" default answer "3"))
set x to x as integer
Line 703 ⟶ 1,176:
end if
end repeat
return item x of fibs</
Line 711 ⟶ 1,184:
The simple recursive version is famously slow:
<
if n < 1 then
0
Line 719 ⟶ 1,192:
fib(n - 2) + fib(n - 1)
end if
end fib</
but we can combine '''enumFromTo(m, n)''' with the accumulator of a higher-order '''fold/reduce''' function to memoize the series:
Line 725 ⟶ 1,198:
{{Trans|JavaScript}} (ES6 memoized fold example)
{{Trans|Haskell}} (Memoized fold example)
<syntaxhighlight lang="applescript">-------------------- FIBONACCI SEQUENCE --------------------
-- fib :: Int -> Int
on fib(n)
Line 739 ⟶ 1,214:
on run
Line 747 ⟶ 1,222:
end run
-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if
set
repeat with i from m to n
set end of lst to i
end repeat
lst
else
end if
end enumFromTo
Line 785 ⟶ 1,259:
end script
end if
end mReturn</
{{Out}}
<pre>2178309</pre>
Line 805 ⟶ 1,279:
=={{header|ARM Assembly}}==
Expects to be called with <math>n</math> in R0, and will return <math>f(n)</math> in the same register.
<
push {r1-r3}
mov r1, #0
Line 820 ⟶ 1,294:
mov r0, r2
pop {r1-r3}
mov pc, lr</
=={{header|ArnoldC}}==
<
HEY CHRISTMAS TREE f1
Line 854 ⟶ 1,328:
CHILL
YOU HAVE BEEN TERMINATED</
=={{header|Arturo}}==
===Recursive===
<syntaxhighlight lang="arturo">fib: $[x][
if? x<2 [1]
else [(fib x-1) + (fib x-2)]
]
loop 1..25 [x][
print ["Fibonacci of" x "=" fib x]
]</syntaxhighlight>
=={{header|AsciiDots}}==
<syntaxhighlight lang="asciidots">
/--#$--\
Line 870 ⟶ 1,357:
. .
</syntaxhighlight>
=={{header|ATS}}==
===Recursive===
<syntaxhighlight lang="ats">
fun fib_rec(n: int): int =
if n >= 2 then fib_rec(n-1) + fib_rec(n-2) else n
</syntaxhighlight>
===Iterative===
<syntaxhighlight lang="ats">
(*
** This one is also referred to as being tail-recursive
Line 890 ⟶ 1,377:
then (fix loop (i:int, r0:int, r1:int): int => if i > 1 then loop (i-1, r1, r0+r1) else r1)(n, 0, 1)
else 0
</syntaxhighlight>
===Iterative and Verified===
<syntaxhighlight lang="ats">
(*
** This implementation is verified!
Line 921 ⟶ 1,408:
loop {0} (FIB0 (), FIB1 () | n, 0, 1)
end // end of [fibats]
</syntaxhighlight>
===Matrix-based===
<syntaxhighlight lang="ats">
(* ****** ****** *)
//
Line 1,004 ⟶ 1,491:
//
} (* end of [main0] *)
</syntaxhighlight>
=={{header|AutoHotkey}}==
Line 1,011 ⟶ 1,498:
===Iterative===
{{trans|C}}
<
MsgBox % fib(A_Index)
Return
Line 1,028 ⟶ 1,515:
}
Return this
}</
===Recursive and iterative===
Source: [http://www.autohotkey.com/forum/topic44657.html AutoHotkey forum] by Laszlo
<syntaxhighlight lang="autohotkey">/*
Important note: the recursive version would be very slow
without a global or static array. The iterative version
Line 1,048 ⟶ 1,535:
c := b, b += a, a := c
Return n=0 ? 0 : n>0 || n&1 ? b : -b
}</
=={{header|AutoIt}}==
===Iterative===
<
$n0 = 0
$n1 = 1
Line 1,078 ⟶ 1,566:
Return $febo
EndFunc
</syntaxhighlight>
===Recursive===
<
$n0 = 0
$n1 = 1
Line 1,099 ⟶ 1,587:
EndIf
EndFunc
</syntaxhighlight>
=={{header|AWK}}==
As in many examples, this one-liner contains the function as well as testing with input from stdin, output to stdout.
<
10
fib(10)=55</
=={{header|Axe}}==
Line 1,112 ⟶ 1,600:
Iterative solution:
<
r₁→N
0→I
Line 1,122 ⟶ 1,610:
End
J
Return</
=={{header|Babel}}==
In Babel, we can define fib using a stack-based approach that is not recursive:
<syntaxhighlight lang="babel">fib { <- 0 1 { dup <- + -> swap } -> times zap } <</syntaxhighlight>
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:
<pre>1, 1, 1 (dup)
1, 1, (<-)
2 (+)
2, 1 (->)
1, 2 (swap) </pre>
And so on. To test fib:
<syntaxhighlight lang="babel">{19 iter - fib !} 20 times collect ! lsnum !</syntaxhighlight>
{{out}}
<pre>( 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 )</pre>
=={{header|bash}}==
===Iterative===
<
$ fib=1;j=1;while((fib<100));do echo $fib;((k=fib+j,fib=j,j=k));done
</syntaxhighlight>
<pre>
1
Line 1,145 ⟶ 1,652:
===Recursive===
<
{
if [ $1 -le 0 ]
Line 1,161 ⟶ 1,668:
fi
}
</syntaxhighlight>
=={{header|BASIC}}==
Line 1,188 ⟶ 1,675:
Entering a value of N > 183, produces an error message:
<pre>?OVERFLOW ERROR IN
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">
# Basic-256 ver 1.1.4
# iterative Fibonacci sequence
Line 1,216 ⟶ 1,703:
print " "
print n + chr(9) + c
</syntaxhighlight>
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> PRINT FNfibonacci_r(1), FNfibonacci_i(1)
PRINT FNfibonacci_r(13), FNfibonacci_i(13)
PRINT FNfibonacci_r(26), FNfibonacci_i(26)
END
DEF FNfibonacci_r(N)
IF N < 2 THEN = N
= FNfibonacci_r(N-1) + FNfibonacci_r(N-2)
DEF FNfibonacci_i(N)
LOCAL F, I, P, T
IF N < 2 THEN = N
P = 1
FOR I = 1 TO N
T = F
F += P
P = T
NEXT
= F
</syntaxhighlight>
{{out}}
<pre> 1 1
233 233
121393 121393</pre>
==={{header|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.
<syntaxhighlight lang="BASIC">
10 print "Enter a ";
20 print "number ";
30 print "greater ";
40 print "than 1";
50 print " and less";
60 print " than 25";
70 input z
80 b=1
90 a=0
100 n=2
110 f=a+b
120 a=b
130 b=f
140 n=n+1
150 if n-z-1 goto 110
160 print "The ";
170 print z ;
180 print "th ";
190 print "Fibonacci ";
200 print "Number is ";
210 print f
</syntaxhighlight>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="qbasic">100 cls
110 for i = 0 to 20 : print fibor(i); : next i
120 print
130 for i = 0 to 20 : print fiboi(i); : next i
140 print
150 for i = 0 to 20 : print fiboa(i); : next i
160 end
170 sub fibor(n) : 'Recursive
180 if n < 2 then
190 fibor = n
200 else
210 fibor = fibor(n-1)+fibor(n-2)
220 endif
230 end sub
240 sub fiboi(n) : 'Iterative
250 n1 = 0
260 n2 = 1
270 for k = 1 to abs(n)
280 sum = n1+n2
290 n1 = n2
300 n2 = sum
310 next k
320 if n < 0 then
330 fiboi = n1*((-1)^((-n)+1))
340 else
350 fiboi = n1
360 endif
370 end sub
380 sub fiboa(n) : 'Analytic
390 fiboa = int(0.5+(((sqr 5+1)/2)^n)/sqr 5)
400 end sub</syntaxhighlight>
{{out}}
<pre>0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765</pre>
==={{header|Commodore BASIC}}===
<syntaxhighlight lang="basic">100 PRINT CHR$(147); CHR$(18); "**** FIBONACCI GENERATOR ****"
120 IF N1 > N2 THEN T = N1: N1 = N2: N2 = T
150 : IF S > 0 THEN T = A + B: A = B: B = T
160 : IF S < 0 THEN T = B - A: B = A: A = T
170 NEXT I
180 PRINT
190 PRINT STR$(A); : REM STR$() PREVENTS TRAILING SPACE
200 IF N2 = N1 THEN 250
210 FOR I = N1 + 1 TO N2
220 : T = A + B: A = B: B = T
230 : PRINT ","; STR$(A);
240 NEXT I
250 PRINT</syntaxhighlight>
{{Out}}
<pre>**** FIBONACCI GENERATOR ****
MIN, MAX? -6,6
-8, 5,-3, 2,-1, 1, 0, 1, 1, 2, 3, 5, 8
READY.</pre>
==={{header|Craft Basic}}===
<syntaxhighlight lang="basic">let a = 1
let b = 1
print "Fibonacci Sequence"
for i = 0 to 20
let s = a + b
let a = b
let b = s
print s
next i</syntaxhighlight>
{{out| Output}}<pre>Fibonacci Sequence
2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 </pre>
==={{header|FreeBASIC}}===
Extended sequence coded big integer.
<syntaxhighlight lang="freebasic">'Fibonacci extended
'Freebasic version 24 Windows
Dim Shared ADDQmod(0 To 19) As Ubyte
Dim Shared ADDbool(0 To 19) As Ubyte
For z As Integer=0 To 19
ADDQmod(z)=(z Mod 10+48)
ADDbool(z)=(-(10<=z))
Next z
Function plusINT(NUM1 As String,NUM2 As String) As String
Dim As Byte flag
#macro finish()
three=Ltrim(three,"0")
If three="" Then Return "0"
If flag=1 Then Swap NUM2,NUM1
Return three
Exit Function
#endmacro
var lenf=Len(NUM1)
var lens=Len(NUM2)
If lens>lenf Then
Swap NUM2,NUM1
Swap lens,lenf
flag=1
End If
var diff=lenf-lens-Sgn(lenf-lens)
var three="0"+NUM1
var two=String(lenf-lens,"0")+NUM2
Dim As Integer n2
Dim As Ubyte addup,addcarry
addcarry=0
For n2=lenf-1 To diff Step -1
addup=two[n2]+NUM1[n2]-96
three[n2+1]=addQmod(addup+addcarry)
addcarry=addbool(addup+addcarry)
Next n2
If addcarry=0 Then
finish()
End If
If n2=-1 Then
three[0]=addcarry+48
finish()
End If
For n2=n2 To 0 Step -1
addup=two[n2]+NUM1[n2]-96
three[n2+1]=addQmod(addup+addcarry)
addcarry=addbool(addup+addcarry)
Next n2
three[0]=addcarry+48
finish()
End Function
Function fibonacci(n As Integer) As String
Dim As String sl,l,term
sl="0": l="1"
If n=1 Then Return "0"
If n=2 Then Return "1"
n=n-2
For x As Integer= 1 To n
term=plusINT(l,sl)
sl=l
l=term
Next x
Function =term
End Function
'============== EXAMPLE ===============
print "THE SEQUENCE TO 10:"
print
For n As Integer=1 To 10
Print "term";n;": "; fibonacci(n)
Next n
print
print "Selected Fibonacci number"
print "Fibonacci 500"
print
print fibonacci(500)
Sleep</syntaxhighlight>
{{out}}
<pre>THE SEQUENCE TO 10:
term 1: 0
term 2: 1
term 3: 1
term 4: 2
term 5: 3
term 6: 5
term 7: 8
term 8: 13
term 9: 21
term 10: 34
Selected Fibonacci number
Fibonacci 500
86168291600238450732788312165664788095941068326060883324529903470149056115823592
713458328176574447204501</pre>
==={{header|FTCBASIC}}===
<syntaxhighlight lang="basic">define a = 1, b = 1, s = 0, i = 0
cls
print "Fibonacci Sequence"
do
let s = a + b
let a = b
let b = s
+1 i
print s
loop i < 20
pause
end</syntaxhighlight>
==={{header|GFA Basic}}===
<syntaxhighlight lang="text">
'
' Compute nth Fibonacci number
'
' open a window for display
OPENW 1
CLEARW 1
' Display some fibonacci numbers
' Fib(46) is the largest number GFA Basic can reach
' (long integers are 4 bytes)
FOR i%=0 TO 46
PRINT "fib(";i%;")=";@fib(i%)
NEXT i%
' wait for a key press and tidy up
~INP(2)
CLOSEW 1
'
' Function to compute nth fibonacci number
' n must be in range 0 to 46, inclusive
'
FUNCTION fib(n%)
LOCAL n0%,n1%,nn%,i%
n0%=0
n1%=1
SELECT n%
CASE 0
RETURN n0%
CASE 1
RETURN n1%
DEFAULT
FOR i%=2 TO n%
nn%=n0%+n1%
n0%=n1%
n1%=nn%
NEXT i%
RETURN nn%
ENDSELECT
ENDFUNC
</syntaxhighlight>
==={{header|GW-BASIC}}===
{{works with|BASICA}}
====Iterative====
<syntaxhighlight lang="gwbasic">
10 ' SAVE"FIBONA", A
20 ' Secuencia de Fibonacci
30 ' Var
40 DEFDBL D
50 IMAXFIBO% = 76
60 DNUM1 = 1: DNUM2 = DNUM1
70 CLS
80 PRINT "Este programa calcula la serie de Fibonacci."
90 PRINT DNUM1; DNUM2;
100 FOR I% = 1 TO IMAXFIBO%
110 DNUM3 = DNUM1 + DNUM2
120 PRINT DNUM3;
130 DNUM1 = DNUM2: DNUM2 = DNUM3
140 NEXT I%
150 PRINT
160 PRINT "Fin de la ejecución del programa."
170 END
</syntaxhighlight>
{{out}}
<pre>
Este programa calcula la serie de Fibonacci.
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584
4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229
832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817
39088169 63245986 102334155 165580141 267914296 433494437 701408733
1134903170 1836311903 2971215073 4807526976 7778742049 12586269025
20365011074 32951280099 53316291173 86267571272 139583862445 225851433717
365435296162 591286729879 956722026041 1548008755920 2504730781961
4052739537881 6557470319842 10610209857723 17167680177565 27777890035288
44945570212853 72723460248141 117669030460994 190392490709135
308061521170129 498454011879264 806515533049393 1304969544928657
2111485077978050 3416454622906707 5527939700884757 8944394323791464
Fin de la ejecución del programa.
Ok
</pre>
====Binet formula====
<syntaxhighlight lang="gwbasic">
10 ' SAVE"FIBINF", A
20 ' Secuencia de Fibonacci mediante la fórmula de Binet
30 ' Var
40 DEFDBL D
50 IMAXFIBO% = 77
60 DSQR5 = SQR(5)
70 DPIV1 = (1 + DSQR5) / 2
80 DPIV2 = (1 - DSQR5) / 2
90 DNUM1 = DPIV1: DNUM2 = DPIV2
100 CLS
110 PRINT "Este programa calcula la serie de Fibonacci."
120 FOR I% = 1 TO IMAXFIBO%
130 DNUM1 = DNUM1 * DPIV1
140 DNUM2 = DNUM2 * DPIV2
150 PRINT FIX(((DNUM1 - DNUM2) / DSQR5)+.5);
160 NEXT I%
170 PRINT
180 PRINT "Fin de la ejecución del programa."
190 END
</syntaxhighlight>
{{out}}
<pre>
Este programa calcula la serie de Fibonacci.
1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
6765 10946 17711 28657 46368 75025 121393 196418 317811 514229
832040 1346269 2178310 3524579 5702889 9227468 14930357 24157826
39088183 63246010 102334195 165580207 267914406 433494620 701409036
1134903671 1836312733 2971216446 4807529247 7778745802 12586275225
20365021312 32951296999 53316319058 86267617266 139583938281 225851558714
365435502118 591287069122 956722584654 1548009675479 2504732295250
4052742027550 6557474414738 10610216591046 17167691246479 27777908226979
44945600103607 72723509350188 117669111103547 190392623123089
308061738545741 498454368657289 806516118510594 1304970505463907
2111486653578091 3416457206941612 5527943938022908 8944401270367342
Fin de la ejecución del programa.
Ok
</pre>
==={{header|Integer BASIC}}===
Only works with quite small values of <math>n</math>.
<
20 A=0
30 B=1
Line 1,239 ⟶ 2,098:
80 NEXT I
90 PRINT B
100 END</
==={{header|IS-BASIC}}===
<
110 FOR I=0 TO 20
120 PRINT "F";I,FIB(I)
Line 1,253 ⟶ 2,112:
190 NEXT
200 LET FIB=A
210 END DEF</
==={{header|Liberty BASIC}}===
====Iterative/Recursive====
{{works with|Just BASIC}}
<syntaxhighlight lang="lb">
for i = 0 to 15
print fiboR(i),fiboI(i)
next i
function fiboR(n)
if n <= 1 then
fiboR = n
else
fiboR = fiboR(n-1) + fiboR(n-2)
end if
end function
function fiboI(n)
a = 0
b = 1
for i = 1 to n
temp = a + b
a = b
b = temp
next i
fiboI = a
end function
</syntaxhighlight>
{{out}}
<pre>
0 0
1 1
1 1
2 2
3 3
5 5
8 8
13 13
21 21
34 34
55 55
89 89
144 144
233 233
377 377
610 610
</pre>
====Iterative/Negative====
{{works with|Just BASIC}}
<syntaxhighlight lang="lb">
print "Rosetta Code - Fibonacci sequence": print
print " n Fn"
for x=-12 to 12 '68 max
print using("### ", x); using("##############", FibonacciTerm(x))
next x
print
[start]
input "Enter a term#: "; n$
n$=lower$(trim$(n$))
if n$="" then print "Program complete.": end
print FibonacciTerm(val(n$))
goto [start]
function FibonacciTerm(n)
n=int(n)
FTa=0: FTb=1: FTc=-1
select case
case n=0 : FibonacciTerm=0 : exit function
case n=1 : FibonacciTerm=1 : exit function
case n=-1 : FibonacciTerm=-1 : exit function
case n>1
for x=2 to n
FibonacciTerm=FTa+FTb
FTa=FTb: FTb=FibonacciTerm
next x
exit function
case n<-1
for x=-2 to n step -1
FibonacciTerm=FTa+FTc
FTa=FTc: FTc=FibonacciTerm
next x
exit function
end select
end function
</syntaxhighlight>
{{out}}
<pre>
Rosetta Code - Fibonacci sequence
n Fn
-12 -144
-11 -89
-10 -55
-9 -34
-8 -21
-7 -13
-6 -8
-5 -5
-4 -3
-3 -2
-2 -1
-1 -1
0 0
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21
9 34
10 55
11 89
12 144
Enter a term#: 12
144
Enter a term#:
Program complete.
</pre>
==={{header|Microsoft Small Basic}}===
====Iterative====
<syntaxhighlight lang="smallbasic">' 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</syntaxhighlight>
{{out}}
<pre>
fibo(139)=50095301248058391139327916261
</pre>
====Binet's Formula====
<syntaxhighlight lang="smallbasic">' 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</syntaxhighlight>
{{out}}
<pre>
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
</pre>
==={{header|Minimal BASIC}}===
{{works with|QBasic}}
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
{{works with|IS-BASIC}}
{{works with|MSX Basic}}
<syntaxhighlight lang="qbasic">110 REM THE ARRAY F HOLDS THE FIBONACCI NUMBERS
120 DIM F(22)
130 LET F(0) = 0
140 LET F(1) = 1
150 LET N = 1
160 REM COMPUTE THE NEXT FIBBONACCI NUMBER
170 LET F(N+1) = F(N)+F(N-1)
180 LET N = N+1
190 PRINT F(N-2);
200 REM STOP AFTER PRINTING 20 NUMBERS
210 IF N < 22 THEN 170
220 END</syntaxhighlight>
==={{header|MSX Basic}}===
{{works with|QBasic}}
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
<syntaxhighlight lang="qbasic">100 CLS
110 FOR N = 0 TO 15: GOSUB 130: PRINT FIBOI; : NEXT N
120 END
130 REM Iterative Fibonacci sequence
140 N1 = 0
150 N2 = 1
160 FOR K = 1 TO ABS(N)
170 SUM = N1 + N2
180 N1 = N2
190 N2 = SUM
200 NEXT K
210 IF N < 0 THEN FIBOI = N1 * ((-1) ^ ((-N) + 1)) ELSE FIBOI = N1
220 RETURN</syntaxhighlight>
==={{header|Palo Alto Tiny BASIC}}===
<syntaxhighlight lang="basic">
10 REM FIBONACCI SEQUENCE
20 INPUT "ENTER N FOR FIB(N)"N
30 LET A=0,B=1
40 FOR I=2 TO N
50 LET T=B,B=A+B,A=T
60 NEXT I
70 PRINT B
80 STOP
</syntaxhighlight>
{{out}}
2 runs.
<pre>
ENTER N FOR FIB(N):9
34
</pre>
<pre>
ENTER N FOR FIB(N):13
233
</pre>
==={{header|PowerBASIC}}===
{{trans|BASIC}}
There seems to be a limitation (dare I say, bug?) in PowerBASIC regarding how large numbers are stored. 10E17 and larger get rounded to the nearest 10. For F(n), where ABS(n) > 87, is affected like this:
actual: displayed:
F(88) 1100087778366101931 1100087778366101930
F(89) 1779979416004714189 1779979416004714190
F(90) 2880067194370816120 2880067194370816120
F(91) 4660046610375530309 4660046610375530310
F(92) 7540113804746346429 7540113804746346430
<syntaxhighlight lang="powerbasic">FUNCTION fibonacci (n AS LONG) AS QUAD
DIM u AS LONG, a AS LONG, L0 AS LONG, outP AS QUAD
STATIC fibNum() AS QUAD
u = UBOUND(fibNum)
a = ABS(n)
IF u < 1 THEN
REDIM fibNum(1)
fibNum(1) = 1
u = 1
END IF
SELECT CASE a
CASE 0 TO 92
IF a > u THEN
REDIM PRESERVE fibNum(a)
FOR L0 = u + 1 TO a
fibNum(L0) = fibNum(L0 - 1) + fibNum(L0 - 2)
IF 88 = L0 THEN fibNum(88) = fibNum(88) + 1
NEXT
END IF
IF n < 0 THEN
fibonacci = fibNum(a) * ((-1)^(a+1))
ELSE
fibonacci = fibNum(a)
END IF
CASE ELSE
'Even without the above-mentioned bug, we're still limited to
'F(+/-92), due to data type limits. (F(93) = &hA94F AD42 221F 2702)
ERROR 6
END SELECT
END FUNCTION
FUNCTION PBMAIN () AS LONG
DIM n AS LONG
#IF NOT %DEF(%PB_CC32)
OPEN "out.txt" FOR OUTPUT AS 1
#ENDIF
FOR n = -92 TO 92
#IF %DEF(%PB_CC32)
PRINT STR$(n); ": "; FORMAT$(fibonacci(n), "#")
#ELSE
PRINT #1, STR$(n) & ": " & FORMAT$(fibonacci(n), "#")
#ENDIF
NEXT
CLOSE
END FUNCTION</syntaxhighlight>
==={{header|PureBasic}}===
====Macro based calculation====
<syntaxhighlight lang="purebasic">Macro Fibonacci (n)
Int((Pow(((1+Sqr(5))/2),n)-Pow(((1-Sqr(5))/2),n))/Sqr(5))
EndMacro</syntaxhighlight>
====Recursive====
<syntaxhighlight lang="purebasic">Procedure FibonacciReq(n)
If n<2
ProcedureReturn n
Else
ProcedureReturn FibonacciReq(n-1)+FibonacciReq(n-2)
EndIf
EndProcedure</syntaxhighlight>
====Recursive & optimized with a static hash table====
This will be much faster on larger n's, this as it uses a table to store known parts instead of recalculating them.
On my machine the speedup compares to above code is
Fib(n) Speedup
20 2
25 23
30 217
40 25847
46 1156741
<syntaxhighlight lang="purebasic">Procedure Fibonacci(n)
Static NewMap Fib.i()
Protected FirstRecursion
If MapSize(Fib())= 0 ; Init the hash table the first run
Fib("0")=0: Fib("1")=1
FirstRecursion = #True
EndIf
If n >= 2
Protected.s s=Str(n)
If Not FindMapElement(Fib(),s) ; Calculate only needed parts
Fib(s)= Fibonacci(n-1)+Fibonacci(n-2)
EndIf
n = Fib(s)
EndIf
If FirstRecursion ; Free the memory when finalizing the first call
ClearMap(Fib())
EndIf
ProcedureReturn n
EndProcedure</syntaxhighlight>
'''Example'''
Fibonacci(0)= 0
Fibonacci(1)= 1
Fibonacci(2)= 1
Fibonacci(3)= 2
Fibonacci(4)= 3
Fibonacci(5)= 5
FibonacciReq(0)= 0
FibonacciReq(1)= 1
FibonacciReq(2)= 1
FibonacciReq(3)= 2
FibonacciReq(4)= 3
FibonacciReq(5)= 5
==={{header|QB64}}===
''CBTJD'': 2020/03/13
<syntaxhighlight lang="qbasic">_DEFINE F AS _UNSIGNED _INTEGER64
CLS
PRINT
PRINT "Enter 40 to more easily see the difference in calculation speeds."
PRINT
INPUT "Enter n for Fibonacci(n): ", n
PRINT
PRINT " Analytic Method (Fastest): F("; LTRIM$(STR$(n)); ") ="; fA(n)
PRINT "Iterative Method (Fast): F("; LTRIM$(STR$(n)); ") ="; fI(n)
PRINT "Recursive Method (Slow): F("; LTRIM$(STR$(n)); ") ="; fR(n)
END
' === Analytic Fibonacci Function (Fastest)
FUNCTION fA (n)
fA = INT(0.5 + (((SQR(5) + 1) / 2) ^ n) / SQR(5))
END FUNCTION
' === Iterative Fibonacci Function (Fast)
FUNCTION fI (n)
FOR i = 1 TO n
IF i < 3 THEN a = 1: b = 1
t = fI + b: fI = b: b = t
NEXT
END FUNCTION
' === Recursive Fibonacci function (Slow)
FUNCTION fR (n)
IF n <= 1 THEN
fR = n
ELSE
fR = fR(n - 1) + fR(n - 2)
END IF
END FUNCTION
</syntaxhighlight>
Fibonacci from Russia
<syntaxhighlight lang="qbasic">DIM F(80) AS DOUBLE 'FibRus.bas DANILIN
F(1) = 0: F(2) = 1
'OPEN "FibRus.txt" FOR OUTPUT AS #1
FOR i = 3 TO 80
F(i) = F(i-1)+F(i-2)
NEXT i
FOR i = 1 TO 80
f$ = STR$(F(i)): LF = 22 - LEN(f$)
n$ = ""
FOR j = 1 TO LF: n$ = " " + n$: NEXT
f$ = n$ + f$
PRINT i, f$: ' PRINT #1, i, f$
NEXT i</syntaxhighlight>
{{out}}
<pre>1 0
2 1
3 1
4 2
5 3
6 5
7 8
8 13
9 21
...
24 28657
25 46368
26 75025
...
36 9227465
37 14930352
38 24157817
...
48 2971215073
49 4807526976
50 7778742049
...
60 956722026041
61 1548008755920
62 2504730781961
...
76 2111485077978050
77 3416454622906707
78 5527939700884757
79 8944394323791464
80 1.447233402467622D+16</pre>
==={{header|QBasic}}===
Line 1,259 ⟶ 2,538:
{{works with|FreeBASIC}}
====Iterative====
<
n1 = 0
n2 = 1
Line 1,272 ⟶ 2,551:
itFib = n1
END IF
END FUNCTION</
Next version calculates each value once, as needed, and stores the results in an array for later retreival (due to the use of <code>REDIM PRESERVE</code>, it requires [[QuickBASIC]] 4.5 or newer):
<
REDIM SHARED fibNum(1) AS LONG
Line 1,313 ⟶ 2,592:
ERROR 6 'overflow
END SELECT
END FUNCTION</
{{out}} (unhandled error in final input prevents output):
Line 1,324 ⟶ 2,603:
====Recursive====
This example can't handle n < 0.
<syntaxhighlight lang="qbasic">FUNCTION recFib (n)
IF (n < 2) THEN
recFib = n
Line 1,331 ⟶ 2,609:
recFib = recFib(n - 1) + recFib(n - 2)
END IF
END FUNCTION</
====Array (Table) Lookup====
This uses a pre-generated list, requiring much less run-time processor usage. (Since the sequence never changes, this is probably the best way to do this in "the real world". The same applies to other sequences like prime numbers, and numbers like pi and e.)
<
DATA 63245986,-39088169,24157817,-14930352,9227465,-5702887,3524578,-2178309
DATA 1346269,-832040,514229,-317811,196418,-121393,75025,-46368,28657,-17711
Line 1,357 ⟶ 2,634:
NEXT
PRINT
'*****sample inputs*****</
==={{header|Quite BASIC}}===
<syntaxhighlight lang="qbasic">100 CLS
110 rem The array F holds the Fibonacci numbers
120 ARRAY f : rem DIM f(22) para Quite BASIC and MSX-BASIC
130 LET f(0) = 0
140 LET f(1) = 1
150 LET n = 1
160 rem Compute the NEXT Fibbonacci number
170 LET f(n+1) = f(n)+f(n-1)
180 LET n = n+1
190 PRINT f(n-2);" ";
200 rem STOP after printing 20 numbers
210 IF n < 22 THEN GOTO 170</syntaxhighlight>
==={{header|Run BASIC}}===
<syntaxhighlight lang="runbasic">for i = 0 to 10
print i;" ";fibR(i);" ";fibI(i)
next i
end
function fibR(n)
if n < 2 then fibR = n else fibR = fibR(n-1) + fibR(n-2)
end function
function fibI(n)
b = 1
for i = 1 to n
t = a + b
a = b
b = t
next i
fibI = a
end function</syntaxhighlight>
==={{header|S-BASIC}}===
Note that the 23rd Fibonacci number (=28657) is the largest that can be generated without overflowing S-BASIC's integer data type.
<syntaxhighlight lang="basic">
rem - iterative function to calculate nth fibonacci number
function fibonacci(n = integer) = integer
var f, i, p1, p2 = integer
p1 = 0
p2 = 1
if n = 0 then
f = 0
else
for i = 1 to n
f = p1 + p2
p2 = p1
p1 = f
next i
end = f
rem - exercise the function
var i = integer
for i = 0 to 10
print fibonacci(i);
next i
end
</syntaxhighlight>
{{out}}
<pre> 0 1 1 2 3 5 8 13 21 34 55
</pre>
==={{header|Sinclair ZX81 BASIC}}===
====Analytic====
<
20 PRINT INT (0.5+(((SQR 5+1)/2)**N)/SQR 5)</
====Iterative====
<
20 LET A=0
30 LET B=1
Line 1,373 ⟶ 2,714:
70 LET A=C
80 NEXT I
90 PRINT B</
====Tail recursive====
<
20 LET A=0
30 LET B=1
Line 1,388 ⟶ 2,729:
110 LET N=N-1
120 GOSUB 70
130 RETURN</
==={{header|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.
<ul>
<li>fibR: Fibonacci Recursive</li>
<li>fibI: Fibonacci Iterative</li>
<li>fibN: Fibonacci N-th Term</li>
</ul>
<syntaxhighlight lang="qbasic">FOR i = 0 TO 15
PRINT fibR(i),fibI(i),fibN(i)
NEXT i
/* Recursive Method */
DEF fibR(n)
IF n <= 1 THEN
fibR = n
ELSE
fibR = fibR(n-1) + fibR(n-2)
ENDIF
END DEF
/* Iterative Method */
DEF fibI(n)
a = 0
b = 1
FOR i = 1 TO n
temp = a + b
a = b
b = temp
NEXT i
fibI = a
END DEF
/* N-th Term Method */
DEF fibN(n)
uphi = .5 + SQR(5)/2
lphi = .5 - SQR(5)/2
fibN = (uphi^n-lphi^n)/SQR(5)
END DEF</syntaxhighlight>
==={{header|Softbridge BASIC}}===
====Iterative====
<syntaxhighlight lang="basic">
Function Fibonacci(n)
x = 0
y = 1
i = 0
n = ABS(n)
If n < 2 Then
Fibonacci = n
Else
Do Until (i = n)
sum = x+y
x=y
y=sum
i=i+1
Loop
Fibonacci = x
End If
End Function
</syntaxhighlight>
==={{header|TI-83 BASIC}}===
==== Sequence table ====
<syntaxhighlight lang="ti83b">[Y=]
nMin=0
u(n)=u(n-1)+u(n-2)
u(nMin)={1,0}
[TABLE]
n u(n)
------- -------
0 0
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21
9 34
10 55
11 89
12 144 </syntaxhighlight>
==== Iterative ====
<syntaxhighlight lang="ti83b">{0,1
While 1
Disp Ans(1
{Ans(2),sum(Ans
End</syntaxhighlight>
==== Binet's formula ====
<syntaxhighlight lang="ti83b">Prompt N
.5(1+√(5 //golden ratio
(Ans^N–(-Ans)^-N)/√(5</syntaxhighlight>
==={{header|TI-89 BASIC}}===
====Recursive====
Optimized implementation (too slow to be usable for ''n'' higher than about 12).
<syntaxhighlight lang="ti89b">fib(n)
when(n<2, n, fib(n-1) + fib(n-2))</syntaxhighlight>
====Iterative====
Unoptimized implementation (I think the for loop can be eliminated, but I'm not sure).
<syntaxhighlight lang="ti89b">fib(n)
Func
Local a,b,c,i
0→a
1→b
For i,1,n
a→c
b→a
c+b→b
EndFor
a
EndFunc</syntaxhighlight>
==={{header|Tiny BASIC}}===
{{works with|TinyBasic}}
<syntaxhighlight lang="basic">10 LET A = 0
20 LET B = 1
30 PRINT "Which F_n do you want?"
40 INPUT N
50 IF N = 0 THEN GOTO 140
60 IF N = 1 THEN GOTO 120
70 LET C = B + A
80 LET A = B
90 LET B = C
100 LET N = N - 1
110 GOTO 60
120 PRINT B
130 END
140 PRINT 0
150 END
</syntaxhighlight>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FUNCTION fibonacci (n)
LET n1 = 0
LET n2 = 1
FOR k = 1 TO ABS(n)
LET sum = n1 + n2
LET n1 = n2
LET n2 = sum
NEXT k
IF n < 0 THEN
LET fibonacci = n1 * ((-1) ^ ((-n) + 1))
ELSE
LET fibonacci = n1
END IF
END FUNCTION
PRINT fibonacci(0) ! 0
PRINT fibonacci(13) ! 233
PRINT fibonacci(-42) !-267914296
PRINT fibonacci(47) ! 2971215073
END</syntaxhighlight>
==={{header|VBA}}===
Like Visual Basic .NET, but with keyword "Public" and type Variant (subtype Currency) instead of Decimal:
<syntaxhighlight lang="vb">Public Function Fib(ByVal n As Integer) As Variant
Dim fib0 As Variant, fib1 As Variant, sum As Variant
Dim i As Integer
fib0 = 0
fib1 = 1
For i = 1 To n
sum = fib0 + fib1
fib0 = fib1
fib1 = sum
Next i
Fib = fib0
End Function </syntaxhighlight>
With Currency type, maximum value is fibo(73).
The (slow) recursive version:
<syntaxhighlight lang="vba">
Public Function RFib(Term As Integer) As Long
If Term < 2 Then RFib = Term Else RFib = RFib(Term - 1) + RFib(Term - 2)
End Function
</syntaxhighlight>
With Long type, maximum value is fibo(46).
==={{header|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:=====
<syntaxhighlight lang="vb">class generator
dim t1
dim t2
dim tn
dim cur_overflow
Private Sub Class_Initialize
cur_overflow = false
t1 = ccur(0)
t2 = ccur(1)
tn = ccur(t1 + t2)
end sub
public default property get generated
on error resume next
generated = ccur(tn)
if err.number <> 0 then
generated = cdbl(tn)
cur_overflow = true
end if
t1 = ccur(t2)
if err.number <> 0 then
t1 = cdbl(t2)
cur_overflow = true
end if
t2 = ccur(tn)
if err.number <> 0 then
t2 = cdbl(tn)
cur_overflow = true
end if
tn = ccur(t1+ t2)
if err.number <> 0 then
tn = cdbl(t1) + cdbl(t2)
cur_overflow = true
end if
on error goto 0
end property
public property get overflow
overflow = cur_overflow
end property
end class</syntaxhighlight>
=====Invocation:=====
<syntaxhighlight lang="vb">dim fib
set fib = new generator
dim i
for i = 1 to 100
wscript.stdout.write " " & fib
if fib.overflow then
wscript.echo
exit for
end if
next</syntaxhighlight>
{{out}}
<pre> 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</pre>
==={{header|Visual Basic}}===
{{works with|Visual Basic|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.
<syntaxhighlight lang="vb">Sub fibonacci()
Const n = 139
Dim i As Integer
Dim f1 As Variant, f2 As Variant, f3 As Variant 'for Decimal
f1 = CDec(0): f2 = CDec(1) 'for Decimal setting
Debug.Print "fibo("; 0; ")="; f1
Debug.Print "fibo("; 1; ")="; f2
For i = 2 To n
f3 = f1 + f2
Debug.Print "fibo("; i; ")="; f3
f1 = f2
f2 = f3
Next i
End Sub 'fibonacci</syntaxhighlight>
{{Out}}
<pre>fibo( 0 )= 0
fibo( 1 )= 1
fibo( 2 )= 1
...
fibo( 137 )= 19134702400093278081449423917
fibo( 138 )= 30960598847965113057878492344
fibo( 139 )= 50095301248058391139327916261 </pre>
==={{header|Visual Basic .NET}}===
'''Platform:''' [[.NET]]
====Iterative====
{{works with|Visual Basic .NET|9.0+}}
With Decimal type, maximum value is fibo(139).
<syntaxhighlight lang="vbnet">Function Fib(ByVal n As Integer) As Decimal
Dim fib0, fib1, sum As Decimal
Dim i As Integer
fib0 = 0
fib1 = 1
For i = 1 To n
sum = fib0 + fib1
fib0 = fib1
fib1 = sum
Next
Fib = fib0
End Function</syntaxhighlight>
====Recursive====
{{works with|Visual Basic .NET|9.0+}}
<syntaxhighlight lang="vbnet">Function Seq(ByVal Term As Integer)
If Term < 2 Then Return Term
Return Seq(Term - 1) + Seq(Term - 2)
End Function</syntaxhighlight>
====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.
<syntaxhighlight lang="vbnet"> Function FiboBig(ByVal n As Integer) As BigInteger
' Fibonacci sequence with BigInteger
Dim fibn2, fibn1, fibn As BigInteger
Dim i As Integer
fibn = 0
fibn2 = 0
fibn1 = 1
If n = 0 Then
Return fibn2
ElseIf n = 1 Then
Return fibn1
ElseIf n >= 2 Then
For i = 2 To n
fibn = fibn2 + fibn1
fibn2 = fibn1
fibn1 = fibn
Next i
Return fibn
End If
Return 0
End Function 'FiboBig
Sub fibotest()
Dim i As Integer, s As String
i = 2000000 ' 2 millions
s = FiboBig(i).ToString
Console.WriteLine("fibo(" & i & ")=" & s & " - length=" & Len(s))
End Sub 'fibotest</syntaxhighlight>
====BigInteger, speedier method====
{{Libheader|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.<br/>Algorithm from [http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormula.html here, see section 3, ''Finding Fibonacci Numbers Fully''.]
<syntaxhighlight lang="vbnet">Imports System
Imports System.Collections.Generic
Imports BI = System.Numerics.BigInteger
Module Module1
' A sparse array of values calculated along the way
Dim sl As SortedList(Of Integer, BI) = New SortedList(Of Integer, BI)()
' Square a BigInteger
Function sqr(ByVal n As BI) As BI
Return n * n
End Function
' Helper routine for Fsl(). It adds an entry to the sorted list when necessary
Sub IfNec(n As Integer)
If Not sl.ContainsKey(n) Then sl.Add(n, Fsl(n))
End Sub
' This routine is semi-recursive, but doesn't need to evaluate every number up to n.
' Algorithm from here: http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormula.html#section3
Function Fsl(ByVal n As Integer) As BI
If n < 2 Then Return n
Dim n2 As Integer = n >> 1, pm As Integer = n2 + ((n And 1) << 1) - 1 : IfNec(n2) : IfNec(pm)
Return If(n2 > pm, (2 * sl(pm) + sl(n2)) * sl(n2), sqr(sl(n2)) + sqr(sl(pm)))
End Function
' Conventional iteration method (not used here)
Function Fm(ByVal n As BI) As BI
If n < 2 Then Return n
Dim cur As BI = 0, pre As BI = 1
For i As Integer = 0 To n - 1
Dim sum As BI = cur + pre : pre = cur : cur = sum : Next : Return cur
End Function
Sub Main()
Dim vlen As Integer, num As Integer = 2_000_000, digs As Integer = 35
Dim sw As System.Diagnostics.Stopwatch = System.Diagnostics.Stopwatch.StartNew()
Dim v As BI = Fsl(num) : sw.[Stop]()
Console.Write("{0:n3} ms to calculate the {1:n0}th Fibonacci number, ", sw.Elapsed.TotalMilliseconds, num)
vlen = CInt(Math.Ceiling(BI.Log10(v))) : Console.WriteLine("number of digits is {0}", vlen)
If vlen < 10000 Then
sw.Restart() : Console.WriteLine(v) : sw.[Stop]()
Console.WriteLine("{0:n3} ms to write it to the console.", sw.Elapsed.TotalMilliseconds)
Else
Console.Write("partial: {0}...{1}", v / BI.Pow(10, vlen - digs), v Mod BI.Pow(10, digs))
End If
End Sub
End Module</syntaxhighlight>
{{out}}
<pre>120.374 ms to calculate the 2,000,000th Fibonacci number, number of digits is 417975
partial: 85312949175076415430516606545038251...91799493108960825129188777803453125</pre>
==={{header|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.
<syntaxhighlight lang="vb">Function fibo(n As Integer) As UInt64
Dim noOne As UInt64 = 1
Dim noTwo As UInt64 = 1
Dim sum As UInt64
For i As Integer = 3 To n
sum = noOne + noTwo
noTwo = noOne
noOne = sum
Next
Return noOne
End Function</syntaxhighlight>
==={{header|Yabasic}}===
====Iterative====
<syntaxhighlight lang="vbnet">sub fibonacciI (n)
local n1, n2, k, sum
n1 = 0
n2 = 1
for k = 1 to abs(n)
sum = n1 + n2
n1 = n2
n2 = sum
next k
if n < 1 then
return n1 * ((-1) ^ ((-n) + 1))
else
return n1
end if
end sub</syntaxhighlight>
====Recursive====
Only positive numbers
<syntaxhighlight lang="vbnet">sub fibonacciR(n)
if n <= 1 then
return n
else
return fibonacciR(n-1) + fibonacciR(n-2)
end if
end sub</syntaxhighlight>
====Analytic====
Only positive numbers
<syntaxhighlight lang="vbnet">sub fibonacciA (n)
return int(0.5 + (((sqrt(5) + 1) / 2) ^ n) / sqrt(5))
end sub</syntaxhighlight>
====Binet's formula====
Fibonacci sequence using the Binet formula
<syntaxhighlight lang="vbnet">sub fibonacciB(n)
local sq5, phi1, phi2, dn1, dn2, k
sq5 = sqrt(5)
phi1 = (1 + sq5) / 2
phi2 = (1 - sq5) / 2
dn1 = phi1: dn2 = phi2
for k = 0 to n
dn1 = dn1 * phi1
dn2 = dn2 * phi2
print int(((dn1 - dn2) / sq5) + .5);
next k
end sub</syntaxhighlight>
==={{header|ZX Spectrum Basic}}===
====Iterative====
<syntaxhighlight lang="zxbasic">10 REM Only positive numbers
20 LET n=10
30 LET n1=0: LET n2=1
40 FOR k=1 TO n
50 LET sum=n1+n2
60 LET n1=n2
70 LET n2=sum
80 NEXT k
90 PRINT n1</syntaxhighlight>
====Analytic====
<syntaxhighlight lang="zxbasic">10 DEF FN f(x)=INT (0.5+(((SQR 5+1)/2)^x)/SQR 5)</syntaxhighlight>
=={{header|Batch File}}==
Recursive version
<
@echo off
if "%1" equ "" goto :eof
Line 1,412 ⟶ 3,228:
set r2=%errorlevel%
set /a r0 = r1 + r2
exit /b !r0!</
{{out}}
Line 1,429 ⟶ 3,245:
>fibo.cmd 16
987</pre>
=={{header|Battlestar}}==
<!--- works with C syntax highlighting --->
<syntaxhighlight lang="c">
// Fibonacci sequence, recursive version
fun fibb
Line 1,478 ⟶ 3,293:
// vim: set syntax=c ts=4 sw=4 et:
</syntaxhighlight>
=={{header|bc}}==
=== iterative ===
<
define fib(x) {
Line 1,522 ⟶ 3,311:
}
fib(1000)
quit</
=={{header|BCPL}}==
<syntaxhighlight lang="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))</syntaxhighlight>
{{out}}
<pre>F_0 = 0
F_1 = 1
F_2 = 1
F_3 = 2
F_4 = 3
F_5 = 5
F_6 = 8
F_7 = 13
F_8 = 21
F_9 = 34
F_10 = 55</pre>
=={{header|beeswax}}==
<
_`Enter n: `TN`Fib(`{`)=`X~P~K#{;
#>~P~L#MM@>+@'q@{;
b~@M<</
Example output:
Line 1,536 ⟶ 3,353:
Notice the UInt64 wrap-around at <code>Fib(94)</code>!
<
Enter n: i0
Line 1,564 ⟶ 3,381:
Fib(94)=1293530146158671551
Program finished!</
=={{header|Befunge}}==
<
^ .:\/*8"@"\%*8"@":\ <</
=={{header|BlitzMax}}==
<syntaxhighlight lang="blitzmax">local a:int = 0, b:int = 1, c:int = 1, n:int
n = int(input( "Enter n: "))
if n = 0 then
print 0
end
else if n = 1
print 1
end
end if
while n>2
a = b
b = c
c = a + b
n = n - 1
wend
print c</syntaxhighlight>
=={{header|Blue}}==
<syntaxhighlight lang="blue">
: fib ( nth:ecx -- result:edi ) 1 0
: compute ( times:ecx accum:eax scratch:edi -- result:edi ) xadd latest loop ;
: example ( -- ) 11 fib drop ;
</syntaxhighlight>
=={{header|BQN}}==
All given functions return the nth element in the sequence.
=== Recursive ===
A primitive recursive can be done with predicates:
<syntaxhighlight lang="bqn">Fib ← {𝕩>1 ? (𝕊 𝕩-1) + 𝕊 𝕩-2; 𝕩}</syntaxhighlight>
Or, it can be done with the Choose(<code>◶</code>) modifier:
<syntaxhighlight lang="bqn">Fib2 ← {(𝕩-1) (𝕩>1)◶⟨𝕩, +○𝕊⟩ 𝕩-2}</syntaxhighlight>
=== Iterative ===
An iterative solution can be made with the Repeat(<code>⍟</code>) modifier:
<syntaxhighlight lang="bqn">{⊑(+`⌽)⍟𝕩 0‿1}</syntaxhighlight>
=={{header|Bracmat}}==
===Recursive===
<syntaxhighlight lang="bracmat">fib=.!arg:<2|fib$(!arg+-2)+fib$(!arg+-1)</syntaxhighlight>
fib$30
832040
===Iterative===
<syntaxhighlight lang="bracmat">(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
)</syntaxhighlight>
fib$777
1081213530912648191985419587942084110095342850438593857649766278346130479286685742885693301250359913460718567974798268702550329302771992851392180275594318434818082
=={{header|Brainf***}}==
{{works with|Brainf***|implementations with unbounded cell size}}
The first cell contains ''n'' (10), the second cell will contain ''fib(n)'' (55), and the third cell will contain ''fib(n-1)'' (34).
<
>>+<<[->[->+>+<<]>[-<+>]>[-<+>]<<<]</
The following generates n fibonacci numbers and prints them, though not in ascii.
It does have a limit due to the cells usually being 1 byte in size.
<
>> + Init #2 to 1
<<
Line 1,614 ⟶ 3,497:
]
<<<< Back to #0
]</
=={{header|Brat}}==
===Recursive===
<
true? x < 2, x, { fibonacci(x - 1) + fibonacci(x - 2) }
}</
===Tail Recursive===
<
true? x == 0,
result,
Line 1,656 ⟶ 3,514:
fibonacci = { x |
fib_aux x, 1, 0
}</
===Memoization===
<
fibonacci = { x |
Line 1,665 ⟶ 3,523:
{ cache[x] }
{true? x < 2, x, { cache[x] = fibonacci(x - 1) + fibonacci(x - 2) }}
}</
=={{header|Bruijn}}==
<syntaxhighlight lang="bruijn">
:import std/Combinator .
:import std/Math .
:import std/List .
# unary/Church fibonacci (moderately fast but very high space complexity)
fib-unary [0 [[[2 0 [2 (1 0)]]]] k i]
:test (fib-unary (+6u)) ((+8u))
# ternary fibonacci using infinite list iteration (very fast)
fib-list \index fibs
fibs head <$> (iterate &[[0 : (1 + 0)]] ((+0) : (+1)))
:test (fib-list (+6)) ((+8))
# recursive fib (very slow)
fib-rec y [[0 <? (+1) (+0) (0 <? (+2) (+1) rec)]]
rec (1 --0) + (1 --(--0))
:test (fib-rec (+6)) ((+8))
</syntaxhighlight>
Performance using <code>HigherOrder</code> reduction without optimizations:
<syntaxhighlight>
> :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
</syntaxhighlight>
=={{header|Burlesque}}==
<
{0 1}{^^++[+[-^^-]\/}30.*\[e!vv
</syntaxhighlight>
<
0 1{{.+}c!}{1000.<}w!
</syntaxhighlight>
=={{header|C}}==
===Recursive===
<
return (--n>0)?(fibb(b, a+b, n)):(a);
}</
===Iterative===
<
int fnow = 0, fnext = 1, tempf;
while(--n>0){
Line 1,692 ⟶ 3,587:
}
return fnext;
}</
===Analytic===
<
#define PHI ((1 + sqrt(5))/2)
long long unsigned fib(unsigned n) {
return floor( (pow(PHI, n) - pow(1 - PHI, n))/sqrt(5) );
}</
===Generative===
{{trans|Python}}
{{works with|gcc|version 4.1.2 20080704 (Red Hat 4.1.2-44)}}
<
typedef enum{false=0, true=!0} bool;
typedef void iterator;
Line 1,741 ⟶ 3,636:
OD;
printf("...\n");
}</
{{out}}
<pre>
Line 1,748 ⟶ 3,643:
===Fast method for a single large value===
<
#include <stdio.h>
#include <gmp.h>
Line 1,821 ⟶ 3,716:
}
return 0;
}</
{{out}}
<pre>
Line 1,834 ⟶ 3,729:
1919488
</pre>
=={{header|C sharp|C#}}==
=== Recursive ===
<syntaxhighlight lang="csharp">
public static ulong Fib(uint n) {
return (n < 2)? n : Fib(n - 1) + Fib(n - 2);
}
</syntaxhighlight>
=== Tail-Recursive ===
<syntaxhighlight lang="csharp">
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);
}
</syntaxhighlight>
=== Iterative ===
<syntaxhighlight lang="csharp">
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;
}
</syntaxhighlight>
=== Iterative ===
<syntaxhighlight lang="csharp">
using System; using System.Text; // FIBRUS.cs Russia
namespace Fibrus { class Program { static void Main()
{ long fi1=1; long fi2=1; long fi3=1; int da; int i; int d;
for (da=1; da<=78; da++) // rextester.com/MNGUV70257
{ d = 20-Convert.ToInt32((Convert.ToString(fi3)).Length);
for (i=1; i<d; i++) Console.Write(".");
Console.Write(fi3); Console.Write(" "); Console.WriteLine(da);
fi3 = fi2 + fi1;
fi1 = fi2;
fi2 = fi3;
}}}}
</syntaxhighlight>
{{out}}
<pre>
..................1 1
..................2 2
..................3 3
...
...5527939700884757 76
...8944394323791464 77
..14472334024676221 78
</pre>
=== Eager-Generative ===
<syntaxhighlight lang="csharp">
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;
}
</syntaxhighlight>
=== Lazy-Generative ===
<syntaxhighlight lang="csharp">
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;
}
}
</syntaxhighlight>
=== Analytic ===
This returns digits up to the 93<sup>rd</sup> Fibonacci number, but the digits become inaccurate past the 71<sup>st</sup>. There is custom rounding applied to the result that allows the function to be accurate at the 71<sup>st</sup> number instead of topping out at the 70<sup>th</sup>.
<syntaxhighlight lang="csharp">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)); }</syntaxhighlight>To get to the 93<sup>rd</sup> Fibonacci number, one must use the decimal type, rather than the double type, like this:<syntaxhighlight lang="csharp">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)); }</syntaxhighlight>Note that the Math.Pow() function and the Math.Sqrt() function must be replaced with ones returning the decimal type.<br/><br/>If one allows the fib() function to return the decimal type, one can reach the 138<sup>th</sup> Fibonacci number. However, the accuracy is lost after the 128<sup>th.</sup><syntaxhighlight lang="csharp">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); }</syntaxhighlight>
=== Matrix ===
Algorithm is based on
:<math>\begin{pmatrix}1&1\\1&0\end{pmatrix}^n = \begin{pmatrix}F(n+1)&F(n)\\F(n)&F(n-1)\end{pmatrix}</math>.
Needs <code>System.Windows.Media.Matrix</code> or similar Matrix class.
Calculates in <math>O(n)</math>.
<syntaxhighlight lang="csharp">
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];
}
</syntaxhighlight>
Needs <code>System.Windows.Media.Matrix</code> or similar Matrix class.
Calculates in <math>O(\log{n})</math>.
<syntaxhighlight lang="csharp">
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;
}
</syntaxhighlight>
=== Array (Table) Lookup ===
<syntaxhighlight lang="csharp">
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];
}
</syntaxhighlight>
===Arbitrary Precision===
{{libheader|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).
<syntaxhighlight lang="csharp">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));
}
}</syntaxhighlight>
{{out}}
<pre>137.209 ms to calculate the 2,000,000th Fibonacci number, number of digits is 417975
partial: 85312949175076415430516606545038251...91799493108960825129188777803453125
</pre>
===Shift PowerMod===
{{libheader|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 (<code>BigInteger.ModPow()</code> 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 (<code>fibTab()</code>). It reuses the intermediate large shifted BigIntegers on suceeding iterations, therfore it is a little more efficient than calling the oneshot (<code>oneFib()</code>) routine repeatedly from a loop.
<syntaxhighlight lang="csharp">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));
}
}</syntaxhighlight>
{{out}}
<pre>Fibonacci numbers 0..20: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
Fibonacci(1000): 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875</pre>
=={{header|C++}}==
Using unsigned int, this version only works up to 48 before fib overflows.
<
int main()
Line 1,852 ⟶ 4,027:
return 0;
}</
Line 1,858 ⟶ 4,033:
This version does not have an upper bound.
<
#include <gmpxx.h>
Line 1,878 ⟶ 4,053:
}
return 0;
}</
Version using transform:
<
#include <vector>
#include <functional>
Line 1,893 ⟶ 4,068:
// "v" now contains the Fibonacci sequence from 0 up
return v[n];
}</
Far-fetched version using adjacent_difference:
<
#include <vector>
#include <functional>
Line 1,908 ⟶ 4,083:
return v[n-1];
}
</syntaxhighlight>
Version which computes at compile time with metaprogramming:
<
template <int n> struct fibo
Line 1,934 ⟶ 4,109:
std::cout<<fibo<46>::value<<std::endl;
return 0;
}</
The following version is based on fast exponentiation:
<
inline void fibmul(int* f, int* g)
Line 1,971 ⟶ 4,146:
std::cout << fibonacci(i) << " ";
std::cout << std::endl;
}</
{{out}}
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. [[Zeckendorf number representation#Using a C++11 User Defined Literal|Here]] I define a class N which defines the operations increment ++() and comparison <=(other N) for Zeckendorf Numbers.
<
// Use Zeckendorf numbers to display Fibonacci sequence.
// Nigel Galloway October 23rd., 2012
Line 1,992 ⟶ 4,167:
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
Line 2,000 ⟶ 4,175:
===Using Standard Template Library===
Possibly less "Far-fetched version".
<
// Use Standard Template Library to display Fibonacci sequence.
// Nigel Galloway March 30th., 2013
Line 2,012 ⟶ 4,187:
return 0;
}
</syntaxhighlight>
{{out}}
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946
=={{header|Cat}}==
<
dup 1 <=
[]
[dup 1 - fib swap 2 - fib +]
if
}</
=={{header|Chapel}}==
<
var a = 0, b = 1;
Line 2,238 ⟶ 4,207:
(a, b) = (b, b + a);
}
}</
=={{header|Chef}}==
<
An unobfuscated iterative implementation.
Line 2,271 ⟶ 4,240:
Pour contents of the 4th mixing bowl into baking dish.
Serves 1.</
=={{header|
<syntaxhighlight lang="scheme">
(define fib (lambda (n) (cond ((> n 1) (+ (fib (- n 1)) (fib (- n 2))))
((= n 1) 1)
((= n 0) 0))))
</syntaxhighlight>
=={{header|Clio}}==
Line 2,324 ⟶ 4,253:
Clio is pure and functions are lazy and memoized by default
<
if n < 2: n
else: (n - 1 -> fib) + (n - 2 -> fib)
[0:100] -> * fib -> * print</
=={{header|Clojure}}==
Line 2,334 ⟶ 4,263:
===Lazy Sequence===
This is implemented idiomatically as an infinitely long, lazy sequence of all Fibonacci numbers:
<
(map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))</
Thus to get the nth one:
<syntaxhighlight lang
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.
<
(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:
<
Then, to see the first ten,
<
(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:
<
;; 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)
Line 2,374 ⟶ 4,303:
(if (< max 2)
max
(fib-iter max 1 0N 1N)))</
"defn-" means that the function is private (for use only inside this library). The "N" suffixes on integers tell Clojure to use arbitrary precision ints for those.
===Doubling Algorithm (Fast)===
Based upon the doubling algorithm which computes in O(log (n)) time as described here https://www.nayuki.io/page/fast-fibonacci-algorithms
Implementation credit: https://stackoverflow.com/questions/27466311/how-to-implement-this-fast-doubling-fibonacci-algorithm-in-clojure/27466408#27466408
<syntaxhighlight lang="clojure">
(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))))
</syntaxhighlight>
===Recursive===
Line 2,381 ⟶ 4,327:
A naive slow recursive solution:
<
(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.
<
(memoize
(fn [n]
Line 2,397 ⟶ 4,343:
1 1
(+ (fib (- n 1))
(fib (- n 2)))))))</
=== Using core.async ===
<
(require '[clojure.core.async
:refer [<! >! >!! <!! timeout chan alt! go]])
Line 2,416 ⟶ 4,362:
(for [i (range 10)]
(println (<!! c))))))
</syntaxhighlight>
=={{header|CLU}}==
<syntaxhighlight lang="clu">% Generate Fibonacci numbers
fib = iter () yields (int)
a: int := 0
b: int := 1
while true do
yield (a)
a, b := b, a+b
end
end fib
% Grab the n'th value from an iterator
nth = proc [T: type] (g: itertype () yields (T), n: int) returns (T)
for v: T in g() do
if n<=0 then return (v) end
n := n-1
end
end nth
% Print a few values
start_up = proc ()
po: stream := stream$primary_output()
% print values coming out of the fibonacci iterator
% (which are generated one after the other without delay)
count: int := 0
for f: int in fib() do
stream$putl(po, "F(" || int$unparse(count) || ") = " || int$unparse(f))
count := count + 1
if count = 15 then break end
end
% print a few random fibonacci numbers
% (to do this it has to restart at the beginning for each
% number, making it O(N))
fibs: sequence[int] := sequence[int]$[20,30,50]
for n: int in sequence[int]$elements(fibs) do
stream$putl(po, "F(" || int$unparse(n) || ") = "
|| int$unparse(nth[int](fib, n)))
end
end start_up</syntaxhighlight>
{{out}}
<pre>F(0) = 0
F(1) = 1
F(2) = 1
F(3) = 2
F(4) = 3
F(5) = 5
F(6) = 8
F(7) = 13
F(8) = 21
F(9) = 34
F(10) = 55
F(11) = 89
F(12) = 144
F(13) = 233
F(14) = 377
F(20) = 6765
F(30) = 832040
F(50) = 12586269025</pre>
=={{header|CMake}}==
Iteration uses a while() loop. Memoization uses global properties.
<syntaxhighlight lang="cmake">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)</syntaxhighlight>
<syntaxhighlight lang="cmake"># 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})</syntaxhighlight>
<pre> 0 1 1 2 3 5 8 13 21 34 ... 75025 121393 196418 317811 514229 832040</pre>
=={{header|COBOL}}==
===Iterative===
<
Data Division.
Working-Storage Section.
Line 2,459 ⟶ 4,514:
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|2.0}}
<
IDENTIFICATION DIVISION.
PROGRAM-ID. fibonacci-main.
Line 2,507 ⟶ 4,562:
END-EVALUATE
.
END PROGRAM fibonacci.</
=={{header|CoffeeScript}}==
===Analytic===
<
sqrt = Math.sqrt
phi = ((1 + sqrt(5))/2)
Math.round((Math.pow(phi, n)/sqrt(5)))</
===Iterative===
<
return n if n < 2
[prev, curr] = [0, 1]
[prev, curr] = [curr, curr + prev] for i in [1..n]
curr</
===Recursive===
<
if n < 2 then n else fib_rec(n-1) + fib_rec(n-2)</
=={{header|Comefrom0x10}}==
Line 2,532 ⟶ 4,587:
===Iterative===
<
a = 1
i = 1 # start
Line 2,546 ⟶ 4,601:
b = next_b
comefrom fib if i > stop</
=={{header|Common Lisp}}==
Note that Common Lisp uses bignums, so this will never overflow.
===Iterative===
<
(case n
(0 f0)
Line 2,558 ⟶ 4,613:
for a = f0 then b and b = f1 then result
for result = (+ a b)
finally (return result)))))</
Simpler one:
<
(let ((a 0) (b 1) (c n))
(loop for i from 2 to n do
Line 2,567 ⟶ 4,622:
a b
b c))
c))</
Not a function, just printing out the entire (for some definition of "entire") sequence with a <code>for var = </code> loop:<
===Recursive===
<
(if (< n 2)
n
(+ (fibonacci-recursive (- n 2)) (fibonacci-recursive (- n 1)))))</
<
(if (= n 0)
a
(fibonacci-tail-recursive (- n 1) b (+ a b))))</
Tail recursive and squaring:
<
(if (= n 1) (+ (* b p) (* a q))
(fib (ash n -1)
Line 2,592 ⟶ 4,647:
(+ (* q q) (* 2 p q))))) ;p is Fib(2^n-1), q is Fib(2^n).
(print (fib 100000))</
=== Alternate solution ===
I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]
<
;; Project : Fibonacci sequence
Line 2,610 ⟶ 4,665:
(write(+ n 1)) (format t "~a" ": ")
(write (fibonacci n)) (terpri))
</syntaxhighlight>
Output:
<pre>
Line 2,627 ⟶ 4,682:
=== Solution with methods and eql specializers ===
<
(defmethod fib (n)
(declare ((integer 0 *) n))
Line 2,636 ⟶ 4,691:
(defmethod fib ((n (eql 1))) 1)
</syntaxhighlight>
=== List-based iterative ===
This solution uses a list to keep track of the Fibonacci sequence for 0 or a
positive integer.
<syntaxhighlight lang="lisp">(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)))))))</syntaxhighlight>
{{out}}
<pre>> (fibo 0)
0
> (fibo 1)
1
> (fibo 10)
55
> (fibo 100)
354224848179261915075
> (fibo 1000)
43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875
> (fibo -10)
NIL</pre>
=== List-based recursive ===
This solution computes Fibonacci numbers as either:
#a list starting from the first element;
#a single number;
#an interval from ''i''-th to ''j''-th element.
Options #2 and #3 can take negative parameters,
but ''i'' (lowest index in range) must be greater
than ''j'' (highest index in range).
Values are represented internally by a reversed
list that grows from the head (and that's why
we reverse it back when we return it).
<syntaxhighlight lang="lisp">(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))))))</syntaxhighlight>
{{out}}
<pre>> (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)</pre>
=={{header|Computer/zero Assembly}}==
To find the <math>n</math>th Fibonacci number, set the initial value of <tt>count</tt> equal to <math>n</math>–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 <math>n</math> greater than 13.
<
STA temp
ADD x ; lower No.
Line 2,661 ⟶ 4,804:
x: 1
y: 1
temp: 0</
=={{header|Coq}}==
<syntaxhighlight lang="coq">
Fixpoint rec_fib (m : nat) (a : nat) (b : nat) : nat :=
match m with
| 0 => a
| S k => rec_fib k b (a + b)
end.
Definition fib (n : nat) : nat :=
rec_fib n 0 1 .
</syntaxhighlight>
=={{header|Corescript}}==
<syntaxhighlight lang="corescript">print Fibonacci Sequence:
var previous = 1
var number = 0
var temp = (blank)
:fib
if number > 50000000000:kill
print (number)
set temp = (add number previous)
set previous = (number)
set number = (temp)
goto fib
:kill
stop</syntaxhighlight>
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
sub fibonacci(n: uint32): (a: uint32) is
a := 0;
var b: uint32 := 1;
while n > 0 loop
var c := a + b;
a := b;
b := c;
n := n - 1;
end loop;
end sub;
# test
var i: uint32 := 0;
while i < 20 loop
print_i32(fibonacci(i));
print_char(' ');
i := i + 1;
end loop;
print_nl();</syntaxhighlight>
{{out}}
<pre>0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181</pre>
=={{header|Crystal}}==
===Recursive===
<syntaxhighlight lang="ruby">def fib(n)
n < 2 ? n : fib(n - 1) + fib(n - 2)
end</syntaxhighlight>
===Iterative===
<syntaxhighlight lang="ruby">def fibIterative(n, prevFib = 0, fib = 1)
return n if n < 2
n.times do
prevFib, fib = fib, prevFib + fib
end
prevFib
end</syntaxhighlight>
===Tail Recursive===
<syntaxhighlight lang="ruby">def fibTailRecursive(n, prevFib = 0, fib = 1)
n == 0 ? prevFib : fibTailRecursive(n - 1, fib, prevFib + fib)
end</syntaxhighlight>
===Analytic===
<syntaxhighlight lang="ruby">def fibBinet(n)
(((5 ** 0.5 + 1) / 2) ** n / 5 ** 0.5).round.to_i
end</syntaxhighlight>
=={{header|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.
<
long sgn(alias unsignedFib)(int n) { // break sign manipulation apart
Line 2,754 ⟶ 4,980:
foreach (i, f; fibG(-9))
writef("%d:%d | ", i, f);
}</
{{out}} for n = 85:
<pre>Fib( 85) =
Line 2,762 ⟶ 4,988:
0:0 | -1:1 | -2:-1 | -3:2 | -4:-3 | -5:5 | -6:-8 | -7:13 | -8:-21 | -9:34 | </pre>
===Matrix Exponentiation Version===
<
T fibonacciMatrix(T=BigInt)(size_t n) {
Line 2,791 ⟶ 5,017:
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.
<
// Algorithm from: Takahashi, Daisuke,
Line 2,838 ⟶ 5,064:
void main() {
10_000_000.fibonacci;
}</
=={{header|Dart}}==
<
if (n==0 || n==1) {
return n;
Line 2,860 ⟶ 5,086:
print(fib(11));
print(fibRec(11));
}</
=={{header|Datalog}}==
Simple recurive implementation for Souffle.
<syntaxhighlight lang="datalog">.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.</syntaxhighlight>
=={{header|DBL}}==
<syntaxhighlight lang="dart">;
; Fibonacci sequence for DBL version 4 by Dario B.
;
RECORD
FIB1, D10
FIB2, D10
FIBN, D10
J, D5
A2, A2
A5, A5
PROC
;----------------------------------------------------------------
XCALL FLAGS (0007000000,1) ;Suppress STOP message
OPEN (1,O,'TT:')
DISPLAY (1,'First 10 Fibonacci Numbers:',10)
FIB2=1
FOR J=1 UNTIL 10
DO BEGIN
FIBN=FIB1+FIB2
A2=J,'ZX'
A5=FIBN,'ZZZZX'
DISPLAY (1,A2,' : ',A5,10)
FIB1=FIB2
FIB2=FIBN
END
CLOSE 1
END</syntaxhighlight>
=={{header|Dc}}==
This needs a modern Dc with <code>r</code> (swap) and <code>#</code> (comment).
It easily can be adapted to an older Dc, but it will impact readability a lot.
<
d - # 0
1 + # 1
Line 2,881 ⟶ 5,151:
] sF
33 lF x f</
{{out}}
<pre>
Line 2,890 ⟶ 5,160:
=== Iterative ===
<syntaxhighlight lang="delphi">
function FibonacciI(N: Word): UInt64;
var
Line 2,909 ⟶ 5,179:
end;
end;
</syntaxhighlight>
=== Recursive ===
<syntaxhighlight lang="delphi">
function Fibonacci(N: Word): UInt64;
begin
Line 2,920 ⟶ 5,190:
Result := Fibonacci(N - 1) + Fibonacci(N - 2);
end;
</syntaxhighlight>
=== Matrix ===
Algorithm is based on
:<math>\begin{pmatrix}1&1\\1&0\end{pmatrix}^n = \begin{pmatrix}F(n+1)&F(n)\\F(n)&F(n-1)\end{pmatrix}</math>.
<syntaxhighlight lang="delphi">
function fib(n: Int64): Int64;
Line 2,962 ⟶ 5,232:
fib := matrix[0,0];
end;
</syntaxhighlight>
=={{header|DIBOL-11}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|DWScript}}==
<
begin
if N < 2 then Result := 1
else Result := fib(N-2) + fib(N-1);
End;</
=={{header|Dyalect}}==
<syntaxhighlight lang="dyalect">func fib(n) {
if n < 2 {
return n
} else {
return fib(n - 1) + fib(n - 2)
}
}
print(fib(30))</syntaxhighlight>
=={{header|E}}==
<
var s := [0, 1]
for _ in 0..!n {
Line 2,980 ⟶ 5,323:
}
return s[0]
}</
(This version defines <tt>fib(0) = 0</tt> because [http://www.research.att.com/~njas/sequences/A000045 OEIS A000045] does.)
=={{header|EasyLang}}==
<syntaxhighlight lang="text">
func fib n .
if n < 2
return n
.
prev = 0
val = 1
for i = 2 to n
h = prev + val
prev = val
val = h
.
return val
.
print fib 36
</syntaxhighlight>
Recursive (inefficient):
<syntaxhighlight lang="text">
func fib n .
if n < 2
return n
.
return fib (n - 2) + fib (n - 1)
.
print fib 36
</syntaxhighlight>
=={{header|EchoLisp}}==
Use '''memoization''' with the recursive version.
<
(define (fib n)
(if (< n 2) n
Line 2,995 ⟶ 5,369:
(for ((i 12)) (write (fib i)))
0 1 1 2 3 5 8 13 21 34 55 89
</syntaxhighlight>
=={{header|ECL}}==
Line 3,001 ⟶ 5,375:
===Analytic===
<
Line 3,029 ⟶ 5,403:
RETURN FibSeq;
END; }</
=={{header|EDSAC order code}}==
This program calculates the <i>n</i>th—by default the tenth—number in the Fibonacci sequence and displays it (in binary) in the first word of storage tank 3.
<
==================
Line 3,084 ⟶ 5,458:
[ 20 ] P0F [ used to clear a ]
EZPF [ begin execution ]</
{{out}}
<pre>00000000000110111</pre>
=={{header|Eiffel}}==
<
class
APPLICATION
Line 3,140 ⟶ 5,514:
end
</syntaxhighlight>
=={{header|Ela}}==
Tail-recursive function:
<
where fib' a b 0 = a
fib' a b n = fib' b (a + b) (n - 1)</
Infinite (lazy) list:
<
where fib' x y = & x :: fib' y (x + y)</
=={{header|Elena}}==
{{trans|Smalltalk}}
ELENA
<
fibu(n)
{
int[] ac := new int[]
if (n < 2)
{
Line 3,164 ⟶ 5,539:
else
{
for(int i := 2
{
int t := ac[1];
Line 3,170 ⟶ 5,545:
ac[0] := t
};
^ ac[1]
}
Line 3,177 ⟶ 5,552:
public program()
{
for(int i := 0
{
console.printLine(fibu(i))
}
}</
{{out}}
<pre>
Line 3,196 ⟶ 5,571:
55
</pre>
=== Alternative version using yieldable method ===
<syntaxhighlight lang="elena">import extensions;
public FibonacciGenerator
{
yieldable next()
{
long n_2 := 1l;
long n_1 := 1l;
$yield n_2;
$yield n_1;
while(true)
{
long n := n_2 + n_1;
$yield n;
n_2 := n_1;
n_1 := n
}
}
}
public program()
{
auto e := new FibonacciGenerator();
for(int i := 0; i < 10; i += 1) {
console.printLine(e.next())
};
console.readChar()
}</syntaxhighlight>
=={{header|Elixir}}==
<
def fib(0), do: 0
def fib(1), do: 1
Line 3,210 ⟶ 5,621:
end
IO.inspect Enum.map(0..10, fn i-> Fibonacci.fib(i) end)</
Using Stream:
<syntaxhighlight lang="elixir">
Stream.unfold({0,1}, fn {a,b} -> {a,{b,a+b}} end) |> Enum.take(10)
</syntaxhighlight>
{{out}}
Line 3,223 ⟶ 5,634:
=={{header|Elm}}==
Naïve recursive implementation.
<
fibonacci n = if n < 2 then
n
else
fibonacci(n - 2) + fibonacci(n - 1)</
'''version 2'''
<syntaxhighlight lang=”elm">fib : Int -> number
fib n =
case n of
0 -> 0
1 -> 1
_ -> fib (n-1) + fib (n-2)
</syntaxhighlight>
{{out}}
<pre>
elm repl
> fib 40
102334155 : number
> List.map (\elem -> fib elem) (List.range 1 40)
[1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,
4181,6765,10946,17711,28657,46368,75025,121393,196418,
317811,514229,832040,1346269,2178309,3524578,5702887,
9227465,14930352,24157817,39088169,63245986,102334155]
: List number
</pre>
=={{header|Emacs Lisp}}==
===version 1===
<syntaxhighlight lang="lisp">(defun fib (n a b c)
(cond
((< c n) (fib n b (+ a b) (+ 1 c)))
((= c n) b)
(t a)))
(defun fibonacci (n)
(
(fib n 0 1 1)))</syntaxhighlight>
===version 2===
<syntaxhighlight lang="lisp">(defun fibonacci (n)
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))))</syntaxhighlight>
<b>Eval:</b>
<syntaxhighlight lang="lisp">(insert
(mapconcat
{{out}}
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610
=={{header|Erlang}}==
===Recursive ===
<syntaxhighlight lang="erlang">
-module(fib).
-export([fib/1]).
Line 3,272 ⟶ 5,718:
fib(1) -> 1;
fib(N) -> fib(N-1) + fib(N-2).
</syntaxhighlight>
===Iterative ===
<syntaxhighlight lang="erlang">
-module(fiblin).
-export([fib/1])
Line 3,289 ⟶ 5,735:
fib(N, A, B) -> if N < 1 -> B; true -> fib(N-1, B, A+B) end.
</syntaxhighlight>
<b> Evaluate:</b>
<syntaxhighlight lang="erlang">
io:write([fiblin:fib(X) || X <- lists:seq(1,10) ]).
</syntaxhighlight>
<b> Output:</b>
Line 3,302 ⟶ 5,748:
===Iterative 2===
<syntaxhighlight lang="erlang">
fib(N) -> fib(N, 0, 1).
Line 3,308 ⟶ 5,754:
fib(Iter, Result, Next) -> fib(Iter-1, Next, Result+Next).
</syntaxhighlight>
=={{header|ERRE}}==
<
! derived from my book "PROGRAMMARE IN ERRE"
! iterative solution
Line 3,338 ⟶ 5,784:
END PROGRAM
</syntaxhighlight>
{{out}}
<pre>
Line 3,348 ⟶ 5,794:
==='Recursive' version===
{{works with|Euphoria|any version}}
<syntaxhighlight lang="euphoria">
function fibor(integer n)
if n<2 then return n end if
return fibor(n-1)+fibor(n-2)
end function
</syntaxhighlight>
==='Iterative' version===
{{works with|Euphoria|any version}}
<syntaxhighlight lang="euphoria">
function fiboi(integer n)
integer f0=0, f1=1, f
Line 3,368 ⟶ 5,814:
return f
end function
</syntaxhighlight>
==='Tail recursive' version===
{{works with|Euphoria|4.0.0}}
<syntaxhighlight lang="euphoria">
function fibot(integer n, integer u = 1, integer s = 0)
if n < 1 then
Line 3,383 ⟶ 5,829:
-- example:
? fibot(10) -- says 55
</syntaxhighlight>
==='Paper tape' version===
{{works with|Euphoria|4.0.0}}
<syntaxhighlight lang="euphoria">
include std/mathcons.e -- for PINF constant
Line 3,467 ⟶ 5,913:
end while
</syntaxhighlight>
=={{header|
===LAMBDA===
Binding the name FIBONACCI to the following lambda in the Excel worksheet Name Manager:
(See [https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ The LAMBDA worksheet function])
{{Works with|Office 365 Betas 2021}}
<syntaxhighlight lang="lisp">FIBONACCI
=LAMBDA(n,
APPLYN(n - 2)(
LAMBDA(xs,
APPENDROWS(xs)(
SUM(
LASTNROWS(2)(xs)
)
)
)
)({1;1})
)</syntaxhighlight>
And assuming that the following names are also bound to reusable generic lambdas in the Name manager:
<syntaxhighlight lang="lisp">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()
)
)
)
)</syntaxhighlight>
{{Out}}
The FIBONACCI(n) lambda defines a column of integers.
Here we obtain a row, by composing FIBONACCI with the built-in TRANSPOSE function:
{| class="wikitable"
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="16" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=TRANSPOSE(FIBONACCI(15))
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
|
| A
| B
| C
| D
| E
| F
| G
| H
| I
| J
| K
| L
| M
| N
| O
| P
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
| style="text-align:left; font-weight:bold" | 15 Fibonacci terms:
| style="text-align:left; background-color:#cbcefb" | 1
| style="text-align:left" | 1
| style="text-align:left" | 2
| style="text-align:left" | 3
| style="text-align:left" | 5
| style="text-align:left" | 8
| style="text-align:left" | 13
| style="text-align:left" | 21
| style="text-align:left" | 34
| style="text-align:left" | 55
| style="text-align:left" | 89
| style="text-align:left" | 144
| style="text-align:left" | 233
| style="text-align:left" | 377
| style="text-align:left" | 610
|}
Or as a fold, obtaining just the Nth term of the Fibonacci series:
<syntaxhighlight lang="lisp">FIBONACCI2
=LAMBDA(n,
INDEX(
FOLDL(
LAMBDA(ab,
LAMBDA(_,
APPEND(INDEX(ab, 2))(SUM(ab))
)
)
)({0;1})(
ENUMFROMTO(1)(n)
),
1
)
)</syntaxhighlight>
Assuming the following generic bindings in the Excel worksheet Name manager:
<syntaxhighlight lang="lisp">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))
)
)</syntaxhighlight>
{{Out}}
{| class="wikitable"
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="2" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=FIBONACCI2(A2)
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
|
| A
| B
|- style="text-align:right;"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
| style="text-align:right; font-weight:bold" | N
| style="font-weight:bold" | Fibonacci
|- style="text-align:right;"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
| style="text-align:right; font-weight:bold" | 32
| style="background-color:#cbcefb;" | 2178309
|- style="text-align:right;"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3
| style="text-align:right; font-weight:bold" | 64
| 10610209857723
|}
=={{header|F_Sharp|F#}}==
This is a fast [tail-recursive] approach using the F# big integer support:
<syntaxhighlight lang="fsharp">
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</syntaxhighlight>
Lazy evaluated using sequence workflow:
<syntaxhighlight lang="fsharp">let rec fib = seq { yield! [0;1];
for (a,b) in Seq.zip fib (Seq.skip 1 fib) -> a+b}</syntaxhighlight>
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:
<syntaxhighlight lang="fsharp">let fibonacci = Seq.unfold (fun (x, y) -> Some(x, (y, x + y))) (0I,1I)
fibonacci |> Seq.nth 10000
</syntaxhighlight>
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.
<syntaxhighlight lang="fsharp">
open System
open System.Diagnostics
open System.Numerics
/// Finds the highest power of two which is less than or equal to a given input.
let inline prevPowTwo (x : int) =
let mutable n = x
n <- n - 1
n <- n ||| (n >>> 1)
n <- n ||| (n >>> 2)
n <- n ||| (n >>> 4)
n <- n ||| (n >>> 8)
n <- n ||| (n >>> 16)
n <- n + 1
match x with
| x when x = n -> x
| _ -> n/2
/// Evaluates the nth Fibonacci number using matrix arithmetic and
/// exponentiation by squaring.
let crazyFib (n : int) =
let powTwo = prevPowTwo n
/// Applies 2n rule repeatedly until another application of the rule would
/// go over the target value (or the target value has been reached).
let rec iter1 i q r s =
match i with
| i when i < powTwo ->
iter1 (i*2) (q*q + r*r) (r * (q+s)) (r*r + s*s)
| _ -> i, q, r, s
/// Applies n+1 rule until the target value is reached.
let rec iter2 (i, q, r, s) =
match i with
| i when i < n ->
iter2 ((i+1), (q+r), q, r)
| _ -> q
match n with
| 0 -> 1I
| _ ->
iter1 1 1I 1I 0I
|> iter2
</syntaxhighlight>
=={{header|Factor}}==
===Iterative===
<
dup 2 < [
[ 0 1 ] dip [ swap [ + ] keep ] times
drop
] unless ;</
===Recursive===
<
dup 2 < [
[ 1 - fib ] [ 2 - fib ] bi +
] unless ;</
===Tail-Recursive===
<
dup 1 <
[ 2drop ]
[ [ swap [ + ] keep ] dip 1 - fib2 ]
if ;
: fib ( n -- m ) [ 0 1 ] dip fib2 ;</
===Matrix===
{{trans|Ruby}}
<
: fib ( n -- m )
Line 3,504 ⟶ 6,264:
[ { { 0 1 } { 1 1 } } ] dip 1 - m^n
second second
] unless ;</
=={{header|Falcon}}==
===Iterative===
<
if n < 2: return n
Line 3,536 ⟶ 6,280:
end
return fib
end</
===Recursive===
<
if n < 2 : return n
return fib_r(n-1) + fib_r(n-2)
end</
===Tail Recursive===
<
return fib_aux(n,0,1)
end
Line 3,551 ⟶ 6,295:
default: return fib_aux(n-1,a+b,a)
end
end</
=={{header|FALSE}}==
<syntaxhighlight lang="false">[[$0=~][1-@@\$@@+\$44,.@]#]f:
20n: {First 20 numbers}
0 1 n;f;!%%44,. {Output: "0,1,1,2,3,5..."}</syntaxhighlight>
=={{header|Fancy}}==
<syntaxhighlight lang="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
}
</syntaxhighlight>
=={{header|Fantom}}==
Line 3,557 ⟶ 6,322:
Ints have a limit of 64-bits, so overflow errors occur after computing Fib(92) = 7540113804746346429.
<
class Main
{
Line 3,579 ⟶ 6,344:
}
}
</syntaxhighlight>
=={{header|Fe}}==
Recursive:
<syntaxhighlight lang="clojure">
(= fib (fn (n)
(if (< n 2) n
(+ (fib (- n 1)) (fib (- n 2))))))
</syntaxhighlight>
Iterative:
<syntaxhighlight lang="clojure">
(= fib (fn (n)
(let p0 0)
(let p1 1)
(while (< 0 n)
(= n (- n 1))
(let tmp (+ p0 p1))
(= p0 p1)
(= p1 tmp))
p0))
</syntaxhighlight>
=={{header|Fermat}}==
<syntaxhighlight lang="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;
.</syntaxhighlight>
=={{header|Fexl}}==
<syntaxhighlight lang="fexl">
# (fib n) = the nth Fibonacci number
\fib=
Line 3,601 ⟶ 6,398:
# Now test it:
for 0 20 (\n say (fib n))
</syntaxhighlight>
{{out}}
Line 3,627 ⟶ 6,424:
6765
</pre>
=={{header|Fish}}==
Outputs Fibonacci numbers until stopped.
<syntaxhighlight lang="fish">10::n' 'o&+&$10.</syntaxhighlight>
=={{header|FOCAL}}==
<
01.20 ASK "N =", N
01.30 SET A=0
Line 3,639 ⟶ 6,440:
02.10 SET T=B
02.20 SET B=A+B
02.30 SET A=T</
{{out}}
<pre>FIBONACCI NUMBERS
Line 3,646 ⟶ 6,447:
=={{header|Forth}}==
<
0 1 rot 0 ?do over + swap loop drop ;</
Or, for negative-index support:
<syntaxhighlight lang="forth">: 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 ;</syntaxhighlight>
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-next, over + swap
dup 0> IF dup , true ELSE false THEN ;
Line 3,667 ⟶ 6,476:
16 fibonacci . 987 ok
#F/64 . 93 ok
92 fibonacci . 7540113804746346429 ok \ largest number generated.</
=={{header|Fortran}}==
===FORTRAN IV===
<
NN=46
DO 1 I=0,NN
Line 3,692 ⟶ 6,501:
5 IFN=IFNM1+IFNM2
9 IFIBO=IFN
END</
{{out}}
<pre>
Line 3,711 ⟶ 6,520:
</pre>
===FORTRAN 77===
<
FUNCTION IFIB(N)
IF (N.EQ.0) THEN
Line 3,736 ⟶ 6,545:
IFIB=ITEMP0
END
</syntaxhighlight>
Test program
<
EXTERNAL IFIB
CHARACTER*10 LINE
Line 3,750 ⟶ 6,559:
901 FORMAT(3(X,I10))
END
</syntaxhighlight>
{{out}}
<pre>
Line 3,770 ⟶ 6,579:
===Recursive===
In ISO Fortran 90 or later, use a RECURSIVE function:
<
contains
recursive function fibR(n) result(fib)
Line 3,781 ⟶ 6,590:
case default; fib = fibR(n-1) + fibR(n-2)
end select
end function fibR</
===Iterative===
In ISO Fortran 90 or later:
<
integer, intent(in) :: n
integer, parameter :: fib0 = 0, fib1 = 1
Line 3,803 ⟶ 6,612:
end select
end function fibI
end module fibonacci</
Test program
<
use fibonacci
Line 3,812 ⟶ 6,621:
print *, fibr(i), fibi(i)
end do
end program fibTest</
{{out}}
Line 3,829 ⟶ 6,638:
</pre>
=={{header|
''See also: [[#Pascal|Pascal]]''
<syntaxhighlight lang="pascal">type
/// domain for Fibonacci function
/// where result is within nativeUInt
// You can not name it fibonacciDomain,
// since the Fibonacci function itself
// is defined for all whole numbers
// but the result beyond F(n) exceeds high(nativeUInt).
fibonacciLeftInverseRange =
{$ifdef CPU64} 0..93 {$else} 0..47 {$endif};
{**
implements Fibonacci sequence iteratively
\param n the index of the Fibonacci number to calculate
\returns the Fibonacci value at n
}
function fibonacci(const n: fibonacciLeftInverseRange): nativeUInt;
type
/// more meaningful identifiers than simple integers
relativePosition = (previous, current, next);
var
/// temporary iterator variable
i: longword;
/// holds preceding fibonacci values
f: array[relativePosition] of nativeUInt;
begin
f[previous] := 0;
f[current] := 1;
// note, in Pascal for-loop-limits are inclusive
for i := 1
begin
f[next] := f[previous] + f[current];
f[previous] := f[current];
f[current] := f[next];
end;
// assign to previous, bc f[current] = f[next] for next iteration
fibonacci := f[previous];
end;</syntaxhighlight>
=={{header|Frink}}==
All of Frink's integers can be arbitrarily large.
<
fibonacciN[n] :=
{
Line 3,949 ⟶ 6,696:
return a
}
</syntaxhighlight>
=={{header|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.
<
PUSH R2
PUSH R3
Line 3,975 ⟶ 6,722:
POP R1
RET</
=={{header|FunL}}==
=== Recursive ===
<
fib( 0 ) = 0
fib( 1 ) = 1
fib( n ) = fib( n - 1 ) + fib( n - 2 )</
=== Tail Recursive ===
<
def
_fib( 0, prev, _ ) = prev
Line 4,063 ⟶ 6,738:
_fib( n, prev, next ) = _fib( n - 1, next, next + prev )
_fib( n, 0, 1 )</
=== Lazy List ===
<
def _fib( a, b ) = a # _fib( b, a + b )
_fib( 0, 1 )
println( fib(10000) )</
{{out}}
Line 4,080 ⟶ 6,755:
=== Iterative ===
<
a, b = 0, 1
Line 4,086 ⟶ 6,761:
a, b = b, a+b
a</
=== Binet's Formula ===
<
def fib( n ) =
phi = (1 + sqrt( 5 ))/2
int( (phi^n - (-phi)^-n)/sqrt(5) + .5 )</
=== Matrix Exponentiation ===
<
res = array( a.length(), b(0).length() )
Line 4,114 ⟶ 6,789:
for i <- 0..10
println( fib(i) )</
{{out}}
Line 4,136 ⟶ 6,811:
=== Iterative ===
<syntaxhighlight lang="futhark">
fun main(n: int): int =
loop((a,b) = (0,1)) = for _i < n do
(b, a + b)
in a
</syntaxhighlight>
=={{header|FutureBasic}}==
=== Iterative ===
<syntaxhighlight lang="futurebasic">window 1, @"Fibonacci Sequence", (0,0,480,620)
local fn Fibonacci( n as long ) as
static long s1
long temp
if ( n < 2 )
s1 = n
temp = s1 + s2
s2 = s1
end fn = s1
CFTimeInterval t
t = fn CACurrentMediaTime
for i = 0 to 40
print i;
next i
print : printf @"Compute time:
HandleEvents</syntaxhighlight>
Output:
<pre>
Compute time: 2.143 ms</pre>
=== Recursive ===
Cost is a time penalty
<syntaxhighlight lang="futurebasic">
local fn Fibonacci( n as NSInteger ) as NSInteger
NSInteger result
if n < 2 then result = n : exit fn
result = fn Fibonacci( n-1 ) + fn Fibonacci( n-2 )
end fn = result
window 1
NSInteger i
CFTimeInterval t
t = fn CACurrentMediaTime
for i = 0 to 40
print i;@".\t";fn Fibonacci(i)
next
print : printf @"Compute time: %.3f ms",(fn CACurrentMediaTime-t)*1000
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
0. 0
1. 1
2. 1
3. 2
4. 3
5. 5
6. 8
7. 13
8. 21
9. 34
10. 55
11. 89
12. 144
13. 233
14. 377
15. 610
16. 987
17. 1597
18. 2584
19. 4181
20. 6765
21. 10946
22. 17711
23. 28657
24. 46368
25. 75025
26. 121393
27. 196418
28. 317811
29. 514229
30. 832040
31. 1346269
32. 2178309
33. 3524578
34. 5702887
35. 9227465
36. 14930352
37. 24157817
38. 39088169
39. 63245986
40. 102334155
Compute time: 2844.217 ms
</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Fibonacci_numbers}}
=== Recursive ===
Recursive version is slow, it is O(2<sup>n</sup>), or of exponential order.
[[File:Fōrmulæ - Fibonacci sequence 01.png]]
[[File:Fōrmulæ - Fibonacci sequence 02.png]]
[[File:Fōrmulæ - Fibonacci sequence result.png]]
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:
[[File:Fōrmulæ - Fibonacci sequence 03.png]]
[[File:Fōrmulæ - Fibonacci sequence 04.png]]
[[File:Fōrmulæ - Fibonacci sequence 05.png]]
=== Iterative (3 variables) ===
It is O(n), or of linear order.
[[File:Fōrmulæ - Fibonacci sequence 06.png]]
[[File:Fōrmulæ - Fibonacci sequence 07.png]]
[[File:Fōrmulæ - Fibonacci sequence result.png]]
=== Iterative (2 variables) ===
It is O(n), or of linear order.
[[File:Fōrmulæ - Fibonacci sequence 08.png]]
[[File:Fōrmulæ - Fibonacci sequence 09.png]]
[[File:Fōrmulæ - Fibonacci sequence result.png]]
=== Iterative, using a list ===
It is O(n), or of linear order.
[[File:Fōrmulæ - Fibonacci sequence 10.png]]
[[File:Fōrmulæ - Fibonacci sequence 11.png]]
[[File:Fōrmulæ - Fibonacci sequence result.png]]
=== Using matrix multiplication ===
[[File:Fōrmulæ - Fibonacci sequence 12.png]]
[[File:Fōrmulæ - Fibonacci sequence 13.png]]
[[File:Fōrmulæ - Fibonacci sequence result.png]]
=== Divide and conquer ===
It is an optimized version of the matrix multiplication algorithm, with an order of O(lg(n))
[[File:Fōrmulæ - Fibonacci sequence 14.png]]
[[File:Fōrmulæ - Fibonacci sequence 15.png]]
[[File:Fōrmulæ - Fibonacci sequence result.png]]
=== Closed-form ===
It has an order of O(lg(n))
[[File:Fōrmulæ - Fibonacci sequence 16.png]]
[[File:Fōrmulæ - Fibonacci sequence 17.png]]
[[File:Fōrmulæ - Fibonacci sequence result.png]]
=={{header|GAP}}==
<
local a;
a := [[0, 1], [1, 1]]^n;
return a[1][2];
end;</
GAP has also a buit-in function for that.
<syntaxhighlight lang
=={{header|Gecho}}==
<
Prints the first several fibonacci numbers...
=={{header|GML}}==
<syntaxhighlight lang="gml">///fibonacci(n)
//Returns the nth fibonacci number
Line 4,364 ⟶ 7,085:
}
return numb;</
=={{header|Go}}==
=== Recursive ===
<
if a < 2 {
return a
}
return fib(a - 1) + fib(a - 2)
}</
=== Iterative ===
<
"math/big"
)
Line 4,389 ⟶ 7,110:
}
return b
}</
=== Iterative using a closure ===
<
fib1, fib2 := 0, 1
return func() int {
Line 4,406 ⟶ 7,127:
}
return fib
}</
=== Using a goroutine and channel ===
<
a, b := 0, 1
for {
Line 4,423 ⟶ 7,144:
}
}
</syntaxhighlight>
=={{header|Grain}}==
=== Recursive ===
<syntaxhighlight lang="haskell">
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, " "))
}
</syntaxhighlight>
=== Iterative ===
<syntaxhighlight lang="haskell">
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)
</syntaxhighlight>
{{out}}
=== Iterative with Buffer ===
<syntaxhighlight lang="haskell">
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)
</syntaxhighlight>
{{out}}<pre>
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
</pre>
=={{header|Groovy}}==
Line 4,429 ⟶ 7,216:
=== Recursive ===
A recursive closure must be ''pre-declared''.
<
rFib = {
it == 0 ? 0
Line 4,436 ⟶ 7,223:
/*it < 0*/: rFib(it+2) - rFib(it+1)
}</
=== Iterative ===
<
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 ===
<
def aFib = { (φ**it - (-φ)**(-it))/(5**(1/2)) as BigInteger }</
Test program:
<
def start = System.currentTimeMillis()
def result = c()
Line 4,466 ⟶ 7,253:
fibList.each { printf ' %3d', it }
println()
}</
{{out}}
Line 4,477 ⟶ 7,264:
=={{header|Harbour}}==
===Recursive===
<syntaxhighlight lang="harbour">
#include "harbour.ch"
Function fibb(a,b,n)
return(if(--n>0,fibb(b,a+b,n),a))
</syntaxhighlight>
===Iterative===
<syntaxhighlight lang="harbour">
#include "harbour.ch"
Function fibb(n)
Line 4,494 ⟶ 7,281:
end while
return(fnext)
</syntaxhighlight>
=={{header|Haskell}}==
===Analytic===
{{Works with|exact-real|0.12.5.1}}
Using Binet's formula and [https://hackage.haskell.org/package/exact-real-0.12.5.1/docs/Data-CReal.html exact real arithmetic] library we can calculate arbitrary Fibonacci number '''exactly'''.
<syntaxhighlight lang="haskell">
import Data.CReal
phi = (1 + sqrt 5) / 2
fib :: (Integral b) => b -> CReal 0
fib n = (phi^^n - (-phi)^^(-n))/sqrt 5
</syntaxhighlight>
Let's try it for large numbers:
<syntaxhighlight lang="haskell">
λ> fib 10 :: CReal 0
55
(0.01 secs, 137,576 bytes)
λ> fib 100 :: CReal 0
354224848179261915075
(0.01 secs, 253,152 bytes)
λ> fib 10000 :: CReal 0
33644764876431783266621612005107543310302148460680063906564769974680081442166662368155595513633734025582065332680836159373734790483865268263040892463056431887354544369559827491606602099884183933864652731300088830269235673613135117579297437854413752130520504347701602264758318906527890855154366159582987279682987510631200575428783453215515103870818298969791613127856265033195487140214287532698187962046936097879900350962302291026368131493195275630227837628441540360584402572114334961180023091208287046088923962328835461505776583271252546093591128203925285393434620904245248929403901706233888991085841065183173360437470737908552631764325733993712871937587746897479926305837065742830161637408969178426378624212835258112820516370298089332099905707920064367426202389783111470054074998459250360633560933883831923386783056136435351892133279732908133732642652633989763922723407882928177953580570993691049175470808931841056146322338217465637321248226383092103297701648054726243842374862411453093812206564914032751086643394517512161526545361333111314042436854805106765843493523836959653428071768775328348234345557366719731392746273629108210679280784718035329131176778924659089938635459327894523777674406192240337638674004021330343297496902028328145933418826817683893072003634795623117103101291953169794607632737589253530772552375943788434504067715555779056450443016640119462580972216729758615026968443146952034614932291105970676243268515992834709891284706740862008587135016260312071903172086094081298321581077282076353186624611278245537208532365305775956430072517744315051539600905168603220349163222640885248852433158051534849622434848299380905070483482449327453732624567755879089187190803662058009594743150052402532709746995318770724376825907419939632265984147498193609285223945039707165443156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875
(0.02 secs, 4,847,128 bytes)
λ> fib (-10) :: CReal 0
-55
(0.01 secs, 138,408 bytes)
</syntaxhighlight>
===Recursive===
Simple definition, very inefficient.
<
if x < 1
then 0
else if x < 2
then 1
else fib (x - 1) + fib (x - 2)</
===Recursive with Memoization===
Very fast.
<
if x < 1
then 0
Line 4,524 ⟶ 7,330:
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):
<
fib :: Integer -> Integer
fib = memo f where
f 0 = 0
f 1 = 1
f n = fib (n-1) + fib (n-2)</
You can rewrite this without introducing f explicitly
<
fib :: Integer -> Integer
fib = memo $ \x -> case x of
0 -> 0
1 -> 1
n -> fib (n-1) + fib (n-2)</
Or using LambdaCase extension you can write it even shorter:
<
import Data.MemoTrie
fib :: Integer -> Integer
Line 4,548 ⟶ 7,354:
0 -> 0
1 -> 1
n -> fib (n-1) + fib (n-2)</
The version that supports negative numbers:
<
import Data.MemoTrie
fib :: Integer -> Integer
Line 4,557 ⟶ 7,363:
1 -> 1
n | n>0 -> fib (n-1) + fib (n-2)
| otherwise -> fib (n+2) - fib (n+1)</
===Iterative===
<
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:
<
Or alternatively:
<
The ''n''th Fibonacci number is then just <code plang="haskell">fib !! n</code>. The above is equivalent to
<
Also
<
==== As a fold ====
Accumulator holds last two members of the series:
<
fib :: Integer -> Integer
Line 4,592 ⟶ 7,398:
(\(a, b) _ -> (b, a + b))
(0, 1)
[1 .. n]</
=== With matrix exponentiation ===
Line 4,598 ⟶ 7,404:
we can simply write:
<
fib
Line 4,641 ⟶ 7,447:
-- TEST ----------------------------------------------------------------------
main :: IO ()
main = (print . take 10 . show . fib) (10 ^ 5)</
So, for example, the hundred-thousandth Fibonacci number starts with the digits:
Line 4,649 ⟶ 7,455:
=== With recurrence relations ===
Using <code>Fib[m=3n+r]</code> [http://en.wikipedia.org/wiki/Fibonacci_number#Other_identities recurrence identities]:
<
fibstep :: (Integer, Integer) -> (Integer, Integer)
Line 4,683 ⟶ 7,489:
main :: IO ()
main = print $ (length &&& take 20) . show . fst $ fibN2 (10 ^ 2)</
{{Out}}
<pre>(21,"35422484817926191507")</pre>
<code>(fibN2 n)</code> directly calculates a pair <code>(f,g)</code> of two consecutive Fibonacci numbers, <code>(Fib[n], Fib[n+1])</code>, from recursively calculated such pair at about <code>n/3</code>:
<
(208988,"19532821287077577316")</
The above should take less than 0.1s to calculate on a modern box.
Other identities that could also be used are [http://en.wikipedia.org/wiki/Fibonacci_number#Matrix_form here]. In particular, for <i>(n-1,n) ---> (2n-1,2n)</i> transition which is equivalent to the matrix exponentiation scheme, we have
<
and for <i>(n,n+1) ---> (2n,2n+1)</i> (derived from d'Ocagne's identity, for example),
<
=={{header|Haxe}}==
=== Iterative ===
<
{
var current = 0;
Line 4,717 ⟶ 7,523:
}
handler(current);
}</
=== As Iterator ===
<
{
private var current = 0;
Line 4,738 ⟶ 7,544:
return ret;
}
}</
Used like:
<
Sys.println(i);</
=={{header|HicEst}}==
<syntaxhighlight lang="hicest">REAL :: Fibonacci(10)
Fibonacci = ($==2) + Fibonacci($-1) + Fibonacci($-2)
WRITE(ClipBoard) Fibonacci ! 0 1 1 2 3 5 8 13 21 34</syntaxhighlight>
=={{header|Hoon}}==
<syntaxhighlight lang="hoon">|= n=@ud
=/ a=@ud 0
=/ b=@ud 1
|-
?: =(n 0) a
$(a b, b (add a b), n (dec n))</syntaxhighlight>
=={{header|Hope}}==
===Recursive===
<
--- f 0 <= 0;
--- f 1 <= 1;
--- f(n+2) <= f n + f(n+1);</
===Tail-recursive===
<
--- 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:
<
--- fibs <= fs whererec fs == 0::1::map (+) (tail fs||fs);</
The ''n''th Fibonacci number is then just <code plang="hope">fibs @ n</code>.
=={{header|Hy}}==
Recursive implementation.
<
(if (< n 2)
n
(+ (fib (- n 2)) (fib (- n 1)))))</
=={{header|Icon}} and {{header|Unicon}}==
Line 4,780 ⟶ 7,594:
computes fib(1000) if there is no integer argument.
<
write(fib(integer(!args) | 1000)
end
Line 4,793 ⟶ 7,607:
/fCache[n] := fib(n-1) + fib(n-2)
return fCache[n]
end</
{{libheader|Icon Programming Library}}
The above solution is similar to the one provided [http://www.cs.arizona.edu/icon/library/src/procs/memrfncs.icn fib in memrfncs]
Line 4,802 ⟶ 7,616:
This example computes fib(1000000) if there is no integer argument.
<
write(fib(integer(!args) | 1000000))
end
Line 4,818 ⟶ 7,632:
if n%2 = 1 then return [c+d, d]
else return [d, c]
end</
=={{header|IDL}}==
===Recursive===
<
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===
<
psum = (csum = 1uL)
if n lt 3 then return,csum
Line 4,838 ⟶ 7,652:
endfor
return,nsum
end</
Execution time O(n). Limited by size of uLong to fib(49)
===Analytic===
<
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).
Line 4,853 ⟶ 7,667:
===Analytic===
<
fibAnalytic n =
floor $ ((pow goldenRatio n) - (pow (-1.0/goldenRatio) n)) / sqrt(5)
where goldenRatio : Double
goldenRatio = (1.0 + sqrt(5)) / 2.0</
===Recursive===
<
fibRecursive Z = Z
fibRecursive (S Z) = (S Z)
fibRecursive (S (S n)) = fibRecursive (S n) + fibRecursive n </
===Iterative===
<
fibIterative n = fibIterative' n Z (S Z)
where fibIterative' : Nat -> Nat -> Nat -> Nat
fibIterative' Z a _ = a
fibIterative' (S n) a b = fibIterative' n b (a + b) </
===Lazy===
<
fibLazy = 0 :: 1 :: zipWith (+) fibLazy (
case fibLazy of
(x::xs) => xs
[] => []) </
=={{header|J}}==
The [
This implementation is doubly recursive except that results are cached across function calls:
<syntaxhighlight lang="j">fibN=: (-&2 +&$: <:)^:(1&<) M."0</syntaxhighlight>
Iteration:
<syntaxhighlight lang="j">fibN=: [: {."1 +/\@|.@]^:[&0 1</syntaxhighlight>
'''Examples:'''
<
144
fibN i.31
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040</
=={{header|Java}}==
===Iterative===
<
{
if (n < 2)
Line 4,903 ⟶ 7,719:
}
return ans;
}</
<
/**
* O(log(n))
Line 4,934 ⟶ 7,750:
return a + b;
}
</syntaxhighlight>
===Recursive===
<
{
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<sup>2</sup>) to simply O(n). Leveraging Java’s Map.computeIfAbsent makes this thread-safe, and the implementation pretty trivial.
<syntaxhighlight lang="java">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));
}
}</syntaxhighlight>
===Analytic===
This method works up to the 92<sup>nd</sup> Fibonacci number. After that, it goes out of range.
<
{
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===
<
{
return fibInner(0, 1, n);
Line 4,958 ⟶ 7,795:
{
return n < 1 ? a : n == 1 ? b : fibInner(b, a + b, n - 1);
}</
===Streams===
<
import java.util.function.LongUnaryOperator;
import java.util.stream.LongStream;
Line 4,979 ⟶ 7,816:
}
}
</syntaxhighlight>
=={{header|JavaScript}}==
Line 4,985 ⟶ 7,822:
====Recursive====
Basic recursive function:
<
return n<2?n:fib(n-1)+fib(n-2);
}</
Can be rewritten as:
<
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:
<
return function(n,a,b) {
return n>0 ? arguments.callee(n-1,b,a+b) : a;
}(n,0,1);
}</
===Iterative===
<
var a = 0, b = 1, t;
while (n-- > 0) {
Line 5,010 ⟶ 7,847:
}
return a;
}</
====Memoization====
Line 5,016 ⟶ 7,853:
With the keys of a dictionary,
<
return cache = cache || {}, function(n){
if (cache[n]) return cache[n];
Line 5,023 ⟶ 7,860:
};
})();
</syntaxhighlight>
with the indices of an array,
<
'use strict';
Line 5,043 ⟶ 7,880:
return fib(32);
})();</
Line 5,051 ⟶ 7,888:
====Y-Combinator====
<
return (function(fn) {
return fn(fn);
Line 5,067 ⟶ 7,904:
return fn(n - 1) + fn(n - 2);
};
});</
====Generators====
<
var prev = 0;
var curr = 1;
Line 5,079 ⟶ 7,916:
}
}
var fib = fibonacciGenerator();</
===ES6===
Line 5,088 ⟶ 7,925:
we can use an accumulating fold.
<
'use strict';
Line 5,122 ⟶ 7,959:
// --> 2178309
})();</
Otherwise, a simple fold will suffice.
Line 5,128 ⟶ 7,965:
{{Trans|Haskell}} (Memoized fold example)
<
'use strict';
Line 5,149 ⟶ 7,986:
// --> 2178309
})();</
{{Out}}
Line 5,156 ⟶ 7,993:
=={{header|Joy}}==
===Recursive===
<
===Iterative===
<
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
The C implementation of jq does not (yet) have infinite-precision integer arithmetic, and
so using it, the following algorithms only give exact answers up to fib(78). By contrast,
using the Go implementation of jq and the definition of nth_fib given below:
<syntaxhighlight lang="jq">
nth_fib(pow(2;20)) | tostring | [length, .[:10], .[-10:]]
</syntaxhighlight>
yields
<pre>
[219140,"1186800606","0691163707"]
</pre>
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===
<
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.
<
# input: [f(i-2), f(i-1), countdown]
def fib: (.[0] + .[1]) as $sum
Line 5,182 ⟶ 8,033:
| fib end;
[-1, 1, n] | fib;
</syntaxhighlight>
Example:<
(range(0;5), 50) | [., nth_fib(.)]
</syntaxhighlight>
yields: <
[1,1]
[2,1]
[3,2]
[4,3]
[50,12586269025]</
===Binet's Formula===
<
(5|sqrt) as $rt
| ((1 + $rt)/2) as $phi
Line 5,201 ⟶ 8,052:
| (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)".<
def fibonacci(n):
# input: [f(i-2), f(i-1), countdown]
Line 5,211 ⟶ 8,062:
else $sum, ([ .[1], $sum, .[2] - 1 ] | fib)
end;
[-1, 1, n] | fib;</
=={{header|Julia}}==
===Recursive===
<
===Iterative===
<
x,y = (0,1)
for i = 1:n x,y = (y, x+y) end
x
end</
===Matrix form===
<
=={{header|K}}==
{{works with|Kona}}
===Recursive===
<
===Recursive with memoization===
Using a (global) dictionary c.
<
===Analytic===
<
{_((phi^x)-((1-phi)^x))%_sqrt[5]}</
===Sequence to n===
{{works with|Kona}} {{works with|ngn/k}}
<syntaxhighlight lang
<syntaxhighlight lang="k">{x{x,+/-2#x}/!2}</syntaxhighlight>
=={{header|Kabap}}==
===Sequence to n===
<syntaxhighlight lang="kabap">
// Calculate the $n'th Fibonacci number
Line 5,282 ⟶ 8,135:
// Return the sequence
return = "Fibonacci number " << $i << " is " << $a << " (" << $sequence << ")";
</syntaxhighlight>
=={{header|Klingphix}}==
<syntaxhighlight lang="text">:Fibonacci
dup 0 less
( ["Invalid argument"]
[1 1 rot 2 sub [drop over over add] for]
) if
;
30 Fibonacci pstack print nl
msec print nl
"bertlham " input</syntaxhighlight>
=={{header|Kotlin}}==
<
ITERATIVE {
override fun
n.toLong()
} else {
var n1 = 0L
var n2 = 1L
val sum = n1 + n2
n1 = n2
n2 = sum
}
n1
}
},
RECURSIVE {
override fun
}
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..
for (fib in Fibonacci.values()
print("${
println()
}
}</
{{out}}
<pre>ITERATIVE: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040
RECURSIVE: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040
CACHING : 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040
</pre>
=={{header|L++}}==
<
(main (prn (fib 30)))</
=={{header|LabVIEW}}==
{{VI solution|LabVIEW_Fibonacci_sequence.png}}
=={{header|
<
1) basic version
{def fib1
Line 5,423 ⟶ 8,286:
{fib5 1000} -> 4.346655768693743e+208 (CPU ~ 1ms)
</syntaxhighlight>
=={{header|Lang}}==
===Iterative===
<syntaxhighlight lang="lang">
fp.fib = ($n) -> {
if($n < 2) {
return $n
}
$prev = 1
$cur = 1
$i = 2
while($i < $n) {
$tmp = $cur
$cur += $prev
$prev = $tmp
$i += 1
}
return $cur
}
</syntaxhighlight>
===Recursive===
<syntaxhighlight lang="lang">
fp.fib = ($n) -> {
if($n < 2) {
return $n
}
return parser.op(fp.fib($n - 1) + fp.fib($n - 2))
}
</syntaxhighlight>
=={{header|Lang5}}==
<syntaxhighlight lang="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 ;</syntaxhighlight>
=={{header|langur}}==
<syntaxhighlight lang="langur">val .fibonacci = fn(.x) { if(.x < 2: .x ; self(.x - 1) + self(.x - 2)) }
writeln map .fibonacci, series 2..20</syntaxhighlight>
{{out}}
<pre>[1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]</pre>
=={{header|Lasso}}==
<syntaxhighlight lang="lasso">
define fibonacci(n::integer) => {
Line 5,450 ⟶ 8,364:
fibonacci(2) //->output 1
fibonacci(3) //->output 2
</syntaxhighlight>
=={{header|Latitude}}==
===Recursive===
<
takes '[n].
if { n <= 1. } then {
Line 5,462 ⟶ 8,376:
fibo (n - 1) + fibo (n - 2).
}.
}.</
===Memoization===
<
takes '[n].
cache := here cache.
Line 5,480 ⟶ 8,394:
;; Attach the cache to the method object itself.
#'self cache := Object clone.
}.</
=={{header|Lean}}==
It runs on Lean 3.4.2:
<syntaxhighlight lang="lean">
-- Our first implementation is the usual recursive definition:
def fib1 : ℕ → ℕ
| 0 := 0
| 1 := 1
| (n + 2) := fib1 n + fib1 (n + 1)
-- We can give a second more efficient implementation using an auxiliary function:
def fib_aux : ℕ → ℕ → ℕ → ℕ
| 0 a b := b
| (n + 1) a b := fib_aux n (a + b) a
def fib2 : ℕ → ℕ
| n := fib_aux n 1 0
-- Use #eval to check computations:
#eval fib1 20
#eval fib2 20</syntaxhighlight>
It runs on Lean 4:
<syntaxhighlight lang="lean">
-- Naive version
def fib1 (n : Nat) : Nat :=
match n with
| 0 => 0
| 1 => 1
| (k + 2) => fib1 k + fib1 (k + 1)
-- More efficient version
def fib_aux (n : Nat) (a : Nat) (b : Nat) : Nat :=
match n with
| 0 => b
| (k + 1) => fib_aux k (a + b) a
def fib2 (n : Nat) : Nat :=
fib_aux n 1 0
-- Examples
#eval fib1 20
#eval fib2 20
</syntaxhighlight>
=={{header|LFE}}==
Line 5,486 ⟶ 8,451:
===Recursive===
<
(defun fib
((0) 0)
Line 5,493 ⟶ 8,458:
(+ (fib (- n 1))
(fib (- n 2)))))
</syntaxhighlight>
===Iterative===
<
(defun fib
((n) (when (>= n 0))
Line 5,508 ⟶ 8,473:
(fib (- n 1) next (+ result next))))
</syntaxhighlight>
=={{header|Lingo}}==
===Recursive===
<syntaxhighlight lang="lingo">on fib (n)
if n<2 then return n
return fib(n-1)+fib(n-2)
end</
===Iterative===
<syntaxhighlight lang="lingo">on fib (n)
if n<2 then return n
fibPrev = 0
Line 5,650 ⟶ 8,494:
end repeat
return fib
end</
===Analytic===
<syntaxhighlight lang="lingo">on fib (n)
sqrt5 = sqrt(5.0)
p = (1+sqrt5)/2
q = 1 - p
return integer((power(p,n)-power(q,n))/sqrt5)
end</
=={{header|Lisaac}}==
<
+ result : UINTEGER_64;
(n < 2).if {
Line 5,670 ⟶ 8,513:
};
result
);</
=={{header|LiveCode}}==
<
function fibi n
put 0 into aa
Line 5,692 ⟶ 8,535:
return fibr(n-1) + fibr(n-2)
end if
end fibr</
=={{header|LLVM}}==
<syntaxhighlight lang="llvm">; This is not strictly LLVM, as it uses the C library function "printf".
; LLVM does not provide a way to print values, so the alternative would be
; to just load the string into memory, and that would be boring.
; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps
$"PRINT_LONG" = comdat any
@"PRINT_LONG" = linkonce_odr unnamed_addr constant [5 x i8] c"%ld\0A\00", comdat, align 1
;--- The declaration for the external C printf function.
declare i32 @printf(i8*, ...)
;--------------------------------------------------------------------
;-- Function for calculating the nth fibonacci numbers
;--------------------------------------------------------------------
define i32 @fibonacci(i32) {
%2 = alloca i32, align 4 ;-- allocate local copy of n
%3 = alloca i32, align 4 ;-- allocate a
%4 = alloca i32, align 4 ;-- allocate b
store i32 %0, i32* %2, align 4 ;-- store copy of n
store i32 0, i32* %3, align 4 ;-- a := 0
store i32 1, i32* %4, align 4 ;-- b := 1
br label %loop
loop:
%5 = load i32, i32* %2, align 4 ;-- load n
%6 = icmp sgt i32 %5, 0 ;-- n > 0
br i1 %6, label %loop_body, label %exit
loop_body:
%7 = load i32, i32* %3, align 4 ;-- load a
%8 = load i32, i32* %4, align 4 ;-- load b
%9 = add nsw i32 %7, %8 ;-- t = a + b
store i32 %8, i32* %3, align 4 ;-- store a = b
store i32 %9, i32* %4, align 4 ;-- store b = t
%10 = load i32, i32* %2, align 4 ;-- load n
%11 = add nsw i32 %10, -1 ;-- decrement n
store i32 %11, i32* %2, align 4 ;-- store n
br label %loop
exit:
%12 = load i32, i32* %3, align 4 ;-- load a
ret i32 %12 ;-- return a
}
;--------------------------------------------------------------------
;-- Main function for printing successive fibonacci numbers
;--------------------------------------------------------------------
define i32 @main() {
%1 = alloca i32, align 4 ;-- allocate index
store i32 0, i32* %1, align 4 ;-- index := 0
br label %loop
loop:
%2 = load i32, i32* %1, align 4 ;-- load index
%3 = icmp sle i32 %2, 12 ;-- index <= 12
br i1 %3, label %loop_body, label %exit
loop_body:
%4 = load i32, i32* %1, align 4 ;-- load index
%5 = call i32 @fibonacci(i32 %4)
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @"PRINT_LONG", i32 0, i32 0), i32 %5)
%7 = load i32, i32* %1, align 4 ;-- load index
%8 = add nsw i32 %7, 1 ;-- increment index
store i32 %8, i32* %1, align 4 ;-- store index
br label %loop
exit:
ret i32 0 ;-- return EXIT_SUCCESS
}</syntaxhighlight>
{{out}}
<pre>0
1
1
2
3
5
8
13
21
34
55
89
144</pre>
=={{header|Logo}}==
<syntaxhighlight lang="logo">
to fib "loop
make "fib1 0
make "fib2 1
type [You requested\ ]
type :loop
print [\ Fibonacci Numbers]
type :fib1
type [\ ]
type :fib2
type [\ ]
make "loop :loop - 2
repeat :loop [ make "fibnew :fib1 + :fib2 type :fibnew type [\ ] make "fib1 :fib2 make "fib2 :fibnew ]
print [\ ]
end
</syntaxhighlight>
=={{header|LOLCODE}}==
<syntaxhighlight lang="lolcode">
HAI 1.2
HOW DUZ I fibonacci YR N
Line 5,718 ⟶ 8,662:
IF U SAY SO
KTHXBYE
</syntaxhighlight>
=={{header|LSL}}==
Rez a box on the ground, and add the following as a New Script.
<syntaxhighlight lang="lsl">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));
}
}
}</syntaxhighlight>
Output:
<pre>
Fibonacci(0)=0
Fibonacci(1)=1
Fibonacci(2)=1
Fibonacci(3)=2
Fibonacci(4)=3
Fibonacci(5)=5
Fibonacci(6)=8
Fibonacci(7)=13
Fibonacci(8)=21
Fibonacci(9)=34
Fibonacci(10)=55
Fibonacci(11)=89
Fibonacci(12)=144
Fibonacci(13)=233
Fibonacci(14)=377
Fibonacci(15)=610
Fibonacci(16)=987
Fibonacci(17)=1597
Fibonacci(18)=2584
Fibonacci(19)=4181
Fibonacci(20)=6765
Fibonacci(21)=10946
Fibonacci(22)=17711
Fibonacci(23)=28657
Fibonacci(24)=46368
Fibonacci(25)=75025
Fibonacci(26)=121393
Fibonacci(27)=196418
Fibonacci(28)=317811
Fibonacci(29)=514229
Fibonacci(30)=832040
Fibonacci(31)=1346269
Fibonacci(32)=2178309
Fibonacci(33)=3524578
Fibonacci(34)=5702887
</pre>
=={{header|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
</syntaxhighlight>
===Pedantic Recursive===
<
--more pedantic version, returns 0 for non-integer n
function pfibs(n)
Line 5,739 ⟶ 8,739:
end
end
</syntaxhighlight>
===Tail Recursive===
<
function a(n,u,s) if n<2 then return u+s end return a(n-1,u+s,u) end
function trfib(i) return a(i-1,1,0) end
</syntaxhighlight>
===Table Recursive===
<
fib_n = setmetatable({1, 1}, {__index = function(z,n) return n<=0 and 0 or z[n-1] + z[n-2] end})
</syntaxhighlight>
===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}).
Line 5,763 ⟶ 8,763:
end
})
</syntaxhighlight>
===Iterative===
<
function ifibs(n)
local p0,p1=0,1
Line 5,772 ⟶ 8,772:
return p0
end
</syntaxhighlight>
=={{header|Luck}}==
<
let cache = {} in
let fibc x = if x<=1 then x else (
Line 5,783 ⟶ 8,783:
) in fibc(x)
);;
for x in range(10) do print(fib(x))</
=={{header|Lush}}==
<
(if (< n 2)
n
(+ (fib-rec (- n 2)) (fib-rec (- n 1)))))</
=={{header|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.
<syntaxhighlight lang="m2000 interpreter">
Inventory K=0:=0,1:=1
fib=Lambda K (x as decimal)-> {
Line 5,862 ⟶ 8,806:
Print Fib(i)
}
</syntaxhighlight>
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.
<syntaxhighlight lang="m2000 interpreter">
Class BigNum {
Line 5,947 ⟶ 8,891:
</syntaxhighlight>
=={{header|M4}}==
<
`eval(fibo(decr($1)) + fibo(decr(decr($1))))')')')dnl
define(`loop',`ifelse($1,$2,,`$3($1) loop(incr($1),$2,`$3')')')dnl
loop(0,15,`fibo')</
=={{header|MAD}}==
<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER
INTERNAL FUNCTION(N)
ENTRY TO FIB.
A = 0
B = 1
THROUGH LOOP, FOR N=N, -1, N.E.0
C = A + B
A = B
LOOP B = C
FUNCTION RETURN A
END OF FUNCTION
THROUGH SHOW, FOR I=0, 1, I.GE.20
SHOW PRINT FORMAT FNUM, I, FIB.(I)
VECTOR VALUES FNUM = $4HFIB(,I2,4H) = ,I4*$
END OF PROGRAM </syntaxhighlight>
{{out}}
<pre style='height: 50ex;'>FIB( 0) = 0
FIB( 1) = 1
FIB( 2) = 1
FIB( 3) = 2
FIB( 4) = 3
FIB( 5) = 5
FIB( 6) = 8
FIB( 7) = 13
FIB( 8) = 21
FIB( 9) = 34
FIB(10) = 55
FIB(11) = 89
FIB(12) = 144
FIB(13) = 233
FIB(14) = 377
FIB(15) = 610
FIB(16) = 987
FIB(17) = 1597
FIB(18) = 2584
FIB(19) = 4181</pre>
=={{header|Maple}}==
<
> f := n -> ifelse(n<3,1,f(n-1)+f(n-2));
> f(2);
Line 5,962 ⟶ 8,950:
> f(3);
2
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
The Wolfram Language already has a built-in function <tt>Fibonacci</tt>, but a simple recursive implementation would be
<
fib[1] = 1
fib[n_Integer] := fib[n - 1] + fib[n - 2]</
An optimization is to cache the values already calculated:
<
fib[1] = 1
fib[n_Integer] := fib[n] = fib[n - 1] + fib[n - 2]</
The above implementations may be too simplistic, as the first is incredibly slow for any reasonable range due to nested recursions and while the second is faster it uses an increasing amount of memory. The following uses recursion much more effectively while not using memory:
<
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):
<
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:
<
fibList[n_Integer] := Map[Take[#, 1] &, NestList[fibi, {0, 1}, n]] // Flatten</
Output from the last with "fibList[100]":
<
1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, \
196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, \
Line 6,016 ⟶ 9,004:
19740274219868223167, 31940434634990099905, 51680708854858323072, \
83621143489848422977, 135301852344706746049, 218922995834555169026, \
354224848179261915075}</
The Wolfram Language can also solve recurrence equations using the built-in function <tt>RSolve</tt>
<
fib[1] == 1}, fib[n], n][[1]]</
which evaluates to the built-in function <tt>Fibonacci[n]</tt>
Line 6,027 ⟶ 9,015:
This function can also be expressed as
<
which evaluates to
<
and is defined for all real or complex values of n.
Line 6,040 ⟶ 9,028:
{{trans|Julia}}
<
f = [1 1 ; 1 0]^(n-1);
f = f(1,1);
end</
===Iterative===
<
Fn = [1 0]; %Fn(1) is F_{n-2}, Fn(2) is F_{n-1}
Line 6,063 ⟶ 9,051:
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.
<
if n == 1
Line 6,080 ⟶ 9,068:
end
end</
===Tartaglia/Pascal Triangle Method===
<syntaxhighlight lang="matlab">
function number = fibonacci(n)
%construct the Tartaglia/Pascal Triangle
Line 6,096 ⟶ 9,084:
number=trace(rot90(pt));
end
</syntaxhighlight>
=={{header|Maxima}}==
<
fib2(n) := (matrix([0, 1], [1, 1])^^n)[1, 2]$
Line 6,106 ⟶ 9,094:
fib2(-10);
-55</
=={{header|MAXScript}}==
===Iterative===
<
(
if n < 2 then
Line 6,128 ⟶ 9,116:
fib
)
)</
===Recursive===
<
(
if n < 2 then
Line 6,140 ⟶ 9,128:
fibRec (n - 1) + fibRec (n - 2)
)
)</
=={{header|Mercury}}==
Line 6,148 ⟶ 9,136:
===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
Line 6,178 ⟶ 9,166:
write_int(fib(40), !IO),
write_string("\n", !IO).
</syntaxhighlight>
=== Iterative algorithm ===
Line 6,184 ⟶ 9,172:
The much faster iterative algorithm can be written as:
<
:- pred fib_acc(int::in, int::in, int::in, int::in, int::out) is det.
Line 6,200 ⟶ 9,188:
Res = Prev2 + Prev1
).
</syntaxhighlight>
This predicate can be called as <
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.
Line 6,209 ⟶ 9,197:
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.
Line 6,216 ⟶ 9,204:
then X = 1
else fib(N - 1, A), fib(N - 2, B), X = A + B ).
</syntaxhighlight>
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.
Line 6,223 ⟶ 9,211:
=={{header|Metafont}}==
<
if n=0: 0
elseif n=1: 1
Line 6,232 ⟶ 9,220:
for i=0 upto 10: show fibo(i); endfor
end</
=={{header|min}}==
{{works with|min|0.
<
(2 <)
(
unless
)
=={{header|
An efficient solution (for n >= 0):
<syntaxhighlight lang="miniscript">fibonacci = function(n)
if n < 2 then return n
for i in range(n-1,
end for
return ans
end function
And for comparison, a recursive solution (also for n >= 0):
<syntaxhighlight lang="miniscript">rfib = function(n)
if n < 1 then return 0
if n == 1 then return 1
return rfib(n-1) + rfib(n-2)
end function
print rfib(6)</syntaxhighlight>
=={{header|MiniZinc}}==
<syntaxhighlight lang="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"];</syntaxhighlight>
=={{header|MIPS Assembly}}==
This is the iterative approach to the Fibonacci sequence.
<syntaxhighlight lang="mips">
.text
main: li $v0, 5 # read integer from input. The read integer will be stroed in $v0
Line 6,347 ⟶ 9,319:
li $v0, 10
syscall
</syntaxhighlight>
=={{header|Mirah}}==
<syntaxhighlight lang="mirah">def fibonacci(n:int)
return n if n < 2
fibPrev = 1
fib = 1
3.upto(Math.abs(n)) do
oldFib = fib
fib = fib + fibPrev
fibPrev = oldFib
end
fib * (n<0 ? int(Math.pow(n+1, -1)) : 1)
end
puts fibonacci 1
puts fibonacci 2
puts fibonacci 3
puts fibonacci 4
puts fibonacci 5
puts fibonacci 6
puts fibonacci 7
</syntaxhighlight>
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">П0 1 lg Вx <-> + L0 03 С/П БП
03</
Instruction: ''n'' В/О С/П, where ''n'' is serial number of the number of Fibonacci sequence; С/П for the following numbers.
Line 6,357 ⟶ 9,351:
=={{header|ML}}==
==={{header|Standard ML}}===
====Tail Recursion====
This version is tail recursive.
<
let
fun fib' (0,a,b) = a
Line 6,365 ⟶ 9,359:
in
fib' (n,0,1)
end</
====Recursion====
<syntaxhighlight lang="sml">fun fib n = if n < 2 then n else fib (n - 1) + fib (n - 2)</syntaxhighlight>
==={{header|MLite}}===
====Recursion====
Tail recursive.
<
(0, x1, x2) = x2
| (n, x1, x2) = fib (n-1, x2, x1+x2)
| n = fib (n, 0, 1)</
=={{header|ML/I}}==
<
"" Fibonacci - recursive
MCSKIP MT,<>
Line 6,389 ⟶ 9,387:
fib(3) is FIB(3)
fib(4) is FIB(4)
fib(5) is FIB(5)</
=={{header|Modula-2}}==
<
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
Line 6,428 ⟶ 9,426:
ReadChar
END Fibonacci.</
=={{header|Modula-3}}==
===Recursive===
<
BEGIN
IF n < 2 THEN
Line 6,439 ⟶ 9,437:
RETURN Fib(n-1) + Fib(n-2);
END;
END Fib;</
=== Iterative (with negatives) ===
<
VAR
Line 6,478 ⟶ 9,476:
RETURN curr;
END IterFib;</
=={{header|Monicelli}}==
Recursive version. It includes a main that reads a number N from standard input and prints the Nth Fibonacci number.
<
# Main
Lei ha clacsonato
Line 6,495 ⟶ 9,493:
Necchi come se fosse brematurata la supercazzola bonaccia con antani meno 2 o scherziamo? vaffanzum
unchiamo più duechiamo! e velocità di esecuzione
</syntaxhighlight>
=={{header|MontiLang}}==
Reads number from standard input and prints to that number in the fibonacci sequence
<
1 VAR b .
INPUT TOINT
Line 6,507 ⟶ 9,505:
b VAR a .
c VAR b .
ENDFOR</
Forth-style solution
<syntaxhighlight lang="montilang">def over
swap dup rot swap
enddef
|Enter a number to obtain Fibonacci sequence: | input nip var count .
0 1
FOR count
over out |, | out . + swap
ENDFOR
. print
input
clear</syntaxhighlight>
Simpler
<syntaxhighlight lang="montilang">|Enter a number to obtain Fibonacci sequence: | input nip 1 - var count .
0 1
FOR count
out |, | out . dup rot +
ENDFOR
print
input /# wait until press ENTER #/
clear /# empties the stack #/</syntaxhighlight>
=={{header|MUMPS}}==
===Iterative===
<
;Iterative version to get the Nth Fibonacci number
;N must be a positive integer
Line 6,521 ⟶ 9,545:
QUIT:N<2 F(N)
FOR I=2:1:N SET F(I)=F(I-1)+F(I-2)
QUIT F(N)</
<pre>
Line 6,527 ⟶ 9,551:
832040
</pre>
=={{header|Nanoquery}}==
===Iterative===
<syntaxhighlight lang="nanoquery">def fibIter(n)
if (n < 2)
return n
end if
$fib = 1
$fibPrev = 1
for num in range(2, n - 1)
fib += fibPrev
fibPrev = fib - fibPrev
end for
return fib
end</syntaxhighlight>
=={{header|Nemerle}}==
===Recursive===
<
using System.Console;
Line 6,547 ⟶ 9,589:
WriteLine("{0}: {1}", n, Fibonacci(n));
}
}</
===Tail Recursive===
<
{
match(x)
Line 6,561 ⟶ 9,603:
{
Fibonacci(x, 0, 1)
}</
=={{header|NESL}}==
===Recursive===
<
=={{header|NetRexx}}==
{{trans|REXX}}
<
options replace format comments java crossref savelog symbols
Line 6,606 ⟶ 9,648:
if n > 0 | na // 2 == 1 then return s /*if positive or odd negative... */
else return -s /*return a negative Fib number. */
</syntaxhighlight>
=={{header|NewLISP}}==
===Iterative===
<
(let (L '(0 1))
(dotimes (i n)
(setq L (list (L 1) (apply + L))))
(L 1)) )
</syntaxhighlight>
===Recursive===
<
(if (< n 2) 1
(+ (fibonacci (- n 1))
(fibonacci (- n 2)))))
</syntaxhighlight>
===Matrix multiplication===
<
(letn (f '((0 1) (1 1)) fib f)
(dotimes (i n)
Line 6,631 ⟶ 9,673:
(fib 0 1)) )
(print(fibonacci 10)) ;;89</
===With a stack ===
<syntaxhighlight lang="newlisp">
;;; 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)
</syntaxhighlight>
=={{header|NGS}}==
===Iterative===
{{trans|Python}}
<
n < 2 returns n
local a = 1, b = 1
Line 6,646 ⟶ 9,707:
}
b
}</
=={{header|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.
<syntaxhighlight lang="nial">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};</syntaxhighlight>
Iterative using fold. Slightly faster, <1.6s:
<syntaxhighlight lang="nial">fibf is op n {1 pick ((n- 1) fold [1 pick, +] 0 1)};</syntaxhighlight>
Tacit verion of above. Slightly faster still, <1.4s:
<syntaxhighlight lang="nial">fibf2 is 1 pick fold [1 pick, +] reverse (0 1 hitch) (-1+);</syntaxhighlight>
===Recursive===
Really slow (over 8s for single iteration, n=33).
(Similar to time for recursive python version with n=37.)
<syntaxhighlight lang="nial">fibr is op n {fork [2>, +, + [fibr (-1 +), fibr (-2 +)]] n};</syntaxhighlight>
...or tacit version. More than twice as fast (?) but still slow:
<syntaxhighlight lang="nial">fibr2 is fork [2>, +, + [fibr2 (-1 +), fibr2 (-2 +)]];</syntaxhighlight>
===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.
<syntaxhighlight lang="nial">fibm is op n {floor (0 1 pick (reduce ip (n reshape [2 2 reshape 1 1 1 0])))};</syntaxhighlight>
Could it look a little more like J?
(Maybe 5% slower than above.)
<syntaxhighlight lang="nial">$ 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](~$)));</syntaxhighlight>
Alternate, not involving replicating matrix n times, but maybe 50% slower
than the fastest matrix version above - similar speed to iterative:
<syntaxhighlight lang="nial">fibm3 is op n {a:=2 2$1 1 1 0; _(0 1 pick ((n- 1) fold (a ip) a))};</syntaxhighlight>
=={{header|Nim}}==
===Analytic===
<
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===
<
var
first = 0
Line 6,668 ⟶ 9,786:
second += first
result = first</
===Recursive===
<
if n <= 2:
result = 1
else:
result = Fibonacci(n - 1) + Fibonacci(n - 2)</
===Tail-recursive===
<
if n == 0:
result = current
Line 6,684 ⟶ 9,802:
result = Fibonacci(n - 1, next, current + next)
proc Fibonacci(n: int): int64 =
result = Fibonacci(n, 0, 1)</
===Continuations===
<
var a = 0
var b = 1
Line 6,697 ⟶ 9,815:
var f = fib
for i in 0.. <10:
echo f()</
=={{header|Nix}}==
<syntaxhighlight lang="nix">fibonacci = n:
if n <= 1 then n else (fibonacci (n - 1) + fibonacci (n - 2));</syntaxhighlight>
=={{header|Oberon-2}}==
{{Works with|oo2c Version 2}}
<
MODULE Fibonacci;
IMPORT
Line 6,762 ⟶ 9,883:
GenR(20);
END Fibonacci.
</syntaxhighlight>
{{out}}
<pre>
Line 6,777 ⟶ 9,898:
=={{header|Objeck}}==
===Recursive===
<
class Fib {
function : Main(args : String[]), Nil {
Line 6,793 ⟶ 9,914:
}
}
}</
=={{header|Objective-C}}==
===Recursive===
<
{
long result = 0;
Line 6,806 ⟶ 9,927:
}
return result;
}</
===Iterative===
<
long beforeLast = 0, last = 1;
while (index > 0) {
Line 6,816 ⟶ 9,937:
}
return last;
}</
=={{header|OCaml}}==
===Tail-Recursive (fast)===
<syntaxhighlight lang="ocaml">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</syntaxhighlight>
===Iterative===
<
if n < 2 then
n
Line 6,830 ⟶ 9,958:
fib_prev := temp
done;
!fib</
===Recursive===
<syntaxhighlight lang="ocaml">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
Line 6,843 ⟶ 9,972:
| n -> if n > 0 then fib (n-1) + fib (n-2)
else fib (n+2) - fib (n+1)
</syntaxhighlight>
===Arbitrary Precision===
Using OCaml's [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Num.html Num] module.
<
let fib =
Line 6,866 ⟶ 9,996:
let n = int_of_string Sys.argv.(1) in
print_endline (string_of_num (fib n))
</syntaxhighlight>
compile with:
Line 6,884 ⟶ 10,014:
=== O(log(n)) with arbitrary precision ===
This performs log2(N) matrix multiplys. Each multiplication is not constant-time but increases sub-linearly, about O(log(N)).
<
let mul (a,b,c) (d,e,f) = let bxe = b*/e in
Line 6,899 ⟶ 10,029:
string_of_num y
;;
Printf.printf "fib %d = %s\n" 300 (fib 300)</
Output:<pre>fib 300 = 222232244629420445529739893461909967206666939096499764990979600</pre>
=== Matrix Exponentiation ===
<syntaxhighlight lang="ocaml">
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
;;
</syntaxhighlight>
=={{header|Octave}}==
<
function fibo = recfibo(n)
if ( n < 2 )
Line 6,911 ⟶ 10,072:
fibo = recfibo(n-1) + recfibo(n-2);
endif
endfunction</
'''
<
for i = 0 : 20
printf("%d %d\n", i, recfibo(i));
endfor</syntaxhighlight>
===Iterative===
<syntaxhighlight lang="octave">% iterative
function fibo = iterfibo(n)
if ( n < 2 )
Line 6,929 ⟶ 10,096:
fibo = f(2);
endif
endfunction</
'''Testing'''
<
for i = 0 : 20
printf("%d %d\n",
endfor</
===Analytic===
<syntaxhighlight lang="octave">function retval = fibanalytic(n)
retval = round(((5 .^ 0.5 + 1) / 2) .^ n / 5 .^ 0.5);
endfunction</syntaxhighlight>
===Tail Recursive===
<syntaxhighlight lang="octave">function retval = fibtailrecursive(n, prevfib = 0, fib = 1)
if (n == 0)
retval = prevfib;
else
retval = fibtailrecursive(n - 1, fib, prevfib + fib);
endif
endfunction</syntaxhighlight>
=={{header|Odin}}==
Fibinacci Sequence - Iterative Solution<br>
Odin Build: dev-2023-07-nightly:3072479c
<syntaxhighlight lang="odin">
package fib
import "core:fmt"
main :: proc() {
fmt.println("\nFibonacci Seq - starting n and n+1 from 0 and 1:")
fmt.println("------------------------------------------------")
for j: u128 = 0; j <= 20; j += 1 {
fmt.println("n:", j, "\tFib:", fibi(j))
}
}
fibi :: proc(n: u128) -> u128 {
if n < 2 {
return n
}
a, b: u128 = 0, 1
for _ in 2..=n {
a += b
a, b = b, a
}
return b
}
</syntaxhighlight>
{{out}}
<pre>
First 20 Fibonacci Numbers
Starting n and n+1 from 0 and 1
-------------------------------
n: 0 Fib: 0
n: 1 Fib: 1
n: 2 Fib: 1
n: 3 Fib: 2
n: 4 Fib: 3
n: 5 Fib: 5
n: 6 Fib: 8
n: 7 Fib: 13
n: 8 Fib: 21
n: 9 Fib: 34
n: 10 Fib: 55
n: 11 Fib: 89
n: 12 Fib: 144
n: 13 Fib: 233
n: 14 Fib: 377
n: 15 Fib: 610
n: 16 Fib: 987
n: 17 Fib: 1597
n: 18 Fib: 2584
n: 19 Fib: 4181
n: 20 Fib: 6765
-------------------------------
</pre>
=={{header|Oforth}}==
<
=={{header|Ol}}==
Same as [https://rosettacode.org/wiki/Fibonacci_sequence#Scheme Scheme] example(s).
=={{header|Onyx (wasm)}}==
<syntaxhighlight lang="C">
use core.iter
use core { printf }
// Procedural Simple For-Loop Style
fib_for_loop :: (n: i32) -> i32 {
a: i32 = 0;
b: i32 = 1;
for 0 .. n {
tmp := a;
a = b;
b = tmp + b;
}
return a;
}
FibState :: struct { a, b: u64 }
// Functional Folding Style
fib_by_fold :: (n: i32) => {
end_state :=
iter.counter()
|> iter.take(n)
|> iter.fold(
FibState.{ a = 0, b = 1 },
(_, state) => FibState.{
a = state.b,
b = state.a + state.b
}
);
return end_state.a;
}
// Custom Iterator Style
fib_iterator :: (n: i32) =>
iter.generator(
&.{ a = cast(u64) 0, b = cast(u64) 1, counter = n },
(state: & $Ctx) -> (u64, bool) {
if state.counter <= 0 {
return 0, false;
}
tmp := state.a;
state.a = state.b;
state.b = state.b + tmp;
state.counter -= 1;
return tmp, true;
}
);
main :: () {
printf("\nBy For Loop:\n");
for i in 0 .. 21 {
printf("{} ", fib_for_loop(i));
}
printf("\n\nBy Iterator:\n");
for i in 0 .. 21 {
printf("{} ", fib_by_fold(i));
}
printf("\n\nBy Fold:\n");
for value, index in fib_iterator(21) {
printf("{} ", value);
}
}
</syntaxhighlight>
{{out}}
<pre>
For-Loop:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
Functional Fold:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
Custom Iterator:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
</pre>
=={{header|OPL}}==
<
REM Fibonacci sequence is generated to the Organiser II floating point variable limit.
REM CLEAR/ON key quits.
Line 6,953 ⟶ 10,272:
B=C
PRINT A,
UNTIL GET=1</
=={{header|Order}}==
===Recursive===
<
#define ORDER_PP_DEF_8fib_rec \
Line 6,966 ⟶ 10,285:
8fib_rec(8sub(8N, 2))))))
ORDER_PP(8fib_rec(10))</
Tail recursive version (example supplied with language):
<
#define ORDER_PP_DEF_8fib \
Line 6,981 ⟶ 10,300:
8fib_iter(8dec(8N), 8J, 8add(8I, 8J)))))
ORDER_PP(8to_lit(8fib(8nat(5,0,0))))</
===Memoization===
<
#define ORDER_PP_DEF_8fib_memo \
Line 7,008 ⟶ 10,327:
8print(8to_lit(8fib_memo(8N)) (,) 8space)),
1, 21)
)</
=={{header|Oz}}==
Line 7,014 ⟶ 10,333:
===Iterative===
Using mutable references (cells).
<
Temp = {NewCell 0}
A = {NewCell 0}
Line 7,025 ⟶ 10,344:
end
@A
end</
===Recursive===
Inefficient (blows up the stack).
<
if N < 2 then N
else {FibR N-1} + {FibR N-2}
end
end</
===Tail-recursive===
Using accumulators.
<
fun{Loop N A B}
if N == 0 then
Line 7,047 ⟶ 10,366:
in
{Loop N 1 0}
end</
===Lazy-recursive===
<
fun lazy {FiboSeq}
{LazyMap
Line 7,069 ⟶ 10,388:
end
in
{Show {List.take {FiboSeq} 8}}</
=={{header|PARI/GP}}==
===Built-in===
<syntaxhighlight lang
===Matrix===
<
===Analytic===
This uses the Binet form.
<
The second term can be dropped since the error is always small enough to be subsumed by the rounding.
<
===Algebraic===
Line 7,089 ⟶ 10,408:
and hence <code>real(quadgen(5)^n)</code> would give the (n-1)-th Fibonacci number.
<
A more direct translation (note that <math>\sqrt5=2\phi-1</math>) would be
<
===Combinatorial===
This uses the generating function. It can be trivially adapted to give the first n Fibonacci numbers.
<
===Binary powering===
<
if(n<=0,
if(n,(-1)^(n+1)*fib(n),0)
Line 7,116 ⟶ 10,435:
if(n,[v[1]^2+2,v[1]*v[2]+1],[v[1]^2-2,v[1]*v[2]-1])
)
};</
===Recursive===
<
if(n<2,
n
Line 7,125 ⟶ 10,444:
fib(n-1)+fib(n)
)
};</
===Anonymous recursion===
{{works with|PARI/GP|2.8.0+}}
This uses <code>self()</code> which gives a self-reference.
<
if(n<2,
n
Line 7,137 ⟶ 10,456:
s(n-2)+s(n-1)
)
};</
It can be used without being named:
<
gives
{{out}}
Line 7,146 ⟶ 10,465:
===Memoization===
<
fib(n)={
if(n>#F,
Line 7,158 ⟶ 10,477:
)
);
}</
===Iterative===
<
if(n<0,return((-1)^(n+1)*fib(n)));
my(a=0,b=1,t);
Line 7,171 ⟶ 10,490:
);
a
};</
===Chebyshev===
This solution uses Chebyshev polynomials of the second kind (Chyebyshev U-polynomials).
<
or
<
===Anti-Hadamard matrix===
Line 7,183 ⟶ 10,502:
R. L. Graham and N. J. A. Sloane, [http://www.math.ucsd.edu/~ronspubs/84_03_anti_hadamard.pdf Anti-Hadamard matrices], Linear Algebra Appl. 62 (1984), 113–137.</ref> 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.
<
matrix(n,n,i,j,
my(t=j-i+1);
Line 7,189 ⟶ 10,508:
);
}
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:
<
{
my(g=2^(n+1)-1);
Line 7,200 ⟶ 10,519:
bitor(i,i<<1)==g
);
}</
===One-by-one===
This code is purely for amusement and requires n > 1. It tests numbers in order to see if they are Fibonacci numbers, and waits until it has seen ''n'' of them.
<
=={{header|ParaCL}}==
<syntaxhighlight lang="parasl">
fibbonachi = func(x) : fibb
{
res = 1;
if (x > 1)
res = fibb(x - 1) + fibb(x - 2);
res;
}
</syntaxhighlight>
=={{header|Pascal}}==
===Analytic===
<
const
Sqrt5 = sqrt(5.0);
Line 7,224 ⟶ 10,554:
else
Fibdirekt := 0
end;</
===Recursive===
<
begin
if (n = 0) or (n = 1)
Line 7,234 ⟶ 10,564:
else
fib := fib(n-1) + fib(n-2)
end;</
===Iterative===
<
var
f0, f1, tmpf0, k: integer;
Line 7,258 ⟶ 10,588:
f1 := 0;
fib := f1;
end;</
===Analytic2===
<
begin
result:= (pow((1+SQRT5)/2,n)-pow((1-SQRT5)/2,n))/SQRT5
end;</
<
var tbig1, tbig2, tbig3: TInteger;
begin
Line 7,284 ⟶ 10,614:
tbig2.free;
tbig1.free;
end;</
writeln(floattoStr(FiboMax(555)))
Line 7,292 ⟶ 10,622:
>>>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].
<syntaxhighlight lang="pascal">
program Fibonacci_console;
{$mode objfpc}{$H+}
uses SysUtils;
function Fibonacci( n : word) : uint64;
{
Starts with the pair F[0],F[1]. At each iteration, uses the doubling formulae
to pass from F[k],F[k+1] to F[2k],F[2k+1]. If the current bit of n (starting
from the high end) is 1, there is a further step to F[2k+1],F[2k+2].
}
var
marker, half_n : word;
f, g : uint64; // pair of consecutive Fibonacci numbers
t, u : uint64; // -----"-----
begin
// The values of F[0], F[1], F[2] are assumed to be known
case n of
0 : result := 0;
1, 2 : result := 1;
else begin
half_n := n shr 1;
marker := 1;
while marker <= half_n do marker := marker shl 1;
// First time: current bit is 1 by construction,
// so go straight from F[0],F[1] to F[1],F[2].
f := 1; // = F[1]
g := 1; // = F[2]
marker := marker shr 1;
while marker > 1 do begin
t := f*(2*g - f);
u := f*f + g*g;
if (n and marker = 0) then begin
f := t;
g := u;
end
else begin
f := u;
g := t + u;
end;
marker := marker shr 1;
end;
// Last time: we need only one of the pair.
if (n and marker = 0) then
result := f*(2*g - f)
else
result := f*f + g*g;
end; // end else (i.e. n > 2)
end; // end case
end;
// Main program
var
n : word;
begin
for n := 0 to 93 do
WriteLn( SysUtils.Format( 'F[%2u] = %20u', [n, Fibonacci(n)]));
end.
</syntaxhighlight>
{{out}}
<pre>
F[ 0] = 0
F[ 1] = 1
F[ 2] = 1
F[ 3] = 2
F[ 4] = 3
F[ 5] = 5
F[ 6] = 8
F[ 7] = 13
[...]
F[90] = 2880067194370816120
F[91] = 4660046610375530309
F[92] = 7540113804746346429
F[93] = 12200160415121876738
</pre>
=={{header|PascalABC.NET}}==
Uses functionality from [[Fibonacci n-step number sequences#PascalABC.NET]]
<syntaxhighlight lang="pascal">
// Fibonacci sequence. Nigel Galloway: August 30th., 2022
begin
unfold(nFib,0bi,1bi).ElementAt(1000).Println;
end.
</syntaxhighlight>
<pre>
43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875
</pre>
=={{header|Perl}}==
===Iterative===
<
my $n = shift;
use bigint try => "GMP,Pari";
Line 7,300 ⟶ 10,724:
($v2,$v1) = ($v1,$v2+$v1) for 0..$n;
$v1;
}</
===Recursive===
<
my $n = shift;
$n < 2 ? $n : fibRec($n - 1) + fibRec($n - 2);
}</
===Modules===
Quite a few modules have ways to do this. Performance is not typically an issue with any of these until 100k or so. With GMP available, the first three are ''much'' faster at large values.
<
use Math::AnyNum qw/fibonacci/;
say fibonacci(10000);
Line 7,333 ⟶ 10,757:
# Perl, gives floating point *approximation*
use Math::Fibonacci qw/term/;
say term(10000);</
===Array accumulation===
<p>This solution accumulates all Fibonacci numbers up to <i>n</i> into an array of <i>n</i>+1 elements (to account for the zeroth Fibonacci number). When the loop reaches <i>n</i>, the function returns the last element of the array, i.e. the <i>n</i>-th Fibonacci number. This function only works for positive integers, but it can be easily extended into negatives.</p>
<p>Note that, without the use of big integer libraries, pure Perl switches to floats in scientific notation above <i>n</i>=93 and treats any number as infinite above <i>n</i>=1476 (see output). This behaviour could vary across Perl implementations.</p>
<syntaxhighlight lang = "Perl>
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);
</syntaxhighlight>
{{out}}
<pre>
Fibonacci(0) -> 0
Fibonacci(1) -> 1
Fibonacci(2) -> 1
Fibonacci(3) -> 2
Fibonacci(4) -> 3
Fibonacci(5) -> 5
Fibonacci(6) -> 8
Fibonacci(7) -> 13
Fibonacci(8) -> 21
Fibonacci(9) -> 34
Fibonacci(10) -> 55
Fibonacci(11) -> 89
Fibonacci(12) -> 144
Fibonacci(13) -> 233
Fibonacci(14) -> 377
Fibonacci(15) -> 610
Fibonacci(16) -> 987
Fibonacci(17) -> 1597
Fibonacci(18) -> 2584
Fibonacci(19) -> 4181
Fibonacci(20) -> 6765
Fibonacci(50) -> 12586269025
Fibonacci(93) -> 12200160415121876738
Fibonacci(94) -> 1.97402742198682e+19
Fibonacci(100) -> 3.54224848179262e+20
Fibonacci(200) -> 2.8057117299251e+41
Fibonacci(1000) -> 4.34665576869374e+208
Fibonacci(1476) -> 1.3069892237634e+308
Fibonacci(1477) -> Inf
</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<
<span style="color: #004080;">atom</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #000000;">0</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)>=</span><span style="color: #000000;">79</span> <span style="color: #008080;">then</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">9</span><span style="color: #0000FF;">/</span><span style="color: #000000;">0</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span> <span style="color: #000080;font-style:italic;">-- inaccuracies creep in above 78</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">+</span><span style="color: #000000;">b</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">b</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">b</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">28</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">i</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">", "</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">fibonacci</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
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
</pre>
Using native integers/atoms, errors creep in above 78, so the same program converted to use
{{libheader|Phix/mpfr}}
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">-- demo\rosetta\fibonacci.exw</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">mpz</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">NULL</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">prev</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">next</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">lastn</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">fibonampz</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- resumable, works for -ve numbers, yields mpz</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">absn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">=</span><span style="color: #004600;">NULL</span> <span style="color: #008080;">or</span> <span style="color: #000000;">absn</span><span style="color: #0000FF;">!=</span><span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lastn</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">=</span><span style="color: #004600;">NULL</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">prev</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">next</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">else</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">==</span><span style="color: #000000;">lastn</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #000000;">res</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #7060A8;">mpz_fib2_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">prev</span><span style="color: #0000FF;">,</span><span style="color: #000000;">absn</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">else</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">lastn</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lastn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #7060A8;">mpz_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">next</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">prev</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">prev</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">next</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">next</span><span style="color: #0000FF;">,</span><span style="color: #000000;">prev</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">lastn</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">28</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">i</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">", "</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fibonampz</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">))})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fibonampz</span><span style="color: #0000FF;">(</span><span style="color: #000000;">705</span><span style="color: #0000FF;">))})</span>
<span style="color: #000080;font-style:italic;">-- not surprisingly JavaScript BigInt takes a bit
-- longer for 0.1M digits that gmp does for 1.0M:</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">big</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()==</span><span style="color: #004600;">JS</span><span style="color: #0000FF;">?</span><span style="color: #000000;">478495</span><span style="color: #0000FF;">:</span><span style="color: #000000;">4784969</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fibonampz</span><span style="color: #0000FF;">(</span><span style="color: #000000;">big</span><span style="color: #0000FF;">))</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811
970066202977562212558683426760773016559904631977220423547980211057068777324159443678590358026859129109599109446646966713225742014317926940054191330
{1000000,"107273956418004772293648135962250043219...407167474856539211500699706378405156269"}
"2.1s"
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">def Fibonacci
dup 0 < if
"Invalid argument: " print
else
1 1 rot 2 -
for
drop
over over +
endfor
endif
enddef
10 Fibonacci pstack print nl
-10 Fibonacci print</syntaxhighlight>
=={{header|PHP}}==
===Iterative===
<
if ($n < 2) {
return $n;
Line 7,433 ⟶ 10,921:
}
return $fib;
}</
===Recursive===
<
return $n < 2 ? $n : fibRec($n-1) + fibRec($n-2);
}</
=={{header|Picat}}==
===Function===
tabling for speed.
<syntaxhighlight lang="picat">go =>
println([fib_fun(I) : I in 1..10]),
F1=fib_fun(2**10),
println(f1=F1),
nl.
table
fib_fun(0) = 0.
fib_fun(1) = 1.
fib_fun(N) = fib_fun(N-1) + fib_fun(N-2).</syntaxhighlight>
{{out}}
<pre>[1,1,2,3,5,8,13,21,34,55]
f1 = 4506699633677819813104383235728886049367860596218604830803023149600030645708721396248792609141030396244873266580345011219530209367425581019871067646094200262285202346655868899711089246778413354004103631553925405243</pre>
===Array===
<syntaxhighlight lang="picat">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.</syntaxhighlight>
===Loop===
<syntaxhighlight lang="picat">fib_loop(N) = Curr =>
Curr = 0,
Prev = 1,
foreach(_I in 1..N)
Tmp = Curr,
Curr := Curr + Prev,
Prev := Tmp
end.</syntaxhighlight>
===Formula===
{{trans|Tcl}}
Works for n <= 70.
<syntaxhighlight lang="picat">fib_formula(N) = round((0.5 + 0.5*sqrt(5))**N / sqrt(5)).</syntaxhighlight>
==="Lazy lists"===
{{trans|Prolog}}
<syntaxhighlight lang="picat">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)) ).</syntaxhighlight>
{{out}}
<pre>[0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]</pre>
===Generators idiom===
{{trans|Prolog}}
<syntaxhighlight lang="picat">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.</syntaxhighlight>
{{out}}
<pre>[0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]</pre>
===Reversible===
This is a reversible variant using constraint modelling.
<code>fib_rev(N,F)</code> 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.
<syntaxhighlight lang="picat">import cp.
go =>
N1 = 30,
fib_rev(30,F1),
println([n1=N1,fib1=F1]),
F2 #= 20365011074,
fib_rev(N2,F2),
println([n2=N2,f2=F2]),
F3 = 61305790721611591,
fib_rev(N3,F3),
println([n3=N3,F3]),
nl.
table
fib_rev(0,1).
fib_rev(1,1).
fib_rev(N,F) :-
N #> 0,
F #> 0,
N1 #= N-1,
N2 #= N-2,
fib_rev(N1,F1),
fib_rev(N2,F2),
F #= F1+F2.</syntaxhighlight>
{{out}}
<pre>[n1 = 30,fib1 = 1346269]
[n2 = 50,f2 = 20365011074]
[n3 = 81,61305790721611591]</pre>
=={{header|PicoLisp}}==
===Recursive===
<
(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:
<
(cache '(NIL) N # Use a cache to accelerate
(if (>= 2 N)
Line 7,454 ⟶ 11,065:
(+ (fibo (dec N)) (fibo (- N 2))) ) ) )
(bench (fibo 1000))</
Output:
<
-> 43466557686937456435688527675040625802564660517371780402481729089536555417949
05189040387984007925516929592259308032263477520968962323987332247116164299644090
6533187938298969649928516003704476137795166849228875</
===Iterative===
<
(let (A 0 B 1)
(do N
(prog1 B (setq B (+ A B) A @)) ) ) )</
===Coroutines===
<
(let (A 0 B 1)
(yield 'ready)
Line 7,478 ⟶ 11,089:
(printsp (yield 'next 'fibo)) )
(prinl)
(yield NIL 'fibo)</
{{out}}
<pre>1 1 2 3 5 8 13 21 34 55 89 144 233 377 610</pre>
=={{header|Pike}}==
===Iterative===
<syntaxhighlight lang="pike">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;
}</syntaxhighlight>
===Recursive===
<syntaxhighlight lang="pike">int
fibRec(int n) {
if (n < 2) {
return(1);
}
return( fib(n-2) + fib(n-1) );
}</syntaxhighlight>
=={{header|PIR}}==
Recursive:
{{works with|Parrot|tested with 2.4.0}}
<
.param int n
.local int nt
Line 7,514 ⟶ 11,153:
DONE:
end
.end</
Iterative (stack-based):
{{works with|Parrot|tested with 2.4.0}}
<
.param int n
.local int counter
Line 7,567 ⟶ 11,206:
DONE:
end
.end</
=={{header|
The program waits for ''n''. Then it displays ''n''<sup>th</sup> Fibonacci number.
<syntaxhighlight lang="pascal">
var n, a, b, i, tmp;
begin
? n;
a := 0; b := 1;
i := 2;
while i <= n do
begin
tmp := b; b := a + b; a := tmp;
i := i + 1
end;
! b
end.
</syntaxhighlight>
4 runs.
{{in}}
<pre>5</pre>
{{out}}
<pre> 5</pre>
{{in}}
<pre>9</pre>
{{out}}
<pre> 34</pre>
{{in}}
<pre>13</pre>
{{out}}
<pre> 233</pre>
{{in}}
<pre>20</pre>
{{out}}
<pre> 6765</pre>
==
<syntaxhighlight lang="pli">/* 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;
f2 =
end Fib;
</syntaxhighlight>
=={{header|PL/M}}==
<syntaxhighlight lang="plm">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</syntaxhighlight>
{{out}}
<pre>0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765</pre>
=={{header|PL/pgSQL}}==
=== Recursive ===
<syntaxhighlight lang="sql">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;</syntaxhighlight>
=== Calculated ===
<syntaxhighlight lang="sql">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;</syntaxhighlight>
=== Linear ===
<syntaxhighlight lang="sql">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;</syntaxhighlight>
=== Tail recursive ===
<syntaxhighlight lang="sql">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;</syntaxhighlight>
=={{header|PL/SQL}}==
<syntaxhighlight lang="plsql">
create or replace function fnu_fibonacci(p_num integer) return integer is
f integer;
begin
case when p_num < 0 or p_num != trunc(p_num)
then raise_application_error(-20001, 'Invalid input: ' || p_num, true);
for i in 2 .. p_num loop
end case;
return(f);
end fnu_fibonacci;
/
</syntaxhighlight>
=={{header|Plain English}}==
<syntaxhighlight lang="plainenglish">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.</syntaxhighlight>
=={{header|Pop11}}==
<
lvars a , b;
1 -> a;
Line 7,643 ⟶ 11,391:
endrepeat;
a;
enddefine;</
=={{header|PostScript}}==
Enter the desired number for "n" and run through your favorite postscript previewer or send to your postscript printer:
<
% We want the 'n'th fibonacci number
Line 7,667 ⟶ 11,415:
(Fib\() show n (....) cvs show (\)=) show n fib (.....) cvs show
showpage</
=={{header|Potion}}==
Line 7,673 ⟶ 11,421:
===Recursive===
Starts with int and upgrades on-the-fly to doubles.
<
if (n <= 1): 1. else: recursive (n - 1) + recursive (n - 2)..
n = 40
("fib(", n, ")= ", recursive (n), "\n") join print</
<pre>
Line 7,685 ⟶ 11,433:
===Iterative===
<
curr = 0
prev = 1
Line 7,695 ⟶ 11,443:
.
curr
.</
===Matrix based===
<
# Based on the fact that
Line 7,717 ⟶ 11,465:
.
algorithm(n)(0)
.</
===Handling negative values===
<syntaxhighlight lang="text">fibonacci = (n) :
myFavorite = matrix
if (n >= 0) :
Line 7,732 ⟶ 11,480:
.
.
.</
=={{header|PowerShell}}==
===Iterative===
<
function FibonacciNumber ( $count )
{
Line 7,806 ⟶ 11,494:
return $answer
}
</syntaxhighlight>
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
</syntaxhighlight>
===Recursive===
<
switch ($n) {
0 { return 0 }
Line 7,825 ⟶ 11,513:
default { return (fib ($n - 1)) + (fib ($n - 2)) }
}
}</
=={{header|Processing}}==
{{trans|Java}}
<
size(400, 400);
fill(255, 64);
Line 7,842 ⟶ 11,530:
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.
Line 7,866 ⟶ 11,554:
{{works with|GNU Prolog}}
{{works with|YAP}}
<
fib(1, 1) :- !.
fib(0, 0) :- !.
Line 7,873 ⟶ 11,561:
B is N - 2, fib(B, B1),
Value is A1 + B1.
</syntaxhighlight>
This naive implementation works, but is very slow for larger values of N. Here are some simple measurements (in SWI-Prolog):
<
% 2 inferences, 0.000 CPU in 0.000 seconds (88% CPU, 161943 Lips)
F = 0.
Line 7,894 ⟶ 11,582:
?- 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.
Line 7,904 ⟶ 11,592:
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). % Not ISO, but works in SWI, YAP and GNU unlike the ISO declaration.
fib(1, 1) :- !.
Line 7,912 ⟶ 11,600:
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:
<
% 2 inferences, 0.000 CPU in 0.000 seconds (90% CPU, 160591 Lips)
F = 0.
Line 7,934 ⟶ 11,622:
?- 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:
<
:- dynamic fib/2.
Line 7,988 ⟶ 11,676:
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.
Line 7,994 ⟶ 11,682:
===Continuation passing style===
Works with <b>SWI-Prolog</b> and module lambda, written by <b>Ulrich Neumerkel</b> found there http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl
<
fib(N, FN) :-
cont_fib(N, _, FN, \_^Y^_^U^(U = Y)).
Line 8,007 ⟶ 11,695:
call(Pred, FNA, FNB, FN1, FN)
).
</syntaxhighlight>
===With lazy lists===
Works with <b>SWI-Prolog</b> and others that support <code>freeze/2</code>.
<
ffib(0,1,X).
ffib(A,B,X) :-
freeze(X, (C is A+B, X=[C|Y], ffib(B,C,Y)) ).</
The predicate <code>fib(Xs)</code> unifies <code>Xs</code> with an infinite list whose values are the Fibonacci sequence. The list can be used like this:
<
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]</
===Generators idiom===
<
take( N, Next, [A|B]-Z, NZ):- N>0, !, next( Next, A, Next1),
N1 is N-1,
Line 8,033 ⟶ 11,721:
%% 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.
<
fib(C, [P,S], C, N) :- N is P + S.
fib(C, [P,S], Cv, V) :- succ(C, Cn), N is P + S, !, fib(Cn, [S,N], Cv, V).
Line 8,044 ⟶ 11,732:
fib(0, 0).
fib(1, 1).
fib(C, N) :- fib(2, [0,1], C, N). % Generate from 3rd sequence on</
Looking at performance:
<pre> ?- time(fib(30,X)).
Line 8,087 ⟶ 11,775:
X = 100 .</pre>
=== Efficient implementation ===
<syntaxhighlight lang="prolog">
% 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), !.
</syntaxhighlight>
{{out}}
<pre>
?- 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.
</pre>
=={{header|Pure}}==
===Tail Recursive===
<syntaxhighlight lang="pure">fib n = loop 0 1 n with
loop a b n = if n==0 then a else loop b (a+b) (n-1);
end;</syntaxhighlight>
=={{header|Purity}}==
The following takes a natural number and generates an initial segment of the Fibonacci sequence of that length:
<syntaxhighlight lang="purity">
data Fib1 = FoldNat
<
Line 8,163 ⟶ 11,824:
(uncurry Cons) . ((uncurry Add) . (Head, Head . Tail), id)
>
</syntaxhighlight>
This following calculates the Fibonacci sequence as an infinite stream of natural numbers:
<syntaxhighlight lang="purity">
type (Stream A?,,,Unfold) = gfix X. A? . X?
data Fib2 = Unfold ((outl, (uncurry Add, outl))) ((curry id) One One)
</syntaxhighlight>
As a histomorphism:
<syntaxhighlight lang="purity">
import Histo
Line 8,186 ⟶ 11,847:
> (outr $p1)) . UnmakeCofree
>
</syntaxhighlight>
=={{header|Python}}==
===Analytic===
Binet's formula:
<
def analytic_fibonacci(n):
Line 8,212 ⟶ 11,861:
for i in range(1,31):
print analytic_fibonacci(i),</
Output:
<pre>
Line 8,219 ⟶ 11,868:
===Iterative===
<
if n < 2:
return n
fibPrev = 1
fib = 1
for
fibPrev, fib = fib, fib + fibPrev
return fib</
====Iterative positive and negative====
<syntaxhighlight lang="python">def fib(n,x=[0,1]):
for i in range(abs(n)-1): x=[x[1],sum(x)]
return x[1]*pow(-1,abs(n)-1) if n<0 else x[1] if n else 0
for i in range(-30,31): print fib(i),</syntaxhighlight>
Output:
<pre>
-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
</pre>
===Recursive===
<
if n < 2:
return n
else:
return fibRec(n-1) + fibRec(n-2)</
===Recursive with Memoization===
<
pad = {0:0, 1:1}
def func(n):
Line 8,246 ⟶ 11,909:
fm = fibMemo()
for i in range(1,31):
print fm(i),</
Output:
<pre>
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</pre>
===Better Recursive doesn't need Memoization===
Line 8,256 ⟶ 11,921:
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(prvprv, prv, c):
if c < 1:
Line 8,262 ⟶ 11,927:
else:
return fib(prv, prvprv + prv, c - 1)
return fib(0, 1, n)</
However, although much faster and not requiring memory, the above code can only work to a limited 'n' due to the limit on stack recursion depth by Python; it is better to use the iterative code above or the generative one below.
===Generative===
<
a, b = 0, 1
while n>0:
yield a
a, b, n = b, a+b, n-1</
====Example use====
<
>>> [i for i in fibGen(11)]
[0,1,1,2,3,5,8,13,21,34,55]
</syntaxhighlight>
===Matrix-Based===
Translation of the matrix-based approach used in F#.
<
def prevPowTwo(n):
'Gets the power of two that is less than or equal to the given input'
Line 8,312 ⟶ 11,977:
return q
</syntaxhighlight>
===Large step recurrence===
This is much faster for a single, large value of n:
<
if n not in c:
x = n // 2
Line 8,322 ⟶ 11,987:
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:
<
def fib(n):
if n in F:
Line 8,333 ⟶ 11,998:
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.
<
"""Yield fib[n+1] + fib[n]"""
yield 1 # have to start somewhere
Line 8,346 ⟶ 12,011:
f=fib()
print [next(f) for _ in range(9)]</
Output:
Line 8,352 ⟶ 12,017:
'''Another version of recursive generators solution, starting from 0'''
<
def fib():
Line 8,362 ⟶ 12,027:
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|3.7}}
<syntaxhighlight lang="python">'''Fibonacci accumulation'''
from itertools import accumulate, chain
from operator import add
# fibs :: Integer :: [Integer]
def fibs(n):
'''An accumulation of the first n integers in
the Fibonacci series. The accumulator is a
pair of the two preceding numbers.
'''
def go(ab, _):
return ab[1], add(*ab)
return [xy[1] for xy in accumulate(
chain(
[(0, 1)],
range(1, n)
),
go
)]
# MAIN ---
if __name__ == '__main__':
print(
'First twenty: ' + repr(
fibs(20)
)
)</syntaxhighlight>
{{Out}}
<pre>First twenty: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]</pre>
====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|3.7}}
<syntaxhighlight lang="python">'''Nth Fibonacci term (by folding)'''
from functools import reduce
from operator import add
# nthFib :: Integer -> Integer
def nthFib(n):
'''Nth integer in the Fibonacci series.'''
def go(ab, _):
return ab[1], add(*ab)
return reduce(go, range(1, n), (0, 1))[1]
# MAIN ---
if __name__ == '__main__':
print(
'1000th term: ' + repr(
nthFib(1000)
)
)</syntaxhighlight>
{{Out}}
<pre>1000th term: 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875</pre>
{{Works with|Python|3.9}}
<syntaxhighlight lang="python">
def fib(n):
from functools import reduce
return reduce(lambda x, y: (x[1], x[0] + x[1]), range(n), (0, 1))[0]
</syntaxhighlight>
===Array and Range===
<syntaxhighlight lang="python">fibseq = [1,1,]
fiblength = 21
for x in range(1,fiblength-1):
xcount = fibseq[x-1] + fibseq[x]
fibseq.append(xcount)
print(xcount)</syntaxhighlight>
{{Out}}
<pre>10946
</pre>
===Minimal from Russia===
<syntaxhighlight lang="python">fi1=fi2=fi3=1 # FIB Russia rextester.com/FEEJ49204
for da in range(1, 88): # Danilin
print("."*(20-len(str(fi3))), end=' ')
print(fi3)
fi3 = fi2+fi1
fi1 = fi2
fi2 = fi3</syntaxhighlight>
{{Out}}
<pre>................... 1
................... 2
................... 3
....... 6557470319842
...... 10610209857723
...... 17167680177565
.. 420196140727489673
.. 679891637638612258
. 1100087778366101931</pre>
=={{header|Qi}}==
===Recursive===
<syntaxhighlight lang="qi">
(define fib
0 -> 0
Line 8,372 ⟶ 12,144:
N -> (+ (fib-r (- N 1))
(fib-r (- N 2))))
</syntaxhighlight>
===Iterative===
<syntaxhighlight lang="qi">
(define fib-0
V2 V1 0 -> V2
Line 8,381 ⟶ 12,153:
(define fib
N -> (fib-0 0 1 N))
</syntaxhighlight>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ 0 1 rot times [ tuck + ] drop ] is fibo ( n --> n )
100 fibo echo</syntaxhighlight>
{{out}}
<pre>354224848179261915075</pre>
=={{header|R}}==
===Iterative positive and negative===
<
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:
<pre>
Line 8,402 ⟶ 12,184:
</pre>
===Other methods===
<
recfibo <- function(n) {
if ( n < 2 ) n
Line 8,440 ⟶ 12,222:
}
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.
Line 8,450 ⟶ 12,232:
=={{header|Ra}}==
<syntaxhighlight lang="ra">
class FibonacciSequence
**Prints the nth fibonacci number**
Line 8,496 ⟶ 12,278:
return a
</syntaxhighlight>
=={{header|Racket}}==
===Tail Recursive===
<syntaxhighlight lang="racket">
(define (fib n)
(let loop ((cnt 0) (a 0) (b 1))
Line 8,507 ⟶ 12,289:
a
(loop (+ cnt 1) b (+ a b)))))
</syntaxhighlight>
<syntaxhighlight lang="racket">
(define (fib n (a 0) (b 1))
(if (< n 2)
1
(+ a (fib (- n 1) b (+ a b)))))
</syntaxhighlight>
===Matrix Form===
<syntaxhighlight lang="racket">
#lang racket
Line 8,529 ⟶ 12,311:
(fibmat 1000)
</syntaxhighlight>
===Foldl Form===
<syntaxhighlight lang="racket">
(define (fib n)
(car (foldl (lambda (y x)
(let ((a (car x)) (b (cdr x)))
(cons b (+ a b)))) (cons 0 1) (range n))))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
===List Generator===
This constructs the fibonacci sequence as a lazy infinite list.
<syntaxhighlight lang="raku" line>constant @fib = 0, 1, *+* ... *;</syntaxhighlight>
If you really need a function for it:
<syntaxhighlight lang="raku" line>sub fib ($n) { @fib[$n] }</syntaxhighlight>
To support negative indices:
<syntaxhighlight lang="raku" line>constant @neg-fib = 0, 1, *-* ... *;
sub fib ($n) { $n >= 0 ?? @fib[$n] !! @neg-fib[-$n] }</syntaxhighlight>
===Iterative===
<syntaxhighlight lang="raku" line>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;
}</syntaxhighlight>
===Recursive===
<syntaxhighlight lang="raku" line>proto fib (Int $n --> Int) {*}
multi fib (0) { 0 }
multi fib (1) { 1 }
multi fib ($n) { fib($n - 1) + fib($n - 2) }</syntaxhighlight>
=={{header|Rapira}}==
===Iterative===
<syntaxhighlight lang="rapira">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</syntaxhighlight>
=={{header|RASEL}}==
<syntaxhighlight lang="text">1&-:?v2\:2\01\--2\
>$.@</syntaxhighlight>
=={{header|RATFOR}}==
<syntaxhighlight lang="RATFOR">
program Fibonacci
#
integer*4 count, loop
integer*4 num1, num2, fib
1 format(A)
2 format(I4)
3 format(I6,' ')
4 format(' ')
write(6,1,advance='no')'How Many: '
read(5,2)count
num1 = 0
num2 = 1
write(6,3,advance='no')num1
write(6,3,advance='no')num2
for (loop = 3; loop<=count; loop=loop+1)
{
fib = num1 + num2
write(6,3,advance='no')fib
num1 = num2
num2 = fib
}
write(6,4)
end
</syntaxhighlight>
=={{header|Red}}==
(unnecessarily, but pleasantly palindromic)
<syntaxhighlight lang="red">Red []
palindrome: [fn: fn-1 + fn-1: fn]
fibonacci: func [n][
fn-1: 0
fn: 1
loop n palindrome
]</syntaxhighlight>
=={{header|Refal}}==
<syntaxhighlight lang="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>;
};</syntaxhighlight>
{{out}}
<pre>1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765</pre>
=={{header|Relation}}==
<syntaxhighlight lang="relation">
function fibonacci (n)
if n < 2
set result = n
else
set f0 = 0
set f1 = 1
set k = 2
while k <= n
set result = f0 + f1
set f0 = f1
set f1 = result
set k = k + 1
end while
end if
end function
</syntaxhighlight>
=={{header|Retro}}==
===Recursive===
<
===Iterative===
<
[ 0 1 ] dip [ over + swap ] times drop ;</
=={{header|REXX}}==
With 210,000 numeric decimal digits, this REXX program can handle Fibonacci numbers past one million.
<br>[Generally speaking, some REXX interpreters can handle up to around eight million decimal digits.]
This version of the REXX program can also handle ''negative'' Fibonacci numbers.
<
numeric digits 210000 /*be able to handle ginormous numbers. */
parse arg x y . /*allow a single number or a range. */
Line 8,566 ⟶ 12,478:
/* [↓] an//2 [same as] (an//2==1).*/
if n>0 | an//2 then return $ /*Positive or even? Then return sum. */
return -$ /*Negative and odd? Return negative sum*/</
{{out|output|text= when using the default inputs:}}
<pre style="height:
Fibonacci(-40) = -102334155
Fibonacci(-39) = 63245986
Line 8,659 ⟶ 12,571:
Fibonacci(10000) has a length of 2090 decimal digits
</pre>
=={{header|Rhovas}}==
Solutions support arbitrarily large numbers as Rhovas's <code>Integer</code> type is arbitrary-precision (Java <code>BigInteger</code>). Additional notes:
* <code>require num >= 0;</code> asserts input range preconditions, throwing on negative numbers
===Iterative===
Standard iterative solution using a <code>for</code> loop:
* <code>range(1, num, :incl)</code> creates an inclusive range (<code>1 <= i <= num</code>) for iteration.
** The loop uses <code>_</code> as the variable name since the value is unused.
<syntaxhighlight lang="scala">
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;
}
</syntaxhighlight>
===Recursive===
Standard recursive solution using a pattern matching approach:
* <code>match</code> without arguments is a ''conditional match'', which works like <code>if/else</code> chains.
* Rhovas doesn't perform tail-call optimization yet, hence why this solution isn't tail recursive.
<syntaxhighlight lang="scala">
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);
}
}
</syntaxhighlight>
===Negatives===
Standard solution using a pattern matching approach, delegating to an existing <code>positiveFibonacci</code> solution (as shown above). For negative fibonacci numbers, odd inputs return positive results while evens return negatives.
<syntaxhighlight lang="scala">
func fibonacci(num: Integer): Integer {
match {
num >= 0: return positiveFibonacci(num);
num.mod(2) != 0: return positiveFibonacci(-num);
else: return -positiveFibonacci(-num);
}
}
</syntaxhighlight>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
give n
x = fib(n)
see n + " Fibonacci is : " + x
func fib nr if nr = 0 return 0 ok
if nr = 1 return 1 ok
if nr > 1 return fib(nr-1) + fib(nr-2) ok
</syntaxhighlight>
=={{header|Rockstar}}==
===Iterative (minimized)===
<syntaxhighlight lang="rockstar">
Fibonacci takes Number
FNow is 0
Line 8,673 ⟶ 12,648:
Say Fibonacci taking 1000 (prints out highest number in Fibonacci sequence less than 1000)
</syntaxhighlight>
===Iterative (idiomatic)===
<syntaxhighlight lang="rockstar">
Love takes Time
My love was addictions
Line 8,689 ⟶ 12,664:
Shout; Love taking 1000 (years, years)
</syntaxhighlight>
The semicolon and the comment <code>(years, years)</code> in this version are there only for poetic effect
==
<syntaxhighlight lang="rockstar">
The Italian takes a lover, a kiss, a promise
love is population
hate is information
If a lover is love
Give back a kiss
If a lover is hate
Give back a promise
Knock a lover down
Put a promise with a kiss into my heart
Give back The Italian taking a lover, a promise, my heart
Listen to your heart
your mind is everything
your soul is opportunity
Whisper The Italian taking your heart, your mind, your soul
</syntaxhighlight>
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
===Iterative===
≪ 0 1
0 4 ROLL '''START'''
OVER + SWAP
'''NEXT''' SWAP DROP
≫ '<span style="color:blue">→FIB</span>' STO
≪ { } 0 20 '''FOR''' j j <span style="color:blue">→FIB</span> + '''NEXT''' ≫ EVAL
===Recursive===
≪ '''IF''' DUP 2 > '''THEN'''
DUP 1 - <span style="color:blue">→FIB</span>
SWAP 2 - <span style="color:blue">→FIB</span> +
'''ELSE''' SIGN '''END'''
≫ '<span style="color:blue">→FIB</span>' STO
{{out}}
<pre>
1: { 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 }
</pre>
===Fast recursive===
A much better recursive approach, based on the formulas: <code>F(2k) = [2*F(k-1) + F(k)]*F(k)</code> and <code>F(2k+1) = F(k)² + F(k+1)²</code>
≪ '''IF''' DUP 2 ≤ '''THEN''' SIGN '''ELSE'''
'''IF''' DUP 2 MOD
'''THEN''' 1 - 2 / DUP <span style="color:blue">→FIB</span> SQ SWAP 1 + <span style="color:blue">→FIB</span> SQ +
'''ELSE''' 2 / DUP <span style="color:blue">→FIB</span> DUP ROT 1 - <span style="color:blue">→FIB</span> 2 * + *
'''END END'''
≫ '<span style="color:blue">→FIB</span>' STO
=={{header|Ruby}}==
===Iterative===
<syntaxhighlight lang
if n
n
else
prev, fib = 0, 1
(n-1).times do
prev, fib = fib, fib + prev
end
fib
end
end
p (0..10).map { |i| fib(i) }</syntaxhighlight>
Output:
<pre>
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
</pre>
===Recursive===
<
return sequence.last if n == 0
Line 8,724 ⟶ 12,749:
fib(n-1, sequence)
end
</syntaxhighlight>
===Recursive with Memoization===
<
# lazily calculate the Fibonacci numbers.
Line 8,739 ⟶ 12,764:
end
end
# examples: fib[10] => 55, fib[-10] => (-55/1)</
===Matrix===
<
# To understand why this matrix is useful for Fibonacci numbers, remember
Line 8,777 ⟶ 12,802:
return nil if matrix.row_size == 0
return matrix[matrix.row_size - 1, matrix.column_size - 1]
end</
===Generative===
<
f0, f1 = 0, 1
loop do
Line 8,786 ⟶ 12,811:
f0, f1 = f1, f0 + f1
end
end</
Usage:
Line 8,795 ⟶ 12,820:
"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." [http://www.ruby-doc.org/ruby-1.9/classes/Fiber.html]
<
a,b = 0,1
loop do
Line 8,802 ⟶ 12,827:
end
end
9.times {puts fib.resume}</
using a lambda
<
a, b = 1, 1
lambda {ret, a, b = a, b, a+b; ret}
end</
<pre>
Line 8,827 ⟶ 12,852:
===Binet's Formula===
<
phi = (1 + Math.sqrt(5)) / 2
((phi**self - (-1 / phi)**self) / Math.sqrt(5)).to_i
end</
<pre>
1.9.3p125 :001 > def fib
Line 8,840 ⟶ 12,865:
=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
</pre>
=={{header|Rust}}==
===Iterative===
<syntaxhighlight lang="rust">fn main() {
let mut prev = 0;
// Rust needs this type hint for the checked_add method
Line 8,874 ⟶ 12,878:
println!("{}", n);
}
}</
===Recursive===
<
fn main() {
fibonacci(0,1);
Line 8,888 ⟶ 12,892:
fibonacci(prev, n);
}
}</
===Recursive (with pattern matching)===
<syntaxhighlight lang="rust">fn fib(n: u32) -> u32 {
match n {
0 => 0,
1 => 1,
n => fib(n - 1) + fib(n - 2),
}
}</syntaxhighlight>
===Tail recursive (with pattern matching)===
<syntaxhighlight lang="rust">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)
}</syntaxhighlight>
===Analytic===
<syntaxhighlight lang="rust">fn main() {
for num in fibonacci_sequence() {
println!("{}", num);
}
}
fn
let sqrt_5 = 5.0f64.sqrt();
let p
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))
}</syntaxhighlight>
===Using an Iterator===
Iterators are very idiomatic in rust, though they may be overkill for such a simple problem.
<
struct Fib {
Line 8,950 ⟶ 12,959:
println!("{}", num);
}
}</
====Iterator
<syntaxhighlight lang="rust">fn main() {
std::iter::successors(Some((1u128, 0)), |&(a, b)| a.checked_add(b).map(|s| (b, s)))
.for_each(|(_, u)| println!("{}", u));
}</syntaxhighlight>
=={{header|SAS}}==
=== Iterative ===
This code builds a table <code>fib</code> holding the first few values of the Fibonacci sequence.
<syntaxhighlight lang="sas">data fib;
a=0;
b=1;
Line 8,968 ⟶ 12,982:
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.
<
proc fcmp outlib=work.f.p;
Line 8,987 ⟶ 13,000:
x = fib(5);
put 'fib(5) = ' x;
run;</
=={{header|Sather}}==
The implementations use the arbitrary precision class INTI.
<
-- RECURSIVE --
Line 9,024 ⟶ 13,037:
end;
end;</
=={{header|Scala}}==
===Recursive===
<
}</
===Lazy sequence===
<
===Tail recursive===
<syntaxhighlight lang="scala">import scala.annotation.tailrec
@tailrec
final def fib(x: Int,
case 0 => prev
case _ => fib(x - 1, next, next + prev)
}</syntaxhighlight>
===foldLeft===
<
// Does not run out of memory for very large Fibonacci numbers
def fib(n: Int): BigInt = {
def series(i: BigInt, j: BigInt):
series(1, 0).take(n).foldLeft(BigInt("0"))(_ + _)
}
Line 9,087 ⟶ 13,072:
// result: 0 1 1 2 3 5 8 13 21 34 55 89 144 233
</syntaxhighlight>
===Iterator===
<
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</syntaxhighlight>
=={{header|Scheme}}==
===Iterative===
<
(do ((num 2 (+ num 1))
(fib-prev 1 fib)
(fib 1 (+ fib fib-prev)))
((>= num n) fib)))</
===Recursive===
<
(if (< n 2)
n
(+ (fib-rec (- n 1))
(fib-rec (- n 2)))))</
This version is tail recursive:
<
(let loop ((a 0) (b 1) (n n))
(if (= n 0) a
(loop b (+ a b) (- n 1)))))
</syntaxhighlight>
===Recursive Sequence Generator===
Line 9,122 ⟶ 13,110:
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)))))
Line 9,132 ⟶ 13,120:
(if (> n 1) (begin (display " ") (shw-nxt (- n 1) ((cdr strm)))) (display ")"))))
(begin (display "(") (shw-nxt n strm)))
(show-stream-take 30 (fib))</
{{output}}
Line 9,138 ⟶ 13,126:
===Dijkstra Algorithm===
<
;;; http://www.cs.utexas.edu/users/EWD/ewd06xx/EWD654.PDF
Line 9,156 ⟶ 13,144:
q
(- count 1)))))
(fib-aux 1 0 0 1 n))</
=={{header|Scilab}}==
<syntaxhighlight lang="text"> clear
n=46
f1=0; f2=1
Line 9,169 ⟶ 13,157:
f1=f2
f2=f3
end</
{{out}}
<pre>...
Line 9,178 ⟶ 13,166:
=={{header|sed}}==
<
# First we need to convert each number into the right number of ticks
Line 9,217 ⟶ 13,205:
s/</|/g
t back
s/^$/0/</
=={{header|Seed7}}==
===Recursive===
<
result
var integer: result is 1;
Line 9,230 ⟶ 13,218:
result := 0;
end if;
end func;</
Original source: [http://seed7.sourceforge.net/algorith/math.htm#fib]
Line 9,237 ⟶ 13,225:
This funtion uses a bigInteger result:
<
result
var bigInteger: result is 1_;
Line 9,250 ⟶ 13,238:
result +:= c;
end for;
end func;</
Original source: [http://seed7.sourceforge.net/algorith/math.htm#iterative_fib]
Line 9,256 ⟶ 13,244:
=={{header|SequenceL}}==
===Recursive===
<
n when n < 2
else
fibonacci(n - 1) + fibonacci(n - 2);</
Based on: [https://www.youtube.com/watch?v=5JVC5dDtnyg]
===Tail Recursive===
<
fibonacciHelper(prev, next, n) :=
Line 9,270 ⟶ 13,258:
next when n = 1
else
fibonacciHelper(next, next + prev, n - 1);</
===Matrix===
<
fibonacciHelper(M(2), n) :=
Line 9,283 ⟶ 13,271:
fibonacciHelper(matmul(M, N), n - 1);
matmul(A(2), B(2)) [i,j] := sum( A[i,all] * B[all,j] );</
Based on the C# version: [http://rosettacode.org/wiki/Fibonacci_sequence#C.23]
Line 9,289 ⟶ 13,277:
=={{header|SETL}}==
<
$ 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}'
Line 9,303 ⟶ 13,291:
end loop;
return C;
end proc;</
=={{header|Shen}}==
<
0 -> 0
1 -> 1
N -> (+ (fib (+ N 1)) (fib (+ N 2)))
where (< N 0)
N -> (+ (fib (- N 1)) (fib (- N 2))))</
=={{header|Sidef}}==
===Iterative===
<
var (a, b) = (0, 1)
{ (a, b) = (b, a+b) } * n
return a
}</
===Recursive===
<
n < 2 ? n : (__FUNC__(n-1) + __FUNC__(n-2))
}</
===Recursive with memoization===
<
n < 2 ? n : (__FUNC__(n-1) + __FUNC__(n-2))
}</
===Closed-form===
<
define S = (1.25.sqrt + 0.5)
define T = (-S + 1)
(S**n - T**n) / (-T + S) -> round
}</
===Built-in===
<
=={{header|Simula}}==
Straightforward iterative implementation.
<
INTEGER n;
BEGIN
Line 9,357 ⟶ 13,344:
END;
fibonacci := hi
END;</
=={{header|SkookumScript}}==
Line 9,365 ⟶ 13,352:
SkookumScript's <code>Integer</code> class has a fast built-in <code>fibonnaci()</code> method.
<syntaxhighlight lang
SkookumScript is designed to work in tandem with C++ and its strength is at the high-level stage-direction of things. So when confronted with [http://skookumscript.com/blog/2016/07-11-fibonacci/ benchmarking scripting systems] it is genrally better to make a built-in call. Though in most practical cases this isn't necessary.
Line 9,373 ⟶ 13,360:
Simple recursive method in same <code>42.fibonacci</code> form as built-in form above.
<
() Integer
[
if this < 2 [this] else [[this - 1].fibonacci + [this - 2].fibonacci]
]</
Recursive procedure in <code>fibonacci(42)</code> form.
<
(Integer n) Integer
[
if n < 2 [n] else [fibonacci(n - 1) + fibonacci(n - 2)]
]</
===Iterative===
Line 9,391 ⟶ 13,378:
Iterative method in <code>42.fibonacci</code> form.
<
() Integer
[
Line 9,409 ⟶ 13,396:
next
]
]</
Optimized iterative method in <code>42.fibonacci</code> form.
Though the best optimiation is to write it in C++ as with the built-in form that comes with SkookumScript.
<
// loop is faster than to_pre (which uses a closure)
() Integer
Line 9,437 ⟶ 13,424:
next
]
]</
=={{header|Slate}}==
<
[
n <= 0 ifTrue: [^ 0].
Line 9,449 ⟶ 13,435:
slate[15]> 10 fib = 55.
True</
=={{header|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):
<syntaxhighlight lang="smalltalk">Integer >> fibI
|aNMinus1 an t|
aNMinus1 := 1.
an := 0.
self timesRepeat:[
t := an.
an := an + aNMinus1 .
aNMinus1 := t.
].
^ an</syntaxhighlight>
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):
<syntaxhighlight lang="smalltalk">Integer >> fibR
(self > 1) ifTrue:[
^ (self - 1) fibR + (self - 2) fibR
].
^ self</syntaxhighlight>
analytic (fast, but inexact, and limited to small n below 1475 if we use double precision IEEE floats):
<syntaxhighlight lang="smalltalk">Integer >> fibBinet
|phi rPhi|
phi := Float phi.
rPhi := 1 / phi.
^ (1 / 5 sqrt) * ((phi raisedTo:self) - (rPhi raisedTo:self))</syntaxhighlight>
using more bits in the exponent, we can compute larger fibs (up to 23599 with x86 extended precision floats), but still inexact:
<syntaxhighlight lang="smalltalk">Integer >> fibBinetFloatE
|phi rPhi|
phi := FloatE phi.
rPhi := 1 / phi.
^ (1 / 5 sqrt) * ((phi raisedTo:self) - (rPhi raisedTo:self))</syntaxhighlight>
<syntaxhighlight lang="smalltalk">
(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)'</syntaxhighlight>
{{out}}
<pre>----10----
55
55
55.0
54.99999999999
----100----
354224848179261915075
timeout
3.54224848179262E+020
3.54224848179263E+020
----1000----
43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875
timeout
4.34665576869373E+208
4.34665576869373E+208
----10000----
336447648764317832666216120051075433103021...050562430701794976171121233066073310059947366875 (2089 digits)
timeout
INF
3.364476487643176087E+2089
----100000----
259740693472217241661550340212759154148804853...653428746875 (20898 digits)
recursion
INF
INF
----1000000----
19532821287077577316320149475962563324435429965918733...2043347225419033684684301719893411568996526838242546875 (208987 digits)
recursion
INF
INF
Timing:
-------
1000 fibI: 94 µs (394736 cycles)
timeout after 30000ms
1000 fibBinet: 5500 ns (21746 cycles)
1000 fibBinetFloatE: 12 µs (43444 cycles)
1000 fib (builtin): 37 µs (130842 cycles)
10000 fibI: 2.44 ms (8775334 cycles)
10000 fib (builtin): 49 µs (175466 cycles)
100000 fibI: 156ms (563848550 cycles)
100000 fib (builtin): 1.66 ms (5970368 cycles)
1000000 fibI: 14.3s (51676292910 cycles)
1000000 fib (builtin): 71.95 ms (259023588 cycles)
2000000 fib (builtin): 229ms (827461038 cycles)
10000000 fib (builtin): 2.769s (9970686190 cycles)</pre>
=={{header|SNOBOL4}}==
===Recursive===
<
fib fib = lt(a,2) a :s(return)
fib = fib(a - 1) + fib(a - 2) :(return)
Line 9,528 ⟶ 13,562:
while a = trim(input) :f(end)
output = a " " fib(a) :(while)
end</
===Tail-recursive===
<
trfib trfib = eq(n,0) a :s(return)
trfib = trfib(n - 1, a + b, a) :(return)
trfib_end</
===Iterative===
<
ifib ifib = le(n,2) 1 :s(return)
f1 = 1; f2 = 1
if1 ifib = gt(n,2) f1 + f2 :f(return)
f1 = f2; f2 = ifib; n = n - 1 :(if1)
ifib_end</
===Analytic===
Line 9,549 ⟶ 13,583:
Note: Snobol4+ lacks built-in sqrt( ) function.
<
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
<
s1 = s1 fib(i) ' ' ; s2 = s2 trfib(i,0,1) ' '
s3 = s3 ifib(i) ' '; s4 = s4 afib(i) ' ' :(loop)
show output = s1; output = s2; output = s3; output = s4
end</
Output:
Line 9,573 ⟶ 13,607:
===Iterative===
<
fib\==>>+<<?!/>!\ ?/\
#<</?\!>/@>\?-<<</@>/@>/>+<-\
\-/ \ !\ !\ !\ ?/#</
===Recursive===
<
fib==!/?!\-?!\->+>+<<?/>>-@\=====?/<@\===?/<#
| #+==/ fib(n-2)|+fib(n-1)|
\=====recursion======/!========/</
=={{header|Spin}}==
Line 9,613 ⟶ 13,624:
{{works with|HomeSpun}}
{{works with|OpenSpin}}
<
_clkmode = xtal1 + pll16x
_clkfreq = 80_000_000
Line 9,634 ⟶ 13,645:
b := a := 1
repeat i
a := b + (b := a)</
{{out}}
<pre>1 1 2 3 5 8 13 21 34 55 89</pre>
Line 9,640 ⟶ 13,651:
=={{header|SPL}}==
=== Analytic ===
<
s5 = #.sqrt(5)
<= (((1+s5)/2)^n-((1-s5)/2)^n)/s5
.</
=== Iterative ===
<
? n<2, <= n
f2 = 0
Line 9,655 ⟶ 13,666:
<
<= f
.</
=== Recursive ===
<
? n<2, <= n
<= fibo(n-1)+fibo(n-2)
.</
=={{header|SQL}}==
=== Analytic ===
As a running sum:
<syntaxhighlight lang="sql">
select round ( exp ( sum (ln ( ( 1 + sqrt( 5 ) ) / 2)
) over ( order by level ) ) / sqrt( 5 ) ) fibo
from dual
connect by level <= 10;
</syntaxhighlight>
<pre>
FIB
Line 9,688 ⟶ 13,699:
</pre>
As a power:
<syntaxhighlight lang="sql">
select round ( power( ( 1 + sqrt( 5 ) ) / 2, level ) / sqrt( 5 ) ) fib
from dual
connect by level <= 10;
</syntaxhighlight>
<pre>
FIB
Line 9,714 ⟶ 13,725:
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;
Line 9,731 ⟶ 13,742:
10 rows selected.
</syntaxhighlight>
{{works with|PostgreSQL}}
<
-- This recursive with generates endless list of Fibonacci numbers.
WITH RECURSIVE fibonacci(current, previous) AS (
Line 9,761 ⟶ 13,772:
-- position in the list.
OFFSET n
$$ LANGUAGE SQL RETURNS NULL ON NULL INPUT IMMUTABLE;</
=={{header|SSEM}}==
Calculates the tenth Fibonacci number. To calculate the <i>n</i>th, change the initial value of the counter to <i>n</i>-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.
<
01101000000001100000000000000000 1. c to 22 temp = acc
00101000000001010000000000000000 2. Sub. 20 acc -= m
Line 9,790 ⟶ 13,801:
10010000000000000000000000000000 23. 9 var count = 9
11111111111111111111111111111111 24. -1 const -1
11110000000000000000000000000000 25. 15 const 15</
=={{header|Stata}}==
<
args n
clear
Line 9,800 ⟶ 13,811:
qui gen a=1
qui replace a=a[_n-1]+a[_n-2] in 3/l
end</
An implementation using '''[https://www.stata.com/help.cgi?dyngen dyngen]'''.
<
args n
clear
Line 9,815 ⟶ 13,826:
fib 10
list</
'''Output'''
Line 9,836 ⟶ 13,847:
=== Mata ===
<
: function fib(n) {
return((((1+sqrt(5))/2):^n-((1-sqrt(5))/2):^n)/sqrt(5))
Line 9,847 ⟶ 13,858:
+--------------------------------------------------------+
: end</
=={{header|StreamIt}}==
<
join roundrobin(0,1);
body in->int filter {
Line 9,859 ⟶ 13,870:
enqueue(0);
enqueue(1);
}</
=={{header|SuperCollider}}==
===Recursive===
nth fibonacci term for positive n
<syntaxhighlight lang="supercollider">
f = { |n| if(n < 2) { n } { f.(n-1) + f.(n-2) } };
(0..20).collect(f)
</syntaxhighlight>
nth fibonacci term for positive and negative n.
<syntaxhighlight lang="supercollider">
f = { |n| var u = neg(sign(n)); if(abs(n) < 2) { n } { f.(2 * u + n) + f.(u + n) } };
(-20..20).collect(f)
</syntaxhighlight>
===Analytic===
<syntaxhighlight lang="supercollider">(
f = { |n|
var sqrt5 = sqrt(5);
Line 9,884 ⟶ 13,895:
};
(0..20).collect(f)
)</
===Iterative===
<syntaxhighlight lang="supercollider">
f = { |n| var a = [1, 1]; n.do { a = a.addFirst(a[0] + a[1]) }; a.reverse };
f.(18)
</syntaxhighlight>
=={{header|Swift}}==
===Analytic===
<
func fibonacci(n: Int) -> Int {
Line 9,905 ⟶ 13,916:
for i in 1...30 {
println(fibonacci(i))
}</
===Iterative===
<
if n < 2 {
return n
Line 9,918 ⟶ 13,929:
}
return fib
}</
Sequence:
<
return SequenceOf {() -> GeneratorOf<UInt> in
var window: (UInt, UInt, UInt) = (0, 0, 1)
Line 9,928 ⟶ 13,939:
}
}
}</
===Recursive===
<
if n < 2 {
return n
Line 9,939 ⟶ 13,950:
}
println(fibonacci(30))</
=={{header|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.
<syntaxhighlight lang="tailspin">
templates nthFibonacci
when <=0|=1> do $ !
otherwise ($ - 1 -> #) + ($ - 2 -> #) !
end nthFibonacci
</syntaxhighlight>
===Iterative, mutable state===
We could use the templates internal mutable state, still only positive N.
<syntaxhighlight lang="tailspin">
templates nthFibonacci
@: {n0: 0"1", n1: 1"1"};
1..$ -> @: {n0: $@.n1, n1: $@.n0 + $@.n1};
$@.n0!
end nthFibonacci
</syntaxhighlight>
To handle negatives, we can keep track of the sign and send it to the matchers.
<syntaxhighlight lang="tailspin">
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
</syntaxhighlight>
===State machine===
Instead of mutating state, we could just recurse internally on a state structure.
<syntaxhighlight lang="tailspin">
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
</syntaxhighlight>
{{out}}
<pre>
21"1"
5"1"
-8"1"
</pre>
=={{header|Tcl}}==
Line 9,946 ⟶ 14,017:
====Iterative====
{{trans|Perl}}
<
if {$n < 2} {return $n}
set prev 1
Line 9,954 ⟶ 14,025:
}
return $fib
}</
====Recursive====
<
if {$n < 2} then {expr {$n}} else {expr {[fib [expr {$n-1}]]+[fib [expr {$n-2}]]} }
}</
The following {{works with|Tcl|8.5}}: defining a procedure in the <code>::tcl::mathfunc</code> namespace allows that proc to be used as a function in <code>[http://www.tcl.tk/man/tcl8.5/TclCmd/expr.htm expr]</code> expressions.
<
if { $n < 2 } {
return $n
Line 9,971 ⟶ 14,042:
# or, more tersely
proc tcl::mathfunc::fib {n} {expr {$n<2 ? $n : fib($n-1) + fib($n-2)}}</
E.g.:
<
namespace path tcl::mathfunc #; or, interp alias {} fib {} tcl::mathfunc::fib
fib 7 ;# ==> 13</
====Tail-Recursive====
In Tcl 8.6 a ''tailcall'' function is available to permit writing tail-recursive functions in Tcl. This makes deeply recursive functions practical. The availability of large integers also means no truncation of larger numbers.
<
proc fib:inner {a b n} {
if {$n < 1} {
Line 9,993 ⟶ 14,064:
}
return [fib:inner 0 1 $n]
}</
% fib-tailrec 100
354224848179261915075
Line 9,999 ⟶ 14,070:
===Handling Negative Numbers===
====Iterative====
<
if {$n < 0} {
set n [expr {abs($n)}]
Line 10,015 ⟶ 14,086:
}
fibiter -5 ;# ==> 5
fibiter -6 ;# ==> -8</
====Recursive====
<
expr {fib(-5)} ;# ==> 5
expr {fib(-6)} ;# ==> -8</
===For the Mathematically Inclined===
This works up to <math>fib(70)</math>, after which the limited precision of IEEE double precision floating point arithmetic starts to show.<br>
{{works with|Tcl|8.5}}
<
=={{header|Tern}}==
===Recursive===
<
if (n < 2) {
return 1;
}
return fib(n - 1) + fib(n - 2);
}</
===Coroutine===
<
let a = 1;
let b = 2;
Line 10,044 ⟶ 14,115:
(a, b) = (b, a + b);
}
}</
=={{header|TI
{| class="wikitable"
|+ Texas Instruments SR-56 Program Listing for "Fibonacci Sequence"
|-
! Display !! Key !! Display !! Key !! Display !! Key !! Display !! Key
|-
| 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.
{| class="wikitable"
|+ 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:
<syntaxhighlight lang="text">
STO 0 // Nth term requested := User input
1 STO 1 // Last term := 1
0 // Initial value: 0
+ *EXC 1 = // Calculate next term.
*dsz 0 6 // Loop while R0 positive
R/S // Done, show answer
GTO 0 6 // If user hits R/S calculate next term
</syntaxhighlight>
'''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.
{{in}}
<pre>1 RST R/S</pre>
{{out}}
<pre>1</pre>
{{in}}
<pre>2 RST R/S</pre>
{{out}}
<pre>1</pre>
{{in}}
<pre>3 RST R/S</pre>
{{out}}
<pre>2</pre>
{{in}}
<pre>10 RST R/S</pre>
{{out}}
<pre>55</pre>
<pre>R/S -> 89</pre>
<pre>R/S -> 144</pre>
=={{header|TI-57}}==
{| class="wikitable"
! Step
! Function
! Comment
|-
| 00
| align="center" | <code>STO</code> <code> 0 </code>
| R0 = n
|-
| 01
|align="center" | <code>C.t</code>
| R7 = 0
|-
| 02
|align="center" | <code> 1 </code>
| Display = 1
|-
| 03
|align="center" | <code>INV</code> <code>SUM</code> <code> 1 </code>
| R0 -= 1
|-
| 04
|align="center" | <code>Lbl</code> <code> 1 </code>
| loop
|-
| 05
|align="center" | <code> + </code>
|
|-
| 06
|align="center" | <code>x⮂t</code>
| Swap Display with R7
|-
| 07
|align="center" | <code> = </code>
| Display += R7
|-
| 08
|align="center" | <code>Dsz</code>
| R0 -= 1
|-
| 09
|align="center" | <code>GTO</code> <code>1</code>
| until R0 == 0
|-
| 10
|align="center" | <code>R/S</code>
| Stop
|-
| 11
|align="center" | <code>RST</code>
| Go back to step 0
|-
|}
10 <code>RST</code> <code>R/S</code>
{{out}}
<pre>
55.
</pre>
=={{header|TSE SAL}}==
<syntaxhighlight lang="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 )
Line 10,129 ⟶ 14,333:
UNTIL FALSE
END
</syntaxhighlight>
=={{header|Turing}}==
<syntaxhighlight lang="turing">% Recursive
function fibb (n: int) : int
if n < 2 then
result n
else
result fibb (n-1) + fibb (n-2)
end if
end fibb
% Iterative
function ifibb (n: int) : int
var a := 0
var b := 1
for : 1 .. n
a := a + b
b := a - b
end for
result a
end ifibb
for i : 0 .. 10
put fibb (i) : 4, ifibb (i) : 4
end for</syntaxhighlight>
Output:<pre> 0 0
1 1
1 1
2 2
3 3
5 5
8 8
13 13
21 21
34 34
55 55</pre>
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
ASK "What fibionacci number do you want?": searchfib=""
Line 10,149 ⟶ 14,388:
PRINT "fibionacci number ",n,"=",fib
ENDLOOP
</syntaxhighlight>
Output:
<pre>
Line 10,166 ⟶ 14,405:
</pre>
=={{header|
{{works with|Uiua|0.10.0-dev.1}}
Simple recursive example with memoisation.
<syntaxhighlight lang="Uiua">
F ← |1 memo⟨+⊃(F-1)(F-2)|∘⟩<2.
F ⇡20
</syntaxhighlight>
=={{header|UNIX Shell}}==
{{works with|bash|3}}
<
a=0
Line 10,187 ⟶ 14,426:
echo "F($n): $a"
b=$(($a - $b))
done</
Recursive:
{{works with|bash|3}}
<
local n=$1
[ $n -lt 2 ] && echo -n $n || echo -n $(( $( fib $(( n - 1 )) ) + $( fib $(( n - 2 )) ) ))
}</
=={{header|UnixPipes}}==
{{incorrect|UnixPipes|There is a race between parallel commands. <code>tee last</code> might open and truncate the file before <code>cat last</code> opens it. Then <code>cat last</code> pipes the empty file to ''xargs'', and ''expr'' reports a syntax error, and the script hangs forever.}}
<syntaxhighlight lang="bash">echo 1 |tee last fib ; tail -f fib | while read x
do
cat last | tee -a fib | xargs -n 1 expr $x + |tee last
done</syntaxhighlight>
=={{header|Ursa}}==
{{trans|Python}}
===Iterative===
<
if (< n 2)
return n
Line 10,211 ⟶ 14,458:
end for
return fib
end</
=={{header|Ursala}}==
All three methods are shown here, and all have unlimited precision.
<
#import nat
Line 10,229 ⟶ 14,475:
(mp..div^|\~& mp..sub+ ~~ @rlX mp..pow_ui)^lrlPGrrPX/~& -+
^\~& ^(~&,mp..sub/1.E0)+ mp..div\2.E0+ mp..add/1.E0,
mp..sqrt+ ..grow/5.E0+-+-</
The analytical method uses arbitrary precision floating point
arithmetic from the mpfr library and then converts the result to
Line 10,235 ⟶ 14,481:
always chosen based on the argument. This test program computes the first
twenty Fibonacci numbers by all three methods.
<
examples = <.iterative_fib,recursive_fib,analytical_fib>* iota20</
output:
<pre>
Line 10,265 ⟶ 14,511:
Generate n'th fib by using binary recursion
<
[small?] []
[pred dup pred]
[+]
binrec].</
=={{header|Vala}}==
Line 10,275 ⟶ 14,521:
===Recursive===
Using int, but could easily replace with double, long, ulong, etc.
<
int fibRec(int n){
if (n < 2)
Line 10,282 ⟶ 14,528:
return fibRec(n - 1) + fibRec(n - 2);
}
</syntaxhighlight>
===Iterative===
Using int, but could easily replace with double, long, ulong, etc.
<
int fibIter(int n){
if (n < 2)
Line 10,303 ⟶ 14,549:
return cur;
}
</syntaxhighlight>
=={{header|VAX Assembly}}==
<
7E 7CFD 0002 2 clro -(sp) ;result buffer
5E DD 0005 3 pushl sp ;pointer to buffer
Line 10,340 ⟶ 14,586:
1836311903
$
</syntaxhighlight>
=={{header|Vedit macro language}}==
Calculate fibonacci(#1). Negative values return 0.
<
#11 = 0
#12 = 1
Line 10,442 ⟶ 14,599:
#12 = #10
}
Return(#11)</
===Unlimited precision===
<syntaxhighlight lang="vedit">// Fibonacci, unlimited precision.
// input: #1 = n
//
:fibo_unlimited:
if (#1 < 2) {
Num_Str(#1, 10)
return
} else {
Buf_Switch(Buf_Free)
IC('0') IN
IC('1') IN
While (#10 > 1)
#12 = 0 // carry out
#15 = 1 // column (ones, tens, hundreds...)
Repeat (ALL) { // Sum all columns
Line(-1) // n-1
Goto_col(#15)
if (At_EOL) { // all digits added
break
}
#11 = Cur_Char - '0' + #12 // digit of (n-1) + carry
Line(-1) // n-2
Goto_Col(#15)
if (!At_EOL) { // may contain fewer digits than n-1
#11 += Cur_Char - '0'
}
Goto_Line(3) // sum
EOL
#12 = #11 / 10 // carry out
Ins_Char((#11 % 10) + '0')
#15++ // next column
}
if (#12) {
Goto_Line(3)
EOL
Ins_Char(#12 + '0') // any extra digit from carry
}
BOF
Del_Line(1) // Next n
Line(1) EOL
Ins_Newline
#10--
}
Goto_Line(2) // Results on line 2
}
// Copy the results to text register 10 in reverse order
Reg_Empty(10)
While(!At_EOL) {
Reg_Copy_Block(10, CP, CP+1, INSERT)
Char()
}
Buf_Quit(OK)
return</syntaxhighlight>
Test:
<syntaxhighlight lang="vedit">#1 = Get_Num("n: ", STATLINE)
Ins_Text("fibonacci(") Num_Ins(#1, LEFT+NOCR) Ins_Text(") = ")
Call("fibo_unlimited")
Reg_Ins(10) IN
return</syntaxhighlight>
{{out}}
<pre>fibonacci(1000) = 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875</pre>
=={{header|V (Vlang)}}==
Update V (Vlang) to version 0.2.2
===Iterative===
<syntaxhighlight lang="go">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}')
}
}</syntaxhighlight>
===Recursive===
<syntaxhighlight lang="go">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}')
}
</syntaxhighlight>
{{out}}
<pre>fibonacci( 0) = 0
fibonacci( 1) = 1
fibonacci( 2) = 1
fibonacci( 3) = 2
fibonacci( 4) = 3
fibonacci( 5) = 5
fibonacci( 6) = 8
fibonacci( 7) = 13
fibonacci( 8) = 21
fibonacci( 9) = 34
fibonacci(10) = 55
</pre>
Line 10,595 ⟶ 14,720:
===Recursive, all at once===
<
if (n < 2)
n
(+ (fib n-1) (fib n-2))</
===Recursive, using cases===
<
(+ (fib n-1) (fib n-2))
def (fib n) :case (n < 2)
n</
===Recursive, using memoization===
<
# 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</
=={{header|WDTE}}==
===Memoized Recursive===
<
===Iterative===
<
let a => import 'arrays';
Line 10,633 ⟶ 14,755:
-> a.at 1
;
);</
=={{header|WebAssembly}}==
<syntaxhighlight lang=wat>(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
)</syntaxhighlight>
=={{header|Whitespace}}==
Line 10,639 ⟶ 14,810:
===Iterative===
This program generates Fibonacci numbers until it is [http://ideone.com/VBDLzk forced to terminate].
<syntaxhighlight lang="whitespace">
Line 10,651 ⟶ 14,822:
</
It was generated from the following pseudo-Assembly.
<
push 1
Line 10,665 ⟶ 14,836:
copy 1
add
jump 0</
{{out}}
<pre>$ wspace fib.ws | head -n 6
Line 10,678 ⟶ 14,849:
This program takes a number ''n'' on standard input and outputs the ''n''th member of the Fibonacci sequence.
<syntaxhighlight lang="whitespace">
Line 10,706 ⟶ 14,877:
</
<
push 0
dup
Line 10,735 ⟶ 14,906:
add ; Leave the sum on the stack.
1:
ret</
{{out}}
Line 10,743 ⟶ 14,914:
=={{header|Wrapl}}==
===Generator===
<
VAR seq <- [0, 1]; EVERY SUSP seq:values;
REP SUSP seq:put(seq:pop + seq[1])[-1];
);</
To get the 17th number:
<syntaxhighlight lang
To get the list of all 17 numbers:
<syntaxhighlight lang
===Iterator===
Using type match signature to ensure integer argument:
<
VAR seq <- [0, 1];
EVERY 3:to(n) DO seq:put(seq:pop + seq[1]);
RET seq[-1];
);</
=={{header|Wren}}==
<syntaxhighlight lang="wren">// iterative (quick)
var fibItr = Fn.new { |n|
if (n < 2) return n
var a = 0
var b = 1
for (i in 2..n) {
var c = a + b
a = b
b = c
}
return b
}
// recursive (slow)
var fibRec
fibRec = Fn.new { |n|
if (n < 2) return n
return fibRec.call(n-1) + fibRec.call(n-2)
}
System.print("Iterative: %(fibItr.call(36))")
System.print("Recursive: %(fibRec.call(36))")</syntaxhighlight>
{{out}}
<pre>
Iterative: 14930352
Recursive: 14930352
</pre>
=={{header|x86 Assembly}}==
{{Works with|MASM}}
<
; __ __/--------\
; >__ \ / | |\
Line 10,811 ⟶ 15,012:
main ENDP
END main</
=={{header|xEec}}==
This will display the first 93 numbers of the sequence.
<syntaxhighlight lang="xeec">
h#1 h#1 h#1 o#
h#10 o$ p
Line 10,823 ⟶ 15,024:
t
jnf
</syntaxhighlight>
=={{header|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.
<
(FLOOR (+ (/ (EXPT (/ (+ (SQRT 5) 1) 2) N) (SQRT 5)) 0.5)))</
To test it, we'll define a <tt>RANGE</tt> function and ask for the first 50 numbers in the sequence:
<
(IF (<= X Y)
(CONS X (RANGE (+ X 1) Y))))
(PRINT (MAPCAR FIBONACCI (RANGE 1 50)))</
{{out}}
<pre>(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)</pre>
Line 10,841 ⟶ 15,042:
===Tail recursive===
Alternatively, this approach is reasonably efficient:
<
(defun fib (a b n)
(if (= n 2)
Line 10,848 ⟶ 15,049:
(if (< x 2)
x
(fib 1 1 x) ) )</
=={{header|
<syntaxhighlight lang="xpl0">func Fib1(N); \Return Nth Fibonacci number using iteration
int N;
int Fn, F0, F1;
[F0:= 0; F1:= 1; Fn:= N;
while N > 1 do
[Fn:= F0 + F1;
F0:= F1;
F1:= Fn;
N:= N-1;
];
return Fn;
];
func Fib2(N); \Return Nth Fibonacci number using recursion
int N;
return if N < 2 then N else Fib2(N-1) + Fib2(N-2);
int N;
[for N:= 0 to 20 do [IntOut(0, Fib1(N)); ChOut(0, ^ )];
CrLf(0);
for N:= 0 to 20 do [IntOut(0, Fib2(N)); ChOut(0, ^ )];
CrLf(0);
]</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|XQuery}}==
<
if($n < 2)
then $n
else local:fib($n - 1) + local:fib($n - 2)
};</
=={{header|Z80 Assembly}}==
<syntaxhighlight lang="z80">; 8 bit version
; IN : a = n (n <= 13, otherwise overflows)
; OUT: a = FIB(n)
fib8: cp 2
ret c ; if n < 2 then done
ld b,a
dec b ; b = n - 1
ld c,0 ; F0
ld a,1 ; F1
f8_l: ld d,a
add a,c
ld c,d
djnz f8_l
ret
</syntaxhighlight>
8 bits only? That's so 80's!
Let's go 32 bits...
<syntaxhighlight lang="z80">; 32 bit version
; IN : a = n (n <= 47, otherwise overflows)
; OUT: hlh'l' = FIB(n)
fib32: ld l,a ; lower bytes in the alt set
ld h,0
exx ; now in regular set
ld hl,0
cp 2
ret c ; if n < 2 then done
dec a ; loopcount = n - 1
ld bc,0
exx ; now in alt set
ld bc,0
ld hl,1
f32_l: ld d,h
ld e,l
add hl,bc
ld b,d
ld c,e
exx ; now in reg set
ld d,h
ld e,l
adc hl,bc
ld b,d
ld c,e
exx ; now in alt set
dec a
jr nz,f32_l
exx ; now in reg set
ret</syntaxhighlight>
=={{header|YAMLScript}}==
<syntaxhighlight lang="yaml">
!yamlscript/v0
defn main(n=10):
loop [a 0, b 1, i 1]:
say: a
if (i < n):
recur: b, (a + b), (i + 1)
</syntaxhighlight>
=={{header|zkl}}==
A slight tweak to the task; creates a function that continuously generates fib numbers
<
<pre>
zkl: do(15){ fibShift().print(",") }
Line 10,884 ⟶ 15,170:
610,987,1597,2584,4181,
</pre>
[[Category:Arithmetic]]
| |||