Products
  • Wolfram|One

    The definitive Wolfram Language and notebook experience

  • Mathematica

    The original technical computing environment

  • System Modeler

    Multidomain modeling and simulation of complex systems

  • Compute ServicesUse with Mathematica and Wolfram|One
  • AI AccessUse with Mathematica and Wolfram|One
  • Finance Platform
  • Wolfram|Alpha Notebook Edition
  • Application Server
  • Enterprise Private Cloud
  • Wolfram Engine
  • Wolfram Player
  • Wolfram Cloud App
  • Wolfram Player App

More mobile apps

Wolfram|Alpha

  • Wolfram|Alpha Website
  • Wolfram|Alpha APIs

AI Products

  • Wolfram AI Ecosystem
  • Wolfram Foundation Tool
  • Wolfram Cloud MCP
  • Wolfram Local MCP
  • Agent One API
  • CAG Component APIs

Core Technologies of Wolfram Products

  • Wolfram Language
  • Computable Data
  • Wolfram Notebooks
  • Linguistic Understanding

Additional Deployment Options

  • Wolfram Cloud
  • Wolfram Web Engine
  • wolframscript
  • WSTPServer
  • Group & Organizational Licensing
  • All Products
Consulting & Solutions

We deliver solutions for the AI era—combining symbolic computation, data-driven insights and deep technical expertise

Wolfram Consulting

Data Science, Finance & Business

  • Artificial Intelligence
  • Data Science
  • Healthcare
  • Real Estate

Engineering

  • Civil Engineering
  • Automotive Engineering
  • Sustainable Energy

Science & Technology

  • AgTech
  • Biosciences
  • Environmental Science
  • Food Science
  • Quantum Computation
  • Social and Behavioral Sciences

More Wolfram Solutions

Technology for Education

  • Research Universities
  • Colleges & Teaching Universities
  • High Schools
  • Resources for Students

Education Initiatives

  • Next-Gen EdTech
  • Computer-Based Math

More Solutions for Education

  • Contact Us
Learning & Support

Get Started

  • Wolfram Language Introduction
  • Fast Intro for Programmers
  • Fast Intro for Math Students
  • Wolfram Language Documentation

More Learning

  • Highlighted Core Areas
  • Demonstrations
  • YouTube
  • Daily Study Groups
  • Wolfram Schools and Programs
  • Books

Grow Your Skills

  • Wolfram U

    Courses in computing, science, life and more

  • Community

    Learn, solve problems and share ideas.

  • Blog

    News, views and insights from Wolfram

  • Resources for

    Software Developers

Tech Support

  • Contact Us
  • Support FAQs
  • Support FAQs
  • Contact Us
Company
  • About Wolfram
  • Career Center
  • All Sites & Resources
  • Connect & Follow
  • Contact Us

Work with Us

  • Student Ambassador Initiative
  • Wolfram for Startups
  • Student Opportunities
  • Jobs Using Wolfram Language

Educational Programs for Adults

  • Summer School
  • Winter School

Educational Programs for Youth

  • Middle School Camp
  • High School Research Program
  • Computational Adventures

Read

  • Stephen Wolfram's Writings
  • Wolfram Blog
  • Wolfram Tech | Books
  • Wolfram Media
  • Complex Systems

Educational Resources

  • Wolfram MathWorld
  • Wolfram in STEM
  • Wolfram Challenges
  • Wolfram Problem Generator

Wolfram Initiatives

  • Wolfram Science
  • Wolfram Foundation
  • History of Mathematics Project

Events

  • Stephen Wolfram Livestreams
  • Online & In-Person Events
  • Contact Us
  • Connect & Follow
For AIs
  • Your Account
  • User Portal
  • Wolfram Cloud
  • Products
    • Wolfram|One
    • Mathematica
    • System Modeler
    • Compute ServicesUse with Mathematica and Wolfram|One
    • AI AccessUse with Mathematica and Wolfram|One
    • Finance Platform
    • Wolfram|Alpha Notebook Edition
    • Application Server
    • Enterprise Private Cloud
    • Wolfram Engine
    • Wolfram Player
    • Wolfram Cloud App
    • Wolfram Player App

    More mobile apps

    • Wolfram|Alpha
      • Wolfram|Alpha Website
      • Wolfram|Alpha APIs
    • AI Products
      • Wolfram AI Ecosystem
      • Wolfram Foundation Tool
      • Wolfram Cloud MCP
      • Wolfram Local MCP
      • Agent One API
      • CAG Component APIs
    • Core Technologies
      • Wolfram Language
      • Computable Data
      • Wolfram Notebooks
      • Linguistic Understanding
    • Additional Deployment Options
      • Wolfram Cloud
      • Wolfram Web Engine
      • wolframscript
      • WSTPServer
    • Group & Organizational Licensing
    • All Products
  • Consulting & Solutions
    • Wolfram Consulting

    Data Science, Finance & Business

    • Artificial Intelligence
    • Data Science
    • Healthcare
    • Real Estate

    Engineering

    • Civil Engineering
    • Automotive Engineering
    • Sustainable Energy

    Science & Technology

    • AgTech
    • Biosciences
    • Environmental Science
    • Food Science
    • Quantum Computation
    • Social and Behavioral Sciences

    More Wolfram Solutions

    Technology for Education

    • Research Universities
    • Colleges & Teaching Universities
    • High Schools
    • Resources for Students

    Education Initiatives

    • Next-Gen EdTech
    • Computer-Based Math

    More Solutions for Education

    • Contact Us
  • Learning & Support

    Get Started

    • Wolfram Language Introduction
    • Fast Intro for Programmers
    • Fast Intro for Math Students
    • Wolfram Language Documentation

    Grow Your Skills

    • Wolfram U

      Courses in computing, science, life and more

    • Community

      Learn, solve problems and share ideas.

    • Blog

      News, views and insights from Wolfram

    • Resources for

      Software Developers
    • Tech Support
      • Contact Us
      • Support FAQs
    • More Learning
      • Highlighted Core Areas
      • Demonstrations
      • YouTube
      • Daily Study Groups
      • Wolfram Schools and Programs
      • Books
    • Support FAQs
    • Contact Us
  • Company
    • About Wolfram
    • Career Center
    • All Sites & Resources
    • Connect & Follow
    • Contact Us

    Work with Us

    • Student Ambassador Initiative
    • Wolfram for Startups
    • Student Opportunities
    • Jobs Using Wolfram Language

    Educational Programs for Adults

    • Summer School
    • Winter School

    Educational Programs for Youth

    • Middle School Camp
    • High School Research Program
    • Computational Adventures

    Read

    • Stephen Wolfram's Writings
    • Wolfram Blog
    • Wolfram Tech | Books
    • Wolfram Media
    • Complex Systems
    • Educational Resources
      • Wolfram MathWorld
      • Wolfram in STEM
      • Wolfram Challenges
      • Wolfram Problem Generator
    • Wolfram Initiatives
      • Wolfram Science
      • Wolfram Foundation
      • History of Mathematics Project
    • Events
      • Stephen Wolfram Livestreams
      • Online & In-Person Events
    • Contact Us
    • Connect & Follow
  • For AIs
  • Wolfram Cloud
  • Your Account
  • User Portal
