Java Randomizer类代码示例

import beast.util.Randomizer; //导入依赖的package包/类
@Test
public void testScaleWithInt() throws Exception {
    Randomizer.setSeed(1);

    XMLParser parser = new XMLParser();
    beast.core.Runnable runnable = parser.parseFile(
            new File("test/epiinf/xmltests/ScaleWithIntTest.xml"));
    Logger.FILE_MODE = Logger.LogFileMode.overwrite;
    runnable.run();


    List<Expectation> expectations = new ArrayList<>();
    expectations.add(new Expectation("x1", 0.5, 0.01));
    expectations.add(new Expectation("y1", 0.5, 0.01));
    expectations.add(new Expectation("y2", 0.5, 0.01));
    expectations.add(new Expectation("y3", 0.5, 0.01));
    expectations.add(new Expectation("n", 50.0, 1.0));
    LogAnalyser logAnalyser = new LogAnalyser("ScaleWithIntTest.log", expectations);

    try {
        for (Expectation expectation : expectations) {
            assertTrue(expectation.isValid());
            assertTrue(expectation.isPassed());
        }
    } catch (Exception e) {
        throw e;

    } finally {
        Files.deleteIfExists(Paths.get("ScaleWithIntTest.xml.state"));
        Files.deleteIfExists(Paths.get("ScaleWithIntTest.log"));
    }
}
 

import beast.util.Randomizer; //导入依赖的package包/类
@Test
public void test2Taxon() throws Exception {
    Randomizer.setSeed(1);

    XMLParser parser = new XMLParser();
    beast.core.Runnable runnable = parser.parseFile(
            new File("examples/ACGsimulations/simulateACGs2taxon.xml"));
    runnable.run();

    List<Expectation> expectations = new ArrayList<>();
    expectations.add(new Expectation("acg.CFheight", 1.0, 1e-2));
    expectations.add(new Expectation("acg.CFlength", 2.0, 1e-2));
    expectations.add(new Expectation("acg.nConv", 10.0, 5e-2));

    LogAnalyser logAnalyser = new LogAnalyser("simulateACGs2taxon.stats",
            expectations);

    for (int i=0; i<expectations.size(); i++) {
        assertTrue(expectations.get(i).isValid());
        assertTrue(expectations.get(i).isPassed());
    }

    Files.deleteIfExists(Paths.get("simulateACGs2taxon.stats"));
    Files.deleteIfExists(Paths.get("simulateACGs2taxon.converted"));
    Files.deleteIfExists(Paths.get("simulateACGs2taxon.trees"));
}
 

import beast.util.Randomizer; //导入依赖的package包/类
@Test
public void testShortMultiLocus() throws Exception {
    Randomizer.setSeed(1);

    XMLParser parser = new XMLParser();
    beast.core.Runnable runnable = parser.parseFile(
            new File("examples/allOperatorTests/allOperatorTestShortSSML.xml"));
    disableScreenLog(runnable);
    runnable.run();

    List<Expectation> expectations = new ArrayList<>();
    expectations.add(new Expectation("acg.CFheight", 1.601, 0.2));
    expectations.add(new Expectation("acg.CFlength", 4.17, 0.5));
    expectations.add(new Expectation("acg.nConv", 39.61, 0.5));

    LogAnalyser logAnalyser = new LogAnalyser("allOperatorTestShortSSML.stats",
            expectations);

    for (Expectation expectation : expectations) {
        assertTrue(expectation.isValid());
        assertTrue(expectation.isPassed());
    }

    Files.deleteIfExists(Paths.get("allOperatorTestShortSSML.stats"));
    Files.deleteIfExists(Paths.get("allOperatorTestShortSSML.converted"));
    Files.deleteIfExists(Paths.get("allOperatorTestShortSSML.trees"));
    Files.deleteIfExists(Paths.get("allOperatorTestShortSSML.cf"));
    Files.deleteIfExists(Paths.get("allOperatorTestShortSSML.xml.state"));
}
 

