Skip to content

Commit

Permalink
Fix paths and names in docs.
Browse files Browse the repository at this point in the history
  • Loading branch information
@michakraus
michakraus committed Aug 29, 2023
1 parent 733629f commit 10ed680
Show file tree
Hide file tree
Showing 6 changed files with 147 additions and 133 deletions.
102 changes: 51 additions & 51 deletions docs/src/integrators/rk.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -67,29 +67,29 @@ GeometricIntegrators.jl provides various explicit and implicit (both diagonally
For many methods, tabulated coefficients are included, namely


| Function and Aliases | Stages | Order |
|:---------------------------------------------------------------|:-------|:------|
| **Explicit Methods** | | |
| [`TableauExplicitEuler`](@ref), [`TableauForwardEuler`](@ref) | 1 | 1 |
| [`TableauExplicitMidpoint`](@ref) | 2 | 2 |
| [`TableauHeun2`](@ref) | 2 | 2 |
| [`TableauHeun3`](@ref) | 3 | 3 |
| [`TableauKutta`](@ref), [`TableauKutta3`](@ref) | 3 | 3 |
| [`TableauRalston2`](@ref) | 2 | 2 |
| [`TableauRalston3`](@ref) | 3 | 3 |
| [`TableauRunge`](@ref), [`TableauRunge2`](@ref) | 2 | 2 |
| [`TableauRK416`](@ref), [`TableauRK4`](@ref) | 4 | 4 |
| [`TableauRK438`](@ref) | 4 | 4 |
| [`TableauSSPRK3`](@ref) | 3 | 3 |
| **Diagonally Implicit Methods** | | |
| [`TableauCrankNicolson`](@ref) | 2 | 2 |
| [`TableauCrouzeix`](@ref) | 2 | 3 |
| [`TableauKraaijevangerSpijker`](@ref) | 2 | 2 |
| [`TableauQinZhang`](@ref) | 2 | 2 |
| **Fully Implicit Methods** | | |
| [`TableauImplicitEuler`](@ref), [`TableauBackwardEuler`](@ref) | 1 | 1 |
| [`TableauImplicitMidpoint`](@ref) | 2 | 2 |
| [`TableauSRK3`](@ref) | 3 | 4 |
| Function and Aliases | Stages | Order |
|:-------------------------------------------------|:-------|:------|
| **Explicit Methods** | | |
| [`ExplicitEuler`](@ref), [`ForwardEuler`](@ref) | 1 | 1 |
| [`ExplicitMidpoint`](@ref) | 2 | 2 |
| [`Heun2`](@ref) | 2 | 2 |
| [`Heun3`](@ref) | 3 | 3 |
| [`Kutta3`](@ref), [`Kutta3`](@ref) | 3 | 3 |
| [`Ralston2`](@ref) | 2 | 2 |
| [`Ralston3`](@ref) | 3 | 3 |
| [`Runge2`](@ref), [`Runge2`](@ref) | 2 | 2 |
| [`RK416`](@ref), [`RK4`](@ref) | 4 | 4 |
| [`RK438`](@ref) | 4 | 4 |
| [`SSPRK3`](@ref) | 3 | 3 |
| **Diagonally Implicit Methods** | | |
| [`CrankNicolson`](@ref) | 2 | 2 |
| [`Crouzeix`](@ref) | 2 | 3 |
| [`KraaijevangerSpijker`](@ref) | 2 | 2 |
| [`QinZhang`](@ref) | 2 | 2 |
| **Fully Implicit Methods** | | |
| [`ImplicitEuler`](@ref), [`BackwardEuler`](@ref) | 1 | 1 |
| [`ImplicitMidpoint`](@ref) | 2 | 2 |
| [`SRK3`](@ref) | 3 | 4 |

The coefficients of other methods are computed on-the-fly as described in the following.

Expand Down Expand Up @@ -167,21 +167,21 @@ The tableaus of all of the above methods can be computed for an arbitrary number

The following methods are provided for selecting the previously described Runge-Kutta schemes:

| Function | Method | Order |
|:---------------------------------|:----------------------------|:------|
| [`TableauGauss(s)`](@ref) | Gauß-Legendre with s stages | 2s |
| [`TableauLobattoIIIA(s)`](@ref) | Lobatto IIIA with s stages | 2s-2 |
| [`TableauLobattoIIIB(s)`](@ref) | Lobatto IIIB with s stages | 2s-2 |
| [`TableauLobattoIIIC(s)`](@ref) | Lobatto IIIC with s stages | 2s-2 |
| [`TableauLobattoIIIC̄(s)`](@ref) | Lobatto IIIC̄ with s stages | 2s-2 |
| [`TableauLobattoIIID(s)`](@ref) | Lobatto IIID with s stages | 2s-2 |
| [`TableauLobattoIIIE(s)`](@ref) | Lobatto IIIE with s stages | 2s-2 |
| [`TableauLobattoIIIF(s)`](@ref) | Lobatto IIIF with s stages | 2s-2 |
| [`TableauLobattoIIIG(s)`](@ref) | Lobatto IIIG with s stages | 2s-2 |
| [`TableauRadauIA(s)`](@ref) | Radau IA with s stages | 2s-1 |
| [`TableauRadauIB(s)`](@ref) | Radau IB with s stages | 2s-1 |
| [`TableauRadauIIA(s)`](@ref) | Radau IIA with s stages | 2s-1 |
| [`TableauRadauIIB(s)`](@ref) | Radau IIB with s stages | 2s-1 |
| Function | Method | Order |
|:--------------------------|:----------------------------|:------|
| [`Gauss(s)`](@ref) | Gauß-Legendre with s stages | 2s |
| [`LobattoIII(s)`](@ref) | Lobatto III with s stages | 2s-2 |
| [`LobattoIIIA(s)`](@ref) | Lobatto IIIA with s stages | 2s-2 |
| [`LobattoIIIB(s)`](@ref) | Lobatto IIIB with s stages | 2s-2 |
| [`LobattoIIIC(s)`](@ref) | Lobatto IIIC with s stages | 2s-2 |
| [`LobattoIIID(s)`](@ref) | Lobatto IIID with s stages | 2s-2 |
| [`LobattoIIIE(s)`](@ref) | Lobatto IIIE with s stages | 2s-2 |
| [`LobattoIIIF(s)`](@ref) | Lobatto IIIF with s stages | 2s-2 |
| [`LobattoIIIG(s)`](@ref) | Lobatto IIIG with s stages | 2s-2 |
| [`RadauIA(s)`](@ref) | Radau IA with s stages | 2s-1 |
| [`RadauIB(s)`](@ref) | Radau IB with s stages | 2s-1 |
| [`RadauIIA(s)`](@ref) | Radau IIA with s stages | 2s-1 |
| [`RadauIIB(s)`](@ref) | Radau IIB with s stages | 2s-1 |

The first argument `s` refers to the number of stages ($s \ge 1$ for Gauß and $s \ge 2$ for all other methods).
The second argument specifies the number type of the coefficients. Internally, all coefficients are computed using `BigFloat` and then converted to the requested number type, defaulting to `Float64`.
Expand Down Expand Up @@ -213,19 +213,19 @@ into a partitioned Runge-Kutta tableau.
A particular interesting family of partitioned Runge-Kutta methods are symplectic Lobatto methods,
specifically

| Function | Method | Order |
|:---------------------------------------|:----------------------------|:------|
| [`TableauLobattoIIIAIIIB(s)`](@ref) | Lobatto-IIIA-IIIB | 2s-2 |
| [`TableauLobattoIIIBIIIA(s)`](@ref) | Lobatto-IIIB-IIIA | 2s-2 |
| [`TableauLobattoIIIAIIIĀ(s)`](@ref) | Lobatto-IIIA-IIIĀ | 2s-2 |
| [`TableauLobattoIIIBIIIB̄(s)`](@ref) | Lobatto-IIIB-IIIB̄ | 2s-2 |
| [`TableauLobattoIIICIIIC̄(s)`](@ref) | Lobatto-IIIC-IIIC̄ | 2s-2 |
| [`TableauLobattoIIIC̄IIIC(s)`](@ref) | Lobatto-IIIC̄-IIIC | 2s-2 |
| [`TableauLobattoIIIDIIID̄(s)`](@ref) | Lobatto-IIID-IIID̄ | 2s-2 |
| [`TableauLobattoIIIEIIIĒ(s)`](@ref) | Lobatto-IIIE-IIIĒ | 2s-2 |
| [`TableauLobattoIIIFIIIF̄(s)`](@ref) | Lobatto-IIIF-IIIF̄ | 2s |
| [`TableauLobattoIIIF̄IIIF(s)`](@ref) | Lobatto-IIIF̄-IIIF | 2s |
| [`TableauLobattoIIIGIIIḠ(s)`](@ref) | Lobatto-IIIG-IIIḠ | 2s |
| Function | Method | Order |
|:--------------------------------|:----------------------------|:------|
| [`LobattoIIIAIIIB(s)`](@ref) | Lobatto-IIIA-IIIB | 2s-2 |
| [`LobattoIIIBIIIA(s)`](@ref) | Lobatto-IIIB-IIIA | 2s-2 |
| [`LobattoIIIAIIIĀ(s)`](@ref) | Lobatto-IIIA-IIIĀ | 2s-2 |
| [`LobattoIIIBIIIB̄(s)`](@ref) | Lobatto-IIIB-IIIB̄ | 2s-2 |
| [`LobattoIIICIIIC̄(s)`](@ref) | Lobatto-IIIC-IIIC̄ | 2s-2 |
| [`LobattoIIIC̄IIIC(s)`](@ref) | Lobatto-IIIC̄-IIIC | 2s-2 |
| [`LobattoIIIDIIID̄(s)`](@ref) | Lobatto-IIID-IIID̄ | 2s-2 |
| [`LobattoIIIEIIIĒ(s)`](@ref) | Lobatto-IIIE-IIIĒ | 2s-2 |
| [`LobattoIIIFIIIF̄(s)`](@ref) | Lobatto-IIIF-IIIF̄ | 2s |
| [`LobattoIIIF̄IIIF(s)`](@ref) | Lobatto-IIIF̄-IIIF | 2s |
| [`LobattoIIIGIIIḠ(s)`](@ref) | Lobatto-IIIG-IIIḠ | 2s |


## Implicit Equations
Expand Down
35 changes: 18 additions & 17 deletions docs/src/integrators/vprk.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -46,30 +46,31 @@ To mitigate this problem, projection methods have been developed, which can be u

GeometricIntegrators.jl provides the following VPRK methods:

| Integrator | Description |
|:--------------------------------------|:-----------------------------------------------------------------------------------------------------|
| [`IntegratorVPRK`](@ref) | Variational Partitioned Runge-Kutta (VPRK) integrator without projection |
| [`IntegratorVPRKpStandard`](@ref) | VPRK integrator with [standard projection](@ref sec:standard-projection) |
| [`IntegratorVPRKpSymmetric`](@ref) | VPRK integrator with [symmetric projection](@ref sec:symmetric-projection) |
| [`IntegratorVPRKpMidpoint`](@ref) | VPRK integrator with [midpoint projection](@ref sec:midpoint-projection) |
| [`IntegratorVPRKpVariational`](@ref) | VPRK integrator with variational projection (*unstable*) |
| [`IntegratorVPRKpSecondary`](@ref) | VPRK integrator with projection on secondary constraint |
| [`IntegratorVPRKpInternal`](@ref) | Gauss-Legendre VPRK integrator with projection on internal stages of Runge-Kutta method |
| [`IntegratorVPRKpTableau`](@ref) | Gauss-Legendre VPRK integrator with projection in tableau of Runge-Kutta method |
| Integrator | Description |
|:----------------------------|:-----------------------------------------------------------------------------------------------------|
| [`VPRK`](@ref) | Variational Partitioned Runge-Kutta (VPRK) integrator without projection |
| [`VPRKpStandard`](@ref) | VPRK integrator with [standard projection](@ref sec:standard-projection) |
| [`VPRKpSymmetric`](@ref) | VPRK integrator with [symmetric projection](@ref sec:symmetric-projection) |
| [`VPRKpMidpoint`](@ref) | VPRK integrator with [midpoint projection](@ref sec:midpoint-projection) |
| [`VPRKpVariational`](@ref) | VPRK integrator with variational projection (*unstable*) |
| [`VPRKpSecondary`](@ref) | VPRK integrator with projection on secondary constraint |
| [`VPRKpInternal`](@ref) | Gauss-Legendre VPRK integrator with projection on internal stages of Runge-Kutta method |
| [`VPRKpTableau`](@ref) | Gauss-Legendre VPRK integrator with projection in tableau of Runge-Kutta method |

For testing purposes [`IntegratorVPRKpStandard`](@ref) provides some additional constructors (*note that these methods are generally unstable*):

| Integrator | Description |
|:--------------------------------------|:-----------------------------------------------------------------------------------------------------|
| [`IntegratorVPRKpVariationalQ`](@ref) | VPRK integrator with variational projection on $(q_{n}, p_{n+1})$ |
| [`IntegratorVPRKpVariationalP`](@ref) | VPRK integrator with variational projection on $(p_{n}, q_{n+1})$ |
| [`IntegratorVPRKpSymplectic`](@ref) | VPRK integrator with [symplectic projection](@ref sec:symplectic-projection) |
| Integrator | Description |
|:----------------------------|:-----------------------------------------------------------------------------------------------------|
| [`VPRKpVariationalQ`](@ref) | VPRK integrator with variational projection on $(q_{n}, p_{n+1})$ |
| [`VPRKpVariationalP`](@ref) | VPRK integrator with variational projection on $(p_{n}, q_{n+1})$ |
| [`VPRKpSymplectic`](@ref) | VPRK integrator with [symplectic projection](@ref sec:symplectic-projection) |

All of the above integrators are applied to either an [`IODEProblem`](@ref) or [`LODEProblem`](@ref) and instantiated as follows:
```julia
int = IntegratorVPRK(iode, tab, Δt)
int = GeometricIntegrator(iode, VPRK(Gauss(1)))
```
The only exception is [`IntegratorVPRKpSecondary`](@ref) which can only be applied to an [`LODEProblem`](@ref) as it needs some additional functions which are only defined for variational problems.
where the constructor of each method needs to be supplied with a Runge-Kutta or partitioned Runge-Kutta method.
The only exception is [`VPRKpSecondary`](@ref) which can only be applied to an [`LODEProblem`](@ref) as it needs some additional functions which are only defined for variational problems.


## Discrete Action Princtiple
Expand Down
51 changes: 32 additions & 19 deletions docs/src/modules/integrators.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -45,37 +45,31 @@ Pages = ["integrators/extrapolation/extrapolation.jl",

# Euler Integrators

```@docs
GeometricIntegrators.Integrators.ExplicitEuler
GeometricIntegrators.Integrators.ImplicitEuler
```


## Splitting Methods

```@autodocs
Modules = [GeometricIntegrators.Integrators]
Pages = ["integrators/splitting/integrators_composition.jl",
"integrators/splitting/integrators_splitting.jl",
"integrators/splitting/integrators_exact_ode.jl",
"integrators/splitting/splitting_tableau.jl"]
Pages = [
"integrators/euler/explicit_euler.jl",
"integrators/euler/implicit_euler.jl",
]
```


## Runge-Kutta Methods

```@autodocs
Modules = [GeometricIntegrators.Integrators]
Pages = ["integrators/rk/abstract_integrator_rk.jl",
"integrators/rk/coefficients.jl",
Pages = ["integrators/rk/abstract.jl",
"integrators/rk/common.jl",
"integrators/rk/tableaus.jl",
"integrators/rk/updates.jl",
"integrators/rk/integrators_erk.jl",
"integrators/rk/integrators_irk.jl",
"integrators/rk/integrators_irk_implicit.jl",
"integrators/rk/integrators_dirk.jl",
"integrators/rk/integrators_eprk.jl",
"integrators/rk/integrators_iprk.jl",
"integrators/rk/integrators_iprk_implicit.jl",
"integrators/rk/methods.jl",
]
```

Expand All @@ -85,17 +79,21 @@ Pages = ["integrators/rk/abstract_integrator_rk.jl",
```@autodocs
Modules = [GeometricIntegrators.Integrators]
Pages = ["integrators/vi/integrators_vprk.jl"]
Pages = ["integrators/vi/vprk_methods.jl"]
```

## Degenerate Variational Integrators

```@autodocs
Modules = [GeometricIntegrators.Integrators]
Pages = ["integrators/dvi/integrators_dvi_a.jl",
"integrators/dvi/integrators_dvi_b.jl",
"integrators/dvi/integrators_cmdvi.jl",
"integrators/dvi/integrators_ctdvi.jl",
"integrators/dvi/integrators_dvrk.jl"]
Pages = [
"integrators/dvi/integrators_dvi_a.jl",
"integrators/dvi/integrators_dvi_b.jl",
"integrators/dvi/integrators_cmdvi.jl",
"integrators/dvi/integrators_ctdvi.jl",
"integrators/dvi/integrators_dvrk.jl",
"integrators/dvi/methods.jl",
]
```

## Galerkin Variational Integrators
Expand All @@ -105,3 +103,18 @@ Modules = [GeometricIntegrators.Integrators]
Pages = ["integrators/cgvi/integrators_cgvi.jl",
"integrators/dgvi/integrators_dgvi.jl"]
```


## Splitting Methods

```@autodocs
Modules = [GeometricIntegrators.Integrators]
Pages = [
"integrators/splitting/exact_solution.jl",
"integrators/splitting/composition_integrators.jl",
"integrators/splitting/composition_methods.jl",
"integrators/splitting/splitting_coefficients.jl",
"integrators/splitting/splitting_integrator.jl",
"integrators/splitting/splitting_methods.jl",
]
```
6 changes: 3 additions & 3 deletions docs/src/modules/problems.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,12 +2,12 @@
# Problem Types

The following data structures are all implemented in [GeometricEquations.jl](https://github.com/JuliaGNI/GeometricEquations.jl).
Each problem type is derived from [`GeometricProblem`](@ref).
Each problem type is derived from [`EquationProblem`](@ref).

## Geometric Problems
## Geometric Equation Problems

```@docs
GeometricEquations.GeometricProblem
GeometricEquations.EquationProblem
```

## Ordinary Differential Equations
Expand Down
4 changes: 2 additions & 2 deletions docs/src/solutions.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@
```@setup 1
using GeometricIntegrators
using GeometricProblems.HarmonicOscillator
prob = harmonic_oscillator_ode()
prob = HarmonicOscillator.odeproblem()
```

In what we have seen so far, the solution was always automatically created by
Expand All @@ -19,7 +19,7 @@ and the third argument is the number of time steps that will be computed in one
integration step.
The call to the integrator is then made via
```@example 1
int = Integrator(prob, Gauss(1))
int = GeometricIntegrator(prob, Gauss(1))
integrate!(sol, int)
```
If several integration cycles shall be performed, the `reset!()` function can be
Expand Down
Loading

0 comments on commit 10ed680

Please sign in to comment.