# Library

## Important concepts

`Bridge.ContinuousTimeProcess`

— Type`ContinuousTimeProcess{T}`

Types inheriting from the abstract type `ContinuousTimeProcess{T}`

characterize the properties of a `T`

-valued stochastic process, play a similar role as distribution types like `Exponential`

in the package `Distributions`

.

`Bridge.SamplePath`

— Type`SamplePath{T} <: AbstractPath{T}`

The struct

```
struct SamplePath{T}
tt::Vector{Float64}
yy::Vector{T}
SamplePath{T}(tt, yy) where {T} = new(tt, yy)
end
```

serves as container for discretely observed `ContinuousTimeProcess`

es and for the sample path returned by direct and approximate samplers. `tt`

is the vector of the grid points of the observation/simulation and `yy`

is the corresponding vector of states.

It supports `getindex, setindex!, length, copy, vcat`

.

`Bridge.GSamplePath`

— TypeLike `VSamplePath`

, but with assumptions on `tt`

and dimensionality. Planned replacement for `VSamplePath`

`Base.valtype`

— Function`valtype(::ContinuousTimeProcess) -> T`

Returns statespace (type) of a `ContinuousTimeProcess{T]`

.

`Bridge.outertype`

— Function`outertype(P::ContinuousTimeProcess) -> T`

Returns the type of `outer(x)`

, where `x`

is a state of `P`

## Ordinary differential equations and quadrature

`Bridge.ODESolver`

— Type`ODESolver`

Abstract (super-)type for solving methods for ordinary differential equations.

`Bridge.solve!`

— Function`solve!(method, Y, W, P) -> Y`

Integrate with `method`

, where `P is a bridge proposal overwriting`

Y`.

`Bridge.solvebackward!`

— FunctionCurrently only timedependent sigma, as Ito correction is necessary

`Bridge.R3`

— Type`R3`

Ralston (1965) update (order 3 step of the Bogacki–Shampine 1989 method) to solve $y(t + dt) - y(t) = \int_t^{t+dt} F(s, y(s)) ds$.

`Bridge.BS3`

— Type`BS3`

Ralston (1965) update (order 3 step of the Bogacki–Shampine 1989 method) to solve $y(t + dt) - y(t) = \int_t^{t+dt} F(s, y(s)) ds$. Uses Bogacki–Shampine method to give error estimate.

`Bridge.LeftRule`

— Type`LeftRule <: QuadratureRule`

Integrate using left Riemann sum approximation.

`Bridge.fundamental_matrix`

— Function`fundamental_matrix(tt, P)`

Compute fundamental solution.

## Brownian motion

## Stochastic differential equations

`Bridge.a`

— Function`a(t, x, P::ProcessOrCoefficients)`

Fallback for `a(t, x, P)`

calling `σ(t, x, P)*σ(t, x, P)'`

.

`StatsBase.sample`

— Function`sample(tt, P, x1=zero(T))`

Sample the process `P`

on the grid `tt`

exactly from its `transitionprob`

(-ability) starting in `x1`

.

`sample(::Thinning, T, P::InhomogPoisson) -> tt`

`StatsBase.sample!`

— Function`sample!([::Bridge.TransitionProb], X, P, x1=zero(T))`

Sample the process `P`

on the grid `X.tt`

exactly from its `transitionprob`

(-ability) starting in `x1`

writing into `X.yy`

.

`Bridge.quvar`

— Function`quvar(X)`

Computes the (realized) quadratic variation of the path `X`

.

`Bridge.bracket`

— Function```
bracket(X)
bracket(X,Y)
```

Computes quadratic variation process of `X`

(of `X`

and `Y`

).

`Bridge.ito`

— Function`ito(Y, X)`

Integrate a stochastic process `Y`

with respect to a stochastic differential `dX`

.

`Bridge.girsanov`

— Function`girsanov(X::SamplePath, P::ContinuousTimeProcess, Pt::ContinuousTimeProcess)`

Girsanov log likelihood $\mathrm{d}P/\mathrm{d}Pt(X)$

`Bridge.lp`

— Function`lp(s, x, t, y, P)`

Log-transition density, shorthand for `logpdf(transitionprob(s,x,t,P),y)`

.

`Bridge.llikelihood`

— Function`llikelihood(X::SamplePath, P::ContinuousTimeProcess)`

Log-likelihood of observations `X`

using transition density `lp`

.

`llikelihood(X::SamplePath, Pº::LocalGammaProcess, P::LocalGammaProcess)`