import beast.util.Randomizer; //导入依赖的package包/类
protected int getRandomBirthIndex(String s, int births) {
	if (births == 0) {
		return -1;
	} else if (births  == 1) {
		return s.indexOf('1');
	}
	int tmp;
	int[] indices = new int[s.length()]; 
	for (int i = 0; i < s.length(); ++i) indices[i] = i;

	for (int i = 0; i < s.length(); i++) {
		int j = Randomizer.nextInt(indices.length - i) + i;
		if (j != i) { // swap to shuffle
			tmp = indices[i];
			indices[i] = indices[j];
			indices[j] = tmp;
		}
		if ((s.charAt(indices[i]) == '1')) {
			return indices[i];
		}
	}
	return -1;
}
 

import beast.util.Randomizer; //导入依赖的package包/类
public Sequence mutateLang(Sequence l, double T) throws Exception {
	Sequence newLang = new Sequence("", l.getData());
	for (int i = 0; i < newLang.getData().length(); i++) {
		int currentTrait = (int) newLang.getData().charAt(i);
		// Mutations are exponentially distributed.
		double t = Randomizer.nextExponential(rate);
		String newSeq;
		while (t < T) {
			currentTrait = Character.getNumericValue(newLang.getData().charAt(i));
			// In binary model, a mutation switches trait.
			// If death: check NoEmptyTrait.
			if (1 - currentTrait == 0) {
				if (noEmptyTraitCheck(newLang)) {
					newSeq = replaceCharAt(newLang.getData(), i, Integer.toString((1 - currentTrait)));
				} else {
					newSeq = newLang.getData();
				}
			} else {
				newSeq = replaceCharAt(newLang.getData(), i, Integer.toString((1 - currentTrait)));
			}
			newLang.dataInput.setValue(newSeq, newLang);
			t += Randomizer.nextExponential(rate);
		}
	}
	return newLang;
}
 

import beast.util.Randomizer; //导入依赖的package包/类
private static void GTRTreeValidation() throws Exception {
	ArrayList<Integer> births = new ArrayList<Integer>();
	for (int i = 0; i < 10000; i++) {
		System.out.println(i);
		ExplicitBinaryGTR gtr_mod = new ExplicitBinaryGTR(0.5, 0.0, 0.0, false);
		String seq = "";
		for (int j = 0; j < 20; j++) {
			seq += Integer.toString(Randomizer.nextInt(2));
		}
		Sequence l = new Sequence("", seq);
		Tree tree = randomYuleTree(8, 0.001);
		tree.getRoot().setMetaData("lang", l);
		tree = gtr_mod.mutateOverTree(tree);
		for (Node n : tree.getExternalNodes()) {
			Sequence l2 = (Sequence) n.getMetaData("lang");
			births.add(LanguageSubsitutionModel.getBirths(l2));
		}

	}
	listToCSV(births, "Utilities/Thesis Graph Generation/gtrtree.csv");
}
 

import beast.util.Randomizer; //导入依赖的package包/类
private boolean pickNarrow() {
    zNode = speciesTreeNodes[nLeafNodes + Randomizer.nextInt(nInternalNodes)];
    while (zNode.getLeft().isLeaf() && zNode.getRight().isLeaf()) {
        zNode = speciesTreeNodes[nLeafNodes + Randomizer.nextInt(nInternalNodes)];
    }

    yNode = zNode.getLeft();
    cNode = zNode.getRight();
    if (yNode.getHeight() < cNode.getHeight()) {
        yNode = zNode.getRight();
        cNode = zNode.getLeft();
    }

    if (yNode.isLeaf()) {
        return false;
    } else if (Randomizer.nextBoolean()) {
        aNode = yNode.getLeft();
        bNode = yNode.getRight();
    } else {
        aNode = yNode.getRight();
        bNode = yNode.getLeft();
    }

    return true;
}
 

