Returns a new :class:`FrameSet` that contains all the elements in either
        `self` or `other`, but not both.

        Args:
            other (:class:`FrameSet`):

        Returns:
            :class:`FrameSet`:
770904
def symmetric_difference(self, other):
        
        other = self._cast_to_frameset(other)
        if other is NotImplemented:
            return NotImplemented
        from_frozenset = self.items.symmetric_difference(other.items)
        return self.from_iterable(from_frozenset, sort=True)
932388
def merge(self, other):
        
        if not isinstance(other, one):
            other = one(other)
        new = concatenate((self.coordinates, other.coordinates))
        unique = set([tuple(x) for x in new.tolist()])
        final = asarray([list(x) for x in unique])
        return one(final)
104126
def /(other)
      if other.is_a?(InternalComplex) or other.is_a?(Complex)
        self * other.conj / other.abs2
      elsif InternalComplex.generic? other
        InternalComplex.new @real / other, @imag / other
      else
        x, y = other.coerce self
        x / y
      end
    end
531681
def symmetric_difference_update(self, other):
        # type: (Iterable[Any]) -> _BaseSet
        
        intersect = self.intersection(other)
        self.remove(*intersect)
        for elem in set(other).difference(intersect):
            self.add(elem)
        return self
128097
def contains(self, other):
        """"""
        return self._start <= other.start and self._end >= other.end
348217
def symmetric_difference(self, other):
        
        if not isinstance(other, set): other = set(other)
        me = set(self)
        ivs = me.difference(other).union(other.difference(me))
        return IntervalTree(ivs)
1058800
def coerce(other)
      if other.is_a? RGB
        return other, self
      else
        return RGB.new( other, other, other ), self
      end
    end
461300
def entails(self, other):
        
        other = BoolCell.coerce(other)
        return other.is_entailed_by(self)
1116573
def difference(self,other):
        
        res = IntervalSet.everything()
        for j in other.ints:
            tmp = []
            for i in self.ints:
                tmp.extend(i._difference(j))
            res = res.intersection(IntervalSet(tmp))
        return res
770883
def is_entailed_by(self, other):
        
        other = BoolCell.coerce(other)
        if self.value == U or other.value == self.value:
            return True
        return False
1118652
def zip(self, other):
        
        return self.__class__(p1 % p2 for p1, p2 in zip(self, other))
180382
def framewise(self):
        
        current_frames = [el for f in self.traverse(lambda x: x.current_frame)
                          for el in (f.traverse(lambda x: x, [Element])
                                     if f else [])]
        current_frames = util.unique_iterator(current_frames)
        return any(self.lookup_options(frame, 'norm').options.get('framewise')
                   for frame in current_frames)
467439
def frames= other
      raise TypeError unless other.kind_of?(Frames)
      @frames.clear
      @frames.concat other
    end
773688
def merge(self, other):
        
        other = StringCell.coerce(other)
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif other.is_entailed_by(self):
            return self
        elif self.is_entailed_by(other):
            self.value = other.value
        elif self.is_contradictory(other):
            raise Contradiction("Cannot merge string '%s' with '%s'" % \
                    (self, other))
        else:
            self._perform_merge(other)
        return self
26728
def _ior(self, other):
		
		# TODO do we have to create a bag from the other first?
		if not isinstance(other, _basebag):
			other = self._from_iterable(other)
		for elem, other_count in other.counts():
			old_count = self.count(elem)
			new_count = max(other_count, old_count)
			self._set_count(elem, new_count)
		return self
318486
def union(self, other):
        
        union = Rect()
        lib.SDL_UnionRect(self._ptr, other._ptr, union._ptr)
        return union
982381
def merge(self, other):
        
        if not isinstance(other, NameVariants):
            raise TypeError("NameVariants isinstance can be merge with"
                            "other isinstance of the same class")
        for key in self.variants:
            self.variants[key] = self.variants[key] or other.variants[key]

        return self