increment the value for key by value: float

        :param name: str     the name of the redis key
        :param amount: int
        :return: Future()
332007
def incrbyfloat(self, name, amount=1.0):
        
        with self.pipe as pipe:
            return pipe.incrbyfloat(self.redis_key(name), amount=amount)
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)
822425
def increment(self, key, amount=1):
        
        payload = {
            key: {
                '__op': 'Increment',
                'amount': amount
                }
            }
        self.__class__.PUT(self._absolute_url, **payload)
        self.__dict__[key] += amount
465989
def lrange(self, name, start, stop):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.lrange(self.redis_key(name), start, stop)

            def cb():
                f.set([self.valueparse.decode(v) for v in res.result])

            pipe.on_execute(cb)
            return f
610941
def increment(self, key: Any, by: int = 1) -> None:
        
        if key is not None:
            self[key] = self.get(key, 0) + by
1331351
def setbit(self, name, offset, value):
        
        with self.pipe as pipe:
            return pipe.setbit(self.redis_key(name), offset, value)
1077982
def increment(self, member, amount=1):
        """"""
        return self.client.zincrby(self.name, member, amount)
719267
def add(self, value):
        """"""
        added = self.redis.sadd(
            self.key,
            value
        )

        if self.redis.scard(self.key) < 2:
            self.redis.expire(self.key, self.expire)

        return added
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
997464
def hget(self, name, key):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.hget(self.redis_key(name),
                            self.memberparse.encode(key))

            def cb():
                f.set(self._value_decode(key, res.result))

            pipe.on_execute(cb)
            return f
168905
def lpop(self, name):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.lpop(self.redis_key(name))

            def cb():
                f.set(self.valueparse.decode(res.result))

            pipe.on_execute(cb)
            return f
89090
def set(self, key, value):
        """"""
        key = "{0}{1}".format(self.prefix, key)

        value = json.dumps(value, cls=NumpyEncoder)
        self.redis.set(key, value)
953057
def update_counter(self, bucket, key, value, w=None, dw=None, pw=None,
                       returnvalue=False):
        
        raise NotImplementedError
1342835
public void incrementFeatureByIndex(double amount, int... key) {
    if (isDense) {
      statistics.incrementEntry(amount, key);
    } else {
      Tensor increment = SparseTensor.singleElement(getTensorDimensions(), getTensorSizes(),
          key, amount);
      statisticsTensor = statisticsTensor.elementwiseAddition(increment);
    }
  }
863936
async def hsetnx(self, name, key, value):
        
        return await self.execute_command('HSETNX', name, key, value)
406158
def increment(self, name, value):
        
        counter = self.get(name, CounterType.Increment)
        counter.count = counter.count + value if counter.count != None else value
        self._update()
86226
def lset(self, name, index, value):
        
        with self.pipe as pipe:
            value = self.valueparse.encode(value)
            return pipe.lset(self.redis_key(name), index, value)