Wolfram Language & System Documentation Center
TemporalData
  • See Also
    • TimeSeries
    • EventSeries
    • TimeSeriesModelFit
    • MovingMap
    • RandomFunction
    • CorrelationFunction
    • EstimatedProcess
    • ListLinePlot
    • DateListPlot
    • EventData
    • WeightedData
  • Related Guides
    • Random Processes
    • Probability & Statistics
    • Time Series Processes
    • Descriptive Statistics
    • See Also
      • TimeSeries
      • EventSeries
      • TimeSeriesModelFit
      • MovingMap
      • RandomFunction
      • CorrelationFunction
      • EstimatedProcess
      • ListLinePlot
      • DateListPlot
      • EventData
      • WeightedData
    • Related Guides
      • Random Processes
      • Probability & Statistics
      • Time Series Processes
      • Descriptive Statistics

TemporalData[{v1,v2,…},tspec]

represents temporal data with values vi at times specified by tspec.

TemporalData[{{v11,v12,…},{v21,v22,…},…},tspec]

represents a temporal data collection with values vij at times specified by tspec.

TemporalData[{{t1,v1},{t2,v2}…}]

represents temporal data specified by time-value pairs {ti,vi}.

TemporalData[{{{t11,v11},{t12,v12}…},{{t21,v21},{t22,v22},…},…}]

represents a temporal data collection given as lists of time-value pairs {tij,vij}.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Basic Uses  
Specifying Values and Times  
Properties and Part Extraction  
Temporal Data Arithmetic  
Options  
CalendarType  
DateFunction  
HolidayCalendar  
Show More Show More
MetaInformation  
MissingDataMethod  
ResamplingMethod  
TemporalRegularity  
TimeZone  
ValueDimensions  
Applications  
Properties & Relations  
Possible Issues  
Neat Examples  
See Also
Related Guides
History
Cite this Page
BUILT-IN SYMBOL
  • See Also
    • TimeSeries
    • EventSeries
    • TimeSeriesModelFit
    • MovingMap
    • RandomFunction
    • CorrelationFunction
    • EstimatedProcess
    • ListLinePlot
    • DateListPlot
    • EventData
    • WeightedData
  • Related Guides
    • Random Processes
    • Probability & Statistics
    • Time Series Processes
    • Descriptive Statistics
    • See Also
      • TimeSeries
      • EventSeries
      • TimeSeriesModelFit
      • MovingMap
      • RandomFunction
      • CorrelationFunction
      • EstimatedProcess
      • ListLinePlot
      • DateListPlot
      • EventData
      • WeightedData
    • Related Guides
      • Random Processes
      • Probability & Statistics
      • Time Series Processes
      • Descriptive Statistics

TemporalData

TemporalData[{v1,v2,…},tspec]

represents temporal data with values vi at times specified by tspec.

TemporalData[{{v11,v12,…},{v21,v22,…},…},tspec]

represents a temporal data collection with values vij at times specified by tspec.

TemporalData[{{t1,v1},{t2,v2}…}]

represents temporal data specified by time-value pairs {ti,vi}.

TemporalData[{{{t11,v11},{t12,v12}…},{{t21,v21},{t22,v22},…},…}]

represents a temporal data collection given as lists of time-value pairs {tij,vij}.

Details and Options

  • TemporalData represents a collection of paths composed of time-value pairs {tij,vij}.
  • The values vij can be scalars or arrays of any dimension, but must all be of equal dimensionality.
  • The following times tspec can be given:
  • Automaticuse uniformly spaced times starting at 0
    {tmin}use uniformly spaced times starting at tmin
    {tmin,tmax}use uniformly spaced times tmin to tmax
    {tmin,tmax,dt}use times tmin to tmax in steps of dt
    {{t1,t2,…}}use explicit times {t1,t2,…}
    {tspec1,tspec2,…}use different times for each path in the collection
  • The tij can be numbers or any valid input to AbsoluteTime.
  • The values tmin, tmax, and dt can be given as numbers, dates, or Automatic.
  • TemporalData objects of equal dimensionality {td1,td2,…} can be combined into a single object using TemporalData[{td1,td2,…}].
  • Normal[td] returns a list containing time-value pairs {tij,vij} for each path.
  • Specifying td[t] gives the empirical slice distribution at time t.
  • A joint empirical slice distribution for times {t1,t2,…} can be obtained by specifying td[{t1,t2,…}].
  • Properties of a TemporalData object td can be obtained from td["property"].
  • A list of available properties can be obtained using td["Properties"].
  • Some properties of the collection of paths:
  • "Components"split the collection into individual components
    "PathCount"the number of paths in the collection
    "PathLengths"a list containing the length of each path
    "Paths"a list containing time-value pairs {tij,vij} for each path
    "DatePaths"a list containing date-value pairs for each path
    "TimeList"a list containing times tij for each path
    "DateList"a list containing tij for each path as dates
    "ValueDimensions"the dimensionality of the values
    "ValueList"a list containing values vij for each path
    "FirstTimes"a list of first times for each path
    "FirstDates"a list of first times for each path as dates
    "LastTimes"a list of last times for each path
    "LastDates"a list of last times for each path as dates
    "FirstValues"a list of values at the first time for each path
    "LastValues"a list of values at the last time for each path
  • If dates are given as input, td["Times"] returns them in AbsoluteTime.
  • Some properties for obtaining parts of the collection:
  • "Part"a subset of the original data
    "Path"time-value pairs {tij,vij} for a given path
    "DatePath"date-value pairs {dateij,vij} for a given path
    "PathComponents"split the multivariate path into univariate components
    "PathFunction"an interpolated path function
    "Values"values vi for a given path
    "Times"times ti for a given path
    "Dates"times ti for a given path as dates
    "SliceData"a slice through all paths at a given time
    "SliceDistribution"empirical distribution of slice data at a given time
    "FirstTime"the first time t1 for a given path
    "FirstDate"the first time t1 for a given path as date
    "LastTime"the last time for a given path
    "LastDate"the last time for a given path as date
    "FirstValue"the value v1 at the first time for a given path
    "LastValue"the value at the last time for a given path
  • Specifying td["Path",p] gives the time-value pairs for the paths specified by p, where p can be any valid Part specification.
  • The property td["PathFunction",p] returns interpolated paths specified by p.
  • Specifying td["PathComponent",p] gives the TemporalData for vector components of the values specified by p.
  • Specifying td["Part",p,tspec] gives TemporalData for paths specified by p and times specified by tspec. If necessary, the paths are resampled according to "PathFunction".
  • Giving td["SliceData",t] returns a slice through all paths at time t, where t can be a number or valid input to AbsoluteTime.
  • The specification td["SliceData",{t1,t2,…}] gives a multivariate slice at times {t1,t2,…}.
  • TemporalData takes the following options:
  • CalendarType "Gregorian"the calendar type to use
    HolidayCalendar {"UnitedStates","Default"}the holiday calendar to use
    TimeZone $TimeZonethe time zone to use
    MetaInformation Noneinclude additional metainformation
    MissingDataMethod Nonemethod to use for missing values
    ResamplingMethod "Interpolation"the method to use for resampling paths
    ValueDimensions Automaticthe dimensions of the values
    TemporalRegularity Automaticwhether to assume the data is regular
    DateFunction Automatichow to convert dates to standard form
  • By default, zero-order interpolation is used for resampling paths. The setting ResamplingMethod->{"Interpolation",opts} can be given, where opts are options passed to Interpolation.
  • The setting ValueDimensions->dim specifies that the values vij are of dimension dim. Setting ValueDimensions->Automatic attempts to automatically determine the dimension of the values from the data.
  • Setting the MissingDataMethod->Automatic will automatically interpolate values with head Missing, according to the ResamplingMethod setting. By default, values with head Missing are treated as missing.
  • Information of a TemporalData may include the following properties:
  • "DateInterval"start and end dates
    "DataPoints"number of data points
    "Regular"whether data is regularly sampled
    "OutputDimensions"dimensions of value output
    "Metadata"all metadata

