Why Table Indexing Matters
Euler's method is often presented as a short recurrence formula, but a numerical table can still go wrong even when the formula itself is familiar. Common sources of error include counting rows as if they were steps, advancing the time index incorrectly, evaluating a slope at the wrong time, or stopping just before the requested endpoint.
These mistakes can be hard to spot by looking only at the final numerical value. A dependable check follows the table row by row: identify the time and approximation in each row, state the step used for that update, and verify that the slope comes from the current row.
Rows, Nodes, and Steps
Consider an initial-value problem \(y'=f(t,y)\) with initial data \(y(t_0)=y_0\). A table row records one time node and the numerical approximation at that time. The first row is indexed by \(0\), so it contains \(t_0\) and \(y_0\). Each update takes the values in one row and produces the values in the next row.
For a fixed positive step size \(h\), forward Euler is defined by
The value \(f(t_n,y_n)\) is the slope used for the update leaving row \(n\). It is not evaluated at the destination time \(t_{n+1}\). The new approximation \(y_{n+1}\) is then used when calculating the slope for the next update.
How Many Fixed Steps Reach the Endpoint?
Suppose the requested interval is \([a,b]\), with \(a<b\), and every step has the same size \(h>0\). After \(N\) updates, the time is \(a+Nh\). Therefore, the endpoint \(b\) is reached exactly by a fixed-step table precisely when there is a positive integer \(N\) such that \(b-a=Nh\).
This quotient must be an integer. If it is not, repeating the fixed update until the time first exceeds \(b\) will overshoot the endpoint. Stopping before that update will leave the endpoint out of the table. A table with a shortened final step is a different, variable-step table and must be checked using that shorter step on its last update.
Worked Example: Counting Rows and Checking a Fixed-Step Table
Worked Example: Counting Rows and Checking a Fixed-Step Table
Use forward Euler for \(y'=t+y\), \(y(0)=1\), on \([0,1]\) with \(h=0.2\). First, the required number of steps is \((1-0)/0.2=5\), an integer. The table should therefore contain six rows, indexed from \(0\) through \(5\).
Row \(0\) has \(t_0=0\) and \(y_0=1\). Its slope is \(f(0,1)=0+1=1\), so \(t_1=0+0.2=0.2\) and \(y_1=1+0.2(1)=1.2\).
At row \(1\), the slope is \(f(0.2,1.2)=0.2+1.2=1.4\). Thus \(t_2=0.2+0.2=0.4\) and \(y_2=1.2+0.2(1.4)=1.48\).
At row \(2\), the slope is \(f(0.4,1.48)=0.4+1.48=1.88\). Thus \(t_3=0.4+0.2=0.6\) and \(y_3=1.48+0.2(1.88)=1.856\).
At row \(3\), the slope is \(f(0.6,1.856)=0.6+1.856=2.456\). Thus \(t_4=0.6+0.2=0.8\) and \(y_4=1.856+0.2(2.456)=2.3472\).
At row \(4\), the slope is \(f(0.8,2.3472)=0.8+2.3472=3.1472\). Thus \(t_5=0.8+0.2=1\) and \(y_5=2.3472+0.2(3.1472)=2.97664\).
The completed index check is \(t_n=0.2n\) for \(n=0,1,2,3,4,5\), giving \(0,0.2,0.4,0.6,0.8,1\). Each listed value also satisfies the row-to-row update using the slope in the preceding row. There are five updates, six rows, and the final row is at the requested endpoint \(t=1\).
Proof of the Fixed-Step Endpoint Count
The endpoint test follows directly from the time recurrence. Starting at \(t_0=a\), each fixed-size update adds \(h\). Applying the recurrence repeatedly gives \(t_1=a+h\), \(t_2=a+2h\), and, after \(N\) updates, \(t_N=a+Nh\). Consequently \(t_N=b\) exactly when \(a+Nh=b\), or equivalently \(N=(b-a)/h\). Since a number of updates must be a positive integer, a fixed step reaches \(b\) exactly if and only if \((b-a)/h\) is a positive integer. This proves the test and explains why a noninteger quotient signals that the fixed grid does not land on the requested endpoint.
Variable Step Sizes and a Shortened Final Step
Sometimes the chosen step size does not divide the interval, but the table is still required to include the endpoint. One option is to use full steps and then take a shorter final step. To avoid applying the full step size incorrectly, define the step used at each update by \(h_n=t_{n+1}-t_n\). The Euler formula for that update is then
The shortened step is not an exception to Euler's method: it uses the same rule with its own value of \(h_n\). The audit must check both the time change and the approximation change with that same \(h_n\) on every row-to-row update.
Worked Example: Including the Endpoint with a Shortened Step
Worked Example: Including the Endpoint with a Shortened Step
Use Euler's method for \(y'=t\), \(y(0)=0\), on \([0,1]\). Take steps of size \(0.3\) while possible, then shorten the last step to land at \(1\).
The first update uses \(h_0=0.3\). Since \(f(0,0)=0\), it gives \(t_1=0+0.3=0.3\) and \(y_1=0+0.3(0)=0\).
The second update uses \(h_1=0.3\). Its slope is \(f(0.3,0)=0.3\), so \(t_2=0.3+0.3=0.6\) and \(y_2=0+0.3(0.3)=0.09\).
The third update uses \(h_2=0.3\). Its slope is \(f(0.6,0.09)=0.6\), so \(t_3=0.6+0.3=0.9\) and \(y_3=0.09+0.3(0.6)=0.27\).
The remaining distance to the endpoint is \(1-0.9=0.1\), so the final update uses \(h_3=0.1\). Its slope is \(f(0.9,0.27)=0.9\), giving \(t_4=0.9+0.1=1\) and \(y_4=0.27+0.1(0.9)=0.36\).
The time increments are \(0.3,0.3,0.3,0.1\), which sum to \(1\), and the table has four updates and five rows. Using \(0.3\) for the last update would instead produce \(t_4=1.2\) and \(y_4=0.27+0.3(0.9)=0.54\). Those values fail the endpoint requirement: the final time would overshoot \(1\). The variable-step audit confirms the correct last row uses \(h_3=0.1\) in both updates.
Check the Slope at the Current Row
An indexing error can also cause a slope-time error. In forward Euler, the update from row \(n\) uses \(f(t_n,y_n)\). Substituting \(t_{n+1}\) in place of \(t_n\) changes the calculation; it is not the forward Euler update. A quick way to catch this is to label the slope explicitly as the slope leaving the current row before calculating the next row.
Worked Example: Correcting a Slope-Evaluation-Time Error
Worked Example: Correcting a Slope-Evaluation-Time Error
Use forward Euler for \(y'=2t-y\), \(y(0)=1\), with \(h=0.5\) through \(t=1\). The endpoint requires \(1/0.5=2\) updates, so there must be three rows.
At row \(0\), \(t_0=0\) and \(y_0=1\). The correct slope is \(f(t_0,y_0)=f(0,1)=2(0)-1=-1\). Thus \(t_1=0+0.5=0.5\), and \(y_1=1+0.5(-1)=0.5\).
At row \(1\), the correct slope is \(f(t_1,y_1)=f(0.5,0.5)=2(0.5)-0.5=0.5\). Thus \(t_2=0.5+0.5=1\), and \(y_2=0.5+0.5(0.5)=0.75\).
To see the error clearly, suppose the first slope is incorrectly evaluated at \(t_1\) while still using the old approximation \(y_0\). This gives \(f(0.5,1)=2(0.5)-1=0\), and the incorrect update produces \(y_1=1+0.5(0)=1\), rather than \(0.5\). The error is the time index: the slope leaving row \(0\) must be \(f(t_0,y_0)=f(0,1)\), not \(f(t_1,y_0)\).
Checking the correct table, the first value change is \(0.5(-1)=-0.5\), so \(y_1=1-0.5=0.5\). The second is \(0.5(0.5)=0.25\), so \(y_2=0.5+0.25=0.75\). The time sequence \(0,0.5,1\) confirms two updates and includes the endpoint.
A Practical Audit for Euler Tables
For a fixed-step table, verify that the time increases by the same \(h\) on every update and that the value changes by \(h f(t_n,y_n)\). For a variable-step table, use \(h_n=t_{n+1}-t_n\) at each row and verify \(y_{n+1}=y_n+h_n f(t_n,y_n)\). Then check the row indices, the number of updates, and the requested endpoint separately.
Record the starting index and pair each row's time \(t_n\) with its approximation \(y_n\).
Count transitions between rows. \(N+1\) rows correspond to \(N\) updates.
For a fixed-step table, verify \(t_{n+1}=t_n+h\). For variable steps, calculate \(h_n=t_{n+1}-t_n\) for each update.
Use the slope \(f(t_n,y_n)\) at the current row and multiply it by the step used on that update.
Compare the last listed time with the requested endpoint. Do not assume that the intended number of steps guarantees the endpoint is present.
Common Mistakes and Their Corrections
- Counting rows as steps. A table with rows \(0\) through \(N\) has \(N+1\) rows but only \(N\) updates. Count the gaps between rows.
- Assuming any step size lands exactly on the endpoint. For a fixed step \(h\), check whether \((b-a)/h\) is an integer before claiming that the endpoint is reached.
- Using the full step on a shortened final update. If the final interval is shorter, calculate \(h_n=t_{n+1}-t_n\) and use that value in both the time and approximation updates.
- Evaluating the slope at the next time. Forward Euler uses \(f(t_n,y_n)\), not \(f(t_{n+1},y_n)\) or \(f(t_{n+1},y_{n+1})\).
- Checking only the final approximation. A plausible final number does not establish that the intermediate rows or endpoint are correct. Verify each transition.
These checks matter because a table is a chain of dependent calculations: an incorrect index or update can affect every later row. The audit does not tell us whether an approximation is sufficiently accurate for a particular application; it checks the more basic question of whether the table actually implements the stated Euler steps and reaches the intended time.
Check Your Understanding
Use the definitions and audit rules above to answer these questions.
- A fixed-step table has six rows indexed \(0\) through \(5\). How many Euler updates does it contain?
- For a fixed step \(h=0.25\) on \([0,1]\), how many updates are required to reach the endpoint exactly?
- A variable-step table goes from \(t_n=2.4\) to \(t_{n+1}=2.5\). What step size must be used in the value update for that row?
- In forward Euler, which time and approximation are used to calculate the slope for the update from row \(n\) to row \(n+1\)?
- A fixed step \(h=0.3\) is used on \([0,1]\). Does repeating that step land exactly at \(1\)? Explain using the endpoint test.
