how to fill a column with 1's between two specific values and with 0 otherwise?

Dear all

I have a matrix with 27 columns. The rows are time periods. Each column takes value 1, 0 or -1. For instance, a typical column would look like this:

 % 
0
0
1
0
0
0
-1
0
0
1
0
0
0
0
-1
0
0
1
end

If you imagine a time series, values of 1 mean a peak, values of -1 mean a trough. Hence, we can define a period of expansion as the period between any t=1 and t=-1 (including these two endpoints).

I want to create a matrix such that each column has 1's in every period belonging to an expansion period and 0's otherwise. For instance, the column above would become

 %
0
0
1
1
1
1
1
0
0
1
1
1
1
1
1
0
0
0
end

My question is how to this in an efficient manner and in a way that applies to every column of the matrix at once. I struggling with the end values. For instance, the last value is a 1 but since there is no -1 after it, it should become a 0!

Thanks for your help

James

Edit: Btw, this is what I have so far.... it has been running for quite a while so I have no idea whether it works or not.. but even if it does it really is inefficient

 %
 [R, C] = size(mBBpre); %mBBpre is the matrix of 0's,1's and -1's

 mExpansionPre = NaN(R,C);        %this is where I want to put the values                                          

 for j = 1 : C

 % iLocalPeak is the number of Peaks for column j    

 iLocalPeak = vPeaksPre(j,1);            

 % iLocalTrough is the number of Troughs for column j

 iLocalTrough = vTroughPre(j,1);             

 % Pre-allocates space                               

 vPositionPeaksPre = NaN(iLocalPeak,1);     

 % Pre-allocates space                                 

 vPositionTroughPre = NaN(iLocalTrough,1);                               

 % Stores Positions of Peaks

 vPositionPeaksPre = find(mBBpre(:,j) == 1); 

 % Stores Positions of Troughs                            

 vPositionTroughPre = find(mBBpre(:,j) == -1);                               

 for k = 1 : numel(vPositionPeaksPre)

    for i = 1 : numel(mExpansionPre)

        if i >= vPositionPeaksPre(k,1) && i <= vPositionTroughPre(k,1)

           mExpansionPre(i,j) = 1;

        else
            mExpansionPre(i,j) = 0;
        end
    end
 end

 end

 end

Answer 1

[dpb]

Sometimes it's just simpler to loop...

i1=find(v==1);  % start
i2=find(v==-1); % end
if length(i2)>length(i1)  % end effect, if any
  v(i2(end))=0;           % zero that position
  ix(end)=[];             % and cleanup array length
end
for i=1:length(i1)        % fill in the array locations wanted
  v(i1(i):i2(i))=ones(i1(i)-i2(i)+1,1);
end

Some effort could turn this into an arrayfun candidate no doubt, but I suspect the above will be just as fast and easier to debug/maintain...

[James Grayot]

Hi. I think it does not account for all the weird cases that can happen as it did not correctly solve all the columns in my matrix. I think this code below works, though.

 %
  [R, C] = size(mBBpre);

mExpansionPre = zeros(R,C);

for j = 1 : C

      iLocalPeak = vPeaksPre(j,1);

      iLocalTrough = vTroughPre(j,1);   

      vPositionPeaksPre = NaN(iLocalPeak,1);

      vPositionTroughPre = NaN(iLocalTrough,1);

      vPositionPeaksPre = find(mBBpre(:,j) == 1);

      vPositionTroughPre = find(mBBpre(:,j) == -1);

      k = numel(vPositionPeaksPre);

          while vPositionPeaksPre(k,1) > vPositionTroughPre(end,1)

                vPositionPeaksPre(end,:) = [];

                k = numel(vPositionPeaksPre);

          end  

      clear k

%Excludes the degenerate case that the first phase is not expansion

      if vPositionPeaksPre(1,1) > vPositionTroughPre(1,1)                 

         vPositionTroughPre(1,:) = [];

      end      

    for k = 1 : numel(vPositionPeaksPre)

        for i = vPositionPeaksPre(k,1) : vPositionTroughPre(k,1)

                mExpansionPre(i,j) = 1;

        end
    end

    end
end

