Apache
/
commons-math
mirror of https://github.com/apache/commons-math.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Tab police

This commit is contained in:
Sebb 2015-01-12 18:54:16 +00:00
parent a14acdf639
commit c4768568c9
6 changed files with 111 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build.xml
View File

@ -245,7 +245,7 @@
doctitle="<h1>${component.title} ${component.version}</h1>" doctitle="<h1>${component.title} ${component.version}</h1>"
windowtitle="${component.title} ${component.version}" windowtitle="${component.title} ${component.version}"
bottom="Copyright (c) 2003-${current.year} Apache Software Foundation" bottom="Copyright (c) 2003-${current.year} Apache Software Foundation"
additionalparam="-header '<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>'" additionalparam="-header '<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>'"
classpathref="compile.classpath"> classpathref="compile.classpath">
<link href="http://java.sun.com/j2se/1.5.0/docs/api/"/> <link href="http://java.sun.com/j2se/1.5.0/docs/api/"/>
</javadoc> </javadoc>

28
src/test/java/org/apache/commons/math3/distribution/AbstractIntegerDistributionTest.java
View File

@ -30,20 +30,20 @@ public class AbstractIntegerDistributionTest {
@Test @Test
public void testInverseCumulativeProbabilityMethod() public void testInverseCumulativeProbabilityMethod()
{ {
double precision = 0.000000000000001; double precision = 0.000000000000001;
Assert.assertEquals(1, diceDistribution.inverseCumulativeProbability(0)); Assert.assertEquals(1, diceDistribution.inverseCumulativeProbability(0));
Assert.assertEquals(1, diceDistribution.inverseCumulativeProbability((1d-Double.MIN_VALUE)/6d)); Assert.assertEquals(1, diceDistribution.inverseCumulativeProbability((1d-Double.MIN_VALUE)/6d));
Assert.assertEquals(2, diceDistribution.inverseCumulativeProbability((1d+precision)/6d)); Assert.assertEquals(2, diceDistribution.inverseCumulativeProbability((1d+precision)/6d));
Assert.assertEquals(2, diceDistribution.inverseCumulativeProbability((2d-Double.MIN_VALUE)/6d)); Assert.assertEquals(2, diceDistribution.inverseCumulativeProbability((2d-Double.MIN_VALUE)/6d));
Assert.assertEquals(3, diceDistribution.inverseCumulativeProbability((2d+precision)/6d)); Assert.assertEquals(3, diceDistribution.inverseCumulativeProbability((2d+precision)/6d));
Assert.assertEquals(3, diceDistribution.inverseCumulativeProbability((3d-Double.MIN_VALUE)/6d)); Assert.assertEquals(3, diceDistribution.inverseCumulativeProbability((3d-Double.MIN_VALUE)/6d));
Assert.assertEquals(4, diceDistribution.inverseCumulativeProbability((3d+precision)/6d)); Assert.assertEquals(4, diceDistribution.inverseCumulativeProbability((3d+precision)/6d));
Assert.assertEquals(4, diceDistribution.inverseCumulativeProbability((4d-Double.MIN_VALUE)/6d)); Assert.assertEquals(4, diceDistribution.inverseCumulativeProbability((4d-Double.MIN_VALUE)/6d));
Assert.assertEquals(5, diceDistribution.inverseCumulativeProbability((4d+precision)/6d)); Assert.assertEquals(5, diceDistribution.inverseCumulativeProbability((4d+precision)/6d));
Assert.assertEquals(5, diceDistribution.inverseCumulativeProbability((5d-precision)/6d));//Can't use Double.MIN Assert.assertEquals(5, diceDistribution.inverseCumulativeProbability((5d-precision)/6d));//Can't use Double.MIN
Assert.assertEquals(6, diceDistribution.inverseCumulativeProbability((5d+precision)/6d)); Assert.assertEquals(6, diceDistribution.inverseCumulativeProbability((5d+precision)/6d));
Assert.assertEquals(6, diceDistribution.inverseCumulativeProbability((6d-precision)/6d));//Can't use Double.MIN Assert.assertEquals(6, diceDistribution.inverseCumulativeProbability((6d-precision)/6d));//Can't use Double.MIN
Assert.assertEquals(6, diceDistribution.inverseCumulativeProbability((6d)/6d)); Assert.assertEquals(6, diceDistribution.inverseCumulativeProbability((6d)/6d));
} }
@Test @Test

40
src/test/java/org/apache/commons/math3/ml/distance/EarthMoversDistanceTest.java
View File

@ -26,25 +26,25 @@ import org.junit.Test;
*/ */
public class EarthMoversDistanceTest { public class EarthMoversDistanceTest {
final DistanceMeasure distance = new EarthMoversDistance(); final DistanceMeasure distance = new EarthMoversDistance();
final double[] a = { 0.1, 0.3, 0.2, 0.0, 0.25, 0.15 }; final double[] a = { 0.1, 0.3, 0.2, 0.0, 0.25, 0.15 };
final double[] b = { 0.3, 0.0, 0.4, 0.1, 0.0, 0.2 }; final double[] b = { 0.3, 0.0, 0.4, 0.1, 0.0, 0.2 };
@Test
public void testZero() {
Assert.assertEquals(0, distance.compute(a, a), 0d);
}
@Test
public void testZero2() {
final double[] zero = new double[] { 0, 0 };
Assert.assertEquals(0, distance.compute(zero, zero), 0d);
}
@Test @Test
public void test() { public void testZero() {
double expected = 0.65; //0.2 + 0.1 + 0.1 + 0.2 + 0.05 + 0.0; Assert.assertEquals(0, distance.compute(a, a), 0d);
Assert.assertEquals(expected, distance.compute(a, b), 1e-10); }
Assert.assertEquals(expected, distance.compute(b, a), 1e-10);
} @Test
public void testZero2() {
final double[] zero = new double[] { 0, 0 };
Assert.assertEquals(0, distance.compute(zero, zero), 0d);
}
@Test
public void test() {
double expected = 0.65; //0.2 + 0.1 + 0.1 + 0.2 + 0.05 + 0.0;
Assert.assertEquals(expected, distance.compute(a, b), 1e-10);
Assert.assertEquals(expected, distance.compute(b, a), 1e-10);
}
} }

30
src/test/java/org/apache/commons/math3/stat/descriptive/SummaryStatisticsTest.java
View File

@ -338,20 +338,20 @@ public class SummaryStatisticsTest {
@Test @Test
public void testToString() { public void testToString() {
SummaryStatistics u = createSummaryStatistics(); SummaryStatistics u = createSummaryStatistics();
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
u.addValue(i); u.addValue(i);
} }
final String[] labels = {"min", "max", "sum", "geometric mean", "variance", final String[] labels = {"min", "max", "sum", "geometric mean", "variance",
"population variance", "second moment", "sum of squares", "standard deviation", "population variance", "second moment", "sum of squares", "standard deviation",
"sum of logs"}; "sum of logs"};
final double[] values = {u.getMin(), u.getMax(), u.getSum(), u.getGeometricMean(), final double[] values = {u.getMin(), u.getMax(), u.getSum(), u.getGeometricMean(),
u.getVariance(), u.getPopulationVariance(), u.getSecondMoment(), u.getSumsq(), u.getVariance(), u.getPopulationVariance(), u.getSecondMoment(), u.getSumsq(),
u.getStandardDeviation(), u.getSumOfLogs()}; u.getStandardDeviation(), u.getSumOfLogs()};
final String toString = u.toString(); final String toString = u.toString();
Assert.assertTrue(toString.indexOf("n: " + u.getN()) > 0); // getN() returns a long Assert.assertTrue(toString.indexOf("n: " + u.getN()) > 0); // getN() returns a long
for (int i = 0; i < values.length; i++) { for (int i = 0; i < values.length; i++) {
Assert.assertTrue(toString.indexOf(labels[i] + ": " + String.valueOf(values[i])) > 0); Assert.assertTrue(toString.indexOf(labels[i] + ": " + String.valueOf(values[i])) > 0);
} }
} }
} }

