Matlab code for RK4 with plot for errors and plots for exact solutions and print all iterations

Below is a MATLAB code implementing the Runge-Kutta 4th order (RK4) method to solve an ordinary differential equation (ODE). The code also plots the errors, compares the numerical solution with the exact solution, and prints all iterations.

### MATLAB Code:

```matlab
% Define the ODE (example: dy/dx = f(x, y) = -2xy, with y(0) = 1)
f = @(x, y) -2*x*y;  % Replace with your ODE
exact_solution = @(x) exp(-x.^2);  % Exact solution for comparison

% Initial conditions
x0 = 0;    % initial x value
y0 = 1;    % initial y value
xf = 2;    % final x value
h = 0.1;   % step size

% Define the number of steps
n_steps = ceil((xf - x0) / h);

% Initialize arrays for x, y, and the exact solution
x = zeros(1, n_steps+1);
y = zeros(1, n_steps+1);
y_exact = zeros(1, n_steps+1);
error = zeros(1, n_steps+1);

% Set initial values
x(1) = x0;
y(1) = y0;
y_exact(1) = exact_solution(x0);
error(1) = abs(y(1) - y_exact(1));

% RK4 method
fprintf('Iteration\t x\t\t y (RK4)\t\t y (Exact)\t Error\n');
fprintf('------------------------------------------------------------\n');
for i = 1:n_steps
    k1 = h * f(x(i), y(i));
    k2 = h * f(x(i) + 0.5*h, y(i) + 0.5*k1);
    k3 = h * f(x(i) + 0.5*h, y(i) + 0.5*k2);
    k4 = h * f(x(i) + h, y(i) + k3);
    
    % Update next value of y
    y(i+1) = y(i) + (1/6) * (k1 + 2*k2 + 2*k3 + k4);
    
    % Update x
    x(i+1) = x(i) + h;
    
    % Exact solution at the new x
    y_exact(i+1) = exact_solution(x(i+1));
    
    % Compute the error
    error(i+1) = abs(y(i+1) - y_exact(i+1));
    
    % Print the current iteration, x, y, exact solution, and error
    fprintf('%d\t\t %.4f\t %.6f\t %.6f\t %.6f\n', i, x(i+1), y(i+1), y_exact(i+1), error(i+1));
end

% Plotting the numerical and exact solutions
figure;
plot(x, y, 'b-', 'LineWidth', 2);
hold on;
plot(x, y_exact, 'r--', 'LineWidth', 2);
legend('RK4 Solution', 'Exact Solution');
title('RK4 vs Exact Solution');
xlabel('x');
ylabel('y');
grid on;

% Plotting the error
figure;
plot(x, error, 'k-', 'LineWidth', 2);
title('Error between RK4 and Exact Solution');
xlabel('x');
ylabel('Error');
grid on;
```

### Explanation:
1. **ODE Definition**: The ODE is defined as `dy/dx = f(x, y)` with an initial condition `y(x0) = y0`.
2. **RK4 Algorithm**: The Runge-Kutta method updates the solution at each step using four slopes (`k1`, `k2`, `k3`, `k4`).
3. **Error Calculation**: The error at each step is calculated as the absolute difference between the RK4 solution and the exact solution.
4. **Plotting**: Two plots are generated:
   - One compares the RK4 numerical solution with the exact solution.
   - Another shows the error as a function of `x`.
5. **Iterations Print**: The script prints each iteration with values of `x`, the RK4 solution `y`, the exact solution, and the error.

Would you like any additional details or further explanation?

---

### Relative Questions:
1. How does the RK4 method compare to other numerical methods for solving ODEs?
2. What are the advantages of using RK4 over Euler's method?
3. How does the choice of step size `h` affect the accuracy of RK4?
4. Can this RK4 code be adapted for systems of ODEs?
5. How would you modify this code to handle stiff differential equations?

### Tip:
When implementing numerical methods like RK4, always check the stability and accuracy by comparing against known exact solutions, if available.

Explore how to implement the Runge-Kutta 4th order method (RK4) in MATLAB to solve ordinary differential equations (ODEs). This guide includes plotting errors, comparing with exact solutions, and printing all iterations. Ideal for undergraduate students in math or engineering.

Math Problem Statement

Solution

Ask a new question for Free

By Image

Math Problem Analysis

Mathematical Concepts

Formulas

Theorems

Suitable Grade Level

Related Recommendation