return a boolean indicating whether this feature is downstream of
        `other` taking the strand of other into account
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
1208003
private boolean isWithinSubtree(X500Name other) {
        if (this == other) {
            return true;
        }
        if (other == null) {
            return false;
        }
        if (other.names.length == 0) {
            return true;
        }
        if (this.names.length == 0) {
            return false;
        }
        if (names.length < other.names.length) {
            return false;
        }
        for (int i = 0; i < other.names.length; i++) {
            if (!names[i].equals(other.names[i])) {
                return false;
            }
        }
        return true;
    }
460731
def issubset(self, other):
        """"""
        self._binary_sanity_check(other)
        return set.issubset(self, other)
1118876
def downstream(self, f, n=1):
        
        if f.strand == -1:
            return self.left(f, n)
        return self.right(f, n)
862351
def DotProd(self, other):
    
    return self.x * other.x + self.y * other.y + self.z * other.z
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)
1061389
def upstream(self, distance):
        
        if getattr(self, "strand", None) == "+":
            e = self.start
            s = e - distance
        else:
            s = self.end
            e = s + distance
        return self._xstream(s, e)
990233
def is_adjacent(self, other: ops.Qid) -> bool:
        """"""
        return (isinstance(other, GridQubit) and
                abs(self.row - other.row) + abs(self.col - other.col) == 1)
711441
def intersection(self, other):
        
        if isinstance(other, self.__class__):
            return self.client.sinter([self.name, other.name])
        else:
            return self._as_set().intersection(other)
1346117
def value_left(self, other):
    
    return other.value if isinstance(other, self.__class__) else other
1081538
def on_same_strand(self):
        ''''''
        return (self.ref_start < self.ref_end) == (self.qry_start < self.qry_end)
1226627
def is_descendant_of(self, other, include_self=False):
        """"""
        if other.pk == self.pk:
            return include_self

        return self._closure_model.objects.filter(
            parent=other,
            child=self
        ).exclude(pk=self.pk).exists()
117530
def features(self, other_start, other_end):
        
        # completely encases gene.
        if other_start <= self.start and other_end >= self.end:
            return ['gene' if self.cdsStart != self.cdsEnd else 'nc_gene']
        other = Interval(other_start, other_end)
        ovls = []
        tx = 'txEnd' if self.strand == "-" else 'txStart'
        if hasattr(self, tx) and other_start <= getattr(self, tx) <= other_end \
            and self.cdsStart != self.cdsEnd:
                ovls = ["TSS"]
        for ftype in ('introns', 'exons', 'utr5', 'utr3', 'cdss'):
            feats = getattr(self, ftype)
            if not isinstance(feats, list): feats = [feats]
            if any(Interval(f[0], f[1]).overlaps(other) for f in feats):
                ovls.append(ftype[:-1] if ftype[-1] == 's' else ftype)
        if 'cds' in ovls:
            ovls = [ft for ft in ovls if ft != 'exon']
        if self.cdsStart == self.cdsEnd:
            ovls = ['nc_' + ft for ft in ovls]
        return ovls
86733
def -(other)
      other = other.to_key_path
      raise KeyError unless prefix?(other)

      super(other.length)
    end
166463
def is_entailed_by(self, other):
        
        other = ListCell.coerce(other)
        if other.size() < self.size():
            # other is bigger, can't be entailed
            return False
        if self.value is None:
            # list is empty
            return True

        # see if any values in the shorter list are contradictory or 
        # unequal
        for i, oval in enumerate(other.value):
            if i == len(self.value):
                break

            if hasattr(self.value[i], 'is_entailed_by') and \
                   not self.value[i].is_entailed_by(oval):
                # compare cells
                return False 
            elif self.value[i] != oval:
                return False 
        return True
465976
def is_ancestor_of(self, other, include_self=False):
        """"""
        return other.is_descendant_of(self, include_self=include_self)
335286
function(bb, other)
{
    return (bb.l <= other.l && bb.r >= other.r && bb.b <= other.b && bb.t >= other.t);
}