Gets the union of the products for the given targets, preserving the input order.

    :API: public
171856
def get_for_targets(self, targets):
    
    products = OrderedSet()
    for target in targets:
      products.update(self._products_by_target[target])
    return products
588008
def _union(self, objs, index=None, column_i=0):
        
        feat_conc = []

        for feat, label in objs:

            # result is tuple of results
            if isinstance(feat, tuple):
                if label is None:
                    label = [None] * len(feat)

                partial_result = self._union(
                    zip(feat, label), column_i=column_i)
                feat_conc.append(partial_result)
                column_i = column_i + partial_result.shape[1]

            # result is pandas.Series.
            elif isinstance(feat, pandas.Series):
                feat.reset_index(drop=True, inplace=True)
                if label is None:
                    label = column_i
                feat.rename(label, inplace=True)
                feat_conc.append(feat)
                column_i = column_i + 1

            # result is pandas.DataFrame
            elif isinstance(feat, pandas.DataFrame):
                feat.reset_index(drop=True, inplace=True)
                if label is None:
                    label = np.arange(column_i, column_i + feat.shape[1])
                feat.columns = label
                feat_conc.append(feat)
                column_i = column_i + feat.shape[1]

            # result is numpy 1d array
            elif is_numpy_like(feat) and len(feat.shape) == 1:
                if label is None:
                    label = column_i
                f = pandas.Series(feat, name=label, copy=False)

                feat_conc.append(f)
                column_i = column_i + 1

            # result is numpy 2d array
            elif is_numpy_like(feat) and len(feat.shape) == 2:
                if label is None:
                    label = np.arange(column_i, column_i + feat.shape[1])
                feat_df = pandas.DataFrame(feat, columns=label, copy=False)
                if label is None:
                    feat_df.columns = [None for _ in range(feat_df.shape[1])]
                feat_conc.append(feat_df)
                column_i = column_i + feat.shape[1]

            # other results are not (yet) supported
            else:
                raise ValueError("expected numpy.ndarray or "
                                 "pandas object to be returned, "
                                 "got '{}'".format(feat.__class__.__name__))

        result = pandas.concat(feat_conc, axis=1, copy=False)
        if index is not None:
            result.set_index(index, inplace=True)

        return result
849254
function union(list1, list2, duplicate=false) {
    if ( arguments.length < 2 ) {
      // Manually currying
      let args1 = arguments;

      return (...args2) => union(...args1, ...args2);
    } else if (arguments.length === 2 && (! Array.isArray(list2))) {
      // curring union(_, list, duplicate) cases
      // Manually currying
      let args = arguments;
      return (list) => union(list, ...args);
    }

    if(duplicate) {
      return differenceWithDup([],list1.concat(list2));
    }
    return difference([],list1.concat(list2));
  }
252720
def union(self, other):
        
        if isinstance(other, self.__class__):
            return self.client.sunion([self.name, other.name])
        else:
            return self._as_set().union(other)
525012
def get_inputs_helper(step, ignore, target):
    
    outputs = set()
    if not ignore and step.target == target:
        outputs.add(step)

    if ignore or not step.target:
        for i in step.inputs:
            outputs.update(get_inputs_helper(i, ignore=False, target=target))

    return outputs
1006611
def sorted_product_set(array_a, array_b):
  """"""
  return np.sort(
      np.concatenate(
          [array_a[i] * array_b for i in xrange(len(array_a))], axis=0)
  )[::-1]
1032926
def union(self, other, ignore_conflicts=False):
        """"""
        result = self.copy()
        result.union_update(other, ignore_conflicts)
        return result
1188246
def uniontypes(type_: Type[Any]) -> Set[Type[Any]]:
    '''
    
    '''
    if not is_union(type_):
        raise ValueError('Not a Union: ' + str(type_))

    if hasattr(type_, '__args__'):
        return set(type_.__args__)
    elif hasattr(type_, '__union_params__'):
        return set(type_.__union_params__)
    raise AttributeError('The typing API for this Python version is unknown')
1374704
def union(self):
        
        usegs = reduce(operator.or_, self.values())
        usegs.name = ' | '.join(self.keys())
        return usegs
12972
def perp_product(self, other):
        

        return self.x * other.y - self.y * other.x
982685
function mergeArrays(source, target) {
  for (let i = 0; i < source.length; i++) {
    // If the item is not yet in the target array, add it
    if (target.indexOf(source[i]) === -1) {
      target.push(source[i])
    }
  }

  return target
}
746171
def getProductUIDs(self):
        
        uids = []
        for orderitem in self.objectValues('XupplyOrderItem'):
            product = orderitem.getProduct()
            if product is not None:
                uids.append(orderitem.getProduct().UID())
        return uids
390359
def union(*sets, **kwargs):
    
    sets = _set_preprocess(sets, **kwargs)
    return as_index( _set_concatenate(sets), axis=0, base=True).unique
451715
def _fit_invhashing_union(vec_union, docs):
    # type: (FeatureUnion, Any) -> FeatureUnion
    
    return FeatureUnion(
        [(name, invert_hashing_and_fit(v, docs))
         for name, v in vec_union.transformer_list],
        transformer_weights=vec_union.transformer_weights,
        n_jobs=vec_union.n_jobs)
152036
def union(left, right, distinct=False):
    
    left, right = _make_different_sources(left, right)
    return UnionCollectionExpr(_lhs=left, _rhs=right, _distinct=distinct)
1370400
def union(self, *args):
        """"""
        if self._readonly:
            raise AttributeError

        if len(args) == 0:
            return None
        if len(args) == 1:
            return self[args[0]]
        for a, b in zip(args[:-1], args[1:]):
            result = self._union_pair(a, b)
        return result
1221772
def feature_union(names, steps, weights):
    """"""
    steps, times = zip(*map(_maybe_timed, steps))
    fit_time = sum(times)
    if any(s is FIT_FAILURE for s in steps):
        fit_est = FIT_FAILURE
    else:
        fit_est = FeatureUnion(list(zip(names, steps)), transformer_weights=weights)
    return fit_est, fit_time