FractionalGaussianNoiseProcess
FractionalGaussianNoiseProcess[μ,σ,h]
represents a fractional Gaussian noise process with drift μ, volatility σ, and Hurst index h.
FractionalGaussianNoiseProcess[h]
represents a fractional Gaussian noise process with drift 0, volatility 1, and Hurst index h.
Details
- FractionalGaussianNoiseProcess is a continuous-time and continuous-state random process.
- FractionalGaussianNoiseProcess is a Gaussian process with mean function
and covariance function ![sigma^2 (TemplateBox[{{t, -, s, -, 1}}, Abs]^(2 h)-2 TemplateBox[{{t, -, s}}, Abs]^(2 h)+TemplateBox[{{t, -, s, +, 1}}, Abs]^(2 h))/2](Files/FractionalGaussianNoiseProcess.en/2.png "sigma^2 (TemplateBox[{{t, -, s, -, 1}}, Abs]^(2 h)-2 TemplateBox[{{t, -, s}}, Abs]^(2 h)+TemplateBox[{{t, -, s, +, 1}}, Abs]^(2 h))/2")
. - FractionalGaussianNoiseProcess[μ,σ,h] is equivalent to TransformedProcess[x[t+1]-x[t],xFractionalBrownianMotionProcess[μ,σ,h],t].
- FractionalGaussianNoiseProcess allows μ to be any real number, σ to be any positive real number, and h to be a real number between 0 and 1.
- FractionalGaussianNoiseProcess can be used with such functions as RandomFunction and CovarianceFunction.
Examples
open all close allBasic Examples (3)
Simulate a fractional Gaussian noise process:
sample = RandomFunction[FractionalGaussianNoiseProcess[.3], {0, 1, .1}]ListLinePlot[RandomFunction[FractionalGaussianNoiseProcess[.4], {0, 100, 1}], Filling -> Axis]Mean and variance functions are constant:
Mean[FractionalGaussianNoiseProcess[μ, σ, h][t]]Variance[FractionalGaussianNoiseProcess[μ, σ, h][t]]CovarianceFunction[FractionalGaussianNoiseProcess[μ, σ, h], s, t]Plot3D[CovarianceFunction[FractionalGaussianNoiseProcess[0, 3, .8], s, t], {s, 0, 10}, {t, 0, 10}, ColorFunction -> "Rainbow"]Scope (11)
Basic Uses (6)
Simulate an ensemble of paths:
data = RandomFunction[FractionalGaussianNoiseProcess[.3], {0, 1, .01}, 4]ListLinePlot[data, Filling -> Axis]Simulate with arbitrary precision:
RandomFunction[FractionalGaussianNoiseProcess[1 / 3], {0, 1, 1 / 4}, WorkingPrecision -> 20]["Path"]Compare paths for various Hurst indices:
sample[h_] := (SeedRandom[3];RandomFunction[FractionalGaussianNoiseProcess[h], {0, 100, 1}])params = {.1, .5, .9};ListLinePlot[sample[#], Filling -> Axis, PlotLabel -> (StringJoin["h = ", ToString[#]])]& /@ paramsSeedRandom[25];data = RandomFunction[FractionalGaussianNoiseProcess[0.4], {0, 140, 1}];EstimatedProcess[data, FractionalGaussianNoiseProcess[h]]Correlation function as a function of lags:
DiscretePlot[CorrelationFunction[FractionalGaussianNoiseProcess[#], k], {k, 1, 10}, ExtentSize -> 1 / 2, PlotRange -> {-.3, .3}, ColorFunction -> "DarkRainbow", PlotLabel -> StringJoin["h = ", ToString[#]]]& /@ {.3, .7}CorrelationFunction[FractionalGaussianNoiseProcess[μ, σ, h], k]Absolute correlation function:
AbsoluteCorrelationFunction[FractionalGaussianNoiseProcess[μ, σ, h], k]Process Slice Properties (5)
Univariate SliceDistribution:
SliceDistribution[FractionalGaussianNoiseProcess[μ, σ, h], t]First-order probability density function does not depend on time:
Plot[Evaluate[PDF[FractionalGaussianNoiseProcess[1 / 3][t], x]], {x, -4, 4}, Filling -> Axis]PDF[FractionalGaussianNoiseProcess[μ, σ, h][t], x]Compare with the density function of a normal distribution:
PDF[NormalDistribution[μ, σ], x]Simplify[% - %%]Multivariate slice distribution:
SliceDistribution[FractionalGaussianNoiseProcess[1 / 3], {s, t}]Slice distribution of higher order will not autoevaluate:
sd = SliceDistribution[FractionalGaussianNoiseProcess[.3], {1, 2, 3}]Through[{Mean, Variance}[sd]]Plot3D[PDF[FractionalGaussianNoiseProcess[1 / 8][{1, 6}], {x, y}], {x, -3, 3}, {y, -3, 3}]PDF[FractionalGaussianNoiseProcess[1 / 8][{1, 6}], {x, y}]Compute the expectation of an expression:
Expectation[x + x ^ 2, xFractionalGaussianNoiseProcess[μ, σ, h][t]]Calculate the probability of an event:
Probability[x < 6, xFractionalGaussianNoiseProcess[μ, σ, h][t]]Skewness and kurtosis are constant:
Skewness[FractionalGaussianNoiseProcess[μ, σ, h][t]]Kurtosis[FractionalGaussianNoiseProcess[μ, σ, h][t]]Moment[FractionalGaussianNoiseProcess[μ, σ, h][t], r]CharacteristicFunction[FractionalGaussianNoiseProcess[μ, σ, h][t], w]MomentGeneratingFunction[FractionalGaussianNoiseProcess[μ, σ, h][t], w]CentralMoment and its generating function:
CentralMoment[FractionalGaussianNoiseProcess[μ, σ, h][t], r]CentralMomentGeneratingFunction[FractionalGaussianNoiseProcess[μ, σ, h][t], w]FactorialMoment[FractionalGaussianNoiseProcess[μ, σ, h][t], 3]FactorialMomentGeneratingFunction[FractionalGaussianNoiseProcess[μ, σ, h][t], w]Cumulant and its generating function:
Cumulant[FractionalGaussianNoiseProcess[μ, σ, h][t], r]CumulantGeneratingFunction[FractionalGaussianNoiseProcess[μ, σ, h][t], w]Generalizations & Extensions (1)
Applications (1)
Consider the time series of yearly minimal water levels of the Nile River for the years 622–1281:
NileFlow = TemporalData[TimeSeries, {{{1157, 1088, 1169, 1169, 984, 1322, 1178, 1103, 1211, 1292, 1124, 1171,
1133, 1227, 1142, 1216, 1259, 1299, 1232, 1117, 1155, 1232, 1083, 1020, 1394, 1196, 1148, 1083,
1189, 1133, 1034, 1157, 1034, 1097, 1299, 1 ... ,
1187, 1196, 1220, 1166, 1128, 1101, 1157, 1175, 1142, 1187, 1254, 1198, 1263, 1283, 1252, 1160,
1234, 1234, 1232, 1306, 1205, 1054, 1151, 1108, 1097}}, {{622, 1281, 659/662}}, 1,
{"Discrete", 1}, {"Discrete", 1}, 1, {}}, False, 10.];ListLinePlot[NileFlow, Filling -> Axis]Fit a fractional Gaussian noise process:
eproc = EstimatedProcess[NileFlow["Values"], FractionalGaussianNoiseProcess[m, s, h]]Compare means of the data and the model:
Mean[NileFlow]//NMean[eproc[t]]dataCov = CovarianceFunction[NileFlow["Values"], {10}];
modelCov = CovarianceFunction[eproc, k];Show[DiscretePlot[modelCov, {k, 0, 10}, ExtentSize -> 1 / 2], ListLinePlot[dataCov, DataRange -> {0, 10}]]Simulate the values for the following 100 years:
paths = RandomFunction[eproc, {1282, 1282 + 100, 1}, 3];
ListLinePlot[paths]Properties & Relations (7)
FractionalGaussianNoiseProcess is weakly stationary:
WeakStationarity[FractionalGaussianNoiseProcess[μ, σ, h]]Fractional Gaussian noise process is mean ergodic:
proc = FractionalGaussianNoiseProcess[0, 1, 1 / 3];The process is weakly stationary:
WeakStationarity[proc]Calculate absolute correlation function:
abscorr[h_] = AbsoluteCorrelationFunction[proc, h]Find value of the strip integral:
int[t_] = 1 / (2 * t)Integrate[(1 - Abs[u] / (2 * t))abscorr[u], {u, -2 * t, 2 * t}, Assumptions -> t > 0]Check if the limit of the integral is 0 to conclude mean ergodicity:
Limit[int[t], t -> ∞]Fractional Gaussian noise does not have independent increments for 
:
proc = FractionalGaussianNoiseProcess[μ, σ, h];Expectation[(x[t2] - x[t1])(x[t4] - x[t3]), xproc, Assumptions -> 0 < t1 < t2 < t3 < t4]//SimplifyCompare to the product of expectations:
Expectation[(x[t2] - x[t1]), xproc, Assumptions -> 0 < t1 < t2] * Expectation[(x[t4] - x[t3]), xproc, Assumptions -> 0 < t3 < t4]% === %%Fractional Gaussian noise has a long memory for a Hurst parameter greater than 1/2:
proc[h_] := FractionalGaussianNoiseProcess[h];DiscretePlot[CovarianceFunction[proc[#], k], {k, 1, 50, 5}, ExtentSize -> 1 / 2, PlotRange -> {-.3, .6}, PlotLabel -> StringJoin["h = ", ToString[#]]]& /@ {.3, .5, .7, .9}Covariance function for a long memory process is not summable:
Sum[CovarianceFunction[proc[.8], k], {k, 0, ∞}]
For a short memory, process is summable:
Sum[CovarianceFunction[proc[.3], k], {k, 0, ∞}]Conditional cumulative probability distribution:
Table[Plot[Evaluate@Probability[(x[3] <= Subscript[x, 2])(x[1] == Subscript[x, 1]), xFractionalGaussianNoiseProcess[.8]], {Subscript[x, 2], -4, 6}, Filling -> Axis, PlotRange -> {0, 1}, PlotLabel -> StringJoin["SubscriptBox[x, 1] = ", ToString[Subscript[x, 1]]]], {Subscript[x, 1], {-1.5, -.3, 1.4, 3}}]Probability[(x[Subscript[t, 2]] ≤ Subscript[x, 2])(x[Subscript[t, 1]] == Subscript[x, 1]), xFractionalGaussianNoiseProcess[h], Assumptions -> 0 < Subscript[t, 1] < Subscript[t, 2] && 0 ≤ Subscript[x, 1] ≤ Subscript[t, 1] && 0 ≤ Subscript[x, 2] ≤ Subscript[t, 2]]Fractional Gaussian noise is self-similar:
h = 6 / 7;
n = 10;
proc = FractionalGaussianNoiseProcess[h];
sample = RandomFunction[proc, {1, n, 1}, 10 ^ 3];Calculate scaled sums of each path:
sums = Map[Total[#] / (n ^ h)&, sample["ValueList"]];edist = EstimatedDistribution[sums, NormalDistribution[a, b]]Compare to the slice distribution of the process:
proc[t]Probability density histogram and functions:
Show[Histogram[sums, 20, "PDF", ChartStyle -> ColorData[35, 4]], Plot[{PDF[edist, x], PDF[proc[t], x]}, {x, -3, 3}, PlotStyle -> Thick, PlotLegends -> {"estimated", "process slice"}]]Compare to non-weakly stationary FractionalBrownianMotionProcess:
h = .6;
SeedRandom[123];fbm = RandomFunction[FractionalBrownianMotionProcess[h], {0, 100, 1}];
SeedRandom[123];fgn = RandomFunction[FractionalGaussianNoiseProcess[h], {1, 100, 1}];
ListLinePlot[{fgn, fbm}, PlotLegends -> {"FGN", "FBM"}]Neat Examples (3)
Simulate a fractional Gaussian noise process in two dimensions:
SeedRandom[103];sample = RandomFunction[FractionalGaussianNoiseProcess[.2], {0, 1, .001}, 2]["ValueList"];ListLinePlot[Transpose@sample, ColorFunction -> "FallColors"]Study the behavior of fractional Gaussian noise depending on the Hurst parameter:
plot[h_] := Graphics3D@Table[{ColorData["SolarColors"][RandomReal[]], Tube@BSplineCurve[Transpose[RandomFunction[FractionalGaussianNoiseProcess[h], {0, 1, 0.01}, 3]["ValueList"]]]}, {8}]{plot[.1], plot[.9]}Simulate paths from a fractional Gaussian noise process:
SeedRandom[13];
data = RandomFunction[FractionalGaussianNoiseProcess[1 / 7], {0, 1, .02}, 300];Take a slice at 1 and visualize its distribution:
sd = data["SliceData", 1];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 -> 45]&[HistogramList[sd, {Range[Min[sd], Max[sd], (Max[sd] - Min[sd]) / 20]}]];Plot paths and histogram distribution of the slice distribution at 1:
ListLinePlot[data, ImageSize -> 400, PlotRange -> All,
AspectRatio -> 3 / 4, Epilog -> Inset[sliced, {1.01, 0}, {0, 12}], PlotStyle -> (cf /@ Rescale[sd]), BaseStyle -> Directive[Thin, Opacity[0.5]], PlotRangePadding -> {{0, .25}, {.5, .5}}]Text
Wolfram Research (2014), FractionalGaussianNoiseProcess, Wolfram Language function, https://reference.wolfram.com/language/ref/FractionalGaussianNoiseProcess.html.
CMS
Wolfram Language. 2014. "FractionalGaussianNoiseProcess." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/FractionalGaussianNoiseProcess.html.
APA
Wolfram Language. (2014). FractionalGaussianNoiseProcess. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/FractionalGaussianNoiseProcess.html