KAHIBARO Bookshelves
Discord Login Register

16.5. Basic Time Series Handling

Understanding Time Series in MATLAB

A time series is a sequence of data values ordered in time. In MATLAB, you can treat time series as ordinary numeric arrays together with a matching time axis, or you can use dedicated time related data types introduced earlier. Here the focus is on how to work practically with simple time series once you already have time values and data in MATLAB.

Typical examples of time series are daily stock prices, hourly temperature readings, or sensor measurements sampled every millisecond. The key idea is that each data point has a corresponding time stamp, and most operations must respect that ordering and spacing in time.

Pairing Time Vectors with Data

In many basic workflows you store time information in one vector and the corresponding values in another. For example, you might have a datetime vector t and a numeric vector x with the same length. Element x(i) represents the value at time t(i).

You can construct such a pair directly. For equally spaced time points, you often use a vector of times created with : or with functions for date and time construction. For example, a series of hourly times can be created and then associated with random data values:

t = datetime(2024,1,1,0,0,0):hours(1):datetime(2024,1,1,23,0,0);
x = rand(size(t));

After this, t(k) and x(k) always belong together. Many plotting and analysis functions accept this style of input, with the time vector as the first argument and the data values as the second, for example plot(t, x).

If your time series is multivariate, such as temperature, pressure, and humidity at the same times, you store one time vector and a matrix of data. Then each column is a variable and each row corresponds to one time point:

t = datetime(2024,1,1,0,0,0):minutes(10):datetime(2024,1,1,3,0,0);
T = rand(length(t), 3);    % 3 variables

In this case T(i,1) is the value of variable 1 at time t(i), and so on.

Ensuring Proper Time Ordering

Many operations on time series assume that the time vector is sorted in ascending order and that there are no duplicated times. If your time points arrive out of order, you should sort them together with the corresponding data.

A simple pattern for sorting uses the sort function to obtain sorting indices and then reorders both the time vector and the data array in the same way. For example, if t is a datetime vector and x is a numeric vector:

[tSorted, idx] = sort(t);
xSorted = x(idx);

After this, tSorted is in increasing time order, and xSorted is reordered to match. You then work with tSorted and xSorted for further analysis.

You should avoid sorting time and data separately. If you used sort on t and another sort on x independently, you would break the mapping between each time and its value. Always use the same index vector when you reorder related arrays.

When your series has multiple variables stored in columns, you use the same approach and apply the sorting indices to all columns:

[tSorted, idx] = sort(t);
TSorted = T(idx, :);

If your time series has duplicate time stamps and you need unique times, one simple approach is to use logical indexing to keep only the first occurrence of each time. This is a basic step that prepares the data for later analysis.

Resampling and Changing Sampling Frequency

In practice, time series data rarely comes in exactly the time spacing you need. You might have measurements every second but want averages every minute, or you might have irregularly spaced data and want values at regular intervals. These tasks are examples of resampling.

A simple way to resample is to create a new time vector with the desired spacing, then compute new values based on the original series. For example, to obtain minute averages from seconds data, you can group indices that fall into each minute and take the mean for each group.

Suppose t is a datetime vector with many time stamps and x is the corresponding data. You can construct a new time vector tNew with a regular spacing and then compute values for it. There are many ways to do this; a straightforward approach uses indexing by ranges of time:

tNew = (t(1)):minutes(1):(t(end));   % new regular times
xNew = zeros(size(tNew));
for k = 1:numel(tNew)
    if k < numel(tNew)
        idx = t >= tNew(k) & t < tNew(k+1);
    else
        idx = t >= tNew(k) & t <= t(end);
    end
    xNew(k) = mean(x(idx));
end

This simple loop computes the average of all values in each one minute bin. In real work you might use more advanced functions to accomplish similar tasks more compactly, but the pattern is the same: define target times, then compute values for those times from the original data.

You can also resample by interpolation rather than averaging. Interpolation estimates data values at new time points by using neighboring samples. A basic tool for this is interp1, which takes original times, original values, and new times, and returns interpolated values. For example:

xInterp = interp1(t, x, tNew, 'linear');

