Related Articles
Runge-Kutta 4th Order Method to Solve Differential Equation
• Difficulty Level : Easy
• Last Updated : 17 May, 2018

Given following inputs,

• An ordinary differential equation that defines value of dy/dx in the form x and y.
• Initial value of y, i.e., y(0)

Thus we are given below. The task is to find value of unknown function y at a given point x.

The Runge-Kutta method finds approximate value of y for a given x. Only first order ordinary differential equations can be solved by using the Runge Kutta 4th order method.

Below is the formula used to compute next value yn+1 from previous value yn. The value of n are 0, 1, 2, 3, ….(x – x0)/h. Here h is step height and xn+1 = x0 + h

. Lower step size means more accuracy. The formula basically computes next value yn+1 using current yn plus weighted average of four increments.

• k1 is the increment based on the slope at the beginning of the interval, using y
• k2 is the increment based on the slope at the midpoint of the interval, using y + hk1/2.
• k3 is again the increment based on the slope at the midpoint, using using y + hk2/2.
• k4 is the increment based on the slope at the end of the interval, using y + hk3.

The method is a fourth-order method, meaning that the local truncation error is on the order of O(h5), while the total accumulated error is order O(h4).

Below is implementation for the above formula.

## C/C++

 // C program to implement Runge Kutta method  #include     // A sample differential equation "dy/dx = (x - y)/2"  float dydx(float x, float y)  {      return((x - y)/2);  }     // Finds value of y for a given x using step size h  // and initial value y0 at x0.  float rungeKutta(float x0, float y0, float x, float h)  {      // Count number of iterations using step size or      // step height h      int n = (int)((x - x0) / h);         float k1, k2, k3, k4, k5;         // Iterate for number of iterations      float y = y0;      for (int i=1; i<=n; i++)      {          // Apply Runge Kutta Formulas to find          // next value of y          k1 = h*dydx(x0, y);          k2 = h*dydx(x0 + 0.5*h, y + 0.5*k1);          k3 = h*dydx(x0 + 0.5*h, y + 0.5*k2);          k4 = h*dydx(x0 + h, y + k3);             // Update next value of y          y = y + (1.0/6.0)*(k1 + 2*k2 + 2*k3 + k4);;             // Update next value of x          x0 = x0 + h;      }         return y;  }     // Driver method  int main()  {      float x0 = 0, y = 1, x = 2, h = 0.2;      printf("\nThe value of y at x is : %f",              rungeKutta(x0, y, x, h));      return 0;  }

## Java

 // Java program to implement Runge Kutta method  import java.io.*;  class differential  {      double dydx(double x, double y)      {          return ((x - y) / 2);      }             // Finds value of y for a given x using step size h      // and initial value y0 at x0.      double rungeKutta(double x0, double y0, double x, double h)      {          differential d1 = new differential();          // Count number of iterations using step size or          // step height h          int n = (int)((x - x0) / h);             double k1, k2, k3, k4, k5;             // Iterate for number of iterations          double y = y0;          for (int i = 1; i <= n; i++)           {              // Apply Runge Kutta Formulas to find              // next value of y              k1 = h * (d1.dydx(x0, y));              k2 = h * (d1.dydx(x0 + 0.5 * h, y + 0.5 * k1));              k3 = h * (d1.dydx(x0 + 0.5 * h, y + 0.5 * k2));              k4 = h * (d1.dydx(x0 + h, y + k3));                 // Update next value of y              y = y + (1.0 / 6.0) * (k1 + 2 * k2 + 2 * k3 + k4);                             // Update next value of x              x0 = x0 + h;          }          return y;      }             public static void main(String args[])      {          differential d2 = new differential();          double x0 = 0, y = 1, x = 2, h = 0.2;                     System.out.println("\nThe value of y at x is : "                      + d2.rungeKutta(x0, y, x, h));      }  }     // This code is contributed by Prateek Bhindwar

## Python

 # Python program to implement Runge Kutta method  # A sample differential equation "dy / dx = (x - y)/2"  def dydx(x, y):      return ((x - y)/2)     # Finds value of y for a given x using step size h  # and initial value y0 at x0.  def rungeKutta(x0, y0, x, h):      # Count number of iterations using step size or      # step height h      n = (int)((x - x0)/h)       # Iterate for number of iterations      y = y0      for i in range(1, n + 1):          "Apply Runge Kutta Formulas to find next value of y"         k1 = h * dydx(x0, y)          k2 = h * dydx(x0 + 0.5 * h, y + 0.5 * k1)          k3 = h * dydx(x0 + 0.5 * h, y + 0.5 * k2)          k4 = h * dydx(x0 + h, y + k3)             # Update next value of y          y = y + (1.0 / 6.0)*(k1 + 2 * k2 + 2 * k3 + k4)             # Update next value of x          x0 = x0 + h      return y     # Driver method  x0 = 0 y = 1 x = 2 h = 0.2 print 'The value of y at x is:', rungeKutta(x0, y, x, h)     # This code is contributed by Prateek Bhindwar

## C#

 // C# program to implement Runge  // Kutta method  using System;     class GFG {             static double dydx(double x, double y)      {          return ((x - y) / 2);      }             // Finds value of y for a given x      // using step size h and initial      // value y0 at x0.      static double rungeKutta(double x0,                  double y0, double x, double h)      {                 // Count number of iterations using          // step size or step height h          int n = (int)((x - x0) / h);             double k1, k2, k3, k4;             // Iterate for number of iterations          double y = y0;                     for (int i = 1; i <= n; i++)           {                             // Apply Runge Kutta Formulas              // to find next value of y              k1 = h * (dydx(x0, y));                             k2 = h * (dydx(x0 + 0.5 * h,                               y + 0.5 * k1));                                              k3 = h * (dydx(x0 + 0.5 * h,                              y + 0.5 * k2));                                             k4 = h * (dydx(x0 + h, y + k3));                 // Update next value of y              y = y + (1.0 / 6.0) * (k1 + 2                          * k2 + 2 * k3 + k4);                             // Update next value of x              x0 = x0 + h;          }                     return y;      }             // Driver code      public static void Main()      {                     double x0 = 0, y = 1, x = 2, h = 0.2;                     Console.WriteLine("\nThe value of y"                              + " at x is : "                  + rungeKutta(x0, y, x, h));      }  }     // This code is contributed by Sam007.

## PHP

 

Output:

The value of y at x is : 1.103639

Time Complexity of above solution is O(n) where n is (x-x0)/h.

Some useful resources for detailed examples and more explanation.
http://w3.gazi.edu.tr/~balbasi/mws_gen_ode_txt_runge4th.pdf