import beast.core.parameter.BooleanParameter; //导入依赖的package包/类
@Override
public void initAndValidate() {
    BooleanParameter indicators = indicatorsInput.get();
    TreeInterface tree = treeInput.get();
    int nodeCount = tree.getNodeCount();

    rootNodeNumber = nodeCount - 1;
    ratesArray = new double[nodeCount];
    storedRatesArray = new double[nodeCount];

    noCache = noCacheInput.get().booleanValue();

    RealParameter rates = branchRatesInput.get();
    rates.setDimension(rootNodeNumber);
    indicators.setDimension(rootNodeNumber);

    if (rates.lowerValueInput.get() == null || rates.lowerValueInput.get() < 0.0) {
        rates.setLower(0.0);
    }
    if (rates.upperValueInput.get() == null || rates.upperValueInput.get() < 0.0) {
        rates.setUpper(Double.MAX_VALUE);
    }
    
    needsUpdate = true;
}
 

import beast.core.parameter.BooleanParameter; //导入依赖的package包/类
/**
 * This is a recursive function that does the work of
 * calculating the unscaled branch rates across the tree
 * taking into account the indicator variables.
 *
 * @param node the node
 * @param rate the rate of the parent node
 */
private void calculateUnscaledBranchRates(Node node, double rate, BooleanParameter indicators, RealParameter rates) {

    int nodeNumber = getNr(node);

    if (!node.isRoot()) {
        if (indicators.getValue(nodeNumber)) {
            if (ratesAreMultipliers) {
                rate *= rates.getValue(nodeNumber);
            } else {
                rate = rates.getValue(nodeNumber);
            }
        }
    }
    unscaledBranchRates[nodeNumber] = rate;

    if (!node.isLeaf()) {
        calculateUnscaledBranchRates(node.getLeft(), rate, indicators, rates);
        calculateUnscaledBranchRates(node.getRight(), rate, indicators, rates);
    }
}
 

import beast.core.parameter.BooleanParameter; //导入依赖的package包/类
@Override
public void initAndValidate() {
    m_fScaleFactor = scaleFactorInput.get();
    m_bIsTreeScaler = (treeInput.get() != null);
    upper = scaleUpperLimit.get();
    lower = scaleLowerLimit.get();

    final BooleanParameter indicators = indicatorInput.get();
    if (indicators != null) {
        if (m_bIsTreeScaler) {
            throw new IllegalArgumentException("indicator is specified which has no effect for scaling a tree");
        }
        final int dataDim = parameterInput.get().getDimension();
        final int indsDim = indicators.getDimension();
        if (!(indsDim == dataDim || indsDim + 1 == dataDim)) {
            throw new IllegalArgumentException("indicator dimension not compatible from parameter dimension");
        }
    }
}
 

import beast.core.parameter.BooleanParameter; //导入依赖的package包/类
/**
 * Change the parameter and return the hastings ratio.
 * Flip (Switch a 0 to 1 or 1 to 0) for a random bit in a bit vector.
 * Return the hastings ratio which makes all subsets of vectors with the same number of 1 bits
 * equiprobable, unless !usesPriorOnSum , then all configurations are equiprobable
 */

@Override
public double proposal() {

    final BooleanParameter p = parameterInput.get(this);

    final int dim = p.getDimension();

    double sum = 0.0;
    if (usesPriorOnSum) {
        for (int i = 0; i < dim; i++) {
            if (p.getValue(i)) sum += 1;
        }
    }

    final int pos = Randomizer.nextInt(dim);

    final boolean value = p.getValue(pos);

    double logq = 0.0;
    if (!value) {
        p.setValue(pos, true);

        if (usesPriorOnSum) {
            logq = -Math.log((dim - sum) / (sum + 1));
        }

    } else {
        //assert value;

        p.setValue(pos, false);
        if (usesPriorOnSum) {
            logq = -Math.log(sum / (dim - sum + 1));
        }
    }
    return logq;
}
 

import beast.core.parameter.BooleanParameter; //导入依赖的package包/类
@Override
public void initAndValidate() {
    List<Function> valuable = functionInput.get();
    mode = Mode.integer_mode;
    for (Function v : valuable) {
     if (!(v instanceof IntegerParameter || v instanceof BooleanParameter)) {
         mode = Mode.double_mode;
     }
    }
}
 

import beast.core.parameter.BooleanParameter; //导入依赖的package包/类
@Test
public void testSum() {
	RealParameter p1 = new RealParameter("1.0 2.0");
	Sum sum = new Sum();
	
	// single argument sum
	sum.initByName("arg", p1);
	double v = sum.getArrayValue();
	assertEquals(3.0, v, 1e-10);
	
	// multiple argument sum
	sum = new Sum();
	RealParameter p2 = new RealParameter("2.0 2.5");
	sum.initByName("arg", p1, "arg", p2);
	v = sum.getArrayValue();
	assertEquals(7.5, v, 1e-10);

	// multiple same argument sum
	sum = new Sum();
	sum.initByName("arg", p1, "arg", p1);
	v = sum.getArrayValue();
	assertEquals(6.0, v, 1e-10);
	
	// sum of integers
	IntegerParameter p3 = new IntegerParameter("1 2 5");
	sum = new Sum();
	sum.initByName("arg", p3);
	v = sum.getArrayValue();
	assertEquals(8.0, v, 1e-10);

	// sum of boolean
	BooleanParameter p4 = new BooleanParameter("true false false true true");
	sum = new Sum();
	sum.initByName("arg", p4);
	v = sum.getArrayValue();
	assertEquals(3.0, v, 1e-10);

	// sum of booleans and integer
	sum = new Sum();
	sum.initByName("arg", p4, "arg", p3);
	v = sum.getArrayValue();
	assertEquals(11.0, v, 1e-10);

	// sum of booleans and real
	sum = new Sum();
	sum.initByName("arg", p1, "arg", p4);
	v = sum.getArrayValue();
	assertEquals(6.0, v, 1e-10);
}
 

import beast.core.parameter.BooleanParameter; //导入依赖的package包/类
private void recalculateScaleFactor() {

        BooleanParameter indicators = indicatorParamInput.get();
        RealParameter rates = rateParamInput.get();

        calculateUnscaledBranchRates(m_tree.getRoot(), 1.0, indicators, rates);

        double timeTotal = 0.0;
        double branchTotal = 0.0;

        for (int i = 0; i < m_tree.getNodeCount(); i++) {
            Node node = m_tree.getNode(i);
            if (!node.isRoot()) {

                double branchInTime = node.getParent().getHeight() - node.getHeight();

                double branchLength = branchInTime * unscaledBranchRates[node.getNr()];

                timeTotal += branchInTime;
                branchTotal += branchLength;
            }
        }

        scaleFactor = timeTotal / branchTotal;

        scaleFactor *= meanRate.getValue();
    }