Predictor-Corrector or Modified-Euler method for solving Differential equation - GeeksforGeeks

28 Dec, 2021
For a given differential equation with initial condition find the approximate solution using Predictor-Corrector method.Predictor-Corrector Method : The predictor-corrector method is also known as Modified-Euler method. In the Euler method, the tangent is drawn at a point and slope is calculated for a given step size. Thus this method works best with linear functions, but for other cases, there remains a truncation error. To solve this problem the Modified Euler method is introduced. In this method instead of a point, the arithmetic average of the slope over an interval is used.Thus in the Predictor-Corrector method for each step the predicted value of is calculated first using Euler’s method and then the slopes at the points and is calculated and the arithmetic average of these slopes are added to to calculate the corrected value of .So,  
Step – 1 : First the value is predicted for a step(here t+1) : , here h is step size for each increment
 
Step – 2 : Then the predicted value is corrected : 
 
Step – 3 : The incrementation is done : 
 
Step – 4 : Check for continuation, if then go to step – 1.
 
Step – 5 : Terminate the process.
As, in this method, the average slope is used, so the error is reduced significantly. Also, we can repeat the process of correction for convergence. Thus at every step, we are reducing the error thus by improving the value of y.Examples:  
Input : eq = , y(0) = 0.5, step size(h) = 0.2 To find: y(1) Output: y(1) = 2.18147Explanation: The final value of y at x = 1 is y=2.18147  
Implementation: Here we are considering the differential equation:  
C++
Java
Python3
C#
PHP
Javascript
// C++ code for solving the differential equation// using Predictor-Corrector or Modified-Euler method// with the given conditions, y(0) = 0.5, step size(h) = 0.2// to find y(1) #include <bits/stdc++.h>using namespace std; // consider the differential equation// for a given x and y, return vdouble f(double x, double y){    double v = y - 2 * x * x + 1;    return v;} // predicts the next value for a given (x, y)// and step size h using Euler methoddouble predict(double x, double y, double h){    // value of next y(predicted) is returned    double y1p = y + h * f(x, y);    return y1p;} // corrects the predicted value// using Modified Euler methoddouble correct(double x, double y,               double x1, double y1,               double h){    // (x, y) are of previous step    // and x1 is the increased x for next step    // and y1 is predicted y for next step    double e = 0.00001;    double y1c = y1;     do {        y1 = y1c;        y1c = y + 0.5 * h * (f(x, y) + f(x1, y1));    } while (fabs(y1c - y1) > e);     // every iteration is correcting the value    // of y using average slope    return y1c;} void printFinalValues(double x, double xn,                      double y, double h){     while (x < xn) {        double x1 = x + h;        double y1p = predict(x, y, h);        double y1c = correct(x, y, x1, y1p, h);        x = x1;        y = y1c;    }     // at every iteration first the value    // of for next step is first predicted    // and then corrected.    cout << "The final value of y at x = "         << x << " is : " << y << endl;} int main(){    // here x and y are the initial    // given condition, so x=0 and y=0.5    double x = 0, y = 0.5;     // final value of x for which y is needed    double xn = 1;     // step size    double h = 0.2;     printFinalValues(x, xn, y, h);     return 0;}
// Java code for solving the differential// equation using Predictor-Corrector// or Modified-Euler method with the// given conditions, y(0) = 0.5, step// size(h) = 0.2 to find y(1)import java.text.*; class GFG{     // consider the differential equation// for a given x and y, return vstatic double f(double x, double y){    double v = y - 2 * x * x + 1;    return v;} // predicts the next value for a given (x, y)// and step size h using Euler methodstatic double predict(double x, double y, double h){    // value of next y(predicted) is returned    double y1p = y + h * f(x, y);    return y1p;} // corrects the predicted value// using Modified Euler methodstatic double correct(double x, double y,                    double x1, double y1,                    double h){    // (x, y) are of previous step    // and x1 is the increased x for next step    // and y1 is predicted y for next step    double e = 0.00001;    double y1c = y1;     do    {        y1 = y1c;        y1c = y + 0.5 * h * (f(x, y) + f(x1, y1));    }    while (Math.abs(y1c - y1) > e);     // every iteration is correcting the value    // of y using average slope    return y1c;} static void printFinalValues(double x, double xn,                    double y, double h){     while (x < xn)    {        double x1 = x + h;        double y1p = predict(x, y, h);        double y1c = correct(x, y, x1, y1p, h);        x = x1;        y = y1c;    }     // at every iteration first the value    // of for next step is first predicted    // and then corrected.    DecimalFormat df = new DecimalFormat("#.#####");    System.out.println("The final value of y at x = "+                        x + " is : "+df.format(y));} // Driver codepublic static void main (String[] args){    // here x and y are the initial    // given condition, so x=0 and y=0.5    double x = 0, y = 0.5;     // final value of x for which y is needed    double xn = 1;     // step size    double h = 0.2;     printFinalValues(x, xn, y, h);}} // This code is contributed by mits
# Python3 code for solving the differential equation# using Predictor-Corrector or Modified-Euler method# with the given conditions, y(0) = 0.5, step size(h) = 0.2# to find y(1) # consider the differential equation# for a given x and y, return vdef f(x, y):    v = y - 2 * x * x + 1;    return v; # predicts the next value for a given (x, y)# and step size h using Euler methoddef predict(x, y, h):         # value of next y(predicted) is returned    y1p = y + h * f(x, y);    return y1p; # corrects the predicted value# using Modified Euler methoddef correct(x, y, x1, y1, h):         # (x, y) are of previous step    # and x1 is the increased x for next step    # and y1 is predicted y for next step    e = 0.00001;    y1c = y1;     while (abs(y1c - y1) > e + 1):        y1 = y1c;        y1c = y + 0.5 * h * (f(x, y) + f(x1, y1));     # every iteration is correcting the value    # of y using average slope    return y1c; def printFinalValues(x, xn, y, h):    while (x < xn):        x1 = x + h;        y1p = predict(x, y, h);        y1c = correct(x, y, x1, y1p, h);        x = x1;        y = y1c;     # at every iteration first the value    # of for next step is first predicted    # and then corrected.    print("The final value of y at x =",                     int(x), "is :", y); # Driver Codeif __name__ == '__main__':         # here x and y are the initial    # given condition, so x=0 and y=0.5    x = 0; y = 0.5;     # final value of x for which y is needed    xn = 1;     # step size    h = 0.2;     printFinalValues(x, xn, y, h); # This code is contributed by Rajput-Ji
// C# code for solving the differential// equation using Predictor-Corrector// or Modified-Euler method with the// given conditions, y(0) = 0.5, step// size(h) = 0.2 to find y(1)using System; class GFG{     // consider the differential equation// for a given x and y, return vstatic double f(double x, double y){    double v = y - 2 * x * x + 1;    return v;} // predicts the next value for a given (x, y)// and step size h using Euler methodstatic double predict(double x, double y, double h){    // value of next y(predicted) is returned    double y1p = y + h * f(x, y);    return y1p;} // corrects the predicted value// using Modified Euler methodstatic double correct(double x, double y,            double x1, double y1,            double h){    // (x, y) are of previous step    // and x1 is the increased x for next step    // and y1 is predicted y for next step    double e = 0.00001;    double y1c = y1;     do    {        y1 = y1c;        y1c = y + 0.5 * h * (f(x, y) + f(x1, y1));    }    while (Math.Abs(y1c - y1) > e);     // every iteration is correcting the value    // of y using average slope    return y1c;} static void printFinalValues(double x, double xn,                    double y, double h){     while (x < xn)    {        double x1 = x + h;        double y1p = predict(x, y, h);        double y1c = correct(x, y, x1, y1p, h);        x = x1;        y = y1c;    }     // at every iteration first the value    // of for next step is first predicted    // and then corrected.    Console.WriteLine("The final value of y at x = "+                        x + " is : " + Math.Round(y, 5));} // Driver codestatic void Main(){    // here x and y are the initial    // given condition, so x=0 and y=0.5    double x = 0, y = 0.5;     // final value of x for which y is needed    double xn = 1;     // step size    double h = 0.2;     printFinalValues(x, xn, y, h);}} // This code is contributed by mits
<?php// PHP code for solving the differential equation// using Predictor-Corrector or Modified-Euler// method with the given conditions, y(0) = 0.5,// step size(h) = 0.2 to find y(1) // consider the differential equation// for a given x and y, return vfunction f($x, $y){    $v = $y - 2 * $x * $x + 1;    return $v;} // predicts the next value for a given (x, y)// and step size h using Euler methodfunction predict($x, $y, $h){    // value of next y(predicted) is returned    $y1p = $y + $h * f($x, $y);    return $y1p;} // corrects the predicted value// using Modified Euler methodfunction correct($x, $y, $x1, $y1, $h){         // (x, y) are of previous step and    // x1 is the increased x for next step    // and y1 is predicted y for next step    $e = 0.00001;    $y1c = $y1;     do    {        $y1 = $y1c;        $y1c = $y + 0.5 * $h * (f($x, $y) +                                f($x1, $y1));    } while (abs($y1c - $y1) > $e);     // every iteration is correcting the    // value of y using average slope    return $y1c;} function printFinalValues($x, $xn, $y, $h){    while ($x < $xn)    {        $x1 = $x + $h;        $y1p = predict($x, $y, $h);        $y1c = correct($x, $y, $x1, $y1p, $h);        $x = $x1;        $y = $y1c;    }     // at every iteration first the value    // of for next step is first predicted    // and then corrected.    echo "The final value of y at x = " . $x .               " is : " . round($y, 5) . "\n";}     // here x and y are the initial    // given condition, so x=0 and y=0.5    $x = 0;    $y = 0.5;     // final value of x for which y is needed    $xn = 1;     // step size    $h = 0.2;     printFinalValues($x, $xn, $y, $h); // This code is contributed by mits?>
<script>// javascript code for solving the differential// equation using Predictor-Corrector// or Modified-Euler method with the// given conditions, y(0) = 0.5, step// size(h) = 0.2 to find y(1)     // consider the differential equation    // for a given x and y, return v    function f(x , y) {        var v = y - 2 * x * x + 1;        return v;    }     // predicts the next value for a given (x, y)    // and step size h using Euler method    function predict(x , y , h) {        // value of next y(predicted) is returned        var y1p = y + h * f(x, y);        return y1p;    }     // corrects the predicted value    // using Modified Euler method    function correct(x , y , x1 , y1 , h) {        // (x, y) are of previous step        // and x1 is the increased x for next step        // and y1 is predicted y for next step        var e = 0.00001;        var y1c = y1;         do {            y1 = y1c;            y1c = y + 0.5 * h * (f(x, y) + f(x1, y1));        } while (Math.abs(y1c - y1) > e);         // every iteration is correcting the value        // of y using average slope        return y1c;    }     function printFinalValues(x , xn , y , h) {         while (x < xn) {            var x1 = x + h;            var y1p = predict(x, y, h);            var y1c = correct(x, y, x1, y1p, h);            x = x1;            y = y1c;        }         // at every iteration first the value        // of for next step is first predicted        // and then corrected.         document.write("The final value of y at x = " + x + " is : " + y.toFixed(5));    }     // Driver code             // here x and y are the initial        // given condition, so x=0 and y=0.5        var x = 0, y = 0.5;         // final value of x for which y is needed        var xn = 1;         // step size        var h = 0.2;        printFinalValues(x, xn, y, h); // This code is contributed by Rajput-Ji</script>
The final value of y at x = 1 is : 2.18147
 
Mithun Kumar
Rajput-Ji
Algebra
Mathematical
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Merge two sorted arrays
Modulo Operator (%) in C/C++ with Examples
Program to find sum of elements in a given array
Program for factorial of a number
Operators in C / C++
Euclidean algorithms (Basic and Extended)
The Knight's tour problem | Backtracking-1
Efficient program to print all prime factors of a given number
Find minimum number of coins that make a given value
Minimum number of jumps to reach end