Add comprehensive documentation with Documenter.jl

This PR adds a complete documentation infrastructure for DiffEqBase.jl:

## Documentation Structure
- Set up Documenter.jl with proper configuration
- Created comprehensive documentation pages for all interfaces
- Added API reference documentation for public functions

## Enhanced Docstrings
- Added detailed docstrings for `Tableau` and `ODERKTableau` types
- Documented `DECostFunction` abstract type
- Enhanced `AbstractParameterizedFunction` documentation
- Added comprehensive docs for `ConvergenceSetup`
- Documented `SensitivityADPassThrough` algorithm
- Added docstrings for `KeywordArgError`, `KeywordArgWarn`, and `KeywordArgSilent`

## Documentation Pages Created
### API Reference
- Callbacks interface documentation
- Integrator interface documentation
- Statistics utilities documentation
- General utilities documentation
- Tableau types documentation
- Internal functions documentation

### Interface Documentation
- Problem interface guide
- Solution interface guide
- Algorithm interface guide
- Function interface guide with examples

## CI/CD
- Added GitHub Actions workflow for automatic documentation building and deployment

The documentation provides clear explanations, usage examples, and cross-references to help users understand and effectively use DiffEqBase.jl's functionality.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: ChrisRackauckas

.github/workflows/Documentation.yml

@@ -0,0 +1,25 @@
+name: Documentation
+
+on:
+  push:
+    branches:
+      - master
+    tags: '*'
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: julia-actions/setup-julia@v2
+        with:
+          version: '1'
+      - uses: julia-actions/cache@v2
+      - name: Install dependencies
+        run: julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate()'
+      - name: Build and deploy
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }}
+        run: julia --project=docs/ docs/make.jl

docs/Project.toml

@@ -0,0 +1,3 @@
+[deps]
+Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
+DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e"

docs/make.jl

@@ -0,0 +1,38 @@
+using Documenter
+using DiffEqBase
+
+DocMeta.setdocmeta!(DiffEqBase, :DocTestSetup, :(using DiffEqBase); recursive = true)
+
+makedocs(;
+    modules = [DiffEqBase],
+    sitename = "DiffEqBase.jl",
+    authors = "Christopher Rackauckas et al.",
+    format = Documenter.HTML(;
+        prettyurls = get(ENV, "CI", "false") == "true",
+        canonical = "https://docs.sciml.ai/DiffEqBase/stable/",
+        assets = String[],
+    ),
+    pages = [
+        "Home" => "index.md",
+        "API Reference" => [
+            "Callbacks" => "api/callbacks.md",
+            "Integrator Interface" => "api/integrator.md",
+            "Statistics" => "api/statistics.md",
+            "Utilities" => "api/utilities.md",
+            "Tableaus" => "api/tableaus.md",
+            "Internal Functions" => "api/internal.md",
+        ],
+        "Interfaces" => [
+            "Problem Interface" => "interfaces/problems.md",
+            "Solution Interface" => "interfaces/solutions.md", 
+            "Algorithm Interface" => "interfaces/algorithms.md",
+            "Function Interface" => "interfaces/functions.md",
+        ],
+    ],
+)
+
+deploydocs(;
+    repo = "github.com/SciML/DiffEqBase.jl",
+    devbranch = "master",
+    push_preview = true,
+)

docs/src/api/callbacks.md

@@ -0,0 +1,32 @@
+# Callbacks
+
+```@meta
+CurrentModule = DiffEqBase
+```
+
+Callbacks provide a way to affect the integrator during the solution process. They can be used to implement event handling, saving, and control mechanisms.
+
+## Initialization and Finalization
+
+```@docs
+initialize!
+finalize!
+```
+
+## Callback Utilities
+
+The callback system integrates with the SciMLBase callback infrastructure. The main types are:
+
+- `CallbackSet`: A collection of callbacks
+- `ContinuousCallback`: Callbacks triggered by continuous conditions
+- `DiscreteCallback`: Callbacks triggered at discrete time points
+
+These base types are defined in SciMLBase.jl and extended here with initialization and finalization methods.
+
+## Helper Functions
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["callbacks.jl"]
+Filter = t -> !occursin("initialize!", string(t)) && !occursin("finalize!", string(t))
+```

docs/src/api/integrator.md

@@ -0,0 +1,36 @@
+# Integrator Interface
+
+```@meta
+CurrentModule = DiffEqBase
+```
+
+The integrator interface provides low-level control over the integration process. This allows for step-by-step integration and fine-grained control over the solution process.
+
+## Integrator Accessors
+
+These functions provide access to and modification of integrator state:
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["integrator_accessors.jl"]
+```
+
+## Internal Integration Methods
+
+### Euler Method
+
+The internal Euler method implementation for basic integration:
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["internal_euler.jl"]
+```
+
+### Interpolation
+
+Internal interpolation utilities:
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["internal_itp.jl"]
+```

