Stochastic Generators

`GARCHGenerator`

Bases: BaseGenerator Generate return series from a GARCH(p, q) model. The model is r_t = mu + eps_t with eps_t = sigma_t * z_t and conditional variance

sigma2_t = omega + sum_i alpha_i * eps_{t-i}^2
                 + sum_j beta_j * sigma2_{t-j}

Stationarity requires sum(alpha) + sum(beta) < 1, giving an unconditional variance of omega / (1 - sum(alpha) - sum(beta)). Squared returns are positively autocorrelated (volatility clustering) while the returns themselves are serially uncorrelated. Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series.	required
`max_length`	`int`	Maximum length of each series.	required
`freq`	`str \| int`	Pandas offset alias (e.g. ‘D’, ‘h’, ‘5min’, ‘MS’) or an integer time step.	required
`p`	`int`	GARCH order (number of variance lags, default: 1).	required
`q`	`int`	ARCH order (number of squared-innovation lags, default: 1).	required
`omega`	`float`	Constant term in the variance equation (default: 0.1).	required
`alpha`	`list[float] \| None`	ARCH coefficients; auto-generated when None.	required
`beta`	`list[float] \| None`	GARCH coefficients; auto-generated when None.	required
`mu`	`float`	Mean of returns (default: 0.0).	required
`initial_variance`	`float`	Variance used to start the recursion (default: 1.0). A 100-step burn-in removes its influence.	required
`seed`	`int \| None`	Random seed for reproducibility (default: None).	required

`GARCHGenerator.generate_single_series`

generate_single_series(length)

Generate values for a single GARCH time series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate	required

Returns:

Type	Description
`ndarray`	Array of time series values

`OrnsteinUhlenbeckGenerator`

Bases: BaseGenerator Generate time series from an Ornstein-Uhlenbeck (mean-reverting) process. The OU process is commonly used to model interest rates, volatility, and other mean-reverting phenomena:

dX_t = theta * (mu - X_t) * dt + sigma * dW_t

Simulated with the Euler-Maruyama scheme X_t = X_{t-1} + theta * (mu - X_{t-1}) * dt + sigma * sqrt(dt) * z_t, where z_t are unit-variance draws from innovation_distribution. This is an AR(1) process with coefficient phi = 1 - theta * dt, stationary mean mu, stationary variance sigma^2 * dt / (1 - phi^2) (which approaches the continuous-time sigma^2 / (2 * theta) as dt -> 0), and lag-1 autocorrelation phi. Stability requires theta * dt < 2. dt is the model time per observation and is independent of freq. Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series.	required
`max_length`	`int`	Maximum length of each series.	required
`freq`	`str \| int`	Pandas offset alias (e.g. ‘D’, ‘h’, ‘5min’, ‘MS’) or an integer for an integer time index.	required
`theta`	`float`	Speed of mean reversion, must satisfy `theta * dt < 2` (default: 0.5).	required
`mu`	`float`	Long-term mean (default: 0.0).	required
`sigma`	`float`	Volatility (default: 1.0).	required
`initial_value`	`float`	Initial value X_0 (default: 0.0).	required
`dt`	`float`	Model time step per observation (default: 1.0).	required
`seed`	`int \| None`	Random seed for reproducibility (default: None).	required

`OrnsteinUhlenbeckGenerator.generate_single_series`

generate_single_series(length)

Generate values for a single Ornstein-Uhlenbeck time series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate.	required

Returns:

Type	Description
`ndarray`	Array of time series values.

`GeometricBrownianMotionGenerator`

Bases: BaseGenerator Generate time series from Geometric Brownian Motion. GBM models strictly positive processes such as asset prices:

dS_t = mu * S_t * dt + sigma * S_t * dW_t

Simulated via the exact solution of the SDE, S_t = S_{t-1} * exp((mu - sigma^2/2) * dt + sigma * sqrt(dt) * z_t), where z_t are unit-variance draws from innovation_distribution (exact for normal innovations). dt is the model time per observation and is independent of freq: with annualized mu/sigma, daily observations correspond to dt=1/252. Note that the default dt=1.0 treats mu and sigma as per-step rates; long series with a large mu * dt grow explosively. Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series.	required
`max_length`	`int`	Maximum length of each series.	required
`freq`	`str \| int`	Pandas offset alias (e.g. ‘D’, ‘h’, ‘5min’, ‘MS’) or an integer for an integer time index.	required
`mu`	`float`	Drift per unit of model time (default: 0.05).	required
`sigma`	`float`	Volatility per sqrt unit of model time (default: 0.2).	required
`initial_value`	`float`	Initial value S_0, must be > 0 (default: 100.0).	required
`dt`	`float`	Model time step per observation (default: 1.0).	required
`seed`	`int \| None`	Random seed for reproducibility (default: None).	required

