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

## Answers

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.

One of the exercises in SICP is about this, which has the answer described here.

In the imperative style, the program would look something like

FunctionFib(count)a← 1b← 0p← 0q← 1Whilecount> 0DoIfEven(count)Thenp←p² +q²q← 2pq+q²count←count÷ 2Elsea←bq+aq+apb←bp+aqcount←count- 1End IfEnd WhileReturnbEnd 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) =M^{n}_{1,2}

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

Two approaches to matrix exponentiation are divide and conquer which yields **M**^{n} 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:

M^{n}= (M^{n/2})^{2}ifneven =M.M^{n-1}ifnis odd

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

M=UΛU^{-1}M^{n}= (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

*n*th power is a simple matter of raising each element in

**Λ** to the

*n*th, so this gives an O(1) method of raising

**M** to the

*n*th 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

using the quadratic formula

λ = ( -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 **X**_{1} and **X**_{2}:

ifX_{1}= [X_{1,1},X_{1,2}]M.X_{1 1}= λ_{1}X_{1}X_{1,1}+X_{1,2}= λ_{1}X_{1,1}X_{1,1}= λ_{1}X_{1,2}=>X_{1}= [ Φ, 1 ]X_{2}= [ 1-Φ, 1 ]

These vectors give **U**:

U= [X_{1,1},X_{2,2}] [X_{1,1},X_{2,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 Ψ+Φ = 1UΛ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 **M**^{n}_{1,2}:

M^{n}=UΛ^{n}U^{-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) =M^{n}_{1,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 (phi

^{n}/√5 +^{1}/_{2})fib n ~= phi

^{n}/√5

How many digits is fib n?

numDigits (fib n) = log (fib n) = log (phi

^{n}/√5) = log phi^{n}– log √5 = n * log phi – log √5numDigits (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.