Differential Equations Quiz: Runge Kutta Method

What this quiz covers

This quiz focuses on Runge Kutta Method, giving you a quick way to practice the rules, question types, and explanations that matter most for Differential Equations.

How to use this quiz

Try each quiz question before looking at the correct answer. Use the explanations to review missed ideas, then come back to similar questions until the pattern feels familiar.

Question 1

1. Each component equation must be solved independently using separate RK4 calculations
2. The four k-vectors are computed simultaneously, with each k-vector having n components (correct answer)
3. The method requires solving a system of nonlinear equations at each step
4. The step size must be the same for all components but the weights can vary

Explanation: For systems, the RK4 method computes vector slopes k₁, k₂, k₃, k₄ where each k-vector has n components corresponding to the n equations. All components are coupled through the vector function f. Choice A incorrectly suggests independence. Choice C describes implicit methods, not RK4. Choice D incorrectly suggests variable weights when the RK4 weights are fixed.

Question 2

1. RK4 requires fewer function evaluations per unit accuracy achieved than RK2 (correct answer)
2. RK4 has better stability properties than RK2 for stiff differential equations
3. RK4 can handle discontinuous right-hand sides while RK2 cannot
4. RK4 automatically adapts step size while RK2 uses fixed step sizes

Explanation: Although RK4 uses 4 function evaluations per step versus 2 for RK2, the higher accuracy (O(h⁴) vs O(h²)) means larger step sizes can be used for the same accuracy, resulting in fewer total function evaluations. Choice B is wrong as both have similar stability regions. Choice C is incorrect since smoothness assumptions apply to both. Choice D confuses the basic methods with adaptive implementations.

Question 3

1. $\epsilon/4$
2. $\epsilon/8$
3. $\epsilon/16$ (correct answer)
4. $\epsilon/32$

Explanation: For a Runge-Kutta method of order $p$, the global truncation error is proportional to $h^p$, written as $O(h^p)$. The classical RK4 method is a fourth-order method, so $p=4$. The error is approximately $Ch^4$ for some constant $C$. When the step size is changed from $h$ to $h/2$, the new error will be approximately $C(h/2)^4 = C(h^4/16) = (Ch^4)/16 = \epsilon/16$. Therefore, halving the step size reduces the global error by a factor of $2^4 = 16$.

Question 4

1. They are slope estimates at the midpoint of the time interval $[t_n, t_{n+1}]$, using preliminary estimates of $y$ at that midpoint. (correct answer)
2. $k_2$ is a slope estimate at the midpoint $t_n + h/2$, while $k_3$ is a slope estimate at the endpoint $t_{n+1}$.
3. They are higher-order derivative estimates used to form a Taylor series expansion of the solution about $t_n$.
4. They are used exclusively to estimate the local truncation error, allowing for adaptive step size control in the algorithm.

Explanation: In the classical RK4 method, $k_1 = f(t_n, y_n)$ is the slope at the beginning of the interval. Then, $k_2 = f(t_n + h/2, y_n + h/2 k_1)$ is a slope estimate at the midpoint in time, $t_n + h/2$, using an Euler step to estimate $y$ at that point. Similarly, $k_3 = f(t_n + h/2, y_n + h/2 k_2)$ is another slope estimate at the same midpoint time, but it uses the more refined slope $k_2$ to estimate $y$. Thus, both $k_2$ and $k_3$ are midpoint slope evaluations designed to capture the curvature of the solution within the interval.

Question 5

1. The stability region for RK4 is smaller, requiring a smaller step size $h$ to maintain stability for a given $\lambda$.
2. The stability region for RK4 is larger, allowing for a larger step size $h$ before the numerical solution becomes unstable. (correct answer)
3. Both methods have the same stability region, which is the interval $(-2, 0)$ on the real axis.
4. The stability of RK4 is independent of the step size $h$, unlike the Forward Euler method which is only conditionally stable.

Explanation: A key advantage of higher-order explicit Runge-Kutta methods is that they have larger regions of absolute stability. For the Forward Euler (RK1) method, the stability condition for $y' = \lambda y$ with real $\lambda < 0$ is $-2 < h\lambda < 0$. For the classical RK4 method, the stability interval on the real axis is approximately $(-2.78, 0)$. Because the stability region for RK4 is larger, it allows for a larger step size $h$ to be used for the same $\lambda$ while maintaining numerical stability, which is a major reason for its widespread use.

