Reset the distribution by throwing away all history and
adding a single data point.

@param value the single data point that makes up the distribution
500074
synchronized void reset(double value, int updated) {
        ewma = value;
        ewmaStddev = value * SINGLE_VALUE_STDDEV;
        ewmaVariance = ewmaStddev * ewmaStddev;
        consecutiveOutliers = 0;
        lastUpdate = updated;
    }
211184
public final void reset() {
                for (int i = 0; i < position.length; i++) {
                        position[i] = i;
                }
                permLeft = new BigInteger(permTotal.toString());
        }
350886
public void reset() {
    this.state = State.FREE;
    this.level = Integer.MAX_VALUE;
    this.mark = 0;
    this.reason = null;
  }
1105811
public void add(
      double value
  )
  {
    readWriteLock.writeLock().lock();

    try {
      if (value < lowerLimit) {
        outlierHandler.handleOutlierAdd(false);
        return;
      } else if (value >= upperLimit) {
        outlierHandler.handleOutlierAdd(true);
        return;
      }

      count += 1;
      if (value > max) {
        max = value;
      }
      if (value < min) {
        min = value;
      }

      double valueRelativeToRange = value - lowerLimit;
      int targetBucket = (int) (valueRelativeToRange / bucketSize);

      if (targetBucket >= histogram.length) {
        targetBucket = histogram.length - 1;
      }

      histogram[targetBucket] += 1;
    }
    finally {
      readWriteLock.writeLock().unlock();
    }
  }
584893
public void accumulate(AverageData data,
                           Object value) {
        if (value != null) {
            data.count++;
            data.total += ( (Number) value ).doubleValue();
        }
    }
297412
public void reset()
    {
        xMin = Double.NaN;
        xMax = Double.NaN;
        yMin = Double.NaN;
        yMax = Double.NaN;
    }
935435
public void add( float value ) {
		// see if it needs to grow the queue
		if( size >= data.length) {
			data[start] = value;
			start = (start+1)%data.length;
		} else {
			data[(start+size)%data.length] = value;
			size++;
		}
	}
185179
public final void setValue(final int value)
	{
		expUnitAdjustment = 0;
		try {
			data = toDpt(dimensionlessCounter, value);
		}
		catch (final KNXFormatException e) {
			logger.error("{} {} coding {} (value {}) should alway have correct format", dpt.getID(),
					dpt.getDescription(), binary(dimensionlessCounter), value, e);
		}
	}
620741
@Override
    protected void reset() {
        super.reset();
        versionEndExcluding = null;
        versionEndIncluding = null;
        versionStartExcluding = null;
        versionStartIncluding = null;
        vulnerable = true;
    }
1033818
public void reset() {

        this.pp.setIndex(0);
        this.pp.setErrorIndex(-1);
        this.errorMessage = "";
        this.warning = false;
        this.rawValues = null;

    }
502397
def _reset_values(self, instance):
        """"""
        self.value = None
        self.reference.value = None
        instance.__dict__.pop(self.field_name, None)
        instance.__dict__.pop(self.reference.field_name, None)
        self.reference.delete_cached_value(instance)
253258
private void reset() {
    size = 0;
    qualifier_index = 0;
    value_index = 0;
    base_time = Long.MIN_VALUE;
    last_timestamp = Long.MIN_VALUE;
  }
57804
@Override
    public void reset() {
        updatesLock.writeLock().lock();

        if (storage != null) {
            storage.assign(0.0f);
        }

        if (updates != null)
            updates.assign(0.0f);

        updatesLock.writeLock().unlock();
    }
372688
synchronized void addDataPoint(double value, int updated) {
        // 8/10/2012: Force the standard deviation to 1/3 of the first data point
        // 8/11:2012: Force it to 1/6th of the first data point (more accurate)
        if (ewmaVariance == Double.NEGATIVE_INFINITY) {
            reset(value, updated);
            return;
        }

        double delta = value - ewma;
        double increment = ALPHA * delta;

        ewma += increment;
        ewmaVariance = (1 - ALPHA) * (ewmaVariance + delta * increment);
        ewmaStddev = Math.sqrt(ewmaVariance);

        lastUpdate = updated;
    }
1291275
public void removeValue(T value, boolean reload) {
        int idx = getIndex(value);
        if (idx >= 0) {
            removeItemInternal(idx, reload);
        }
    }
1107432
protected void reset() {
	done.set(false);
	performing.set(false);
	cancelled.set(false);
	estimated.set(0L);
    }
1192035
public void add(long value) {
        writeLock.lock();
        try {
            // do we need to evict anything?
            if (this.values.size() >= this.size) {
                Long oldValue = this.values.pollFirst();
                // subtract from running total
                this.total -= oldValue.longValue();
            }
            // add this new value onto the end
            this.values.add(value);
            // add to our total
            this.total += value;
        } finally {
            writeLock.unlock();
        }
    }