`GeometricBrownianMotionGenerator.generate_single_series`

generate_single_series(length)

Generate values for a single Geometric Brownian Motion time series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate.	required

Returns:

Type	Description
`ndarray`	Array of time series values.

`JumpDiffusionGenerator`

Bases: BaseGenerator Generate time series from a jump diffusion process (Merton model). Combines Geometric Brownian Motion with discontinuous jumps from a compound Poisson process, commonly used for asset prices with rare events:

dS_t = mu * S_t * dt + sigma * S_t * dW_t + S_{t-} * dJ_t

Each step multiplies the price by exp((mu - sigma^2/2) * dt + sigma * sqrt(dt) * z_t + sum_k Y_k) with N_t ~ Poisson(lambda_jump * dt) jumps of log-size Y_k = jump_mean + jump_std * eps_k. Both z_t and eps_k are unit-variance draws from innovation_distribution (normal by default, giving Merton’s log-normal jumps). The drift is not compensated for jumps, so the expected log-return per step is (mu - sigma^2/2) * dt + lambda_jump * dt * jump_mean. dt is the model time per observation and is independent of freq. Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series.	required
`max_length`	`int`	Maximum length of each series.	required
`freq`	`str \| int`	Pandas offset alias (e.g. ‘D’, ‘h’, ‘5min’, ‘MS’) or an integer for an integer time index.	required
`mu`	`float`	Drift per unit of model time (default: 0.05).	required
`sigma`	`float`	Diffusion volatility (default: 0.2).	required
`lambda_jump`	`float`	Jump intensity, expected jumps per unit of model time (default: 0.1).	required
`jump_mean`	`float`	Mean jump size in log-price (default: 0.0).	required
`jump_std`	`float`	Std of jump size in log-price (default: 0.1).	required
`initial_value`	`float`	Initial value S_0, must be > 0 (default: 100.0).	required
`dt`	`float`	Model time step per observation (default: 1.0).	required
`seed`	`int \| None`	Random seed for reproducibility (default: None).	required

`JumpDiffusionGenerator.generate_single_series`

generate_single_series(length)

Generate values for a single jump diffusion time series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate.	required

Returns:

Type	Description
`ndarray`	Array of time series values.

`PoissonProcessGenerator`

Bases: BaseGenerator Generate time series based on a homogeneous Poisson process. Each observation is the event count in one time step: y_t ~ Poisson(lambda_rate), i.i.d., so mean and variance both equal lambda_rate. With cumulative=True the running total N(t) = sum y_s is returned instead (the counting process itself). lambda_rate is expressed per time step of freq. Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series	required
`max_length`	`int`	Maximum length of each series	required
`freq`	`str \| int`	Frequency of the data (e.g. ‘D’, ‘h’, ‘5min’) or int	required
`lambda_rate`	`float`	Expected events per time step (default: 5.0)	required
`cumulative`	`bool`	Return cumulative counts (default: False)	required
`seed`	`int \| None`	Random seed for reproducibility (default: None)	required

`PoissonProcessGenerator.generate_single_series`

generate_single_series(length)

Generate values for a single Poisson Process time series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate	required

Returns:

Type	Description
`ndarray`	Array of time series values (counts per time period)

`CyclicGenerator`

Bases: BaseGenerator Generate time series with irregular cyclic patterns. Models business cycles and economic indicators: a linear trend plus num_cycles superposed sinusoids whose periods and amplitudes are drawn once per series (period ~ |N(period_mean, period_std)|, amplitude ~ N(amplitude_mean, amplitude_std)), plus additive noise drawn from the configured innovation_distribution. Each sinusoid’s instantaneous frequency is slowly modulated (+-20% around 2*pi/period, integrated as a cumulative phase), so cycle lengths vary within a series, unlike regular seasonal patterns. Parameters:

Name	Type	Description	Default
`base_level`	`float`	Base level of the series (default: 100.0).	required
`trend`	`float`	Linear trend coefficient per step (default: 0.0).	required
`cycle_period_mean`	`float`	Mean cycle period in steps (default: 50.0).	required
`cycle_period_std`	`float`	Std of the per-series period draw (default: 10.0).	required
`cycle_amplitude_mean`	`float`	Mean cycle amplitude (default: 20.0).	required
`cycle_amplitude_std`	`float`	Std of the per-series amplitude draw (default: 5.0).	required
`num_cycles`	`int`	Number of superposed cycle components (default: 3).	required
`noise_std`	`float`	Standard deviation of additive noise (default: 1.0).	required

`CyclicGenerator.generate_single_series`

generate_single_series(length)

Generate values for a single time series with irregular cycles. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate	required

Returns:

Type	Description
`ndarray`	Array of time series values

`FractionalBrownianMotionGenerator`

Bases: BaseGenerator Generate time series using Fractional Brownian Motion (fBm). fBm extends standard Brownian motion with a Hurst exponent H that controls long-range dependence:

H = 0.5: standard Brownian motion (independent increments)
H > 0.5: persistent/trending (positively correlated increments)
H < 0.5: anti-persistent/mean-reverting (negatively correlated)

The increments (fractional Gaussian noise, fGn) are stationary with autocovariance gamma(k) = (sigma^2/2) * (|k+1|^{2H} - 2|k|^{2H} + |k-1|^{2H}), and the path satisfies Var(B_H(t)) = sigma^2 * t^{2H}. Parameters:

Name	Type	Description	Default
`hurst`	`float`	Hurst exponent H in (0, 1) (default: 0.5).	required
`sigma`	`float`	Volatility/scale of the increments (default: 1.0).	required
`method`	`str`	Generation method: ‘fft’ (O(n log n), default), ‘cholesky’ or ‘hosking’ (both exact, O(n^2) memory).	required
`return_increments`	`bool`	Return fGn increments instead of the cumulative fBm path (default: False).	required
`initial_value`	`float`	Starting value of the fBm path; ignored when return_increments=True (default: 0.0).	required

`FractionalBrownianMotionGenerator.generate_single_series`

generate_single_series(length)

Generate a single fBm series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate.	required

Returns:

Type	Description
`ndarray`	fBm path values (or fGn increments if return_increments=True).

`FractionalBrownianMotionGenerator.get_model_info`

get_model_info()

Return model parameters and qualitative behavior.

`FractionalBrownianMotionGenerator.estimate_hurst`

estimate_hurst(series, method='rs')

Estimate the Hurst exponent from an increment (fGn) series. Parameters:

Name	Type	Description	Default
`series`	`ndarray`	Time series of increments.	required
`method`	`str`	’rs’ (rescaled range) or ‘var’ (variance of aggregates).	`‘rs’`

Returns:

Type	Description
`float`	Estimated Hurst exponent, clipped to [0.01, 0.99].

`HawkesProcessGenerator`

Bases: BaseGenerator Generate time series using Hawkes (self-exciting) point processes. Hawkes processes model events where past occurrences increase the probability of future events. The conditional intensity at time t is:

lambda(t) = mu + sum_{t_i <= t} g(t - t_i)

with baseline intensity mu and excitation kernel g. Supported kernels:

- exponential: g(t) = alpha * exp(-beta * t), branching ratio
  n = alpha / beta
- power_law: g(t) = alpha / (1 + beta * t)^p with p > 1, branching
  ratio n = alpha / (beta * (p - 1))

