Fix spurious tiny final step for fixed-dt methods

When solving with a fixed-dt method (e.g. `solve(prob, Euler(); dt = 0.1)`),
the accumulated `t + dt + dt + ...` drifts past `tspan[end]` by one ulp,
producing a spurious trailing micro-step.  PR #2869 removed the old
`100eps(tstop)` snap in `fixed_t_for_floatingpoint_error!` that masked this.

Fix: add a floating-point tolerance (`100 * eps(max(|t|, |tstop|))`) to
the `dt < distance_to_tstop` comparison in `modify_dt_for_tstops!`.
When `dt ≈ distance` within rounding the integrator now takes the tstop
branch, and `fixed_t_for_tstop_error!` snaps `t` to the exact tstop
value — eliminating the extra step.

Adds a regression test covering forward, reverse, and non-evenly-
dividing `dt` on `tspan = (0.0, 1.0)`.

Fixes the PositiveIntegrators.jl CI failure noted in
NumericalMathematics/PositiveIntegrators.jl#192.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Author: ChrisRackauckas

lib/OrdinaryDiffEqCore/src/integrators/integrator_utils.jl

@@ -178,11 +178,22 @@ function modify_dt_for_tstops!(integrator)
         tdir_t = integrator.tdir * integrator.t
         tdir_tstop = first_tstop(integrator)
         distance_to_tstop = abs(tdir_tstop - tdir_t)
+        # Floating-point tolerance so that a dt whose nominal value matches
+        # distance_to_tstop to within rounding still triggers the tstop
+        # branch.  Without this, accumulated `t + dt + dt + …` can drift
+        # just past the last tstop and produce a spurious micro-step.
+        tstop_tol = if integrator.t isa AbstractFloat && isfinite(tdir_tstop) &&
+                isfinite(integrator.t)
+            100 * eps(float(max(abs(integrator.t), abs(tdir_tstop)) /
+                            oneunit(integrator.t))) * oneunit(integrator.t)
+        else
+            zero(distance_to_tstop)
+        end
 
         if integrator.opts.adaptive
             original_dt = abs(integrator.dt)
             integrator.dtpropose = integrator.tdir * original_dt
-            if original_dt < distance_to_tstop
+            if original_dt + tstop_tol < distance_to_tstop
                 _set_tstop_flag!(integrator, false)
             else
                 _set_tstop_flag!(
@@ -198,7 +209,7 @@ function modify_dt_for_tstops!(integrator)
         elseif integrator.dtchangeable && !integrator.force_stepfail
             # always try to step! with dtcache, but lower if a tstop
             # however, if force_stepfail then don't set to dtcache, and no tstop worry
-            if abs(integrator.dtcache) < distance_to_tstop
+            if abs(integrator.dtcache) + tstop_tol < distance_to_tstop
                 _set_tstop_flag!(integrator, false)
             else
                 _set_tstop_flag!(

test/interface/ode_tstops_tests.jl

@@ -272,6 +272,29 @@ end
     @test sol.u[end] ≈ 0.0 atol = 1.0e-10
 end
 
+@testset "Fixed-dt: no spurious tiny final step from accumulated drift" begin
+    # Regression test: with fixed dt = 0.1 and tspan = (0.0, 1.0) the
+    # accumulated `t + dt + dt + ...` drifts and used to produce a spurious
+    # 12th step at 0.9999999999999999 followed by 1.0. A tolerance in
+    # modify_dt_for_tstops! ensures the final tstop is hit cleanly.
+    f!(du, u, p, t) = (du .= u; nothing)
+    u0 = [1.0]
+    prob = ODEProblem(f!, u0, (0.0, 1.0))
+    sol = solve(prob, Euler(); dt = 0.1)
+    @test length(sol.t) == 11
+    @test sol.t[end] == 1.0
+
+    # Reverse direction
+    prob_rev = ODEProblem(f!, u0, (1.0, 0.0))
+    sol_rev = solve(prob_rev, Euler(); dt = -0.1)
+    @test length(sol_rev.t) == 11
+    @test sol_rev.t[end] == 0.0
+
+    # dt that does not evenly divide tspan still hits tspan[end] cleanly
+    sol_uneven = solve(prob, Euler(); dt = 0.3)
+    @test sol_uneven.t[end] == 1.0
+end
+
 @testset "d_discontinuities: tprev advanced past discontinuity" begin
     # Directly verify the shift-past invariant using the integrator interface:
     # after stepping past the discontinuity, integrator.tprev should be