OrdinaryDiffEqFeagin

Ultra-high-order explicit Runge-Kutta methods for non-stiff problems at extremely low tolerances (< 1e-30). These methods are designed for applications requiring extreme precision, typically used with higher-precision number types like BigFloat.

Key Properties

Feagin methods provide:

• Ultra-high-order accuracy (10th, 12th, and 14th order)
• Extreme precision capabilities for very low tolerance requirements
• Compatibility with arbitrary precision arithmetic (BigFloat, Float128)
• Specialized for very demanding applications requiring maximum accuracy

When to Use Feagin Methods

These methods are recommended for:

• Extremely low tolerance problems (< 1e-30)
• Arbitrary precision arithmetic applications using BigFloat or Float128
• Ultra-high precision requirements where standard methods are insufficient
• Research applications requiring maximum possible accuracy
• Long-time integration where error accumulation must be minimized to extreme levels

Important Limitations

Theoretical vs Practical Performance

• Very good theoretical efficiency due to high order and optimized coefficients
• Poor practical performance in benchmarks due to bad error estimators and adaptivity issues
• Generally recommend Vern9 instead as it tends to be more efficient in practice despite lower theoretical order

Performance Considerations

• May be less efficient than Vern9 even for very low tolerance problems
• Outperformed by extrapolation methods at extremely low tolerances due to adaptive order
• Potential efficiency for >128-bit numbers but no practical cases found yet where this is actually true
• Should always be tested against Vern9 and extrapolation methods

Solver Selection Guide

Extreme precision (< 1e-30)

• Feagin14: 14th-order method for maximum accuracy
• Feagin12: 12th-order method, balance of accuracy and efficiency
• Feagin10: 10th-order method for moderate extreme precision

Strongly recommended alternatives

• For most very low tolerance problems: Use Vern9 first (more efficient in practice despite lower theoretical order)
• For extremely low tolerances: Consider extrapolation methods for adaptive order
• For >128-bit precision: These methods may be more efficient, but no practical cases found yet
• Always benchmark: Compare performance with Vern9 and extrapolation methods before choosing Feagin methods

Usage Guidelines

• Best with BigFloat or Float128 number types
• Useful in Float128 precision range but test against other algorithms
• Consider problem-specific characteristics when choosing order level

Installation

To be able to access the solvers in OrdinaryDiffEqFeagin, you must first install them use the Julia package manager:

using Pkg
Pkg.add("OrdinaryDiffEqFeagin")

This will only install the solvers listed at the bottom of this page. If you want to explore other solvers for your problem, you will need to install some of the other libraries listed in the navigation bar on the left.

Example usage

using OrdinaryDiffEqFeagin

function lorenz!(du, u, p, t)
    du[1] = 10.0 * (u[2] - u[1])
    du[2] = u[1] * (28.0 - u[3]) - u[2]
    du[3] = u[1] * u[2] - (8 / 3) * u[3]
end
u0 = [1.0; 0.0; 0.0]
tspan = (0.0, 100.0)
prob = ODEProblem(lorenz!, u0, tspan)
sol = solve(prob, Feagin14())

Full list of solvers

Feagin10(; step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Feagin12(; step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Feagin14(; step_limiter! = OrdinaryDiffEq.trivial_limiter!)