Stability requires n < 1; the long-run event rate is then mu / (1 - n) events per time step, and each event spawns on average 1 / (1 - n) events (itself included) in its cluster. Time is measured in steps of freq, so mu and beta are per-step quantities. Applications: order arrivals in high-frequency trading, earthquake aftershock sequences, viral cascades, clustered fraud events. Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series	required
`max_length`	`int`	Maximum length of each series	required
`freq`	`str \| int`	Frequency of the data (e.g. ‘D’, ‘h’, ‘5min’) or int	required
`baseline_intensity`	`float`	Background event rate mu per time step (default: 1.0)	required
`excitation_amplitude`	`float`	Jump in intensity per event alpha (default: 0.5)	required
`decay_rate`	`float`	Rate of intensity decay beta (default: 1.0)	required
`kernel`	`str`	Excitation kernel, ‘exponential’ or ‘power_law’ (default: ‘exponential’)	required
`power_law_exponent`	`float`	Exponent p for the power-law kernel, must be > 1 (default: 1.5)	required
`output_type`	`str`	’counts’ (events per bin), ‘intensity’ (lambda at bin midpoints), or ‘events’ (0/1 indicator per bin) (default: ‘counts’)	required
`max_events`	`int`	Maximum events to simulate per series (default: 10000)	required
`seed`	`int \| None`	Random seed for reproducibility (default: None)	required

`HawkesProcessGenerator.generate_single_series`

generate_single_series(length)

Generate values for a single Hawkes process series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate	required

Returns:

Type	Description
`ndarray`	Array of values (counts, intensity, or event indicator)

`HawkesProcessGenerator.simulate_with_events`

simulate_with_events(time_horizon)

Simulate and return both event times and intensity at those times. Parameters:

Name	Type	Description	Default
`time_horizon`	`float`	Total time to simulate	required

Returns:

Type	Description
`tuple[ndarray, ndarray]`	(event_times, intensity_at_events)

`HawkesProcessGenerator.get_model_info`

get_model_info()

Get information about the Hawkes process model. Returns:

Type	Description
`dict`	Model parameters and characteristics

`HawkesProcessGenerator.estimate_parameters`

estimate_parameters(event_times, _method='mle')

Estimate Hawkes process parameters from observed event times. Heuristic moment-based estimation: the coefficient of variation of inter-arrival times proxies the branching ratio (CV = 1 for a Poisson process, larger under clustering), and the mean rate identifies mu via rate = mu / (1 - n). Parameters:

Name	Type	Description	Default
`event_times`	`ndarray`	Array of observed event times	required
`_method`	`str`	Estimation method (currently only ‘mle’ supported)	`‘mle’`

Returns:

Type	Description
`dict`	Estimated parameters

`StochasticVolatilityGenerator`

Bases: BaseGenerator Generate time series where volatility itself follows a stochastic process. Heston model (variance is mean-reverting square-root/CIR):

dS = mu * S dt + sqrt(V) * S dW1
dV = kappa * (theta - V) dt + sigma_v * sqrt(V) dW2
Corr(dW1, dW2) = rho

SABR model (for rates/FX):

dF = sigma * F^beta dW1
dsigma = alpha * sigma dW2
Corr(dW1, dW2) = rho

Both are simulated with Euler-Maruyama; the Heston variance uses a truncation scheme (floored at a small positive value) so the discretized variance stays positive even when the Feller condition 2 * kappa * theta > sigma_v^2 is violated. Negative rho produces the leverage effect (volatility rises when prices fall). Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series.	required
`max_length`	`int`	Maximum length of each series.	required
`freq`	`str \| int`	Pandas offset alias (e.g. ‘D’, ‘h’, ‘5min’) or an integer time step.	required
`model`	`str`	’heston’ or ‘sabr’ (default: ‘heston’).	required
`initial_price`	`float`	Starting price S0 (default: 100.0).	required
`initial_vol`	`float`	Starting variance V0; SABR uses sqrt(initial_vol) as its starting volatility sigma0 (default: 0.04).	required
`drift`	`float`	Price drift mu (default: 0.05).	required
`mean_vol`	`float`	Long-run variance theta (Heston only, default: 0.04).	required
`vol_mean_reversion`	`float`	Variance mean-reversion speed kappa (Heston only, default: 2.0).	required
`vol_of_vol`	`float`	Volatility of volatility sigma_v (Heston) or alpha (SABR) (default: 0.3).	required
`correlation`	`float`	Price-volatility correlation rho in [-1, 1] (default: -0.7).	required
`beta`	`float`	CEV exponent in [0, 1] (SABR only; 0=normal, 1=lognormal, default: 0.5).	required
`dt`	`float`	Time step for discretization (default: 1/252).	required
`output_type`	`str`	’price’, ‘returns’ (log returns), or ‘volatility’ (default: ‘price’).	required
`seed`	`int \| None`	Random seed for reproducibility (default: None).	required

