[Paper Review] Confederated Modular Differential Equation APIs for Accelerated Algorithm Development and Benchmarking

Christopher Rackauckas, Qing Nie|arXiv (Cornell University)|Jul 17, 2018

Advanced Data Storage Technologies3 references3 citations

TL;DR

This paper introduces a confederated modular API for DifferentialEquations.jl that enables seamless integration, benchmarking, and comparison of diverse numerical solvers for differential equations. By leveraging Julia’s multiple dispatch and a polyalgorithmic approach, it allows researchers to empirically verify theoretical advances and end-users to automatically select optimal solvers, significantly accelerating algorithm development and improving performance across scientific domains.

ABSTRACT

Performant numerical solving of differential equations is required for large-scale scientific modeling. In this manuscript we focus on two questions: (1) how can researchers empirically verify theoretical advances and consistently compare methods in production software settings and (2) how can users (scientific domain experts) keep up with the state-of-the-art methods to select those which are most appropriate? Here we describe how the confederated modular API of DifferentialEquations.jl addresses these concerns. We detail the package-free API which allows numerical methods researchers to readily utilize and benchmark any compatible method directly in full-scale scientific applications. In addition, we describe how the complexity of the method choices is abstracted via a polyalgorithm. We show how scientific tooling built on top of DifferentialEquations.jl, such as packages for dynamical systems quantification and quantum optics simulation, both benefit from this structure and provide themselves as convenient benchmarking tools.

Motivation & Objective

• Address the challenge of empirically verifying theoretical advances in numerical solvers within real-world scientific applications.
• Enable consistent, production-grade benchmarking of diverse differential equation solvers across multiple languages and implementations.
• Abstract the complexity of method selection for domain scientists through automatic algorithm specialization using a type-hierarchy polyalgorithm.
• Facilitate rapid adoption and contribution of new solvers by methods researchers through a unified, package-agnostic API.
• Support the development of high-performance scientific tooling by providing a standardized, composable foundation for downstream packages.

Proposed method

• Implement a confederated modular API using Julia’s multiple dispatch system to decouple problem types from solver algorithms.
• Define a common API in DiffEqBase.jl with a stub solve function that dispatches to specialized solver packages based on input types.
• Use type-based dispatch to enable automatic selection of optimal solvers via a polyalgorithm that classifies problem structure (e.g., ODE, SDE, DAE).
• Integrate legacy solvers from C++ (SUNDIALS) and Fortran (Hairer’s dop853) into the same interface for fair benchmarking.
• Develop open, reproducible benchmarks using real-world applications and reference solutions with 10−14 tolerance to measure work-precision trade-offs.
• Enable cross-language performance comparisons by running benchmarks on identical hardware, revealing performance gaps (e.g., 10–100× faster in Julia vs. Python, MATLAB, R).

Experimental results

Research questions

• RQ1 How can researchers consistently benchmark and compare numerical solvers in real scientific applications across different programming languages and implementations?
• RQ2 How can end-users without deep numerical analysis expertise reliably select the most efficient differential equation solver for their problem?
• RQ3 To what extent can a modular, confederated API accelerate the adoption and evaluation of new numerical methods in scientific computing?
• RQ4 What performance advantages does a Julia-native implementation offer over mature, statically-typed languages like C++ and Fortran in solving differential equations?
• RQ5 How can automatic algorithm selection via polyalgorithms improve solver choice without requiring expert knowledge from users?

Key findings

• The confederated modular API enables direct benchmarking of hundreds of solvers—including legacy C++ and Fortran codes—within the same high-level interface, ensuring fair and consistent comparisons.
• Benchmark results show that Julia implementations are typically 10–100× faster than equivalent implementations in Python (SciPy), MATLAB, and R’s deSolve, even with Numba acceleration.
• Within the same method family (e.g., BDF, Rosenbrock, ESDIRK), performance differences are generally within an order of magnitude, while differences between method families are far more significant.
• The benchmarks directly influenced development priorities, such as triggering a Google Summer of Code project to implement automatic stiffness detection and switching in OrdinaryDiffEq.jl.
• Observations from benchmarking led to targeted improvements in stochastic integrators and highlighted the importance of coefficient optimization in high-order Runge-Kutta methods.
• The open benchmarking framework has become a key tool for guiding JuliaDiffEq’s development and helping new users evaluate whether to migrate from existing tooling.