title: Python equivalent of MATLAB's "ismember" function
body: <p>After many attempts trying optimize code, it seems that one last resource would be to attempt to run the code below using multiple cores. I don't know exactly how to convert/re-structure my code so that it can run much faster using multiple cores. I will appreciate if I could get guidance to achieve the end goal. The end goal is to be able to run this code as fast as possible for arrays A and B where each array holds about 700,000 elements. Here is the code using small arrays.  The 700k element arrays are commented out.</p>
  
  <pre><code>import numpy as np
  
  def ismember(a,b):
      for i in a:
          index = np.where(b==i)[0]
          if index.size == 0:
              yield 0
          else:
              yield index
  
  
  def f(A, gen_obj):
      my_array = np.arange(len(A))
      for i in my_array:
          my_array[i] = gen_obj.next()
      return my_array
  
  
  #A = np.arange(700000)
  #B = np.arange(700000)
  A = np.array([3,4,4,3,6])
  B = np.array([2,5,2,6,3])
  
  gen_obj = ismember(A,B)
  
  f(A, gen_obj)
  
  print 'done'
  # if we print f(A, gen_obj) the output will be: [4 0 0 4 3]
  # notice that the output array needs to be kept the same size as array A.
  </code></pre>
  
  <p>What I am trying to do is to mimic a MATLAB function called <a href="http://www.mathworks.de/de/help/matlab/ref/ismember.html" rel="noreferrer">ismember</a>[2] (The one that is formatted as: <code>[Lia,Locb] = ismember(A,B)</code>.  I am just trying to get the <code>Locb</code> part only. </p>
  
  <blockquote>
    <p>From Matlab: Locb, contain the lowest index in B for each value in A that is a member of B. The output array, Locb, contains 0 wherever A is not a member of B</p>
  </blockquote>
  
  <p>One of the main problems is that I need to be able to perform this operation as efficient as possible.  For testing I have two arrays of 700k elements.  Creating a generator and going through the values of the generator doesn't seem to get the job done fast. </p>