discrete
import "github.com/umbralcalc/stochadex/pkg/discrete"Package discrete provides implementations of discrete-time and event-based stochastic processes for simulation modeling. It includes counting processes, state transition models, and other discrete stochastic dynamics commonly used in queueing theory, epidemiology, finance, and system modeling.
Key Features:
- Poisson processes for event counting and arrival modeling
- Bernoulli processes for binary outcomes and trials
- Binomial observation processes for sampling and measurement
- Categorical state transitions for discrete state spaces
- Cox processes for intensity-driven event modeling
- Hawkes processes for self-exciting event sequences
Mathematical Background: Discrete stochastic processes typically model events, transitions, or counting phenomena. They are characterized by:
- Discrete state spaces (integers, categories, binary states)
- Event-driven dynamics (jumps, arrivals, transitions)
- Probability distributions for event occurrence
- Memory properties (Markovian vs. non-Markovian)
Usage Patterns:
- Queueing systems (arrival processes, service times)
- Epidemiology (disease spread, infection events)
- Finance (default events, insurance claims)
- Network modeling (packet arrivals, connection events)
- Manufacturing (production events, quality control)
Index
- type BernoulliProcessIteration
- type
BinomialObservationProcessIteration
- func (b *BinomialObservationProcessIteration) Configure(partitionIndex int, settings *simulator.Settings)
- func (b *BinomialObservationProcessIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
- type
CategoricalStateTransitionIteration
- func (c *CategoricalStateTransitionIteration) Configure(partitionIndex int, settings *simulator.Settings)
- func (c *CategoricalStateTransitionIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
- type CoxProcessIteration
- type
HawkesProcessIntensityIteration
- func NewHawkesProcessIntensityIteration(excitingKernel kernels.IntegrationKernel, hawkesPartitionIndex int) *HawkesProcessIntensityIteration
- func (h *HawkesProcessIntensityIteration) Configure(partitionIndex int, settings *simulator.Settings)
- func (h *HawkesProcessIntensityIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64
- type HawkesProcessIteration
- type PoissonProcessIteration
type BernoulliProcessIteration
BernoulliProcessIteration emits 1/0 based on per-dimension success probs.
Usage hints:
- Provide “state_value_observation_probs” with values in [0, 1].
- Outputs are written in-place to the current state row and returned.
- Seed is taken from the partition’s Settings for reproducibility.
type BernoulliProcessIteration struct {
// contains filtered or unexported fields
}func (*BernoulliProcessIteration) Configure
func (b *BernoulliProcessIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*BernoulliProcessIteration) Iterate
func (b *BernoulliProcessIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type BinomialObservationProcessIteration
BinomialObservationProcessIteration draws binomial counts for selected indices.
Usage hints:
- Provide: “observed_values” (counts), “state_value_observation_probs” (p’s), and “state_value_observation_indices” (which entries to observe).
- For each index i: draws Binomial(N=observed_values[i], p=probs[i]).
- Seed is taken from the partition’s Settings for reproducibility.
type BinomialObservationProcessIteration struct {
// contains filtered or unexported fields
}func (*BinomialObservationProcessIteration) Configure
func (b *BinomialObservationProcessIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*BinomialObservationProcessIteration) Iterate
func (b *BinomialObservationProcessIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type CategoricalStateTransitionIteration
CategoricalStateTransitionIteration is essentially a state machine which transitions between states according to the event rate parameters.
type CategoricalStateTransitionIteration struct {
// contains filtered or unexported fields
}func (*CategoricalStateTransitionIteration) Configure
func (c *CategoricalStateTransitionIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*CategoricalStateTransitionIteration) Iterate
func (c *CategoricalStateTransitionIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type CoxProcessIteration
CoxProcessIteration defines an iteration for a Cox process.
type CoxProcessIteration struct {
// contains filtered or unexported fields
}func (*CoxProcessIteration) Configure
func (c *CoxProcessIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*CoxProcessIteration) Iterate
func (c *CoxProcessIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type HawkesProcessIntensityIteration
HawkesProcessIntensityIteration an iteration for a Hawkes process self-exciting intensity function.
type HawkesProcessIntensityIteration struct {
// contains filtered or unexported fields
}func NewHawkesProcessIntensityIteration
func NewHawkesProcessIntensityIteration(excitingKernel kernels.IntegrationKernel, hawkesPartitionIndex int) *HawkesProcessIntensityIterationNewHawkesProcessIntensityIteration creates a new HawkesProcessIntensityIteration given a partition index for the Hawkes process itself.
func (*HawkesProcessIntensityIteration) Configure
func (h *HawkesProcessIntensityIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*HawkesProcessIntensityIteration) Iterate
func (h *HawkesProcessIntensityIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type HawkesProcessIteration
HawkesProcessIteration defines an iteration for a Hawkes process.
type HawkesProcessIteration struct {
// contains filtered or unexported fields
}func (*HawkesProcessIteration) Configure
func (h *HawkesProcessIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*HawkesProcessIteration) Iterate
func (h *HawkesProcessIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64type PoissonProcessIteration
PoissonProcessIteration implements a Poisson counting process for event simulation.
The Poisson process is a fundamental counting process that models the occurrence of random events in continuous time. It is widely used in queueing theory, reliability analysis, and event-driven modeling.
Domain Context: Poisson processes model random events occurring independently in time. Common applications include:
- Arrival times in queueing systems (customers, packets, calls)
- Radioactive decay events (particle emissions, nuclear decay)
- Network packet arrivals (data transmission, network traffic)
- Insurance claim arrivals (accidents, claims processing)
- Manufacturing defects (quality control, failure events)
Mathematical Properties: The Poisson process N(t) with rate λ has the following properties:
- N(0) = 0 (starts at zero)
- N(t) - N(s) ~ Poisson(λ(t-s)) for t > s (independent increments)
- Inter-arrival times are exponentially distributed with rate λ
- Number of events in [0,t] follows Poisson(λt) distribution
- Events occur at rate λ per unit time on average
Implementation Details:
- Probability of event in timestep dt ≈ λ * dt (for small dt)
- Uses uniform random sampling for event detection
- Maintains cumulative count of events since t=0
- Each dimension can have different event rates
Configuration:
- Provide “rates” parameter: per-dimension event rates (λ values)
- Set timestep size via TimestepFunction to control event probability
- Seed controls reproducibility via partition Settings
Example:
iteration := &PoissonProcessIteration{}
// Configure with rate = 0.5, dt = 0.01
// Event probability per step ≈ 0.5 * 0.01 = 0.005 (0.5%)Performance:
- O(d) time complexity where d is the number of dimensions
- Memory usage: O(1) per dimension
- Efficient for high-dimensional event modeling
type PoissonProcessIteration struct {
// contains filtered or unexported fields
}func (*PoissonProcessIteration) Configure
func (p *PoissonProcessIteration) Configure(partitionIndex int, settings *simulator.Settings)func (*PoissonProcessIteration) Iterate
func (p *PoissonProcessIteration) Iterate(params *simulator.Params, partitionIndex int, stateHistories []*simulator.StateHistory, timestepsHistory *simulator.CumulativeTimestepsHistory) []float64Generated by gomarkdoc