Wolfram Language & System Documentation Center

WienerProcess

WienerProcess[μ,σ]

represents a Wiener process with a drift μ and volatility σ.

WienerProcess[]

represents a standard Wiener process with drift 0 and volatility 1.

Details

WienerProcess is also known as Brownian motion, a continuous-time random walk, or integrated white Gaussian noise.
WienerProcess is a continuous-time and continuous-state random process.
The state at time t follows NormalDistribution[μ t,σ].
The parameter μ can be any real number and the parameter σ can be any positive real number.
WienerProcess can be used with such functions as Mean, PDF, Probability, and RandomFunction.

Examples

open all close all

Basic Examples (3)

Simulate a Wiener process:

Wolfram Language code: data = RandomFunction[WienerProcess[.3, .5], {0, 1, 0.01}]

Wolfram Language code: ListLinePlot[%, Filling -> Axis]

Mean and variance functions:

Wolfram Language code: Mean[WienerProcess[μ, σ][t]]

Wolfram Language code: Variance[WienerProcess[μ, σ][t]]

Covariance function:

Wolfram Language code: CovarianceFunction[WienerProcess[μ, σ], s, t]

Wolfram Language code: CovarianceFunction[WienerProcess[], s, t]

Wolfram Language code: Plot3D[CovarianceFunction[WienerProcess[], s, t], {s, 0, 5}, {t, 0, 5}, ColorFunction -> "Rainbow"]

Scope (12)

Basic Uses (7)

Simulate an ensemble of paths:

Wolfram Language code: data = RandomFunction[WienerProcess[.3, .5], {0, 1, 0.01}, 4]

Wolfram Language code: ListLinePlot[data, Filling -> Axis]

Simulate with arbitrary precision:

Wolfram Language code: RandomFunction[WienerProcess[1 / 10, 1 / 3], {0, 1, 1 / 4}, WorkingPrecision -> 20]["Path"]

Compare paths for different values of the drift parameter:

Wolfram Language code: sample[μ_] := (SeedRandom[14];RandomFunction[WienerProcess[μ, 1], {0, 1, .01}])