120
src/userguide/java/org/apache/commons/math3/userguide/genetics/HelloWorldExample.java
View File

@ -38,16 +38,16 @@ import org.apache.commons.math3.util.FastMath;
import org.apache.commons.math3.util.Precision; import org.apache.commons.math3.util.Precision;
public class HelloWorldExample { public class HelloWorldExample {
public static final int POPULATION_SIZE = 1000; public static final int POPULATION_SIZE = 1000;
public static final double CROSSOVER_RATE = 0.9; public static final double CROSSOVER_RATE = 0.9;
public static final double MUTATION_RATE = 0.03; public static final double MUTATION_RATE = 0.03;
public static final double ELITISM_RATE = 0.1; public static final double ELITISM_RATE = 0.1;
public static final int TOURNAMENT_ARITY = 2; public static final int TOURNAMENT_ARITY = 2;
public static final String TARGET_STRING = "Hello World!"; public static final String TARGET_STRING = "Hello World!";
public static final int DIMENSION = TARGET_STRING.length(); public static final int DIMENSION = TARGET_STRING.length();
public static void main(String[] args) { public static void main(String[] args) {
long startTime = System.currentTimeMillis(); long startTime = System.currentTimeMillis();
// initialize a new genetic algorithm // initialize a new genetic algorithm
@ -93,8 +93,8 @@ public class HelloWorldExample {
Chromosome best = finalPopulation.getFittestChromosome(); Chromosome best = finalPopulation.getFittestChromosome();
System.out.println("Generation " + ga.getGenerationsEvolved() + ": " + best.toString()); System.out.println("Generation " + ga.getGenerationsEvolved() + ": " + best.toString());
System.out.println("Total execution time: " + (endTime - startTime) + "ms"); System.out.println("Total execution time: " + (endTime - startTime) + "ms");
} }
private static List<Character> randomRepresentation(int length) { private static List<Character> randomRepresentation(int length) {
return asList(RandomStringUtils.randomAscii(length)); return asList(RandomStringUtils.randomAscii(length));
} }
@ -112,20 +112,20 @@ public class HelloWorldExample {
return new ElitisticListPopulation(popList, 2 * popList.size(), ELITISM_RATE); return new ElitisticListPopulation(popList, 2 * popList.size(), ELITISM_RATE);
} }
/** /**
* String Chromosome represented by a list of characters. * String Chromosome represented by a list of characters.
*/ */
public static class StringChromosome extends AbstractListChromosome<Character> { public static class StringChromosome extends AbstractListChromosome<Character> {
public StringChromosome(List<Character> repr) { public StringChromosome(List<Character> repr) {
super(repr); super(repr);
} }
public StringChromosome(String str) { public StringChromosome(String str) {
this(asList(str)); this(asList(str));
} }
public double fitness() { public double fitness() {
String target = TARGET_STRING; String target = TARGET_STRING;
int f = 0; // start at 0; the best fitness int f = 0; // start at 0; the best fitness
List<Character> chromosome = getRepresentation(); List<Character> chromosome = getRepresentation();
@ -137,51 +137,51 @@ public class HelloWorldExample {
return f; return f;
} }
@Override @Override
protected void checkValidity(List<Character> repr) throws InvalidRepresentationException { protected void checkValidity(List<Character> repr) throws InvalidRepresentationException {
for (char c : repr) { for (char c : repr) {
if (c < 32 || c > 126) { if (c < 32 || c > 126) {
throw new InvalidRepresentationException(LocalizedFormats.INVALID_FIXED_LENGTH_CHROMOSOME); throw new InvalidRepresentationException(LocalizedFormats.INVALID_FIXED_LENGTH_CHROMOSOME);
} }
} }
} }
public List<Character> getStringRepresentation() { public List<Character> getStringRepresentation() {
return getRepresentation(); return getRepresentation();
} }
@Override @Override
public StringChromosome newFixedLengthChromosome(List<Character> repr) { public StringChromosome newFixedLengthChromosome(List<Character> repr) {
return new StringChromosome(repr); return new StringChromosome(repr);
} }
@Override @Override
public String toString() { public String toString() {
StringBuffer sb = new StringBuffer(); StringBuffer sb = new StringBuffer();
for (Character i : getRepresentation()) { for (Character i : getRepresentation()) {
sb.append(i.charValue()); sb.append(i.charValue());
} }
return String.format("(f=%s '%s')", getFitness(), sb.toString()); return String.format("(f=%s '%s')", getFitness(), sb.toString());
} }
} }
private static class RandomCharacterMutation implements MutationPolicy { private static class RandomCharacterMutation implements MutationPolicy {
public Chromosome mutate(Chromosome original) { public Chromosome mutate(Chromosome original) {
if (!(original instanceof StringChromosome)) { if (!(original instanceof StringChromosome)) {
throw new IllegalArgumentException(); throw new IllegalArgumentException();
} }
StringChromosome strChromosome = (StringChromosome) original; StringChromosome strChromosome = (StringChromosome) original;
List<Character> characters = strChromosome.getStringRepresentation(); List<Character> characters = strChromosome.getStringRepresentation();
int mutationIndex = GeneticAlgorithm.getRandomGenerator().nextInt(characters.size()); int mutationIndex = GeneticAlgorithm.getRandomGenerator().nextInt(characters.size());
List<Character> mutatedChromosome = new ArrayList<Character>(characters); List<Character> mutatedChromosome = new ArrayList<Character>(characters);
char newValue = (char) (32 + GeneticAlgorithm.getRandomGenerator().nextInt(127 - 32)); char newValue = (char) (32 + GeneticAlgorithm.getRandomGenerator().nextInt(127 - 32));
mutatedChromosome.set(mutationIndex, newValue); mutatedChromosome.set(mutationIndex, newValue);
return strChromosome.newFixedLengthChromosome(mutatedChromosome); return strChromosome.newFixedLengthChromosome(mutatedChromosome);
} }
} }
} }

2
src/userguide/java/org/apache/commons/math3/userguide/sofm/ChineseRingsClassifier.java
View File

@ -58,7 +58,7 @@ public class ChineseRingsClassifier {
/** Distance function. */ /** Distance function. */
private final DistanceMeasure distance = new EuclideanDistance(); private final DistanceMeasure distance = new EuclideanDistance();
public static void main(String[] args) { public static void main(String[] args) {
final ChineseRings rings = new ChineseRings(new Vector3D(1, 2, 3), final ChineseRings rings = new ChineseRings(new Vector3D(1, 2, 3),
25, 2, 25, 2,
20, 1, 20, 1,