Clears the lowest score.

        raise:  NoAccess - ``Metadata.isRequired()`` or
                ``Metadata.isReadOnly()`` is ``true``
        *compliance: mandatory -- This method must be implemented.*
197397
def clear_lowest_numeric_score(self):
        
        # Implemented from template for osid.grading.GradeSystemForm.clear_lowest_numeric_score
        if (self.get_lowest_numeric_score_metadata().is_read_only() or
                self.get_lowest_numeric_score_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['lowestNumericScore'] = self._lowest_numeric_score_default
1159765
def remove_range_by_score(self, minval, maxval,
                              include_min=True, include_max=True):
        '''
        '''
        return self._sl.remove_range_by_score(
            minval, maxval, include_min=include_min, include_max=include_max,
            callback=lambda sc, value: self._dict.pop(value))
1274683
def clear_end_date(self):
        
        if (self.get_end_date_metadata().is_read_only() or
                self.get_end_date_metadata().is_required()):
            raise NoAccess()
        self.my_osid_object_form._my_map['endDate'] = \
            DateTime(**self._end_date_metadata['default_date_time_values'][0])
375334
public void pruneZeroCounts() {
        int i = 0;
        while (i < rankedItems.size()) {
            if (rankedItems.get(i).getCount() == 0) {
                rankedItems.remove(i);
            } else {
                i++;
            }
        }
    }
33880
public final void reset() {
    equivalencesMatched.clear();
    allFeatsIn = false;
    tokCnt = 0;
    featuresFound.clear();
    tmpFeaturesFound.clear();
    tokSequence.clear();
    tokSequenceEquivalences.clear();
    readingsCounter = 1;
    uniMatched = false;
    uniAllMatched = false;
    inUnification = false;
  }
515151
public void clear() {
      this.min = Double.POSITIVE_INFINITY;
      this.max = Double.NEGATIVE_INFINITY;
      this.sum = 0;
      this.sumOfSq = 0;
      this.count = 0;
   }
1183518
def reset_scorer(self):
        """"""
        self.scorer = get_eidos_bayesian_scorer()
        for corpus_id, corpus in self.corpora.items():
            corpus.curations = {}
642649
def clear_description(self):
        
        if (self.get_description_metadata().is_read_only() or
                self.get_description_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['description'] = dict(self._description_default)
277619
def cleared=(cleared)
      validator = EnumAttributeValidator.new('String', ['cleared', 'uncleared', 'reconciled'])
      unless validator.valid?(cleared)
        fail ArgumentError, 'invalid value for "cleared", must be one of #{validator.allowable_values}.'
      end
      @cleared = cleared
    end
937110
def clear_cycles(self):
        """"""
        if self.rater is None:
            raise IndexError('You need to have at least one rater')

        cycles = self.rater.find('cycles')
        for cyc in list(cycles):
            cycles.remove(cyc)

        self.save()
703119
def clear(self):
    """"""
    value = self._sum / tf.cast(self._count, self._dtype)
    with tf.control_dependencies([value]):
      reset_value = self._sum.assign(tf.zeros_like(self._sum))
      reset_count = self._count.assign(0)
    with tf.control_dependencies([reset_value, reset_count]):
      return tf.identity(value)
395934
public void clearGuaranteedRemoteGet() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "clearGuaranteedRemoteGet");
        getHdr2().setChoiceField(JsHdr2Access.GUARANTEEDREMOTEGET, JsHdr2Access.IS_GUARANTEEDREMOTEGET_EMPTY);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "clearGuaranteedRemoteGet");
    }
286997
def clear(self):
        
        # mark this task as incomplete
        self.mark_incomplete()

        # Delete the indicator metadata, this also deletes values by cascading.
        #
        # NOTE: calling 'delete()' on the query (instead of on the queried object,
        # as done here), would NOT work! For a query, there is no in-Python cascading
        # of delete statements in sqlalchemy, so the associated values would not
        # be deleted e.g. for SQLite databases.
        try:
            indicator = self.session.query(models.EuroStatIndicator) \
                .filter(models.EuroStatIndicator.number == self.number) \
                .one()
            self.session.delete(indicator)
        except NoResultFound:
            # Data didn't exist yet, no problem
            pass

        self.close_session()
300200
def get_lowest_numeric_score_metadata(self):
        
        # Implemented from template for osid.resource.ResourceForm.get_group_metadata_template
        metadata = dict(self._mdata['lowest_numeric_score'])
        metadata.update({'existing_decimal_values': self._my_map['lowestNumericScore']})
        return Metadata(**metadata)
1181333
def clear_assessment(self):
        
        # Implemented from template for osid.resource.ResourceForm.clear_avatar_template
        if (self.get_assessment_metadata().is_read_only() or
                self.get_assessment_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['assessmentId'] = self._assessment_default
498038
def reset(self):
        
        self._count = 0
        self._sum = float(0)
        self._min = float('inf')
        self._max = float(0)
400889
def clear_start_time(self):
        
        # Implemented from template for osid.assessment.AssessmentOfferedForm.clear_start_time_template
        if (self.get_start_time_metadata().is_read_only() or
                self.get_start_time_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['startTime'] = self._start_time_default