return differences from this catalog and right catalog
 param [Cat] right
 @return [CatOnYaml]
2379
def -(right)
      result = CatOnYaml.new
      @entries.each do |e|
        result.add_entry(e) unless right.contains(e)
      end
      result
    end
382438
def symmetric_difference(self, that):
        
        diff = self._set.symmetric_difference(that)
        new_set = self.__class__(key=self._key, load=self._load, _set=diff)
        return new_set
695642
def getBottomRight(self):
        
        return (float(self.get_cx()) + float(self.get_r()), float(self.get_cy()) - float(self.get_r()))
975211
def right_sections(self):
        
        lines = self.text.split('\n')
        sections = 0
        for i in range(len(lines)):
            if lines[i].endswith('+'):
                sections += 1
        return sections - 1
408399
def right(self, num=None):
        
        if num == None:
            return FlatList([_get_list(self)[-1]])
        if num <= 0:
            return Null

        return FlatList(_get_list(self)[-num:])
861277
def symmetric_difference(self, other):
        
        return self.copy(super(NGram, self).symmetric_difference(other))
133097
def right_most(boxes):
        
        x_list = [(box.x, box) for box in boxes]
        x_list.sort()
        return x_list[-1][1]
305302
def getBottomRight(self):
        
        return (float(self.get_cx()) + float(self.get_rx()), float(self.get_cy()) - float(self.get_ry()))
1125757
def -( right )
      raise "operators only on registers, not #{right.class}" unless right.is_a? RegisterValue
      op = Risc.op("#{self.type} - #{right.type}", :- , self , right )
      builder.add_code(op) if builder
      op
    end
407347
final boolean casRight(Index<K,V> cmp, Index<K,V> val) {
            return U.compareAndSwapObject(this, RIGHT, cmp, val);
        }
175078
def right(*conditions, &effect)
      branch = Fear.case(Fear::Right, &RIGHT_EXTRACTOR).and_then(Fear.case(*conditions, &effect))
      or_else(branch)
    end
599025
def _get_rightMargin(self):
        
        bounds = self.bounds
        if bounds is None:
            return None
        xMin, yMin, xMax, yMax = bounds
        return self.width - xMax
909796
def getBottomRight(self):
        
        return Location(self.x+self.w, self.y+self.h)
866792
def insert_right(self, item):
        ''
        k = self._key(item)
        i = bisect_right(self._keys, k)
        self._keys.insert(i, k)
        self._items.insert(i, item)
725198
def symmetric_difference(self, that):
        
        diff = self._set.symmetric_difference(that)
        return self._fromset(diff, key=self._key)
1020429
def _dict_merge_right(dict_left, dict_right, merge_method):
    """"""
    new_dict = deepcopy(dict_left)
    for key, value in dict_right.items():
        if key not in new_dict:
            new_dict[key] = value
        else:
            recurse = (merge_method == 'take_right_deep' and
                       isinstance(dict_left[key], dict) and
                       isinstance(dict_right[key], dict))
            if recurse:
                new_dict[key] = dict_merge(dict_left[key],
                                           dict_right[key],
                                           merge_method='take_right_deep')
            else:
                new_dict[key] = value
    return new_dict
1295876
def compare(left, right):
    

    with open_zip(left) as l:
        with open_zip(right) as r:
            return compare_zips(l, r)