Hi understand that you want to improve the speed of computing the moving window skewness for your time series data.
You can consider the following optimizations:
- Utilize Parallel Computing: Since you have 16 workers available, you can use MATLAB's Parallel Computing Toolbox to distribute the computation across multiple workers. This can significantly speed up the calculations. You can use the 'parfor' loop instead of the regular 'for' loop to parallelize the computation. However, keep in mind that the parallelization overhead might not be worth it for smaller window sizes.
- Preallocate Memory: Preallocating memory for the results can improve the performance. Instead of initializing 'sk_timeseries' as an empty array, you can preallocate it with the appropriate size using 'zeros' or 'NaN' values.
- Vectorization: Whenever possible, try to avoid explicit loops and use vectorized operations. This can significantly improve the execution speed. In your case, you can calculate the moving window skewness for all windows simultaneously using indexing and vectorized operations.
Here's an optimized version of your code incorporating these suggestions:
% Dummy data of equal length
state_timeseries = randn(1, 10000000);
time = 1:length(state_timeseries);
total_window_count = 200; % 200 as used above
window_size_list = floor(linspace(300000, 4000000, total_window_count));
step_size_list = floor(window_size_list * (1 / 100));
% Preallocate cell array for results
Data_skewness_timeseries = cell(1, total_window_count);
% Use GPU if available
gpu_available = canUseGPU();
if gpu_available == 1
time = gpuArray(time);
state_timeseries = gpuArray(state_timeseries);
end
parfor k = 1:total_window_count
% Set window size and step size to calculate the corresponding EWS timeseries
window_size = window_size_list(k);
window_step = step_size_list(k);
% Get the indices where windows start and the corresponding times at which they end.
% This is to specify the skewness of a window at the time value at the end of the window.
window_idx = 1:window_step:(length(time) - window_size + 1);
time_window_ends_idx = window_idx + window_size - 1;
time_window_ends = time(time_window_ends_idx);
% Calculate the moving window skewness using vectorized operations
sk_timeseries = arrayfun(@(idx) skewness(state_timeseries(idx:idx+window_size-1)), window_idx);
% Store the results in the cell array
Data_skewness_timeseries{k} = struct('time_window_ends', time_window_ends, 'sk_timeseries', sk_timeseries);
end
Regarding your question about implementing these calculations in C++, it is possible to achieve better performance by implementing the computation in a lower-level language like C++. MATLAB provides a way to call C++ code from MATLAB using the MATLAB Engine API. You can write the computationally intensive part of the code in C++ and then call it from MATLAB to get the generated moving window skewness time series back into MATLAB for further processing. This approach can potentially provide significant speed gains, especially for large datasets.
Here are some of the useful resources for you:
I hope this helps.
