Skip to content

Main content

Ornstein–Uhlenbeck Process Simulator Source Code

Browse the implementation files for Ornstein–Uhlenbeck Process Simulator.
tool.ts typescript
import { parseFiniteNumber } from '../../parse/number/tool';
import { parseInteger } from '../../parse/integer/tool';
import { randomNormal } from '../../probability/normal-box-muller-sampler/tool';
import { createSeededRandom } from '../../random/seeded-number/tool';

export const simulateOrnsteinUhlenbeck = (
	initialInput: unknown,
	meanInput: unknown,
	reversionInput: unknown,
	volatilityInput: unknown,
	timeStepInput: unknown,
	stepsInput: unknown,
	seedInput: unknown
): string => {
	const initial = parseFiniteNumber(initialInput);
	const mean = parseFiniteNumber(meanInput);
	const reversion = parseFiniteNumber(reversionInput);
	const volatility = parseFiniteNumber(volatilityInput);
	const timeStep = parseFiniteNumber(timeStepInput);
	const steps = parseInteger(stepsInput);
	if (
		initial === null ||
		mean === null ||
		reversion === null ||
		reversion < 0 ||
		volatility === null ||
		volatility < 0 ||
		timeStep === null ||
		timeStep <= 0 ||
		steps === null ||
		steps < 1 ||
		steps > 100_000 ||
		typeof seedInput !== 'string' ||
		!seedInput.trim()
	)
		return '';
	const random = createSeededRandom(seedInput);
	const values = [initial];
	let current = initial;
	for (let step = 0; step < steps; step += 1) {
		const normal = randomNormal(random);
		if (normal === null) return '';
		current +=
			reversion * (mean - current) * timeStep +
			volatility * Math.sqrt(timeStep) * normal;
		if (!Number.isFinite(current)) return '';
		values.push(Number(current.toPrecision(10)));
	}
	return JSON.stringify(
		{
			parameters: {
				initial,
				mean,
				reversion,
				volatility,
				timeStep
			},
			seed: seedInput,
			values
		},
		null,
		2
	);
};

export const Tool: TypeTool = {
	name: 'Ornstein–Uhlenbeck Process Simulator',
	slug: 'stochastic-process/ornstein-uhlenbeck',
	intro:
		'Simulate a reproducible mean-reverting Ornstein–Uhlenbeck process with Euler–Maruyama steps.',
	tool: simulateOrnsteinUhlenbeck,
	i: [
		{
			example: '0',
			label: 'Initial Value',
			placeholder: 'Starting state',
			type: 'number'
		},
		{
			example: '1',
			label: 'Long-Run Mean',
			placeholder: 'Mean level',
			type: 'number'
		},
		{
			example: '0.7',
			label: 'Reversion Rate',
			placeholder: 'Nonnegative theta',
			type: 'number'
		},
		{
			example: '0.3',
			label: 'Volatility',
			placeholder: 'Nonnegative sigma',
			type: 'number'
		},
		{
			example: '0.1',
			label: 'Time Step',
			placeholder: 'Positive delta time',
			type: 'number'
		},
		{
			example: '50',
			label: 'Steps',
			placeholder: 'Number of steps',
			type: 'number'
		},
		{
			example: 'tool.io',
			label: 'Seed',
			placeholder: 'Reproducible seed',
			type: 'text'
		}
	],
	o: [
		{
			example: '{ "values": [0, 0.1] }',
			label: 'Process Path',
			placeholder: 'Simulated values will appear here...',
			render: 'textarea',
			type: 'text'
		}
	],
	rerunnable: true,
	cite: [
		{
			title: 'Ornstein–Uhlenbeck process - Wikipedia',
			url: 'https://en.wikipedia.org/wiki/Ornstein%E2%80%93Uhlenbeck_process'
		}
	]
};
export default Tool;

Description

Browse the implementation files for Ornstein–Uhlenbeck Process Simulator.

References

  1. Tool.io on GitHub
  2. Tool.io TypeScript tools library

Similar or alternative tools