Wolfram Language & System Documentation Center

TransformedProcess

TransformedProcess[expr,xproc,t]

represents the transformed process of expr where the variable x follows the random process proc and t denotes the time.

TransformedProcess[expr,{x₁proc₁,x₂proc₂,…},t]

represents a transformed process where x₁, x₂, … are independent and follow the processes proc₁, proc₂, ….

Details and Options

TransformedProcess is typically used to represent functional transformations of one or a finite number of time slices.
xproc can be entered as x dist proc or x \[Distributed]proc.
The processes proc_i must all be discrete-time or continuous-time processes.
The expression expr must be a function of x_i[f_ij[t]] for a finite number of different f_ij.
Assumptions on parameters can be specified using the option Assumptions->assum.
TransformedProcess can be used with such functions as Mean, PDF, Probability, and RandomFunction.

Examples

open all close all

Basic Examples (1)

Define a transformed Wiener process:

Wolfram Language code: 𝒫 = TransformedProcess[t b[2t + 1], bWienerProcess[], t];

Simulate the process:

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

Wolfram Language code: ListLinePlot[data]

Mean and variance functions:

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

Covariance function:

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

Scope (8)

Single Process Single Time (4)

Square of a Poisson process:

Wolfram Language code: 𝒫 = TransformedProcess[p[t] ^ 2, pPoissonProcess[1], t];

Simulate the process:

Wolfram Language code: data = RandomFunction[𝒫, {0, 30, 0.1}, 3];

Wolfram Language code: ListLinePlot[data]

Covariance and correlation functions for the process:

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

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

Cube of an AR process:

Wolfram Language code: 𝒫 = TransformedProcess[a[t] ^ 3, aARProcess[{1 / 5}, 1], t];

Simulate the process:

Wolfram Language code: data = RandomFunction[𝒫, {0, 30}, 3];

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

Mean and variance functions:

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

Monomial transformation of a Wiener process:

Wolfram Language code: 𝒫 = TransformedProcess[b[t] ^ k, bWienerProcess[], t];

Mean function:

Wolfram Language code: Mean[𝒫[t]]

Evaluate the mean function for specific values of k:

Wolfram Language code: {% /. {k -> 4}, % /. {k -> 6}}

Quadratic transformation of an Ornstein–Uhlenbeck process:

Wolfram Language code: 𝒫 = TransformedProcess[p[2t + 1] ^ 2 + 3, pOrnsteinUhlenbeckProcess[0, 1, 0.2], t];

Simulate the transformed process:

Wolfram Language code: data = RandomFunction[𝒫, {0, 30, 0.1}, 3];

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

Mean and variance functions are constant:

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

Verify the results by simulating a slice of the process:

Wolfram Language code: data1 = RandomVariate[𝒫[1.9], 12000];

Wolfram Language code: {Mean[data1], Variance[data1]}

Multiple Process Single Time (2)

Sum of a Wiener process and a geometric Brownian motion process:

Wolfram Language code: 𝒫 = TransformedProcess[w[t] + g[t], {wWienerProcess[], gGeometricBrownianMotionProcess[0, 1, 2]}, t];

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

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

Skewness and kurtosis functions:

Wolfram Language code: {Skewness[𝒫[t]], Kurtosis[𝒫[t]]}

Create a jump-diffusion process as the sum of a Poisson process and a Wiener process:

Wolfram Language code: Jump𝒫 = PoissonProcess[3];

Wolfram Language code: Diffusion𝒫 = WienerProcess[];

Wolfram Language code: 𝒫 = TransformedProcess[w[t] + p[t], {wDiffusion𝒫, pJump𝒫}, t];

Simulate the process:

Wolfram Language code:

tspec = {0, 3, .05};
jump = RandomFunction[Jump𝒫, tspec];
diff = RandomFunction[Diffusion𝒫, tspec];
jumpdiff = RandomFunction[𝒫, tspec];

Visualize the paths:

Wolfram Language code:

{ListPlot[{jump, diff}, PlotLegends -> Placed[{"jump", "diffusion"}, Below]], ListPlot[jumpdiff, PlotStyle -> RGBColor[0.560181, 0.691569, 0.194885], PlotLegends -> Placed[{"jump-diffusion"}, Below]]}

Compute slice properties for the process:

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

Wolfram Language code: {Skewness[𝒫[t]], Kurtosis[𝒫[t]]}

Wolfram Language code: CharacteristicFunction[𝒫[t], x]

Single Process Multiple Times (1)

Difference of two time slices for a Wiener process:

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

Probability density function:

Wolfram Language code: PDF[𝒫[t], x]

The time slices of this process follow a normal distribution:

Wolfram Language code: PDF[NormalDistribution[0, Sqrt[5]], x]

Multiple Processes Multiple Times (1)

Sum of two different time slices of a Wiener process and an Ornstein–Uhlenbeck process:

Wolfram Language code: 𝒫 = TransformedProcess[x[5t + 1] - y[7t + 3], {xWienerProcess[], yOrnsteinUhlenbeckProcess[0, 1, 1 / 5]}, t];

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