import beast.util.Randomizer; //导入依赖的package包/类
protected int[] chooseK(final int n) {
    final int[] sequential = new int[n];

    for (int i = 0; i < n; i++) sequential[i] = i;

    for (int i = 0; i < discreteK; i++) {
        final int j = Randomizer.nextInt(n - i);
        if (j > 0) { // swap [i] with [i + j]
            final int i_temp = sequential[i];
            final int iplusj = i + j;
            sequential[i] = sequential[iplusj];
            sequential[iplusj] = i_temp;
        }
    }

    return sequential;
}
 

import beast.util.Randomizer; //导入依赖的package包/类
@Override
public double proposal() {
    Tree tree = treeInput.get(this);

    // randomly select leaf node
    int i = Randomizer.nextInt(taxonIndices.length);
    Node node = tree.getNode(taxonIndices[i]);
    double upper = node.getParent().getHeight();
    //double lower = 0.0;
    //final double newValue = (Randomizer.nextDouble() * (upper -lower)) + lower;

    // scale node
    double scale = (scaleFactor + (Randomizer.nextDouble() * ((1.0 / scaleFactor) - scaleFactor)));
    final double newValue = node.getHeight() * scale;

    // check the tree does not get negative branch lengths
    if (newValue > upper) {
        return Double.NEGATIVE_INFINITY;
    }
    node.setHeight(newValue);

    return -Math.log(scale);
}
 

import beast.util.Randomizer; //导入依赖的package包/类
/**
 * override this for proposals,
 * returns log of hastingRatio, or Double.NEGATIVE_INFINITY if proposal should not be accepted *
 */
@Override
public double proposal() {

    final IntegerParameter param = parameterInput.get(this);

    final int i = Randomizer.nextInt(param.getDimension());
    final int value = param.getValue(i);
    final int newValue = value + Randomizer.nextInt(2 * windowSize + 1) - windowSize;

    if (newValue < param.getLower() || newValue > param.getUpper()) {
        // invalid move, can be rejected immediately
        return Double.NEGATIVE_INFINITY;
    }
    if (newValue == value) {
        // this saves calculating the posterior
        return Double.NEGATIVE_INFINITY;
    }

    param.setValue(i, newValue);

    return 0.0;
}
 

import beast.util.Randomizer; //导入依赖的package包/类
/**
 * change the parameter and return the hastings ratio.
 *
 * @return log of Hastings Ratio, or Double.NEGATIVE_INFINITY if proposal should not be accepted *
 */
@Override
public double proposal() {
    final Tree tree = treeInput.get(this);

    // randomly select internal node
    final int nodeCount = tree.getNodeCount();
    
    // Abort if no non-root internal nodes
    if (tree.getInternalNodeCount()==1)
        return Double.NEGATIVE_INFINITY;
    
    Node node;
    do {
        final int nodeNr = nodeCount / 2 + 1 + Randomizer.nextInt(nodeCount / 2);
        node = tree.getNode(nodeNr);
    } while (node.isRoot() || node.isLeaf());
    final double upper = node.getParent().getHeight();
    final double lower = Math.max(node.getLeft().getHeight(), node.getRight().getHeight());
    final double newValue = (Randomizer.nextDouble() * (upper - lower)) + lower;
    node.setHeight(newValue);

    return 0.0;
}
 

import beast.util.Randomizer; //导入依赖的package包/类
/**
 * perform the actual sequence generation
 *
 * @return alignment containing randomly generated sequences for the nodes in the
 *         leaves of the tree
 */
public void simulate() {
    Node root = m_tree.getRoot();


    double[] categoryProbs = m_siteModel.getCategoryProportions(root);
    int[] category = new int[m_sequenceLength];
    for (int i = 0; i < m_sequenceLength; i++) {
        category[i] = Randomizer.randomChoicePDF(categoryProbs);
    }

    double[] frequencies = m_siteModel.getSubstitutionModel().getFrequencies();
    int[] seq = new int[m_sequenceLength];
    for (int i = 0; i < m_sequenceLength; i++) {
        seq[i] = Randomizer.randomChoicePDF(frequencies);
    }


    //alignment.setDataType(m_siteModel.getFrequencyModel().getDataType());

    traverse(root, seq, category);

}
 

