Sets the upper bound on the false positive rate for detecting concept
drifts
@param delta the upper bound on false positives in (0,1)
778823
public void setDelta(double delta)
    {
        if(delta <= 0 || delta >= 1 || Double.isNaN(delta))
            throw new IllegalArgumentException("delta must be in (0,1), not " + delta);
        this.delta = delta;
    }
818515
public void deltaTotalPoolTime(long delta)
   {
      if (enabled.get() && delta > 0)
      {
         totalPoolTime.addAndGet(delta);
         totalPoolTimeInvocations.incrementAndGet();

         if (delta > maxPoolTime.get())
            maxPoolTime.set(delta);
      }
   }
1348709
private static long specialNStar(final long numSamplesI, final double p, final double delta) {
    final double q, numSamplesF;
    double tot, curTerm;
    long m;
    assertTrue(numSamplesI >= 1);
    assertTrue((0.0 < p) && (p < 1.0));
    assertTrue((0.0 < delta) && (delta < 1.0));
    q = 1.0 - p;
    numSamplesF = numSamplesI;
    // Use a different algorithm if the following isn't true; this one will be too slow, or worse.
    assertTrue((numSamplesF / p) < 500.0);
    curTerm = Math.pow(p, numSamplesF);  // curTerm = posteriorProbability (k, k, p)
    assertTrue(curTerm > 1e-100); // sanity check for non-use of logarithms
    tot = curTerm;
    m = numSamplesI;
    while (tot <= delta) { // this test can fail even the first time
      curTerm = (curTerm * q * (m)) / ((m + 1) - numSamplesI);
      tot += curTerm;
      m += 1;
    }
    // we have reached a state where tot > delta, so back up one
    return (m - 1);
  }
1184973
public static int compare(double a, double b, double delta) {
        if (equals(a, b, delta)) {
            return 0;
        }
        return Double.compare(a, b);
    }
527548
public void setEpsilon(double eps)
    {
        if(eps < 0 || Double.isInfinite(eps) || Double.isNaN(eps))
            throw new ArithmeticException("Regularization must be a positive value");
        this.eps = eps;
    }
494491
private void adjustNodeCount(final int delta) {
		for (TableTreeNode parent = this; parent != null; parent = (TableTreeNode) parent.
				getParent()) {
			parent.nodeCount += delta;
		}
	}
731818
public static boolean contains(float[] array, float value, float delta) {
        for (int i=0; i<array.length; i++) {
            if (Primitives.equals(array[i], value, delta)) {
                return true;
            }
        }
        return false;
    }
943426
void update(int delta) {
		if (!playing) {
			return;
		}
       
		if (fadeTime > 0) {
			fadeTime -= delta;
			if (fadeTime <= 0) {
				fadeTime = 0;
				if (stopAfterFade) {
					stop();
					return;
				}
			}
			
			float offset = (fadeEndGain - fadeStartGain) * (1 - (fadeTime / (float)fadeDuration));
			setVolume(fadeStartGain + offset);
		}
	}
44826
private boolean _createDeltas()
    {
        if (isInitialStateMarked())
        {
            if (_deltas == null)
            {
                _deltas = new HashMap<Serializable, Object>(2);
            }
            return true;
        }

        return false;
    }
311892
public void setProbability(double v) {
    if (WordForm_Type.featOkTst && ((WordForm_Type)jcasType).casFeat_probability == null)
      jcasType.jcas.throwFeatMissing("probability", "com.digitalpebble.rasp.WordForm");
    jcasType.ll_cas.ll_setDoubleValue(addr, ((WordForm_Type)jcasType).casFeatCode_probability, v);}
1313951
public void addHeuristicCpuCost(double cost) {
		if (cost <= 0) {
			throw new IllegalArgumentException("Heuristic costs must be positive.");
		}
		this.heuristicCpuCost += cost;
		// check for overflow
		if (this.heuristicCpuCost < 0) {
			this.heuristicCpuCost = Double.MAX_VALUE;
		}
	}
66346
def set_learning_rate(self, lr):
        
        if not isinstance(self._optimizer, opt.Optimizer):
            raise UserWarning("Optimizer has to be defined before its learning "
                              "rate is mutated.")
        else:
            self._optimizer.set_learning_rate(lr)
1161073
protected void accumulatePersistedRepositoryChanges(long delta)
   {
      long dataSize = 0;
      try
      {
         dataSize = quotaPersister.getRepositoryDataSize(rName);
      }
      catch (UnknownDataSizeException e)
      {
         if (LOG.isTraceEnabled())
         {
            LOG.trace(e.getMessage(), e);
         }
      }

      long newDataSize = Math.max(dataSize + delta, 0); // to avoid possible inconsistency
      quotaPersister.setRepositoryDataSize(rName, newDataSize);
   }
810163
public static int delta(int[] data, int start, int length, int init) {
                final int nextinit = data[start + length - 1];
                for (int i = length - 1; i > 0; --i) {
                        data[start + i] -= data[start + i - 1];
                }
                data[start] -= init;
                return nextinit;
        }
881577
public static void assertEquals(float expected, float actual, float delta) {
        assertEquals(expected, actual, delta, "Expected " + expected + " +- " + delta + " but got " + actual);
    }
928205
public void deltaTotalUsageTime(long delta)
   {
      if (enabled.get() && delta > 0)
      {
         totalUsageTime.addAndGet(delta);
         totalUsageTimeInvocations.incrementAndGet();

         if (delta > maxUsageTime.get())
            maxUsageTime.set(delta);
      }
   }
503920
private void ensureCapacity(int delta) {
        ByteBuffer bb = m_container.b();
        int bufferDelta = (bb.position() + delta) - bb.capacity();
        if (bufferDelta > 0) {
            BBContainer ncntnr = DBBPool.allocateUnsafeByteBuffer(bb.capacity() + bufferDelta);

            ByteBuffer newbb = ncntnr.b();
            bb.flip();
            newbb.put(bb);

            m_container.discard();
            m_container = ncntnr;
        }
    }