Log-likelihood `dPº/dP`

. (Up to proportionality.)

`llikelihood(X::SamplePath, P::LocalGammaProcess)`

Bridge log-likelihood with respect to reference measure `P.P`

. (Up to proportionality.)

`Bridge.solve`

— Function```
solve(method::SDESolver, u, W::SamplePath, P) -> X
solve(method::SDESolver, u, W::SamplePath, (b, σ)) -> X
```

Solve stochastic differential equation $dX_t = b(t,X_t)dt + σ(t,X_t)dW_t$ using `method`

in place.

**Example**

`solve(EulerMaruyama(), 1.0, sample(0:0.1:10, Wiener()), ((t,x)->-x, (t,x)->I))`

```
struct OU <: ContinuousTimeProcess{Float64}
μ::Float64
end
Bridge.b(s, x, P::OU) = -P.μ*x
Bridge.σ(s, x, P::OU) = I
solve(EulerMaruyama(), 1.0, sample(0:0.1:10, Wiener()), OU(1.4))
```

`solve(method::SDESolver, u, W::VSamplePath, P) -> X`

Solve stochastic differential equation $dX_t = b(t,X_t)dt + σ(t,X_t)dW_t$ using `method`

.

`solve(method, W, P) -> Y`

Integrate with `method`

, where `P`

is a bridge proposal from `startpoint(P)`

`to`

endpoint(P)`.

**Examples**

```
cs = Bridge.CSpline(tt[1], tt[end], Bridge.b(tt[1], v[1], P), Bridge.b(tt[end], v[2], P))
P° = BridgeProp(Pσ, v), Pσ.a, cs)
W = sample(tt, Wiener())
solve(Euler(), W, P°)
```

`Bridge.EulerMaruyama`

— Type`EulerMaruyama() <: SDESolver`

Euler-Maruyama scheme. `Euler`

is defined as alias.

`Bridge.Euler`

— Type`EulerMaruyama() <: SDESolver`

Euler-Maruyama scheme. `Euler`

is defined as alias.

`Bridge.StochasticRungeKutta`

— Type`StochasticRungeKutta() <: SDESolver`

Stochastic Runge-Kutta scheme for `T<:Number`

-valued processes.

`Bridge.StochasticHeun`

— Type`StochasticHeun() <: SDESolver`

Stochastic heun scheme.

`Bridge.NoDrift`

— Type`NoDrift(tt, P)`

As `P`

, but without drift.

## In place solvers

`Bridge.R3!`

— Type`R3!`

Inplace Ralston (1965) update (order 3 step of the Bogacki–Shampine 1989 method) to solve $y(t + dt) - y(t) = \int_t^{t+dt} F(s, y(s)) ds$.

`Bridge.σ!`

— Function`σ!(t, y, Δw, tmp2, P)`

Compute stochastic increment at `y`

, $σ Δw$, modifying `tmp2`

.

`Bridge.b!`

— Function`b!(t, y, tmp1, P)`

Compute drift $b$ in `y`

(without factor $Δt$, modifying `tmp1`

.

`Bridge.kernelr3!`

— FunctionOne step for inplace Ralston (1965) update (order 3 step of the Bogacki–Shampine 1989 method) to solve $y(t + dt) - y(t) = \int_t^{t+dt} f(s, y(s)) ds$. Starting point is specified by (t,y)

f!(t,y,k) is a function that takes (t,y) and writes the result in k. ws contains 4 copies of the type of y the result is written into out which is of type y

## Levy processes

`Bridge.GammaProcess`

— Type`GammaProcess`

A *GammaProcess* with jump rate `γ`

and inverse jump size `λ`

has increments `Gamma(t*γ, 1/λ)`

and Levy measure

Here `Gamma(α,θ)`

is the Gamma distribution in julia's parametrization with shape parameter `α`

and scale `θ`

.

`Bridge.GammaBridge`

— Type`GammaBridge(t, v, P)`

A `GammaProcess`

`P`

conditional on htting `v`

at time `t`

.

`Bridge.ExpCounting`

— Type`ExpCounting(λ)`

Counting process with arrival times `arrival(P) = Exponential(1/λ)`

and unit jumps.

`Bridge.CompoundPoisson`

— Type`CompoundPoisson{T} <: LevyProcess{T}`

Abstract type. For a compound Poisson process define `rjumpsize(P) -> T`

and `arrival(P) -> Distribution`

.

`Bridge.nu`

— Function` nu(k, P)`

(Bin-wise) integral of the Levy measure $\nu(B_k)$ (sic).

`Bridge.uniform_thinning!`

— Function`uniform_thinning!(X, P::GammaProcess, γᵒ)`

Return a Gamma process `Y`

with new intensity `γᵒ`

, such that `X-Y`

has intensity `γ-γᵒ`

and `Y`

and `X-Y`

are independent. In the limit $dt \to \infty$ the new Gamma process has each of is jump removed with probability `γᵒ/γ`

. Overwrites `X`

with `Y`

.

## Poisson processes

`Bridge.ThinningAlg`

— Type`ThinningAlg(λmax)`

Sampling method for `InhomogPoisson`

by the 'thinning' algorithm.

**Examples:**

`sample(ThinningAlg(λmax), T, InhomogPoisson(λ))`

`Bridge.InhomogPoisson`

— Type`InhomogPoisson(λ)`

Inhomogenous Poisson process with intensity function `λ(t)`

. See also `ThinningAlg`

.

## Bessel processes

`Bridge.Bessel`

— Type`Bessel{N}(σ)`

N-dimensional Bessel process with dispersion σ. Sample with

```
u = 0.0
t = 0:0.1:1
σ = 1.0
sample(u, t, Bridge.Bessel{3}(σ))
```

`Bridge.Bessel3Bridge`

— Type`Bessel3Bridge(t, v, σ)`

Bessel(3) bridge from below or above to the point `v`

at time `t`

, not crossing `v`

, with dispersion σ.

`Bridge.BesselProp`

— Type`BesselProp`

Bessel type proposal

## Miscellaneous

`Bridge.endpoint!`

— Function`endpoint!(X::SamplePath, v)`

Convenience functions setting the endpoint of `X to`

v`.

