Update the internal state of the Plot to represent the given
        key tuple (where integers represent frames). Returns this
        state.
556597
def update_frame(self, key, ranges=None):
        
        ranges = self.compute_ranges(self.layout, key, ranges)
        for coord in self.layout.keys(full_grid=True):
            subplot = self.subplots.get(wrap_tuple(coord), None)
            if subplot is not None:
                subplot.update_frame(key, ranges)
        title = self._get_title_div(key)
        if title:
            self.handles['title']
1060357
function update(t) {
    var p, idx;

    if (res.length < num) {
      res.push(t);
    } else {
      idx = ~~((cnt + 1) * random());
      if (idx < res.length && idx >= cap) {
        p = res[idx];
        if (map[tupleid(p)]) out.rem.push(p); // eviction
        res[idx] = t;
      }
    }
    ++cnt;
  }
720596
def _update_plot(self, key, plot, element=None):
        
        plot.update(**self._plot_properties(key, element))
        self._update_labels(key, plot, element)
        self._update_title(key, plot, element)
        self._update_grid(plot)
1100188
def _trigger_refresh(self, key):
        ""
        # Update if not top-level, batched or an ElementPlot
        if not self.top_level or isinstance(self, GenericElementPlot):
            self.update(key)
2289
def updateFft(self, *args, **kwargs):
        
        p = kwargs.pop('plot')
        if p == 'response': 
            self.responseFftPlot.updateData(*args, **kwargs)
        else:
            self.stimFftPlot.updateData(*args, **kwargs)
237698
def _update_plot(self, key, element, bars, lims, ranges):
        
        main = self.adjoined.main
        _, y1 = element.range(1)
        offset = self.offset * y1
        range_item, main_range, dim = get_sideplot_ranges(self, element, main, ranges)

        # Check if plot is colormapped
        plot_type = Store.registry['matplotlib'].get(type(range_item))
        if isinstance(plot_type, PlotSelector):
            plot_type = plot_type.get_plot_class(range_item)
        opts = self.lookup_options(range_item, 'plot')
        if plot_type and issubclass(plot_type, ColorbarPlot):
            cidx = opts.options.get('color_index', None)
            if cidx is None:
                opts = self.lookup_options(range_item, 'style')
                cidx = opts.kwargs.get('color', None)
                if cidx not in range_item:
                    cidx = None
            cdim = None if cidx is None else range_item.get_dimension(cidx)
        else:
            cdim = None

        # Get colormapping options
        if isinstance(range_item, (HeatMap, Raster)) or cdim:
            style = self.lookup_options(range_item, 'style')[self.cyclic_index]
            cmap = cm.get_cmap(style.get('cmap'))
            main_range = style.get('clims', main_range)
        else:
            cmap = None

        if offset and ('offset_line' not in self.handles):
            self.handles['offset_line'] = self.offset_linefn(offset,
                                                             linewidth=1.0,
                                                             color='k')
        elif offset:
            self._update_separator(offset)

        if cmap is not None:
            self._colorize_bars(cmap, bars, element, main_range, dim)
        return bars
643510
def initialize_plot(self, ranges=None, plot=None, plots=None, source=None):
        
        # Get element key and ranges for frame
        element = self.hmap.last
        key = self.keys[-1]
        self.current_frame = element
        self.current_key = key

        data, _, _ = self.get_data(element, ranges, {})
        div = BkDiv(text=data, width=self.width, height=self.height)
        self.handles['plot'] = div
        self._execute_hooks(element)
        self.drawn = True
        return div
550505
def _update_frames(self, written):
        """"""
        if self.seekable():
            curr = self.tell()
            self._info.frames = self.seek(0, SEEK_END)
            self.seek(curr, SEEK_SET)
        else:
            self._info.frames += written
1165860
def _trigger_refresh(self, key):
        ""
        if self.top_level:
            self.update(key)
        else:
            self.current_key = None
            self.current_frame = None
779403
def update_index(self, key, value):
        ""
        for k, v in value.items():
            if k in self.indexes:
                # A non-string index value switches it into a lazy one.
                if not isinstance(v, six.string_types):
                    self.index_defs[k]['type'] = 'lazy'
                if v not in self.indexes[k]:
                    self.indexes[k][v] = set([])
                self.indexes[k][v].add(key)
1221586
def key(self) -> Tuple[int, int]:
        
        return self._source.index, self._target.index
738080
def _update_subplot(self, subplot, spec):
        

        # See if the precise spec has already been assigned a cyclic
        # index otherwise generate a new one
        if spec in self.cyclic_index_lookup:
            cyclic_index = self.cyclic_index_lookup[spec]
        else:
            group_key = spec[:self.style_grouping]
            self.group_counter[group_key] += 1
            cyclic_index = self.group_counter[group_key]
            self.cyclic_index_lookup[spec] = cyclic_index

        subplot.cyclic_index = cyclic_index
        if subplot.overlay_dims:
            odim_key = util.wrap_tuple(spec[-1])
            new_dims = zip(subplot.overlay_dims, odim_key)
            subplot.overlay_dims = util.OrderedDict(new_dims)
951301
def update(self):
        
        if not self.showing:
            return
        d = self.declaration
        self.set_show(d.show)
258087
def update_flags(self):
        
        # view mode, filled vs wirefrom
        if self.view['wireframe']:
            gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE)
        else:
            gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL)

        # set fullscreen or windowed
        self.set_fullscreen(fullscreen=self.view['fullscreen'])

        # backface culling on or off
        if self.view['cull']:
            gl.glEnable(gl.GL_CULL_FACE)
        else:
            gl.glDisable(gl.GL_CULL_FACE)

        # case where we WANT an axis and NO vertexlist
        # is stored internally
        if self.view['axis'] and self._axis is None:
            from .. import creation
            # create an axis marker sized relative to the scene
            axis = creation.axis(origin_size=self.scene.scale / 100)
            # create ordered args for a vertex list
            args = rendering.mesh_to_vertexlist(axis)
            # store the axis as a reference
            self._axis = self.batch.add_indexed(*args)

        # case where we DON'T want an axis but a vertexlist
        # IS stored internally
        elif not self.view['axis'] and self._axis is not None:
            # remove the axis from the rendering batch
            self._axis.delete()
            # set the reference to None
            self._axis = None
1351606
def update(self, instance, oldValue, newValue, subKey):
    """"""
    histogram = self.__get__(instance, None)
    histogram[subKey] += newValue - oldValue
61714
function updateStates()
    {
        var numVertices = graph.vertexCount();
        var newStates = [];

        // Calculate new states without changing current states
        for(var i = 0; i < numVertices; i++)
        {
            var currentVertex = graph.getVertex(topologicalSortOrder[i]);

            if(currentVertex.state == "NOT_READY")
            {
                if(graph.indegree(currentVertex.id) == 0)
                {
                    newStates.push("READY");
                }
                else
                {
                    var parents = graph.getParentVertexIds(currentVertex.id);
                    var numParents = parents.length;
                    var allParentsAreSuccess = true;
                    var someParentFailed = false;

                    for(var j = 0; j < numParents; j++)
                    {
                        var currentParent = graph.getVertex(parents[j]);
                        allParentsAreSuccess = allParentsAreSuccess && currentParent.state == "SUCCESS";
                        someParentFailed = someParentFailed || currentParent.state == "FAIL";
                    }

                    if(allParentsAreSuccess)
                    {
                        newStates.push("READY");
                    }
                    else if(someParentFailed)
                    {
                        newStates.push("FAIL");
                    }
                    else
                    {
                        newStates.push("NOT_READY");
                    }
                }
            }
            else
            {
                newStates.push(currentVertex.state);
            }
        }

        // Transfer new states to the vertices
        for(var i = 0; i < numVertices; i++)
        {
            var currentVertex = graph.getVertex(topologicalSortOrder[i]);
            currentVertex.setState(newStates[i]);
        }
    }
323803
def update_plot(self, indep_var, dep_var):
        
        evaluated_model = self.ig._eval_model()
        plot = self.ig._plots[(indep_var, dep_var)]
        y_vals = getattr(evaluated_model, dep_var.name)
        x_vals = self.ig._x_points[indep_var]
        plot.set_data(x_vals, y_vals)