WOLFRAM

Wolfram Language & System Documentation Center

TimeSeriesThread[f,{tes1,tes2,…}]

combines the time or event series data tesi using the function f.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Basic Uses  
Data Types  
Options  
Resampling Method  
Applications  
Properties & Relations  
Possible Issues  
Neat Examples  
See Also
Related Guides
History
Cite this Page

TimeSeriesThread

TimeSeriesThread[f,{tes1,tes2,…}]

combines the time or event series data tesi using the function f.

Details and Options

  • TimeSeriesThread is typically used to combine the values of multiple time or event series.
  • Possible forms of time or event series data tesi include:
  • TimeSeries[…]continuous time-ordered sampled data
    EventSeries[…]collection of temporal events with values
    TemporalData[…]one or more paths composed of time-value pairs
    {{t1,x1},{t2,x2},…}list of time-value pairs
  • The collection {tes1,tes2,…} can equivalently be given as TemporalData[{tes1,tes2,…}].
  • For time series with components, use #[[i,"com"]] in the function f to use component "com" of tesi. »
  • If the times for the tesi are not equivalent, each tesi is resampled using the union of all the times. »
  • TimeSeriesThread takes the following option:
  • ResamplingMethodAutomaticmethod to use for resampling paths
  • All of the tesi must contain the same number of paths. For multiple paths, TimeSeriesThread threads pathwise.

Examples

open all close all

Basic Examples  (4)

Obtain the sum of two time series:

Wolfram Language code: ts1 = TimeSeries[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5]}, {1}]; ts2 = TimeSeries[{Subscript[y, 1], Subscript[y, 2], Subscript[y, 3], Subscript[y, 4], Subscript[y, 5]}, {1}];
Wolfram Language code: TimeSeriesThread[Total, {ts1, ts2}]//Normal

Interpolation and extrapolation are used for misaligned time series:

Wolfram Language code: ts1 = TimeSeries[{Subscript[x, 0], Subscript[x, 1], Subscript[x, 3]}, {{0, 1, 3}}]; ts2 = TimeSeries[{Subscript[y, 1], Subscript[y, 2], Subscript[y, 3]}, {{1, 2, 3}}];
Wolfram Language code: TimeSeriesThread[f, {ts1, ts2}]//Normal//Simplify

Compute the differences between two financial time series in 2025:

Wolfram Language code: goog = FinancialData["GOOGL", {DateObject[{2025}]}]; appl = FinancialData["AAPL", {DateObject[{2025}]}];
Wolfram Language code: TimeSeriesThread[Apply[Subtract], {goog, appl}]
Wolfram Language code: DateListPlot[%]

Combine time series with components:

