Debug a Wrong Result with a Plot

A plot can reveal where a numerical result departs from an expectation. It cannot tell us why. We still need the source values, a checked reference, and a small calculation that can separate observation from explanation.

The recurring raw table has three observations and two sensors:

Every value should be transformed by the rule:

calibrated = raw × 0.5 + 1.0

The expected table is therefore:

[[ 2.0,  6.0],
 [ 3.0,  8.0],
 [ 4.0, 10.0]]

This visible calculation is our reference. It gives the plot something precise to compare against.

Compare the Reference with the Computed Values

Suppose one branch of the program applies -1.0 instead of +1.0 to sensor 1 at observation 2. The program still runs:

expected sensor 1: [ 6.  8. 10.]
computed sensor 1: [ 6.  6. 10.]
difference: [ 0. -2.  0.]

Plot the expected and computed sensor series on the same axes. The same observation positions, units, and limits keep their coordinates comparable:

The plot supports one observation: the computed sensor-1 point is 2 °C below the reference at observation 2, while the other displayed points agree. That sentence reports what the evidence shows. It does not yet claim a cause.

Test a Hypothesis with the Smallest Failing Value

One possible explanation is that the offset sign is wrong in the operation that produced this point. Test that idea with the source value 14.0:

expected: 14.0 × 0.5 + 1.0 = 8.0
computed: 14.0 × 0.5 - 1.0 = 6.0

The small test reproduces the exact two-degree difference. It does not prove that no other defect exists, but it supports this hypothesis and points to one operation to inspect.

The difference table also identifies the first divergence:

[[1 1]]

Array position [1, 1] means the second observation and second sensor because NumPy positions begin at zero. Trace that position backward: plotted point → computed[1, 1] → transformation branch → raw[1, 1]. Stop at the first stage where the computed value differs from its checked reference.

Repair, Then Verify Twice

Repair the wrong branch by using the same +1.0 offset as the stated transformation:

computed[1, 1] = raw[1, 1] * 0.5 + 1.0

Numerical checks should pass after the repair:

Then rebuild the comparison plot. The expected and computed points should overlap, and the difference should lie on zero. The numerical checks enforce the result on later runs; the plot confirms that the repaired behavior also looks as expected across the complete series.

Do not repair only the picture. Changing a limit, hiding the reference, or removing the unusual point can make the figure look calmer while leaving the wrong value untouched. Repair the first divergent computation, rerun the full pipeline, then repeat both numerical and visual checks.