i means the ith round. Increase i by 1
436499
def increase_i(self):
        """"""
        self.i += 1
        if self.i > self.bracket_id:
            self.no_more_trial = True
528337
def set(i)
      check_range(i)
      w = self.word_index(i)
      result = @words[w] |= (1 << (i % BITS_PER_WORD))
      result
    end
669001
def _setuie(self, i):
        
        if i < 0:
            raise CreationError("Cannot use negative initialiser for unsigned "
                                "interleaved exponential-Golomb.")
        self._setbin_unsafe('1' if i == 0 else '0' + '0'.join(bin(i + 1)[3:]) + '1')
1062329
def strictly_increasing(values):
    """"""
    return all(x < y for x, y in zip(values, values[1:]))
1077982
def increment(self, member, amount=1):
        """"""
        return self.client.zincrby(self.name, member, amount)
1215951
def add(self,  i, val):
        
        assert i > 0
        while i < len(self.s):
            self.s[i] += val
            i += (i & -i)
511112
def _setse(self, i):
        """"""
        if i > 0:
            u = (i * 2) - 1
        else:
            u = -2 * i
        self._setue(u)
447221
private void upHeap(int idx) {
        Reference<E> e = entries.array[idx];

        int iter = idx;
        while (hasParent(iter)) {
            int pidx = parent(iter);
            Reference<E> p = entries.array[pidx];
            if (compare(e, p) < 0) {
                entries.array[pidx] = e;
                entries.array[iter] = p;
                p.index = iter;
                iter = parent(iter);
            } else {
                break;
            }
        }
        e.index = iter;
    }
869551
def increment_name(self, name, i):
        
        if i == 0:
            return name
        if '.' in name:
            split = name.split('.')
            split[-2] = split[-2] + str(i)
            return '.'.join(split)
        else:
            return name + str(i)
717846
public void extendBound(int i) {
        if (i < 0 || i >= dimension) {
            throw new IllegalArgumentException("Invalid bound index: " + i);
        }

        extendBound[i] = true;
        lowerBound[i] = precisionUnit[i] * (Math.floor(originalLowerBound[i] / precisionUnit[i]));
        upperBound[i] = precisionUnit[i] * (Math.ceil(originalUpperBound[i] / precisionUnit[i]));
    }
1262817
private static int incrementOrOne(@SuppressWarnings("unused") Object k, Integer i) {
        return i == null ? 1 : Math.addExact(i, 1);
    }
1149340
def increment(cls, v):
        """"""
        if not isinstance(v, ObjectNumber):
            v = ObjectNumber.parse(v)

        return v.rev(v.revision+1)
1201617
def increment(self, member, amount=1):
        """"""
        self._dict[member] += amount
        return self._dict[member]
689101
def round_if_near_integer(a, epsilon=1e-4):
    
    if abs(a - round(a)) <= epsilon:
        return round(a)
    else:
        return a
937718
def increment(self, amount=1):
        
        self.__lock.acquire()
        self.__count += amount
        v = self.value()
        self.__lock.release()
        return v
805196
def increment(self, key, value=1):
        
        raw = self._get_payload(key)

        integer = int(raw['data']) + value

        self.put(key, integer, int(raw['time']))

        return integer
354658
def frange(start, stop, step, precision):
    """"""
    value = start
    while round(value, precision) < stop:
        yield round(value, precision)
        value += step