Neural ODEs and SDEs API Reference

Neural ODE classes, Neural fSDE classes, SDE solvers, and noise models.

Neural ODEs

Targeted Optimized Neural Fractional Ordinary Differential Equations (Neural fODE)

This module provides targeted optimizations for neural networks that can learn to represent fractional differential equations, focusing on high-impact improvements without adding unnecessary complexity.

Key Improvements: - Optimized fractional ODE implementation (proper fractional calculus) - Advanced solver options with better performance - Memory optimization for large inputs - Improved training efficiency - Performance monitoring without overhead

Author: Davian R. Chin, Department of Biomedical Engineering, University of Reading Targeted Optimization: September 2025

class hpfracc.ml.neural_ode.NeuralODEConfig(input_dim=2, hidden_dim=64, output_dim=2, num_layers=3, activation='tanh', use_adjoint=True, solver='dopri5', rtol=1e-05, atol=1e-05, fractional_order=None, device=None, dtype=torch.float32, enable_performance_monitoring=False, memory_optimization=True, use_advanced_solvers=True)[source]

Bases: object

Targeted configuration for neural ODE models

Parameters:

input_dim (int)
hidden_dim (int)
output_dim (int)
num_layers (int)
activation (str)
use_adjoint (bool)
solver (str)
rtol (float)
atol (float)
fractional_order (float | FractionalOrder | None)
device (torch.device | None)
dtype (torch.dtype)
enable_performance_monitoring (bool)
memory_optimization (bool)
use_advanced_solvers (bool)

input_dim: int = 2

hidden_dim: int = 64

output_dim: int = 2

num_layers: int = 3

activation: str = 'tanh'

use_adjoint: bool = True

solver: str = 'dopri5'

rtol: float = 1e-05

atol: float = 1e-05

fractional_order: float | FractionalOrder | None = None

device: torch.device | None = None

enable_performance_monitoring: bool = False

memory_optimization: bool = True

use_advanced_solvers: bool = True

__init__(input_dim=2, hidden_dim=64, output_dim=2, num_layers=3, activation='tanh', use_adjoint=True, solver='dopri5', rtol=1e-05, atol=1e-05, fractional_order=None, device=None, dtype=torch.float32, enable_performance_monitoring=False, memory_optimization=True, use_advanced_solvers=True)

Parameters:

input_dim (int)
hidden_dim (int)
output_dim (int)
num_layers (int)
activation (str)
use_adjoint (bool)
solver (str)
rtol (float)
atol (float)
fractional_order (float | FractionalOrder | None)
device (torch.device | None)
dtype (torch.dtype)
enable_performance_monitoring (bool)
memory_optimization (bool)
use_advanced_solvers (bool)

Return type:

None

class hpfracc.ml.neural_ode.BaseNeuralODE(*args, **kwargs)[source]

Bases: Module, ABC

Targeted optimized base class for Neural ODE implementations

Parameters:: config (NeuralODEConfig)

__init__(config)[source]

Parameters:: config (NeuralODEConfig)

_setup_layer()[source]: Setup layer-specific components

_build_network()[source]: Build neural network architecture with optimizations

_initialize_weights()[source]: Optimized weight initialization

_get_activation(x)[source]

Apply activation function

Parameters:: x (torch.Tensor)
Return type:: torch.Tensor

ode_func(t, x)[source]

Optimized ODE function with improved tensor handling

Parameters:

t (torch.Tensor)
x (torch.Tensor)

Return type:

torch.Tensor

abstractmethod forward(x, t)[source]

Forward pass - must be implemented by subclasses

Parameters:

x (torch.Tensor)
t (torch.Tensor)

Return type:

torch.Tensor

class hpfracc.ml.neural_ode.NeuralODE(*args, **kwargs)[source]

Bases: BaseNeuralODE

Targeted optimized Neural ODE implementation

Parameters:

input_dim (int)
hidden_dim (int)
output_dim (int)
num_layers (int)
activation (str)
use_adjoint (bool)
solver (str)
rtol (float)
atol (float)