`Bridge.inner`

— Function`inner(x[, y])`

Short-hand for quadratic form x'x (or x'y).

`Bridge.cumsum0`

— Function`cumsum0(x)`

Cumulative sum starting at 0 such that `cumsum0(diff(x)) ≈ x`

.

`Bridge.mat`

— Function`mat(yy::Vector{SVector})`

Reinterpret `X`

or `yy`

to an array without change in memory.

`Bridge.outer`

— Function`outer(x[, y])`

Short-hand for quadratic form xx' (or xy').

`Bridge.CSpline`

— Type`CSpline(s, t, x, y = x, m0 = (y-x)/(t-s), m1 = (y-x)/(t-s))`

Cubic spline parametrized by $f(s) = x$ and $f(t) = y$, $f'(s) = m_0$, $f'(t) = m_1$.

`Bridge.integrate`

— Function`integrate(cs::CSpline, s, t)`

Integrate the cubic spline from `s`

to `t`

.

`Bridge.logpdfnormal`

— Function`logpdfnormal(x, Σ)`

logpdf of centered Gaussian with covariance Σ

`Bridge.runmean`

— Function`runmean(x)`

Running mean of the vector `x`

.

`Bridge.PSD`

— Type`PSD{T}`

Simple wrapper for the lower triangular Cholesky root of a positive (semi-)definite element `σ`

.

`Bridge.Gaussian`

— Type`Gaussian(μ, Σ) -> P`

Gaussian distribution with mean `μ`

`and covariance`

Σ`. Defines`

rand(P)`and`

(log-)pdf(P, x)`. Designed to work with`

Number`s,`

UniformScaling`s,`

StaticArrays`and`

PSD`-matrices.

Implementation details: On `Σ`

the functions `logdet`

, `whiten`

and `unwhiten`

(or `cholupper`

as fallback for the latter two) are called.

`Bridge.refine`

— Function`refine(tt, n)`

Refine range by decreasing stepsize by a factor `n`

.

`Bridge.quaternion`

— Function`quaternion(m::SMatrix{3,3})`

Compute the (rotation-) quarternion of a 3x3 rotation matrix. Useful to create isodensity ellipses from spheres in GL visualizations.

`Bridge._viridis`

— Constant`_viridis`

Color data of the Viridis map by Nathaniel J. Smith, Stefan van Der Walt, Eric Firing from https://github.com/BIDS/colormap/blob/master/colormaps.py .

`Bridge.supnorm`

— Function`Supremum norm`

`Bridge.posterior`

— Function`posterior(Val{:λ}, P::GammaProcess, U::SamplePath, prior = (0.0, 0.0))`

Marginal posterior distribution of parameter `λ`

. Interpretation of conjugate prior is "observed time, observed increment".

## Online statistics

Online updating of the tuple `state = (m, m2, n)`

where

`m`

- `mean(x[1:n])`

`m2`

- sum of squares of differences from the current mean, $\textstyle\sum_{i=1}^n (x_i - \bar x_n)^2$

`n`

- number of iterations

`Bridge.mcstart`

— Function`mcstart(x) -> state`

Create state for random chain online statitics. The entries/value of `x`

are ignored

`Bridge.mcnext`

— Function`mcnext(state, x) -> state`

Update random chain online statistics when new chain value `x`

was observed. Return new `state`

.

`Bridge.mcband`

— Function`mcband(mc)`

Compute marginal 95% coverage interval for the chain from normal approximation.

`Bridge.mcbandmean`

— Function`mcmeanband(mc)`

Compute marginal confidence interval for the chain *mean* using normal approximation

`Bridge.mcstats`

— Function`mcstats(mc)`

Compute mean and covariance estimates.

`Bridge.mcmarginalstats`

— Function`mcmarginalstats(mcstates) -> mean, std`

Compute `mean`

`and marginal standard deviations`

std` for 2d plots.