`StochasticVolatilityGenerator.generate_single_series`

generate_single_series(length)

Generate values for a single stochastic volatility series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate	required

Returns:

Type	Description
`ndarray`	Array of values (price, returns, or volatility)

`StochasticVolatilityGenerator.generate_with_volatility`

generate_with_volatility(n_series=1, start_id=0)

Generate series and return both prices and volatility paths. Parameters:

Name	Type	Description	Default
`n_series`	`int`	Number of series to generate (default: 1)	`1`
`start_id`	`int`	Starting ID for series naming (default: 0)	`0`

Returns:

Type	Description
`tuple[ndarray, ndarray, ndarray]`	(prices, volatilities, series_ids) arrays

`StochasticVolatilityGenerator.get_model_info`

get_model_info()

Get information about the stochastic volatility model. Returns:

Type	Description
`dict`	Model parameters and characteristics

`StochasticVolatilityGenerator.implied_volatility_smile`

implied_volatility_smile(strikes, maturity=1.0)

Approximate implied volatility smile for given strikes. Uses the Hagan SABR approximation formula (valid for the SABR model; a rough approximation for Heston). Parameters:

Name	Type	Description	Default
`strikes`	`ndarray`	Array of strike prices	required
`maturity`	`float`	Time to maturity in years	`1.0`

Returns:

Type	Description
`ndarray`	Array of implied volatilities

`RegimeSwitchingGenerator`

Bases: BaseGenerator Generate time series with Markov regime-switching dynamics. A hidden regime s_t follows a first-order Markov chain with transition matrix P (rows sum to 1). Conditional on the regime, values follow an AR(1) around the regime mean:

y_t = mu_{s_t} + phi_{s_t} * (y_{t-1} - mu_{s_t}) + sigma_{s_t} * eps_t

When no initial regime is given, s_0 is drawn from the stationary distribution pi of P (pi = pi P), so long-run regime occupancy matches pi. Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series.	required
`max_length`	`int`	Maximum length of each series.	required
`freq`	`str \| int`	Pandas offset alias (e.g. ‘D’, ‘h’, ‘5min’) or an integer time step.	required
`n_regimes`	`int`	Number of regimes/states (default: 2).	required
`regime_means`	`list[float] \| None`	Mean per regime (default: spread across levels).	required
`regime_variances`	`list[float] \| None`	Variance per regime (default: linspace(0.5, 2.0)).	required
`regime_ar_coeffs`	`list[float] \| None`	AR(1) coefficient per regime, each	phi	< 1 (default: 0).	required
`transition_matrix`	`list[list[float]] \| None`	Row-stochastic regime transition matrix (default: 0.95 self-transition probability).	required
`initial_regime`	`int \| None`	Starting regime, 0-indexed (default: drawn from the stationary distribution).	required
`seed`	`int \| None`	Random seed for reproducibility (default: None).	required

`RegimeSwitchingGenerator.generate_single_series`

generate_single_series(length)

Generate values for a single regime-switching time series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate	required

Returns:

Type	Description
`ndarray`	Array of time series values

`RegimeSwitchingGenerator.generate_with_regimes`

generate_with_regimes(n_series=1, start_id=0)

Generate series and return both values and regime labels. Parameters:

Name	Type	Description	Default
`n_series`	`int`	Number of series to generate (default: 1)	`1`
`start_id`	`int`	Starting ID for series naming (default: 0)	`0`

Returns:

Type	Description
`tuple[ndarray, ndarray, ndarray]`	(values, regimes, series_ids) arrays

`RegimeSwitchingGenerator.get_model_info`

get_model_info()

Get information about the regime-switching model. Returns:

Type	Description
`dict`	Model parameters and characteristics

`ChaoticSystemGenerator`

Bases: BaseGenerator Generate time series from deterministic chaotic dynamical systems. Produces series that look stochastic but are fully deterministic given the initial condition; randomness enters only through a seeded perturbation of the initial condition and optional observation noise. Parameters:

