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






                        filter_none









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







                        filter_none









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


N = 6


res = [0] * 2


  


FastDoubling(N, res)  


  


print(res[0])  


      


# This code is contributed by divyamohan123 



















                        chevron_right







                        filter_none









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







                        filter_none











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
    

    

        
        

            
            
        

    


Recommended Posts:
kushal_chakraborty
Check out this Author's contributed articles.
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.