In this call, 'linear' specifies linear interpolation. Different methods give different behavior, but all share the same basic pattern.

Handling Missing Data in Time Series

In many time series, some values are missing. In MATLAB, missing numeric data is often represented by NaN. Before calculating statistics or plotting, you must decide how to handle these missing values.

A basic step is simply to remove missing values entirely, which you can do with logical indexing. For instance, if x contains NaN values and you want to work only with the subset of valid points, you can construct a logical index valid that is true where both the time and value are valid and then keep only those rows:

valid = ~isnan(x);
tValid = t(valid);
xValid = x(valid);

Alternatively, you might want to fill missing values with estimates. One simple approach uses interpolation. For example, to replace NaN values in x with linear interpolation in time, you can first identify indices of valid elements and then interpolate only over them:

valid = ~isnan(x);
xFilled = x;
xFilled(~valid) = interp1(t(valid), x(valid), t(~valid), 'linear');

This code leaves existing values unchanged and replaces only the missing values by estimates based on neighboring times.

Sometimes you might prefer to fill with a fixed value, such as zero, or with the last observed value carried forward. These are also straightforward with logical indexing and do not require interpolation.

Regardless of the method, the key is to keep time and values aligned and to apply the same logical mask to both the time vector and any data arrays.

Aligning Multiple Time Series

Often you need to compare or combine two or more time series with different time vectors. For example, one sensor might report every second and another every five seconds. To correlate or plot them together in a meaningful way, you must align them in time.

A simple alignment strategy is to choose a common time axis and resample each time series onto that axis. For instance, suppose t1, x1 represent series 1 and t2, x2 represent series 2. You can define a time grid that covers the entire shared span, then interpolate both series onto that grid:

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

Where to Move