__init__(input_dim, hidden_dim, output_dim, num_layers=3, activation='tanh', use_adjoint=True, solver='dopri5', rtol=1e-05, atol=1e-05)[source]

Parameters:

input_dim (int)
hidden_dim (int)
output_dim (int)
num_layers (int)
activation (str)
use_adjoint (bool)
solver (str)
rtol (float)
atol (float)

_check_torchdiffeq()[source]

Check if torchdiffeq is available

Return type:: bool

forward(x, t)[source]

Optimized forward pass

Parameters:

x (torch.Tensor)
t (torch.Tensor)

Return type:

torch.Tensor

_solve_torchdiffeq(x, t)[source]

Solve using torchdiffeq with optimizations

Parameters:

x (torch.Tensor)
t (torch.Tensor)

Return type:

torch.Tensor

_solve_optimized_euler(x, t)[source]

Optimized Euler solver with memory efficiency

Parameters:

x (torch.Tensor)
t (torch.Tensor)

Return type:

torch.Tensor

class hpfracc.ml.neural_ode.NeuralFODE(*args, **kwargs)[source]

Bases: BaseNeuralODE

Targeted optimized Neural Fractional ODE implementation

Parameters:

input_dim (int)
hidden_dim (int)
output_dim (int)
fractional_order (float | FractionalOrder)
num_layers (int)
activation (str)
use_adjoint (bool)
solver (str)
rtol (float)
atol (float)

__init__(input_dim, hidden_dim, output_dim, fractional_order=0.5, num_layers=3, activation='tanh', use_adjoint=True, solver='fractional_euler', rtol=1e-05, atol=1e-05)[source]

Parameters:

input_dim (int)
hidden_dim (int)
output_dim (int)
fractional_order (float | FractionalOrder)
num_layers (int)
activation (str)
use_adjoint (bool)
solver (str)
rtol (float)
atol (float)

get_fractional_order()[source]

Get the fractional order

Return type:: float

_check_torchdiffeq()[source]

Check if torchdiffeq is available

Return type:: bool

forward(x, t)[source]

Optimized fractional forward pass

Parameters:

x (torch.Tensor)
t (torch.Tensor)

Return type:

torch.Tensor

_solve_fractional_ode_optimized(x, t)[source]

Optimized fractional ODE solver with proper fractional calculus. Uses the L1 scheme (Grünwald-Letnikov weights) for correct memory handling.

Parameters:

x (torch.Tensor)
t (torch.Tensor)

Return type:

torch.Tensor

class hpfracc.ml.neural_ode.NeuralODETrainer(model, optimizer='adam', learning_rate=0.001, loss_function='mse')[source]

Bases: object

Targeted optimized trainer for Neural ODE models

Parameters:

model (NeuralODE | NeuralFODE)
optimizer (str)
learning_rate (float)
loss_function (str)

__init__(model, optimizer='adam', learning_rate=0.001, loss_function='mse')[source]

Parameters:

model (NeuralODE | NeuralFODE)
optimizer (str)
learning_rate (float)
loss_function (str)

_setup_optimizer(optimizer_type)[source]

Set up optimizer

Parameters:: optimizer_type (str)
Return type:: torch.optim.Optimizer

_setup_loss_function(loss_type)[source]

Set up loss function

Parameters:: loss_type (str)
Return type:: torch.nn.Module

train_step(x, y_target, t)[source]

Optimized training step

Parameters:

x (torch.Tensor)
y_target (torch.Tensor)
t (torch.Tensor)

Return type:

float

_validate(data_loader)[source]

Compute average validation loss over a data loader.

Return type:: float

train(data_loader, num_epochs=1, verbose=False)[source]

Parameters:

num_epochs (int)
verbose (bool)

hpfracc.ml.neural_ode.create_neural_ode(model_type='standard', **kwargs)[source]

Factory function to create neural ODE models

Parameters:: model_type (str)
Return type:: NeuralODE | NeuralFODE

hpfracc.ml.neural_ode.create_neural_ode_trainer(model, **kwargs)[source]

Factory function to create targeted neural ODE trainer