[James Grayot]

 The previous code is for contractionts, not expansions (my mistake).  This code is for expansions. It works very well even though there might be more efficient ways to do it. Maybe it will be helpful for someone in the future!

 % iLocalPeak is the number of Peaks for column j

% iLocalTrough is the number of Troughs for column j

 function [mExpansion] = expansion(mBB, vPeaks, vTrough)

 [R, C] = size(mBB);

 mExpansion = zeros(R,C);   

    for j = 1 : C

        iLocalPeak = vPeaks(j,1);   

   iLocalTrough = vTrough(j,1);                                         

        vPositionPeaks = NaN(iLocalPeak,1);  % Pre-allocates space

        vPositionTrough = NaN(iLocalTrough,1); 

        vPositionPeaks = find(mBB(:,j) == 1); 

        vPositionTrough = find(mBB(:,j) == -1);  

            if ~isempty(vPositionPeaks) && ~isempty(vPositionTrough)

                k = numel(vPositionTrough);     

                    while vPositionTrough(k,1) > vPositionPeaks(end,1)...
  && ~isempty(vPositionPeaks) &&  ~isempty(vPositionTrough)                        

 % Excludes the degenerate case that the last peak
   is not followed by a trough

                          vPositionTrough(end,:) = [];

                          k = numel(vPositionTrough);

                    end 

            end

 % Ensures that we analyse Trough-to-peak(expansion) and not Peak-to-  Trough (contraction)

            if ~isempty(vPositionPeaks) && ~isempty(vPositionTrough)

                if vPositionTrough(1,1) > vPositionPeaks(1,1) 

                    vPositionPeaks(1,:) = [];

                end      

            end

        if ~isempty(vPositionPeaks) && ~isempty(vPositionTrough)

            for k = 1 : numel(vPositionPeaks)                               % Fills mExpansion

                for i = vPositionTrough(k,1)+1 : vPositionPeaks(k,1)        % +1 ensures that the peak point is excluded from the contraction phase

                    mExpansion(i,j) = 1;

                end
            end

        end    

    end

 end

[dpb]

Don't know what "weird cases" there are; you didn't specify any other patterns. Fixing the typo in the original submission might help; the ix should be i2 when cleaning up the array size for the end effect of a +1 w/ no trailing -1 after.

Of course, if there are cases other than +1 ... -1 patterns with perhaps the last +1 not having its mate, that's a whole different ballgame... :(

So, what else can happen...if there's an arbitrary +/-1 seems like it'd be quite difficult without additional conditions to "do the right thing" as how's one to know what is the right thing given random data?

[James Grayot]

Hi. +1/-1 alternate by previous code I used to create matrix with 1/-1/0's, but it can start with either 0, 1´s or -1´s. I understood that "ix" was a typo and changed it when running the code. However in our codes (as far as I understood), we must ensure that: 1) the vectors which store the positions of peaks and troughs have the same size; 2) that the first entry in the vector of position of troughs is a number smaller than the first entry in the vector of positions of peaks; 3) account for the cases in which the set of peaks or troughs is empty to begin with or becomes empty in the process of applying either 1) or 2). I am not 100% sure (I am a matlab beginner), but I think that your code does not account for the empty sets and that it accounts for end effects but not necessarily for beginning effects. For instance, does your code account for the possibility that you have this: peak - trough - peak - trough? In this case, we would need to delete the first peak and the last trough.

[dpb]

"does your code account for the possibility that you have this: peak - trough - peak - trough?"

No, of course not. That wasn't in the design spec, sorry. "SCOPE!" :)

If you've got a case that works, good, hopefully the posted code led you in the right direction but in future, realize we only know what we're told (while the crystal ball has been known to operate, it's a rare occurrence and more often it is in the shop for repair when needed than not) so if there are conditions such as these additional that are important, it's important those are given. Else't one receives a perfectly good solution, just wasn't the right question.

[James Grayot]

True that, my apologies. I should have explained it more clearly. I did accept your answer btw. The "bright" side is that we ended up asnwering two different questions which may me useful in the future for others. Thank you for your help. :D

Answer 2

[Andrei Bobrov]

v = [0
0
1
0
0
0
-1
0
0
1
0
0
0
0
-1
0
0
1];

z = find(v == -1);
v(z) = 0;
v(z+1) = -1;
v(end) = 0;
out = cumsum(v);