Fast Doubling method to find the Nth Fibonacci number

Given an integer N, the task is to find the N-th Fibonacci numbers.

Examples:

Input: N = 3
Output: 2
Explanation:
F(1) = 1, F(2) = 1
F(3) = F(1) + F(2) = 2

Input: N = 6
Output: 8

Approach:



  • The Matrix Exponentiation Method is already discussed before. The Doubling Method can be seen as an improvement to the matrix exponentiation method to find the N-th Fibonacci number although it doesn’t use matrix multiplication itself.
  • The Fibonacci recursive sequence is given by

    F(n+1) = F(n) + F(n-1)

  • The Matrix Exponentiation method uses the following formula

         \[ \begin{bmatrix}     1 & 1  \\     1 & 0   \end{bmatrix}^n =   \begin{bmatrix}     F_{n+1} & F_n   \\     F_n & F_{n-1}   \end{bmatrix} \]

  • The method involves costly matrix multiplication and moreover Fn is redundantly computed twice.
    On the other hand, Fast Doubling Method is based on two basic formulas:

    F(2n) = F(n)[2F(n+1) – F(n)]
    F(2n + 1) = F(n)2 + F(n+1)2
  • Here is a short explanation of the above results:

    Start with:
    F(n+1) = F(n) + F(n-1) &
    F(n) = F(n)
    It can be rewritten in the matrix form as:

         \[ \begin{bmatrix}     F(n+1)  \\     F(n)   \end{bmatrix} = \begin{bmatrix}     1 & 1  \\     1 & 0   \end{bmatrix}   \begin{bmatrix}     F(n)   \\     F(n-1)   \end{bmatrix} \]  \[\quad\enspace= \begin{bmatrix}     1 & 1  \\     1 & 0   \end{bmatrix}^2   \begin{bmatrix}     F(n-1)   \\     F(n-2)   \end{bmatrix}  \] \quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\enspace\enspace\thinspace......\\ \[= \begin{bmatrix}     1 & 1  \\     1 & 0   \end{bmatrix}^n   \begin{bmatrix}     F(1)   \\     F(0)   \end{bmatrix}  \]

    For doubling, we just plug in “2n” into the formula:



         \[ \begin{bmatrix}     F(2n+1)  \\     F(2n)   \end{bmatrix} = \begin{bmatrix}     1 & 1  \\     1 & 0   \end{bmatrix}^{2n}   \begin{bmatrix}     F(1)   \\     F(0)   \end{bmatrix} \]  \[\quad\enspace= \begin{bmatrix}     1 & 1  \\     1 & 0   \end{bmatrix}^n \begin{bmatrix}     1 & 1  \\     1 & 0   \end{bmatrix}^n   \begin{bmatrix}     F(1)   \\     F(0)   \end{bmatrix}  \] \[\quad\enspace= \begin{bmatrix}     F(n+1) & F(n)  \\     F(n) & F(n-1)   \end{bmatrix} \begin{bmatrix}     F(n+1) & F(n)  \\     F(n) & F(n-1)   \end{bmatrix} \begin{bmatrix}     F(1)   \\     F(0)   \end{bmatrix}  \] \[\quad\enspace= \begin{bmatrix}     F(n+1)^2 + F(n)^2 \\     F(n)F(n+1) + F(n)F(n-1)   \end{bmatrix} \]

    Substituting F(n-1) = F(n+1)- F(n) and after simplification we get,

         \[ \begin{bmatrix}     F(2n+1)  \\     F(2n)   \end{bmatrix} = \begin{bmatrix}     F(n+1)^2 + F(n)^2 \\     2F(n+1)F(n) - F(n)^2   \end{bmatrix} \]

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find the Nth Fibonacci
// number using Fast Doubling Method
#include <bits/stdc++.h>
using namespace std;
  
int a, b, c, d;
#define MOD 1000000007
  
// Function calculate the N-th fibanacci
// number using fast doubling method
void FastDoubling(int n, int res[])
{
    // Base Condition
    if (n == 0) {
        res[0] = 0;
        res[1] = 1;
        return;
    }
    FastDoubling((n / 2), res);
  
    // Here a = F(n)
    a = res[0];
  
    // Here b = F(n+1)
    b = res[1];
  
    c = 2 * b - a;
  
    if (c < 0)
        c += MOD;
  
    // As F(2n) = F(n)[2F(n+1) – F(n)]
    // Here c  = F(2n)
    c = (a * c) % MOD;
  
    // As F(2n + 1) = F(n)^2 + F(n+1)^2
    // Here d = F(2n + 1)
    d = (a * a + b * b) % MOD;
  
    // Check if N is odd
    // or even
    if (n % 2 == 0) {
        res[0] = c;
        res[1] = d;
    }
    else {
        res[0] = d;
        res[1] = c + d;
    }
}
  
