# Get intersecting rows across two 2D numpy arrays

Posted on

### Question :

Get intersecting rows across two 2D numpy arrays

I want to get the intersecting (common) rows across two 2D numpy arrays. E.g., if the following arrays are passed as inputs:

``````array([[1, 4],
[2, 5],
[3, 6]])

array([[1, 4],
[3, 6],
[7, 8]])
``````

the output should be:

``````array([[1, 4],
[3, 6])
``````

I know how to do this with loops. I’m looking at a Pythonic/Numpy way to do this.

For short arrays, using sets is probably the clearest and most readable way to do it.

Another way is to use `numpy.intersect1d`. You’ll have to trick it into treating the rows as a single value, though… This makes things a bit less readable…

``````import numpy as np

A = np.array([[1,4],[2,5],[3,6]])
B = np.array([[1,4],[3,6],[7,8]])

nrows, ncols = A.shape
dtype={'names':['f{}'.format(i) for i in range(ncols)],
'formats':ncols * [A.dtype]}

C = np.intersect1d(A.view(dtype), B.view(dtype))

# This last bit is optional if you're okay with "C" being a structured array...
C = C.view(A.dtype).reshape(-1, ncols)
``````

For large arrays, this should be considerably faster than using sets.

You could use Python’s sets:

``````>>> import numpy as np
>>> A = np.array([[1,4],[2,5],[3,6]])
>>> B = np.array([[1,4],[3,6],[7,8]])
>>> aset = set([tuple(x) for x in A])
>>> bset = set([tuple(x) for x in B])
>>> np.array([x for x in aset & bset])
array([[1, 4],
[3, 6]])
``````

As Rob Cowie points out, this can be done more concisely as

``````np.array([x for x in set(tuple(x) for x in A) & set(tuple(x) for x in B)])
``````

There’s probably a way to do this without all the going back and forth from arrays to tuples, but it’s not coming to me right now.

I could not understand why there is no suggested pure numpy way to get this working. So I found one, that uses numpy broadcast. The basic idea is to transform one of the arrays to 3d by axes swapping. Let’s construct 2 arrays:

``````a=np.random.randint(10, size=(5, 3))
b=np.zeros_like(a)
b[:4,:]=a[np.random.randint(a.shape, size=4), :]
``````

With my run it gave:

``````a=array([[5, 6, 3],
[8, 1, 0],
[2, 1, 4],
[8, 0, 6],
[6, 7, 6]])
b=array([[2, 1, 4],
[2, 1, 4],
[6, 7, 6],
[5, 6, 3],
[0, 0, 0]])
``````

The steps are (arrays can be interchanged) :

``````#a is nxm and b is kxm
c = np.swapaxes(a[:,:,None],1,2)==b #transform a to nx1xm
# c has nxkxm dimensions due to comparison broadcast
# each nxixj slice holds comparison matrix between a[j,:] and b[i,:]
# Decrease dimension to nxk with product:
c = np.prod(c,axis=2)
#To get around duplicates://
# Calculate cumulative sum in k-th dimension
c= c*np.cumsum(c,axis=0)
# compare with 1, so that to get only one 'True' statement by row
c=c==1
#//
# sum in k-th dimension, so that a nx1 vector is produced
c=np.sum(c,axis=1).astype(bool)
# The intersection between a and b is a[c]
result=a[c]
``````

In a function with 2 lines for used memory reduction (correct me if wrong):

``````def array_row_intersection(a,b):
tmp=np.prod(np.swapaxes(a[:,:,None],1,2)==b,axis=2)
return a[np.sum(np.cumsum(tmp,axis=0)*tmp==1,axis=1).astype(bool)]
``````

which gave result for my example:

``````result=array([[5, 6, 3],
[2, 1, 4],
[6, 7, 6]])
``````

This is faster than set solutions, as it makes use only of simple numpy operations, while it reduces constantly dimensions, and is ideal for two big matrices. I guess I might have made mistakes in my comments, as I got the answer by experimentation and instinct. The equivalent for column intersection can either be found by transposing the arrays or by changing the steps a little. Also, if duplicates are wanted, then the steps inside “//” have to be skipped. The function can be edited to return only the boolean array of the indices, which came handy to me ,while trying to get different arrays indices with the same vector. Benchmark for the voted answer and mine (number of elements in each dimension plays role on what to choose):

Code:

``````def voted_answer(A,B):
nrows, ncols = A.shape
dtype={'names':['f{}'.format(i) for i in range(ncols)],
'formats':ncols * [A.dtype]}
C = np.intersect1d(A.view(dtype), B.view(dtype))
return C.view(A.dtype).reshape(-1, ncols)

a_small=np.random.randint(10, size=(10, 10))
b_small=np.zeros_like(a_small)
b_small=a_small[np.random.randint(a_small.shape,size=[a_small.shape]),:]
a_big_row=np.random.randint(10, size=(10, 1000))
b_big_row=a_big_row[np.random.randint(a_big_row.shape,size=[a_big_row.shape]),:]
a_big_col=np.random.randint(10, size=(1000, 10))
b_big_col=a_big_col[np.random.randint(a_big_col.shape,size=[a_big_col.shape]),:]
a_big_all=np.random.randint(10, size=(100,100))
b_big_all=a_big_all[np.random.randint(a_big_all.shape,size=[a_big_all.shape]),:]

print 'Small arrays:'
print 'Big column arrays:'
print 'Big row arrays:'
print 'Big arrays:'
``````

with results:

``````Small arrays:
Big column arrays:
Big row arrays:
Big arrays:
``````

Following verdict is that if you have to compare 2 big 2d arrays of 2d points then use voted answer. If you have big matrices in all dimensions, voted answer is the best one by all means. So, it depends on what you choose each time.

Another way to achieve this using structured array:

``````>>> a = np.array([[3, 1, 2], [5, 8, 9], [7, 4, 3]])
>>> b = np.array([[2, 3, 0], [3, 1, 2], [7, 4, 3]])
>>> av = a.view([('', a.dtype)] * a.shape).ravel()
>>> bv = b.view([('', b.dtype)] * b.shape).ravel()
>>> np.intersect1d(av, bv).view(a.dtype).reshape(-1, a.shape)
array([[3, 1, 2],
[7, 4, 3]])
``````

Just for clarity, the structured view looks like this:

``````>>> a.view([('', a.dtype)] * a.shape)
array([[(3, 1, 2)],
[(5, 8, 9)],
[(7, 4, 3)]],
dtype=[('f0', '<i8'), ('f1', '<i8'), ('f2', '<i8')])
``````

``````np.array(set(map(tuple, b)).difference(set(map(tuple, a))))
``````

This could also work

``````A = np.array([[1,4],[2,5],[3,6]])
B = np.array([[1,4],[3,6],[7,8]])

def matching_rows(A,B):
matches=[i for i in range(B.shape) if np.any(np.all(A==B[i],axis=1))]
if len(matches)==0:
return B[matches]
return np.unique(B[matches],axis=0)

>>> matching_rows(A,B)
array([[1, 4],
[3, 6]])

``````

This of course assumes the rows are all the same length.

Without Index

``````def intersect2D(Array_A, Array_B):
"""
Find row intersection between 2D numpy arrays, a and b.
"""

# ''' Using Tuple ''' #
intersectionList = list(set([tuple(x) for x in Array_A for y in Array_B  if(tuple(x) == tuple(y))]))
print ("intersectionList = n",intersectionList)

# ''' Using Numpy function "array_equal" ''' #
""" This method is valid for an ndarray """
intersectionList = list(set([tuple(x) for x in Array_A for y in Array_B  if(np.array_equal(x, y))]))
print ("intersectionList = n",intersectionList)

# ''' Using set and bitwise and '''
intersectionList = [list(y) for y in (set([tuple(x) for x in Array_A]) & set([tuple(x) for x in Array_B]))]
print ("intersectionList = n",intersectionList)

return intersectionList
``````
``````def intersect2D(Array_A, Array_B):
"""
Find row intersection between 2D numpy arrays, a and b.
Returns another numpy array with shared rows and index of items in A & B arrays
"""
# [[IDX], [IDY], [value]] where Equal
# ''' Using Tuple ''' #
IndexEqual = np.asarray([(i, j, x) for i,x in enumerate(Array_A) for j, y in enumerate (Array_B)  if(tuple(x) == tuple(y))]).T

# ''' Using Numpy array_equal ''' #
IndexEqual = np.asarray([(i, j, x) for i,x in enumerate(Array_A) for j, y in enumerate (Array_B)  if(np.array_equal(x, y))]).T

idx, idy, intersectionList = (IndexEqual, IndexEqual, IndexEqual) if len(IndexEqual) != 0 else ([], [], [])

return intersectionList, idx, idy
``````

``````import numpy as np

A=np.array([[1, 4],
[2, 5],
[3, 6]])

B=np.array([[1, 4],
[3, 6],
[7, 8]])

intersetingRows=[(B==irow).all(axis=1).any() for irow in A]
print(A[intersetingRows])
``````