If object is over the speed, reduce its speed.
762655
def act(environment)
    environment.objects.each do |object|
      object.vector.speed = Utility.constrain_value(object.vector.speed, @maximum)
    end
  end
732981
public static float reduce(float startValue, float endValue, float time) {
        if (startValue < endValue)
            throw new IllegalArgumentException("End size can't be larger than start size.");
        return endValue + (startValue - endValue) * (1 - time);
    }
810713
private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }
1061313
private void decreaseCache(I_CmsLruCacheObject theCacheObject) {

        // notify the object that it was now removed from the cache
        //theCacheObject.notify();
        theCacheObject.removeFromLruCache();

        // set the list pointers to null
        theCacheObject.setNextLruObject(null);
        theCacheObject.setPreviousLruObject(null);

        // update the cache stats.
        m_objectCosts -= theCacheObject.getLruCacheCosts();
        m_objectCount--;
    }
1088458
def move_left(self):
        """"""
        self.at(ardrone.at.pcmd, True, -self.speed, 0, 0, 0)
496282
def _reduce(self, op, name, axis=0, skipna=True, numeric_only=None,
                filter_type=None, **kwds):
        
        return op(self.get_values(), skipna=skipna, **kwds)
979604
def remove_property(self, prop):
        """"""
        self._properties.remove(prop)
        self._pairs.difference_update((o, prop) for o in self._objects)
1104383
public void stop()
    {
        if (!mIsRunning || (mAnimations.size() == 0))
        {
            return;
        }
        GVRAnimation anim = mAnimations.get(0);
        mIsRunning = false;
        anim.setOnFinish(null);
        for (int i = 0; i < mAnimations.size(); ++i)
        {
            anim = mAnimations.get(i);
            getGVRContext().getAnimationEngine().stop(anim);
        }
    }
124831
function (response) {
            // the overlap vector
            var overlap = response.overlapV;

            // FIXME: Respond proportionally to object mass

            // Move out of the other object shape
            this.ancestor.pos.sub(overlap);

            // adjust velocity
            if (overlap.x !== 0) {
                this.vel.x = ~~(0.5 + this.vel.x - overlap.x) || 0;
                if (this.bounce > 0) {
                    this.vel.x *= -this.bounce;
                }
            }
            if (overlap.y !== 0) {
                this.vel.y = ~~(0.5 + this.vel.y - overlap.y) || 0;
                if (this.bounce > 0) {
                    this.vel.y *= -this.bounce;
                }

                // cancel the falling an jumping flags if necessary
                var dir = Math.sign(this.gravity.y) || 1;
                this.falling = overlap.y >= dir;
                this.jumping = overlap.y <= -dir;
            }
        }
276704
def stop(cls):
        """"""
        if AnimatedDecorator._enabled:
            if cls.spinner.running:
                cls.spinner.running = False
                cls.animation.thread.join()

            if any(cls.animation.messages):
                cls.pop_message()

            sys.stdout = sys.__stdout__
22315
def change_speed(body, speed=1):
    """"""
    if speed == 1:
        return body

    length = int(len(body) * speed)
    rv = bytearray(length)

    step = 0
    for v in body:
        i = int(step)
        while i < int(step + speed) and i < length:
            rv[i] = v
            i += 1
        step += speed
    return rv
1010846
protected void actionGoingToWarehouse()
    {
        if (checker.canCarry())
        {
            for (final ExtractorListener listener : listeners)
            {
                listener.notifyStartDropOff(resourceType, lastProgress);
            }
            speed = dropOffPerSecond / rate.getAsInt();
            state = ExtractorState.DROPOFF;
        }
    }
203939
def move_backward(self):
        """"""
        self.at(ardrone.at.pcmd, True, 0, self.speed, 0, 0)
915372
function(decl) {
  if (
    decl.prop == 'position' &&
    (decl.value == 'absolute' || decl.value == 'fixed')
  ) {
    decl.parent.each(function(neighbor) {
      if (neighbor.prop == 'float' && neighbor.prop != 'none') {
        neighbor.remove()
      }
    })
  }
}
794549
function stop() {
  var time;
  if(!this.enabled) return false;
  time = this._record.isSlowerThan(this._slowerThan);
  if(this._record && time > -1) {
    this._records.unshift(this._record.toArray(id++, time));
    if(this._records.length >= this._maxLen) {
      this._records.pop();
    }
  }
}
951177
private boolean lessThan(int i, int j) {

        if (sortOnValues) {
            if (values[i] < values[j]) {
                return true;
            }
        } else {
            if (keys[i] < keys[j]) {
                return true;
            }
        }

        return false;
    }
454130
def down(self, point):
        
        self._pdown = np.array(point, dtype=np.float32)
        self._pose = self._n_pose
        self._target = self._n_target