docs/src/api/internal.md

@@ -0,0 +1,55 @@
+# Internal Functions
+
+```@meta
+CurrentModule = DiffEqBase
+```
+
+Internal functions that are part of the public API but primarily used by solver packages.
+
+## Solver Functions
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["solve.jl"]
+```
+
+## No-Recompile Utilities
+
+Functions for avoiding recompilation:
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["norecompile.jl"]
+```
+
+## Cost Functions
+
+```@docs
+DECostFunction
+```
+
+## Parameterized Functions
+
+```@docs
+AbstractParameterizedFunction
+```
+
+## Convergence Setup
+
+```@docs
+ConvergenceSetup
+```
+
+## Sensitivity Analysis
+
+```@docs
+SensitivityADPassThrough
+```
+
+## Keyword Argument Handling
+
+```@docs
+KeywordArgError
+KeywordArgWarn
+KeywordArgSilent
+```

docs/src/api/statistics.md

@@ -0,0 +1,23 @@
+# Statistics
+
+```@meta
+CurrentModule = DiffEqBase
+```
+
+Statistical analysis utilities for differential equation solutions.
+
+## Statistics Functions
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["stats.jl"]
+```
+
+## Residual Calculations
+
+Functions for calculating residuals between solutions:
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["calculate_residuals.jl"]
+```

docs/src/api/tableaus.md

@@ -0,0 +1,22 @@
+# Tableaus
+
+```@meta
+CurrentModule = DiffEqBase
+```
+
+Butcher tableaus and related structures for Runge-Kutta methods.
+
+## Tableau Types
+
+```@docs
+Tableau
+ODERKTableau
+```
+
+## Tableau Functions
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["tableaus.jl"]
+Filter = t -> !(t in [Tableau, ODERKTableau])
+```

docs/src/api/utilities.md

@@ -0,0 +1,23 @@
+# Utilities
+
+```@meta
+CurrentModule = DiffEqBase
+```
+
+General utility functions for working with differential equations.
+
+## Utility Functions
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["utils.jl"]
+```
+
+## Common Defaults
+
+Default values and configurations:
+
+```@autodocs
+Modules = [DiffEqBase]
+Pages = ["common_defaults.jl"]
+```

docs/src/index.md

@@ -0,0 +1,65 @@
+# DiffEqBase.jl
+
+```@meta
+CurrentModule = DiffEqBase
+```
+
+## Overview
+
+DiffEqBase.jl is the common foundation library for the DifferentialEquations.jl ecosystem. It provides the core types, interfaces, and functionality that are shared across all differential equation solvers in the SciML ecosystem.
+
+## Features
+
+- Common problem and solution types for ODEs, SDEs, DDEs, DAEs, and more
+- Unified integrator interface for all differential equation types
+- Callback system for event handling and control
+- Statistics and analysis utilities
+- Interpolation and tableau definitions
+- Integration with automatic differentiation and sensitivity analysis
+
+## Installation
+
+```julia
+using Pkg
+Pkg.add("DiffEqBase")
+```
+
+## Getting Started
+
+DiffEqBase.jl is typically used as a dependency by other packages in the DifferentialEquations.jl ecosystem. However, you can use it directly for low-level operations:
+
+```julia
+using DiffEqBase
+
+# Most functionality is re-exported from SciMLBase
+# and used through higher-level packages
+```
+
+## Main Components
+
+### Problems and Solutions
+The package defines abstract types and interfaces for various differential equation problems and their solutions.
+
+### Integrators
+Low-level integrator interface for step-by-step integration control.
+
+### Callbacks
+Event handling system for modifying solutions during integration.
+
+### Utilities
+Various utility functions for working with differential equations.
+
+## Package Ecosystem
+
+DiffEqBase.jl is part of the larger SciML ecosystem:
+
+- **SciMLBase.jl**: Core types and interfaces
+- **OrdinaryDiffEq.jl**: ODE solvers
+- **StochasticDiffEq.jl**: SDE solvers
+- **DelayDiffEq.jl**: DDE solvers
+- **DifferentialEquations.jl**: Meta-package
+
+## Index
+
+```@index
+```