`Bridge.OnlineStat`

— Type```
stats = map(OnlineStat, (x, θ, η))
map(push!, stats, (x, θ, η))
mean.(stats)
cov.(stats)
```

## Linear Processes

`Bridge.LinPro`

— Type`LinPro(B, μ::T, σ)`

Linear diffusion $dX = B(X - μ)dt + σdW$.

`Bridge.Ptilde`

— Type`Ptilde(cs::CSpline, σ)`

Affine diffusion $dX = cs(t) dt + σdW$ with cs a cubic spline `::CSpline`

.

`Bridge.LinearNoiseAppr`

— Type`LinearNoiseAppr(tt, P, x, a, direction = forward)`

Precursor of the linear noise approximation of `P`

. For now no attempt is taken to add in a linearization around the deterministic path. `direction`

can be one of `:forward`

, `:backward`

or `:nothing`

. The latter corresponds to choosing `β == 0`

.

`Bridge.LinearAppr`

— Type`LinearAppr(tt, B, β, a)`

`Bridge.LinProBridge`

— Type`LinProBridge`

Bridge process of `P::LinPro`

with `μ == 0`

conditional on ending in `v`

at time `t`

.

## Bridges

`Bridge.GuidedProp`

— Type`GuidedProp`

General bridge proposal process, only assuming that `Pt`

defines `H`

and `r`

in the right way.

`Bridge.GuidedBridge`

— Type`GuidedBridge`

Guided proposal process for diffusion bridge using backward recursion.

`GuidedBridge(tt, P, Pt, v)`

Constructor of guided proposal process for diffusion bridge of `P`

to `v`

on the time grid `tt`

using guiding term derived from linear process `Pt`

.

`GuidedBridge(tt, P, Pt, V, H♢)`

Guided proposal process for diffusion bridge of `P`

to `v`

on the time grid `tt`

using guiding term derived from linear process `Pt`

. Initialize using `Bridge.gpupdate`

(H♢, V, L, Σ, v)

`Bridge.PartialBridge`

— Type`PartialBridge`

Guided proposal process for diffusion bridge using backward recursion. PartialBridge(tt, P, Pt, L, v, Σ) Guided proposal process for a partial diffusion bridge of `P`

to `v`

on the time grid `tt`

using guiding term derived from linear process `Pt`

. Simulate with `bridge!`

.

`Bridge.PartialBridgeνH`

— Type`PartialBridgeνH`

Guided proposal process for diffusion bridge using backward recursion.

```
PartialBridgeνH(tt, P, Pt, L, v,ϵ Σ)
Guided proposal process for a partial diffusion bridge of `P` to `v` on
the time grid `tt` using guiding term derived from linear process `Pt`.
PartialBridgeνH(tt, P, Pt, ν, Hend⁺)
Guided proposal process on the time grid `tt` using guiding term derived from
linear process `Pt` with backwards equation initialized at `ν, Hend⁺`.
```

`Bridge.BridgeProp`

— Type`BridgeProp(Target::ContinuousTimeProcess, tt, v, a, cs)`

Simple bridge proposal derived from a linear process with time dependent drift given by a `CSpline`

and constant diffusion coefficient `a`

.

`Bridge.Mdb`

— Type`Mdb() <: SDESolver`

Euler scheme with the diffusion coefficient correction of the modified diffusion bridge.

`Bridge.Vs`

— Function`Vs(s, T1, T2, v, P)`