Wolfram Language code: ListLinePlot[data]

Compute probabilities and expectations:

Wolfram Language code: Assuming[{t > 3 / 7}, Probability[z[t] ^ 2 < 5z[t], z𝒫]]

Wolfram Language code: NExpectation[z[3.5] ^ 4 + 11z[3.5] + 7, z𝒫]

Options (1)

Assumptions (1)

Specify assumptions for a transformation parameter:

Wolfram Language code: 𝒫 = TransformedProcess[b[t] ^ k, bWienerProcess[], t, Assumptions -> Mod[k, 2] == 0];

Mean for the slice distribution:

Wolfram Language code: Mean[𝒫[t]]

Compare with the mean for general values of the parameter:

Wolfram Language code: 𝒫1 = TransformedProcess[b[t] ^ k, bWienerProcess[], t];

Wolfram Language code: Mean[𝒫1[t]]

Applications (14)

Periodic Signal Corrupted with Noise (1)

Add white noise to a periodic signal:

Wolfram Language code: 𝒫 = TransformedProcess[Sin[t / 10] + noise[t], noiseWhiteNoiseProcess[UniformDistribution[{-1 / 5, 1 / 5}]], t];

Wolfram Language code: data = RandomFunction[𝒫, {0, 200}];

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

Stochastic Exponential Function (1)

Define the stochastic exponential function:

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

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

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

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

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

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

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

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

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

Bessel Process (3)

Define a one-dimensional Bessel process:

Wolfram Language code: Bessel1 = TransformedProcess[Abs[x[t]], xWienerProcess[], t];

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

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

The mean and variance functions:

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

Correlation function:

Wolfram Language code: CorrelationFunction[Bessel1, 1, 2]

The slice distributions:

Wolfram Language code: CDF[Bessel1[t], x]

Compute the probability of an event:

Wolfram Language code: Probability[x[t] > 3, xBessel1]

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 squared Bessel process in 2D:

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

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

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

Mean and variance functions:

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

Brownian Bridge (1)

Define a Brownian bridge process:

Wolfram Language code: 𝒫 = TransformedProcess[b[t] - t b[1], bWienerProcess[], t];

Simulate the process:

Wolfram Language code: data = RandomFunction[𝒫, {0, 1, 0.05}, 3];

Wolfram Language code: ListLinePlot[data]

The mean of the process:

Wolfram Language code: Mean[𝒫[t]]

Compare the variance with that of BrownianBridgeProcess:

Wolfram Language code: Variance[𝒫[t]]

Wolfram Language code: Refine[% == Variance[BrownianBridgeProcess[][t]], 0 < t < 1]

Moving Average Process (1)

Define a moving average process:

Wolfram Language code: 𝒫 = TransformedProcess[x[t] + 3 x[t - 1] + 5x[t - 2], xWhiteNoiseProcess[], t];

Simulate the process:

Wolfram Language code: data = RandomFunction[𝒫, {3, 100}, 3];

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

Mean, variance, and kurtosis for the process:

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

Compare with the property values for the corresponding MAProcess:

Wolfram Language code: 𝒫1 = MAProcess[{3, 5}, 1];

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

Telegraph Process (1)

Define the telegraph process in terms of PoissonProcess:

Wolfram Language code: 𝒯 = TransformedProcess[(-1)^n[t], nPoissonProcess[1.2], t];

Simulate the process:

Wolfram Language code: data = RandomFunction[𝒯, {0, 20, 0.1}];

Wolfram Language code: ListLinePlot[data]

Probability density function for a time slice of the process:

Wolfram Language code: PDF[𝒯[t], x]

Compare with the PDF for TelegraphProcess:

Wolfram Language code: PDF[TelegraphProcess[1.2][t], x]

Gaussian Processes (1)

Linear transformations of Gaussian processes are Gaussian:

Wolfram Language code:

𝒫1 = WienerProcess[μ, σ];
𝒫2 = TransformedProcess[a x[t] + b, x𝒫1, t, Assumptions -> a∈Reals];

Verify that single slices of both processes are Gaussian:

Wolfram Language code: 𝒩 = NormalDistribution[t μ, Sqrt[t]σ];

Wolfram Language code: PDF[𝒫1[t], x] == PDF[𝒩, x]

Wolfram Language code: PDF[𝒫2[t], x] == PDF[TransformedDistribution[a y + b, y𝒩], x]//Simplify[#, a > 0 && b∈Reals && σ > 0]&

TemporalData (1)

Square of a TemporalData object:

Wolfram Language code: td = RandomFunction[ARProcess[2, {.3, -.5}, .1], {1, 100}, 1000]

Wolfram Language code: 𝒫 = TransformedProcess[x[t] ^ 2, xtd, t];

Simulate the process:

Wolfram Language code: data = RandomFunction[𝒫, {1, 100}];

Wolfram Language code: ListStepPlot[data]

Mean and variance for a time slice of the process:

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

Compare with the values obtained from simulation:

Wolfram Language code: data = RandomFunction[𝒫, {1, 100}, 100];

Wolfram Language code: {Mean[data[80]], Variance[data[80]]}