Question 6

1. Evaluating $f$ as $(t_n)^2 + (y_n + a_{21} h k_1)$, failing to update the time variable. (correct answer)
2. Using $k_1$ directly as the increment for $y$ instead of $a_{21} h k_1$.
3. Evaluating $f$ as $(t_n + c_2 h)^2 + y_n$, failing to update the state variable.
4. Calculating $k_2$ as $c_2 h (t_n^2 + y_n)$ instead of re-evaluating the function $f$.

Explanation: The function is $f(t,y) = t^2+y$. When calculating $k_2$, the function $f$ must be evaluated at the intermediate point $(t_n + c_2 h, y_n + a_{21} h k_1)$. A common error with non-autonomous equations (where $f$ depends explicitly on $t$) is to update the $y$ argument but forget to update the $t$ argument. The incorrect calculation would be $k_2 = (t_n)^2 + (y_n + a_{21} h k_1)$. The correct calculation must update both arguments: $k_2 = (t_n + c_2 h)^2 + (y_n + a_{21} h k_1)$.

Question 7

1. It compares the result of one step of size $h$ with the result of two steps of size $h/2$ to estimate the local error.
2. It uses an embedded pair of formulas of different orders (e.g., 4th and 5th) to compute two different solution estimates with minimal extra computation. (correct answer)
3. It monitors the magnitude of the slope $f(t,y)$ and reduces the step size whenever the slope becomes too steep.
4. It computes the Taylor series expansion of the solution at each step and reduces $h$ if the higher-order terms are too large.

Explanation: Adaptive methods like RKF45 use a technique called 'embedded pairs'. The method computes two approximations to the solution at each step using formulas of different orders (e.g., a 4th-order result $y_{n+1}^{(4)}$ and a 5th-order result $y_{n+1}^{(5)}$). Crucially, these formulas are designed to share most of their intermediate $k_i$ calculations, making it computationally efficient. The difference, $|y_{n+1}^{(5)} - y_{n+1}^{(4)}|$, serves as an estimate of the local error in the lower-order method. This error estimate is then compared to a user-defined tolerance to decide whether to accept the step, and how to adjust the size of the next step $h$.

Question 8

1. The Trapezoidal Rule
2. The Midpoint Rule
3. Simpson's 1/3 Rule (correct answer)
4. Gaussian Quadrature

Explanation: Simpson's 1/3 rule for approximating $\int_a^b g(x) dx$ is $\frac{b-a}{6}[g(a) + 4g(\frac{a+b}{2}) + g(b)]$. If we consider integrating the slope function $f$, then $k_1$ is the slope at the start ($t_n$), $k_2$ and $k_3$ are two estimates of the slope at the midpoint ($t_n+h/2$), and $k_4$ is an estimate of the slope at the end ($t_{n+1}$). The RK4 formula's weighted average $\frac{1}{6}(k_1 + 2k_2 + 2k_3 + k_4) can be seen as $\frac{1}{6}(k_1 + 4\frac{k_2+k_3}{2} + k_4)$, which has the characteristic $(1, 4, 1)$ weighting of Simpson's rule, applied to the slope estimates at the beginning, midpoint, and end of the interval. This connection highlights why RK4 is so accurate; it is based on a high-order quadrature formula.

Question 9

1. Runge-Kutta methods with an order greater than four are numerically unstable for all non-trivial problems.
2. The global error for methods of order five or higher no longer follows the $O(h^p)$ relationship, making their convergence unpredictable.
3. It is mathematically impossible to derive the coefficients for explicit Runge-Kutta methods with an order greater than seven.
4. The computational cost of additional function evaluations per step yields diminishing returns in accuracy and efficiency for most problems. (correct answer)

