Updates the plot of the proposed model.
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)
1015386
def updateData(self, data):
        
#        pylab.ion()
        fig = pylab.figure(1)

        n_agent = len(data)

        idx = 1
        for i, adata in enumerate(data):
            saxis = fig.add_subplot(3, n_agent, i + 1)
            saxis.plot(adata[0])
            idx += 1

            aaxis = fig.add_subplot(3, n_agent, i + 1 + n_agent)
            aaxis.plot(adata[1])
            idx += 1

            raxis = fig.add_subplot(3, n_agent, i + 1 + (n_agent * 2))
            raxis.plot(adata[2])
            idx += 1

        pylab.show()
1116054
def update(self, other):
        

        acceptable_models = [ m for m in other._models if set(m.model.keys()) == self.variables ]
        self._models.update(acceptable_models)
        self._eval_exhausted.update(other._eval_exhausted)
        self._max_exhausted.update(other._max_exhausted)
        self._min_exhausted.update(other._min_exhausted)
818820
def update(self, **kwargs):
        """"""
        self.inflate()
        for model in self._models:
            model.update(**kwargs)
        return self
371399
def update(self, *args):
        
        self.kwargs = {}
        if self.manual:
            self.manual_button.disabled = True
        try:
            show_inline_matplotlib_plots()
            with self.out:
                if self.clear_output:
                    clear_output(wait=True)
                for widget in self.kwargs_widgets:
                    value = widget.get_interact_value()
                    self.kwargs[widget._kwarg] = value
                self.result = self.f(**self.kwargs)
                show_inline_matplotlib_plots()
                if self.auto_display and self.result is not None:
                    display(self.result)
        except Exception as e:
            ip = get_ipython()
            if ip is None:
                self.log.warn("Exception in interact callback: %s", e, exc_info=True)
            else:
                ip.showtraceback()
        finally:
            if self.manual:
                self.manual_button.disabled = False
600351
def _update(self):
        
        self._colorbar.halfdim = self._halfdim
        self._border.halfdim = self._halfdim

        self._label.text = self._label_str
        self._ticks[0].text = str(self._clim[0])
        self._ticks[1].text = str(self._clim[1])

        self._update_positions()

        self._colorbar._update()
        self._border._update()
1237286
def _update_cg(self):
        """"""
        beta = self._beta()
        # Automatic direction reset
        if beta < 0:
            self.direction = -self.gradient
            self.status = "SD"
        else:
            self.direction = self.direction * beta - self.gradient
            self.status = "CG"
721988
def update(self, **params):
        
        self._current_params = self._transform_params(**params)
        self._current_stats = ModelStats()
179023
def update(self):
        """"""
        if self.single_channel:
            self.im.set_data(self.data[self.ind, :, :])
        else:
            self.im.set_data(self.data[self.ind, :, :, :])
        self.ax.set_ylabel('time frame %s' % self.ind)
        self.im.axes.figure.canvas.draw()
930118
def setModel(self, model):
        
        self.paramList.setModel(model)
        model.hintRequested.connect(self.hintRequested)
        model.rowsInserted.connect(self.updateTitle)
        model.rowsRemoved.connect(self.updateTitle)
        self.updateTitle()
1334667
def update_average_model(self, model):
        
        for model_param, average_param in zip(model.parameters(), self.average_model.parameters()):
            # EWMA average model update
            average_param.data.mul_(self.average_model_alpha).add_(model_param.data * (1 - self.average_model_alpha))
870664
def update_GUI_with_new_interpretation(self):
        

        self.update_fit_bounds_and_statistics()
        self.draw_interpretations()
        self.calculate_high_levels_data()
        self.plot_high_levels_data()
988194
def update(self, **kwargs):
        
        super(ModelQuerySet, self).update(_changed=True, **kwargs)
934937
public void update() {
        if (polygon != null) {
            if (isDeleted()) {
                remove();
            } else {

                List<LatLng> points = converter.getPointsFromMarkers(markers);
                polygon.setPoints(points);

                List<List<LatLng>> holePointList = new ArrayList<List<LatLng>>();
                for (PolygonHoleMarkers hole : holes) {
                    if (!hole.isDeleted()) {
                        List<LatLng> holePoints = converter
                                .getPointsFromMarkers(hole.getMarkers());
                        holePointList.add(holePoints);
                    }
                }
                polygon.setHoles(holePointList);
            }
        }
    }
1018007
def dynamic_update(plot, subplot, key, overlay, items):
    
    match_spec = get_overlay_spec(overlay,
                                  wrap_tuple(key),
                                  subplot.current_frame)
    specs = [(i, get_overlay_spec(overlay, wrap_tuple(k), el))
             for i, (k, el) in enumerate(items)]
    closest = closest_match(match_spec, specs)
    if closest is None:
        return closest, None, False
    matched = specs[closest][1]
    return closest, matched, match_spec == matched
616733
def update_model(self):
        
        '''
             
        '''
        
        import requests
        url = self.endpoint_public + '/calculate'
        params = {
            'group': self.group_name
        }
        response = requests.get(url, params=params)
        response_details = response.json()
        
        return response_details['success']
1141426
def update(self):
        

        s = self.extract()
        self.mean = s[2][0]

        self.gradient = None
        self.gradient_error = None
        self.gradient_relative_error = None