Implementing a "moving window" on an array and selecting values preceding each window

Hey all! I have an array which I will call as "spiketimes''. It's essentially an array consisitng of time points, from ~0.1 secs to ~4.5 secs. Now I have another array called "eyetimes", also consisting of time points. What I ultimately want to do is to select values of the "eyetimes" array based on the values of the "spiketimes" array and how I want to go about this is to implement a "moving window" of sorts.

For eg, the first window will take a window of 0.2 secs in the "spiketime" array from the start (0.0 secs) till about 0.2 secs. Based on this selection, I need to select the value of the "eyetimes" array right before this window.

The second window will now offset the starting point by 0.05 secs such that the starting point will now be at 0.05 secs and the end point will be at 0.25 secs, while keeping the same interval of 0.2 secs. Again I need to select the value of "eyetimes" before the start of the second window.

Likewise, the third window will start at 0.1 secs and end at 0.3 secs and so on...

This continues till the end of the array contents, offsetting the start of the window by 0.05 secs, while still maintaining the interval of 0.2 secs. What might be the best way to go about this? Thanks in advance!

Edited: attached .mat files for both "spiketimes" and "eyetime"

[Image Analyst]

Data? Screenshots?

TUTORIAL: How to ask a question (on Answers) and get a fast answer

[Kevin Akash Rajasekaran]

Apologies. Hopefully the screenshots provide some context.

[Image Analyst]

Just a tip -- no one is going to type in all those numbers to help you. Just saying...

You might want to attach your data like I originally asked. Use the paperclip icon to attach the data file. And also give code to read the data in to your variables. Come on, make it easy for people to help you, not hard. Did you read the link I gave?

[Kevin Akash Rajasekaran]

Done. Again, sorry for the trouble. I'm not sure what exactly you mean by using code to read the data in to the variables? At the moment, I have just these two cell arrays to work with.

[Mathieu NOE]

O don't get the reason why your are focusing on defining a window just to pick data before that window ??

also, that is not odable for the first window, because that means you would like to pick data in the negative time horizon, which does not exist...

unless I haved missed some points , this request is quite unclear to me

[Catalytic]

@Kevin Akash Rajasekaran

Please do not make us download multiple .mat files. Put all your variables in one .mat file.

[Kevin Akash Rajasekaran]

A spike event happens at a particular time point and is stored in the spike times array. Preceding this particular time point is an eye time event stored in the eye times array. The catch is that not all eye time points leads to a spike event. Hence the reason for selecting eye times based on spike times. Hope this helps!

Answer 1

[VINAYAK LUHA]

Hi Akash,

As per my understading, the use-cases you are trying to achieve are as follows: -

• You have two sorted arrays of time values, “spiketimes” and “eyetimes”.
• Let the parameters for your “sliding window-based algorithm” be defined as-

d =>window size.

[s,t] =>start and end of the window.

r =>smallest time value in “eyetimes” array closest to “s” in “spiketimes” array.

m =>sliding offset for the window.

• You want to find all “r”s as the window of size “d”, defined by time [s,t] slides over the “spiketimes” array with sliding offset “m”.

Implementing the sliding window algorithm for this purpose is suboptimal as you don’t require to do any computation for the window elements.

Here is an alternate more efficient approach to achieve your use-case using binary search algorithm-

• Define “s” as 0 initially and a vector “sol” to store the solution.
• Loop over and keep incrementing “s” by “d” each step till “s” < “spiketimes(end)”.
• In each iteration –

Define variables “a” and “b” as follows:

a =upper bound of “s” in the “spiketimes” array (using a binary search variant).

b =lower bound of “a” in the “eyetimes” array (using another binary search variant).

Store the values of “b” in the “sol” array.

For your better understanding, I am attaching here, the code snippet that demonstrates this approach: 

load eyetime.mat; 
load spiketimes.mat; 

s=0; 
d=0.05; 
sol=zeros(1,100) 

while s<=spiketimes(end) 
    a=upperbound(s,spiketimes); 
    b=lowerbound(a,eyetime); 
    disp(num2str(s)+" "+num2str(a)+" "+num2str(b)) 
    s=s+d; 
end 

%finds a number greater than equal to “k” in the array arr. 
function a=upperbound(k,arr) 
    startIndex = 1; 
    endIndex = length(arr); 
    while startIndex < endIndex 
        mid = floor((startIndex + endIndex) / 2); 
        if k>=arr(mid)  
            startIndex = mid + 1; 
        else 
            endIndex = mid; 
        end 
    end 
    if (startIndex<length(arr)&&arr(startIndex)<=k) 
          startIndex=startIndex+1; 
    end 
    a = arr(startIndex); 
end 


%finds a number less than “k” in array “arr” 
function b=lowerbound(k,arr) 
    startIndex = 1; 
    endIndex = length(arr); 
    while startIndex < endIndex 
        mid = floor((startIndex + endIndex) / 2); 
        if k<=arr(mid)  
            endIndex = mid; 
        else 
            startIndex = mid+1; 
        end 
    end 
    if (startIndex<length(arr)&&arr(startIndex)<k) 
          startIndex=startIndex+1; 
    end 
    b = arr(startIndex-1); 

end 

Further, you can refer to the following articles to understand the algorithm in detail:

• Binary search:

https://www.geeksforgeeks.org/binary-search/

• Finding lower and upper bound of an element using binary search:

https://www.geeksforgeeks.org/implementing-upper_bound-and-lower_bound-in-c/

I hope you find this solution useful, and this helps you find the correct set of values from the “eyetimes” array, as desired.

Regards,

Vinayak Luha