Make adaptive time updates exact at large |t| (fixes #567; stacked on #561)

[ChrisRackauckas-Claude]

Ignore this draft until reviewed by @ChrisRackauckas.

Stacked on #561: it uses #561's step helpers in integrator_utils.jl. The branch is #561's head 8da09d3 (which already merges current master 4f726d5), then one commit, cb6aef9 Make every adaptive time update exact, which fixes #567. The mixed-type tstops fix that this PR first carried is now part of #561 (51c325d).

What changed and why

In all nine adaptive EnsembleGPUKernel steppers, t += dt rounds when |t| is large relative to dt. Time then advances by a different amount than the step integrated (Tsit5 with dt = 12 at t = 2^26 ends at 60 instead of 64). And a step that error control shortened could round onto tf, completing the solve with part of the interval un-integrated (round-7 review of #561). Before the first trial step and after every rejection, the shared helper _representable_step now rounds dt down to the largest step whose end time t + dt is exactly representable. A step of exactly the distance to the landing target (tf or a stop) is kept as is. The time advance therefore always equals the integrated length, and a shortened step can never round up onto tf. If no representable end time exists before t + dt, i.e. time precision cannot resolve the step, the step becomes 0 and fails the existing dtmin check with an explicit dt<dtmin. Rounding only ever goes down, so a rejected step is never re-enlarged and the error-control loop cannot cycle.

Reproducers

The round-7 review of #561, Vern7, Float32 t0 = 2^26, tf = nextfloat(t0) (tf - t0 = 8), u' = (1/8, -u₂/8), dt = 8, exact endpoint [1, exp(-1)]:

source	result
master bacef85 / #561 ceeed40	Success, [0.72025377, 0.48662883] (accepted dt = 5.76203, stored t = tf)
this branch	ERROR: dt<dtmin. Error control rejects the one representable step and no shorter step has a representable end time

Its step-level grid (invariant_grid.jl, 281 stiffness values per algorithm, t0 = 2^26 Float32 and 2^55 Float64, 8-unit final interval) finds a counterexample (t == tf after a step shorter than tf - t0) for all 18 algorithm/precision pairs on master and on #561, and none on this branch.

#567's reproducer (no tstops, Float32 t0 = 2^26, tf = t0 + 64, exact 64):

algorithm, dt	master bacef85	this branch
Tsit5, 12	60.50067	64.0
Tsit5, 20	68.83426	64.0
Vern9, 12	60.031746	64.0
Rodas4, 20	64.73596	64.00001
Rodas5P, 12	66.5423	64.000206

The t0 + 64 survey with a stop at t0 + 24 now gives 64 for all nine algorithms (Rodas5P 64.0001, Kvaerno3 63.999996). On #561 Vern9, Rodas4 and Rodas5P gave 60.3, 65.6 and 63.8.

Tests

Added to test/gpu_kernel_de/adaptive_endpoint.jl (CPU group), across all nine adaptive algorithms:

• Rounded completion at large t, Float32 and Float64. The review's step-level grid asserts that a step reporting t == tf covered the whole interval. The public reproducer must either fail with dt<dtmin or return the exact endpoint.
• Time advance equals integrated length at large t, Float32 and Float64, no tstops: u' = 1 over 64 units at t0 = 2^26 / 2^55 with dt ∈ {12, 20}. The final state must be ≈ 64.

Before/after, Julia 1.12.7, include-ing the test file (384 assertions):

source	result
master bacef85	229 pass / 83 fail / 36 errors; both new large-t tests fail for all 9 algorithms in both precisions
#561 ceeed40	326 pass / 56 fail / 2 errors: both large-t tests fail for all 9 in both precisions (the 2 errors are the mixed-type stops, fixed in #561 at 51c325d)
this branch cb6aef9	523 / 523 pass (the #567 tests plus all of #561's current tests)

Verification

# 4771eb5 (cb6aef9 differs only by a comment in #561's part); JULIA_PKG_PRECOMPILE_AUTO=0, clean worktree per version, Enzyme v0.13.209 (unpinned; #568 is on master)
GROUP=CPU    julia +lts  -> Tsit5 accuracy | 172 172; Adaptive endpoint termination | 523 523; Testing DiffEqGPU tests passed
GROUP=CPU    julia +1.12 -> Tsit5 accuracy | 172 172; Adaptive endpoint termination | 523 523; Testing DiffEqGPU tests passed
GROUP=OpenCL julia +lts  (pocl) -> Tsit5 accuracy | 112 112; Testing DiffEqGPU tests passed
GROUP=OpenCL julia +1.12 (pocl) -> Tsit5 accuracy | 112 112; Testing DiffEqGPU tests passed
GROUP=Enzyme julia +lts  -> Enzyme ensemble gradients (Float64, adaptive=true) | 1 1; Lorenz parameter gradients | 2 2; Testing DiffEqGPU tests passed
GROUP=Enzyme julia +1.12 -> Enzyme ensemble gradients (Float64, adaptive=true) | 1 1; Lorenz parameter gradients | 2 2; Testing DiffEqGPU tests passed

Runic --check, typos, and git diff --check exit 0 on the changed files.

Merged from #561: saveat before a continuous event (e1000a2)

e1000a2 merges #561's 8adb69a. That commit fixes the CUDA "Callbacks" failure at test/gpu_kernel_de/stiff_ode/gpu_ode_continuous_callbacks.jl:185 (GPURodas4, 0.71378124 < 7e-4): https://github.com/SciML/DiffEqGPU.jl/actions/runs/37130654908/job/111224921829. apply_callback! moved integrator.u to the event state before saving saveat points. The Rodas4/Rodas5P/Kvaerno interpolants use integrator.u as the step's end state, so points before the event were interpolated against the wrong endpoint. #561's 1b90199 (no dtnew clamp after acceptance) let the step after a bounce run to tf past the next bounce, which exposed it. Cause, bisect and failing-before/passing-after evidence are in #561's body. The only conflict was in test/gpu_kernel_de/adaptive_endpoint.jl, where both branches append testsets; both were kept. On the merge, the endpoint file runs 577/577 (Julia 1.12, CPU). Runic --check and typos exit 0.

Risk assessment

• Risk: medium
• Blast radius: step selection in all nine adaptive EnsembleGPUKernel steppers: every trial step is rounded down to one with an exactly representable end time, before the error-control loop and on rejection. No public API change. Results change at rounding level for all adaptive solves, and visibly at large |t|, which is the intended fix.
• Evidence: the Adaptive kernel steppers: t += dt rounding decouples time from integrated length at large t #567 reproducers fail on master and on Interpolate to tstops by step length and handle sub-dtmin stop spacing #561 and pass here (tables above); the step-level invariant grid has no counterexample in 18/18 algorithm/precision pairs; the CPU, OpenCL and Enzyme groups pass on LTS and 1.12.
• Independent review: pending. An Opus 5.5 first-pass review (Claude Code, the same harness as the author, so not independent) returned MERGE, low risk, on Interpolate to tstops by step length and handle sub-dtmin stop spacing #561's 8adb69a, which e1000a2 merges here, and confirmed the diagnosis by running it. The independent review is pending: Codex is over its usage pace, and Devin and Grok are exhausted. CUDA CI on the new head is also pending.
• Merge: needs human review — stacked on Interpolate to tstops by step length and handle sub-dtmin stop spacing #561, and touches numerics in all adaptive steppers.

Known CI noise

• The CUDA test/enzyme/cuda_records.jl:9 and downgrade-lane failures are pre-existing on master, tracked in CUDA CI: test/enzyme/cuda_records.jl fails on released CUDACore (Enzyme undef-shadow fill! for non-numeric eltypes) #546 and Raise ModelingToolkitBase floor to 1.72 (fixes downgrade CPU lane) #548.

Not verified

• CUDA/AMDGPU/Metal/oneAPI execution. This host has no GPU. Only CUDA CI can confirm the Callbacks fix on GPU.
• After the merge e1000a2, only the endpoint test file was rerun locally (host overloaded). The full CPU, OpenCL and Enzyme groups are left to CI.
• GROUP=QA.

Closes #567 (once #561 is merged).

🤖 Generated with Claude Code (model: claude-opus-5-5[1m])

https://claude.ai/code/session_01SJfy3ez7u4CqvAerKrT5np