DiffEqDocs.jl Documentation

DifferentialEquations.jl is a high-performance suite for numerically solving a wide variety of differential equations in Julia, with interfaces available for Python and R. It provides efficient implementations of classic algorithms and cutting-edge research methods, often outperforming standard C/Fortran implementations.

Supported Equation Types:

• Discrete equations (function maps, Gillespie/Markov simulations)
• Ordinary differential equations (ODEs)
• Split and Partitioned ODEs (Symplectic integrators, IMEX Methods)
• Stochastic ODEs (SODEs/SDEs) and SDAEs
• Random differential equations (RODEs/RDEs)
• Differential algebraic equations (DAEs)
• Delay differential equations (DDEs, NDDEs, RDDEs, DDAEs)
• Stochastic delay differential equations (SDDEs, SNDDEs, SRDDEs, SDDAEs)
• Mixed discrete and continuous equations (Hybrid Equations, Jump Diffusions)
• (Stochastic) partial differential equations ((S)PDEs) via finite difference and finite element methods

Key Integrations:

• Acceleration: GPU acceleration via CUDA.jl and DiffEqGPU.jl.
• Sparsity & Linear Algebra: Automatic sparsity detection with Symbolics.jl, Jacobian coloring with SparseDiffTools.jl, and custom linear solvers via LinearSolve.jl.
• Analysis: Forward/Adjoint Sensitivity Analysis, Parameter Estimation, Bayesian Analysis, and Neural Differential Equations via DiffEqFlux.jl.
• Parallelism: Automatic distributed, multithreaded, and GPU parallel ensemble simulations.

The Beeler-Reuter model is a classic cardiac electrophysiology model used to describe the time-evolution of transmembrane potential and gating variables. It is characterized as a stiff system due to the varying time scales of its state variables.

Key Components:

• State Variables (8 total): Transmembrane potential ($V$), sodium-channel gates ($m, h, j$), calcium-channel gates ($d, f$), potassium gate ($x_1$), and intracellular calcium concentration ($c$).
• Currents: Sodium ($i_{Na}$), calcium ($i_{Ca}$), time-dependent potassium ($i_{x_1}$), and background potassium ($i_{K_1}$).
• Mathematical Form: It is modeled as a reaction-diffusion equation: $$\frac{\partial V}{\partial t} = D \nabla^2 V - \frac {I_{\text{ion}}} {C_m}$$ where $V$ is potential, $D$ is the diffusion scalar, $I_{\text{ion}}$ is the sum of transmembrane currents, and $C_m$ is membrane capacitance.

DiffEqCallbacks.jl provides a variety of pre-built callbacks for SciML differential equation solvers. The available callback types include:

• Manifold Projection Callbacks: For projecting solutions back onto a manifold.
• Saving Callbacks: For saving state or specific values during integration (e.g., SavingCallback, SavedValues).
• Domain Callbacks: For enforcing constraints on the solution domain (e.g., PositiveDomain, GeneralDomain).
• Stepping Callbacks: For controlling step size or executing functions at specific steps (e.g., StepsizeLimiter, FunctionCallingCallback).
• Termination Callbacks: For stopping the solver when specific conditions are met (e.g., TerminateSteadyState).
• Iterative Callbacks: For logic that repeats or occurs periodically (e.g., IterativeCallback, PeriodicCallback).
• Preset Time Callbacks: For triggering events at specific time points (e.g., PresetTimeCallback).
• AutoAbstol: For automatic absolute tolerance adjustment.

For all OrdinaryDiffEq.jl methods, you can control how initial conditions are handled using the initializealg keyword argument. This is particularly important for Differential-Algebraic Equations (DAEs) to ensure consistency between differential and algebraic variables.

Available schemes:

• SciMLBase.CheckInit: Validates that initial conditions satisfy the equation. If they do not, it throws an error. This avoids nonlinear solving and prevents the solver from modifying your provided initial conditions.
• OrdinaryDiffEqNonlinearSolve.BrownFullBasicInit: Suitable for Index-1 DAEs (implicit or semi-explicit in mass matrix form). It keeps differential variables constant. Note: Requires providing du0 when used on a DAEProblem.
• OrdinaryDiffEqNonlinearSolve.ShampineCollocationInit: Suitable for Index-1 DAEs (implicit or semi-explicit in mass matrix form). Unlike Brown, this method allows both differential and algebraic variables to change during initialization.
• SciMLBase.NoInit: Explicitly disables DAE initialization.

# Example usage pattern
prob = DAEProblem(f, du0, u0, tspan)
solve(prob, method, initializealg=SciMLBase.CheckInit)

In DifferentialEquations.jl, native Julia solvers allow you to solve problems using AbstractArray types. ArrayPartition (from RecursiveArrayTools.jl) is used to treat multiple heterogeneous arrays (e.g., arrays with different units, different precision, or different shapes) as a single, unified array. This is useful for modeling systems where different state variables have different physical meanings or properties.

Key Behaviors

• Linear Indexing: A[i] indexes through the constituent arrays linearly (first array, then second, etc.).
• Storage Access: The underlying arrays are stored in the .x field. You can access individual components via A.x[i].
• Efficiency: Broadcasting operations like f.(A) are type-stable and efficient, making them suitable for use inside high-performance solvers.

import RecursiveArrayTools: ArrayPartition
A = ArrayPartition(x::AbstractArray...)