## Runge-Kutta 3/8 Method

The 3/8 method is a fourth order Runge-Kutta method for approximating the solution of the initial value problem*y'(x) = f(x,y)*;

*y(x*which evaluates the integrand,

_{0}) = y_{0}*f(x,y)*, four times per step. For step

*i+1*,

*y*,

_{i+1}= y_{i}+ 1/8 ( k_{1}+ 3 k_{2}+ 3 k_{3}+ k_{4})where

*k*,

_{1}= h f(x_{i}, y_{i})*k*,

_{2}= h f(x_{i}+ h / 3, y_{i}+ k_{1}/ 3 )*k*,

_{3}= h f(x_{i}+ 2 h / 3, y_{i}- k_{1}/ 3 + k_{2})*k*,

_{4}= h f(x_{i}+ h, y_{i}+ k_{1}- k_{2}+ k_{3})and

*x*.

_{i}= x_{0}+ i hThis method is a fourth order procedure for which Richardson extrapolation can be used.

### Function List

- double Runge_Kutta_3_8( double (*f)(double, double), double y0, double x0, double h, int number_of_steps )

This function uses the 3/8 method to return the estimate of the solution of the initial value problem,*y' = f(x,y); y(x0) = y0*, at*x = x0 + h * n*, where*h*is the step size and*n*is*number_of_steps*.

- double Runge_Kutta_3_8_Richardson( double (*f)(double, double), double y0, double x0, double h, int number_of_steps, int richardson_columns )

This function uses the 3/8 method together with Richardson extrapolation to the limit to return the estimate of the solution of the initial value problem,*y' = f(x,y); y(x0) = y0*, at*x = x0 + h * n*, where*h*is the step size and*n*is*number_of_steps*. The argument*richardson_columns*is the number of step size halving + 1 used in Richardson extrapolation so that if*richardson_columns = 1*then no extrapolation to the limit is performed.

- void Runge_Kutta_3_8_Integral_Curve( double (*f)(double, double), double y[ ], double x0, double h, int number_of_steps_per_interval, int number_of_intervals )

This function uses 3/8 method to estimate the solution of the initial value problem,*y' = f(x,y); y(x0) = y0*, at*x = x0 + h * n * m*, where*h*is the step size and*n*is the interval number*0 ≤ n ≤ number_of_intervals*, and*m*is the*number_of_steps_per_interval*. The values are return in the array*y[ ]*i.e.*y[n] = y(x0 + h * m * n)*, where*m, n*are as above.

- void Runge_Kutta_3_8_Richardson_Integral_Curve( double (*f)(double, double), double y[ ], double x0, double h, int number_of_steps_per_interval, int number_of_intervals, int richardson_columns )

This function uses the 3/8 method together with Richardson extrapolation to the limit to estimate the solution of the initial value problem,*y' = f(x,y); y(x0) = y0*, at*x = x0 + h * n * m*, where*h*is the step size and*n*is the interval number*0 ≤ n ≤ number_of_intervals*, and*m*is the*number_of_steps_per_interval*. The values are return in the array*y[ ]*i.e.*y[n] = y(x0 + h * m * n)*, where*m, n*are as above. The argument*richardson_columns*is the number of step size halving + 1 used in Richardson extrapolation so that if*richardson_columns = 1*then no extrapolation to the limit is performed.

*C* Source Code

- The file, runge_kutta_3_8.c, contains versions of Runge_Kutta_3_8( ), Runge_Kutta_3_8_Richardson( ), Runge_Kutta_3_8_Integral_Curve( ), and Runge_Kutta_3_8_Richardson_Integral_Curve( ) written in
*C*.