// Driver code
int main()
{
    int N = 6;
    int res[2] = { 0 };
  
    FastDoubling(N, res);
  
    cout << res[0] << "\n";
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find the Nth Fibonacci
// number using Fast Doubling Method
class GFG{ 
  
// Function calculate the N-th fibanacci
// number using fast doubling method
static void FastDoubling(int n, int []res)
{
    int a, b, c, d;
    int MOD = 1000000007;
      
    // Base Condition
    if (n == 0
    {
        res[0] = 0;
        res[1] = 1;
        return;
    }
    FastDoubling((n / 2), res);
  
    // Here a = F(n)
    a = res[0];
  
    // Here b = F(n+1)
    b = res[1];
  
    c = 2 * b - a;
  
    if (c < 0)
        c += MOD;
  
    // As F(2n) = F(n)[2F(n+1) – F(n)]
    // Here c = F(2n)
    c = (a * c) % MOD;
  
    // As F(2n + 1) = F(n)^2 + F(n+1)^2
    // Here d = F(2n + 1)
    d = (a * a + b * b) % MOD;
  
    // Check if N is odd
    // or even
    if (n % 2 == 0)
    {
        res[0] = c;
        res[1] = d;
    }
    else
    {
        res[0] = d;
        res[1] = c + d;
    }
}
  
// Driver code
public static void main(String []args)
{
    int N = 6;
    int res[] = new int[2];
  
    FastDoubling(N, res);
  
    System.out.print(res[0]);
}
}
  
// This code is contributed by rock_cool

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to find the Nth Fibonacci 
# number using Fast Doubling Method 
MOD = 1000000007
  
# Function calculate the N-th fibanacci 
# number using fast doubling method 
def FastDoubling(n, res): 
      
    # Base Condition 
    if (n == 0): 
        res[0] = 0
        res[1] = 1
        return
          
    FastDoubling((n // 2), res) 
  
    # Here a = F(n) 
    a = res[0
  
    # Here b = F(n+1) 
    b = res[1
  
    c = 2 * b -
  
    if (c < 0): 
        c += MOD 
  
    # As F(2n) = F(n)[2F(n+1) – F(n)] 
    # Here c = F(2n) 
    c = (a * c) % MOD 
  
    # As F(2n + 1) = F(n)^2 + F(n+1)^2 
    # Here d = F(2n + 1) 
    d = (a * a + b * b) % MOD 
  
    # Check if N is odd 
    # or even 
    if (n % 2 == 0): 
        res[0] =
        res[1] =
    else
        res[0] =
        res[1] = c +
      
# Driver code 
N = 6
res = [0] * 2
  
FastDoubling(N, res) 
  
print(res[0]) 
      
# This code is contributed by divyamohan123

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find the Nth Fibonacci
// number using Fast Doubling Method
using System;
class GFG{ 
  
// Function calculate the N-th fibanacci
// number using fast doubling method
static void FastDoubling(int n, int []res)
{
    int a, b, c, d;
    int MOD = 1000000007;
      
    // Base Condition
    if (n == 0) 
    {
        res[0] = 0;
        res[1] = 1;
        return;
    }
    FastDoubling((n / 2), res);
  
    // Here a = F(n)
    a = res[0];
  
    // Here b = F(n+1)
    b = res[1];
  
    c = 2 * b - a;
  
    if (c < 0)
        c += MOD;
  
    // As F(2n) = F(n)[2F(n+1) – F(n)]
    // Here c = F(2n)
    c = (a * c) % MOD;
  
    // As F(2n + 1) = F(n)^2 + F(n+1)^2
    // Here d = F(2n + 1)
    d = (a * a + b * b) % MOD;
  
    // Check if N is odd
    // or even
    if (n % 2 == 0)
    {
        res[0] = c;
        res[1] = d;
    }
    else
    {
        res[0] = d;
        res[1] = c + d;
    }
}
  
// Driver code
public static void Main()
{
    int N = 6;
    int []res = new int[2];
  
    FastDoubling(N, res);
  
    Console.Write(res[0]);
}
}
  
// This code is contributed by Code_Mech

chevron_right


Output:

8

Time Complexity: Repeated squaring reduces time from linear to logarithmic . Hence, with constant time arithmetic, the time complexity is O(log n).

competitive-programming-img




My Personal Notes arrow_drop_up


If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.