Remove elements from the ZSet by their rank (relative position).

        :param low: Lower bound.
        :param high: Upper bound.
517737
def remove_by_rank(self, low, high=None):
        
        if high is None:
            high = low
        return self.database.zremrangebyrank(self.key, low, high)
990464
public void dropElementsBelowThreshold(double threshold) {
        Iterator<T> iterator = keySet().iterator();
        while (iterator.hasNext()) {
            T element  = iterator.next();
            double val = map.get(element).get();
            if (val < threshold) {
                iterator.remove();
                dirty.set(true);
            }
        }

    }
1199982
def remove(self, value):
        
        self._set.remove(value)
        self._list.remove(value)
669944
def discard(self, val):
        
        _maxes = self._maxes

        if not _maxes:
            return

        key = self._key(val)
        pos = bisect_left(_maxes, key)

        if pos == len(_maxes):
            return

        _keys = self._keys
        _lists = self._lists
        idx = bisect_left(_keys[pos], key)

        len_keys = len(_keys)
        len_sublist = len(_keys[pos])

        while True:
            if _keys[pos][idx] != key:
                return
            if _lists[pos][idx] == val:
                self._delete(pos, idx)
                return
            idx += 1
            if idx == len_sublist:
                pos += 1
                if pos == len_keys:
                    return
                len_sublist = len(_keys[pos])
                idx = 0
491021
def pop(self, key, default=None):
        
        return self._dictionary.pop(key.lower(), default)
439041
def atmost(cls, lits, weights=None, bound=1, top_id=None,
            encoding=EncType.best):
        

        return cls.leq(lits, weights, bound, top_id, encoding)
408055
function (low, high) {
            return this._set(me.Math.clamp(this._x, low, high), me.Math.clamp(this._y, low, high));
        }
847880
public T between(Object low, Object hi) {
        return _withComparisonOperator(ComparisonOperator.BETWEEN)._withValues(low, hi);
    }
345031
def trim(self):
        
        # Only allow leaves to stay on list (highest-resolution) level
        return

        for l in self._levels[-2::-1]:
            for n in l:
                if n.is_leaf:
                    n.parent.remove_child(n.label)

        self._clear_all_leaves()
330683
def limit(lower, upper):
    
    offset = lower or 0
    lim = (upper - offset) if upper else -1
    smt = 'LIMIT %d OFFSET %d' % (lim, offset)
    return smt, ()
517053
private void removeObsoleteElements(List<String> names,
                                        Map<String, View> sharedElements,
                                        List<String> elementsToRemove) {
        if (elementsToRemove.size() > 0) {
            names.removeAll(elementsToRemove);
            for (String elementToRemove : elementsToRemove) {
                sharedElements.remove(elementToRemove);
            }
        }
    }
854371
function clampSelf(low, high) {
         return this._set(me.Math.clamp(this.x, low, high), me.Math.clamp(this.y, low, high));
       }
179138
def highs(self, *args):
		
		for t in ifilter(lambda e: e[2] == 'H', self.extrema(*args)):
			yield t
550853
def ylim(self, low, high, index=1):
        
        self.layout['yaxis' + str(index)]['range'] = [low, high]
        return self
975772
def _upper(val_list):
    
    res = []
    for ele in val_list:
        res.append(ele.upper())
    return res
988582
def rank_remove(self, rank, items, cutoff):

        

        def remove(tokens):
            return [t for t in tokens if t not in to_remove]

        if rank == "df":
            to_remove = set([t[0] for t in self.df_ranking if t[1] <= cutoff])
        elif rank == "tfidf":
            to_remove = set([t[0] for t in self.tfidf_ranking
                             if t[1] <= cutoff])
        else:
            raise ValueError("Rank must be either \'df\' or \'tfidf\'.")

        if items == 'tokens':
            self.tokens = list(map(remove, self.tokens))
        elif items == 'bigrams':
            self.bigrams = list(map(remove, self.bigrams))
        elif items == 'stems':
            self.stems = list(map(remove, self.stems))
        else:
            raise ValueError("Items must be either \'tokens\', \'bigrams\' or \'stems\'.")
37975
public static int bound (int low, int value, int high)
    {
        return Math.min(high, Math.max(low, value));
    }