Parameters:: model (NeuralODE | NeuralFODE)
Return type:: NeuralODETrainer

Neural fSDE

Neural Fractional Stochastic Differential Equations

This module provides neural network-based fractional SDEs with adjoint training methods for efficient gradient-based learning.

class hpfracc.ml.neural_fsde.NeuralFSDEConfig(input_dim=2, hidden_dim=64, output_dim=2, num_layers=3, activation='tanh', use_adjoint=True, solver='dopri5', rtol=1e-05, atol=1e-05, fractional_order=None, device=None, dtype=torch.float32, enable_performance_monitoring=False, memory_optimization=True, use_advanced_solvers=True, diffusion_dim=1, noise_type='additive', drift_net=None, diffusion_net=None, use_sde_adjoint=True, learn_alpha=False)[source]

Bases: NeuralODEConfig

Configuration for neural fractional SDE models.

Parameters:

input_dim (int)
hidden_dim (int)
output_dim (int)
num_layers (int)
activation (str)
use_adjoint (bool)
solver (str)
rtol (float)
atol (float)
fractional_order (float | FractionalOrder | None)
device (torch.device | None)
dtype (torch.dtype)
enable_performance_monitoring (bool)
memory_optimization (bool)
use_advanced_solvers (bool)
diffusion_dim (int)
noise_type (str)
drift_net (torch.nn.Module | None)
diffusion_net (torch.nn.Module | None)
use_sde_adjoint (bool)
learn_alpha (bool)

diffusion_dim: int = 1

noise_type: str = 'additive'

drift_net: torch.nn.Module | None = None

diffusion_net: torch.nn.Module | None = None

use_sde_adjoint: bool = True

learn_alpha: bool = False

__init__(input_dim=2, hidden_dim=64, output_dim=2, num_layers=3, activation='tanh', use_adjoint=True, solver='dopri5', rtol=1e-05, atol=1e-05, fractional_order=None, device=None, dtype=torch.float32, enable_performance_monitoring=False, memory_optimization=True, use_advanced_solvers=True, diffusion_dim=1, noise_type='additive', drift_net=None, diffusion_net=None, use_sde_adjoint=True, learn_alpha=False)

Parameters:

input_dim (int)
hidden_dim (int)
output_dim (int)
num_layers (int)
activation (str)
use_adjoint (bool)
solver (str)
rtol (float)
atol (float)
fractional_order (float | FractionalOrder | None)
device (torch.device | None)
dtype (torch.dtype)
enable_performance_monitoring (bool)
memory_optimization (bool)
use_advanced_solvers (bool)
diffusion_dim (int)
noise_type (str)
drift_net (torch.nn.Module | None)
diffusion_net (torch.nn.Module | None)
use_sde_adjoint (bool)
learn_alpha (bool)

Return type:

None

class hpfracc.ml.neural_fsde.NeuralFractionalSDE(*args, **kwargs)[source]

Bases: BaseNeuralODE

Neural network-based fractional SDE with adjoint training.

Extends neural ODE framework to fractional stochastic differential equations for modeling stochastic dynamics with memory effects.

The model learns: - Drift function f(t, x): deterministic dynamics - Diffusion function g(t, x): stochastic noise magnitude - Fractional order: memory effects in dynamics

Parameters:: config (NeuralFSDEConfig)

__init__(config)[source]

Initialize neural fractional SDE.

Parameters:: config (NeuralFSDEConfig) – Configuration for the neural fSDE

_build_drift_network()[source]: Build neural network for drift function.

_build_diffusion_network()[source]: Build neural network for diffusion function.

drift_function(t, x)[source]

Alias for drift() for compatibility with tests.

Parameters:

t (torch.Tensor)
x (torch.Tensor)

Return type:

torch.Tensor

diffusion_function(t, x)[source]

Alias for diffusion() for compatibility with tests.

Parameters:

t (torch.Tensor)
x (torch.Tensor)

Return type:

torch.Tensor

drift(t, x)[source]

Compute drift function f(t, x).

Parameters:

t (torch.Tensor) – Time tensor
x (torch.Tensor) – State tensor

Returns:

