*/ {
33 | /**
34 | * Modify the shape parameter, alpha.
35 | *
36 | * @param alpha the new shape parameter.
37 | * @deprecated as of v2.1
38 | */
39 | @Deprecated
40 | void setAlpha(double alpha);
41 |
42 | /**
43 | * Access the shape parameter, alpha
44 | *
45 | * @return alpha.
46 | */
47 | double getAlpha();
48 |
49 | /**
50 | * Modify the scale parameter, beta.
51 | *
52 | * @param beta the new scale parameter.
53 | * @deprecated as of v2.1
54 | */
55 | @Deprecated
56 | void setBeta(double beta);
57 |
58 | /**
59 | * Access the scale parameter, beta
60 | *
61 | * @return beta.
62 | */
63 | double getBeta();
64 |
65 | /**
66 | * Return the probability density for a particular point.
67 | *
68 | * @param x The point at which the density should be computed.
69 | * @return The pdf at point x.
70 | */
71 | double density(Double x);
72 | }
73 |
--------------------------------------------------------------------------------
/src/org/apache/commons/math/distribution/HasDensity.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more
3 | * contributor license agreements. See the NOTICE file distributed with
4 | * this work for additional information regarding copyright ownership.
5 | * The ASF licenses this file to You under the Apache License, Version 2.0
6 | * (the "License"); you may not use this file except in compliance with
7 | * the License. You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 |
18 | package org.apache.commons.math.distribution;
19 |
20 | import org.apache.commons.math.MathException;
21 |
22 | /**
23 | * Interface that signals that a distribution can compute the probability density function
24 | * for a particular point.
25 | *
26 | * @param
the type of the point at which density is to be computed, this
27 | * may be for example Double.
28 | *
29 | * This interface is deprecated. As of version 2.0, the {@link ContinuousDistribution}
30 | * interface will be extended to include a density(double) method.
31 | * @version $Revision: 924362 $ $Date: 2010-03-17 12:45:31 -0400 (Wed, 17 Mar 2010) $
32 | * @deprecated to be removed in math 3.0
33 | */
34 | @Deprecated
35 | public interface HasDensity {
36 |
37 | /**
38 | * Compute the probability density function.
39 | *
40 | * @param x point for which the probability density is requested
41 | * @return probability density at point x
42 | * @throws MathException if probability density cannot be computed at specifed point
43 | */
44 | double density(P x) throws MathException;
45 |
46 | }
47 |
--------------------------------------------------------------------------------
/src/org/apache/commons/math/distribution/NormalDistribution.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more
3 | * contributor license agreements. See the NOTICE file distributed with
4 | * this work for additional information regarding copyright ownership.
5 | * The ASF licenses this file to You under the Apache License, Version 2.0
6 | * (the "License"); you may not use this file except in compliance with
7 | * the License. You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 |
18 | package org.apache.commons.math.distribution;
19 |
20 | /**
21 | * Normal (Gauss) Distribution.
22 | *
23 | *
24 | * References:
25 | *
29 | *
30 | *
31 | * @version $Revision: 920852 $ $Date: 2010-03-09 07:53:44 -0500 (Tue, 09 Mar 2010) $
32 | */
33 | public interface NormalDistribution extends ContinuousDistribution /*, HasDensity*/ {
34 | /**
35 | * Access the mean.
36 | *
37 | * @return mean for this distribution
38 | */
39 | double getMean();
40 |
41 | /**
42 | * Modify the mean.
43 | *
44 | * @param mean for this distribution
45 | * @deprecated as of v2.1
46 | */
47 | @Deprecated
48 | void setMean(double mean);
49 |
50 | /**
51 | * Access the standard deviation.
52 | *
53 | * @return standard deviation for this distribution
54 | */
55 | double getStandardDeviation();
56 |
57 | /**
58 | * Modify the standard deviation.
59 | *
60 | * @param sd standard deviation for this distribution
61 | * @deprecated as of v2.1
62 | */
63 | @Deprecated
64 | void setStandardDeviation(double sd);
65 |
66 | /**
67 | * Return the probability density for a particular point.
68 | *
69 | * @param x The point at which the density should be computed.
70 | * @return The pdf at point x.
71 | */
72 | double density(Double x);
73 | }
74 |
--------------------------------------------------------------------------------
/src/org/apache/commons/math/distribution/PoissonDistribution.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more
3 | * contributor license agreements. See the NOTICE file distributed with
4 | * this work for additional information regarding copyright ownership.
5 | * The ASF licenses this file to You under the Apache License, Version 2.0
6 | * (the "License"); you may not use this file except in compliance with
7 | * the License. You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 | package org.apache.commons.math.distribution;
18 |
19 | import org.apache.commons.math.MathException;
20 |
21 | /**
22 | * Interface representing the Poisson Distribution.
23 | *
24 | *
25 | * References:
26 | *
30 | *
31 | *
32 | * @version $Revision: 920852 $ $Date: 2010-03-09 07:53:44 -0500 (Tue, 09 Mar 2010) $
33 | */
34 | public interface PoissonDistribution extends IntegerDistribution {
35 |
36 | /**
37 | * Get the mean for the distribution.
38 | *
39 | * @return the mean for the distribution.
40 | */
41 | double getMean();
42 |
43 | /**
44 | * Set the mean for the distribution.
45 | * The parameter value must be positive; otherwise an
46 | * IllegalArgument is thrown.
47 | *
48 | * @param p the mean
49 | * @throws IllegalArgumentException if p ≤ 0
50 | * @deprecated as of v2.1
51 | */
52 | @Deprecated
53 | void setMean(double p);
54 |
55 | /**
56 | * Calculates the Poisson distribution function using a normal approximation.
57 | *
58 | * @param x the upper bound, inclusive
59 | * @return the distribution function value calculated using a normal approximation
60 | * @throws MathException if an error occurs computing the normal approximation
61 | */
62 | double normalApproximateProbability(int x) throws MathException;
63 |
64 | }
65 |
--------------------------------------------------------------------------------
/src/org/apache/commons/math/distribution/TDistribution.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more
3 | * contributor license agreements. See the NOTICE file distributed with
4 | * this work for additional information regarding copyright ownership.
5 | * The ASF licenses this file to You under the Apache License, Version 2.0
6 | * (the "License"); you may not use this file except in compliance with
7 | * the License. You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 | package org.apache.commons.math.distribution;
18 |
19 | /**
20 | * Student's t-Distribution.
21 | *
22 | *
23 | * References:
24 | *
28 | *
29 | *
30 | * @version $Revision: 920852 $ $Date: 2010-03-09 07:53:44 -0500 (Tue, 09 Mar 2010) $
31 | */
32 | public interface TDistribution extends ContinuousDistribution {
33 | /**
34 | * Modify the degrees of freedom.
35 | *
36 | * @param degreesOfFreedom the new degrees of freedom.
37 | * @deprecated as of v2.1
38 | */
39 | @Deprecated
40 | void setDegreesOfFreedom(double degreesOfFreedom);
41 |
42 | /**
43 | * Access the degrees of freedom.
44 | *
45 | * @return the degrees of freedom.
46 | */
47 | double getDegreesOfFreedom();
48 | }
49 |
--------------------------------------------------------------------------------
/src/org/apache/commons/math/distribution/WeibullDistribution.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Licensed to the Apache Software Foundation (ASF) under one or more
3 | * contributor license agreements. See the NOTICE file distributed with
4 | * this work for additional information regarding copyright ownership.
5 | * The ASF licenses this file to You under the Apache License, Version 2.0
6 | * (the "License"); you may not use this file except in compliance with
7 | * the License. You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 |
18 | package org.apache.commons.math.distribution;
19 |
20 | /**
21 | * Weibull Distribution. This interface defines the two parameter form of the
22 | * distribution as defined by
23 | *
24 | * Weibull Distribution, equations (1) and (2).
25 | *
26 | *
27 | * References:
28 | *
32 | *
33 | *
34 | * @version $Revision: 920852 $ $Date: 2010-03-09 07:53:44 -0500 (Tue, 09 Mar 2010) $
35 | * @since 1.1
36 | */
37 | public interface WeibullDistribution extends ContinuousDistribution {
38 |
39 | /**
40 | * Access the shape parameter.
41 | *
42 | * @return the shape parameter.
43 | */
44 | double getShape();
45 |
46 | /**
47 | * Access the scale parameter.
48 | *
49 | * @return the scale parameter.
50 | */
51 | double getScale();
52 |
53 | /**
54 | * Modify the shape parameter.
55 | *
56 | * @param alpha The new shape parameter value.
57 | * @deprecated as of v2.1
58 | */
59 | @Deprecated
60 | void setShape(double alpha);
61 |
62 | /**
63 | * Modify the scale parameter.
64 | *
65 | * @param beta The new scale parameter value.
66 | * @deprecated as of v2.1
67 | */
68 | @Deprecated
69 | void setScale(double beta);
70 | }
71 |
--------------------------------------------------------------------------------
/src/org/json/JSONException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2010 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package org.json;
18 |
19 | // Note: this class was written without inspecting the non-free org.json sourcecode.
20 |
21 | /**
22 | * Thrown to indicate a problem with the JSON API. Such problems include:
23 | *
24 | * - Attempts to parse or construct malformed documents
25 | *
- Use of null as a name
26 | *
- Use of numeric types not available to JSON, such as {@link
27 | * Double#isNaN() NaNs} or {@link Double#isInfinite() infinities}.
28 | *
- Lookups using an out of range index or nonexistent name
29 | *
- Type mismatches on lookups
30 | *
31 | *
32 | * Although this is a checked exception, it is rarely recoverable. Most
33 | * callers should simply wrap this exception in an unchecked exception and
34 | * rethrow:
35 | *
public JSONArray toJSONObject() {
36 | * try {
37 | * JSONObject result = new JSONObject();
38 | * ...
39 | * } catch (JSONException e) {
40 | * throw new RuntimeException(e);
41 | * }
42 | * }
43 | */
44 | public class JSONException extends Exception {
45 |
46 | private static final long serialVersionUID = 1L;
47 |
48 | public JSONException(String s) {
49 | super(s);
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/test/test/beast/beast2vs1/trace/TraceException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * TraceException.java
3 | *
4 | * Copyright (C) 2002-2006 Alexei Drummond and Andrew Rambaut
5 | *
6 | * This file is part of BEAST.
7 | * See the NOTICE file distributed with this work for additional
8 | * information regarding copyright ownership and licensing.
9 | *
10 | * BEAST is free software; you can redistribute it and/or modify
11 | * it under the terms of the GNU Lesser General Public License as
12 | * published by the Free Software Foundation; either version 2
13 | * of the License, or (at your option) any later version.
14 | *
15 | * BEAST is distributed in the hope that it will be useful,
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 | * GNU Lesser General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU Lesser General Public
21 | * License along with BEAST; if not, write to the
22 | * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
23 | * Boston, MA 02110-1301 USA
24 | */
25 |
26 | package test.beast.beast2vs1.trace;
27 |
28 | /**
29 | * An exception for traces
30 | *
31 | * @author Andrew Rambaut
32 | * @author Alexei Drummond
33 | */
34 |
35 | public class TraceException extends Exception {
36 | private static final long serialVersionUID = 1L;
37 |
38 | public TraceException() {
39 | super();
40 | }
41 |
42 | public TraceException(String message) {
43 | super(message);
44 | }
45 | }
--------------------------------------------------------------------------------
/test/test/beast/beast2vs1/trace/TraceType.java:
--------------------------------------------------------------------------------
1 | package test.beast.beast2vs1.trace;
2 |
3 | /**
4 | * @author Alexei Drummond
5 | * @author Walter Xie
6 | */
7 | public enum TraceType {
8 | DOUBLE("double", "D", Double.class),
9 | INTEGER("integer", "I", Integer.class),
10 | STRING("string", "S", String.class);
11 |
12 | TraceType(String name, String brief, Class type) {
13 | this.name = name;
14 | this.brief = brief;
15 | this.type = type;
16 | }
17 |
18 | @Override
19 | public String toString() {
20 | return name;
21 | }
22 |
23 | public String getBrief() {
24 | return brief;
25 | }
26 |
27 | public Class getType() {
28 | return type;
29 | }
30 |
31 | private final String name;
32 | private final String brief;
33 | private final Class type;
34 | }
35 |
--------------------------------------------------------------------------------
/test/test/beast/core/PrimitiveInterface.java:
--------------------------------------------------------------------------------
1 | package test.beast.core;
2 |
3 |
4 | import beast.base.core.BEASTObject;
5 | import beast.base.core.Description;
6 | import beast.base.core.Param;
7 |
8 | @Description("PrimitiveInterface is used for testing inner class inside interface")
9 | public interface PrimitiveInterface {
10 |
11 |
12 | @Description("InterfaceInnerClass is used for testing inner class inside interface")
13 | public class InterfaceInnerClass extends BEASTObject implements PrimitiveInterface {
14 | private int i;
15 |
16 | public InterfaceInnerClass(@Param(name="i", description="input of primitive type") int i) {
17 | this.i = i;
18 | }
19 |
20 | public InterfaceInnerClass() {}
21 |
22 | @Override
23 | public void initAndValidate() {
24 | }
25 |
26 | public int getI() {
27 | return i;
28 | }
29 | public void setI(int i) {
30 | this.i = i;
31 | }
32 |
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/test/test/beast/core/StateNodeInitialiserTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.core;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 |
5 | import org.junit.jupiter.api.Test;
6 |
7 | import beast.base.evolution.alignment.Alignment;
8 | import beast.base.evolution.tree.ClusterTree;
9 | import beast.base.evolution.tree.Tree;
10 | import beast.base.evolution.tree.TreeParser;
11 |
12 | import test.beast.BEASTTestCase;
13 |
14 | public class StateNodeInitialiserTest {
15 |
16 | @Test
17 | public void testClusterTree() throws Exception {
18 | Alignment data = BEASTTestCase.getAlignment();
19 | Tree tree = new Tree();
20 | tree.initAndValidate();
21 | assertEquals(true, tree.getNodeCount() == 1);
22 |
23 | TreeParser tree2 = new TreeParser();
24 | tree2.initByName(
25 | "initial", tree,
26 | "taxa", data,
27 | "newick", "((((human:0.024003,(chimp:0.010772,bonobo:0.010772):0.013231):0.012035,gorilla:0.036038):0.033087000000000005,orangutan:0.069125):0.030456999999999998,siamang:0.099582);",
28 | "IsLabelledNewick", true);
29 |
30 | assertEquals(true, tree.getNodeCount() > 1);
31 | assertEquals(11, tree.getNodeCount());
32 | }
33 |
34 | @Test
35 | public void testNewickTree() throws Exception {
36 | Alignment data = BEASTTestCase.getAlignment();
37 | Tree tree = new Tree();
38 | tree.initAndValidate();
39 | assertEquals(true, tree.getNodeCount() == 1);
40 |
41 | ClusterTree tree2 = new ClusterTree();
42 | tree2.initByName(
43 | "initial", tree,
44 | "clusterType", "upgma",
45 | "taxa", data);
46 | assertEquals(true, tree.getNodeCount() > 1);
47 | assertEquals(11, tree.getNodeCount());
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/test/test/beast/core/util/SumTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.core.util;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 |
5 | import org.junit.jupiter.api.Test;
6 |
7 | import beast.base.evolution.Sum;
8 | import beast.base.inference.parameter.BooleanParameter;
9 | import beast.base.inference.parameter.IntegerParameter;
10 | import beast.base.inference.parameter.RealParameter;
11 |
12 |
13 | public class SumTest {
14 |
15 |
16 | @Test
17 | public void testSum() {
18 | RealParameter p1 = new RealParameter("1.0 2.0");
19 | Sum sum = new Sum();
20 |
21 | // single argument sum
22 | sum.initByName("arg", p1);
23 | double v = sum.getArrayValue();
24 | assertEquals(3.0, v, 1e-10);
25 |
26 | // multiple argument sum
27 | sum = new Sum();
28 | RealParameter p2 = new RealParameter("2.0 2.5");
29 | sum.initByName("arg", p1, "arg", p2);
30 | v = sum.getArrayValue();
31 | assertEquals(7.5, v, 1e-10);
32 |
33 | // multiple same argument sum
34 | sum = new Sum();
35 | sum.initByName("arg", p1, "arg", p1);
36 | v = sum.getArrayValue();
37 | assertEquals(6.0, v, 1e-10);
38 |
39 | // sum of integers
40 | IntegerParameter p3 = new IntegerParameter("1 2 5");
41 | sum = new Sum();
42 | sum.initByName("arg", p3);
43 | v = sum.getArrayValue();
44 | assertEquals(8.0, v, 1e-10);
45 |
46 | // sum of boolean
47 | BooleanParameter p4 = new BooleanParameter("true false false true true");
48 | sum = new Sum();
49 | sum.initByName("arg", p4);
50 | v = sum.getArrayValue();
51 | assertEquals(3.0, v, 1e-10);
52 |
53 | // sum of booleans and integer
54 | sum = new Sum();
55 | sum.initByName("arg", p4, "arg", p3);
56 | v = sum.getArrayValue();
57 | assertEquals(11.0, v, 1e-10);
58 |
59 | // sum of booleans and real
60 | sum = new Sum();
61 | sum.initByName("arg", p1, "arg", p4);
62 | v = sum.getArrayValue();
63 | assertEquals(6.0, v, 1e-10);
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/datatype/DataTypeDeEncodeTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.evolution.datatype;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 |
5 | import java.util.Arrays;
6 | import java.util.List;
7 |
8 | import org.junit.jupiter.api.Test;
9 | import beast.base.evolution.datatype.Aminoacid;
10 | import beast.base.evolution.datatype.Binary;
11 | import beast.base.evolution.datatype.IntegerData;
12 | import beast.base.evolution.datatype.Nucleotide;
13 | import beast.base.evolution.datatype.TwoStateCovarion;
14 | import beast.base.evolution.datatype.DataType.Base;
15 |
16 | public class DataTypeDeEncodeTest {
17 |
18 | @Test
19 | public void testDataTypeDeEncode() {
20 | Base dAa = new Aminoacid();
21 | Base dBi = new Binary();
22 | Base dIn = new IntegerData();
23 | Base dNt = new Nucleotide();
24 | Base d2C = new TwoStateCovarion();
25 |
26 | for (Object [] o : Arrays.asList(new Object[][] {
27 | { dIn, "1,2,14,23,?", Arrays.asList(new Integer[] { 1, 2, 14, 23, -1 }) },
28 | { dNt, "ACGTURYMWSKBDHVNX", Arrays.asList(
29 | new Integer[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }) },
30 | { dBi, "01-?10", Arrays.asList(new Integer[] { 0, 1, 2, 3, 1, 0 }) },
31 | { d2C, "01ABCD-?", Arrays.asList(new Integer[] { 0, 1, 2, 3, 4, 5, 6, 7 }) },
32 | { dAa, "ACDEFGHIKLMNPQRSTVWY", Arrays.asList(
33 | new Integer[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }) }
34 | })) {
35 | Base d = (Base) o[0];
36 | String s = (String) o[1];
37 | List c = (List) o[2];
38 | // o.testStingToEncoding();
39 | assertEquals(c, d.stringToEncoding(s));
40 | //o.testRoundTrip();
41 | assertEquals(s, d.encodingToString(d.stringToEncoding(s)));
42 | }
43 | }
44 |
45 | }
46 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/datatype/IntegerDataTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.evolution.datatype;
2 |
3 | import org.junit.jupiter.api.Test;
4 |
5 | import beast.base.evolution.datatype.IntegerData;
6 | import beast.base.util.Randomizer;
7 | import static org.junit.jupiter.api.Assertions.assertEquals;;
8 |
9 | public class IntegerDataTest {
10 |
11 |
12 | @Test
13 | public void testIntegerData() {
14 | IntegerData datatype = new IntegerData();
15 | assertEquals("?", datatype.getCharacter(-1));
16 | assertEquals("0", datatype.getCharacter(0));
17 | assertEquals("1", datatype.getCharacter(1));
18 | assertEquals("10", datatype.getCharacter(10));
19 | assertEquals("123", datatype.getCharacter(123));
20 | Randomizer.setSeed(127);
21 | for (int i = 0; i < 100; i++) {
22 | int state = Randomizer.nextInt(100000000);
23 | int x = state;
24 | String str = "";
25 | while (state > 0) {
26 | str = (char)('0' + state%10) + str;
27 | state /= 10;
28 | }
29 | assertEquals(str, datatype.getCharacter(x));
30 | }
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/likelihood/BeagleTreeLikelihoodTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.evolution.likelihood;
2 |
3 | import beast.base.evolution.likelihood.TreeLikelihood;
4 |
5 | public class BeagleTreeLikelihoodTest extends TreeLikelihoodTest {
6 |
7 | @Override
8 | protected TreeLikelihood newTreeLikelihood() {
9 | System.err.println("==============================================================================================================");
10 | System.err.println("==============================================================================================================");
11 | System.err.println("== Make sure to have BEAGLE installed and set the -Djava.library.path=/path/to/beagle option for this test. ==");
12 | System.err.println("==============================================================================================================");
13 | System.err.println("==============================================================================================================");
14 | System.setProperty("java.only", "false");
15 | return new TreeLikelihood();
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/operator/CompoundParameterHelperTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.evolution.operator;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | import org.junit.jupiter.api.Test;
7 |
8 | import beast.base.inference.operator.CompoundParameterHelper;
9 | import beast.base.inference.parameter.RealParameter;
10 | import static org.junit.jupiter.api.Assertions.assertEquals;
11 |
12 | public class CompoundParameterHelperTest {
13 |
14 |
15 | @Test
16 | public void testCompoundParameterHelper() {
17 | RealParameter p1 = new RealParameter("1.0 2.0");
18 | RealParameter p2 = new RealParameter("3.0 4.0 5.0");
19 | List list = new ArrayList<>();
20 | list.add(p1);
21 | list.add(p2);
22 |
23 | CompoundParameterHelper cph = new CompoundParameterHelper(list);
24 |
25 | // prints 5
26 | System.out.println("Dim = " + cph.getDimension());
27 | // results in java.lang.ArrayIndexOutOfBoundsException: 2
28 | for (int i = 0; i < cph.getDimension(); i++) {
29 | System.out.println("value[" + i + "] = " +cph.getValue(i));
30 | }
31 |
32 | assertEquals(5, cph.getDimension());
33 | for (int i = 0; i < 4; i++) {
34 | assertEquals(i+1.0, cph.getValue(i), 1e-15);
35 | }
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/operator/DeltaExchangeOperatorTest.java:
--------------------------------------------------------------------------------
1 | /**
2 | *
3 | */
4 | package test.beast.evolution.operator;
5 |
6 | import static org.junit.jupiter.api.Assertions.assertEquals;
7 |
8 | import org.junit.jupiter.api.Test;
9 |
10 | import beast.base.inference.State;
11 | import beast.base.inference.operator.DeltaExchangeOperator;
12 | import beast.base.inference.parameter.IntegerParameter;
13 | import beast.base.inference.parameter.RealParameter;
14 |
15 | /**
16 | * @author gereon
17 | *
18 | */
19 | public class DeltaExchangeOperatorTest extends TestOperator {
20 |
21 | @Test
22 | public void testKeepsSum() {
23 | DeltaExchangeOperator operator = new DeltaExchangeOperator();
24 | RealParameter parameter = new RealParameter(new Double[] {1., 1., 1., 1.});
25 | register(operator,
26 | "parameter", parameter);
27 | for (int i=0; i<100; ++i) {
28 | operator.proposal();
29 | }
30 | double i = 0;
31 | for (Double p : parameter.getValues()) {
32 | i += p;
33 | }
34 | assertEquals(i, 4, 0.00001, "The DeltaExchangeOperator should not change the sum of a parameter");
35 | }
36 |
37 | @Test
38 | public void testKeepsWeightedSum() {
39 | RealParameter parameter = new RealParameter(new Double[] {1., 1., 1., 1.});
40 | register(new DeltaExchangeOperator(),
41 | "weightvector", new IntegerParameter(new Integer[] {0, 1, 2, 1}),
42 | "parameter", parameter);
43 | Double[] p = parameter.getValues();
44 | assertEquals(0*p[1]+1*p[1]+2*p[2]+1*p[3], 4, 0.00001,
45 | "The DeltaExchangeOperator should not change the sum of a parameter");
46 | }
47 |
48 | @Test
49 | public void testCanOperate() {
50 | // Test whether a validly initialised operator may make proposals
51 | State state = new State();
52 | RealParameter parameter = new RealParameter(new Double[] { 1., 1., 1., 1. });
53 | state.initByName("stateNode", parameter);
54 | state.initialise();
55 | DeltaExchangeOperator d = new DeltaExchangeOperator();
56 | // An invalid operator should either fail in initByName or make valid
57 | // proposals
58 | try {
59 | d.initByName("parameter", parameter, "weight", 1.0);
60 | } catch (RuntimeException e) {
61 | return;
62 | }
63 | d.proposal();
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/operator/ScaleOperatorTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.evolution.operator;
2 |
3 | import org.junit.jupiter.api.Test;
4 |
5 | import beast.base.evolution.operator.ScaleOperator;
6 | import beast.base.evolution.tree.Node;
7 | import beast.base.evolution.tree.TreeParser;
8 | import static org.junit.jupiter.api.Assertions.assertEquals;
9 |
10 | public class ScaleOperatorTest {
11 | final static double EPSILON = 1e-10;
12 |
13 |
14 | @Test
15 | public void testTreeScaling() {
16 | String newick = "((0:1.0,1:1.0)4:1.0,(2:1.0,3:1.0)5:0.5)6:0.0;";
17 |
18 | TreeParser tree = new TreeParser(newick, false, false, false, 0);
19 |
20 | Node [] node = tree.getNodesAsArray();
21 |
22 | ScaleOperator operator = new ScaleOperator();
23 | operator.initByName("tree", tree, "weight", 1.0);
24 | operator.proposal();
25 |
26 | // leaf node
27 | node = tree.getNodesAsArray();
28 | assertEquals(0.0, node[0].getHeight(), EPSILON);
29 | assertEquals(0.0, node[1].getHeight(), EPSILON);
30 | // leaf node, not scaled
31 | assertEquals(0.5, node[2].getHeight(), EPSILON);
32 | assertEquals(0.5, node[3].getHeight(), EPSILON);
33 |
34 | // internal nodes, all scaled
35 | // first determine scale factor
36 | double scale = node[4].getHeight() / 1.0;
37 | assertEquals(1.0 * scale, node[4].getHeight(), EPSILON);
38 | assertEquals(1.5 * scale, node[5].getHeight(), EPSILON);
39 | assertEquals(2.0 * scale, node[6].getHeight(), EPSILON);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/operator/TestOperator.java:
--------------------------------------------------------------------------------
1 | /**
2 | *
3 | */
4 | package test.beast.evolution.operator;
5 |
6 | import java.util.ArrayList;
7 | import java.util.HashMap;
8 |
9 | import beast.base.inference.Operator;
10 | import beast.base.inference.State;
11 | import beast.base.inference.StateNode;
12 | import static org.junit.jupiter.api.Assertions.assertEquals;
13 |
14 | /**
15 | * @author gereon
16 | *
17 | */
18 | public abstract class TestOperator {
19 |
20 | static public void register(Operator operator, final Object... operands) {
21 | HashMap operandsMap;
22 | operandsMap = new HashMap();
23 | if (operands.length % 2 == 1) {
24 | throw new RuntimeException("Expected even number of arguments, name-value pairs");
25 | }
26 | for (int i = 0; i < operands.length; i += 2) {
27 | if (operands[i] instanceof String) {
28 | final String name = (String) operands[i];
29 | if (operands[i + 1] instanceof StateNode) {
30 | final StateNode node = (StateNode) operands[i + 1];
31 | operandsMap.put(name, node);
32 | } else {
33 | throw new IllegalArgumentException("Expected a StateNode in " + (i + 1) + "th argument ");
34 | }
35 | } else {
36 | throw new IllegalArgumentException("Expected a String in " + i + "th argument ");
37 | }
38 | }
39 | State state = new State();
40 | state.initByName("stateNode", new ArrayList(operandsMap.values()));
41 | state.initialise();
42 | Object[] operandsAndWeight = new Object[operands.length + 2];
43 | for (int i = 0; i < operands.length; ++i) {
44 | operandsAndWeight[i] = operands[i];
45 | }
46 | operandsAndWeight[operands.length] = "weight";
47 | operandsAndWeight[operands.length + 1] = "1";
48 | operator.initByName(operandsAndWeight);
49 | operator.validateInputs();
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/tree/TreeTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.evolution.tree;
2 |
3 | import org.junit.jupiter.api.Test;
4 |
5 | import beast.base.evolution.tree.Node;
6 | import beast.base.evolution.tree.TreeParser;
7 | import static org.junit.jupiter.api.Assertions.assertEquals;
8 |
9 | public class TreeTest {
10 | final static double EPSILON = 1e-10;
11 |
12 | @Test
13 | public void testTreeScaling() {
14 | String newick = "((0:1.0,1:1.0)4:1.0,(2:1.0,3:1.0)5:0.5)6:0.0;";
15 |
16 | TreeParser treeParser = new TreeParser(newick, false, false, false, 0);
17 |
18 | Node [] node = treeParser.getNodesAsArray();
19 | assertEquals(0.0, node[0].getHeight(), EPSILON);
20 | assertEquals(0.0, node[1].getHeight(), EPSILON);
21 | // leaf node, not scaled
22 | assertEquals(0.5, node[2].getHeight(), EPSILON);
23 | assertEquals(0.5, node[3].getHeight(), EPSILON);
24 | // internal nodes, all scaled
25 | assertEquals(1.0, node[4].getHeight(), EPSILON);
26 | assertEquals(1.5, node[5].getHeight(), EPSILON);
27 | assertEquals(2.0, node[6].getHeight(), EPSILON);
28 |
29 | treeParser.scale(2.0);
30 |
31 | // leaf node
32 | node = treeParser.getNodesAsArray();
33 | assertEquals(0.0, node[0].getHeight(), EPSILON);
34 | assertEquals(0.0, node[1].getHeight(), EPSILON);
35 | // leaf node, not scaled
36 | assertEquals(0.5, node[2].getHeight(), EPSILON);
37 | assertEquals(0.5, node[3].getHeight(), EPSILON);
38 | // internal nodes, all scaled
39 | assertEquals(2.0, node[4].getHeight(), EPSILON);
40 | assertEquals(3.0, node[5].getHeight(), EPSILON);
41 | assertEquals(4.0, node[6].getHeight(), EPSILON);
42 |
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/tree/TreeUtilsTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.evolution.tree;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 | import org.junit.jupiter.api.Test;
5 |
6 | import beast.base.evolution.tree.TreeParser;
7 | import beast.base.evolution.tree.TreeUtils;
8 |
9 | /**
10 | * Test class for TreeUtils methods
11 | */
12 | public class TreeUtilsTest {
13 |
14 | @Test
15 | public void testSortTreeAlphabetically() {
16 |
17 | String newick = "((D:5.0,C:4.0):6.0,(A:1.0,B:2.0):3.0):0.0;";
18 |
19 | TreeParser treeParser = new TreeParser();
20 | treeParser.initByName("IsLabelledNewick", true,
21 | "newick", newick,
22 | "adjustTipHeights", false);
23 |
24 |
25 | TreeUtils.rotateTreeAlphabetically(treeParser.getRoot());
26 |
27 | String result = treeParser.getRoot().toNewick();
28 | String goal = "((A:1.0,B:2.0):3.0,(C:4.0,D:5.0):6.0):0.0";
29 |
30 | assertEquals(goal, result);
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/tree/coalescent/BayesianSkylineTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.evolution.tree.coalescent;
2 |
3 |
4 | import org.junit.jupiter.api.Test;
5 |
6 | import beast.base.evolution.tree.Tree;
7 | import beast.base.evolution.tree.TreeIntervals;
8 | import beast.base.evolution.tree.coalescent.BayesianSkyline;
9 | import static org.junit.jupiter.api.Assertions.assertEquals;
10 |
11 |
12 |
13 | /**
14 | * @author Alexei Drummond
15 | */
16 | public class BayesianSkylineTest {
17 |
18 | @Test
19 | public void testSkyline() throws Exception {
20 |
21 | //RealParameter popSize = new RealParameter("1.0", 0.0, 10.0, 2);
22 | //IntegerParameter groupSize = new IntegerParameter("2", 1, 4, 2);
23 |
24 | //popSize.setValue(1, 2.0);
25 |
26 | Tree tree = new Tree("(((1:1,2:1):2.5,(3:1.5,4:1.5):2):2,5:5.5);");
27 | TreeIntervals intervals = new TreeIntervals(tree);
28 |
29 | BayesianSkyline skyline = new BayesianSkyline();
30 | //skyline.init(popSize, groupSize, intervals);
31 | skyline.initByName("popSizes", "1.0 2.0",
32 | "groupSizes", "2 2",
33 | "treeIntervals", intervals);
34 |
35 | assertEquals(skyline.getPopSize(0.01), 1.0);
36 | assertEquals(skyline.getPopSize(1.49), 1.0);
37 | assertEquals(skyline.getPopSize(1.51), 2.0);
38 | assertEquals(skyline.getPopSize(5.51), 2.0);
39 |
40 | }
41 |
42 | }
43 |
--------------------------------------------------------------------------------
/test/test/beast/evolution/tree/coalescent/CoalescentTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.evolution.tree.coalescent;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 |
5 | import org.junit.jupiter.api.BeforeEach;
6 |
7 | import beast.base.evolution.alignment.Alignment;
8 | import beast.base.evolution.tree.Tree;
9 | import beast.base.evolution.tree.TreeIntervals;
10 | import beast.base.evolution.tree.coalescent.Coalescent;
11 | import beast.base.evolution.tree.coalescent.ConstantPopulation;
12 | import test.beast.BEASTTestCase;
13 |
14 | /**
15 | * @author Alexei Drummond
16 | * @author Walter Xie
17 | */
18 | public class CoalescentTest extends BEASTTestCase {
19 | String[] trees = new String[]{"((A:1.0,B:1.0):1.0,C:2.0);", ""}; //more trees ?
20 | Alignment data;
21 | final double pop = 10000;
22 |
23 | @BeforeEach
24 | protected void setUp() throws Exception {
25 | //super.setUp();
26 | data = getFourTaxaNoData();
27 | }
28 |
29 | public void testConstantPopulation() throws Exception {
30 | // *********** 3 taxon **********
31 | Tree tree = getTree(data, trees[0]);
32 | TreeIntervals treeIntervals = new TreeIntervals();
33 | treeIntervals.initByName("tree", tree);
34 |
35 | ConstantPopulation cp = new ConstantPopulation();
36 | cp.initByName("popSize", Double.toString(pop));
37 |
38 | Coalescent coal = new Coalescent();
39 | coal.initByName("treeIntervals", treeIntervals, "populationModel", cp);
40 |
41 | double logL = coal.calculateLogP();
42 |
43 | assertEquals(logL, -(4 / pop) - 2 * Math.log(pop), PRECISION);
44 |
45 | // *********** 4 taxon **********
46 | // tree = getTree(data, trees[1]);
47 | // treeIntervals = new TreeIntervals();
48 | // treeIntervals.initByName("tree", tree);
49 | //
50 | // cp = new ConstantPopulation();
51 | // cp.initByName("popSize", Double.toString(pop));
52 | //
53 | // coal = new Coalescent();
54 | // coal.initByName("treeIntervals", treeIntervals, "populationModel", cp);
55 | //
56 | // logL = coal.calculateLogP();
57 | //
58 | // assertEquals(logL, -(4 / pop) - 2 * Math.log(pop), PRECISION);
59 |
60 | }
61 |
62 | public void testExponentialGrowth() throws Exception {
63 |
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/test/test/beast/util/RandomizerTest.java:
--------------------------------------------------------------------------------
1 | package test.beast.util;
2 |
3 | import org.junit.jupiter.api.Test;
4 |
5 | import beast.base.util.DiscreteStatistics;
6 | import beast.base.util.Randomizer;
7 |
8 | import static org.junit.jupiter.api.Assertions.assertEquals;
9 |
10 | public class RandomizerTest {
11 |
12 | @Test
13 | public void logNormalTest() {
14 |
15 | Randomizer.setSeed(1);
16 |
17 | double M1=1, M2=0, S=0.5;
18 |
19 | int reps=10000000;
20 |
21 | double [] vals1 = new double[reps];
22 | double [] vals2 = new double[reps];
23 |
24 | for (int i=0; i taxa = new ArrayList<>();
27 | taxa.add(new Taxon("first one"));
28 | taxa.add(new Taxon("second one"));
29 |
30 | AnnotatedRunnableTestClass t = new AnnotatedRunnableTestClass(3, taxa);
31 | BEASTClassLoader.addService(BEASTInterface.class.getName(), AnnotatedRunnableTestClass.class.getName(), "BEAST.base");
32 |
33 | XMLProducer producer = new XMLProducer();
34 | String xml = producer.toXML(t);
35 |
36 | assertEquals(3, (int) t.getParam1());
37 |
38 |
39 | FileWriter outfile = new FileWriter(new File("/tmp/XMLTest.xml"));
40 | outfile.write(xml);
41 | outfile.close();
42 |
43 |
44 | XMLParser parser = new XMLParser();
45 | BEASTInterface b = parser.parseFile(new File("/tmp/XMLTest.xml"));
46 | assertEquals(3, (int) ((AnnotatedRunnableTestClass) b).getParam1());
47 | assertEquals(2, ((AnnotatedRunnableTestClass) b).getTaxon().size());
48 | }
49 |
50 | @Test
51 | public void testVariableReplacement() {
52 |
53 | String stringWithVariables = "$(one) $(two) $(three=3)";
54 |
55 | Map variableDefs = new HashMap<>();
56 |
57 | XMLParserUtils.extractVariableDefaultsFromString(stringWithVariables, variableDefs);
58 |
59 | assertEquals(1, variableDefs.size());
60 | assertTrue(variableDefs.containsKey("three"));
61 | assertTrue(variableDefs.containsValue("3"));
62 |
63 | String modifiedString = XMLParserUtils.replaceVariablesInString(stringWithVariables, variableDefs);
64 | assertEquals("$(one) $(two) 3", modifiedString);
65 | }
66 | }
67 |
--------------------------------------------------------------------------------