# nth fibonacci number in sublinear time

Is there any algorithm to compute the nth fibonacci number in sub linear time?

Returning Nth Fibonacci number the sequence?

I have a question on my homework for class and I need to know how to return nth number of Fibonacci sequence using iteration (no recursion allowed). I need some tips on how to do this so I can better

Fibonacci method return nth number in sequence

I need to make a method that returns the nth integer in the fibonacci series, the code that I wrote returns every second integer from the series when printed in a table. The int fib used in the method

Check if the Nth number of Fibonacci is NthFib or not – arithmetic error fail

Here is my predicate, which should check if the Nth number of Fibonacci is NthFib or not. I am getting arithmetic is not function error. K – current iteration N – Nth number Tmp – previous Fibonacci n

finding the greatest Fibonacci number within limited time in python

I need a code that calculates nth fibonacci number as well as giving me the time used to calculate it, in python. def fib(n): if n==0 or n==1: return 1 else: return fib(n-1)+fib(n-2) The calculation

nth Fibonacci number in dynamic programming

Every one know logic of Fibonacci series Fib0 = 0 Fib1 = 1 Fibn = Fibn-1 + Fibn-2 , n > 1 my question is i have to calculate fib(n)%(100000000+7) and output should be according n like for n=0 outp

Calculating nth fibonacci number using the formulae in python

I am calculating the n-th fibonacci number using (a) a linear approach, and (b) this expression Python code: ‘Different implementations for computing the n-th fibonacci number’ def lfib(n): ‘Find the

Finding out nth fibonacci number for very large ‘n’

I was wondering about how can one find the nth term of fibonacci sequence for a very large value of n say, 1000000. Using the grade-school recurrence equation fib(n)=fib(n-1)+fib(n-2), it takes 2-3 mi

How do I print a fibonacci sequence to the nth number in Python?

