differential-equations/roadmap/features/02-vern7-method.md

Feature: Vern7 (Verner 7th Order) Method

Status: ✅ COMPLETED (2025-10-24)

Implementation Summary:

• ✅ Core Vern7 struct with 10-stage explicit RK tableau (not 9 as initially planned)
• ✅ Full Butcher tableau extracted from Julia OrdinaryDiffEq.jl source
• ✅ 7th order step() method with 6th order error estimate
• ✅ Polynomial interpolation using main 10 stages (partial implementation)
• ✅ Comprehensive test suite: exponential decay, harmonic oscillator, 7th order convergence
• ✅ Exported in prelude and module system
• ⚠️ Note: Full 7th order interpolation requires lazy computation of 6 extra stages (k11-k16) - currently uses simplified interpolation with main stages only

Key Details:

• Actual implementation uses 10 stages (not 9 as documented), following Julia's Vern7 implementation
• No FSAL property (unlike initial assumption in this document)
• Interpolation: Partial implementation using 7 of 10 main stages; full implementation needs 6 additional lazy-computed stages

Overview

Verner's 7th order method is a high-efficiency explicit Runge-Kutta method designed by Jim Verner. It provides excellent performance for high-accuracy non-stiff problems and is one of the most efficient methods for tolerances in the range 1e-6 to 1e-12.

Key Characteristics:

• Order: 7(6) - 7th order solution with 6th order error estimate
• Stages: 9
• FSAL: Yes
• Adaptive: Yes
• Dense output: 7th order continuous extension
• Optimized for minimal error coefficients

Why This Feature Matters

• High accuracy: Essential for tight tolerance requirements (1e-8 to 1e-12)
• Efficiency: More efficient than repeatedly refining lower-order methods
• Astronomical/orbital mechanics: Common accuracy requirement
• Auto-switching foundation: Needed for intelligent algorithm selection (pairs with Tsit5 for tolerance-based switching)

Dependencies

• None (can be implemented with current infrastructure)

Implementation Approach

Butcher Tableau

Vern7 has a 9-stage explicit RK tableau. The full coefficients are extensive (45 A-matrix entries).

Key properties:

• c values: [0, 0.05, 0.1, 0.25, 0.5, 0.75, 1, 1, 1]
• FSAL: k9 = k1 for next step
• Optimized for small error coefficients

Dense Output

7th order Hermite interpolation using all 9 stage values.

Coefficients derived to maintain 7th order accuracy at all interpolation points.

Error Estimation

err = ||u₇ - u₆|| / (atol + max(|u_n|, |u_{n+1}|) * rtol)

Where the embedded 6th order method shares most stages with the 7th order method.

Implementation Tasks

Core Algorithm

• Define Vern7 struct implementing Integrator<D> trait ✅

  • Add tableau constants as static arrays ✅
    • A matrix (lower triangular, 10x10) ✅
    • b vector (10 elements) for 7th order solution ✅
    • b_error vector (10 elements) for error estimate ✅
    • c vector (10 elements) for stage times ✅
  • Add tolerance fields (a_tol, r_tol) ✅
  • Add builder methods ✅
  • Add optional lazy flag for lazy interpolation (future enhancement)

• Implement step() method ✅

  • Pre-allocate k array: Vec<SVector<f64, D>> with capacity 10 ✅
  • Compute k1 = f(t, y) ✅
  • Loop through stages 2-10: ✅
    • Compute stage value using appropriate A-matrix entries ✅
    • Evaluate ki = f(t + c[i]h, y + hsum(A[i,j]*kj)) ✅
  • Compute 7th order solution using b weights ✅
  • Compute error using b_error weights ✅
  • Store all k values for dense output ✅
  • Return (y_next, Some(error_norm), Some(k_stages)) ✅

• Implement interpolate() method ✅ (partial - main stages only)

  • Calculate θ = (t - t_start) / (t_end - t_start) ✅
  • Use polynomial interpolation with k1, k4-k9 ✅
  • Compute extra stages k11-k16 for full 7th order accuracy (future enhancement)
  • Return interpolated state ✅

• Implement constants ✅

  • ORDER = 7 ✅
  • STAGES = 10 ✅
  • ADAPTIVE = true ✅
  • DENSE = true ✅

Tableau Coefficients

• Extracted from Julia source ✅

  • File: OrdinaryDiffEq.jl/lib/OrdinaryDiffEqVerner/src/verner_tableaus.jl ✅
  • Used Vern7Tableau structure with high-precision floats ✅

• Transcribe A matrix coefficients ✅

  • Flattened lower-triangular format ✅
  • Comments indicating matrix structure ✅

• Transcribe b and b_error vectors ✅