Drift vector

Return type:

torch.Tensor

diffusion(t, x)[source]

Compute diffusion function g(t, x).

Parameters:

t (torch.Tensor) – Time tensor
x (torch.Tensor) – State tensor

Returns:

Diffusion matrix

Return type:

torch.Tensor

fractional_order()[source]

Get current fractional order.

Return type:: float

forward(x0, t, method='euler_maruyama', num_steps=100, seed=None)[source]

Forward pass through neural fractional SDE.

Parameters:

x0 (torch.Tensor) – Initial condition
t (torch.Tensor) – Time points (1D tensor or 2D batch)
method (str) – Solver method
num_steps (int) – Number of integration steps
seed (int | None) – Random seed for reproducibility

Returns:

Trajectory solution

Return type:

torch.Tensor

_solve_fractional_sde_torch(x0, t_start, t_end, num_steps, seed=None)[source]

PyTorch-native fractional SDE solver (Euler-Maruyama).

Parameters:

x0 (torch.Tensor)
t_start (torch.Tensor)
t_end (torch.Tensor)
num_steps (int)
seed (int | None)

Return type:

torch.Tensor

get_fractional_order()[source]

Get the fractional order parameter.

Return type:: float | torch.Tensor

adjoint_forward(x0, t, **kwargs)[source]

Adjoint-compatible forward pass.

Parameters:

x0 (torch.Tensor)
t (torch.Tensor)

Return type:

torch.Tensor

hpfracc.ml.neural_fsde.create_neural_fsde(input_dim=None, output_dim=None, hidden_dim=64, num_layers=3, fractional_order=0.5, diffusion_dim=1, noise_type='additive', learn_alpha=False, use_adjoint=True, drift_net=None, diffusion_net=None, config=None)[source]

Factory function to create a neural fractional SDE.

Parameters:

input_dim (int) – Input dimension
output_dim (int) – Output dimension
hidden_dim (int) – Hidden layer dimension
num_layers (int) – Number of hidden layers
fractional_order (float) – Initial fractional order
diffusion_dim (int) – Dimension of noise
noise_type (str) – Type of noise (“additive” or “multiplicative”)
learn_alpha (bool) – Whether to learn fractional order
use_adjoint (bool) – Use adjoint method for backpropagation
drift_net (torch.nn.Module | None) – Custom drift network
diffusion_net (torch.nn.Module | None) – Custom diffusion network
config (NeuralFSDEConfig | None)

Returns:

NeuralFractionalSDE instance

Return type:

NeuralFractionalSDE

SDE Solvers

Fractional Stochastic Differential Equation Solvers

This module provides comprehensive solvers for fractional SDEs including various numerical methods, adaptive step size control, and error estimation.

Performance Note: - Uses FFT-based convolution for O(N log N) history summation instead of O(N²) - Intelligent backend selection for optimal performance - Multi-backend support (PyTorch, JAX, NumPy/Numba)

hpfracc.solvers.sde_solvers._get_gamma_function()[source]: Get gamma function through adapter system.

hpfracc.solvers.sde_solvers._get_intelligent_selector()[source]: Get intelligent backend selector instance.

hpfracc.solvers.sde_solvers._fft_convolution(coeffs, values, axis=0)[source]

Fast convolution using FFT for O(N log N) performance.

Parameters:

coeffs (ndarray) – Coefficient array (1D)
values (ndarray) – Value array (can be 1D or 2D)
axis (int) – Axis along which to perform convolution

Returns:

Convolution result (same shape as values)

Return type:

ndarray

class hpfracc.solvers.sde_solvers.SDESolution(t, y, fractional_order, method, drift_func, diffusion_func, metadata=None)[source]

Bases: object

Solution object for SDE solvers.

Parameters:

t (ndarray)
y (ndarray)
fractional_order (float | FractionalOrder)
method (str)
drift_func (Callable)
diffusion_func (Callable)
metadata (Dict[str, Any])

t: ndarray

y: ndarray

fractional_order: float | FractionalOrder

method: str

drift_func: Callable

diffusion_func: Callable