import beast.util.Randomizer; //导入依赖的package包/类
/**
 * recursively walk through the tree top down, and add sequence to alignment whenever
 * a leave node is reached.
 *
 * @param node           reference to the current node, for which we visit all children
 * @param parentSequence randomly generated sequence of the parent node
 * @param category       array of categories for each of the sites
 * @param alignment
 */
void traverse(Node node, int[] parentSequence, int[] category) {
    for (int childIndex = 0; childIndex < 2; childIndex++) {
        Node child = (childIndex == 0 ? node.getLeft() : node.getRight());
        for (int i = 0; i < m_categoryCount; i++) {
            getTransitionProbabilities(m_tree, child, i, m_probabilities[i]);
        }

        int[] seq = new int[m_sequenceLength];
        double[] cProb = new double[m_stateCount];
        for (int i = 0; i < m_sequenceLength; i++) {
            System.arraycopy(m_probabilities[category[i]], parentSequence[i] * m_stateCount, cProb, 0, m_stateCount);
            seq[i] = Randomizer.randomChoicePDF(cProb);
        }

        if (child.isLeaf()) {
            sequenceInput.setValue(intArray2Sequence(seq, child), this);
        } else {
            traverse(child, seq, category);
        }
    }
}
 

import beast.util.Randomizer; //导入依赖的package包/类
/**
 * recursively walk through the tree top down, and add sequence to alignment whenever
 * a leave node is reached.
 *
 * @param node           reference to the current node, for which we visit all children
 * @param parentSequence randomly generated sequence of the parent node
 * @param category       array of categories for each of the sites
 * @param alignment
 * @
 */
void traverse(Node node, int[] parentSequence, int[] category, Alignment alignment)  {
    for (int childIndex = 0; childIndex < 2; childIndex++) {
        Node child = (childIndex == 0 ? node.getLeft() : node.getRight());
        for (int i = 0; i < m_categoryCount; i++) {
            getTransitionProbabilities(m_tree, child, i, m_probabilities[i]);
        }

        int[] seq = new int[m_sequenceLength];
        double[] cProb = new double[m_stateCount];
        for (int i = 0; i < m_sequenceLength; i++) {
            System.arraycopy(m_probabilities[category[i]], parentSequence[i] * m_stateCount, cProb, 0, m_stateCount);
            seq[i] = Randomizer.randomChoicePDF(cProb);
        }

        if (child.isLeaf()) {
            alignment.sequenceInput.setValue(intArray2Sequence(seq, child), alignment);
        } else {
            traverse(child, seq, category, alignment);
        }
    }
}
 

import beast.util.Randomizer; //导入依赖的package包/类
public void testPdf() {

        System.out.println("Testing 10000 random pdf calls");

        for (int i = 0; i < 10000; i++) {
            double M = Randomizer.nextDouble() * 10.0 - 5.0;
            double S = Randomizer.nextDouble() * 10;

            double x = Randomizer.nextDouble() * 10;

            norm.meanInput.setValue(M + "", norm);
            norm.sigmaInput.setValue(S + "", norm);
            norm.initAndValidate();
            
            double a = 1.0 / (Math.sqrt(2.0 * Math.PI) * S);
            double b = -(x - M) * (x - M) / (2.0 * S * S);
            double pdf =  a * Math.exp(b);

            assertEquals(pdf, norm.density(x), 1e-10);
        }

        /* Test with an example using R */
        norm.meanInput.setValue(2.835202292812448 + "", norm);
        norm.sigmaInput.setValue(3.539139491639669 + "", norm);
        assertEquals(0.1123318, norm.density(2.540111), 1e-6);
    }