Sets the underlying bin view to match current view
433126
def _set_bin_view(self, session):
        """"""
        if self._bin_view == COMPARATIVE:
            try:
                session.use_comparative_bin_view()
            except AttributeError:
                pass
        else:
            try:
                session.use_plenary_bin_view()
            except AttributeError:
                pass
591920
function View_setLoader(resolve, load) {
            this.swig.setDefaults({
                loader: {
                    resolve: resolve,
                    load: load
                }
            });
        }
1201826
def as_view(cls, **initkwargs):
        """"""
        view = super(AtomicMixin, cls).as_view(**initkwargs)
        return cls.create_atomic_wrapper(view)
1134401
function setView({ action, config, route, routes, method }) {
  const ws = route.ws;
  return exports.getView(action, config).then(view => {
    routes[ws ? 'ws' : route.type].push({
      action,
      method,
      view,
      match: new Route(route.url),
    });
  });
}
461728
def fixed_width_binning(data=None, bin_width: Union[float, int] = 1, *, range=None, includes_right_edge=False, **kwargs) -> FixedWidthBinning:
    
    result = FixedWidthBinning(bin_width=bin_width, includes_right_edge=includes_right_edge,
                               **kwargs)
    if range:
        result._force_bin_existence(range[0])
        result._force_bin_existence(range[1], includes_right_edge=True)
        if not kwargs.get("adaptive"):
            return result  # Otherwise we want to adapt to data
    if data is not None and data.shape[0]:
        # print("Jo, tady")
        result._force_bin_existence([np.min(data), np.max(data)],
                                    includes_right_edge=includes_right_edge)
    return result
299487
def visit_binop(self, node, parent):
        """"""
        newnode = nodes.BinOp(
            self._bin_op_classes[type(node.op)], node.lineno, node.col_offset, parent
        )
        newnode.postinit(
            self.visit(node.left, newnode), self.visit(node.right, newnode)
        )
        return newnode
727720
def _set_vault_view(self, session):
        """"""
        if self._vault_view == COMPARATIVE:
            try:
                session.use_comparative_vault_view()
            except AttributeError:
                pass
        else:
            try:
                session.use_plenary_vault_view()
            except AttributeError:
                pass
736617
def set_visible(self, visible):
        
        v = View.VISIBILITY_VISIBLE if visible else View.VISIBILITY_GONE
        self.widget.setVisibility(v)
44204
def yview(self, *args):
        """"""
        self.after_idle(self.__updateWnds)
        ttk.Treeview.yview(self, *args)
501568
def adapt(self, other: 'BinningBase'):
        
        # TODO: in-place arg
        if np.array_equal(self.bins, other.bins):
            return None, None
        elif not self.is_adaptive():
            raise RuntimeError("Cannot adapt non-adaptive binning.")
        else:
            return self._adapt(other)
825879
function setActiveBin (bins, activebin) {
    var i, bin = null
    for (i in bins) {
      bins[i] = false
    }
    bins[activebin] = true
    return bins
  }
1130148
function(bin, full) {
      var url = [];

      if (bin.url) {
        url.push(bin.url);

        if (bin.revision) {
          url.push(bin.revision);
        }
      }

      return this.url(url.join('/'), full);
    }
294917
public void setClearView(View view) {
        mClearView = view;
        if (view != null) {
            view.setVisibility(mOpened ? VISIBLE : INVISIBLE);
            view.setOnClickListener(mOnClickListenerClearView);
        }
    }
669352
def _bin_op(instance, opnode, op, other, context, reverse=False):
    
    if reverse:
        method_name = protocols.REFLECTED_BIN_OP_METHOD[op]
    else:
        method_name = protocols.BIN_OP_METHOD[op]
    return functools.partial(
        _invoke_binop_inference,
        instance=instance,
        op=op,
        opnode=opnode,
        other=other,
        context=context,
        method_name=method_name,
    )
1061143
def set_bin_window(self, bin_size=None, window_size=None):
        """"""
        bin_size = bin_size or self.bin_size
        window_size = window_size or self.window_size
        assert 1e-6 < bin_size < 1e3
        assert 1e-6 < window_size < 1e3
        assert bin_size < window_size
        self.bin_size = bin_size
        self.window_size = window_size
        # Set the status message.
        b, w = self.bin_size * 1000, self.window_size * 1000
        self.set_status('Bin: {:.1f} ms. Window: {:.1f} ms.'.format(b, w))
1306534
def _set_view(self):
        """"""
        if self.logarithmic:
            if self._dual:
                view_class = XYLogView
            else:
                view_class = LogView
        else:
            view_class = ReverseView if self.inverse_y_axis else View

        self.view = view_class(
            self.width - self.margin_box.x, self.height - self.margin_box.y,
            self._box
        )
498391
def fill_view(self, view):
        
        other = view.hist
        _other_x_center = other.axis(0).GetBinCenter
        _other_y_center = other.axis(1).GetBinCenter
        _other_z_center = other.axis(2).GetBinCenter
        _other_get = other.GetBinContent
        _other_get_bin = super(_HistBase, other).GetBin
        other_sum_w2 = other.GetSumw2()
        _other_sum_w2_at = other_sum_w2.At

        _find = self.FindBin
        sum_w2 = self.GetSumw2()
        _sum_w2_at = sum_w2.At
        _sum_w2_setat = sum_w2.SetAt
        _set = self.SetBinContent
        _get = self.GetBinContent

        for x, y, z in view.points:
            idx = _find(
                _other_x_center(x),
                _other_y_center(y),
                _other_z_center(z))
            other_idx = _other_get_bin(x, y, z)
            _set(idx, _get(idx) + _other_get(other_idx))
            _sum_w2_setat(
                _sum_w2_at(idx) + _other_sum_w2_at(other_idx),
                idx)