/*
*    Modified Euler ---- RUNGE-KUTTA (ORDER 2) ALGORITHM
*
*    TO APPROXIMATE THE SOLUTION TO THE INITIAL VALUE PROBLEM:
*               Y' = F(T,Y), A<=T<=B, Y(A) = ALPHA,
*    AT (N+1) EQUALLY SPACED NUMBERS IN THE INTERVAL [A,B].
*
*    INPUT:   ENDPOINTS A,B; INITIAL CONDITION ALPHA; INTEGER N.
*
*    OUTPUT:  APPROXIMATION W TO Y AT THE (N+1) VALUES OF T.
*/

#include<stdio.h>
#include<math.h>
#include<iostream> 

#define true 1
#define false 0

static   double F(double, double);

using namespace std;

int main()
{
      double A,B,ALPHA,H,T,W,K1,K2,K3,K4;
      int I,N;

      A = 0.0;
      B = 2.0;
      N = 10;

      cout.setf(ios::fixed,ios::floatfield);
      cout.precision(10);

      /* STEP 1 */
      H = (B - A) / N;
      T = A;
      W = 0.5; // initial value

      /* STEP 2 */
      /// NOTE: The "for" loop starts with I = 1. 
      for (I=1; I<=N; I++) 
      {
         /* STEP 3 */
         /* Compute K1, K2 RESP. */
         K1 = F(T, W);
         K2 = F(T + H, W + H*K1);

         /* STEP 4 */
         /* COMPUTE W(I) */
         W = W + H/2.0*(K1 + K2);

         /* COMPUTE T(I) */ 
         T = A + I * H;

         /* STEP 5 */
         cout <<"At time "<< T <<" the solution = "<< W << endl;
      }
      /* STEP 6 */

   return 0;
}
/*  Change function F for a new problem   */
double F(double T, double Y)
{
   double f; 

   f = Y - T*T + 1.0;
   return f;
}