continuous
import "github.com/umbralcalc/stochadex/pkg/continuous"Package continuous provides implementations of continuous-time stochastic processes for simulation modeling. It includes various diffusion processes, jump-diffusion models, and other continuous stochastic dynamics commonly used in mathematical finance, physics, and engineering applications.
Key Features:
- Wiener processes (Brownian motion)
- Geometric Brownian motion for asset price modeling
- Ornstein-Uhlenbeck processes for mean-reverting dynamics
- Drift-diffusion and jump-diffusion processes
- Compound Poisson processes
- Gradient descent and optimization algorithms
- Cumulative time tracking utilities
Mathematical Background: Continuous stochastic processes are typically described by stochastic differential equations (SDEs) of the form:
dX(t) = μ(X,t)dt + σ(X,t)dW(t)where μ is the drift, σ is the volatility, and W(t) is a Wiener process.
Usage Patterns:
- Financial modeling (asset prices, interest rates, volatility)
- Physics simulation (particle dynamics, thermal motion)
- Engineering applications (noise modeling, signal processing)
- Machine learning (stochastic optimization, sampling)
Index
- type
CompoundPoissonProcessIteration
- func (c *CompoundPoissonProcessIteration) Configure(partitionIndex int, settings *simulator.Settings)
- func (c *CompoundPoissonProcessIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
- type CumulativeTimeIteration
- type DriftDiffusionIteration
- type DriftJumpDiffusionIteration
- type GammaJumpDistribution
- type
GeometricBrownianMotionIteration
- func (g *GeometricBrownianMotionIteration) Configure(partitionIndex int, settings *simulator.Settings)
- func (g *GeometricBrownianMotionIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
- type GradientDescentIteration
- type JumpDistribution
- type OrnsteinUhlenbeckIteration
- type WienerProcessIteration
type CompoundPoissonProcessIteration
CompoundPoissonProcessIteration steps a compound Poisson process.
Usage hints:
- Provide per-dimension “rates” and a JumpDistribution implementation.
- At each step, increments by a jump draw with probability approx. rate*dt.
- Configure timestep size via the simulator to control event frequency.
type CompoundPoissonProcessIteration struct {
JumpDist JumpDistribution
// contains filtered or unexported fields
}func (*CompoundPoissonProcessIteration) Configure
func (c *CompoundPoissonProcessIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*CompoundPoissonProcessIteration) Iterate
func (c *CompoundPoissonProcessIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type CumulativeTimeIteration
CumulativeTimeIteration outputs the cumulative simulation time.
Usage hints:
- Returns a single-element vector: current_time + dt for the next step.
- Useful for logging or as an input to time-dependent components.
type CumulativeTimeIteration struct{}func (*CumulativeTimeIteration) Configure
func (c *CumulativeTimeIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*CumulativeTimeIteration) Iterate
func (c *CumulativeTimeIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type DriftDiffusionIteration
DriftDiffusionIteration steps a general drift–diffusion SDE per dimension.
Usage hints:
- Provide per-dimension params: “drift_coefficients” and “diffusion_coefficients”.
- The update uses x_{t+dt} = x_t + drift*dt + diffusion*sqrt(dt)*N(0,1).
- Ensure the timestep function is configured; diffusion scales with sqrt(dt).
- Seed is taken from the partition’s Settings for reproducibility.
type DriftDiffusionIteration struct {
// contains filtered or unexported fields
}func (*DriftDiffusionIteration) Configure
func (d *DriftDiffusionIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*DriftDiffusionIteration) Iterate
func (d *DriftDiffusionIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type DriftJumpDiffusionIteration
DriftJumpDiffusionIteration steps a general drift–jump–diffusion process.
Usage hints:
- Provide per-dimension params: “drift_coefficients”, “diffusion_coefficients”, and “jump_rates”; also set a JumpDistribution implementation (e.g. Gamma).
- Uses x_{t+dt} = x_t + drift*dt + diffusion*sqrt(dt)*N(0,1) + jumps.
- Jumps occur with Poisson hazard approx. rate*dt; set dt via timestep config.
- Seed for RNGs derives from the partition’s Settings for reproducibility.
type DriftJumpDiffusionIteration struct {
JumpDist JumpDistribution
// contains filtered or unexported fields
}func (*DriftJumpDiffusionIteration) Configure
func (d *DriftJumpDiffusionIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*DriftJumpDiffusionIteration) Iterate
func (d *DriftJumpDiffusionIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type GammaJumpDistribution
GammaJumpDistribution draws jump magnitudes from a gamma distribution.
Usage hints:
- Param names per dimension: “gamma_alphas” and “gamma_betas”.
- Seed is taken from the partition’s Settings for reproducibility.
type GammaJumpDistribution struct {
// contains filtered or unexported fields
}func (*GammaJumpDistribution) Configure
func (g *GammaJumpDistribution) Configure(partitionIndex int, settings *simulator.Settings)func (*GammaJumpDistribution) NewJump
func (g *GammaJumpDistribution) NewJump(params *simulator.Params, valueIndex int) float64type GeometricBrownianMotionIteration
GeometricBrownianMotionIteration steps a multiplicative (geometric) Brownian motion per dimension.
Usage hints:
- Provide per-dimension “variances”; multiplicative noise uses sqrt(variance*dt).
- Consider log-transforms if you need additive dynamics in log space.
- Seed is taken from the partition’s Settings for reproducibility.
type GeometricBrownianMotionIteration struct {
// contains filtered or unexported fields
}func (*GeometricBrownianMotionIteration) Configure
func (g *GeometricBrownianMotionIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*GeometricBrownianMotionIteration) Iterate
func (g *GeometricBrownianMotionIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type GradientDescentIteration
GradientDescentIteration performs a gradient-based parameter update.
Usage hints:
- Provide params: “gradient” (vector) and “learning_rate” (scalar).
- Optional flag: “ascent” == 1 switches to gradient ascent.
- Update uses x_{t+1} = x_t - lr * gradient (or + for ascent).
type GradientDescentIteration struct{}func (*GradientDescentIteration) Configure
func (g *GradientDescentIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*GradientDescentIteration) Iterate
func (g *GradientDescentIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type JumpDistribution
JumpDistribution defines the interface to draw sudden jumps.
Usage hints:
- Implement for custom jump magnitudes; called when a jump event occurs.
- Used by compound Poisson processes and drift–jump–diffusions.
type JumpDistribution interface {
Configure(partitionIndex int, settings *simulator.Settings)
NewJump(params *simulator.Params, valueIndex int) float64
}type OrnsteinUhlenbeckIteration
OrnsteinUhlenbeckIteration steps an Ornstein–Uhlenbeck mean-reverting process per dimension.
Usage hints:
- Required params per dimension: “thetas” (reversion speed), “mus” (long-run mean), and “sigmas” (volatility).
- Timestep size influences both drift and diffusion terms; ensure dt is configured.
- Seed is taken from the partition’s Settings for reproducibility.
type OrnsteinUhlenbeckIteration struct {
// contains filtered or unexported fields
}func (*OrnsteinUhlenbeckIteration) Configure
func (o *OrnsteinUhlenbeckIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*OrnsteinUhlenbeckIteration) Iterate
func (o *OrnsteinUhlenbeckIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type WienerProcessIteration
WienerProcessIteration implements a standard Wiener process (Brownian motion) for stochastic simulation.
The Wiener process W(t) is a fundamental continuous-time stochastic process that serves as the building block for many other stochastic models. It represents pure random motion with no drift or mean reversion.
Mathematical Background: The Wiener process W(t) is characterized by:
- W(0) = 0 (starts at zero)
- W(t) - W(s) ~ N(0, t-s) for t > s (independent increments)
- W(t) has continuous sample paths (almost surely)
- Cov(W(s), W(t)) = min(s,t) (covariance structure)
Implementation: At each timestep, the process evolves as:
X(t+dt) = X(t) + sqrt(variance * dt) * Zwhere Z ~ N(0,1) is a standard normal random variable, variance is the per-dimension variance rate, and dt is the timestep size.
Applications:
- Financial modeling: Asset price dynamics, interest rate modeling
- Physics: Particle diffusion, thermal motion, quantum mechanics
- Engineering: Noise modeling, signal processing, control systems
- Machine learning: Stochastic optimization, sampling algorithms
Configuration:
- Provide “variances” parameter: per-dimension variance rates
- Set appropriate timestep size via TimestepFunction
- Seed controls reproducibility via partition Settings
Example:
iteration := &WienerProcessIteration{}
// Configure with variance = 0.1, dt = 0.01
// Results in sqrt(0.1 * 0.01) = 0.0316 standard deviation per stepPerformance:
- O(d) time complexity where d is the number of dimensions
- Memory usage: O(1) per dimension
- Efficient for high-dimensional simulations
type WienerProcessIteration struct {
// contains filtered or unexported fields
}func (*WienerProcessIteration) Configure
func (w *WienerProcessIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*WienerProcessIteration) Iterate
func (w *WienerProcessIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64Generated by gomarkdoc