Examples

open all close all

Basic Examples  (3)

Attach temporal information to some values:

Wolfram Language code: s = {2, 1, 6, 5, 7, 4}; t = {1, 2, 5, 10, 12, 15};
Wolfram Language code: td = TemporalData[s, {t}]

Visualize the path:

Wolfram Language code: ListLinePlot[td]

Create a collection of paths with equivalent times:

Wolfram Language code: s1 = {2, 1, 6, 5, 7, 4}; s2 = {4, 7, 5, 6, 1, 2}; t = {1, 2, 5, 10, 12, 15};
Wolfram Language code: td = TemporalData[{s1, s2}, {t}]

Visualize the collection:

Wolfram Language code: ListLinePlot[td]

Compute the Mean and StandardDeviation at time :

Wolfram Language code: {Mean[td[10]], StandardDeviation[td[10]]}

Use dates as time stamps:

Wolfram Language code: goog = FinancialData["GOOGL", "Jan. 1, 2008"]; appl = FinancialData["AAPL", "Jan. 1, 2008"];
Wolfram Language code: td = TemporalData[{goog, appl}];

Plot the financial time series with DateListPlot:

Wolfram Language code: DateListPlot[td["Paths"], PlotLegends -> {"GOOGL", "AAPL"}]

The value of both stocks on May 24, 2009:

Wolfram Language code: td["SliceData", "May 24, 2009"]

The average value of each stock over the date range:

Wolfram Language code: Mean /@ td["ValueList"]

Scope  (40)

Basic Uses  (5)

Estimate autocorrelation and partial autocorrelation for a time series:

Wolfram Language code: td = TemporalData[Automatic, {{{0.03164129479860563, -0.27833387647918045, -0.48321642681451094, -0.26476811361536023, -0.07235165843507146, -0.6531225705637944, -0.670674759639523, -0.0474684373898403, -0.6821385384102134, 0.8531776374411912, ... 0.3472102155923046, 0.8017745468335118, -0.3702003893822077, 0.6639322988529811, 0.30154676266691394, -1.6103378947994194, 1.1714374690490412, -0.025279183327656413}}, {{0, 1000, 1}}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, {}}, False, 9.];
Wolfram Language code: ListLinePlot[td]
Wolfram Language code: Map[ListPlot[#[td, {25}], Filling -> 0, PlotLabel -> #]&, {CorrelationFunction, PartialCorrelationFunction}]

Generate sample paths for a random process, using RandomFunction:

Wolfram Language code: td = RandomFunction[WienerProcess[], {0, 1, .01}, 20]
Wolfram Language code: ListLinePlot[td]

Estimate process parameters, given a sample path:

Wolfram Language code: td = TemporalData[Automatic, {{{-1.0646141639299331, -0.34828669752008434, 0.6567520829091731, 0.3523769436890944, 1.6044338698176925, -0.061312285857197335, -0.6632843308217629, -0.41316994382433175, 0.12112373250080619, 0.2982229777079768, - ... 31645802958, -0.8433370468017489, -0.8691558493303159, 0.011631609806550813, 0.2667628393343585, -2.325977079092904, 0.06934850837333398, -0.16798024468075898}}, {{0, 500, 1}}, 1, {"Continuous", 1}, {"Discrete", 1}, 1, {}}, False, 9.];
Wolfram Language code: proc = EstimatedProcess[td, ARProcess[3]]

Compare the CorrelationFunction for the process and data:

Wolfram Language code: Show[ListPlot[CorrelationFunction[td, {10}], Filling -> 0, PlotStyle -> PointSize[Medium]], DiscretePlot[CorrelationFunction[proc, h], {h, 0, 10}, ExtentSize -> 1 / 2]]

Fill in missing values in a time series:

Wolfram Language code: data = {412, 480, 683, Missing[], 1385, 1418, 1634, 2178, 3362, 5948, 6109, 5981, 6753, 8003, 10566, Missing[], 14760, 16769, 19819, 22362, Missing[], 25343, 29269, 30514};
Wolfram Language code: ListLinePlot[data]

Use linear interpolation to fill in the missing values:

Wolfram Language code: td = TemporalData[data, MissingDataMethod -> {"Interpolation", InterpolationOrder -> 1}];
Wolfram Language code: ListLinePlot[td]

Compute properties for time slices through multiple paths:

Wolfram Language code: td = TemporalData[Automatic, {{{0., -0.1354171281373512, -0.5929021350888302, -0.9316408617185155, -1.3013511310933015, -1.3104347033766137, -1.6627085294858874, -0.7076429703077599, -1.0755066261381967, -0.6358918108218164, -0.643870554126035 ... 647596223984, 0.5769680931204549, 0.288745572733065, 0.44466645673443594, 0.49070058572939124}}, {{0, 1, 0.1}}, 25, {"Continuous", 25}, {"Continuous", 1}, 1, {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}}}, False, 10.];
Wolfram Language code: ListLinePlot[td]

Mean and StandardDeviation:

Wolfram Language code: Map[Plot[#[td[t]], {t, 0, 1}, PlotLabel -> #]&, {Mean, StandardDeviation}]

Probabilities and expectations:

Wolfram Language code: Map[Plot[#, {t, 0, 1}, PlotLabel -> Head[#]]&, {Expectation[x[t], xtd], Probability[x[t] > 0, xtd]}]

Specifying Values and Times  (19)

Give a list of values with Automatic time stamps:

Wolfram Language code: s = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12};
Wolfram Language code: td = TemporalData[s, Automatic];
Wolfram Language code: ListLinePlot[td, Filling -> Axis]

Create a path with times starting at :

Wolfram Language code: s = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12, 11};
Wolfram Language code: td = TemporalData[s, {10}];
Wolfram Language code: ListLinePlot[td, Filling -> Axis]

Use dates for starting times:

Wolfram Language code: vals = {19, 16, 9, 3, 7, 2, 17};

Dates can be given as any valid input to AbsoluteTime:

Wolfram Language code: td1 = TemporalData[vals, {{1982, 5, 24}}]; td2 = TemporalData[vals, {"May 24, 1982"}];
Wolfram Language code: DateListPlot[#, Filling -> Axis]& /@ {td1, td2}

Use equally spaced times from 10 to 50:

Wolfram Language code: vals = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12};
Wolfram Language code: td = TemporalData[vals, {10, 50}];
Wolfram Language code: ListLinePlot[td, Filling -> Axis]

Give a range of dates to use:

Wolfram Language code: vals = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12};
Wolfram Language code: td = TemporalData[vals, {"2001", "2012"}];
Wolfram Language code: DateListPlot[td, Filling -> Axis]

Specify an Automatic endpoint:

Wolfram Language code: vals = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12};
Wolfram Language code: td = TemporalData[vals, {"2001", Automatic}];
Wolfram Language code: DateListPlot[td, Filling -> Axis]

Extract the computed last date:

Wolfram Language code: td["LastDate"]

Create a path with times 1 to 20 in steps of 2:

Wolfram Language code: vals = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12};
Wolfram Language code: td = TemporalData[vals, {1, 20, 2}];
Wolfram Language code: ListLinePlot[td, Filling -> Axis]