Wolfram Language code: ts1 = TimeSeries[Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2, 3}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], {Today}]; ts2 = TimeSeries[Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "String"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{11, 21, 31}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{3, {0, 3, 6, 9}, "catfoxdog"}, {}, None}, "ElementType" -> "String"]]}}]]]], {Today}];
Wolfram Language code: TimeSeriesThread[#[[1, "b"]] + #[[2, "a"]]&, {ts1, ts2}]//Tabular

Scope  (8)

Basic Uses  (4)

Total 10 simulated BernoulliProcess paths:

Wolfram Language code: td = RandomFunction[BernoulliProcess[1 / 4], {25}, 10];
Wolfram Language code: sum = TimeSeriesThread[Total, td];
Wolfram Language code: ListPlot[sum, Filling -> Axis]

Compute the mean across components of a time series:

Wolfram Language code: ts = TimeSeries[Tabular[Association["RawSchema" -> Association["ColumnProperties" -> Association["a" -> Association["ElementType" -> "Integer64"], "b" -> Association["ElementType" -> "Integer64"]], "KeyColumns" -> None, "Backend" -> "WolframKernel"], "Options" -> {}, "BackendData" -> Association["ColumnData" -> DataStructure["ColumnTable", {{TabularColumn[Association["Data" -> {{1, 2, 3}, {}, None}, "ElementType" -> "Integer64"]], TabularColumn[Association["Data" -> {{4, 5, 6}, {}, None}, "ElementType" -> "Integer64"]]}}]]]], {Today}]
Wolfram Language code: TimeSeriesThread[Mean @* First, {ts}]//Normal

Compute a min-max envelope for some process paths:

Wolfram Language code: data = RandomFunction[WienerProcess[], {0, 1, .01}, 10 ^ 3];
Wolfram Language code: max = TimeSeriesThread[Max, data]; min = TimeSeriesThread[Min, data];
Wolfram Language code: ListLinePlot[{max, min}, PlotLegends -> {"max", "min"}]

Create a 95% confidence envelope for some process paths:

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

Compute a time series of means and standard deviations :

Wolfram Language code: μ = TimeSeriesThread[Mean, data]; σ = TimeSeriesThread[StandardDeviation, data];

A 95% confidence interval for a normal is given :

Wolfram Language code: conf = TimeSeriesThread[{#[[1]] - 1.95#[[2]], #[[1]] + 1.95#[[2]]}&, {μ, σ}];
Wolfram Language code: Show[ListLinePlot[data, PlotStyle -> Opacity[.1]], ListLinePlot[conf, PlotStyle -> StandardGreen]]

Data Types  (4)

Obtain the sum of two time series given by time-value pairs:

Wolfram Language code: ts1 = {{1, a}, {2, b}, {3, c}}; ts2 = {{1, d}, {2, e}, {3, f}};
Wolfram Language code: TimeSeriesThread[Total, {ts1, ts2}]

Obtain the difference between two TimeSeries:

Wolfram Language code: ts1 = TimeSeries[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5], Subscript[x, 6]}]; ts2 = TimeSeries[{Subscript[y, 1], Subscript[y, 2], Subscript[y, 3], Subscript[y, 4], Subscript[y, 5], Subscript[y, 6]}];
Wolfram Language code: TimeSeriesThread[Subtract@@#&, {ts1, ts2}]["Path"]

Find the standard deviation of various paths in TemporalData:

Wolfram Language code: data = RandomFunction[WienerProcess[], {0, 1, .001}, 100]
Wolfram Language code: ListLinePlot[data, PlotStyle -> Thin]
Wolfram Language code: TimeSeriesThread[StandardDeviation, data];
Wolfram Language code: ListLinePlot[%]

Find the maximum values between two EventSeries:

Wolfram Language code: es1 = TemporalData[EventSeries, {{{2, 1, 6, 5, 7, 4}}, {{{1, 2, 5, 10, 12, 15}}}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, {ResamplingMethod -> None}}, False, 10.];
Wolfram Language code: es2 = TemporalData[EventSeries, {{{3, 2, 10, 4, 11, 7}}, {{{1, 2, 5, 10, 12, 15}}}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, {ResamplingMethod -> None}}, False, 10.];
Wolfram Language code: max = TimeSeriesThread[Max, {es1, es2}];
Wolfram Language code: ListPlot[#, Filling -> Axis]& /@ {es1, es2, max}

Options  (1)

Resampling Method  (1)

Combine two time series with mismatched times:

Wolfram Language code: ts1 = TimeSeries[{1, 3, 5, 7, 9}, {1}]; ts2 = TimeSeries[{2, 3, 4, 5, 6}, {{1, 1.5, 3.5, 4, 5}}];

Use zero-order interpolation:

Wolfram Language code: int0 = TimeSeriesThread[Total, {ts1, ts2}, ResamplingMethod -> "Interpolation"];
Wolfram Language code: int0//Normal

Use interpolation order 1:

Wolfram Language code: int1 = TimeSeriesThread[Total, {ts1, ts2}, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}];
Wolfram Language code: int1//Normal
Wolfram Language code: ListLinePlot[{int0, int1}, PlotLegends -> {"interpolation order 0", "interpolation order 1"}]

Applications  (4)

Find the average process path:

Wolfram Language code: data = RandomFunction[WienerProcess[], {0, 1, .001}, 100];
Wolfram Language code: ListLinePlot[data, PlotStyle -> Thin]
Wolfram Language code: TimeSeriesThread[Mean, data];
Wolfram Language code: ListLinePlot[%]

Simulate a jump-diffusion process:

Wolfram Language code: tspec = {0, 3, .01}; jump = RandomFunction[PoissonProcess[3], tspec]; diff = RandomFunction[WienerProcess[1.9, 1], tspec]; data = TimeSeriesThread[Total, {jump, diff}];
Wolfram Language code: ListPlot[{data, jump, diff}, PlotStyle -> {Thick, Dashed, Dashed}, PlotLegends -> {"jump-diffusion", "jumps", "diffusion"}]

Generate a time series of the Sun's position and the Moon's position over a period of two months:

Wolfram Language code: sunpos = SunPosition[DateRange[Today - Quantity[2, "Months"], Today, {12, "Hour"}], CelestialSystem -> "Equatorial"]
Wolfram Language code: moonpos = MoonPosition[DateRange[Today - Quantity[2, "Months"], Today, {12, "Hour"}], CelestialSystem -> "Equatorial"]

Define a function to compute the angular distance between two objects on a sphere:

Wolfram Language code: AngularDistance[{ϕ1_, θ1_}, {ϕ2_, θ2_}] := InverseHaversine[Haversine[ϕ1 - ϕ2] + Cos[ϕ1]Cos[ϕ2]Haversine[θ1 - θ2]] / Degree

Find the time series for the angular distance between the Sun and the Moon:

Wolfram Language code: angdist = TimeSeriesThread[AngularDistance[First[#], Last[#]]&, {sunpos, moonpos}]

Visualize the angular distance:

Wolfram Language code: DateListPlot[angdist]

Study male unemployment in France:

Wolfram Language code: MaleLaborForce = EntityValue[Entity["Country", "France"], EntityProperty["Country", "LaborForce", {"Date" -> All, "Gender" -> "Male"}]];

Unemployment rates:

Wolfram Language code: Rates = EntityValue[Entity["Country", "France"], EntityProperty["Country", "UnemploymentRate", {"Date" -> All, "Gender" -> "Male"}]];
Wolfram Language code: Rates["Values"]

Convert rates to fractions:

Wolfram Language code: MaleUnemploymentRate = QuantityMagnitude[Rates] / 100;
Wolfram Language code: MaleUnemploymentRate["Values"]

Male unemployment is the corresponding fraction of the male labor force:

Wolfram Language code: MaleUnemployment = TimeSeriesThread[Times@@#&, TimeSeriesResample[TemporalData[{MaleLaborForce, MaleUnemploymentRate}], "Intersection"]];
Wolfram Language code: DateListPlot[MaleUnemployment, FrameLabel -> Automatic]

Properties & Relations  (3)

It is possible to thread EventSeries and TimeSeries:

Wolfram Language code: es = EventSeries[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5]}, {1}]; ts = TimeSeries[{Subscript[y, 1], Subscript[y, 2], Subscript[y, 3], Subscript[y, 4], Subscript[y, 5]}, {3}];
Wolfram Language code: TimeSeriesThread[f, {es, ts}]

The type of the result is determined by the type of the first object:

Wolfram Language code: TimeSeriesThread[f, {ts, es}]

Compare TimeSeriesThread with TimeSeriesMap operating on a single time series:

Wolfram Language code: ts = TimeSeries[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5]}, {1}];
Wolfram Language code: TimeSeriesThread[f, ts]["Path"]
Wolfram Language code: TimeSeriesMap[f, ts]["Path"]

The values of TimeSeriesThread can be computed with MapThread if the time series are aligned:

Wolfram Language code: ts1 = TimeSeries[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5]}, {3}]; ts2 = TimeSeries[{Subscript[y, 1], Subscript[y, 2], Subscript[y, 3], Subscript[y, 4], Subscript[y, 5]}, {3}];
Wolfram Language code: TimeSeriesThread[Apply[f], {ts1, ts2}]//Values//Normal
Wolfram Language code: MapThread[f, {Values[ts1], Values[ts2]}]