metadata: Dict[str, Any] = None

__init__(t, y, fractional_order, method, drift_func, diffusion_func, metadata=None)

Parameters:

t (ndarray)
y (ndarray)
fractional_order (float | FractionalOrder)
method (str)
drift_func (Callable)
diffusion_func (Callable)
metadata (Dict[str, Any])

Return type:

None

class hpfracc.solvers.sde_solvers.FractionalSDESolver(fractional_order, definition='caputo', adaptive=False, rtol=1e-05, atol=1e-08)[source]

Bases: ABC

Base class for fractional SDE solvers.

A fractional SDE takes the form:

D^α X(t) = f(t, X(t)) dt + g(t, X(t)) dW(t)

where:

α is the fractional order
f is the drift function
g is the diffusion function
W(t) is a Wiener process

Parameters:

fractional_order (float | FractionalOrder)
definition (str)
adaptive (bool)
rtol (float)
atol (float)

__init__(fractional_order, definition='caputo', adaptive=False, rtol=1e-05, atol=1e-08)[source]

Initialize fractional SDE solver.

Parameters:

fractional_order (float | FractionalOrder) – Fractional order (0 < α < 2)
definition (str) – Type of fractional derivative (“caputo” or “riemann_liouville”)
adaptive (bool) – Use adaptive step size
rtol (float) – Relative tolerance for adaptive stepping
atol (float) – Absolute tolerance for adaptive stepping

abstractmethod solve(drift, diffusion, x0, t_span, noise_model=None, **kwargs)[source]

Solve fractional SDE.

Parameters:

drift (Callable[[float, ndarray], ndarray]) – Drift function f(t, x) -> R^d
diffusion (Callable[[float, ndarray], ndarray]) – Diffusion function g(t, x) -> R^(d x m) where m is dimension of noise
x0 (ndarray) – Initial condition
t_span (Tuple[float, float]) – Time interval (t0, tf)
**kwargs – Additional solver parameters
noise_model (NoiseModel | None)

Returns:

SDESolution object containing trajectory

Return type:

SDESolution

class hpfracc.solvers.sde_solvers.FastHistoryConvolution(alpha, num_steps, dim)[source]

Bases: object

Helper class for efficient history convolution in fractional SDE solvers.

Features: - Pre-allocated arrays to avoid list overhead (O(N) -> O(1) allocation) - Dynamic switching between direct dot product (small N) and FFT (large N) - JAX/SciPy/NumPy backend support via _fft_convolution

Parameters:

alpha (float)
num_steps (int)
dim (int)

__init__(alpha, num_steps, dim)[source]

Parameters:

alpha (float)
num_steps (int)
dim (int)

update(value)[source]

Add new value to history.

Parameters:: value (ndarray)

convolve()[source]

Compute convolution of weights with history.

Return type:: ndarray

hpfracc.solvers.sde_solvers._milstein_fd_eps(x, base=1e-06)[source]

Scale-aware finite-difference step for ∂g/∂x.

Parameters:

x (ndarray)
base (float)

Return type:

float

hpfracc.solvers.sde_solvers._milstein_correction_diagonal(diffusion, t, x, g_vec, dW, dt)[source]

Diagonal / independent-noise Milstein correction:

0.5 * sum_i g_i(t,x) * (∂g_i/∂x_i) * (dW_i^2 - dt)

with ∂g_i/∂x_i approximated by central differences on x_i.

Parameters:

diffusion (Callable[[float, ndarray], ndarray])
t (float)
x (ndarray)
g_vec (ndarray)
dW (ndarray)
dt (float)

Return type:

ndarray

hpfracc.solvers.sde_solvers._milstein_correction_single_wiener(diffusion, t, x, g_vec, dW, dt)[source]

Milstein correction for a single driving Wiener process (m=1, dW scalar):

0.5 * (dW^2 - dt) * sum_j g_j * (∂g_k/∂x_j) for each component k.

Uses central differences in the state directions x_j.

Parameters:

diffusion (Callable[[float, ndarray], ndarray])
t (float)
x (ndarray)
g_vec (ndarray)
dW (ndarray)
dt (float)

