Return a new Array with elements that aren't present in the other Arrays.
979931
function difference(arr) {
        var arrs = slice(arguments, 1),
            result = filter(unique(arr), function(needle){
                return !some(arrs, function(haystack){
                    return contains(haystack, needle);
                });
            });
        return result;
    }
265424
function unique(oldArray) {
    var nIndex,
      nLen = oldArray.length,
      aArr = [];
    for (nIndex = 0; nIndex < nLen; nIndex++) {
      if (!contains(aArr, oldArray[nIndex][1])) {
        aArr.push(oldArray[nIndex]);
      }
    }
    return aArr;
  }
68499
def duplicate(self):
        """"""
        other = Matcher(self.loc, self.check_var, self.checkdefs, self.names, self.var_index)
        other.insert_check(0, "not " + self.check_var)
        self.others.append(other)
        return other
1359420
def A(*a):
    """"""
    return np.array(a[0]) if len(a)==1 else [np.array(o) for o in a]
98302
def compare_lists(old=None, new=None):
    '''
    
    '''
    ret = dict()
    for item in new:
        if item not in old:
            ret['new'] = item
    for item in old:
        if item not in new:
            ret['old'] = item
    return ret
963551
function (array) {
    var m = array.length, t, i;

    // While there remain elements to shuffle…
    while (m) {

      // Pick a remaining element…
      i = Math.floor(Math.random() * m--);

      // And swap it with the current element.
      t = array[m];
      array[m] = array[i];
      array[i] = t;
    }

    return array;
  }
1276032
def _ensure_array_list(arrays):
    """"""
    # Note: the isinstance test is needed below so that instances of FieldArray
    # are not converted to numpy arrays
    return [numpy.array(arr, ndmin=1) if not isinstance(arr, numpy.ndarray)
            else arr for arr in arrays]
560172
public static int[] mergeSortedArrays(int[] nums1, int[] nums2, boolean ignoreEquals, boolean desc) {
        int len = nums1.length + nums2.length;
        int[] nums = new int[len];
        int m = 0;
        int n = 0;
        for (int i = 0; i < len; i++) {
            if (ignoreEquals && m < nums1.length && n < nums2.length && nums1[m] == nums2[n]) {
                if (m < nums1.length - 1) {
                    m++;
                } else if (n < nums2.length - 1) {
                    n++;
                }
                len--;
                i--;
                continue;
            }
            boolean inNums1 = n == nums2.length || (m != nums1.length && ((nums1[m] < nums2[n]) ^ desc));
            if (inNums1) {
                nums[i] = nums1[m++];
            } else {
                nums[i] = nums2[n++];
            }
        }
        if (nums1.length + nums2.length == len) {
            return nums;
        } else {
            int[] newNums = new int[len];
            System.arraycopy(nums, 0, newNums, 0, len);
            return newNums;
        }
    }
450536
def _fill_array_from_list(the_list, the_array):
        """"""
        for i, val in enumerate(the_list):
            the_array[i] = val
        return the_array
816528
function(arrayA, arrayB) {

    var returnArray =[];
    var i = 0;
    arrayA.forEach(function(doc){
        if (common.isUseless(theIDCheck(arrayB, doc) )) { i += 1; }
        else {
            i += 1;
            returnArray.push([doc, theIDCheck(arrayB, doc)]); ////push a pair of matching docs
        };
    });

    if ( (i == arrayA.length) && ( common.isUseless(returnArray[0]) ) ) {    return null;    }
    else if ( (i == arrayA.length) && (common.isUseless(returnArray[0]) == false ) ) {    return returnArray;    };
}
456102
def without(seq1, seq2):
    
    """
    if isSet(seq2): d2 = seq2
    else: d2 = set(seq2)
    return [elt for elt in seq1 if elt not in d2]
985174
function arrayMergeUnique(a, b) {
  return a.concat(b).filter(function(v,i,c) {
    if(i === c.indexOf(v)) return true
    return false
  })
}
791400
function (a, b) {
                var result = [], inB = {}, i, n;
                for (i = 0, n = b.length; i < n; i++) {
                    inB[b[i]] = true;
                }
                for (i = 0, n = a.length; i < n; i++) {
                    if (!inB[a[i]]) {
                        result.push(a[i]);
                    }
                }
                return result;
            }
340502
public static <T> T[] notNullElements(T[] array, String name) {
        notEmpty(Arrays.asList(array), name);
        for (T ele : array) {
            notNull(ele, String.format("Collection %s element %s", name, ele));
        }
        return array;
    }
456309
def _get_sorting_key_values(self, array1, array2):
        """"""

        concat_arrays = numpy.concatenate([array1, array2])
        unique_values = numpy.unique(concat_arrays)

        return numpy.sort(unique_values)
1320015
def array_subscripts(expr):
    """"""
    if isinstance(expr, Array):
        return all_subs(expr._bounds)
    elif isinstance(expr, list):
        subs = [subscripts(x) for x in expr]
        return flatten(subs)
    else:
        return [expr]
155358
@SafeVarargs
  public static <E> RubyArray<E> newRubyArray(E... elements) {
    return new RubyArray<>(new ArrayList<>(Arrays.asList(elements)));
  }