Move chapter:

  • ☰ 1. Getting Started with MATLAB
    • ☰ 1.1. What Is MATLAB and What Is It Used For
      • ☰ 1.2. Installing MATLAB and Setting Up the Environment
        • ☰ 1.3. Understanding the MATLAB Desktop Interface
          • ☰ 1.4. Command Window, Workspace, and Current Folder
            • ☰ 1.5. Basic Workflow and Running Simple Commands
              • ☰ 1.6. Getting Help and Documentation
              • ☰ 2. MATLAB Language Basics
                • ☰ 2.1. MATLAB Syntax and Expressions
                  • ☰ 2.2. Variables and Assignment
                    • ☰ 2.3. Data Types and Type Conversion
                      • ☰ 2.4. Vectors and Matrices Fundamentals
                        • ☰ 2.5. Creating and Indexing Arrays
                          • ☰ 2.6. Basic Arithmetic and Elementwise Operations
                            • ☰ 2.7. Using Built-In Constants and Functions
                            • ☰ 3. Working with Variables and the Workspace
                              • ☰ 3.1. Creating, Viewing, and Editing Variables
                                • ☰ 3.2. Workspace Browser and Variable Inspector
                                  • ☰ 3.3. Saving and Loading Data Files
                                    • ☰ 3.4. MAT-Files and Importing External Data
                                      • ☰ 3.5. Clearing Variables and Managing the Workspace
                                      • ☰ 4. Vectors, Matrices, and Arrays
                                        • ☰ 4.1. Row and Column Vectors
                                          • ☰ 4.2. Matrix Creation and Concatenation
                                            • ☰ 4.3. Indexing, Slicing, and Logical Indexing
                                              • ☰ 4.4. Matrix Operations vs Elementwise Operations
                                                • ☰ 4.5. Reshaping and Rearranging Arrays
                                                  • ☰ 4.6. Special Matrices and Functions
                                                  • ☰ 5. Basic Programming Constructs
                                                    • ☰ 5.1. Scripts vs Functions
                                                      • ☰ 5.2. Control Flow with if, elseif, else
                                                        • ☰ 5.3. Loops with for and while
                                                          • ☰ 5.4. break, continue, and return
                                                            • ☰ 5.5. Logical Expressions and Relational Operators
                                                              • ☰ 5.6. Best Practices for Clear and Readable Code
                                                              • ☰ 6. Functions in MATLAB
                                                                • ☰ 6.1. Creating Simple Functions
                                                                  • ☰ 6.2. Function Inputs and Outputs
                                                                    • ☰ 6.3. Function Files and the Path
                                                                      • ☰ 6.4. Local vs Global Variables
                                                                        • ☰ 6.5. Anonymous Functions
                                                                          • ☰ 6.6. Organizing Code into Multiple Functions
                                                                          • ☰ 7. Working with Numbers and Math
                                                                            • ☰ 7.1. Scalars and Vectorized Computations
                                                                              • ☰ 7.2. Basic Mathematical Functions
                                                                                • ☰ 7.3. Trigonometric and Exponential Functions
                                                                                  • ☰ 7.4. Complex Numbers in MATLAB
                                                                                    • ☰ 7.5. Rounding, Modulo, and Special Values
                                                                                      • ☰ 7.6. Numerical Precision and Floating Point Considerations
                                                                                      • ☰ 8. Strings, Characters, and Categorical Data
                                                                                        • ☰ 8.1. Character Arrays and String Arrays
                                                                                          • ☰ 8.2. Creating and Manipulating Strings
                                                                                            • ☰ 8.3. Converting Between Data Types and Strings
                                                                                              • ☰ 8.4. Comparing and Searching Strings
                                                                                                • ☰ 8.5. Categorical Arrays Basics
                                                                                                • ☰ 9. Tables, Structures, and Cell Arrays
                                                                                                  • ☰ 9.1. Introduction to Tables
                                                                                                    • ☰ 9.2. Creating Tables and Accessing Data
                                                                                                      • ☰ 9.3. Modifying and Joining Tables
                                                                                                        • ☰ 9.4. Structures and Nested Structures
                                                                                                          • ☰ 9.5. Cell Arrays and Cell Indexing
                                                                                                            • ☰ 9.6. Choosing the Right Container Type
                                                                                                            • ☰ 10. Importing and Exporting Data
                                                                                                              • ☰ 10.1. Reading Text and CSV Files
                                                                                                                • ☰ 10.2. Importing Excel Spreadsheets
                                                                                                                  • ☰ 10.3. Importing Data with the Import Tool
                                                                                                                    • ☰ 10.4. Exporting Data to Files
                                                                                                                      • ☰ 10.5. Working with Image and Audio Files
                                                                                                                        • ☰ 10.6. Basic File Management from MATLAB
                                                                                                                        • ☰ 11. Plotting and Visualization
                                                                                                                          • ☰ 11.1. Introduction to 2D Plotting
                                                                                                                            • ☰ 11.2. Customizing Plots and Axes
                                                                                                                              • ☰ 11.3. Multiple Plots in One Figure
                                                                                                                                • ☰ 11.4. Labels, Titles, Legends, and Annotations
                                                                                                                                  • ☰ 11.5. Plotting with Different Line and Marker Styles
                                                                                                                                    • ☰ 11.6. Saving and Exporting Figures
                                                                                                                                    • ☰ 12. Advanced Plotting for Beginners
                                                                                                                                      • ☰ 12.1. Subplots and Tiled Layouts
                                                                                                                                        • ☰ 12.2. Bar, Scatter, and Stem Plots
                                                                                                                                          • ☰ 12.3. Histograms and Density Plots
                                                                                                                                            • ☰ 12.4. 3D Plots and Surface Plots
                                                                                                                                              • ☰ 12.5. Using plottools and Interactive Editing
                                                                                                                                                • ☰ 12.6. Basics of Handle Graphics
                                                                                                                                                • ☰ 13. Working with Scripts and Live Scripts
                                                                                                                                                  • ☰ 13.1. Creating and Running Script Files
                                                                                                                                                    • ☰ 13.2. Sectioning Code and Running Sections
                                                                                                                                                      • ☰ 13.3. Live Scripts and Rich Text
                                                                                                                                                        • ☰ 13.4. Adding Equations, Images, and Outputs
                                                                                                                                                          • ☰ 13.5. Sharing and Exporting Live Scripts
                                                                                                                                                          • ☰ 14. Debugging and Code Quality
                                                                                                                                                            • ☰ 14.1. Finding and Fixing Syntax Errors
                                                                                                                                                              • ☰ 14.2. Setting Breakpoints and Stepping Through Code
                                                                                                                                                                • ☰ 14.3. Inspecting Variable Values During Execution
                                                                                                                                                                  • ☰ 14.4. Using the Editor Debugging Tools
                                                                                                                                                                    • ☰ 14.5. Using Code Analyzer and Warnings
                                                                                                                                                                      • ☰ 14.6. Writing Clean and Maintainable MATLAB Code
                                                                                                                                                                      • ☰ 15. Basic Linear Algebra with MATLAB
                                                                                                                                                                        • ☰ 15.1. Vectors and Norms
                                                                                                                                                                          • ☰ 15.2. Matrix Addition and Multiplication
                                                                                                                                                                            • ☰ 15.3. Solving Linear Systems with Backslash
                                                                                                                                                                              • ☰ 15.4. Inverses, Determinants, and Rank
                                                                                                                                                                                • ☰ 15.5. Eigenvalues and Eigenvectors
                                                                                                                                                                                  • ☰ 15.6. Using Linear Algebra Functions Safely
                                                                                                                                                                                  • ☰ 16. Data Analysis and Statistics Fundamentals
                                                                                                                                                                                    • ☰ 16.1. Descriptive Statistics and Summary Measures
                                                                                                                                                                                      • ☰ 16.2. Sorting, Filtering, and Grouping Data
                                                                                                                                                                                        • ☰ 16.3. Basic Correlation and Regression
                                                                                                                                                                                          • ☰ 16.4. Simple Data Cleaning Techniques
                                                                                                                                                                                            • ☰ 16.5. Basic Time Series Handling
                                                                                                                                                                                            • ☰ 17. Working with Time and Dates
                                                                                                                                                                                              • ☰ 17.1. Representing Dates and Times
                                                                                                                                                                                                • ☰ 17.2. Creating and Formatting datetime Arrays
                                                                                                                                                                                                  • ☰ 17.3. Date Calculations and Differences
                                                                                                                                                                                                    • ☰ 17.4. Plotting Data over Time
                                                                                                                                                                                                    • ☰ 18. Introduction to Signal and Image Handling
                                                                                                                                                                                                      • ☰ 18.1. Basic Signal Representation in MATLAB
                                                                                                                                                                                                        • ☰ 18.2. Simple Filtering and Transformations
                                                                                                                                                                                                          • ☰ 18.3. Reading, Displaying, and Writing Images
                                                                                                                                                                                                            • ☰ 18.4. Basic Image Transformations
                                                                                                                                                                                                            • ☰ 19. Automation and Scripting Tasks
                                                                                                                                                                                                              • ☰ 19.1. Batch Processing of Files
                                                                                                                                                                                                                • ☰ 19.2. Writing Reusable Utility Scripts
                                                                                                                                                                                                                  • ☰ 19.3. Using Relative Paths and the MATLAB Path
                                                                                                                                                                                                                    • ☰ 19.4. Simple User Interaction with input and disp
                                                                                                                                                                                                                    • ☰ 20. Introduction to Toolboxes
                                                                                                                                                                                                                      • ☰ 20.1. What Are Toolboxes and How to Use Them
                                                                                                                                                                                                                        • ☰ 20.2. Exploring Installed Toolboxes
                                                                                                                                                                                                                          • ☰ 20.3. Finding Functions in Toolboxes
                                                                                                                                                                                                                            • ☰ 20.4. Add-Ons and MATLAB File Exchange
                                                                                                                                                                                                                            • ☰ 21. Best Practices and Next Steps
                                                                                                                                                                                                                              • ☰ 21.1. Organizing Projects and Folders
                                                                                                                                                                                                                                • ☰ 21.2. Version Control Basics with MATLAB
                                                                                                                                                                                                                                  • ☰ 21.3. Performance Tips for Beginners
                                                                                                                                                                                                                                    • ☰ 21.4. Learning Resources and Documentation Path
                                                                                                                                                                                                                                      • ☰ 21.5. Suggested Practice Projects for Beginners