Return type:

ndarray

class hpfracc.solvers.sde_solvers.FractionalEulerMaruyama(*args, **kwargs)[source]

Bases: FractionalSDESolver

Fractional Euler-Maruyama method for solving fractional SDEs.

This is a first-order strong convergence method.

__init__(*args, **kwargs)[source]

Initialize fractional SDE solver.

Parameters:

fractional_order – Fractional order (0 < α < 2)
definition – Type of fractional derivative (“caputo” or “riemann_liouville”)
adaptive – Use adaptive step size
rtol – Relative tolerance for adaptive stepping
atol – Absolute tolerance for adaptive stepping

solve(drift, diffusion, x0, t_span, num_steps=100, seed=None, noise_model=None, **kwargs)[source]

Solve fractional SDE using Euler-Maruyama method.

Parameters:

drift (Callable) – Drift function f(t, x)
diffusion (Callable) – Diffusion function g(t, x)
x0 (ndarray) – Initial condition
t_span (Tuple[float, float]) – Time interval (t0, tf)
num_steps (int) – Number of time steps
seed (int | None) – Random seed for Wiener process
noise_model (NoiseModel | None) – Optional noise model for non-Brownian noise

Returns:

SDESolution object

Return type:

SDESolution

class hpfracc.solvers.sde_solvers.FractionalMilstein(*args, **kwargs)[source]

Bases: FractionalSDESolver

Fractional SDE integrator with the same history-convolution path as Euler–Maruyama, plus a Milstein correction where supported.

The correction uses the standard form 0.5 * (dW^2 - dt) multiplied by terms involving spatial derivatives of the diffusion, approximated by central finite differences.

Supported

Diagonal noise: g(t,x) returns a vector of length d; one Brownian increment per component (same layout as Euler–Maruyama).
Single Wiener process: g(t,x) returns shape (d, 1); scalar dW.

Not implemented

General matrix diffusion with m > 1 independent Wiener processes (Levy area / non-commutative terms not included). Use diagonal or scalar noise, or extend the solver.

__init__(*args, **kwargs)[source]

Initialize fractional SDE solver.

Parameters:

fractional_order – Fractional order (0 < α < 2)
definition – Type of fractional derivative (“caputo” or “riemann_liouville”)
adaptive – Use adaptive step size
rtol – Relative tolerance for adaptive stepping
atol – Absolute tolerance for adaptive stepping

solve(drift, diffusion, x0, t_span, num_steps=100, seed=None, noise_model=None, **kwargs)[source]

Integrate with fractional history terms and Milstein correction (supported cases).

Parameters:

drift (Callable)
diffusion (Callable)
x0 (ndarray)
t_span (Tuple[float, float])
num_steps (int)
seed (int | None)
noise_model (NoiseModel | None)

Return type:

SDESolution

hpfracc.solvers.sde_solvers.solve_fractional_sde(drift, diffusion, x0, t_span, fractional_order=0.5, method='euler_maruyama', num_steps=100, seed=None, noise_model=None, **kwargs)[source]

Solve a fractional SDE.

Parameters:

drift (Callable) – Drift function f(t, x) -> R^d
diffusion (Callable) – Diffusion function g(t, x) -> R^(d x m)
x0 (ndarray) – Initial condition
t_span (Tuple[float, float]) – Time interval (t0, tf)
fractional_order (float | FractionalOrder) – Fractional order (0 < α < 2)
method (str) – Solver method (euler_maruyama or milstein). milstein adds a finite-difference Milstein correction for diagonal noise or a single Wiener driver; see FractionalMilstein.
num_steps (int) – Number of time steps
seed (int | None) – Random seed for Wiener process
**kwargs – Additional solver parameters
noise_model (NoiseModel | None)

Returns:

SDESolution object

Return type:

SDESolution

Example

>>> def drift(t, x):
...     return -0.5 * x
>>> def diffusion(t, x):
...     return 0.2 * np.eye(1)
>>> x0 = np.array([1.0])
>>> sol = solve_fractional_sde(drift, diffusion, x0, (0, 1), 0.5, num_steps=100)
>>> print(sol.y[-1])