Insurance Process (1)

Simulate the surplus process for insurance, given that the insurer's initial surplus is 70 and the total annual premium is 61.2, if the number of claims follows a Poisson process with mean 60 and the losses are distributed exponentially with mean 1:

Wolfram Language code: u = 70;c = 61.2;λ = 60;m = 1;

Wolfram Language code:

InsuranceProcess = TransformedProcess[u + c t - S[t], SCompoundPoissonProcess[λ, ExponentialDistribution[1 / m]], t];

Wolfram Language code: ListLinePlot[RandomFunction[InsuranceProcess, {0, 100, 0.3}, 15]]

Delayed Process (1)

Define a delayed process:

Wolfram Language code:

delay = 1;
proc = WienerProcess[];
tp = TransformedProcess[x[t - delay], xproc, t];

Simulate the original and delayed processes:

Wolfram Language code:

{min, max, step} = {0, 3, .1};
SeedRandom[3];original = RandomFunction[proc, {min, max, step}];
SeedRandom[3];delayed = RandomFunction[tp, {delay + min, delay + max, step}];

Wolfram Language code: ListLinePlot[{original, delayed}, PlotLegends -> {"original", "delayed"}]

Standardized Process (1)

Standardize a random process to one with zero mean and unit variance:

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

Wolfram Language code: Standard𝒲 = TransformedProcess[(x[t] - Mean[𝒲[t]]) / StandardDeviation[𝒲[t]], x𝒲, t];

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

Merton's Jump-Diffusion Model (1)

Define Merton's jump-diffusion model for option pricing:

Wolfram Language code:

Merton𝒫 = TransformedProcess[(v - (σ^2/2)) t + σ w[t] + j[t], {wWienerProcess[r, σ], jCompoundPoissonProcess[λ, NormalDistribution[μ, δ]]}, t];

Simulate the process:

Wolfram Language code: data = RandomFunction[Merton𝒫 /. {v -> 1.2, σ -> 0.7, λ -> 1.3, μ -> 0.92, δ -> 0.425, r -> 1}, {0, 3, 0.02}];

Wolfram Language code: ListPlot[data]

Slice properties for the process:

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

Properties & Relations (2)

SliceDistribution relates TransformedProcess to TransformedDistribution:

Wolfram Language code:

𝒟1 = TransformedProcess[3b[t] + 5, bPoissonProcess[2], t][s];
𝒟2 = TransformedDistribution[3b + 5, bPoissonProcess[2][s]];

The resulting distributions are equal:

Wolfram Language code: CDF[𝒟1, x] == CDF[𝒟2, x]//FullSimplify

Transformed Wiener processes are related to ItoProcess:

Wolfram Language code:

𝒫1 = TransformedProcess[b[t] ^ 2, bWienerProcess[], t];
𝒫2 = ItoProcess[{0, 1, b[t] ^ 2}, b, t];

Mean, variance, etc. functions agree:

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

Wolfram Language code: Refine[CovarianceFunction[𝒫1, t, s] == CovarianceFunction[𝒫2, t, s], t < s]

Neat Examples (2)

Generate Brownian motion on the unit circle:

Wolfram Language code:

𝒫 = TransformedProcess[E ^ (I b[t]), bWienerProcess[], t];data = First@RandomFunction[𝒫, {0, 8Pi, 0.1}]["ValueList"];

Wolfram Language code: ListPlot[{Re[data], Im[data]}, AspectRatio -> Automatic]

A family of transformed Wiener processes:

Wolfram Language code:

ℬ = WienerProcess[];
𝒫1 = TransformedProcess[0.1 x[t] + t, xℬ, t];
𝒫2 = TransformedProcess[x[t] + 0.1t, xℬ, t];
𝒫3 = TransformedProcess[x[t] ^ 2 - t, xℬ, t];
𝒫4 = TransformedProcess[E ^ (x[t] - t / 2), xℬ, t];
𝒫5 = TransformedProcess[x[t] - t x[1], xℬ, t];

Wolfram Language code: data = RandomFunction[#, {0, 1, 0.01}]& /@ {ℬ, 𝒫1, 𝒫2, 𝒫3, 𝒫4, 𝒫5};

Wolfram Language code: Table[ListLinePlot[data[[i]], PlotLabel -> StringJoin["𝒫", ToString[i]]], {i, 6}]

Top

TransformedProcess

Details and Options

Examples

Basic Examples (1)

Scope (8)

Single Process Single Time (4)

Multiple Process Single Time (2)

Single Process Multiple Times (1)

Multiple Processes Multiple Times (1)

Options (1)

Assumptions (1)

Applications (14)

Periodic Signal Corrupted with Noise (1)

Stochastic Exponential Function (1)

Bessel Process (3)

Brownian Bridge (1)

Moving Average Process (1)

Telegraph Process (1)

Gaussian Processes (1)

TemporalData (1)

Insurance Process (1)

Delayed Process (1)

Standardized Process (1)

Merton's Jump-Diffusion Model (1)

Properties & Relations (2)

Neat Examples (2)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX