Advance the model by one time step.
3282
def update(self, τ: float = 1.0, update_indicators=True, dampen=False):
        

        for n in self.nodes(data=True):
            n[1]["next_state"] = n[1]["update_function"](n)

        for n in self.nodes(data=True):
            n[1]["rv"].dataset = n[1]["next_state"]

        for n in self.nodes(data=True):
            for i in range(self.res):
                self.s0[i][n[0]] = n[1]["rv"].dataset[i]
                if dampen:
                    self.s0[i][f"∂({n[0]})/∂t"] = self.s0_original[
                        f"∂({n[0]})/∂t"
                    ] * exp(-τ * self.t)
            if update_indicators:
                for indicator in n[1]["indicators"].values():
                    indicator.samples = np.random.normal(
                        indicator.mean * np.array(n[1]["rv"].dataset),
                        scale=0.01,
                    )

        self.t += self.Δt
492764
def move_forward(num_steps):
    
    assert int(num_steps) == num_steps, "move_forward() only accepts integers, but you gave it " + str(num_steps)

    _make_cnc_request("move.forward./" + str(num_steps))

    state['turtle'].forward(num_steps)
1363711
def step(self, exploration):
        
        if len(self._runners) > 1:
            self._populate_job_queue.put(exploration)
        else:
            self._runners[0].step(exploration)
495021
def up(self, n=1, interval=0, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.tap_key(self.k.up_key, n, interval)
        self.delay(post_dl)
362729
public function advance($step = 1, $redraw = false)
    {
        parent::advance($step, $redraw);

        $this->current += $step;

        $percent = 0;
        if ($this->max > 0) {
            $percent = (float) $this->current / $this->max;
        }
        $this->output->write(sprintf('%d%%', floor($percent * 100)));
    }
175374
def _pre_train(self,
                   stop_param_updates,
                   num_epochs,
                   updates_epoch):
        """"""
        # Calculate the total number of updates given early stopping.
        updates = {k: stop_param_updates.get(k, num_epochs) * updates_epoch
                   for k, v in self.params.items()}

        # Calculate the value of a single step given the number of allowed
        # updates.
        single_steps = {k: np.exp(-((1.0 - (1.0 / v)))
                        * self.params[k]['factor'])
                        for k, v in updates.items()}

        # Calculate the factor given the true factor and the value of a
        # single step.
        constants = {k: np.exp(-self.params[k]['factor']) / v
                     for k, v in single_steps.items()}

        return constants
308453
public function advance($step = 1.0)
    {
        if ($this->position < $this->max) {
            $this->position = min($this->position + $step, $this->max);
        }

        return $this;
    }
129449
def run_step(self):
        """"""
        rewriter = StreamRewriter(self.context.iter_formatted_strings)
        super().run_step(rewriter)
175883
def move_up(self):
        """"""
        self.at(ardrone.at.pcmd, True, 0, 0, self.speed, 0)
99009
protected function performStep()
    {
        $attributes = [];

        // Get the columns from the model's table
        $tableFields = $this->databaseAnalyzer()->getColumns(
            $this->model()->getTable(),
            $this->model()->getConnectionName()
        );

        foreach ($tableFields as $field) {

            $length = $field['length'];

            $cast = $this->getAttributeCastForColumnType($field['type'], $length);

            $attributes[ $field['name'] ] = new ModelAttributeData([
                'name'     => $field['name'],
                'cast'     => $cast,
                'type'     => $field['type'],
                'nullable' => $field['nullable'],
                'unsigned' => $field['unsigned'],
                'length'   => $length,
                'values'   => $field['values'],
            ]);
        }


        foreach ($this->model()->getFillable() as $attribute) {

            if ( ! isset($attributes[ $attribute ])) {
                continue;
            }

            $attributes[ $attribute ]['fillable'] = true;
        }

        foreach ($this->model()->getCasts() as $attribute => $cast) {

            if ( ! isset($attributes[ $attribute ])) {
                continue;
            }

            $attributes[ $attribute ]['cast'] = $this->normalizeCastString($cast);
        }


        $this->info->attributes = $attributes;
    }
741235
def step(self) -> None:
        
        event = heappop(self._events)
        self._ts_now = event.timestamp or self._ts_now
        event.execute(self)
782115
private void advance() {
        next = null;
        while (next == null) {
            // If 
            if (ext != null) {
                next = ext.next();
                if (next != null)
                    return;
            }
            if (!vertexIter.hasNext())
                return;

            // Otherwise the extension is null or there are no more remaining
            // subgraphs in it, so create a new 
            int nextVertex = vertexIter.nextInt();
            veryVerbose(LOGGER, "Loading next round of subgraphs starting " +
                        "from vertex %d", nextVertex);
            ext = new Extension(nextVertex);
        }
    }
1023786
def apply(self, model):
        """"""
        model.medium = {row.exchange: row.uptake
                        for row in self.data.itertuples(index=False)}
372309
def advancing(self):
        
        if self._forward:
            raise ValueError("Already advancing")
        self._forward = True
        yield
        self._forward = False
1084797
def move_forward(self, seconds=None):
        """"""
        self._move(speed=SPEED_MAX, steering=0, seconds=seconds)
199955
private void advance() {
        while (nextSubgraphs.isEmpty() && vertexIter.hasNext()) {
            Integer nextVertex = vertexIter.next();
            // Determine the set of vertices that are greater than this vertex
            Set<Integer> extension = new HashSet<Integer>();
            for (Integer v : g.getNeighbors(nextVertex))
                if (v > nextVertex)
                    extension.add(v);
            Set<Integer> subgraph = new HashSet<Integer>();
            subgraph.add(nextVertex);
            extendSubgraph(subgraph, extension, nextVertex);
        }
    }
234127
def goForward(self):
        
        if self._slideshow.currentIndex() == self._slideshow.count() - 1:
            self.finished.emit()
        else:
            self._slideshow.slideInNext()