Possible Issues  (1)

When threading misaligned event series, the result may contain Missing:

Wolfram Language code: es1 = EventSeries[{Subscript[x, 1], Subscript[x, 2], Subscript[x, 3], Subscript[x, 4], Subscript[x, 5]}, {1}]; es2 = EventSeries[{Subscript[y, 1], Subscript[y, 2], Subscript[y, 3], Subscript[y, 4], Subscript[y, 5]}, {3}];
Wolfram Language code: TimeSeriesThread[f, {es1, es2}]//Normal

Specify how to replace Missing with the ResamplingMethod option:

Wolfram Language code: TimeSeriesThread[f, {es1, es2}, ResamplingMethod -> {"Constant", 0}]//Normal

Neat Examples  (1)

Create a lunar calendar in which the background color depends on the fraction of the Moon illumination:

Wolfram Language code: dates = DateRange[DateObject[{2014, 1, 1, 12}], DateObject[{2014, 1, 31, 12}], 1];
Wolfram Language code: mp = MoonPhase[dates, "Icon"]; sf = MoonPhase[dates, "Fraction"];

Create a new event series with vector values composed of icons and fractions:

Wolfram Language code: phases = TimeSeriesThread[#&, {mp, sf}]

Visualize the lunar calendar:

Wolfram Language code: Labeled[Grid[Partition[Framed[Labeled[ImageResize[First[#2], 45], DateString[#1, {"DayNameShort", " ", "DayShort"}]], Background -> Lighter[ColorData["StarryNightColors", Last[#2]], .3]] & @@@ phases["Path"], 7, 7, 4, ""], Frame -> All, Spacings -> {0, 0}], "January 2014", Top]
Wolfram Research (2014), TimeSeriesThread, Wolfram Language function, https://reference.wolfram.com/language/ref/TimeSeriesThread.html (updated 2026).

Text

Wolfram Research (2014), TimeSeriesThread, Wolfram Language function, https://reference.wolfram.com/language/ref/TimeSeriesThread.html (updated 2026).

CMS

Wolfram Language. 2014. "TimeSeriesThread." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2026. https://reference.wolfram.com/language/ref/TimeSeriesThread.html.

APA

Wolfram Language. (2014). TimeSeriesThread. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/TimeSeriesThread.html

BibTeX

@misc{reference.wolfram_2026_timeseriesthread, author="Wolfram Research", title="{TimeSeriesThread}", year="2026", howpublished="\url{https://reference.wolfram.com/language/ref/TimeSeriesThread.html}", note=[Accessed: 12-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_timeseriesthread, organization={Wolfram Research}, title={TimeSeriesThread}, year={2026}, url={https://reference.wolfram.com/language/ref/TimeSeriesThread.html}, note=[Accessed: 12-June-2026]}