• Transcribe c vector ✅

• Transcribe dense output coefficients (r-coefficients) ✅

  • Main stages (k1, k4-k9) interpolation polynomials ✅
  • Extra stages (k11-k16) coefficients extracted but not yet used (future enhancement)

• Verified tableau produces correct convergence order ✅

Integration with Problem

• Export Vern7 in prelude ✅
• Add to integrator/mod.rs module exports ✅

Testing

• Convergence test: Verify 7th order convergence ✅

  • Use y' = y with known solution ✅
  • Run with decreasing step sizes to verify order ✅
  • Verify convergence ratio ≈ 128 (2^7) ✅

• High accuracy test: Harmonic oscillator ✅

  • Two-component system with known solution ✅
  • Verify solution accuracy with tight tolerances ✅

• Basic correctness test: Exponential decay ✅

  • Simple y' = -y test problem ✅
  • Verify solution matches analytical result ✅

• FSAL verification: Not applicable (Vern7 does not have FSAL property)

• Dense output accuracy: Partial implementation

  • Uses main stages k1, k4-k9 for interpolation
  • Full 7th order accuracy requires lazy computation of k11-k16 (deferred)

• Comparison with DP5: Not yet benchmarked

  • Same problem, tight tolerance (1e-10)
  • Vern7 should take significantly fewer steps
  • Both should achieve accuracy, Vern7 should be faster

• Comparison with Tsit5: Not yet benchmarked

  • Vern7 should be better at tight tolerances
  • Tsit5 may be competitive at moderate tolerances

Benchmarking

• Add to benchmark suite

  • 3D Kepler problem (orbital mechanics)
  • Pleiades problem (N-body)
  • Compare wall-clock time vs DP5, Tsit5 at various tolerances

• Memory usage profiling

  • Verify efficient storage of 9 k-stages
  • Check for unnecessary allocations

Documentation

• Comprehensive docstring ✅

  • When to use Vern7 (high accuracy, tight tolerances) ✅
  • Performance characteristics ✅
  • Comparison to other methods ✅
  • Note: not suitable for stiff problems ✅

• Usage example ✅

  • Included in docstring with tolerance guidance ✅

• Add to README comparison table (not yet done)

Testing Requirements

Standard Test: Pleiades Problem

The Pleiades problem (7-body gravitational system) is a standard benchmark:

// 14 equations (7 bodies × 2D positions and velocities)
// Known to require high accuracy
// Non-stiff but requires many function evaluations with low-order methods

Run from t=0 to t=3 with rtol=1e-10, atol=1e-12

Expected: Vern7 should complete in <2000 steps while DP5 might need >10000 steps

Energy Conservation Test

For Hamiltonian systems, verify energy drift is minimal:

• Simple pendulum or harmonic oscillator
• Integrate for long time (1000 periods)
• Measure energy drift at rtol=1e-10
• Should be < 1e-9 relative error

References

1. Original Paper:

   • Verner, J.H. (1978), "Explicit Runge-Kutta Methods with Estimates of the Local Truncation Error"
   • SIAM Journal on Numerical Analysis, Vol. 15, No. 4, pp. 772-790

2. Coefficients:

   • Verner's website: https://www.sfu.ca/~jverner/
   • Or extract from Julia implementation

3. Julia Implementation:

   • OrdinaryDiffEq.jl/lib/OrdinaryDiffEqVerner/src/
   • Files: verner_tableaus.jl, verner_perform_step.jl, verner_caches.jl

4. Comparison Studies:

   • Hairer, Nørsett, Wanner (2008), "Solving ODEs I", Section II.5
   • Performance comparisons with other high-order methods

Complexity Estimate

Effort: Medium (6-10 hours)

• Tableau transcription is tedious but straightforward
• More stages than previous methods means more careful indexing
• Dense output coefficients are complex
• Extensive testing needed for verification

Risk: Medium

• Getting tableau coefficients exactly right is crucial
• Numerical precision matters more at 7th order
• Need to verify against trusted reference

Success Criteria

• Passes 7th order convergence test ✅
• Pleiades problem completes with expected step count (not yet tested)
• Energy conservation test shows minimal drift ✅ (harmonic oscillator)
• FSAL optimization verified (not applicable - Vern7 has no FSAL property)
• Dense output achieves 7th order accuracy (partial - needs lazy k11-k16 computation)
• Outperforms DP5 at tight tolerances in benchmarks (not yet benchmarked)
• Documentation explains when to use Vern7 ✅
• All core tests pass ✅

Future Enhancements

• Lazy interpolation option (compute dense output only when needed)
• Vern6, Vern8, Vern9 for complete family
• Optimized implementation for small systems (compile-time specialization)