Sets the caption_found and plot_found variables to False.
544330
def prepare(doc):
    """"""
    doc.caption_found = False
    doc.plot_found = False
    doc.listings_counter = 0
750832
def un_set_variable(op, var, val, should_persist)

      result = if op == :set
        Ruote.set(h.variables, var, val)
      else # op == :unset
        Ruote.unset(h.variables, var)
      end

      if should_persist && r = try_persist # persist failed, have to retry

        self.h = r
        un_set_variable(op, var, val, true)

      else # success (even when should_persist == false)

        @context.storage.put_msg("variable_#{op}", 'var' => var, 'fei' => h.fei)
      end

      result
    end
1126238
private void tryToEliminateTheScope()
  {
    for( int i = 0; i < _statements.length; i++ )
    {
      Statement statement = _statements[i];
      if( statement instanceof VarStatement ||
          (!(statement instanceof StatementList) &&
           statement.getContainedParsedElementsByType( EvalExpression.class, null )) )
      {
        return;
      }
    }
    setNoScope();
  }
1295861
def set_variable(var, val, override=false)

      fexp, v = locate_set_var(var, override) || locate_var(var)

      fexp.un_set_variable(:set, v, val, (fexp.h.fei != h.fei)) if fexp
    end
119463
def _set_default_format(self, vmin, vmax):
        ""

        if self.plot_obj.date_axis_info is None:
            self.plot_obj.date_axis_info = self.finder(vmin, vmax, self.freq)
        info = self.plot_obj.date_axis_info

        if self.isminor:
            format = np.compress(info['min'] & np.logical_not(info['maj']),
                                 info)
        else:
            format = np.compress(info['maj'], info)
        self.formatdict = {x: f for (x, _, _, f) in format}
        return self.formatdict
334854
def _set_labels(self, axes, dimensions, xlabel=None, ylabel=None, zlabel=None):
        
        xlabel, ylabel, zlabel = self._get_axis_labels(dimensions, xlabel, ylabel, zlabel)
        if self.invert_axes:
            xlabel, ylabel = ylabel, xlabel
        if xlabel and self.xaxis and 'x' in self.labelled:
            axes.set_xlabel(xlabel, **self._fontsize('xlabel'))
        if ylabel and self.yaxis and 'y' in self.labelled:
            axes.set_ylabel(ylabel, **self._fontsize('ylabel'))
        if zlabel and self.zaxis and 'z' in self.labelled:
            axes.set_zlabel(zlabel, **self._fontsize('zlabel'))
1374398
def warn_if_nans_exist(X):
    """"""
    null_count = count_rows_with_nans(X)
    total = len(X)
    percent = 100 * null_count / total

    if null_count > 0:
        warning_message = \
            'Warning! Found {} rows of {} ({:0.2f}%) with nan values. Only ' \
            'complete rows will be plotted.'.format(null_count, total, percent)
        warnings.warn(warning_message, DataWarning)
1167861
public static void setVariableWithSingleQuotationMarks(final String variablename,
		final Object object, final Map<String, Object> variables)
	{
		if (object != null)
		{
			variables.put(variablename, "'" + object + "'");
		}
		else
		{
			variables.put(variablename, "null");
		}
	}
979721
def hide_ticks(plot, min_tick_value=None, max_tick_value=None):
    """"""
    for tick, tick_value in zip(plot.get_yticklabels(), plot.get_yticks()):
        tick_label = as_numeric(tick_value)
        if tick_label:
            if (min_tick_value is not None and tick_label < min_tick_value or 
                 max_tick_value is not None and tick_label > max_tick_value):
                tick.set_visible(False)
104436
def _set_rc(self):
        """"""
        base_str = self._get_rc_strings()
        # to make sure that the '.' is not interpreted as a regex pattern,
        # we specify the pattern_base by ourselves
        pattern_base = map(lambda s: s.replace('.', '\.'), base_str)
        # pattern for valid keys being all formatoptions in this plotter
        pattern = '(%s)(?=$)' % '|'.join(self._get_formatoptions())
        self._rc = rcParams.find_and_replace(base_str, pattern=pattern,
                                             pattern_base=pattern_base)
        user_rc = SubDict(rcParams['plotter.user'], base_str, pattern=pattern,
                          pattern_base=pattern_base)
        self._rc.update(user_rc.data)

        self._defaultParams = SubDict(rcParams.defaultParams, base_str,
                                      pattern=pattern,
                                      pattern_base=pattern_base)
1038138
public void setCaptionSelectors(java.util.Collection<CaptionSelector> captionSelectors) {
        if (captionSelectors == null) {
            this.captionSelectors = null;
            return;
        }

        this.captionSelectors = new java.util.ArrayList<CaptionSelector>(captionSelectors);
    }
1163934
public void setEndings(FloatArray v) {
    if (DocumentLine_Type.featOkTst && ((DocumentLine_Type)jcasType).casFeat_endings == null)
      jcasType.jcas.throwFeatMissing("endings", "ch.epfl.bbp.uima.types.DocumentLine");
    jcasType.ll_cas.ll_setRefValue(addr, ((DocumentLine_Type)jcasType).casFeatCode_endings, jcasType.ll_cas.ll_getFSRef(v));}
906259
public void setObjectCaption(Caption v) {
    if (TextObject_Type.featOkTst && ((TextObject_Type)jcasType).casFeat_objectCaption == null)
      jcasType.jcas.throwFeatMissing("objectCaption", "de.julielab.jules.types.TextObject");
    jcasType.ll_cas.ll_setRefValue(addr, ((TextObject_Type)jcasType).casFeatCode_objectCaption, jcasType.ll_cas.ll_getFSRef(v));}
584009
def setup_params(self, data):
        
        # Variable for which to do the stacking
        if 'ymax' in data:
            if any((data['ymin'] != 0) & (data['ymax'] != 0)):
                warn("Stacking not well defined when not "
                     "anchored on the axis.", PlotnineWarning)
            var = 'ymax'
        elif 'y' in data:
            var = 'y'
        else:
            warn("Stacking requires either ymin & ymax or y "
                 "aesthetics. Maybe you want position = 'identity'?",
                 PlotnineWarning)
            var = None

        params = self.params.copy()
        params['var'] = var
        params['fill'] = self.fill
        return params
505570
private boolean checkForVariables(List<Map<String, String>> values) {
    if (values == null || values.isEmpty()) {
      return false;
    } else {
      for (Map<String, String> list : values) {
        if (list.containsKey("type") && list.get("type")
            .equals(MtasParserMapping.PARSER_TYPE_VARIABLE)) {
          return true;
        }
      }
    }
    return false;
  }
1181893
def set_ylimits_widgets(self, set_min=True, set_max=True):
        """"""
        ymin, ymax = self.tab_plot.ax.get_ylim()
        if set_min:
            self.w.y_lo.set_text('{0}'.format(ymin))
        if set_max:
            self.w.y_hi.set_text('{0}'.format(ymax))
8235
def _set_init_vars_and_dims(self, data_vars, coords, compat):
        
        both_data_and_coords = [k for k in data_vars if k in coords]
        if both_data_and_coords:
            raise ValueError('variables %r are found in both data_vars and '
                             'coords' % both_data_and_coords)

        if isinstance(coords, Dataset):
            coords = coords.variables

        variables, coord_names, dims = merge_data_and_coords(
            data_vars, coords, compat=compat)

        self._variables = variables
        self._coord_names = coord_names
        self._dims = dims