Increase forces with input value.

@param extrp The extrapolation value.
@param fh The added horizontal force.
@param fv The added vertical force.
163499
public void addDirection(double extrp, double fh, double fv)
    {
        fhLast = fh;
        fvLast = fv;
        this.fh += fh * extrp;
        this.fv += fv * extrp;
        fixForce();
    }
569801
@Override
    public void update(double extrp, int x, int y, double speed)
    {
        data.setOffsetY(y);

        for (int i = 0; i < cloudsNumber; i++)
        {
            this.x[i] += this.speed[i] * extrp;
            this.x[i] = UtilMath.wrapDouble(this.x[i], 0.0, sprite.getWidth());
        }
    }
459491
public void execute(TransformerImpl transformer) throws TransformerException
  {    
    XPathContext context = transformer.getXPathContext();

    // Verify that result has not already been set by another result
    // element. Recursion is allowed: intermediate results are cleared 
    // in the owner ElemExsltFunction execute().
    if (transformer.currentFuncResultSeen()) {
        throw new TransformerException("An EXSLT function cannot set more than one result!");
    }

    int sourceNode = context.getCurrentNode();

    // Set the return value;
    XObject var = getValue(transformer, sourceNode);
    transformer.popCurrentFuncResult();
    transformer.pushCurrentFuncResult(var);
  }
454306
function(min, max) {
    return function limitHfov(params) {
      var width = params.width;
      var height = params.height;
      if (width > 0 && height > 0) {
        var vmin = convertFov.htov(min, width, height);
        var vmax = convertFov.htov(max, width, height);
        params.fov = clamp(params.fov, vmin, vmax);
      }
      return params;
    };
  }
1195192
public void addExStrFeats(double weight, Object xObj, Object yObj, List<String>[] fvStrs) {
        FeatureVector[] fvs = new FeatureVector[fvStrs.length];
        for (int i=0; i<fvs.length; i++) {
            fvs[i] = new FeatureVector();
            for (String featName : fvStrs[i]) {
                fvs[i].add(featAlphabet.lookupIndex(featName), 1);
            }
        }
        addEx(weight, xObj, yObj, fvs);
    }
394998
public int decrease(double extrp, int decrease)
    {
        final int remain = getCurrent();
        final double decreased = remain - decrease * extrp;
        set(decreased);
        if (decreased < 0)
        {
            return remain;
        }
        return decrease;
    }
334306
private void addClauseSetWithRelaxation(final Variable relaxationVar, final Formula formula) {
        switch (formula.type()) {
            case TRUE:
                break;
            case FALSE:
            case LITERAL:
            case OR:
                this.addClauseWithRelaxation(relaxationVar, formula);
                break;
            case AND:
                for (final Formula op : formula) { this.addClauseWithRelaxation(relaxationVar, op); }
                break;
            default:
                throw new IllegalArgumentException("Input formula ist not a valid CNF: " + formula);
        }
    }
391554
private Ref eqvOp() throws PageException {
	Ref ref = xorOp();
	while (cfml.forwardIfCurrent("eqv")) {
	    cfml.removeSpace();
	    ref = new EQV(ref, xorOp(), limited);
	}
	return ref;
    }
104924
public void addNextValue(Object val) {
    long newVal = Long.parseLong(val.toString());
    if (this.maxVal < newVal) {
      this.maxVal = newVal;
    }
  }
1157418
private static void adjustQuality(Map<String, Float> pFormatQuality, String pFormat, float pFactor) {
        Float oldValue = pFormatQuality.get(pFormat);
        if (oldValue != null) {
            pFormatQuality.put(pFormat, oldValue * pFactor);
            //System.out.println("New vallue after multiplying with " + pFactor + " is " + pFormatQuality.get(pFormat));
        }
    }
209837
private void fixForce()
    {
        final double minH;
        final double minV;
        final double maxH;
        final double maxV;

        if (directionMin == null)
        {
            minH = fh;
            minV = fv;
        }
        else
        {
            minH = directionMin.getDirectionHorizontal();
            minV = directionMin.getDirectionVertical();
        }
        if (directionMax == null)
        {
            maxH = fh;
            maxV = fv;
        }
        else
        {
            maxH = directionMax.getDirectionHorizontal();
            maxV = directionMax.getDirectionVertical();
        }
        fh = UtilMath.clamp(fh, minH, maxH);
        fv = UtilMath.clamp(fv, minV, maxV);
    }
815155
public void divBP(VarTensor f) {
    	VarTensor newFactor = applyBinOp(this, f, new AlgebraLambda.DivBP());
        internalSet(newFactor);
    }
385185
public void setHeight(float v) {
    if (DocumentElement_Type.featOkTst && ((DocumentElement_Type)jcasType).casFeat_height == null)
      jcasType.jcas.throwFeatMissing("height", "ch.epfl.bbp.uima.types.DocumentElement");
    jcasType.ll_cas.ll_setFloatValue(addr, ((DocumentElement_Type)jcasType).casFeatCode_height, v);}
1280285
public void set(VarTensor f) {
        if (!this.vars.equals(f.vars)) {
            throw new IllegalStateException("The varsets must be equal.");
        }
        super.setValuesOnly(f);
    }
1229677
public void addSoftFormula(final Formula formula, int weight) {
    if (this.result != UNDEF)
      throw new IllegalStateException("The MaxSAT solver does currently not support an incremental interface.  Reset the solver.");
    if (weight < 1)
      throw new IllegalArgumentException("The weight of a formula must be > 0");
    this.addCNF(formula.cnf(), weight);
  }
329486
public void addVarRefExpr(final INodeReadTrx mTransaction, final String mVarName) {

        final VariableAxis axis = (VariableAxis)mVarRefMap.get(mVarName);
        if (axis != null) {
            getExpression().add(new VarRefExpr(mTransaction, axis));
        } else {
            throw new IllegalStateException("Variable " + mVarName + " unkown.");
        }

    }
994026
public FFmpegBuilder addExtraArgs(String... values) {
    checkArgument(values.length > 0, "one or more values must be supplied");
    checkNotEmpty(values[0], "first extra arg may not be empty");

    for (String value : values) {
      extra_args.add(checkNotNull(value));
    }
    return this;
  }