Explanation: When evaluating numerical methods for differential equations, you need to balance accuracy against computational efficiency. Higher-order methods aren't always better in practice due to cost-benefit considerations. RK4's dominance stems from its optimal trade-off between accuracy and computational cost. While higher-order methods do provide better theoretical accuracy per step, they require significantly more function evaluations. For example, RK4 uses 4 function evaluations per step, while an eighth-order method might need 11-13 evaluations. This means that for the same computational budget, you could take smaller steps with RK4, often achieving comparable or better accuracy than fewer steps with a higher-order method. Option A is incorrect because higher-order Runge-Kutta methods are not inherently unstable - their stability depends on the problem and step size, just like RK4. Option B misrepresents convergence theory; higher-order methods do follow the $O(h^p)$ relationship where $p$ is the method's order, making them theoretically more accurate. Option C contains a mathematical falsehood - explicit Runge-Kutta methods of order eight and higher do exist and have been successfully derived, though they're complex. The correct answer is D because computational efficiency matters enormously in practice. The additional function evaluations required by higher-order methods create diminishing returns - you spend much more computational time for modest accuracy improvements that could often be achieved more efficiently by simply reducing the step size with RK4. Remember: in numerical analysis, theoretical superiority doesn't always translate to practical advantage. Always consider the computational cost when comparing methods.

Question 10

1. It requires information from future time steps, such as $y_{n+2}$, to compute the solution at $y_{n+1}$, making it a multistep method.
2. The function $f(t,y)$ must be linear with respect to $y$, as non-linear functions make the implicit equations computationally unsolvable.
3. The step size $h$ is determined implicitly by error tolerance, making all implicit methods inherently adaptive with variable steps.
4. The stage values $k_i$ within a single step depend on other stage values from the same step, requiring a root-finding algorithm. (correct answer)

Explanation: When you encounter questions about Runge-Kutta methods, focus on understanding the fundamental difference between explicit and implicit approaches in how they compute intermediate stage values within each time step. The defining characteristic of implicit Runge-Kutta methods is that the stage values $k_i$ are coupled together within the same step. In an explicit method, you can compute each $k_i$ sequentially using previously calculated values. However, in implicit methods, computing $k_i$ requires knowledge of other stage values from the same step that haven't been calculated yet. This creates a system of nonlinear equations that must be solved simultaneously, typically requiring iterative root-finding algorithms like Newton's method. Option A is incorrect because implicit Runge-Kutta methods are still one-step methods—they only use information from the current time step $t_n$ to compute $y_{n+1}$. Multistep methods are an entirely different category that uses multiple previous points. Option B is wrong because implicit RK methods can handle nonlinear functions just fine. While nonlinearity makes the implicit equations more challenging to solve, it doesn't make them "computationally unsolvable"—that's exactly what iterative methods are designed for. Option C confuses the implicit nature of the method with adaptive step sizing. Implicit RK methods can use fixed step sizes, and explicit methods can be adaptive. These are independent characteristics. Remember this key distinction: explicit RK methods compute stage values sequentially, while implicit RK methods require solving coupled systems of equations for all stage values simultaneously.

Question 11

1. As a first-order method ($s=1$) with $b_1 = 1$. (correct answer)
2. As a second-order method ($s=2$) with $b_1 = 1$ and $b_2 = 0$.
3. It cannot be represented in this framework because it does not use intermediate slope estimates.
4. As a first-order method ($s=1$) with $b_1 = h$ and an adjusted step size.

Explanation: The Forward Euler method is the simplest Runge-Kutta method. It uses only one stage ($s=1$), so we only need to calculate $k_1 = f(t_n, y_n)$. The update formula is $y_{n+1} = y_n + h \sum_{i=1}^{1} b_i k_i = y_n + h b_1 k_1$. To match the Euler formula $y_{n+1} = y_n + h f(t_n, y_n)$, we must have $b_1 k_1 = f(t_n, y_n)$. Since $k_1 = f(t_n, y_n)$, this requires $b_1 = 1$. Therefore, the Forward Euler method is an RK method with $s=1$ and $b_1=1$. It is also known as RK1.

Question 12

1. For any order $p$, the minimum number of stages required is always $s=p$.
2. For orders $p \ge 5$, the minimum number of stages $s$ required is strictly greater than the order $p$. (correct answer)
3. For any order $p$, the minimum number of stages required is always $s=p-1$.
4. The number of stages $s$ is unrelated to the order $p$, as order is determined by the coefficients, not the number of evaluations.

