Calculating difference between both adjacent and non-adjacent pairs using multiple index vectors

Question

I have three numerical vectors containing position values (pos), a category (type), and an index (ind), in these general forms:

pos =
2 4 5 11 1 5 8 11 12 20

type = 
1 2 1 2 1 1 2 1 2 3

ind =
1 1 1 1 2 2 2 2 2 2

I want to calculate the difference between values held within pos but only between the same types, and confined to each index. Using the above example:

When ind = 1

The difference(s) between type 1 positions = 3 (5-2). 
The difference(s) between type 2 positions = 7 (11-4).

In the case where more than two instances of any given type exist within any index, the differences are calculate sequentially from left to right as shown here:

When ind = 2

The difference(s) between type 1 positions = 4 (5-1), 6 (11-5).
The difference(s) between type 2 positions = 4 (12-8).

Even though index 2 contains type '3', no difference is calculated as only 1 instance of this type is present.

Types are not always only 1, 2 or 3.

Ideally, the desired output would be matrix containing the same number of columns as length(unique(type)) with rows containing all differences calculated for that type. The output does not need to separate by index, only the actual calculation needs to. In this case there are three unique types, so the output would be (labels added for clarity only):

Type 1  Type 2  Type 3
  3       7       0
  4       4       0
  6       0       0

Any empty entries can be padded with zeroes.

Is there a concise or fast manner to do this?

EDIT:

EDIT 2:

Additional input/output example.

pos = [1 15 89 120 204 209 8 43 190 304]
type = [1 1 1 2 2 1 2 3 2 3]
ind = [1 1 1 1 1 1 2 2 2 2]

Desired output:

Type 1  Type 2  Type 3
  14      84     261
  74      182     0
  120      0      0

In this case, the script works perfectly:

At least in recent matlab versions, I expect a solution using two loops to be the fastest. — Daniel, Aug 22 '15 at 18:01
What would be the expected output for this case? I don't understand how you want to put the output into one matrix. — Daniel, Aug 22 '15 at 18:03
So for each value of `ind` and for the corresponding values of `pos` that coincide with `type`, do you wish to find all possible combinations of differences? I'm still having trouble understanding what the expected output is. — rayryeng, Aug 22 '15 at 18:39
Not all combinations. It's done sequentially from left to right. The first value of any given type is paired with the next one of the same type to its right and so on. Pos will always be sorted for each index. — AnnaSchumann, Aug 22 '15 at 18:43

score 2 · Accepted Answer · edited May 23 '17 at 11:58

At least for creating the output matrix a loop is required:

pos = [2 4 5 11 1 5 8 11 12 20]
type = [1 2 1 2 1 1 2 1 2 3]
ind = [1 1 1 1 2 2 2 2 2 2]

%// get unique combinations of type and ind
[a,~,subs] = unique( [type(:) ind(:)] , 'rows')
%// create differences
%// output is cell array according to a
temp = accumarray(subs,1:numel(subs),[],@(x) {abs(diff(pos(x(end:-1:1))))} )

%// creating output matrix
for ii = 1:max(a(:,1))              %// iterating over types
    vals = [temp{ a(:,1) == ii }];  %// differences for each type
    out(1:numel(vals),ii) = vals;
end

out =

     3     7     0
     4     4     0
     6     0     0

In case it doesn't work for your real data you may need unique(...,'rows','stable') and a 'stable' accumarray.

It appeared that the above solution gives different results depending on the system.

The only reason, why the code could give different results on different machines, is that accumarray is not "stable" as mentioned above. And in some very rare cases it could return unpredictable results. So please try the following:

pos =  [2 4 5 11 1 5 8 11 12 20]
type = [1 2 1  2 1 1 2  1  2  3]
ind =  [1 1 1  1 2 2 2  2  2  2]

%// get unique combinations of type and ind
[a,~,subs] = unique( [type(:) ind(:)] , 'rows')

%// take care of unstable accumarray
[~, I] = sort(subs);
pos = pos(I);
subs = subs(I,:);

%// create differences
%// output is cell array according to a
temp = accumarray(subs,1:numel(subs),[],@(x) {abs(diff(pos(x(end:-1:1))))} )

%// creating output matrix
for ii = 1:max(a(:,1))              %// iterating over types
    vals = [temp{ a(:,1) == ii }];  %// differences for each type
    out(1:numel(vals),ii) = vals;
end

out =

     3     7     0
     4     4     0
     6     0     0

Calculating difference between both adjacent and non-adjacent pairs using multiple index vectors

1 Answers1