Increment the integer value of a hash field by the given number.
967000
def hincrby(self, key, field, increment=1):
        """"""
        return self.execute(b'HINCRBY', key, field, increment)
638752
def _increment(self, n=1):
        """"""
        if self._cur_position >= self.num_tokens-1:
            self._cur_positon = self.num_tokens - 1
            self._finished = True
        else:
            self._cur_position += n
53935
def _set_increment(self, statement):
        """"""
        assert isinstance(statement, CodeStatement)
        self.increment = statement
        statement.scope = self.body
240780
public function increment($fieldName, $value = 1)
    {
        parent::set($fieldName, (int) $this->get($fieldName) + $value);

        if ($this->getId()) {
            $this->operator->increment($fieldName, $value);
        }


        return $this;
    }
471672
def increment(key, amount = 1, options = {})
      @cache.delete(key, options)
      @adapter.increment(key, amount, options)
    end
854726
private boolean increment(int index)
    {
        if (index == -1)
        {
            return false;
        }
        int value = current.get(index);
        if (value < max.get(index))
        {
            current.set(index, value+1);
            updateMinMax(index+1);
            return true;
        }
        boolean hasNext = increment(index-1);
        if (hasNext)
        {
            current.set(index, min.get(index));            
        }
        return hasNext;
    }
848353
public void update(int number) {
        byte[] numberInBytes = new byte[ByteUtils.SIZE_OF_INT];
        ByteUtils.writeInt(numberInBytes, number, 0);
        update(numberInBytes);
    }
756319
public int incrementCount (K key, int amount)
    {
        int[] val = get(key);
        if (val == null) {
            put(key, val = new int[1]);
        }
        val[0] += amount;
        return val[0];

        /* Alternate implementation, less hashing on the first increment but more garbage created
         * every other time.  (this whole method would be more optimal if this class were
         * rewritten)
         *
        int[] newVal = new int[] { amount };
        int[] oldVal = put(key, newVal);
        if (oldVal != null) {
            newVal[0] += oldVal[0];
            return oldVal[0];
        }
        return 0;
        */
    }
610941
def increment(self, key: Any, by: int = 1) -> None:
        
        if key is not None:
            self[key] = self.get(key, 0) + by
944454
public function Increment()
    {
        if($this->version == null) {
            $this->_getVersion();
        }
        $this->version += .1;
        $this->_StoreVersion();
    }
920197
def incrbyfloat(self, key, increment):
        
        if not isinstance(increment, float):
            raise TypeError("increment must be of type int")
        fut = self.execute(b'INCRBYFLOAT', key, increment)
        return wait_convert(fut, float)
368394
static int hash(int hashIn, int n) {
		int hash = ((hashIn << 5) + hashIn) + (n & 0xFF); /* hash * 33 + c */
		hash = ((hash << 5) + hash) + ((n >> 8) & 0xFF);
		hash = ((hash << 5) + hash) + ((n >> 16) & 0xFF);
		hash = ((hash << 5) + hash) + ((n >> 24) & 0xFF);
		hash &= 0x7FFFFFFF;
		return hash;
	}
1252206
def add(self, num):
        
        self.index = max(0, min(len(self.allowed)-1, self.index+num))
        self.set(self.allowed[self.index])
637318
static void incrementKey(byte[] key)
  {
    for (int i = key.length - 1; i >= 0; i--) {
      int v = key[i] & 0xff;
      
      if (v < 0xff) {
        key[i] = (byte) (v + 1);
        return;
      }
      
      key[i] = 0;
    }
  }
579823
def increment(self, size: int):
        '''
        '''
        assert size >= 0, size

        self.files += 1
        self.size += size
        self.bandwidth_meter.feed(size)
882673
def _increment(arr, indices):
    """"""
    arr = _as_array(arr)
    indices = _as_array(indices)
    bbins = np.bincount(indices)
    arr[:len(bbins)] += bbins
    return arr
515537
public function increment(string $field, int $num) : int
        {
                return intval($this->_redis->hincrby($this->_key, $field, $num));
        }