确定矩阵A是否为矩阵B的子集

Question

For a matrix such as

A = [...
    12 34 67;
    90 78 15;
    10 71 24];

how could we determine efficiently if it is subset of a larger matrix?

B = [...
    12 34 67;                        % found
    89 67 45;
    90 78 15;                        % found  
    10 71 24;                        % found, so A is subset of B. 
    54 34 11];

Here are conditions:

• all numbers are integers
• matrices are so large, ie, row# > 100000, column# may vary from 1 to 10 (same for A and B).

Edit: It seems that ismember for the case of this question, when called only few times works just fine. My initial impression was due to previous experiences where ismember was being invoked many times inside a nested loop resulting in the worst performance.

clear all; clc
n = 200000;
k = 10;
B = randi(n,n,k);
f = randperm(n);
A = B(f(1:1000),:);
tic
assert(sum(ismember(A,B,'rows')) == size(A,1));
toc
tic
assert(all(any(all(bsxfun(@eq,B,permute(A,[3,2,1])),2),1))); %user2999345
toc

which results in:

Elapsed time is 1.088552 seconds.
Elapsed time is 12.154969 seconds.

Here are more benchmarks:

clear all; clc
n = 20000;
f = randperm(n);
k = 10;
t1 = 0;
t2 = 0;
t3 = 0;
for i=1:7
    B = randi(n,n,k);
    A = B(f(1:n/10),:);
    %A(100,2) = 0;                                      % to make A not submat of B
    tic
    b = sum(ismember(A,B,'rows')) == size(A,1);
    t1 = t1+toc;
    assert(b);
    tic
    b = ismember_mex(A,sortrows(B));
    t2 = t2+toc;
    assert(b);
    tic
    b = issubmat(A,B);
    t3 = t3+toc;
    assert(b);
end

                             George's       skm's
                ismember | ismember_mex | issubmat
n=20000,k=10      0.6326      0.1064      11.6899
n=1000,k=100      0.2652      0.0155       0.0577
n=1000,k=1000     1.1705      0.1582       0.2202
n=1000,k=10000   13.2470      2.0033       2.6367
*issubmat eats RAM when n or k is over 10000!
*issubmat(A,B), A is being checked as submat of B. 

Answer 1

For small matrices ismember should be enough, probably. Usage: ismember(B,A,'rows')

ans =
   1
   0
   1
   1
   0

I put this answer here, emphasizing on a need to solutions with higher performance. I will accept this answer only if there was no better solution.

Answer 2

Using ismember , if a row of A appears twice in B while another one is missing, might wrongly indicate that A is a member of B . The following solution is suitable if the rows of A and B doesn't need to be in the same order. However, I haven't tested its performance for large matrices.

A = [...
34 12 67;
90 78 15;
10 71 24];
B = [...
34 12 67;                        % found
89 67 45;
90 78 15;                        % found  
10 71 24;                        % found, so A is subset of B. 
54 34 11];
A = permute(A,[3 2 1]);
rowIdx = all(bsxfun(@eq,B,A),2);
colIdx = any(rowIdx,1);
isAMemberB = all(colIdx);

Answer 3

You have said number of columns <= 10. In addition, if the matrix elements are all integers representable as bytes, you could code each row into a two 64 bit integers. That would reduce the number of comparisons by a factor of 64.

For the general case, the following may not be all that much better for thin matrices, but scales very well as the matrices get fat due to the level 3 multiplication:

function yes = is_submat(A,B)
   ma = size(A, 1);
   mb = size(B, 1);
   n = size(B, 2);

   yes = false;
   if ma >= mb
      a = A(:,1);
      b = B(:,1);

      D = (0 == bsxfun(@minus, a, b'));
      q = any(D, 2);

      yes = all(any(D,1));
      if yes && (n > 1)
         A = A(q, :);

         C = B*A';

         za = sum(A.*A, 2);
         zb = sum(B.*B, 2);
         Z = sqrt(zb)*sqrt(za');

         [~, ix] = max(C./Z, [], 2);

         A = A(ix,:);
         yes = all(A(:) == B(:));
      end
   end
end

In the above, I use the fact that the dot product is maximized when two unit vectors are equal.

For fat matrices (say 5000+ columns) with large numbers of unique elements the performance beats ismember quite handily, but otherwise, it is slower than ismember. For thin matrices ismember is faster by an order of magnitude.

Best case test for this function:

A = randi(50000, [10000, 10000]);
B = A(2:3:end, :);
B = B(randperm(size(B,1)),:);
fprintf('%s: %u\n', 'Number of columns', size(A,2));
fprintf('%s: %u\n', 'Element spread', 50000);
tic; is_submat(A,B); toc;
tic; all(ismember(B,A,'rows')); toc;
fprintf('________\n\n');

is_submat_test;

Number of columns: 10000

Element spread: 50000

Elapsed time is 10.713310 seconds (is_submat).

Elapsed time is 17.446682 seconds (ismember).

So I have to admit, all round ismember seems to be much better.

Edits: Edited to correct bug when there is only one column - fixing this also results in more efficient code. Also previous version did not distinguish between positive and negative numbers. Added timing tests.

Answer 4

It seems that ismember is hard to beat, at least using MATLAB code. I created a C implementation which can be used using the MEX compiler.

#include "mex.h"

#if MX_API_VER < 0x07030000
typedef int mwIndex;
typedef int mwSize;
#endif /* MX_API_VER */

#include <math.h>
#include <stdlib.h>
#include <string.h>

int ismember(const double *y, const double *x, int yrow, int xrow, int ncol);

void mexFunction(int nlhs, mxArray *plhs[],
        int nrhs, const mxArray *prhs[])
{
    mwSize xcol, ycol, xrow, yrow;

    /* output data */
    int* result;

    /* arguments */
    const mxArray* y;
    const mxArray* x;

    if (nrhs != 2)
    {
        mexErrMsgTxt("2 input required.");
    }

    y = prhs[0];
    x = prhs[1];
    ycol = mxGetN(y);
    yrow = mxGetM(y);
    xcol = mxGetN(x);
    xrow = mxGetM(x);

    /* The first input must be a sparse matrix. */
    if (!mxIsDouble(y) || !mxIsDouble(x))
    {
        mexErrMsgTxt("Input must be of type 'double'.");
    }
    if (xcol != ycol)
    {
        mexErrMsgTxt("Inputs must have the same number of columns");
    }

    plhs[0] = mxCreateLogicalMatrix(1, 1);
    result = mxGetPr(plhs[0]);
    *result = ismember(mxGetPr(y), mxGetPr(x), yrow, xrow, ycol);
}

int ismemberinner(const double *y, int idx, const double *x, int yrow, int xrow, int ncol) {
    int from, to, i;
    from = 0;
    to = xrow-1;

    for(i = 0; i < ncol; ++i) {
        // Perform binary search
        double yi = *(y + i * yrow + idx);
        double *curx = x + i * xrow;
        int l = from;
        int u = to;
        while(l <= u) {
            int mididx = l + (u-l)/2;
            if(yi < curx[mididx]) {
                u = mididx-1;
            }
            else if(yi > curx[mididx]) {
                l = mididx+1;
            }
            else {
                // This can be further optimized by performing additional binary searches
                for(from = mididx; from > l && curx[from-1] == yi; --from);
                for(to = mididx; to < u && curx[to+1] == yi; ++to);
                break;
            }
        }
        if(l > u) {
            return 0;
        }
    }
    return 1;
}

int ismember(const double *y, const double *x, int yrow, int xrow, int ncol) {
    int i;
    for(i = 0; i < yrow; ++i) {
        if(!ismemberinner(y, i, x, yrow, xrow, ncol)) {
            return 0;
        }
    }
    return 1;
}

Compile it using:

mex -O ismember_mex.c

It can be called as follows:

ismember_mex(x, sortrows(x))

First of all, it assumes that the columns of the matrices have the same size. It works by first sorting the rows of the larger matrix (x in this case, the second argument to the function). Then, a type of binary search is employed to identify whether the rows of the smaller matrix (y hereafter) are contained in x. This is done for each row of y separately (see ismember C function). For a given row of y, it starts from the first entry and finds the range of indices (using the from and to variables) that match with the first column of x using binary search. This is repeated for the remaining entries, unless some value is not found, in which case it terminates and returns 0.

I tried implementing it this idea in MATLAB, but it didn't work that well. Regarding performance, I found that: (a) in case there are mismatches, it is usually much faster than ismember (b) in case the range of values in x and y is large, it is again faster than ismember , and (c) in case everything matches and the number of possible values in x and y is small (eg less than 1000), then ismember may be faster in some situations. Finally, I want to point out that some parts of the C implementation may be further optimized.

EDIT 1

I fixed the warnings and further improved the function.

#include "mex.h"
#include <math.h>
#include <stdlib.h>
#include <string.h>

int ismember(const double *y, const double *x, unsigned int nrowy, unsigned int nrowx, unsigned int ncol);

void mexFunction(int nlhs, mxArray *plhs[],
        int nrhs, const mxArray *prhs[])
{
    unsigned int xcol, ycol, nrowx, nrowy;

    /* arguments */
    const mxArray* y;
    const mxArray* x;

    if (nrhs != 2)
    {
        mexErrMsgTxt("2 inputs required.");
    }

    y = prhs[0];
    x = prhs[1];
    ycol = (unsigned int) mxGetN(y);
    nrowy = (unsigned int) mxGetM(y);
    xcol = (unsigned int) mxGetN(x);
    nrowx = (unsigned int) mxGetM(x);

    /* The first input must be a sparse matrix. */
    if (!mxIsDouble(y) || !mxIsDouble(x))
    {
        mexErrMsgTxt("Input must be of type 'double'.");
    }
    if (xcol != ycol)
    {
        mexErrMsgTxt("Inputs must have the same number of columns");
    }

    plhs[0] = mxCreateLogicalScalar(ismember(mxGetPr(y), mxGetPr(x), nrowy, nrowx, ycol));
}

int ismemberinner(const double *y, const double *x, unsigned int nrowy, unsigned int nrowx, unsigned int ncol) {
    unsigned int from = 0, to = nrowx-1, i;

    for(i = 0; i < ncol; ++i) {
        // Perform binary search
        const double yi = *(y + i * nrowy);
        const double *curx = x + i * nrowx;
        unsigned int l = from;
        unsigned int u = to;
        while(l <= u) {
            const unsigned int mididx = l + (u-l)/2;
            const double midx = curx[mididx];
            if(yi < midx) {
                u = mididx-1;
            }
            else if(yi > midx) {
                l = mididx+1;
            }
            else {
                {
                    // Binary search to identify smallest index of x that equals yi
                    // Equivalent to for(from = mididx; from > l && curx[from-1] == yi; --from)
                    unsigned int limit = mididx;
                    while(curx[from] != yi) {
                        const unsigned int mididx = from + (limit-from)/2;
                        if(curx[mididx] < yi) {
                            from = mididx+1;
                        }
                        else {
                            limit = mididx-1;
                        }
                    }
                }
                {
                    // Binary search to identify largest index of x that equals yi
                    // Equivalent to for(to = mididx; to < u && curx[to+1] == yi; ++to);
                    unsigned int limit = mididx;
                    while(curx[to] != yi) {
                        const unsigned int mididx = limit + (to-limit)/2;
                        if(curx[mididx] > yi) {
                            to = mididx-1;
                        }
                        else {
                            limit = mididx+1;
                        }
                    }
                }
                break;
            }
        }
        if(l > u) {
            return 0;
        }
    }
    return 1;
}

int ismember(const double *y, const double *x, unsigned int nrowy, unsigned int nrowx, unsigned int ncol) {
    unsigned int i;
    for(i = 0; i < nrowy; ++i) {
        if(!ismemberinner(y + i, x, nrowy, nrowx, ncol)) {
            return 0;
        }
    }
    return 1;
}

Using this version I wasn't able to identify any case where ismember is faster. Also, I noticed that one reason ismember is hard to beat is that it uses all cores of the machine! Of course, the function I provided can be optimized to do this too, but this requires much more effort.

Finally, before using my implementation I would advise you to do extensive testing. I did some testing and it seems to work, but I suggest you also do some additional testing.