hpfracc.solvers.sde_solvers.solve_fractional_sde_system(drift, diffusion, x0, t_span, fractional_order, method='euler_maruyama', noise_type='additive', num_steps=100, seed=None, noise_model=None, **kwargs)[source]

Solve a system of coupled fractional SDEs.

Parameters:

drift (Callable) – Drift function f(t, x) -> R^d
diffusion (Callable) – Diffusion function g(t, x) -> R^(d x m)
x0 (ndarray) – Initial condition
t_span (Tuple[float, float]) – Time interval (t0, tf)
fractional_order (float | FractionalOrder | List[float]) – Fractional order(s) for system
method (str) – Solver method
noise_type (str) – Type of noise (“additive” or “multiplicative”)
num_steps (int) – Number of time steps
seed (int | None) – Random seed
noise_model (NoiseModel | None) – Optional noise model
**kwargs – Additional parameters

Returns:

SDESolution object

Return type:

SDESolution

Noise Models

Stochastic Noise Models for Fractional SDEs

This module provides various noise models including Brownian motion, fractional Brownian motion, Lévy processes, and coloured noise.

class hpfracc.solvers.noise_models.NoiseModel[source]

Bases: ABC

Base class for stochastic noise models.

abstractmethod generate_increment(t, dt, size=(), seed=None)[source]

Generate noise increment.

Parameters:

t (float) – Current time
dt (float) – Time step
size (Tuple[int, ...]) – Output shape
seed (int | None) – Random seed

Returns:

Noise increment array

Return type:

ndarray

prepare(num_steps, dt, size=())[source]

Optional preparation step for pre-computing noise paths. Useful for non-Markovian processes like fBm.

Parameters:

num_steps (int)
dt (float)
size (Tuple[int, ...])

class hpfracc.solvers.noise_models.BrownianMotion(scale=1.0)[source]

Bases: NoiseModel

Standard Brownian motion (Wiener process).

Generates independent Gaussian increments with variance dt.

Parameters:: scale (float)

__init__(scale=1.0)[source]

Initialize Brownian motion.

Parameters:: scale (float) – Scaling factor for noise

generate_increment(t, dt, size=(), seed=None)[source]

Generate Wiener increment.

Parameters:

t (float)
dt (float)
size (Tuple[int, ...])
seed (int | None)

Return type:

ndarray

variance(dt)[source]

Get variance of increment.

Parameters:: dt (float)
Return type:: float

class hpfracc.solvers.noise_models.FractionalBrownianMotion(hurst=0.5, scale=1.0)[source]

Bases: NoiseModel

Fractional Brownian motion (fBm).

A Gaussian process with long-range dependence characterized by the Hurst exponent H (0 < H < 1).

Parameters:

hurst (float)
scale (float)

__init__(hurst=0.5, scale=1.0)[source]

Initialize fractional Brownian motion.

Parameters:

hurst (float) – Hurst exponent (H=0.5 gives standard Brownian motion)
scale (float) – Scaling factor for noise

prepare(num_steps, dt, size=())[source]

Pre-compute fBm increments using Davies-Harte method (FFT).

Parameters:

num_steps (int)
dt (float)
size (Tuple[int, ...])

generate_increment(t, dt, size=(), seed=None)[source]

Generate fractional Brownian motion increment.

Uses precomputed Davies-Harte increments if available, otherwise falls back to simplified independent increments (with warning).

Parameters:

t (float)
dt (float)
size (Tuple[int, ...])
seed (int | None)

Return type:

ndarray

property is_standard_bm: bool: Check if this is standard Brownian motion.

class hpfracc.solvers.noise_models.LevyNoise(alpha=1.5, beta=0.0, scale=1.0, location=0.0)[source]

Bases: NoiseModel

Lévy noise for jump diffusions.

Uses stable distributions to model heavy-tailed noise.

Parameters:

alpha (float)
beta (float)
scale (float)
location (float)

__init__(alpha=1.5, beta=0.0, scale=1.0, location=0.0)[source]

