Step the engine forward by one (or more) step.
4837
def step(self, count=1):
    """"""
    return self._client.send(step=sc_pb.RequestStep(count=count))
928598
def scroll_to_beginning_horizontally(self, steps=10, *args,**selectors):
        
        return self.device(**selectors).scroll.horiz.toBeginning(steps=steps)
560425
def step(self)->Number:
        ""
        self.n += 1
        return self.func(self.start, self.end, self.n/self.n_iter)
81855
def step(self, action, blocking=True):
    
    promise = self.call('step', action)
    if blocking:
      return promise()
    else:
      return promise
1304717
def backward_step(self):
        
        logger.debug("Executing backward step ...")
        self.run_to_states = []
        self.set_execution_mode(StateMachineExecutionStatus.BACKWARD)
990193
private void forward( MouseWheelEvent e )
  {
    e = new MouseWheelEvent( e.getComponent().getParent(), e.getID(), e.getWhen(), e.getModifiers(), e.getX(), e.getY(), e.getClickCount(), e.isPopupTrigger(), e.getScrollType(), e.getScrollAmount(), e.getWheelRotation() );
    Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent( e );
  }
299788
public void setStep(java.lang.Object _step) {
		getStateHelper().put(PropertyKeys.step, _step);
	}
1013592
def run_step(self):
        """"""
        formatted_replacements = self.context.get_formatted_iterable(
            self.replace_pairs)

        iter = StreamReplacePairsRewriterStep.iter_replace_strings(
            formatted_replacements)
        rewriter = StreamRewriter(iter)
        super().run_step(rewriter)
694627
def step(self, viewer=None):
        ""
        if not self.is_completed(self.state):
            for agent in self.agents:
                action = agent.program(self.percept(agent, self.state))
                next_state = self.do_action(self.state, action, agent)
                if viewer:
                    viewer.event(self.state, action, next_state, agent)
                self.state = next_state
                if self.is_completed(self.state):
                    return
215560
def run(self, steps=float('inf')):
        
        while len(self.program) > (self.register['PC'] - 1):
            steps -= 1
            if steps < 0:
                break
            self.program[self.register['PC'] - 1]()
            self.register['PC'] += 1
694232
def right(self, speed=1):
        
        self.left_motor.forward(speed)
        self.right_motor.backward(speed)
599935
protected function performStep()
    {
        // Detect whether the model is translated; if not, skip this step
        if ( ! $this->modelHasTrait($this->getTranslatableTraits())) {
            return;
        }

        // Model is translated using translatable
        $this->info->translated           = true;
        $this->info->translation_strategy = 'translatable';

        $this->addIncludesDefault('translations');

        $this->updateAttributesWithTranslated();
    }
462997
def forward(self, data_batch, is_train=None, carry_state=True):
        
        # propagate states from the previous iteration
        if carry_state:
            if isinstance(self._next_states, (int, float)):
                self._module.set_states(value=self._next_states)
            else:
                self._module.set_states(states=self._next_states)
        self._module.forward(data_batch, is_train=is_train)
        outputs = self._module.get_outputs(merge_multi_context=False)
        self._next_states = outputs[:-1]
1374866
private void onPushLevelProgress(int steps, Object source, boolean singlesteplevel)
    {
        if (this.currentStep.isLevelFinished()) {
            // If current step is done move to next one
            this.currentStep = this.currentStep.getParent().nextStep(null, source);
        }

        // Add level
        this.currentStep = this.currentStep.addLevel(steps, source, singlesteplevel);
    }
246256
def forward(self, is_train=False):
        """"""
        for texec in self.train_execs:
            texec.forward(is_train=is_train)
709567
def frange(start, end, step):
    """"""
    if start <= end:
        step = abs(step)
    else:
        step = -abs(step)

    while start < end:
        yield start
        start += step
367797
function Step() {

  var actions = Array.prototype.slice.call(arguments);
  var queue;

  function _Step() {}

  function next(method) {
    if (queue.length === 0) {
      _Step.finish();
      return;
    }
    var a = queue.pop();
    if (a.on) {
      a.on('finish.chain', function() {
        a.on('finish.chain', null);
        next(method);
      });
    }
    if (!a[method] || !a[method]()) {
      next(method);
      if(a.on) a.on('finish.chain', null);
    }
  }

  _Step.enter = function() {
    // call enter on each action
    queue = actions.slice().reverse();
    next('enter');
    return true;
  }

  _Step.exit = function() {
    // call exit on each action
    queue = actions.slice();
    next('exit');
    return true;
  }

  _Step.clear = function() {
    for(var i = 0, len = actions.length; i < len; ++i) {
      var a = actions[i];
      a.clear && a.clear();
    }
  }

  _Step = Action(_Step);
  return _Step;
}