Fix stepping past domain error for NoiseGrid when dt doesn't evenly divide time span

When solving a NoiseProblem with a NoiseGrid where the dt doesn't evenly divide
the time span, floating point errors could cause the solver to report "Stepped past
the defined domain for the NoiseGrid".

This occurred because:
1. After many steps with dt=0.01 over tspan [0.0, 10.0], floating point errors
   accumulate and W.curt ends up at ~9.9999999999 instead of exactly 10.0
2. The step_setup flag gets set to false when W.curt + dt > W.t[end]
3. The while loop continues because W.curt < prob.tspan[2] (floating point)
4. accept_step! errors because step_setup is false

The fix adds two checks in the solve loop:
1. If we're essentially at the end (within floating point tolerance), exit
2. If the next step would overshoot, take a partial final step to reach exactly
   the end, resetting step_setup if necessary

Fixes #136

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: claude

src/solve.jl

@@ -44,7 +44,23 @@ function DiffEqBase.__solve(
     setup_next_step!(W, nothing, nothing)
     tType = typeof(W.curt)
     while W.curt < prob.tspan[2]
-        if tType <: AbstractFloat && abs(W.curt + dt - prob.tspan[2]) < 100 * eps(dt) # Correct the end due to floating point error
+        # Check if we're essentially at the end due to floating point error
+        if tType <: AbstractFloat &&
+                abs(W.curt - prob.tspan[2]) < 100 * eps(typeof(W.curt)(prob.tspan[2]))
+            W.curt = prob.tspan[2]
+            break
+        end
+        # Check if taking the full step would overshoot the end
+        if W.curt + dt > prob.tspan[2]
+            # Take a final partial step to reach exactly the end
+            final_dt = prob.tspan[2] - W.curt
+            # For NoiseGrid, we need to reset step_setup if it was set to false
+            if hasproperty(W, :step_setup) && !W.step_setup
+                W.step_setup = true
+            end
+            accept_step!(W, final_dt, nothing, nothing)
+            W.curt = prob.tspan[2]
+        elseif tType <: AbstractFloat && abs(W.curt + dt - prob.tspan[2]) < 100 * eps(dt) # Correct the end due to floating point error
             dt = prob.tspan[2] - W.curt
             accept_step!(W, dt, nothing, nothing)
             W.curt = prob.tspan[2]

test/noise_grid.jl

@@ -47,4 +47,33 @@
     W = NoiseGrid(t, brownian_values)
     prob_rational = NoiseProblem(W, (0, 1))
     sol = solve(prob_rational; dt = 1 // 10)
+
+    # Test for issue #136: stepping past domain with dt that doesn't evenly divide the time span
+    # When dt doesn't evenly divide (tspan[2] - tspan[1]), floating point errors can cause
+    # the solver to think it needs to step past the domain boundary
+    @testset "Issue #136 - stepping past domain" begin
+        # Original issue case: dt=0.01 with grid step 0.1
+        tgrid = 0.0:0.1:10.0
+        brownian_noise = [[0.0, 0.0] for _ in 1:length(tgrid)]
+        W = NoiseGrid(collect(tgrid), brownian_noise)
+        prob = NoiseProblem(W, (tgrid[begin], tgrid[end]))
+        sol = solve(prob; dt = 0.01)
+        @test sol.curt == 10.0
+
+        # Case where dt does not evenly divide the time span
+        tgrid2 = 0.0:0.1:1.0
+        brownian_noise2 = [[0.0, 0.0] for _ in 1:length(tgrid2)]
+        W2 = NoiseGrid(collect(tgrid2), brownian_noise2)
+        prob2 = NoiseProblem(W2, (0.0, 1.0))
+        sol2 = solve(prob2; dt = 0.03)
+        @test sol2.curt == 1.0
+
+        # Case with scalar noise
+        tgrid3 = 0.0:0.1:10.0
+        brownian_noise3 = [0.0 for _ in 1:length(tgrid3)]
+        W3 = NoiseGrid(collect(tgrid3), brownian_noise3)
+        prob3 = NoiseProblem(W3, (tgrid3[begin], tgrid3[end]))
+        sol3 = solve(prob3; dt = 0.01)
+        @test sol3.curt == 10.0
+    end
 end