Name	Type	Description	Default
`system`	`str`	’lorenz’, ‘logistic’ or ‘mackey_glass’ (default: ‘lorenz’).	required
`sigma`	`float`	Lorenz sigma (default: 10.0).	required
`rho`	`float`	Lorenz rho (default: 28.0).	required
`beta_param`	`float`	Lorenz beta, alias ‘lorenz_beta’ (default: 2.6667).	required
`dt`	`float`	Lorenz RK4 integration step (default: 0.01).	required
`logistic_r`	`float`	Logistic map parameter r (default: 3.9).	required
`mg_beta`	`float`	Mackey-Glass beta (default: 0.2).	required
`mg_gamma`	`float`	Mackey-Glass gamma (default: 0.1).	required
`mg_n`	`float`	Mackey-Glass exponent n (default: 10.0).	required
`mg_tau`	`int`	Mackey-Glass delay tau (default: 17).	required
`observation_noise`	`float`	Std of additive Gaussian observation noise (default: 0.0).	required
`initial_perturbation`	`float`	Scale of the random initial-condition perturbation; 0 makes the output seed-independent (default: 0.01).	required

`ChaoticSystemGenerator.generate_single_series`

generate_single_series(length)

Generate a single chaotic time series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate.	required

Returns:

Type	Description
`ndarray`	Array of time series values.

`ChaoticSystemGenerator.get_model_info`

get_model_info()

Return information about the chaotic system configuration.

`BoundedProcessGenerator`

Bases: BaseGenerator Generate time series constrained to a bounded interval. Values are simulated on the unit interval and affinely mapped to [lower, upper] (default [0, 1]). Useful for proportions, market shares, probabilities, and other bounded quantities. Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series.	required
`max_length`	`int`	Maximum length of each series.	required
`freq`	`str \| int`	Pandas offset alias (e.g. ‘D’, ‘h’, ‘5min’) or an integer time step.	required
`model`	`str`	’beta_ar’ or ‘logit_normal’ (default: ‘beta_ar’).	required
`phi`	`float`	AR coefficient in [-1, 1] (default: 0.8).	required
`omega`	`float`	Intercept of the beta_ar conditional mean (default: 0.1). Must satisfy 0 < omega + phi * x < 1 for x in (0, 1).	required
`kappa`	`float`	Beta precision; larger = less noise (default: 20.0).	required
`sigma`	`float`	Logit-scale innovation std (logit_normal only, default: 0.3).	required
`initial_value`	`float`	Starting value on the unit scale, in (0, 1) (default: 0.5).	required
`lower`	`float`	Lower bound of the output interval (default: 0.0).	required
`upper`	`float`	Upper bound of the output interval (default: 1.0).	required
`seed`	`int \| None`	Random seed for reproducibility (default: None).	required

`BoundedProcessGenerator.generate_single_series`

generate_single_series(length)

Generate a single bounded time series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate	required

Returns:

Type	Description
`ndarray`	Array of time series values in [lower, upper]

`BoundedProcessGenerator.get_model_info`

get_model_info()

Return information about the bounded process configuration.

`LevyProcessGenerator`

Bases: BaseGenerator Generate time series with alpha-stable (Levy) increments. Each observation step adds an independent increment scale * X + location where X ~ S(alpha, beta_skew; 1) is a standard alpha-stable random variable in the S1 parameterization (matching scipy.stats.levy_stable), sampled with the Chambers-Mallows-Stuck algorithm. For alpha < 2 the increments have infinite variance, producing extreme jumps far beyond Gaussian or t-distributed innovations. There is no separate dt: scale is the per-step scale (a step of duration dt in model time corresponds to scale ~ dt**(1/alpha) by self-similarity). Parameters:

Name	Type	Description	Default
`min_length`	`int`	Minimum length of each series.	required
`max_length`	`int`	Maximum length of each series.	required
`freq`	`str \| int`	Pandas offset alias (e.g. ‘D’, ‘h’, ‘5min’, ‘MS’) or an integer for an integer time index.	required
`alpha`	`float`	Stability index in (0, 2] (default: 1.5).	required
`beta_skew`	`float`	Skewness parameter in [-1, 1] (default: 0.0).	required
`scale`	`float`	Scale of each increment (default: 1.0).	required
`location`	`float`	Location shift of each increment (default: 0.0).	required
`cumulative`	`bool`	Return the cumulative sum (Levy flight) instead of raw increments (default: True).	required
`initial_value`	`float`	Starting value for cumulative mode (default: 0.0).	required
`seed`	`int \| None`	Random seed for reproducibility (default: None).	required

