Test if the object is a subdomain of the other.

        :param other: the object to which we compare this instance
        :returns: True if this instance is a subdomain of the other
324308
def is_subdomain(self, other):
        
        compared = other.value if hasattr(other, 'value') else other
        try:
            return self.value.is_subdomain(compared)
        except AttributeError:
            return False
13260
def is_downstream_of(self, other):
        
        if self.chrom != other.chrom: return None
        if getattr(other, "strand", None) == "-":
            # other feature is on - strand, so this must have higher start
            return self.end <= other.start
        return self.start >= other.end
460731
def issubset(self, other):
        """"""
        self._binary_sanity_check(other)
        return set.issubset(self, other)
1216806
def contains(self, other):
        
        return (self.left <= other.left and
                self.right >= other.right and
                self.top >= other.top and
                self.bottom <= other.bottom)
244981
public boolean contains(final InternetDomainName domain) {
        ImmutableList<String> otherDomainParts = domain.parts();

        if (parts.size() > otherDomainParts.size()) {
            return false;
        }

        otherDomainParts = otherDomainParts.reverse()
                .subList(0, parts.size());

        return parts.reverse()
                .equals(otherDomainParts);
    }
780482
def is_subdomain_record(rec):
    
    txt_entry = rec['txt']
    if not isinstance(txt_entry, list):
        return False

    has_parts_entry = False
    has_pk_entry = False
    has_seqn_entry = False
    for entry in txt_entry:
        if entry.startswith(SUBDOMAIN_ZF_PARTS + "="):
            has_parts_entry = True
        if entry.startswith(SUBDOMAIN_PUBKEY + "="):
            has_pk_entry = True
        if entry.startswith(SUBDOMAIN_N + "="):
            has_seqn_entry = True

    return (has_parts_entry and has_pk_entry and has_seqn_entry)
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
755633
def is_sub_plate(self, other):
        
        if all(v in set(other.values) for v in self.values):
            return True
        if all(any(all(spv in m for spv in v) for m in map(set, other.values)) for v in self.values):
            return True
        if other in self.ancestor_plates:  # added by MK, but still not sure whether all cases are covered
            return True
        return False
874642
def is_not_equal_to(self, other):
        
        self._run(unittest_case.assertNotEqual, (self._subject, other))
        return ChainInspector(self._subject)
64971
def IsSubset(self, other):
        """"""
        for val, freq in self.Items():
            if freq > other.Freq(val):
                return False
        return True
464727
def check_initial_subdomain(cls, subdomain_rec):
        
        if subdomain_rec.n != 0:
            return False
       
        if subdomain_rec.independent:
            return False

        return True
209469
public boolean equalsExact(Ort other) {
        return Objects.equals(this.plz, other.plz) && this.name.equals(other.name);
    }
68663
def is_entailed_by(self, other):
        
        if not set(self.include.keys()).issubset(set(other.include.keys())):
            return False
        if not self.exclude.isuperset(other.exclude):
            return False
        if not self.prototype.is_entailed_by(other.prototype):
            return False
        return True
549340
def is_domain_equal(self, other):
        
        domain = self.get_domain()
        other_domain = other.get_domain()
        # if they share the same instance of memory for the domain
        if domain == other_domain:
            return True
        else:
            return False
927364
def merge(self, other):
        
        other = self.coerce(other)
        if list_diff(self.domain, other.domain) != []:
            raise Exception("Incomparable orderings. Different domains")
        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.low, self.high = other.low, other.high
        elif self.is_contradictory(other):
            raise Contradiction("Cannot merge %s and %s" % (self, other))
        else:
            # information in both
            to_i = self.to_i
            self.low = self.domain[max(map(to_i, [self.low, other.low]))]
            self.high =self.domain[min(map(to_i, [self.high, other.high]))]
        return self
1135328
function (other) {
            var self = this;
            // port and hostname has to be same
            return equalsIgnoreCase(self.hostname, other['hostname']) &&
                equalsIgnoreCase(self.scheme, other['scheme']) &&
                equalsIgnoreCase(self.port, other['port']);
        }
1298238
def is_equal(self, other):
        
        if not (hasattr(other, 'get_domain') or hasattr(other, 'upper') or hasattr(other, 'lower')):
            other = self.coerce(other)
        if self.is_domain_equal(other)  \
            and len(self.upper.symmetric_difference(other.upper)) == 0 \
            and len(self.lower.symmetric_difference(other.lower)) == 0:
            return True
        return False