I have a homework assignment that I’m stumped on. I’m trying to write a program that outputs the fibonacci sequence up the nth number. Here’s what I have so far: def fib(): n = int(input(Please Ente

Get number of Nth place of modified Fibonacci sequence

In an interview today, I was given this sequence, which is sort of a modified Fibonacci: 1, 1, 2, 4, 6, 13, 19, 42, 61, 135, …, I was asked to write a function to return the number at place n. So, i

How to determine the largest fibonacci number

I am asked to determine the largest fibonacci number that can be displayed on my system and I am wondering about how to do that.. here’s my simple application that determines the nth fibonacci number

Wikipedia has a closed form solution http://en.wikipedia.org/wiki/Fibonacci_number

Or in c#:

```    public static int Fibonacci(int N)
{
double sqrt5 = Math.Sqrt(5);
double phi = (1 + sqrt5) / 2.0;
double fn = (Math.Pow(phi, N) - Math.Pow(1 - phi, N)) / sqrt5;
return (int)fn;
}
```

The nth Fibonacci number is given by

```f(n) = Floor(phi^n / sqrt(5) + 1/2)
```

where

```phi = (1 + sqrt(5)) / 2
```

Assuming that the primitive mathematical operations (+, -, * and /) are O(1) you can use this result to compute the nth Fibonacci number in O(log n) time (O(log n) because of the exponentiation in the formula).

In C#:

```static double inverseSqrt5 = 1 / Math.Sqrt(5);
static double phi = (1 + Math.Sqrt(5)) / 2;
/* should use
const double inverseSqrt5 = 0.44721359549995793928183473374626
const double phi = 1.6180339887498948482045868343656
*/

static int Fibonacci(int n) {
return (int)Math.Floor(Math.Pow(phi, n) * inverseSqrt5 + 0.5);
}
```

You can do it by exponentiating a matrix of integers as well. If you have the matrix

```    / 1  1 /
M = |      |
/ 1  0 /
```

then (M^n)[1, 2] is going to be equal to the nth Fibonacci number, if [] is a matrix subscript and ^ is matrix exponentiation. For a fixed-size matrix, exponentiation to an positive integral power can be done in O(log n) time in the same way as with real numbers.

EDIT: Of course, depending on the type of answer you want, you may be able to get away with a constant-time algorithm. Like the other formulas show, the nth Fibonacci number grows exponentially with n. Even with 64-bit unsigned integers, you’ll only need a 94-entry lookup table in order to cover the entire range.

SECOND EDIT: Doing the matrix exponential with an eigendecomposition first is exactly equivalent to JDunkerly’s solution below. The eigenvalues of this matrix are the (1 + sqrt(5))/2 and (1 – sqrt(5))/2.

In the imperative style, the program would look something like

```Function Fib(count)
a ← 1
b ← 0
p ← 0
q ← 1

While count > 0 Do
If Even(count) Then
p ← p² + q²
q ← 2pq + q²
count ← count ÷ 2
Else
a ← bq + aq + ap
b ← bp + aq
count ← count - 1
End If
End While

Return b
End Function
```

Just giving a pointer to a reddit discussion about the topic. It has some nice comments.

Following from Pillsy’s reference to matrix exponentiation, such that for the matrix

```M = [1 1]
[1 0]
```

then

`fib(n) = Mn1,2`

Raising matrices to powers using repeated multiplication is not very efficient.

Two approaches to matrix exponentiation are divide and conquer which yields Mn in O(ln n) steps, or eigenvalue decomposition which is constant time, but may introduce errors due to limited floating point precision.

If you want an exact value greater than the precision of your floating point implementation, you have to use the O ( ln n ) approach based on this relation:

```Mn = (Mn/2)2 if n even
= M.Mn-1 if n is odd
```

The eigenvalue decomposition on M finds two matrices U and Λ such that Λ is diagonal and

``` M  = U Λ U-1
Mn = ( U Λ U-1) n
= U Λ U-1 U Λ U-1 U Λ U-1 ... n times
= U Λ Λ Λ ... U-1
= U Λ n U-1
```

Raising a the diagonal matrix
Λ to the
nth power is a simple matter of raising each element in
Λ to the
nth, so this gives an O(1) method of raising
M to the
nth power. However, the values in
Λ are not likely to be integers, so some error will occur.

Defining Λ for our 2×2 matrix as

```Λ = [ λ1 0 ]
= [ 0 λ2 ]
```

To find each λ, we solve

` |M - λI| = 0`

which gives

``` |M - λI| = -λ ( 1 - λ ) - 1

λ² - λ - 1 = 0
```

```λ    = ( -b ± √ ( b² - 4ac ) ) / 2a
= ( 1 ± √5 ) / 2
{ λ1, λ2 } = { Φ, 1-Φ } where Φ = ( 1 + √5 ) / 2
```

If you’ve read Jason’s answer, you can see where this is going to go.

Solving for the eigenvectors X1 and X2:

```if X1 = [ X1,1, X1,2 ]

M.X1 1 = λ1X1

X1,1 + X1,2 = λ1 X1,1
X1,1      = λ1 X1,2

=>
X1 = [ Φ,   1 ]
X2 = [ 1-Φ, 1 ]
```

These vectors give U:

```U = [ X1,1, X2,2 ]
[ X1,1, X2,2 ]

= [ Φ,   1-Φ ]
[ 1,   1   ]
```

Inverting U using

```A   = [  a   b ]
[  c   d ]
=>
A-1 = ( 1 / |A| )  [  d  -b ]
[ -c   a ]
```

so U-1 is given by

```U-1 = ( 1 / ( Φ - ( 1 - Φ ) )  [  1  Φ-1 ]
[ -1   Φ  ]
U-1 = ( √5 )-1  [  1  Φ-1 ]
[ -1   Φ  ]
```

Sanity check:

```UΛU-1 = ( √5 )-1 [ Φ   1-Φ ] . [ Φ   0 ] . [ 1  Φ-1 ]
[ 1   1  ]   [ 0  1-Φ ]   [ -1   Φ ]

let Ψ = 1-Φ, the other eigenvalue

as Φ is a root of λ²-λ-1=0
so  -ΨΦ = Φ²-Φ = 1
and Ψ+Φ = 1

UΛU-1 = ( √5 )-1 [ Φ   Ψ ] . [ Φ   0 ] . [  1  -Ψ ]
[ 1   1 ]   [ 0   Ψ ]   [ -1   Φ ]

= ( √5 )-1 [ Φ   Ψ ] . [ Φ   -ΨΦ ]
[ 1   1 ]   [ -Ψ  ΨΦ ]

= ( √5 )-1 [ Φ   Ψ ] . [ Φ    1 ]
[ 1   1 ]   [ -Ψ  -1 ]

= ( √5 )-1 [ Φ²-Ψ²  Φ-Ψ ]
[ Φ-Ψ      0 ]

= [ Φ+Ψ   1 ]
[ 1     0 ]

= [ 1     1 ]
[ 1     0 ]

= M
```

So the sanity check holds.

Now we have everything we need to calculate Mn1,2:

```Mn = UΛnU-1
= ( √5 )-1 [ Φ   Ψ ] . [ Φn  0 ] . [  1  -Ψ ]
[ 1   1 ]   [ 0   Ψn ]   [ -1   Φ ]

= ( √5 )-1 [ Φ   Ψ ] . [  Φn  -ΨΦn ]
[ 1   1 ]   [ -Ψn   ΨnΦ ]

= ( √5 )-1 [ Φ   Ψ ] . [  Φn   Φn-1 ]
[ 1   1 ]   [ -Ψn  -Ψn-1 ] as ΨΦ = -1

= ( √5 )-1 [ Φn+1-Ψn+1      Φn-Ψn ]
[ Φn-Ψn      Φn-1-Ψn-1 ]
```

so

``` fib(n) = Mn1,2
= ( Φn - (1-Φ)n ) / √5
```

Which agrees with the formula given elsewhere.

You can derive it from a recurrance relation, but in engineering computing and simulation calculating the eigenvalues and eigenvectors of large matrices is an important activity, as it gives stability and harmonics of systems of equations, as well as allowing raising matrices to high powers efficiently.

If you want the exact number (which is a “bignum”, rather than an int/float), then I’m afraid that

It’s impossible!

As stated above, the formula for fibonacci numbers is:

fib n = floor (phin/√5 + 1/2)

fib n ~= phin/√5

How many digits is fib n?

numDigits (fib n) = log (fib n) = log (phin/√5) = log phin – log √5 = n * log phi – log √5

numDigits (fib n) = n * const + const

it’s O(n)

Since the requested result is of O(n), it can’t be calculated in less than O(n) time.

If you only want the lower digits of the answer, then it is possible to calculate in sub-linear time using the matrix exponentiation method.

using R

```l1 <- (1+sqrt(5))/2
l2 <- (1-sqrt(5))/2

P <- matrix(c(0,1,1,0),nrow=2) #permutation matrix
S <- matrix(c(l1,1,l2,1),nrow=2)
L <- matrix(c(l1,0,0,l2),nrow=2)
C <- c(-1/(l2-l1),1/(l2-l1))

k<-20 ; (S %*% L^k %*% C)[2]
[1] 6765
```

see divide and conquer algorithm here

The link has pseudocode for the matrix exponentiation mentioned in some of the other answers for this question.

Fixed point arithmetic is inaccurate. Jason’s C# code gives incorrect answer for n = 71 (308061521170130 instead of 308061521170129) and beyond.

For correct answer, use a computational algebra system. Sympy is such a library for Python. There’s an interactive console at http://live.sympy.org/ . Copy and paste this function

```phi = (1 + sqrt(5)) / 2
def f(n):
return floor(phi**n / sqrt(5) + 1/2)
```

Then calculate

```>>> f(10)
55

>>> f(71)
308061521170129
```

You might like to try inspecting phi.

For really big ones, this recursive function works. It uses the following equations:

```F(2n-1) = F(n-1)^2 + F(n)^2
F(2n) = (2*F(n-1) + F(n)) * F(n)
```

You need a library that lets you work with big integers. I use the BigInteger library from https://mattmccutchen.net/bigint/.

Start with an array of of fibonacci numbers. Use fibs[0]=0, fibs[1]=1, fibs[2]=1, fibs[3]=2, fibs[4]=3, etc. In this example, I use an array of the first 501 (counting 0). You can find the first 500 non-zero Fibonacci numbers here: http://home.hiwaay.net/~jalison/Fib500.html. It takes a little editing to put it in the right format, but that is not too hard.

Then you can find any Fibonacci number using this function (in C):

```BigUnsigned GetFib(int numfib)
{
int n;
BigUnsigned x, y, fib;

if (numfib < 501) // Just get the Fibonacci number from the fibs array
{
fib=(stringToBigUnsigned(fibs[numfib]));
}
else if (numfib%2) // numfib is odd
{
n=(numfib+1)/2;
x=GetFib(n-1);
y=GetFib(n);
fib=((x*x)+(y*y));
}
else // numfib is even
{
n=numfib/2;
x=GetFib(n-1);
y=GetFib(n);
fib=(((big2*x)+y)*y);
}
return(fib);
}
```

I’ve tested this for the 25,000th Fibonacci number and the like.

Here’s my recursive version that recurses log(n) times. I think that it’s easiest to read in the recursive form:

```def my_fib(x):
if x < 2:
return x
else:
return my_fib_helper(x)[0]

def my_fib_helper(x):
if x == 1:
return (1, 0)
if x % 2 == 1:
(p,q) = my_fib_helper(x-1)
return (p+q,p)
else:
(p,q) = my_fib_helper(x/2)
return (p*p+2*p*q,p*p+q*q)
```

It works because you can compute fib(n),fib(n-1) using fib(n-1),fib(n-2) if n is odd and if n is even, you can compute fib(n),fib(n-1) using fib(n/2),fib(n/2-1).

The base case and the odd case are simple. To derive the even case, start with a,b,c as consecutive fibonacci values (eg, 8,5,3) and write them in a matrix, with a = b+c. Notice:

```[1 1] * [a b]  =  [a+b a]
[1 0]   [b c]     [a   b]
```

From that, we see that a matrix of the first three fibonacci numbers, times a matrix of any three consecutive fibonacci numbers, equals the next. So we know that:

```      n
[1 1]   =  [fib(n+1) fib(n)  ]
[1 0]      [fib(n)   fib(n-1)]
```

So:

```      2n                        2
[1 1]    =  [fib(n+1) fib(n)  ]
[1 0]       [fib(n)   fib(n-1)]
```

Simplifying the right hand side leads to the even case.