`LevyProcessGenerator.generate_single_series`

generate_single_series(length)

Generate a single Levy process time series. Parameters:

Name	Type	Description	Default
`length`	`int`	The length of the series to generate.	required

Returns:

Type	Description
`ndarray`	Array of time series values.

`LevyProcessGenerator.get_model_info`

get_model_info()

Return information about the Levy process configuration.

​GARCHGenerator

​GARCHGenerator.generate_single_series

​OrnsteinUhlenbeckGenerator

​OrnsteinUhlenbeckGenerator.generate_single_series

​GeometricBrownianMotionGenerator

​GeometricBrownianMotionGenerator.generate_single_series

​JumpDiffusionGenerator

​JumpDiffusionGenerator.generate_single_series

​PoissonProcessGenerator

​PoissonProcessGenerator.generate_single_series

​CyclicGenerator

​CyclicGenerator.generate_single_series

​FractionalBrownianMotionGenerator

​FractionalBrownianMotionGenerator.generate_single_series

​FractionalBrownianMotionGenerator.get_model_info

​FractionalBrownianMotionGenerator.estimate_hurst

​HawkesProcessGenerator

​HawkesProcessGenerator.generate_single_series

​HawkesProcessGenerator.simulate_with_events

​HawkesProcessGenerator.get_model_info

​HawkesProcessGenerator.estimate_parameters

​StochasticVolatilityGenerator

​StochasticVolatilityGenerator.generate_single_series

​StochasticVolatilityGenerator.generate_with_volatility

​StochasticVolatilityGenerator.get_model_info

​StochasticVolatilityGenerator.implied_volatility_smile

​RegimeSwitchingGenerator

​RegimeSwitchingGenerator.generate_single_series

​RegimeSwitchingGenerator.generate_with_regimes

​RegimeSwitchingGenerator.get_model_info

​ChaoticSystemGenerator

​ChaoticSystemGenerator.generate_single_series

​ChaoticSystemGenerator.get_model_info

​BoundedProcessGenerator

​BoundedProcessGenerator.generate_single_series

​BoundedProcessGenerator.get_model_info

​LevyProcessGenerator

​LevyProcessGenerator.generate_single_series

​LevyProcessGenerator.get_model_info

`GARCHGenerator`

`GARCHGenerator.generate_single_series`

`OrnsteinUhlenbeckGenerator`

`OrnsteinUhlenbeckGenerator.generate_single_series`

`GeometricBrownianMotionGenerator`

`GeometricBrownianMotionGenerator.generate_single_series`

`JumpDiffusionGenerator`

`JumpDiffusionGenerator.generate_single_series`

`PoissonProcessGenerator`

`PoissonProcessGenerator.generate_single_series`

`CyclicGenerator`

`CyclicGenerator.generate_single_series`

`FractionalBrownianMotionGenerator`

`FractionalBrownianMotionGenerator.generate_single_series`

`FractionalBrownianMotionGenerator.get_model_info`

`FractionalBrownianMotionGenerator.estimate_hurst`

`HawkesProcessGenerator`

`HawkesProcessGenerator.generate_single_series`

`HawkesProcessGenerator.simulate_with_events`

`HawkesProcessGenerator.get_model_info`

`HawkesProcessGenerator.estimate_parameters`

`StochasticVolatilityGenerator`

`StochasticVolatilityGenerator.generate_single_series`

`StochasticVolatilityGenerator.generate_with_volatility`

`StochasticVolatilityGenerator.get_model_info`

`StochasticVolatilityGenerator.implied_volatility_smile`

`RegimeSwitchingGenerator`

`RegimeSwitchingGenerator.generate_single_series`

`RegimeSwitchingGenerator.generate_with_regimes`

`RegimeSwitchingGenerator.get_model_info`

`ChaoticSystemGenerator`

`ChaoticSystemGenerator.generate_single_series`

`ChaoticSystemGenerator.get_model_info`

`BoundedProcessGenerator`

`BoundedProcessGenerator.generate_single_series`

`BoundedProcessGenerator.get_model_info`

`LevyProcessGenerator`

`LevyProcessGenerator.generate_single_series`

`LevyProcessGenerator.get_model_info`