Time changed `V`

for generation of `U`

.

`Bridge.gpV!`

— FunctiongpV!(K::SamplePath, P, KT=zero(T))

Precompute `V`

from $(d/dt)V = BV + β$, $V_T = v$ for a guided proposal.

`Bridge.r`

— Function`r(t, x, T, v, P)`

Returns $r(t,x) = \operatorname{grad}_x \log p(t,x; T, v)$ where $p$ is the transition density of the process $P$.

`Bridge.gpHinv!`

— Function`gpHinv!(K::SamplePath, P, KT=zero(T))`

Precompute $K = H^{-1}$ from $(d/dt)K = BK + KB' + a$ for a guided proposal.

`Bridge.gpupdate`

— Function```
gpupdate(H♢, V, L, Σ, v)
gpupdate(P, V, L, Σ, v)
```

Return updated `H♢, V`

when observation `v`

at time zero with error `Σ`

is observed.

## Unsorted

`Bridge.LocalGammaProcess`

— Type`LocalGammaProcess`

`Bridge.compensator0`

— Function`compensator0(kstart, P::LocalGammaProcess)`

Compensator of GammaProcess approximating the LocalGammaProcess. For `kstart == 1`

(only choice) this is $\nu_0([b_1,\infty)$.

`Bridge.compensator`

— Function`compensator(kstart, P::LocalGammaProcess)`

Compensator of LocalGammaProcess For `kstart = 1`

, this is $\sum_{k=1}^N \nu(B_k)$, for `kstart = 0`

, this is $\sum_{k=0}^N \nu(B_k) - C$ (where $C$ is a constant).

`Bridge.θ`

— Function`θ(x, P::LocalGammaProcess)`

Inverse jump size compared to gamma process with same alpha and beta.

`Bridge.soft`

— Function`soft(t, T1, T2)`

Time change mapping `s`

in `[T1, T2]`

`(`

`U`

`-time) to`

t``in`

[T1, T2]`(`

X`-time).

`Bridge.tofs`

— Function`tofs(s, T1, T2)`

Time change mapping `t`

in `[T1, T2]`

($X$-time) to `s`

in `[T1, T2]`

(`U`

-time).

`Bridge.dotVs`

— Function`dotVs (s, T1, T2, v, P)`

Time changed time derivative of `V`

for generation of `U`

.

`Bridge.SDESolver`

— Type`SDESolver`

Abstract (super-)type for solving methods for stochastic differential equations.

`Bridge.Increments`

— Type`Increments{S<:AbstractPath{T}}`

Iterator over the increments of an AbstractPath. Iterates over `(i, tt[i], tt[i+1]-tt[i], yy[i+1]-y[i])`

.

`Bridge.sizedtype`

— Function`sizedtype(x) -> T`

Return an extended type which preserves `size`

information. Makes `one(T)`

and `zero(T)`

for vectors possible.

`Bridge.piecewise`

— Function`piecewise(X::SamplePath, [endtime]) -> tt, xx`

If X is a jump process with piecewise constant paths and jumps in `X.tt`

, piecewise returns coordinates path for plotting purposes. The second argument allows to choose the right endtime of the last interval.

`Bridge.aeuler`

— Function`aeuler(u, s:dtmax:t, P, tau=0.5)`

Adaptive Euler-Maruyama scheme from https://arxiv.org/pdf/math/0601029.pdf sampling a path from u at s to t with adaptive stepsize of 2.0^(-k)*dtmax

`Bridge.MeanCov`

— Type`MeanCov(itr)`

Iterator interface for online mean and covariance estimates. Iterates are triples `mean, λ, cov/λ`

Example:

```
c = Channel{Vector}(1)
m = Bridge.MeanCov(c)
put!(c, rand(5))
u = iterate(m)
put!(c, rand(5))
u = iterate(m, u[2])
close(c)
u[1][1]
```

```
m = Bridge.MeanCov(Channel{Vector{Float64}}(1))
u = register!(m, rand(5))
u = register!(m, rand(5), u)
close(m)
u[1][1]
```

`Bridge.upsample`

— Function`upsample(x, td, t)`

If `x`

is piecewise constant with jumps at `td`

, return values of `x`

at times `t`

.

`Bridge.viridis`

— Function`viridis`

Map `s`

onto the first `maxviri`

viridis colors

`Bridge.rescale`

— Function`rescale(x, a=>b, u=>v)`

Linearly map the interval [a,b] to [u,v].

Example:

`rescale.(x, Ref(extrema(x)))`