Return copy and score after being applied other system and soft features.

        Args:

        - other(system, optional): system to apply just before soft features.

        Return(tuple): tuple of the resulting system and its score.
483986
def concrete(self, other=None):
        

        new_system = self.clone()
        if other:
            new_system.applyFeatures(other, missing="other")
        soft_features = self.getValue(SoftFeatures.SOFT, [])
        score = 0
        for f in sorted(soft_features, key=lambda f: f.soft, reverse=True):
            try:
                new_system.applyFeatures(f, missing="other")
                score += f.soft
            except:
                pass
        new_system.delValue(SoftFeatures.SOFT)
        return new_system, score
461178
def matches(self, other):
        
        if not isinstance(other, Failure):
            return False
        if self.exc_info is None or other.exc_info is None:
            return self._matches(other)
        else:
            return self == other
328877
def absorb(self, other, ignore_none=True):
        
        if not isinstance(other, self.__class__):
            raise TypeError("`other` has to be a instance of %s!" %
                            self.__class__)

        if ignore_none:
            for attr, value in other.items():
                if value is not None:
                    setattr(self, attr, deepcopy(value))
        else:
            for attr, value in other.items():
                setattr(self, attr, deepcopy(value))

        return self
24348
def copy(self):
        '''

        '''
        # Significant performance improvements by skipping alphabet check
        features_copy = [feature.copy() for feature in self.features]
        copy = type(self)(self.top.seq, circular=self.circular,
                          features=features_copy, name=self.name,
                          bottom=self.bottom.seq, run_checks=False)
        return copy
1337805
def copy(self):
        """"""
        other = MeanStdFilter(self.shape)
        other.sync(self)
        return other
290264
def copy(self):
        
        return self.filter(np.ones(self._num_fix).astype(bool))
266236
def merge(self, other):
        
        for this, other in zip(self.stats, other.stats):
            this.merge(other)
400089
def sge(self, other):
        
        self._check_match(other)
        return self.to_sint() >= other.to_sint()
1125874
def copy(self, overrides=None, locked=False):
        """"""
        other = copy.copy(self)

        if overrides is not None:
            other.overrides = overrides

        other.locked = locked

        other._uncache()
        return other
591209
def difference(self, other):
        

        obj = self._clone()
        obj.difference_update(other)
        return obj
1239154
def difference(self, *other):
        
        from_frozenset = self.items.difference(*map(set, other))
        return self.from_iterable(from_frozenset, sort=True)
862410
def _set_other(self):
        """"""
        # manage not setting if not mandatory for numpy
        if self.dst.style['in'] == 'numpydoc':
            if self.docs['in']['raw'] is not None:
                self.docs['out']['post'] = self.dst.numpydoc.get_raw_not_managed(self.docs['in']['raw'])
            elif 'post' not in self.docs['out'] or self.docs['out']['post'] is None:
                self.docs['out']['post'] = ''
234739
def copy(self):
        # type: () -> Requirement
        
        return Requirement(
            self.specification,
            self.aggregate,
            self.optional,
            self.__original_filter,
            self.immediate_rebind,
        )
1373510
public void copyFrom(Frame<ValueType> other) {
        lastUpdateTimestamp = other.lastUpdateTimestamp;
        slotList = new ArrayList<>(other.slotList);
        isTop = other.isTop;
        isBottom = other.isBottom;
    }
479521
def difference(self, other):
        
        diff = (tuple(set(self.plates) - set(other.plates)), tuple(set(other.plates) - set(self.plates)))
        counts = map(len, diff)
        # is_sub_plate = counts == [1, 1] and diff[1][0].is_sub_plate(diff[0][0])
        is_sub_plate = counts == [1, 1] and diff[0][0].is_sub_plate(diff[1][0])  # MK fixed
        if len(other.plates) == 1 and counts == [1, 0] and diff[0][0].parent == other.plates[0].parent:
            is_sub_plate = True
        return diff, counts, is_sub_plate
766696
def equals(self, other):
        
        if self.is_dtype_equal(other):
            if self.categories.equals(other.categories):
                # fastpath to avoid re-coding
                other_codes = other._codes
            else:
                other_codes = _recode_for_categories(other.codes,
                                                     other.categories,
                                                     self.categories)
            return np.array_equal(self._codes, other_codes)
        return False
315468
def split_desired_other(fhs, req_geo, rem_geo):
    """"""
    desired = []
    other = []
    for fh in fhs:
        if req_geo in fh.datasets:
            desired.append(fh)
        elif rem_geo in fh.datasets:
            other.append(fh)
    return desired, other