Explanation: A common misconception is that an $s$-stage method always has order $p=s$. This is only true for $s=1, 2, 3, 4$. For higher orders, more stages are required than the order of the method. It has been proven that for $p=5$, a minimum of $s=6$ stages are needed. For $p=6$, $s=7$ stages are needed. For $p \ge 5$, it is always the case that $s > p$. This phenomenon is sometimes referred to as the 'Butcher barriers'.

Question 13

1. $\mathbf{f}(t, \mathbf{y}) = \begin{pmatrix} y_2 \\ \cos(t) + 2y_2 + 5y_1 \end{pmatrix}$
2. $\mathbf{f}(t, \mathbf{y}) = \begin{pmatrix} y_1 \\ \cos(t) - 2y_2 - 5y_1 \end{pmatrix}$
3. $\mathbf{f}(t, \mathbf{y}) = \begin{pmatrix} y_2 \\ \cos(t) - 2y_2 - 5y_1 \end{pmatrix}$ (correct answer)
4. $\mathbf{f}(t, \mathbf{y}) = \begin{pmatrix} \cos(t) - 2y_2 - 5y_1 \\ y_2 \end{pmatrix}$

Explanation: First, define the state vector $\mathbf{y} = [y_1, y_2]^T = [x, x']^T$. We need to find $\mathbf{y}' = [y_1', y_2']^T$. The first component is $y_1' = x'$. By our definition, $x' = y_2$. So, $y_1' = y_2$. The second component is $y_2' = (x')' = x''$. From the original ODE, we can solve for $x''$: $x'' = \cos(t) - 2x' - 5x$. Now substitute $y_1$ and $y_2$ back into this expression: $x'' = \cos(t) - 2y_2 - 5y_1$. So, $y_2' = \cos(t) - 2y_2 - 5y_1$. Combining these gives the vector function $\mathbf{f}(t, \mathbf{y}) = [y_1', y_2']^T = [y_2, \cos(t) - 2y_2 - 5y_1]^T$. This corresponds to the matrix form in choice C.

Question 14

1. The order conditions derived from Taylor series expansion must be satisfied through fourth order (correct answer)
2. The sum of each row in the coefficient matrix must equal the corresponding c-value
3. The weights must form a symmetric pattern to ensure error cancellation
4. The intermediate stage points must be equally spaced within the step interval

Explanation: When you encounter questions about Runge-Kutta methods and their order of accuracy, you're dealing with the fundamental theory of how numerical methods achieve their precision. The key insight is that higher-order accuracy requires satisfying increasingly complex mathematical conditions. The classical fourth-order Runge-Kutta method achieves its remarkable accuracy because its Butcher tableau coefficients are specifically chosen to satisfy the order conditions derived from Taylor series expansion through fourth order. These conditions ensure that when you expand both the exact solution and the numerical approximation as Taylor series, they match term-by-term up to the fourth-order terms. This is why option A is correct—it captures the essential mathematical requirement that governs the method's accuracy. Option B describes the row-sum condition ($\sum_{j=1}^{i-1} a_{ij} = c_i$), which is necessary but insufficient for fourth-order accuracy. This condition alone only ensures consistency, not high-order precision. Option C incorrectly suggests that symmetry in the weights is required—the classical RK4 weights (1/6, 1/3, 1/3, 1/6) aren't symmetric, yet the method works perfectly. Option D is false because the intermediate points (at $c_i$ values of 0, 1/2, 1/2, 1) aren't equally spaced—there's no requirement for equal spacing in Runge-Kutta methods. Remember: for any Runge-Kutta method, the order of accuracy is determined by how many Taylor series order conditions the coefficients satisfy. More conditions satisfied equals higher accuracy, but the algebra becomes increasingly complex.

Question 15

1. They used the wrong formula for the weighted average of slopes
2. They used an incorrect step size in the slope calculations
3. They computed $k_3$ using $k_1$ instead of $k_2$
4. They failed to compute $k_4$ before calculating $y_1$ (correct answer)