Initialize Lévy noise.

Parameters:

alpha (float) – Stability parameter (0 < α ≤ 2)
beta (float) – Skewness parameter (-1 ≤ β ≤ 1)
scale (float) – Scale parameter
location (float) – Location parameter

generate_increment(t, dt, size=(), seed=None)[source]

Generate Lévy noise increment.

Uses stable distribution sampling (simplified implementation).

Parameters:

t (float)
dt (float)
size (Tuple[int, ...])
seed (int | None)

Return type:

ndarray

class hpfracc.solvers.noise_models.ColouredNoise(correlation_time=1.0, amplitude=1.0, seed=None)[source]

Bases: NoiseModel

Coloured noise (Ornstein-Uhlenbeck process).

Gaussian noise with exponential autocorrelation.

Parameters:

correlation_time (float)
amplitude (float)
seed (int | None)

__init__(correlation_time=1.0, amplitude=1.0, seed=None)[source]

Initialize coloured noise.

Parameters:

correlation_time (float) – Correlation time constant
amplitude (float) – Noise amplitude
seed (int | None) – Random seed for state initialization

generate_increment(t, dt, size=(), seed=None)[source]

Generate coloured noise increment.

Parameters:

t (float)
dt (float)
size (Tuple[int, ...])
seed (int | None)

Return type:

ndarray

reset()[source]: Reset the noise process state.

hpfracc.solvers.noise_models.numpyro_brownian_noise(t, dt, scale=1.0)[source]

NumPyro model for Brownian noise.

Parameters:

t (float) – Current time
dt (float) – Time step
scale (float) – Noise scale

Returns:

NumPyro sample

hpfracc.solvers.noise_models.numpyro_fractional_brownian_noise(t, dt, hurst=0.5, scale=1.0)[source]

NumPyro model for fractional Brownian noise.

Parameters:

t (float) – Current time
dt (float) – Time step
hurst (float) – Hurst exponent
scale (float) – Noise scale

Returns:

NumPyro sample

hpfracc.solvers.noise_models.numpyro_levy_noise(t, dt, alpha=1.5, scale=1.0)[source]

NumPyro model for Lévy noise.

Note: NumPyro doesn’t have stable distribution, so uses approximation.

Parameters:

t (float) – Current time
dt (float) – Time step
alpha (float) – Stability parameter
scale (float) – Noise scale

Returns:

NumPyro sample

class hpfracc.solvers.noise_models.NoiseConfig(noise_type='brownian', hurst=0.5, scale=1.0, alpha=1.5, beta=0.0, correlation_time=1.0, amplitude=1.0)[source]

Bases: object

Configuration for noise models.

Parameters:

noise_type (str)
hurst (float)
scale (float)
alpha (float)
beta (float)
correlation_time (float)
amplitude (float)

noise_type: str = 'brownian'

hurst: float = 0.5

scale: float = 1.0

alpha: float = 1.5

beta: float = 0.0

correlation_time: float = 1.0

amplitude: float = 1.0

__init__(noise_type='brownian', hurst=0.5, scale=1.0, alpha=1.5, beta=0.0, correlation_time=1.0, amplitude=1.0)

Parameters:

noise_type (str)
hurst (float)
scale (float)
alpha (float)
beta (float)
correlation_time (float)
amplitude (float)

Return type:

None

hpfracc.solvers.noise_models.create_noise_model(config)[source]

Create a noise model from configuration.

Parameters:: config (NoiseConfig) – Noise configuration
Returns:: NoiseModel instance
Return type:: NoiseModel

hpfracc.solvers.noise_models.generate_noise_trajectory(noise_model, t_span, num_steps, size=(), seed=None)[source]

Generate a complete noise trajectory.

Parameters:

noise_model (NoiseModel) – Noise model to use
t_span (Tuple[float, float]) – Time interval (t0, tf)
num_steps (int) – Number of steps
size (Tuple[int, ...]) – Shape of noise increments
seed (int | None) – Random seed

Returns:

Tuple of (time array, noise increments array)

Return type:

Tuple[ndarray, ndarray]