Does the correction propose suggestions for correction?
359820
def hassuggestions(self,allowempty=False):
        """"""
        for e in self.select(Suggestion,None,False, False):
            if not allowempty and len(e) == 0: continue
            return True
        return False
1283228
public void setSuggestions(java.util.Collection<SuggestionMatch> suggestions) {
        if (suggestions == null) {
            this.suggestions = null;
            return;
        }

        this.suggestions = new com.amazonaws.internal.SdkInternalList<SuggestionMatch>(suggestions);
    }
1319275
def apply_modification(self):
        """"""
        self.__changing_model = True

        if self.adding_model: self.model.add(self.adding_model)
        elif self.editing_model and self.editing_iter:
            # notifies the currencies model
            path = self.model.get_path(self.editing_iter)
            self.model.row_changed(path, self.editing_iter)            
            pass            
        
        self.view.remove_currency_view()
        self.adding_model = None
        self.editing_model = None
        self.editing_iter = None
        self.curreny = None

        self.unselect()
        self.__changing_model = False
        return
780318
def _update_pref(self, lmin, lmax, cur):
        
        rate_of_change_positive = 10
        rate_of_change_negative = 2
        add_positive = 10
        add_negative = 2
        if lmin == lmax:
            self.rating -= int(abs(lmin - cur)*100) / 10
        else:
            if lmin <= cur:
                self.rating += (int(abs(lmin - cur)*rate_of_change_positive)) + add_positive
            else:
                self.rating -= (int(abs(lmin - cur)*rate_of_change_negative)) + add_negative
            if lmax >= cur:
                self.rating += (int(abs(lmax - cur)*rate_of_change_positive)) + add_positive
            else:
                self.rating -= (int(abs(lmax - cur)*rate_of_change_negative)) + add_negative
756933
def _qu_fix(self, sents_syllables):
        

        for sentence in sents_syllables:
            for word in sentence:
                for syllable in word:
                    if 'qu' in syllable:
                        qu_syll_index = word.index(syllable)
                        next_syll = qu_syll_index + 1
                        fixed_syllable = [''.join(word[qu_syll_index:
                                                       (next_syll + 1)])]
                        word[qu_syll_index:(next_syll + 1)] = fixed_syllable

        return sents_syllables
1086567
function (response) {
        var that = this,
            suggestions;

        if (!response || !$.isArray(response.suggestions)) {
            return false;
        }

        that.verifySuggestionsFormat(response.suggestions);
        that.setUnrestrictedValues(response.suggestions);

        if ($.isFunction(that.options.onSuggestionsFetch)) {
            suggestions = that.options.onSuggestionsFetch.call(that.element, response.suggestions);
            if ($.isArray(suggestions)) {
                response.suggestions = suggestions;
            }
        }

        return true;
    }
78614
def correct_pairs(p, pf, tag):
    
    from jcvi.assembly.preprocess import correct as cr

    logging.debug("Work on {0} ({1})".format(pf, ','.join(p)))
    itag = tag[0]
    cm = ".".join((pf, itag))
    targets = (cm + ".1.corr.fastq", cm + ".2.corr.fastq", \
                pf + ".PE-0.corr.fastq")
    if not need_update(p, targets):
        logging.debug("Corrected reads found: {0}. Skipped.".format(targets))
        return

    slink(p, pf, tag)

    cwd = os.getcwd()
    os.chdir(pf)
    cr(sorted(glob("*.fastq") + glob("*.fastq.gz")) + ["--nofragsdedup"])
    sh("mv {0}.1.corr.fastq ../{1}".format(itag, targets[0]))
    sh("mv {0}.2.corr.fastq ../{1}".format(itag, targets[1]))
    sh("mv frag_reads_corr.corr.fastq ../{0}".format(targets[2]))

    logging.debug("Correction finished: {0}".format(targets))
    os.chdir(cwd)
98301
def _fix_bias(op_name, attrs, num_inputs):
    """"""
    if num_inputs == 3:
        attrs['no_bias'] = False
    elif num_inputs == 2:
        attrs['no_bias'] = True
    else:
        raise ValueError("Unexpected number of inputs for: {}".format(op_name))
    return attrs
1169312
public function addCorrection(\Innova\CollecticielBundle\Entity\Correction $corrections)
    {
        $this->corrections[] = $corrections;

        return $this;
    }
259604
protected void addExamplePair(IncorrectExample incorrectSentence, CorrectExample correctSentence) {
    String correctExample = correctSentence.getExample();
    int markerStart= correctExample.indexOf("<marker>");
    int markerEnd = correctExample.indexOf("</marker>");
    if (markerStart != -1 && markerEnd != -1) {
      List<String> correction = Collections.singletonList(correctExample.substring(markerStart + "<marker>".length(), markerEnd));
      incorrectExamples.add(new IncorrectExample(incorrectSentence.getExample(), correction));
    } else {
      incorrectExamples.add(incorrectSentence);
    }
    correctExamples.add(correctSentence);
  }
1013230
private void findErrors(final Span references[], final Span predictions[],
      final List<Span> falseNegatives, final List<Span> falsePositives) {

    falseNegatives.addAll(Arrays.asList(references));
    falsePositives.addAll(Arrays.asList(predictions));

    for (final Span referenceName : references) {

      for (final Span prediction : predictions) {
        if (referenceName.equals(prediction)) {
          // got it, remove from fn and fp
          falseNegatives.remove(referenceName);
          falsePositives.remove(prediction);
        }
      }
    }
  }
7219
def _adjustment_reactions(self):
        """"""
        for reaction_id in self._model.reactions:
            if not self._model.is_exchange(reaction_id):
                yield reaction_id
1353078
private function correctInputs()
    {
        if (($diff = array_diff_key($this->rules, $this->inputs))) {
            foreach ($diff as $key => $value) {
                $this->inputs[ $key ] = '';
            }
        }
    }
1048292
def suggestTitle(self, title):
        """"""
        if not self._title_changed or not str(self.wtitle.text()):
            self.wtitle.setText(title)
            self._title_changed = False
887808
private void onCursorChanged(final Event event, final Suggestion<T> suggestion) {
        TypeaheadCursorChangedEvent.fire(this, suggestion, event);
    }
1265737
private void fixConstraints(IPattern p) {
        if (p instanceof FactPattern) {
            fixConstraints((FactPattern) p);
        } else if (p instanceof CompositeFactPattern) {
            fixConstraints((CompositeFactPattern) p);
        }
    }
1319860
function correctReply(reply, msg) {
  if (!_.isPlainObject(reply)) {
    reply = { "output": reply }
  }
  // autofill if not already exist
  reply["to"] = reply["to"] || msg["from"]
  reply["from"] = reply["from"] || ioid
  reply["hash"] = reply["hash"] || msg["hash"]
  return reply
}