Use an Automatic endpoint and fixed step:

Wolfram Language code: vals = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12};
Wolfram Language code: td = TemporalData[vals, {"May 24th 1982", Automatic, "BusinessDay"}];
Wolfram Language code: DateListPlot[td, Filling -> Axis]

Extract the computed last date:

Wolfram Language code: td["LastDate"]

Use an Automatic start point and given frequency:

Wolfram Language code: v = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12}; freq = 10;
Wolfram Language code: td = TemporalData[v, {Automatic, 20, 1 / freq}];
Wolfram Language code: ListLinePlot[td["Path"]]

Extract the computed first time:

Wolfram Language code: td["FirstTime"]

Give an explicit list of times:

Wolfram Language code: vals = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12}; times = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
Wolfram Language code: td = TemporalData[vals, {times}];
Wolfram Language code: ListLinePlot[td, Filling -> Axis]

Give an explicit list of dates:

Wolfram Language code: vals = {19, 16, 9, 3, 7, 2, 17, 10, 6, 12}; times = DateRange[{1985, 1}, {1994, 1}, "Year"];
Wolfram Language code: td = TemporalData[vals, {times}];
Wolfram Language code: DateListPlot[td, Filling -> Axis]

Create a collection of three paths with identical time stamps:

Wolfram Language code: s1 = RandomInteger[{1, 20}, 10]; s2 = RandomInteger[{1, 20}, 10]; s3 = RandomInteger[{1, 20}, 10];
Wolfram Language code: td = TemporalData[{s1, s2, s3}, Automatic];
Wolfram Language code: ListLinePlot[td]

Use different time stamps for each path:

Wolfram Language code: s1 = RandomInteger[{1, 20}, 10]; s2 = RandomInteger[{1, 20}, 10]; s3 = RandomInteger[{1, 20}, 10];
Wolfram Language code: t1 = Range[10]; t2 = Range[21, 30]; t3 = Range[11, 20];
Wolfram Language code: td = TemporalData[{s1, s2, s3}, {{t1}, {t2}, {t3}}];
Wolfram Language code: ListLinePlot[td, PlotLegends -> {"s1", "s2", "s3"}]

Create a collection of paths with different times, but the same values:

Wolfram Language code: vals = {1, 3, 2, 5, 7, 4, 9};
Wolfram Language code: td = TemporalData[vals, {{1, 10}, {1, 25}, {1, 50}, {1, 75}, {1, 100}}];
Wolfram Language code: ListLinePlot[td]

Specify a path, using time-value pairs:

Wolfram Language code: path = {{1, -1}, {2, -2}, {3, -1}, {4, 0}, {5, 1}, {6, 2}, {7, 2}, {8, 3}, {9, 2}, {10, 3}, {11, 4}, {12, 5}, {13, 6}, {14, 7}, {15, 8}, {16, 9}, {17, 8}, {18, 7}, {19, 8}, {20, 9}};
Wolfram Language code: td = TemporalData[path];
Wolfram Language code: ListLinePlot[td]

Create a path from date-value pairs:

Wolfram Language code: path = FinancialData["GOOG", {2005}, Method -> "Legacy"];
Wolfram Language code: path[[1]]
Wolfram Language code: td = TemporalData[path]
Wolfram Language code: DateListPlot[td]

Create a collection of paths from time-value pairs:

Wolfram Language code: path1 = {{1, -1}, {2, -2}, {3, -1}, {4, 0}, {5, 1}, {6, 2}, {7, 2}, {8, 3}, {9, 2}, {10, 3}, {11, 4}, {12, 5}, {13, 6}, {14, 7}, {15, 8}, {16, 9}, {17, 8}, {18, 7}, {19, 8}, {20, 9}}; path2 = {{0, 0}, {1, -1}, {2, -2}, {3, -3}, {4, -2}, {5, -1}, {6, 0}, {7, -1}, {8, 0}, {9, -1}, {10, -1}, {11, -2}, {12, -3}, {13, -4}, {14, -5}, {15, -6}, {16, -5}, {17, -4}, {18, -3}, {19, -3}, {20, -3}};
Wolfram Language code: td = TemporalData[{path1, path2}];
Wolfram Language code: ListLinePlot[td]

Create a collection of paths, using date-value pairs:

Wolfram Language code: td = TemporalData[{FinancialData["AAPL", {2005}], FinancialData["SBUX", {2005}]}];
Wolfram Language code: DateListPlot[td, PlotLegends -> {"AAPL", "SBUX"}]

Create a path with data involving quantities:

Wolfram Language code: vals = Quantity[{19, 16, 9, 3, 7, 2, 17, 10, 6, 12}, "Meters"]; times = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
Wolfram Language code: td = TemporalData[vals, {times}];
Wolfram Language code: ListLinePlot[td, Filling -> Axis, AxesLabel -> Automatic]

Properties and Part Extraction  (13)

Obtain a list of available properties:

Wolfram Language code: td = TemporalData[Automatic, {{{0, -1, 0, -1, -2, -1, 0, -1, 0, -1, 0}}, {{0, 10, 1}}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, {}}, False, 9.];
Wolfram Language code: td["Properties"]

Obtain properties related to the input data:

Wolfram Language code: td = RandomFunction[RandomWalkProcess[.5], {0, 10}, 10];

The number of paths in the collection:

Wolfram Language code: td["PathCount"]

The dimension of the values:

Wolfram Language code: td["ValueDimensions"]

The values used for the first path:

Wolfram Language code: td["Values"]

The times for the first path:

Wolfram Language code: td["Times"]

Extract paths from the collection:

Wolfram Language code: td = RandomFunction[WienerProcess[], {0, 1, .2}, 10];

The first path:

Wolfram Language code: td["Path"]

Obtain the fifth path:

Wolfram Language code: td["Path", 5]

Plot three of the paths:

Wolfram Language code: ListLinePlot[td["Path", {1, 3, 5}]]

Show all the paths in the ensemble:

Wolfram Language code: ListLinePlot[td["Path", All]]

Extract path components of vector-valued collection:

Wolfram Language code: td = RandomFunction[ARProcess[{{{.3, 0}, {.1, .4}}}, {{.1, 0}, {0, .1}}], {0, 100}]
Wolfram Language code: td["ValueDimensions"]

The first component:

Wolfram Language code: td["PathComponent", 1]
Wolfram Language code: %["ValueDimensions"]

Obtain the second component:

Wolfram Language code: td["PathComponent", 2]

Plot the paths components:

Wolfram Language code: ListLinePlot[td["PathComponents"]]

Specify path and path component names and use them for extraction:

Wolfram Language code: td = TemporalData[RandomReal[2, {4, 3, 2}], Automatic, MetaInformation -> {"PathNames" -> {"p1", "p2", "p3", "p4"}, "ComponentNames" -> {"c1", "c2"}}]

Extract path by name:

Wolfram Language code: td["Path", "p2"]

Extract path component by name:

Wolfram Language code: td["PathComponent", "c1"]

Obtain paths as functions of time:

Wolfram Language code: td = RandomFunction[WienerProcess[], {0, 1, .1}, 10];

The first path function:

Wolfram Language code: Plot[td["PathFunction"][t], {t, 0, 1}]

The 10^(th) path function:

Wolfram Language code: Plot[td["PathFunction", 10][t], {t, 0, 1}]

Plot three of the paths:

Wolfram Language code: paths = (#[t]& /@ td["PathFunction", {1, 5, 10}]);
Wolfram Language code: Plot[paths, {t, 0, 1}]

Show all the paths in the collection:

Wolfram Language code: paths = (#[t]& /@ td["PathFunction", All]);
Wolfram Language code: Plot[paths, {t, 0, 1}]

Obtain slices through the collection of paths at different time points:

Wolfram Language code: td = RandomFunction[WienerProcess[], {0, 1, .1}, 50];

A slice at time :

Wolfram Language code: SmoothHistogram[td["SliceData", .5]]

A bivariate slice:

Wolfram Language code: SmoothHistogram3D[td["SliceData", {.25, .5}]]

Obtain a slice at a particular date:

Wolfram Language code: td = TemporalData[{FinancialData["SBUX", {2005}], FinancialData["AAPL", {2005}]}];
Wolfram Language code: td["SliceData", "January 5, 2006"]

Obtain empirical slice distributions for different time points:

Wolfram Language code: td = RandomFunction[WienerProcess[], {0, 1, .1}, 15];

An empirical slice distribution at time 0.25:

Wolfram Language code: sd = td[.25]
Wolfram Language code: Plot[CDF[sd, t], {t, -1, 1}, Exclusions -> None]

A bivariate empirical slice distribution:

Wolfram Language code: sd2 = td[{.25, .5}]
Wolfram Language code: Plot3D[Evaluate@CDF[sd2, {t1, t2}], {t1, -2, 2}, {t2, -2, 2}, Exclusions -> None]

Obtain a subset of the original data:

Wolfram Language code: td = RandomFunction[WienerProcess[], {0, 1, .2}, 10];
Wolfram Language code: range = {{0, 1}, {-2, 2}}; ListLinePlot[td, PlotRange -> range]

Take odd-numbered paths over the time range 0.2 to 0.8:

Wolfram Language code: subset = td["Part", 1 ;; -1 ;; 2, {.2, .8}]
Wolfram Language code: ListLinePlot[subset, PlotRange -> range]

Resample data over a given set of times:

Wolfram Language code: td = RandomFunction[WienerProcess[0.1, 1], {0, 10, 1}];
Wolfram Language code: ListPlot[td]

Upsample the original path in steps of 0.25:

Wolfram Language code: td1 = TimeSeriesResample[td, .25]

The new data is sampled from the path function:

Wolfram Language code: ListPlot[{td, td1}, Filling -> {1 -> 0}, PlotLegends -> {"original data", "resampled data"}]

Resample data over a given set of days:

Wolfram Language code: td = TemporalData[FinancialData["SBUX", {{2009}, {2010}}]];
Wolfram Language code: DateListPlot[td]
Wolfram Language code: td1 = TimeSeriesResample[td, Monday]
Wolfram Language code: DateListPlot[td1]

Temporal data involving quantities:

Wolfram Language code: s = Quantity[{19, 16, 9, 3, 7, 2, 17, 10, 6, 12}, "Meters"]; t = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
Wolfram Language code: td = TemporalData[s, {t}];

The values are given as QuantityArray:

Wolfram Language code: td["Values"]

Extract quantity unit information:

Wolfram Language code: td["Values"]["UnitBlock"]

Extract quantity magnitudes:

Wolfram Language code: td["Values"]["Magnitudes"]

Temporal Data Arithmetic  (3)

Numerical, listable functions automatically thread over values of TemporalData:

Wolfram Language code: td = TemporalData[Automatic, {{{0.23, 1.2920000000000003, 2.318, 3.3080000000000007, 4.2620000000000005, 5.180000000000001, 6.062000000000002, 6.908000000000001, 7.718000000000002, 8.492, 9.23, 9.932000000000002, 10.598000000000003, 11.2280000 ... 15.548000000000002, 15.782000000000004, 15.98, 16.142, 16.268, 16.358, 16.412, 16.430000000000003, 16.412, 16.358}}, {{0., 3.2, 0.1}}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, {ValueDimensions -> 1, DateFunction -> Automatic}}, False, 10.2];
Wolfram Language code: Sin[td + 1]

Compare to the result of TimeSeriesMap:

Wolfram Language code: TimeSeriesMap[Sin[# + 1]&, td]
Wolfram Language code: % === %%

Combining several TemporalData objects with identical time stamps threads over values:

Wolfram Language code: TemporalData[{{1, Subscript[x, 1]}, {2, Subscript[x, 2]}, {3, Subscript[x, 3]}}] + TemporalData[{{1, Subscript[y, 1]}, {2, Subscript[y, 2]}, {3, Subscript[y, 3]}}]
Wolfram Language code: Normal[%]

Create new temporal data of quantity magnitudes from existing temporal data involving quantities:

Wolfram Language code: s = Quantity[{19, 16, 9, 3, 7, 2, 17, 10, 6, 12}, "Meters"]; t = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
Wolfram Language code: td = TemporalData[s, {t}];
Wolfram Language code: QuantityMagnitude[td]
Wolfram Language code: Normal[%]

Create new temporal data of quantity units:

Wolfram Language code: QuantityUnit[td]
Wolfram Language code: Normal[%]

Options  (22)

CalendarType  (1)

Specify timestamps as dates in a specific calendar using CalendarType:

Wolfram Language code: TemporalData[Range[5], {{2014, 2, 14}, Automatic, "Day"}, CalendarType -> "Jewish"]

By default, the "Gregorian" calendar is being used:

Wolfram Language code: TemporalData[Range[5], {{2014, 2, 14}, Automatic, "Day"}]

DateFunction  (2)

Use DateList to define functions for interpreting ambiguous date strings:

Wolfram Language code: data = {{"06/01/06", 8}, {"07/01/06", 10}, {"08/01/06", 12}, {"09/01/06", 14}, {"10/01/06", 15}, {"11/01/06", 20}};
Wolfram Language code: TemporalData[data, DateFunction :> (DateList[{#, {"Month", "Day", "YearShort"}}]&)]
Wolfram Language code: TemporalData[data, DateFunction :> (DateList[{#, {"Day", "Month", "YearShort"}}]&)]
Wolfram Language code: TemporalData[data, DateFunction :> (DateList[{#, {"YearShort", "Month", "Day"}}]&)]

Use DateObject to define functions for interpreting ambiguous date strings:

Wolfram Language code: data = {{"2006 12-1", 8}, {"2006 12-2", 10}, {"2006 12-3", 12}, {"2006 12-4", 14}, {"2006 12-5", 15}, {"2006 12-6", 20}};
Wolfram Language code: TemporalData[data, DateFunction :> (DateObject[{#, {"Year", "Month", "Day"}}]&)]

Specify the TimeZone of the inputs:

Wolfram Language code: TemporalData[data, DateFunction :> (DateObject[{#, {"Year", "Day", "Month"}}, TimeZone -> "America/Chicago"]&)]

HolidayCalendar  (1)

Use HolidayCalendar to visualize business days in a given country:

Wolfram Language code: td = TemporalData[ConstantArray[1, 40], {{2014, 11, 1}, Automatic, "BusinessDay"}, HolidayCalendar -> "UnitedStates"]
Wolfram Language code: DateListPlot[td, Joined -> False, Filling -> Axis, FrameTicks -> {{Automatic, Automatic}, {DateRange[td["FirstTime"], td["LastTime"], {2, "Day"}], None}}, DateTicksFormat -> "DayShort"]

MetaInformation  (4)

Include additional metadata as a list of rules:

Wolfram Language code: vals = Accumulate[RandomInteger[{-5, 1}, 10]~Join~RandomInteger[{-1, 5}, 10]];
Wolfram Language code: td = TemporalData[vals, {1, 20}, MetaInformation -> {"Event" -> 10}];

The properties now include the metadata "Event":

Wolfram Language code: td["Properties"]

The added metadata can be used like any other property:

Wolfram Language code: e = td["Event"]
Wolfram Language code: Show[ListLinePlot[td, PlotRange -> {Min[vals] - 1, Max[vals] + 1}], Graphics[{Red, PointSize[Large], Point[{e, td["PathFunction"][e]}]}]]

Use MetaInformation to specify PlotLegends:

Wolfram Language code: data = TemporalData[Automatic, {{{{1662.33502197266, 1572.}, {1653.52496337891, 1563.}, {1634.92498779297, 1536.5}, {1642.40002441406, 1525.5}, {1642.40002441406, 1525.5}, {1640.23498535156, 1521.5}, {1638.70001220703, 1530.}, {1606.10504150391, ... 1, {"Continuous", 1}, {"Discrete", 1}, 2, {MetaInformation -> {"MetalList" -> {"Gold", "Platinum"}, "Unit" -> "USDollars"/"TroyOunces"}, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 2}}, True, 10.];

See the available MetaInformation:

Wolfram Language code: data["MetaInformation"]

Access specific information directly:

Wolfram Language code: data["MetalList"]

Visualize the data:

Wolfram Language code: DateListPlot[data, PlotLegends -> data["MetalList"]]

Use MetaInformation to name the path components in a vector-valued TemporalData:

Wolfram Language code: td = TemporalData[Array[a, {2, 5, 3}], {0}, "MetaInformation" -> {"ComponentNames" -> {"a", "b", "c"}}]

Extract second component:

Wolfram Language code: td["PathComponent", "b"]//Normal

Extract first and third components using either their name or number:

Wolfram Language code: td["PathComponent", {1, "c"}]//Normal

Use MetaInformation to name the paths:

Wolfram Language code: td = TemporalData[RandomReal[2, {4, 3}], Automatic, MetaInformation -> {"PathNames" -> {"a", "b", "c", "d"}}];

Extract path by name:

Wolfram Language code: td["Path", "a"]

Extract first and third paths using either their name or number:

Wolfram Language code: td["Path", {1, "c"}]

MissingDataMethod  (5)

By default, values with head Missing are interpreted as missing:

Wolfram Language code: missd = {2, 1, 3, Missing[], 2, 1, 2, Missing[], 6, 2, 5};
Wolfram Language code: td = TemporalData[missd, Automatic]
Wolfram Language code: Plot[td["PathFunction"][t], {t, 0, 10}, PlotRange -> All]

The setting Automatic will use the ResamplingMethod setting:

Wolfram Language code: missd = {2, 1, 3, Missing[], 2, 1, 2, Missing[], 6, 2, 5};
Wolfram Language code: td = TemporalData[missd, {0}, MissingDataMethod -> Automatic]
Wolfram Language code: Plot[td["PathFunction"][t], {t, 0, 10}, PlotRange -> All]

Use cubic interpolation to interpolate the path:

Wolfram Language code: td3 = TemporalData[missd, Automatic, MissingDataMethod -> Automatic, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 3}]
Wolfram Language code: Plot[td3["PathFunction"][t], {t, 0, 10}, PlotRange -> All]

With ResamplingMethod set to None, missing values will not be interpolated:

Wolfram Language code: missd = {2, 1, 3, Missing[], 2, 1, 2, Missing[], 6, 2, 5};
Wolfram Language code: td = TemporalData[missd, Automatic, MissingDataMethod -> Automatic, ResamplingMethod -> None]
Wolfram Language code: td["PathFunction"][Range[0, 10]]

Use a custom interpolation for filling in missing values:

Wolfram Language code: missd = {2, 1, 3, Missing[], 2, 1, 2, Missing[], 6, 2, 5};
Wolfram Language code: td = TemporalData[missd, Automatic, MissingDataMethod -> {"Interpolation", Method -> "Spline", InterpolationOrder -> 3}]
Wolfram Language code: Plot[td["PathFunction"][t], {t, 0, 10}]

The method for handling missing data need not match the ResamplingMethod:

Wolfram Language code: tdM = TemporalData[missd, Automatic, MissingDataMethod -> {"Constant", 0}, ResamplingMethod -> {"Interpolation", Method -> "Hermite", InterpolationOrder -> 3}]
Wolfram Language code: Plot[tdM["PathFunction"][t], {t, 0, 10}]

Retain missing data indices as metainformation:

Wolfram Language code: missd = {2, 1, 3, Missing[], 2, 1, 2, Missing[], 6, 2, 5};
Wolfram Language code: t = Flatten[Position[missd, _Missing] - 1]
Wolfram Language code: td = TemporalData[missd, Automatic, MissingDataMethod -> Automatic, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 3}, MetaInformation -> {"MissingTimes" -> t}];

Highlight the interpolated regions:

Wolfram Language code: Show[Plot[td["PathFunction"][x], {x, 0, 10}], Table[Plot[td["PathFunction"][x], {x, i, i + 1}, PlotStyle -> {Thick, Red}], {i, td["MissingTimes"]}]]

ResamplingMethod  (6)

By default, "PathFunction" gives zero-order paths that hold their value from the left:

Wolfram Language code: vals = {2, 1, 6, 5, 7, 4};
Wolfram Language code: td = TemporalData[vals, Automatic];
Wolfram Language code: Plot[td["PathFunction", 1][t], {t, 0, 5}]

Set the InterpolationOrder to 1:

Wolfram Language code: td2 = TemporalData[vals, Automatic, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}];
Wolfram Language code: Plot[td2["PathFunction", 1][t], {t, 0, 5}]

Use zero-order interpolation that holds its value from the right:

Wolfram Language code: vals = {2, 1, 6, 5, 7, 4};
Wolfram Language code: tdR = TemporalData[vals, Automatic, ResamplingMethod -> {"Interpolation", "HoldFrom" -> Right}];
Wolfram Language code: Plot[tdR["PathFunction", 1][t], {t, 0, 5}]

Use a constant value:

Wolfram Language code: vals = {2, 1, 6, 5, 7, 4};
Wolfram Language code: td = TemporalData[vals, Automatic, ResamplingMethod -> {"Constant", 10}];
Wolfram Language code: DiscretePlot[td["PathFunction", 1][t], {t, 0, 5, .25}, Joined -> True]

Use cubic spline interpolation for paths:

Wolfram Language code: vals = Accumulate /@ RandomVariate[NormalDistribution[], {3, 50}];
Wolfram Language code: td = TemporalData[vals, Automatic, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 3, Method -> "Spline"}];
Wolfram Language code: Plot[Evaluate@Table[i[t], {i, td["PathFunction", All]}], {t, 0, 49}]

The interpolating method used can impact the value of time slices:

Wolfram Language code: vals = {{2, 1, 6, 5, 7, 4}, {1, 2, 3, 4, 5, 6}};
Wolfram Language code: td1 = TemporalData[vals, Automatic, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 0}]; td2 = TemporalData[vals, Automatic, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}];

Time stamps for the paths:

Wolfram Language code: times = td1["Times"]
Wolfram Language code: td1["SliceData", times] == td2["SliceData", times]

Time points in between the time stamps:

Wolfram Language code: times2 = MovingAverage[times, 2]//N
Wolfram Language code: td1["SliceData", times2] == td2["SliceData", times2]

Setting the method to None will treat values not present in the data as missing:

Wolfram Language code: vals = {2, 1, 6, 5, 7, 4};
Wolfram Language code: td = TemporalData[vals, Automatic, ResamplingMethod -> None];
Wolfram Language code: td["PathFunction"][Range[0, 5]]
Wolfram Language code: td["PathFunction"][Range[0, 5, .5]]

Equivalently, use a constant Missing[]:

Wolfram Language code: td2 = TemporalData[vals, Automatic, ResamplingMethod -> {"Constant", Missing[]}];
Wolfram Language code: td2["PathFunction"][Range[0, 5, .5]]

TemporalRegularity  (1)

Explicitly assume that temporal data is regularly spaced:

Wolfram Language code: times = {1, 3, 4, 5, 6};
Wolfram Language code: td1 = TemporalData[Range[5], {times}];
Wolfram Language code: RegularlySampledQ[td1]

Internal representation of times:

Wolfram Language code: td1["UnexpandedRawTimes"]
Wolfram Language code: td2 = TemporalData[Range[5], {times}, TemporalRegularity -> True];
Wolfram Language code: RegularlySampledQ[td2]

New internal representation of times:

Wolfram Language code: td2["UnexpandedRawTimes"]

TimeZone  (1)

Specify the time zone of TemporalData:

Wolfram Language code: td = TemporalData[{1, 2, 3}, {Yesterday}, TimeZone -> 0]

The time stamps were created in $TimeZone, but the dates are displayed in the time zone specified by the option:

Wolfram Language code: td["Dates"]

ValueDimensions  (1)

By default, the dimensionality of the values is inferred from the data:

Wolfram Language code: vals = {{1, 1}, {0, 2}, {-1, 1}, {0, 0}, {-1, -1}, {0, 0}, {1, -1}, {0, -2}, {1, -3}, {0, -2}, {1, -3}, {0, -4}, {1, -5}, {2, -4}, {3, -5}, {2, -6}, {3, -5}, {4, -4}, {3, -5}, {4, -6}, {5, -5}, {6, -6}, {7, -5}, {8, -6}, {9, -7}};
Wolfram Language code: td = TemporalData[vals, Automatic];

The input is interpreted as 25 separate paths:

Wolfram Language code: ListLinePlot[td]

Setting the ValueDimensions to 2 treats the data as a single path of dimension 2:

Wolfram Language code: td2 = TemporalData[vals, Automatic, ValueDimensions -> 2];
Wolfram Language code: ParametricPlot[td2["PathFunction"][t], {t, 0, 24}]

Applications  (2)

Reproduce the mean function for a random process:

Wolfram Language code: td = RandomFunction[WienerProcess[1, 1], {0, 10, 0.5}, 100];
Wolfram Language code: Show[ListLinePlot[td, PlotStyle -> Directive[Opacity[0.2], Thin]], Plot[Mean[td[t]], {t, 0, 10}, PlotStyle -> Thick]]

Compare the variance function for the data with the variance function for the process:

Wolfram Language code: Plot[{Variance[WienerProcess[1, 1][t]], Variance[td[t]]}, {t, 0, 10}, PlotStyle -> Thick]

Compare the moment functions of order 4:

Wolfram Language code: Plot[{Moment[WienerProcess[1, 1][t], 4], Moment[td[t], 4]}, {t, 0, 10}, PlotStyle -> Thick]

Estimate the variance for a slice of TransformedProcess:

Wolfram Language code: 𝒫 = TransformedProcess[b[2t + 1], bWienerProcess[], t];
Wolfram Language code: data = RandomFunction[𝒫, {0, 4, 0.01}, 100]
Wolfram Language code: Variance[data["SliceData", 1.4]]

Compare with the actual variance:

Wolfram Language code: Variance[𝒫[1.4]]

Properties & Relations  (5)

Some equivalence relationships:

Wolfram Language code: td = TemporalData[Automatic, {{{0., -0.139684575896826, -0.059517699038847, 0.0660932103196359, -0.01602506797095704, -0.0289948080792522, -0.013245285254768709, 0.0062738135921464044, 0.010874104000783792, -0.008001405909889188, -0.0053088155 ... 0.6747608871514955, 0.6454023452359723, 0.4659297460527968, 0.27925702539178754, 0.17904719606354433, 0.1535778398761809, 0.29343414442311655, 0.5929274833073943}}, {{0., 1., 0.1}}, 25, {"Discrete", 25}, {"Discrete", 1}, 1, {}}, False, 9.];

Two ways to extract the collection of paths:

Wolfram Language code: td["Path", All] == td["Paths"]

Two ways to obtain the first path in the ensemble:

Wolfram Language code: td["Path"] == td["Path", 1]

Slice distributions at time :

Wolfram Language code: td[.1] == EmpiricalDistribution[td["SliceData", .1]]

TemporalData can contain several paths:

Wolfram Language code: data = RandomReal[{-1, 1}, {3, 100}];
Wolfram Language code: td = TemporalData[data, Automatic]

TimeSeries is limited to a single path, interpreting the same data as a list of vectors:

Wolfram Language code: ts = TimeSeries[data, Automatic]

The slicing behavior of TimeSeries differs from TemporalData:

Wolfram Language code: {td[5], ts[5]}

TemporalData at a time outside the time domain extrapolates the values:

Wolfram Language code: TemporalData[{1, 2, 3}][4]

The warning message is not issued by default but can be turned on:

Wolfram Language code: On[TemporalData::dmval]
Wolfram Language code: TemporalData[{1, 2, 3}][4]

Turn the message off:

Wolfram Language code: Off[TemporalData::dmval]

TimeSeries objects can be combined into a single TemporalData object:

Wolfram Language code: data = RandomReal[{-1, 1}, {3, 100}];
Wolfram Language code: tslist = TimeSeries /@ data
Wolfram Language code: TemporalData[tslist]

TemporalData is a generalization of EventSeries:

Wolfram Language code: data = RandomReal[{-1, 1}, 100];
Wolfram Language code: es = EventSeries[data, Automatic]

Unlike TemporalData, EventSeries does not interpolate between the existing timestamps:

Wolfram Language code: es[2]
Wolfram Language code: es[2.5]

Possible Issues  (6)

The dimensionality of the values can be ambiguous:

Wolfram Language code: vals = {{1, -1}, {0, -2}, {-1, -3}, {0, -4}, {1, -5}};
Wolfram Language code: td = TemporalData[vals, Automatic];

By default, this is interpreted as an ensemble of five paths of dimension 1:

Wolfram Language code: td["ValueDimensions"]
Wolfram Language code: td["PathCount"]

Setting the ValueDimensions to 2 treats the data as a single path of dimension 2:

Wolfram Language code: td2 = TemporalData[vals, Automatic, ValueDimensions -> 2];
Wolfram Language code: td2["ValueDimensions"]
Wolfram Language code: td2["PathCount"]

Accumulating irregularly sampled temporal data:

Wolfram Language code: vals = Range[4]; times = {1, 3, 4, 9};
Wolfram Language code: td = TemporalData[vals, {times}]

Accumulate will resample to create regularly sampled temporal data:

Wolfram Language code: Accumulate[td]//Normal

Compare with accumulated values:

Wolfram Language code: Accumulate[vals]

To recover that behavior, assume TemporalRegularity:

Wolfram Language code: Accumulate[TemporalData[td, TemporalRegularity -> True]]//Normal

Another way is to specify ResamplingMethod by setting new values to 0:

Wolfram Language code: Accumulate[TemporalData[td, ResamplingMethod -> {"Constant", 0}]]//Normal

If the ResamplingMethod specification is not an implemented one, it will assume the value Automatic:

Wolfram Language code: td = TemporalData[{1, 2, 3}, ResamplingMethod -> foo];
Wolfram Language code: td["ResamplingType"]

Path names must be strings:

Wolfram Language code: td = TemporalData[RandomReal[2, {4, 3}], Automatic, MetaInformation -> {"PathNames" -> {"a", 1, "b", "c"}}]
Wolfram Language code: td["Path", "a"]

Path names must be non-empty strings:

Wolfram Language code: td = TemporalData[RandomReal[2, {4, 3}], Automatic, MetaInformation -> {"PathNames" -> {"a", "b", "", "c"}}]
Wolfram Language code: td["Path", ""]

Path component names must be strings:

Wolfram Language code: td = TemporalData[RandomReal[2, {1, 5, 3}], Automatic, MetaInformation -> {"ComponentNames" -> {1, "b", "c"}}];
Wolfram Language code: td["PathComponent", "b"]

Path component names must be non-empty strings:

Wolfram Language code: td = TemporalData[RandomReal[2, {1, 5, 3}], Automatic, MetaInformation -> {"ComponentNames" -> {"", "b", "c"}}];
Wolfram Language code: td["PathComponent", ""]

Temporal data with repeated component names:

Wolfram Language code: td = TemporalData[Array[x, {4, 3}], {0}, ValueDimensions -> 3, MetaInformation -> {"ComponentNames" -> {"d", "a", "a"}}]
Wolfram Language code: td["ComponentNames"]

For a repeated name, only the first component will be repeatedly extracted:

Wolfram Language code: td["PathComponent", {"a", "a"}]//Normal

Use an index to access the next components with the same name:

Wolfram Language code: td["PathComponent", {"a", 3}]//Normal

Neat Examples  (1)

Animate the movement of the continental plates during the Mesozoic Era:

Wolfram Language code: cp = Entity["GeologicalPeriod", "MesozoicEra"]["ContinentalPlates"];
Wolfram Language code: vals = GeoGraphics[{GeoStyling[GrayLevel[.7]], #}, GeoBackground -> LightBlue, GeoProjection -> "Mollweide", GeoCenter -> {0, 0}, GeoRange -> All]& /@ Values[cp];
Wolfram Language code: td = TemporalData[vals, {Keys[cp]}]
Wolfram Language code: ListAnimate[td, AnimationRunning -> False]

See Also

TimeSeries  EventSeries  TimeSeriesModelFit  MovingMap  RandomFunction  CorrelationFunction  EstimatedProcess  ListLinePlot  DateListPlot  EventData  WeightedData

Related Guides

    ▪
  • Random Processes
  • ▪
  • Probability & Statistics
  • ▪
  • Time Series Processes
  • ▪
  • Descriptive Statistics

History

Introduced in 2012 (9.0) | Updated in 2014 (10.0) ▪ 2015 (10.1) ▪ 2019 (12.0)

Wolfram Research (2012), TemporalData, Wolfram Language function, https://reference.wolfram.com/language/ref/TemporalData.html (updated 2019).

Text

Wolfram Research (2012), TemporalData, Wolfram Language function, https://reference.wolfram.com/language/ref/TemporalData.html (updated 2019).

CMS

Wolfram Language. 2012. "TemporalData." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2019. https://reference.wolfram.com/language/ref/TemporalData.html.

APA

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

BibTeX

@misc{reference.wolfram_2026_temporaldata, author="Wolfram Research", title="{TemporalData}", year="2019", howpublished="\url{https://reference.wolfram.com/language/ref/TemporalData.html}", note=[Accessed: 01-September-2026]}

BibLaTeX

@online{reference.wolfram_2026_temporaldata, organization={Wolfram Research}, title={TemporalData}, year={2019}, url={https://reference.wolfram.com/language/ref/TemporalData.html}, note=[Accessed: 01-September-2026]}

Top
Introduction for Programmers
Introductory Book
Wolfram Function Repository | Wolfram Data Repository | Wolfram Data Drop | Wolfram Language Products
Top
  • Products
  • Wolfram|One
  • Mathematica
  • AI Access
  • Compute Services
  • System Modeler

  • Wolfram|Alpha Notebook Edition
  • Wolfram|Alpha Pro
  • Mobile Apps

  • Wolfram Engine
  • Wolfram Player

  • Volume & Site Licensing
  • Server Deployment Options
  • Consulting
  • Wolfram Consulting
  • Repositories
  • Data Repository
  • Function Repository
  • Community Paclet Repository
  • Neural Net Repository
  • Prompt Repository

  • Wolfram Language Example Repository
  • Notebook Archive
  • Wolfram GitHub
  • Learning
  • Wolfram U
  • Wolfram Language Documentation
  • Webinars & Training
  • Educational Programs

  • Wolfram Language Introduction
  • Fast Introduction for Programmers
  • Fast Introduction for Math Students
  • Books

  • Wolfram Community
  • Wolfram Blog
  • Public Resources
  • Wolfram|Alpha
  • Wolfram Problem Generator
  • Wolfram Challenges

  • Computer-Based Math
  • Computational Thinking
  • Computational Adventures

  • Demonstrations Project
  • Wolfram Data Drop
  • MathWorld
  • Wolfram Science
  • Wolfram Media Publishing
  • Customer Resources
  • Store
  • Product Downloads
  • User Portal
  • Your Account
  • Organization Access

  • Support FAQ
  • Contact Support
  • Company
  • About Wolfram
  • Careers
  • Contact
  • Events
Wolfram Community Wolfram Blog
Legal & Privacy Policy
WolframAlpha.com | WolframCloud.com
© 2026 Wolfram
© 2026 Wolfram | Legal & Privacy Policy |
English