Explanation: When you encounter RK4 (Runge-Kutta 4th order) problems, remember that this method requires computing four slope estimates in a specific sequence, where each depends on the previous ones. The algorithm cannot skip steps or work out of order. Looking at this student's work, they've correctly computed $k_1 = 0$, $k_2 = 0.005$, and $k_3 = 0.0025$ for the differential equation $\frac{dy}{dx} = xy$. However, they're attempting to calculate the final result $y_1$ using the RK4 formula before computing $k_4$. This creates a fundamental problem: $k_4$ depends on the intermediate value calculated using $k_3$, and without it, the weighted average is incomplete. The RK4 method specifically requires all four slope estimates because each contributes to the final approximation with different weights. Option A is incorrect because their weighted average formula $\frac{h}{6}(k_1 + 2k_2 + 2k_3 + k_4)$ is actually correct. Option B is wrong since their step size $h = 0.1$ appears consistent in their calculations. Option C misidentifies the error—there's no evidence they used $k_1$ instead of $k_2$ when computing $k_3$; the value $k_3 = 0.0025$ is reasonable given the differential equation. The answer is D because you cannot complete RK4 without all four slope calculations. Study tip: In RK4 problems, always verify that all four $k$ values are computed before applying the final weighted average formula. Missing any step breaks the method's accuracy.

Question 16

1. $h\lambda \leq 1$
2. $h\lambda \leq 2$
3. $h\lambda \leq 2.78$ (correct answer)
4. $h\lambda \leq 4$

Explanation: For the test equation dy/dx = -λy, the RK4 method is stable when |1 - hλ + (hλ)²/2 - (hλ)³/6 + (hλ)⁴/24| ≤ 1. The stability boundary occurs at approximately hλ ≈ 2.78. Choice A gives the stability limit for Euler's method. Choice B is too conservative. Choice D exceeds the actual stability boundary and would lead to unstable oscillations.

Question 17

1. 2
2. 4
3. 16
4. 32 (correct answer)

Explanation: The fourth-order Runge-Kutta method has local truncation error O(h⁵). When step size h is halved, the error becomes O((h/2)⁵) = O(h⁵/32), so the error decreases by a factor of 32. Choice A assumes first-order method, Choice B assumes second-order, and Choice C assumes fourth-order global error rather than local truncation error.

Question 18

1. To minimize the absolute value of the local truncation error coefficient
2. To ensure the method reduces to Simpson's rule for integration when $f$ is independent of $y$ (correct answer)
3. To guarantee stability for all differential equations with bounded derivatives
4. To make the method self-starting without requiring additional initial conditions

Explanation: The specific weights 1/6, 2/6, 2/6, 1/6 ensure that when f(x,y) = g(x) (independent of y), the RK4 method becomes Simpson's rule for numerical integration, achieving fourth-order accuracy. Choice A is incorrect as these weights don't minimize error coefficients. Choice C is wrong as no explicit method is unconditionally stable. Choice D is irrelevant since all one-step methods are self-starting.

Question 19

1. 2 times more function evaluations per step
2. 3 times more function evaluations per step
3. 4 times more function evaluations per step (correct answer)
4. 5 times more function evaluations per step

Explanation: The fourth-order Runge-Kutta method requires 4 function evaluations per step (k₁, k₂, k₃, k₄) while Euler's method requires only 1 function evaluation per step. Therefore, RK4 requires 4 times more function evaluations. The other choices reflect confusion about the number of slopes calculated or misunderstanding of what constitutes a function evaluation.

Question 20

1. $(x_n + \frac{h}{2}, y_n + \frac{h}{2}k_1)$
2. $(x_n + \frac{h}{2}, y_n + \frac{h}{2}k_2)$ (correct answer)
3. $(x_n + h, y_n + hk_2)$
4. $(x_n + h, y_n + hk_3)$

Explanation: In the fourth-order Runge-Kutta method, k₃ = f(x_n + h/2, y_n + (h/2)k₂). This uses the midpoint x-coordinate and the y-value adjusted by half a step using the slope k₂. Choice A incorrectly uses k₁ instead of k₂. Choice C uses the full step h in x but should use h/2. Choice D is circular since k₃ cannot be calculated using itself.