Wolfram Language code: ListStepPlot[sample[#], Filling -> Axis, PlotLabel -> StringJoin["μ = ", ToString[#]]]& /@ {-2, 0, 2}

Compare paths for different values of the volatility parameter:

Wolfram Language code: sample[σ_] := (SeedRandom[4];RandomFunction[WienerProcess[0, σ], {0, 1, .01}])

Wolfram Language code:

ListStepPlot[sample[#], Filling -> Axis, PlotRange -> {-1, 3}, PlotLabel -> StringJoin["σ = ", ToString[#]]]& /@ {.5, 1, 1.4}

Process parameter estimation:

Wolfram Language code: data = RandomFunction[WienerProcess[.4, .7], {0, 100, 0.01}];

Wolfram Language code: EstimatedProcess[data, WienerProcess[μ, σ]]

Correlation function:

Wolfram Language code: CorrelationFunction[WienerProcess[μ, σ], s, t]

Absolute correlation function:

Wolfram Language code: AbsoluteCorrelationFunction[WienerProcess[μ, σ], s, t]

Process Slice Properties (5)

Univariate SliceDistribution:

Wolfram Language code: SliceDistribution[WienerProcess[μ, σ], t]

First-order probability density function:

Wolfram Language code:

Plot[Evaluate@Table[PDF[WienerProcess[][t], x], {t, {1 / 2, 1, 2}}], {x, -4, 4}, Filling -> Axis, PlotLegends -> {"t = 1/2", "t = 1", "t = 2"}]

Wolfram Language code: PDF[WienerProcess[μ, σ][t], x]

Compare with the density function of a normal distribution:

Wolfram Language code: PDF[NormalDistribution[μ t, σ Sqrt[t]], x]

Wolfram Language code: Simplify[% - %%]

Multivariate slice distributions:

Wolfram Language code: SliceDistribution[WienerProcess[μ, σ], {s, t}]

Wolfram Language code: WienerProcess[][{1, 2, 3}]//Mean

Second-order PDF:

Wolfram Language code: PDF[WienerProcess[μ, σ][{s, t}], {x, y}]

Higher-order PDF:

Wolfram Language code: PDF[WienerProcess[μ, σ][{1, 3, 7}], {x, y, z}]

Compute the expectation of an expression:

Wolfram Language code: Expectation[x[t] ^ 2, xWienerProcess[μ, σ]]

Calculate the probability of an event:

Wolfram Language code: Probability[x[t] < 6, xWienerProcess[μ, σ]]

Skewness and kurtosis are constant:

Wolfram Language code: Skewness[WienerProcess[μ, σ][t]]

Wolfram Language code: Kurtosis[WienerProcess[μ, σ][t]]

Moment of order r:

Wolfram Language code: Moment[WienerProcess[μ, σ][t], r]

Generating functions:

Wolfram Language code: CharacteristicFunction[WienerProcess[μ, σ][t], w]

Wolfram Language code: MomentGeneratingFunction[WienerProcess[μ, σ][t], w]

CentralMoment and its generating function:

Wolfram Language code: CentralMoment[WienerProcess[μ, σ][t], r]

Wolfram Language code: CentralMomentGeneratingFunction[WienerProcess[μ, σ][t], w]

FactorialMoment has no closed form for symbolic order:

Wolfram Language code: FactorialMoment[WienerProcess[μ, σ][t], 3]

Wolfram Language code: FactorialMomentGeneratingFunction[WienerProcess[μ, σ][t], w]

Cumulant and its generating function:

Wolfram Language code: Cumulant[WienerProcess[μ, σ][t], r]

Wolfram Language code: CumulantGeneratingFunction[WienerProcess[μ, σ][t], w]

Applications (7)

Define a two-dimensional Bessel process:

Wolfram Language code: Bessel2 = TransformedProcess[Sqrt[x[t]^2 + y[t]^2], {xWienerProcess[], yWienerProcess[]}, t];

Wolfram Language code: data = RandomFunction[Bessel2, {0, 10, 0.01}, 3];

Wolfram Language code: ListLinePlot[data, PlotRange -> All]

Mean and variance functions:

Wolfram Language code: {Mean[Bessel2[t]], Variance[Bessel2[t]]}

Define a martingale process using a quadratic WienerProcess:

Wolfram Language code: proc = TransformedProcess[w[t] ^ 2 - t, wWienerProcess[], t];

Wolfram Language code: Mean[proc[t]]

Wolfram Language code: CovarianceFunction[proc, s, t]

Wolfram Language code: ListLinePlot[RandomFunction[proc, {0, 2, .01}, 3]]

Define the stochastic exponential function:

Wolfram Language code: 𝒫 = TransformedProcess[E^w[t] - (t/2), wWienerProcess[], t];

Wolfram Language code:

SeedRandom[5];
data = RandomFunction[𝒫, {0, 10, 0.01}, 3];

Wolfram Language code: ListLinePlot[data, PlotRange -> All]

Slice properties:

Wolfram Language code: {Mean[𝒫[t]], Variance[𝒫[t]]}

The corresponding differential equation is u[t]  u[t] w[t]:

Wolfram Language code: 𝒫2 = ItoProcess[ⅆu[t] == u[t]ⅆw[t], u[t], {u, 1}, t, wWienerProcess[]];

Wolfram Language code:

SeedRandom[5];
data = RandomFunction[𝒫2, {0, 10, 0.01}, 3];

Wolfram Language code: ListLinePlot[data, PlotRange -> All]

Slice properties:

Wolfram Language code: {Mean[𝒫2[t]], Variance[𝒫2[t]]}

Use WienerProcess directly to simulate GeometricBrownianMotionProcess:

Wolfram Language code: μ = 1;σ = 1 / 3;x0 = 2;

Wolfram Language code:

proc = WienerProcess[μ - σ^2 / 2, σ];
SeedRandom[3];
data = RandomFunction[proc, {0, 1, s = .01}];

Apply a transformation to the random sample:

Wolfram Language code: sample = x0 Exp[data];

Compare to the corresponding GeometricBrownianMotionProcess:

Wolfram Language code:

SeedRandom[3];
gbm = RandomFunction[GeometricBrownianMotionProcess[μ, σ, x0], {s, 1 + s, s}];

Wolfram Language code: ListLinePlot[{sample, gbm}, PlotStyle -> {Thick, Dashed}]

Use WienerProcess directly to simulate BrownianBridgeProcess:

Wolfram Language code: μ = 0;σ = 1 / 3;t0 = 0;t1 = 2;x0 = 0;x1 = 0;

Wolfram Language code:

proc = WienerProcess[μ, σ];
SeedRandom[3];
data = RandomFunction[proc, {t0, t1, .01}];

Apply a transformation to the random sample:

Wolfram Language code:

sample = TimeSeriesMapThread[x0(x1 - x0)(#1 - t0) / (t1 - t0) + #2 - (#1 - t0) Last[data["Values"]] / (t1 - t0) - (t1 - #1)First[data["Values"]] / (t1 - t0)&, data];

Compare to the corresponding BrownianBridgeProcess:

Wolfram Language code:

SeedRandom[3];
data = RandomFunction[BrownianBridgeProcess[σ, {t0, x0}, {t1, x1}], {t0, t1, .01}];

Wolfram Language code: ListLinePlot[{sample, data}, PlotStyle -> {Thick, Dotted}]

Use Wiener process to simulate a solution to the stochastic differential equation :

Wolfram Language code: P[t_, w_] := p E^σ w + (μ - (σ^2/2)) t

Use the simulation to plot the solution:

Wolfram Language code: μ = 2;σ = .1;p = 1;

Wolfram Language code:

sim = RandomFunction[WienerProcess[], {0, 3, 0.01}, 10 ^ 2];
sol = TimeSeriesMapThread[P[#1, #2]&, sim];

Wolfram Language code: paths = ListLinePlot[sol, PlotStyle -> Directive[Opacity[.1]]]

Find the mean function of the simulated paths:

Wolfram Language code: meanFunction = TimeSeriesThread[Mean, sol];

Wolfram Language code: Show[paths, ListLinePlot[meanFunction, PlotStyle -> Directive[Black, Thick]]]

Compare with the corresponding smooth solution:

Wolfram Language code: smoothsol = NDSolve[P'[t] == μ P[t] && P[0] == p, P, {t, 0, 3}]

Wolfram Language code: Plot[P[t] /. smoothsol, {t, 0, 3}]

Find the distribution of the time a WienerProcess with positive drift takes to reach 2:

Wolfram Language code: sample = Map[FirstCase[#, _ ? (Last[#] ≥ 2&)]&, RandomFunction[WienerProcess[1, 1], {0, 15, 0.01}, 10 ^ 4]["Paths"]];

Remove empty lists and extract times:

Wolfram Language code: data0 = DeleteCases[sample, {}][[All, 1]];

Select positive values:

Wolfram Language code: data = Cases[data0, _ ? Positive];

Fit InverseGaussianDistribution to the data:

Wolfram Language code: edist = EstimatedDistribution[data, InverseGaussianDistribution[μ, λ]]

Compare its histogram to the PDF:

Wolfram Language code:

Show[
	Histogram[data, 20, "PDF"], 
	Plot[PDF[edist, x], {x, 0, 10}, PlotStyle -> Thick]]

Properties & Relations (12)

A Wiener process is not weakly stationary:

Wolfram Language code: WeakStationarity[WienerProcess[μ, σ]]

Wiener process has independent increments:

Wolfram Language code: proc = WienerProcess[μ, σ];

Wolfram Language code: Expectation[(x[t2] - x[t1])(x[t4] - x[t3]), xproc, Assumptions -> 0 < t1 < t2 < t3 < t4]//Simplify

Compare to the product of expectations:

Wolfram Language code:

Expectation[(x[t2] - x[t1]), xproc, Assumptions -> 0 < t1 < t2] * Expectation[(x[t4] - x[t3]), xproc, Assumptions -> 0 < t3 < t4]//Simplify

Wolfram Language code: % === %%

Conditional cumulative distribution function:

Wolfram Language code:

Table[Plot[Evaluate@Probability[(x[5] <= Subscript[x, 2])(x[2] == Subscript[x, 1]), xWienerProcess[]], {Subscript[x, 2], -4, 6}, Filling -> Axis, PlotLabel -> Row[{"SubscriptBox[x, 1] = ", Subscript[x, 1]}]], {Subscript[x, 1], {-1.5, -.4, 1.3, 3}}]

Wolfram Language code:

Probability[(x[Subscript[t, 2]] ≤ Subscript[x, 2])(x[Subscript[t, 1]] == Subscript[x, 1]), xWienerProcess[], Assumptions -> 0 < Subscript[t, 1] < Subscript[t, 2] && 0 ≤ Subscript[x, 1] ≤ Subscript[t, 1] && 0 ≤ Subscript[x, 2] ≤ Subscript[t, 2]]//Simplify

The correlation function of the Wiener process is the same as that of RandomWalkProcess:

Wolfram Language code: CorrelationFunction[RandomWalkProcess[p], s, t]

Wolfram Language code: CorrelationFunction[WienerProcess[μ, σ], s, t]

A Wiener process is a special ItoProcess:

Wolfram Language code: ItoProcess[WienerProcess[μ, σ]]

As well as StratonovichProcess:

Wolfram Language code: StratonovichProcess[WienerProcess[μ, σ]]

Simulate the proportion of time spent on the positive side by a standard WienerProcess:

Wolfram Language code: data[n_] := RandomFunction[WienerProcess[], {0, 1, 1 / n}];

Wolfram Language code: ratio[n_] := Count[data[n]["Values"], _ ? Positive] / n

In the limit, the ratio follows ArcSinDistribution:

Wolfram Language code: sample[n_, walks_] := Table[ratio[n], {i, walks}]

Wolfram Language code:

Show[Histogram[sample[10 ^ 3, 10 ^ 3], 20, "PDF"], Plot[PDF[ArcSinDistribution[{0, 1}], x], {x, 0, 1}, PlotStyle -> Thick]]

Find the distribution of the last time WienerProcess changed sign between times 0 and 1:

Wolfram Language code: data = RandomFunction[WienerProcess[], {0, 1, .01}, 10 ^ 4];

Calculate the differences of signs to find sign changes:

Wolfram Language code: diff = Differences[Sign[data]];

Extract paths and find times of the last sign change for each path:

Wolfram Language code: paths = diff["Paths"];

Wolfram Language code: sample = Map[First[FirstCase[Reverse[#], _ ? (Last[#] =!= 0&)]]&, paths];

In the limit, the times follow ArcSinDistribution:

Wolfram Language code: Show[Histogram[sample, 20, "PDF"], Plot[PDF[ArcSinDistribution[{0, 1}], x], {x, 0, 1}, PlotStyle -> Thick]]

Find the distribution of the time corresponding to the maximum value of WienerProcess until time 1:

Wolfram Language code: data = RandomFunction[WienerProcess[], {0, 1, .01}, n = 10 ^ 4]["Paths"];

From each path, extract the times corresponding to the maximum for that path:

Wolfram Language code:

sample = {};
Do[
	path = data[[i]];
	m = Max[path[[All, 2]]];AppendTo[sample, First@FirstCase[path, _ ? (Last[#] == m&)]], {i, n}]

In the limit, the times follow ArcSinDistribution:

Wolfram Language code:

Show[Histogram[sample, 20, "PDF"], Plot[PDF[ArcSinDistribution
	[{0, 1}], x], {x, 0, 1}, PlotStyle -> Thick]]

Wiener process is scaling invariant:

Wolfram Language code: proc = TransformedProcess[Sqrt[c]x[t / c], xWienerProcess[], t];

Wolfram Language code: Mean[proc[t]]

Covariance function:

Wolfram Language code: CovarianceFunction[proc, s, t]

Compare to the WienerProcess:

Wolfram Language code: Mean[WienerProcess[][t]]

Wolfram Language code: CovarianceFunction[WienerProcess[], s, t]

Wiener process is invariant under a difference transformation:

Wolfram Language code: proc = TransformedProcess[x[t + u] - x[u], xWienerProcess[], t];

Wolfram Language code: Mean[proc[t]]

Covariance function:

Wolfram Language code: CovarianceFunction[proc, s, t]

Compare to the WienerProcess:

Wolfram Language code: Mean[WienerProcess[][t]]

Wolfram Language code: CovarianceFunction[WienerProcess[], s, t]

GeometricBrownianMotionProcess is a transformation of a WienerProcess:

Wolfram Language code: proc[μ_, σ_, a_] := TransformedProcess[a Exp[(μ - σ^2 / 2)t + σ w[t]], wWienerProcess[], t]

Wolfram Language code: ListLinePlot[RandomFunction[proc[0, 1, 3], {0, 1, .001}]]

PDF of a slice distribution:

Wolfram Language code: PDF[proc[0, 1, 3][t], x]

Compare to the slice distribution of the corresponding GeometricBrownianMotionProcess:

Wolfram Language code: PDF[GeometricBrownianMotionProcess[0, 1, 3][t], x]

Wolfram Language code: % - %%//FullSimplify

Wiener process is a transformation of BrownianBridgeProcess:

Wolfram Language code: 𝒫 = TransformedProcess[(t + 1)x[t / (t + 1)], xBrownianBridgeProcess[], t];

Wolfram Language code: Mean[𝒫[t]]

Covariance function:

Wolfram Language code: CovarianceFunction[𝒫, s, t]

Wolfram Language code: sample = RandomFunction[𝒫, {0, 1, .01}];

Wolfram Language code: ListLinePlot[sample, Filling -> Axis]

Neat Examples (3)

Simulate a Wiener process in two dimensions:

Wolfram Language code: SeedRandom[103];sample = RandomFunction[WienerProcess[], {0, 1, .001}, 2]["ValueList"];

Wolfram Language code: ListLinePlot[Transpose@sample, ColorFunction -> "FallColors"]

Simulate a Wiener process in three dimensions:

Wolfram Language code:

proc = WienerProcess[];
SeedRandom[123];
sample = Table[RandomFunction[proc, {0, 1, 0.01}, 3]["ValueList"], {6}];

Wolfram Language code: Graphics3D@Table[{ColorData["SolarColors"][RandomReal[]], Tube@Line@sample[[i]]}, {i, 6}]

Simulate 500 paths from a Wiener process:

Wolfram Language code: data = RandomFunction[WienerProcess[], {0, 1, .01}, 500];

Take a slice at 1 and visualize its distribution:

Wolfram Language code: sd = data["SliceData", 1];

Wolfram Language code:

cf = ColorData["Rainbow"];
sliced = BarChart[Last[#], Axes -> False, BarOrigin -> Left, AspectRatio -> 4, ChartStyle -> (cf /@ Rescale[MovingAverage[First[#], 2], {Min[sd], Max[sd]}, {0, 1}]), ImageSize -> 70]&[HistogramList[sd, {Range[Min[sd], Max[sd], (Max[sd] - Min[sd]) / 20]}]];

Plot paths and histogram distribution of the slice distribution at 1:

Wolfram Language code:

ListLinePlot[data, ImageSize -> 400, PlotRange -> All, 
	AspectRatio -> 3 / 4, Epilog -> Inset[sliced, {1.01, 0}, {0, 10}], PlotStyle -> (cf /@ Rescale[sd]), BaseStyle -> Directive[Thin, Opacity[0.5]], PlotRangePadding -> {{0, .25}, {.5, .5}}]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

WienerProcess

Details

Examples

Basic Examples (3)

Scope (12)

Basic Uses (7)

Process Slice Properties (5)

Applications (7)

Properties & Relations (12)

Neat Examples (3)

Text

CMS

APA

BibTeX

BibLaTeX

WienerProcess

Details

Examples

Basic Examples (3)

Scope (12)

Basic Uses (7)

Process Slice Properties (5)

Applications (7)

Properties & Relations (12)

Neat Examples (3)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX