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

added support for generation and analysis of random vectors 

git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/math/trunk@512039 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Luc Maisonobe 2007-02-26 22:22:53 +00:00
parent 2a4219105e
commit 15d96cbafd
21 changed files with 688 additions and 948 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
src/java/org/apache/commons/math/random/GaussianRandomGenerator.java Normal file
View File

@ -0,0 +1,45 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.apache.commons.math.random;
/** This class is a gaussian normalized random generator for scalars.
* <p>This class is a simple wrapper around the {@link
* RandomGenerator#nextGaussian} method.</p>
* @version $Revision:$ $Date$
*/
public class GaussianRandomGenerator implements NormalizedRandomGenerator {
/** Create a new generator.
* @param generator underlying random generator to use
*/
public GaussianRandomGenerator(RandomGenerator generator) {
this.generator = generator;
}
/** Generate a random scalar with null mean and unit standard deviation.
* @return a random scalar with null mean and unit standard deviation
*/
public double nextNormalizedDouble() {
return generator.nextGaussian();
}
/** Underlying generator. */
private RandomGenerator generator;
}

16
src/mantissa/src/org/spaceroots/mantissa/random/NormalizedRandomGenerator.java → src/java/org/apache/commons/math/random/NormalizedRandomGenerator.java
View File

@ -15,26 +15,22 @@
// specific language governing permissions and limitations // specific language governing permissions and limitations
// under the License. // under the License.
package org.spaceroots.mantissa.random; package org.apache.commons.math.random;
import java.io.Serializable;
/** This interface represent a normalized random generator for /** This interface represent a normalized random generator for
* scalars. * scalars.
* Normalized generator should provide null mean and unit standard * Normalized generator provide null mean and unit standard deviation scalars.
* deviation scalars. * @version $Revision:$ $Date$
* @version $Id: NormalizedRandomGenerator.java 1705 2006-09-17 19:57:39Z luc $
* @author L. Maisonobe
*/ */
public interface NormalizedRandomGenerator extends Serializable { public interface NormalizedRandomGenerator {
/** Generate a random scalar with null mean and unit standard deviation. /** Generate a random scalar with null mean and unit standard deviation.
* <p>This method does <strong>not</strong> specify the shape of the * <p>This method does <strong>not</strong> specify the shape of the
* distribution, it is the implementing class that provides it. The * distribution, it is the implementing class that provides it. The
* only contract here is to generate numbers with null mean and unit * only contract here is to generate numbers with null mean and unit
* standard deviation.</p> * standard deviation.</p>
* @return a random scalar * @return a random scalar with null mean and unit standard deviation
*/ */
public double nextDouble(); public double nextNormalizedDouble();
} }

34
src/mantissa/tests-src/org/spaceroots/mantissa/random/UniformRandomGeneratorTest.java → src/java/org/apache/commons/math/random/NotPositiveDefiniteMatrixException.java
View File

@ -15,29 +15,25 @@
// specific language governing permissions and limitations // specific language governing permissions and limitations
// under the License. // under the License.
package org.spaceroots.mantissa.random; package org.apache.commons.math.random;
import junit.framework.*; import org.apache.commons.math.MathException;
public class UniformRandomGeneratorTest /** This class represents exceptions thrown by the correlated random
extends TestCase { * vector generator.
* @version $Revision:$ $Date$
*/
public UniformRandomGeneratorTest(String name) { public class NotPositiveDefiniteMatrixException extends MathException {
super(name);
}
public void testMeanAndStandardDeviation() { /** Serializable version identifier */
UniformRandomGenerator generator = new UniformRandomGenerator(17399225432l); private static final long serialVersionUID = 4122929125438624648L;
ScalarSampleStatistics sample = new ScalarSampleStatistics();
for (int i = 0; i < 1000; ++i) { /** Simple constructor.
sample.add(generator.nextDouble()); * build an exception with a default message.
*/
public NotPositiveDefiniteMatrixException() {
super("not positive definite matrix", new Object[0]);
} }
assertEquals(0.0, sample.getMean(), 0.07);
assertEquals(1.0, sample.getStandardDeviation(), 0.02);
}
public static Test suite() {
return new TestSuite(UniformRandomGeneratorTest.class);
}
} }

7
src/mantissa/src/org/spaceroots/mantissa/random/RandomVectorGenerator.java → src/java/org/apache/commons/math/random/RandomVectorGenerator.java
View File

@ -15,7 +15,7 @@
// specific language governing permissions and limitations // specific language governing permissions and limitations
// under the License. // under the License.
package org.spaceroots.mantissa.random; package org.apache.commons.math.random;
/** This interface represent a random generator for whole vectors. /** This interface represent a random generator for whole vectors.
@ -27,10 +27,7 @@ package org.spaceroots.mantissa.random;
public interface RandomVectorGenerator { public interface RandomVectorGenerator {
/** Generate a random vector. /** Generate a random vector.
* @return a random vector as an array of double. The generator * @return a random vector as an array of double.
* <em>will</em> reuse the same array for each call, in order to
* save the allocation time, so the user should keep a copy by
* himself if he needs so.
*/ */
public double[] nextVector(); public double[] nextVector();

48
src/mantissa/src/org/spaceroots/mantissa/random/UncorrelatedRandomVectorGenerator.java → src/java/org/apache/commons/math/random/UncorrelatedRandomVectorGenerator.java
View File

@ -15,42 +15,34 @@
// specific language governing permissions and limitations // specific language governing permissions and limitations
// under the License. // under the License.
package org.spaceroots.mantissa.random; package org.apache.commons.math.random;
import java.io.Serializable; import java.util.Arrays;
/** This class allows to generate random vectors with uncorrelated components. /** This class allows to generate random vectors with uncorrelated components.
* @version $Id:$
* @version $Id: UncorrelatedRandomVectorGenerator.java 1705 2006-09-17 19:57:39Z luc $
* @author L. Maisonobe
*/ */
public class UncorrelatedRandomVectorGenerator public class UncorrelatedRandomVectorGenerator
implements Serializable, RandomVectorGenerator { implements RandomVectorGenerator {
/** Simple constructor. /** Simple constructor.
* <p>Build an uncorrelated random vector generator from its mean * <p>Build an uncorrelated random vector generator from
* and standard deviation vectors.</p> * its mean and standard deviation vectors.</p>
* @param mean expected mean values for all components * @param mean expected mean values for each component
* @param standardDeviation standard deviation for all components * @param standardDeviation standard deviation for each component
* @param generator underlying generator for uncorrelated normalized * @param generator underlying generator for uncorrelated normalized
* components * components
* @exception IllegalArgumentException if there is a dimension
* mismatch between the mean and standard deviation vectors
*/ */
public UncorrelatedRandomVectorGenerator(double[] mean, public UncorrelatedRandomVectorGenerator(double[] mean,
double[] standardDeviation, double[] standardDeviation,
NormalizedRandomGenerator generator) { NormalizedRandomGenerator generator) {
if (mean.length != standardDeviation.length) { if (mean.length != standardDeviation.length) {
throw new IllegalArgumentException("dimension mismatch"); throw new IllegalArgumentException("dimension mismatch");
} }
this.mean = (double[]) mean.clone(); this.mean = (double[]) mean.clone();
this.standardDeviation = (double[]) standardDeviation.clone(); this.standardDeviation = (double[]) standardDeviation.clone();
this.generator = generator; this.generator = generator;
} }
/** Simple constructor. /** Simple constructor.
@ -62,34 +54,20 @@ public class UncorrelatedRandomVectorGenerator
*/ */
public UncorrelatedRandomVectorGenerator(int dimension, public UncorrelatedRandomVectorGenerator(int dimension,
NormalizedRandomGenerator generator) { NormalizedRandomGenerator generator) {
mean = new double[dimension]; mean = new double[dimension];
standardDeviation = new double[dimension]; standardDeviation = new double[dimension];
for (int i = 0; i < dimension; ++i) { Arrays.fill(standardDeviation, 1.0);
mean[i] = 0;
standardDeviation[i] = 1;
}
this.generator = generator; this.generator = generator;
}
/** Get the underlying normalized components generator.
* @return underlying uncorrelated components generator
*/
public NormalizedRandomGenerator getGenerator() {
return generator;
} }
/** Generate a correlated random vector. /** Generate a correlated random vector.
* @return a random vector as an array of double. The returned array * @return a random vector as a newly built array of double
* is created at each call, the caller can do what it wants with it.
*/ */
public double[] nextVector() { public double[] nextVector() {
double[] random = new double[mean.length]; double[] random = new double[mean.length];
for (int i = 0; i < random.length; ++i) { for (int i = 0; i < random.length; ++i) {
random[i] = mean[i] + standardDeviation[i] * generator.nextDouble(); random[i] = mean[i] + standardDeviation[i] * generator.nextNormalizedDouble();
} }
return random; return random;
@ -103,8 +81,6 @@ public class UncorrelatedRandomVectorGenerator
private double[] standardDeviation; private double[] standardDeviation;
/** Underlying scalar generator. */ /** Underlying scalar generator. */
NormalizedRandomGenerator generator; private NormalizedRandomGenerator generator;
private static final long serialVersionUID = -9094322067568302961L;
} }

50
src/java/org/apache/commons/math/random/UniformRandomGenerator.java Normal file
View File

@ -0,0 +1,50 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.apache.commons.math.random;
/** This class implements a normalized uniform random generator.
* <p>Since it is a normalized random generator, it has a null mean
* and a unit standard deviation. Being also a uniform
* generator, it produces numbers in the range [-&sqrt;(3) ; +&sqrt;(3)].</p>
* @version $Revision:$ $Date$
*/
public class UniformRandomGenerator implements NormalizedRandomGenerator {
/** Create a new generator.
* @param generator underlying random generator to use
*/
public UniformRandomGenerator(RandomGenerator generator) {
this.generator = generator;
}
/** Generate a random scalar with null mean and unit standard deviation.
* <p>The number generated is uniformly distributed between -&sqrt;(3)
* and +&sqrt;(3).</p>
* @return a random scalar with null mean and unit standard deviation
*/
public double nextNormalizedDouble() {
return SQRT3 * (2 * generator.nextDouble() - 1.0);
}
/** Underlying generator. */
private RandomGenerator generator;
private static final double SQRT3 = Math.sqrt(3.0);
}

105
src/java/org/apache/commons/math/stat/descriptive/moment/VectorialCovariance.java Normal file
View File

@ -0,0 +1,105 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math.stat.descriptive.moment;
import java.io.Serializable;
import org.apache.commons.math.DimensionMismatchException;
import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.linear.RealMatrixImpl;
/**
* Returns the covariance matrix of the available vectors.
* @version $Revision:$
*/
public class VectorialCovariance implements Serializable {
/** Serializable version identifier */
private static final long serialVersionUID = 4118372414238930270L;
/** Sums for each component. */
private double[] sums;
/** Sums of products for each component. */
private double[] productsSums;
/** Number of vectors in the sample. */
private long n;
/** Constructs a VectorialMean.
* @param dimension vectors dimension
*/
public VectorialCovariance(int dimension) {
sums = new double[dimension];
productsSums = new double[dimension * (dimension + 1) / 2];
n = 0;
}
/**
* Add a new vector to the sample.
* @param vector vector to add
* @exception DimensionMismatchException if the vector does not have the right dimension
*/
public void increment(double[] v) throws DimensionMismatchException {
if (v.length != sums.length) {
throw new DimensionMismatchException(v.length, sums.length);
}
int k = 0;
for (int i = 0; i < v.length; ++i) {
sums[i] += v[i];
for (int j = 0; j <= i; ++j) {
productsSums[k++] += v[i] * v[j];
}
}
n++;
}
/**
* Get the covariance matrix.
* @return covariance matrix
*/
public RealMatrix getResult() {
int dimension = sums.length;
RealMatrixImpl result = new RealMatrixImpl(dimension, dimension);
if (n > 1) {
double[][] resultData = result.getDataRef();
double c = 1.0 / (n * (n - 1));
int k = 0;
for (int i = 0; i < dimension; ++i) {
for (int j = 0; j <= i; ++j) {
double e = c * (n * productsSums[k++] - sums[i] * sums[j]);
resultData[i][j] = e;
resultData[j][i] = e;
}
}
}
return result;
}
/**
* Get the number of vectors in the sample.
* @return number of vectors in the sample
*/
public long getN() {
return n;
}
}

79
src/java/org/apache/commons/math/stat/descriptive/moment/VectorialMean.java Normal file
View File

@ -0,0 +1,79 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math.stat.descriptive.moment;
import java.io.Serializable;
import org.apache.commons.math.DimensionMismatchException;
/**
* Returns the arithmetic mean of the available vectors.
* @version $Revision:$
*/
public class VectorialMean implements Serializable {
/** Serializable version identifier */
private static final long serialVersionUID = 8223009086481006892L;
/** Means for each component. */
private Mean[] means;
/** Constructs a VectorialMean.
* @param dimension vectors dimension
*/
public VectorialMean(int dimension) {
means = new Mean[dimension];
for (int i = 0; i < dimension; ++i) {
means[i] = new Mean();
}
}
/**
* Add a new vector to the sample.
* @param vector vector to add
* @exception DimensionMismatchException if the vector does not have the right dimension
*/
public void increment(double[] v) throws DimensionMismatchException {
if (v.length != means.length) {
throw new DimensionMismatchException(v.length, means.length);
}
for (int i = 0; i < v.length; ++i) {
means[i].increment(v[i]);
}
}
/**
* Get the mean vector.
* @return mean vector
*/
public double[] getResult() {
double[] result = new double[means.length];
for (int i = 0; i < result.length; ++i) {
result[i] = means[i].getResult();
}
return result;
}
/**
* Get the number of vectors in the sample.
* @return number of vectors in the sample
*/
public long getN() {
return (means.length == 0) ? 0 : means[0].getN();
}
}

281
src/mantissa/src/org/spaceroots/mantissa/random/CorrelatedRandomVectorGenerator.java
View File

@ -1,281 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.spaceroots.mantissa.random;
import org.spaceroots.mantissa.MantissaException;
import org.spaceroots.mantissa.linalg.Matrix;
import org.spaceroots.mantissa.linalg.GeneralMatrix;
import org.spaceroots.mantissa.linalg.SymetricalMatrix;
import java.io.Serializable;
/** This class allows to generate random vectors with correlated components.
* <p>Random vectors with correlated components are built by combining
* the uncorrelated components of another random vector in such a way
* the resulting correlations are the ones specified by a positive
* definite covariance matrix.</p>
* <p>Sometimes, the covariance matrix for a given simulation is not
* strictly positive definite. This means that the correlations are
* not all independant from each other. In this case, however, the non
* strictly positive elements found during the Cholesky decomposition
* of the covariance matrix should not be negative either, they
* should be null. This implies that rather than computing <code>C =
* L.Lt</code> where <code>C</code> is the covariance matrix and
* <code>L</code> is a lower-triangular matrix, we compute <code>C =
* B.Bt</code> where <code>B</code> is a rectangular matrix having
* more rows than columns. The number of columns of <code>B</code> is
* the rank of the covariance matrix, and it is the dimension of the
* uncorrelated random vector that is needed to compute the component
* of the correlated vector. This class does handle this situation
* automatically.</p>
* @version $Id: CorrelatedRandomVectorGenerator.java 1705 2006-09-17 19:57:39Z luc $
* @author L. Maisonobe
*/
public class CorrelatedRandomVectorGenerator
implements Serializable, RandomVectorGenerator {
/** Simple constructor.
* <p>Build a correlated random vector generator from its mean
* vector and covariance matrix.</p>
* @param mean expected mean values for all components
* @param covariance covariance matrix
* @param generator underlying generator for uncorrelated normalized
* components
* @exception IllegalArgumentException if there is a dimension
* mismatch between the mean vector and the covariance matrix
* @exception NotPositiveDefiniteMatrixException if the
* covariance matrix is not strictly positive definite
*/
public CorrelatedRandomVectorGenerator(double[] mean,
SymetricalMatrix covariance,
NormalizedRandomGenerator generator)
throws NotPositiveDefiniteMatrixException {
int order = covariance.getRows();
if (mean.length != order) {
String message =
MantissaException.translate("dimension mismatch {0} != {1}",
new String[] {
Integer.toString(mean.length),
Integer.toString(order)
});
throw new IllegalArgumentException(message);
}
this.mean = (double[]) mean.clone();
factorize(covariance);
this.generator = generator;
normalized = new double[rank];
}
/** Simple constructor.
* <p>Build a null mean random correlated vector generator from its
* covariance matrix.</p>
* @param covariance covariance matrix
* @param generator underlying generator for uncorrelated normalized
* components
* @exception NotPositiveDefiniteMatrixException if the
* covariance matrix is not strictly positive definite
*/
public CorrelatedRandomVectorGenerator(SymetricalMatrix covariance,
NormalizedRandomGenerator generator)
throws NotPositiveDefiniteMatrixException {
int order = covariance.getRows();
mean = new double[order];
for (int i = 0; i < order; ++i) {
mean[i] = 0;
}
factorize(covariance);
this.generator = generator;
normalized = new double[rank];
}
/** Get the root of the covariance matrix.
* The root is the matrix <code>B</code> such that <code>B.Bt</code>
* is equal to the covariance matrix
* @return root of the square matrix
*/
public Matrix getRootMatrix() {
return root;
}
/** Get the underlying normalized components generator.
* @return underlying uncorrelated components generator
*/
public NormalizedRandomGenerator getGenerator() {
return generator;
}
/** Get the rank of the covariance matrix.
* The rank is the number of independant rows in the covariance
* matrix, it is also the number of columns of the rectangular
* matrix of the factorization.
* @return rank of the square matrix.
*/
public int getRank() {
return rank;
}
/** Factorize the original square matrix.
* @param covariance covariance matrix
* @exception NotPositiveDefiniteMatrixException if the
* covariance matrix is not strictly positive definite
*/
private void factorize(SymetricalMatrix covariance)
throws NotPositiveDefiniteMatrixException {
int order = covariance.getRows();
SymetricalMatrix c = (SymetricalMatrix) covariance.duplicate();
GeneralMatrix b = new GeneralMatrix(order, order);
int[] swap = new int[order];
int[] index = new int[order];
for (int i = 0; i < order; ++i) {
index[i] = i;
}
rank = 0;
for (boolean loop = true; loop;) {
// find maximal diagonal element
swap[rank] = rank;
for (int i = rank + 1; i < order; ++i) {
if (c.getElement(index[i], index[i])
> c.getElement(index[swap[i]], index[swap[i]])) {
swap[rank] = i;
}
}
// swap elements
if (swap[rank] != rank) {
int tmp = index[rank];
index[rank] = index[swap[rank]];
index[swap[rank]] = tmp;
}
// check diagonal element
if (c.getElement(index[rank], index[rank]) < 1.0e-12) {
if (rank == 0) {
throw new NotPositiveDefiniteMatrixException();
}
// check remaining diagonal elements
for (int i = rank; i < order; ++i) {
if (c.getElement(index[rank], index[rank]) < -1.0e-12) {
// there is at least one sufficiently negative diagonal element,
// the covariance matrix is wrong
throw new NotPositiveDefiniteMatrixException();
}
}
// all remaining diagonal elements are close to zero,
// we consider we have found the rank of the covariance matrix
++rank;
loop = false;
} else {
// transform the matrix
double sqrt = Math.sqrt(c.getElement(index[rank], index[rank]));
b.setElement(rank, rank, sqrt);
double inverse = 1 / sqrt;
for (int i = rank + 1; i < order; ++i) {
double e = inverse * c.getElement(index[i], index[rank]);
b.setElement(i, rank, e);
c.setElement(index[i], index[i],
c.getElement(index[i], index[i]) - e * e);
for (int j = rank + 1; j < i; ++j) {
double f = b.getElement(j, rank);
c.setElementAndSymetricalElement(index[i], index[j],
c.getElement(index[i], index[j])
- e * f);
}
}
// prepare next iteration
loop = ++rank < order;
}
}
// build the root matrix
root = new GeneralMatrix(order, rank);
for (int i = 0; i < order; ++i) {
for (int j = 0; j < rank; ++j) {
root.setElement(swap[i], j, b.getElement(i, j));
}
}
}
/** Generate a correlated random vector.
* @return a random vector as an array of double. The returned array
* is created at each call, the caller can do what it wants with it.
*/
public double[] nextVector() {
// generate uncorrelated vector
for (int i = 0; i < rank; ++i) {
normalized[i] = generator.nextDouble();
}
// compute correlated vector
double[] correlated = new double[mean.length];
for (int i = 0; i < correlated.length; ++i) {
correlated[i] = mean[i];
for (int j = 0; j < rank; ++j) {
correlated[i] += root.getElement(i, j) * normalized[j];
}
}
return correlated;
}
/** Mean vector. */
private double[] mean;
/** Permutated Cholesky root of the covariance matrix. */
private Matrix root;
/** Rank of the covariance matrix. */
private int rank;
/** Underlying generator. */
NormalizedRandomGenerator generator;
/** Storage for the normalized vector. */
private double[] normalized;
private static final long serialVersionUID = -88563624902398453L;
}

69
src/mantissa/src/org/spaceroots/mantissa/random/GaussianRandomGenerator.java
View File

@ -1,69 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.spaceroots.mantissa.random;
import java.util.Random;
/** This class is a gaussian normalized random generator
* for scalars.
* <p>This class is a simple interface adaptor around the {@link
* java.util.Random#nextGaussian nextGaussian} method.</p>
* @version $Id: GaussianRandomGenerator.java 1705 2006-09-17 19:57:39Z luc $
* @author L. Maisonobe
*/
public class GaussianRandomGenerator
implements NormalizedRandomGenerator {
/** Create a new generator.
* The seed of the generator is related to the current time.
*/
public GaussianRandomGenerator() {
generator = new Random();
}
/** Creates a new random number generator using a single int seed.
* @param seed the initial seed (32 bits integer)
*/
public GaussianRandomGenerator(int seed) {
generator = new Random(seed);
}
/** Create a new generator initialized with a single long seed.
* @param seed seed for the generator (64 bits integer)
*/
public GaussianRandomGenerator(long seed) {
generator = new Random(seed);
}
/** Generate a random scalar with null mean and unit standard deviation.
* @return a random scalar with null mean and unit standard deviation
*/
public double nextDouble() {
return generator.nextGaussian();
}
/** Underlying generator. */
private Random generator;
private static final long serialVersionUID = 5504568059866195697L;
}

50
src/mantissa/src/org/spaceroots/mantissa/random/NotPositiveDefiniteMatrixException.java
View File

@ -1,50 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.spaceroots.mantissa.random;
import org.spaceroots.mantissa.MantissaException;
/** This class represents exceptions thrown by the correlated random
* vector generator.
* @version $Id: NotPositiveDefiniteMatrixException.java 1705 2006-09-17 19:57:39Z luc $
* @author L. Maisonobe
*/
public class NotPositiveDefiniteMatrixException
extends MantissaException {
/** Simple constructor.
* build an exception with a default message.
*/
public NotPositiveDefiniteMatrixException() {
super("not positive definite matrix");
}
/** Simple constructor.
* build an exception with the specified message.
* @param message message to use to build the exception
*/
public NotPositiveDefiniteMatrixException(String message) {
super(message);
}
private static final long serialVersionUID = -6801349873804445905L;
}

76
src/mantissa/src/org/spaceroots/mantissa/random/UniformRandomGenerator.java
View File

@ -1,76 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.spaceroots.mantissa.random;
import java.util.Random;
/** This class implements a normalized uniform random generator.
* <p>Since this is a normalized random generator, it has a null mean
* and a unit standard deviation. Being also a uniform
* generator, it produces numbers in the range [-sqrt(3) ;
* sqrt(3)].</p>
* @version $Id: UniformRandomGenerator.java 1705 2006-09-17 19:57:39Z luc $
* @author L. Maisonobe
*/
public class UniformRandomGenerator
implements NormalizedRandomGenerator {
/** Create a new generator.
* The seed of the generator is related to the current time.
*/
public UniformRandomGenerator() {
generator = new Random();
}
/** Creates a new random number generator using a single int seed.
* @param seed the initial seed (32 bits integer)
*/
public UniformRandomGenerator(int seed) {
generator = new Random(seed);
}
/** Create a new generator initialized with a single long seed.
* @param seed seed for the generator (64 bits integer)
*/
public UniformRandomGenerator(long seed) {
generator = new Random(seed);
}
/** Generate a random scalar with null mean and unit standard deviation.
* <p>The number generated is uniformly distributed between -sqrt(3)
* and sqrt(3).</p>
* @return a random scalar with null mean and unit standard deviation
*/
public double nextDouble() {
return TWOSQRT3 * generator.nextDouble() - SQRT3;
}
/** Underlying generator. */
private Random generator;
private static final double SQRT3 = Math.sqrt(3.0);
private static final double TWOSQRT3 = 2.0 * Math.sqrt(3.0);
private static final long serialVersionUID = -6913329325753217654L;
}

114
src/mantissa/tests-src/org/spaceroots/mantissa/random/CorrelatedRandomVectorGeneratorTest.java
View File

@ -1,114 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.spaceroots.mantissa.random;
import org.spaceroots.mantissa.linalg.Matrix;
import org.spaceroots.mantissa.linalg.GeneralMatrix;
import org.spaceroots.mantissa.linalg.SymetricalMatrix;
import junit.framework.*;
public class CorrelatedRandomVectorGeneratorTest
extends TestCase {
public CorrelatedRandomVectorGeneratorTest(String name) {
super(name);
mean = null;
covariance = null;
generator = null;
}
public void testRank() {
assertEquals(3, generator.getRank());
}
public void testRootMatrix() {
Matrix b = generator.getRootMatrix();
Matrix bbt = b.mul(b.getTranspose());
for (int i = 0; i < covariance.getRows(); ++i) {
for (int j = 0; j < covariance.getColumns(); ++j) {
assertEquals(covariance.getElement(i, j),
bbt.getElement(i, j),
1.0e-12);
}
}
}
public void testMeanAndCovariance() {
VectorialSampleStatistics sample = new VectorialSampleStatistics();
for (int i = 0; i < 5000; ++i) {
sample.add(generator.nextVector());
}
double[] estimatedMean = sample.getMean();
SymetricalMatrix estimatedCovariance = sample.getCovarianceMatrix(null);
for (int i = 0; i < estimatedMean.length; ++i) {
assertEquals(mean[i], estimatedMean[i], 0.07);
for (int j = 0; j <= i; ++j) {
assertEquals(covariance.getElement(i, j),
estimatedCovariance.getElement(i, j),
0.1 * (1.0 + Math.abs(mean[i])) * (1.0 + Math.abs(mean[j])));
}
}
}
public void setUp() {
try {
mean = new double[] { 0.0, 1.0, -3.0, 2.3};
GeneralMatrix b = new GeneralMatrix(4, 3);
int counter = 0;
for (int i = 0; i < b.getRows(); ++i) {
for (int j = 0; j < b.getColumns(); ++j) {
b.setElement(i, j, 1.0 + 0.1 * ++counter);
}
}
Matrix bbt = b.mul(b.getTranspose());
covariance = new SymetricalMatrix(mean.length);
for (int i = 0; i < covariance.getRows(); ++i) {
covariance.setElement(i, i, bbt.getElement(i, i));
for (int j = 0; j < covariance.getColumns(); ++j) {
covariance.setElementAndSymetricalElement(i, j,
bbt.getElement(i, j));
}
}
GaussianRandomGenerator rawGenerator = new GaussianRandomGenerator(17399225432l);
generator = new CorrelatedRandomVectorGenerator(mean, covariance, rawGenerator);
} catch (NotPositiveDefiniteMatrixException e) {
fail("not positive definite matrix");
}
}
public void tearDown() {
mean = null;
covariance = null;
generator = null;
}
public static Test suite() {
return new TestSuite(CorrelatedRandomVectorGeneratorTest.class);
}
private double[] mean;
private SymetricalMatrix covariance;
private CorrelatedRandomVectorGenerator generator;
}

43
src/mantissa/tests-src/org/spaceroots/mantissa/random/GaussianRandomGeneratorTest.java
View File

@ -1,43 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.spaceroots.mantissa.random;
import junit.framework.*;
public class GaussianRandomGeneratorTest
extends TestCase {
public GaussianRandomGeneratorTest(String name) {
super(name);
}
public void testMeanAndStandardDeviation() {
GaussianRandomGenerator generator = new GaussianRandomGenerator(17399225432l);
ScalarSampleStatistics sample = new ScalarSampleStatistics();
for (int i = 0; i < 10000; ++i) {
sample.add(generator.nextDouble());
}
assertEquals(0.0, sample.getMean(), 0.012);
assertEquals(1.0, sample.getStandardDeviation(), 0.01);
}
public static Test suite() {
return new TestSuite(GaussianRandomGeneratorTest.class);
}
}

78
src/mantissa/tests-src/org/spaceroots/mantissa/random/UncorrelatedRandomVectorGeneratorTest.java
View File

@ -1,78 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.spaceroots.mantissa.random;
import org.spaceroots.mantissa.linalg.SymetricalMatrix;
import junit.framework.*;
public class UncorrelatedRandomVectorGeneratorTest
extends TestCase {
public UncorrelatedRandomVectorGeneratorTest(String name) {
super(name);
mean = null;
standardDeviation = null;
generator = null;
}
public void testMeanAndCorrelation() {
VectorialSampleStatistics sample = new VectorialSampleStatistics();
for (int i = 0; i < 10000; ++i) {
sample.add(generator.nextVector());
}
double[] estimatedMean = sample.getMean();
double scale;
SymetricalMatrix estimatedCorrelation = sample.getCovarianceMatrix(null);
for (int i = 0; i < estimatedMean.length; ++i) {
assertEquals(mean[i], estimatedMean[i], 0.07);
for (int j = 0; j < i; ++j) {
scale = standardDeviation[i] * standardDeviation[j];
assertEquals(0, estimatedCorrelation.getElement(i, j) / scale, 0.03);
}
scale = standardDeviation[i] * standardDeviation[i];
assertEquals(1, estimatedCorrelation.getElement(i, i) / scale, 0.025);
}
}
public void setUp() {
mean = new double[] {0.0, 1.0, -3.0, 2.3};
standardDeviation = new double[] {1.0, 2.0, 10.0, 0.1};
generator =
new UncorrelatedRandomVectorGenerator(mean, standardDeviation,
new GaussianRandomGenerator(17399225432l));
}
public void tearDown() {
mean = null;
standardDeviation = null;
generator = null;
}
public static Test suite() {
return new TestSuite(UncorrelatedRandomVectorGeneratorTest.class);
}
private double[] mean;
private double[] standardDeviation;
private UncorrelatedRandomVectorGenerator generator;
}

167
src/mantissa/tests-src/org/spaceroots/mantissa/random/VectorialSampleStatisticsTest.java
View File

@ -1,167 +0,0 @@
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.spaceroots.mantissa.random;
import org.spaceroots.mantissa.linalg.SymetricalMatrix;
import junit.framework.*;
public class VectorialSampleStatisticsTest
extends TestCase {
public VectorialSampleStatisticsTest(String name) {
super(name);
points = null;
}
public void testSimplistic() {
VectorialSampleStatistics sample = new VectorialSampleStatistics();
sample.add(new double[] {-1.0, 1.0});
sample.add(new double[] { 1.0, -1.0});
SymetricalMatrix c = sample.getCovarianceMatrix(null);
assertEquals( 2.0, c.getElement(0, 0), 1.0e-12);
assertEquals(-2.0, c.getElement(1, 0), 1.0e-12);
assertEquals( 2.0, c.getElement(1, 1), 1.0e-12);
}
public void testBasicStats() {
VectorialSampleStatistics sample = new VectorialSampleStatistics();
for (int i = 0; i < points.length; ++i) {
sample.add(points[i]);
}
assertEquals(points.length, sample.size());
double[] min = sample.getMin();
double[] max = sample.getMax();
double[] mean = sample.getMean();
SymetricalMatrix c = sample.getCovarianceMatrix(null);
double[] refMin = new double[] {-0.70, 0.00, -3.10};
double[] refMax = new double[] { 6.00, 2.30, 5.00};
double[] refMean = new double[] { 1.78, 1.62, 3.12};
double[][] refC = new double[][] {
{ 8.0470, -1.9195, -3.4445},
{-1.9195, 1.0470, 3.2795},
{-3.4445, 3.2795, 12.2070}
};
for (int i = 0; i < min.length; ++i) {
assertEquals(refMin[i], min[i], 1.0e-12);
assertEquals(refMax[i], max[i], 1.0e-12);
assertEquals(refMean[i], mean[i], 1.0e-12);
for (int j = 0; j <= i; ++j) {
assertEquals(refC[i][j], c.getElement(i, j), 1.0e-12);
}
}
}
public void testAddSample() {
VectorialSampleStatistics all = new VectorialSampleStatistics();
VectorialSampleStatistics even = new VectorialSampleStatistics();
VectorialSampleStatistics odd = new VectorialSampleStatistics();
for (int i = 0; i < points.length; ++i) {
all.add(points[i]);
if (i % 2 == 0) {
even.add(points[i]);
} else {
odd.add(points[i]);
}
}
even.add(odd);
assertEquals(all.size(), even.size());
double[] min = even.getMin();
double[] max = even.getMax();
double[] mean = even.getMean();
SymetricalMatrix c = even.getCovarianceMatrix(null);
double[] refMin = all.getMin();
double[] refMax = all.getMax();
double[] refMean = all.getMean();
SymetricalMatrix refC = all.getCovarianceMatrix(null);
for (int i = 0; i < min.length; ++i) {
assertEquals(refMin[i], min[i], 1.0e-12);
assertEquals(refMax[i], max[i], 1.0e-12);
assertEquals(refMean[i], mean[i], 1.0e-12);
for (int j = 0; j <= i; ++j) {
assertEquals(refC.getElement(i, j), c.getElement(i, j), 1.0e-12);
}
}
}
public void testAddArray() {
VectorialSampleStatistics loop = new VectorialSampleStatistics();
VectorialSampleStatistics direct = new VectorialSampleStatistics();
for (int i = 0; i < points.length; ++i) {
loop.add(points[i]);
}
direct.add(points);
assertEquals(loop.size(), direct.size());
double[] min = direct.getMin();
double[] max = direct.getMax();
double[] mean = direct.getMean();
SymetricalMatrix c = direct.getCovarianceMatrix(null);
double[] refMin = loop.getMin();
double[] refMax = loop.getMax();
double[] refMean = loop.getMean();
SymetricalMatrix refC = loop.getCovarianceMatrix(null);
for (int i = 0; i < min.length; ++i) {
assertEquals(refMin[i], min[i], 1.0e-12);
assertEquals(refMax[i], max[i], 1.0e-12);
assertEquals(refMean[i], mean[i], 1.0e-12);
for (int j = 0; j <= i; ++j) {
assertEquals(refC.getElement(i, j), c.getElement(i, j), 1.0e-12);
}
}
}
public void setUp() {
points = new double[][] {
{ 1.2, 2.3, 4.5},
{-0.7, 2.3, 5.0},
{ 3.1, 0.0, -3.1},
{ 6.0, 1.2, 4.2},
{-0.7, 2.3, 5.0}
};
}
public void tearDown() {
points = null;
}
public static Test suite() {
return new TestSuite(VectorialSampleStatisticsTest.class);
}
private double [][] points;
}

47
src/test/org/apache/commons/math/random/GaussianRandomGeneratorTest.java Normal file
View File

@ -0,0 +1,47 @@
//Licensed to the Apache Software Foundation (ASF) under one
//or more contributor license agreements. See the NOTICE file
//distributed with this work for additional information
//regarding copyright ownership. The ASF licenses this file
//to you under the Apache License, Version 2.0 (the
//"License"); you may not use this file except in compliance
//with the License. You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing,
//software distributed under the License is distributed on an
//"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//KIND, either express or implied. See the License for the
//specific language governing permissions and limitations
//under the License.
package org.apache.commons.math.random;
import org.apache.commons.math.stat.StatUtils;
import junit.framework.*;
public class GaussianRandomGeneratorTest
extends TestCase {
public GaussianRandomGeneratorTest(String name) {
super(name);
}
public void testMeanAndStandardDeviation() {
RandomGenerator rg = new JDKRandomGenerator();
rg.setSeed(17399225432l);
GaussianRandomGenerator generator = new GaussianRandomGenerator(rg);
double[] sample = new double[10000];
for (int i = 0; i < sample.length; ++i) {
sample[i] = generator.nextNormalizedDouble();
}
assertEquals(0.0, StatUtils.mean(sample), 0.012);
assertEquals(1.0, StatUtils.variance(sample), 0.01);
}
public static Test suite() {
return new TestSuite(GaussianRandomGeneratorTest.class);
}
}

86
src/test/org/apache/commons/math/random/UncorrelatedRandomVectorGeneratorTest.java Normal file
View File

@ -0,0 +1,86 @@
//Licensed to the Apache Software Foundation (ASF) under one
//or more contributor license agreements. See the NOTICE file
//distributed with this work for additional information
//regarding copyright ownership. The ASF licenses this file
//to you under the Apache License, Version 2.0 (the
//"License"); you may not use this file except in compliance
//with the License. You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing,
//software distributed under the License is distributed on an
//"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//KIND, either express or implied. See the License for the
//specific language governing permissions and limitations
//under the License.
package org.apache.commons.math.random;
import org.apache.commons.math.DimensionMismatchException;
import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.stat.descriptive.moment.VectorialCovariance;
import org.apache.commons.math.stat.descriptive.moment.VectorialMean;
import junit.framework.*;
public class UncorrelatedRandomVectorGeneratorTest
extends TestCase {
public UncorrelatedRandomVectorGeneratorTest(String name) {
super(name);
mean = null;
standardDeviation = null;
generator = null;
}
public void testMeanAndCorrelation() throws DimensionMismatchException {
VectorialMean meanStat = new VectorialMean(mean.length);
VectorialCovariance covStat = new VectorialCovariance(mean.length);
for (int i = 0; i < 10000; ++i) {
double[] v = generator.nextVector();
meanStat.increment(v);
covStat.increment(v);
}
double[] estimatedMean = meanStat.getResult();
double scale;
RealMatrix estimatedCorrelation = covStat.getResult();
for (int i = 0; i < estimatedMean.length; ++i) {
assertEquals(mean[i], estimatedMean[i], 0.07);
for (int j = 0; j < i; ++j) {
scale = standardDeviation[i] * standardDeviation[j];
assertEquals(0, estimatedCorrelation.getEntry(i, j) / scale, 0.03);
}
scale = standardDeviation[i] * standardDeviation[i];
assertEquals(1, estimatedCorrelation.getEntry(i, i) / scale, 0.025);
}
}
public void setUp() {
mean = new double[] {0.0, 1.0, -3.0, 2.3};
standardDeviation = new double[] {1.0, 2.0, 10.0, 0.1};
RandomGenerator rg = new JDKRandomGenerator();
rg.setSeed(17399225432l);
generator =
new UncorrelatedRandomVectorGenerator(mean, standardDeviation,
new GaussianRandomGenerator(rg));
}
public void tearDown() {
mean = null;
standardDeviation = null;
generator = null;
}
public static Test suite() {
return new TestSuite(UncorrelatedRandomVectorGeneratorTest.class);
}
private double[] mean;
private double[] standardDeviation;
private UncorrelatedRandomVectorGenerator generator;
}

47
src/test/org/apache/commons/math/random/UniformRandomGeneratorTest.java Normal file
View File

@ -0,0 +1,47 @@
//Licensed to the Apache Software Foundation (ASF) under one
//or more contributor license agreements. See the NOTICE file
//distributed with this work for additional information
//regarding copyright ownership. The ASF licenses this file
//to you under the Apache License, Version 2.0 (the
//"License"); you may not use this file except in compliance
//with the License. You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing,
//software distributed under the License is distributed on an
//"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//KIND, either express or implied. See the License for the
//specific language governing permissions and limitations
//under the License.
package org.apache.commons.math.random;
import org.apache.commons.math.stat.StatUtils;
import junit.framework.*;
public class UniformRandomGeneratorTest
extends TestCase {
public UniformRandomGeneratorTest(String name) {
super(name);
}
public void testMeanAndStandardDeviation() {
RandomGenerator rg = new JDKRandomGenerator();
rg.setSeed(17399225432l);
UniformRandomGenerator generator = new UniformRandomGenerator(rg);
double[] sample = new double[10000];
for (int i = 0; i < sample.length; ++i) {
sample[i] = generator.nextNormalizedDouble();
}
assertEquals(0.0, StatUtils.mean(sample), 0.07);
assertEquals(1.0, StatUtils.variance(sample), 0.02);
}
public static Test suite() {
return new TestSuite(UniformRandomGeneratorTest.class);
}
}

101
src/test/org/apache/commons/math/stat/descriptive/moment/VectorialCovarianceTest.java Normal file
View File

@ -0,0 +1,101 @@
//Licensed to the Apache Software Foundation (ASF) under one
//or more contributor license agreements. See the NOTICE file
//distributed with this work for additional information
//regarding copyright ownership. The ASF licenses this file
//to you under the Apache License, Version 2.0 (the
//"License"); you may not use this file except in compliance
//with the License. You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing,
//software distributed under the License is distributed on an
//"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//KIND, either express or implied. See the License for the
//specific language governing permissions and limitations
//under the License.
package org.apache.commons.math.stat.descriptive.moment;
import org.apache.commons.math.DimensionMismatchException;
import org.apache.commons.math.linear.RealMatrix;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
public class VectorialCovarianceTest
extends TestCase {
public VectorialCovarianceTest(String name) {
super(name);
points = null;
}
public void testMismatch() {
try {
new VectorialCovariance(8).increment(new double[5]);
fail("an exception should have been thrown");
} catch (DimensionMismatchException dme) {
assertEquals(5, dme.getDimension1());
assertEquals(8, dme.getDimension2());
} catch (Exception e) {
fail("wrong exception type caught: " + e.getClass().getName());
}
}
public void testSimplistic() throws DimensionMismatchException {
VectorialCovariance stat = new VectorialCovariance(2);
stat.increment(new double[] {-1.0, 1.0});
stat.increment(new double[] { 1.0, -1.0});
RealMatrix c = stat.getResult();
assertEquals( 2.0, c.getEntry(0, 0), 1.0e-12);
assertEquals(-2.0, c.getEntry(1, 0), 1.0e-12);
assertEquals( 2.0, c.getEntry(1, 1), 1.0e-12);
}
public void testBasicStats() throws DimensionMismatchException {
VectorialCovariance stat = new VectorialCovariance(points[0].length);
for (int i = 0; i < points.length; ++i) {
stat.increment(points[i]);
}
assertEquals(points.length, stat.getN());
RealMatrix c = stat.getResult();
double[][] refC = new double[][] {
{ 8.0470, -1.9195, -3.4445},
{-1.9195, 1.0470, 3.2795},
{-3.4445, 3.2795, 12.2070}
};
for (int i = 0; i < c.getRowDimension(); ++i) {
for (int j = 0; j <= i; ++j) {
assertEquals(refC[i][j], c.getEntry(i, j), 1.0e-12);
}
}
}
public void setUp() {
points = new double[][] {
{ 1.2, 2.3, 4.5},
{-0.7, 2.3, 5.0},
{ 3.1, 0.0, -3.1},
{ 6.0, 1.2, 4.2},
{-0.7, 2.3, 5.0}
};
}
public void tearDown() {
points = null;
}
public static Test suite() {
return new TestSuite(VectorialCovarianceTest.class);
}
private double [][] points;
}

93
src/test/org/apache/commons/math/stat/descriptive/moment/VectorialMeanTest.java Normal file
View File

@ -0,0 +1,93 @@
//Licensed to the Apache Software Foundation (ASF) under one
//or more contributor license agreements. See the NOTICE file
//distributed with this work for additional information
//regarding copyright ownership. The ASF licenses this file
//to you under the Apache License, Version 2.0 (the
//"License"); you may not use this file except in compliance
//with the License. You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing,
//software distributed under the License is distributed on an
//"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//KIND, either express or implied. See the License for the
//specific language governing permissions and limitations
//under the License.
package org.apache.commons.math.stat.descriptive.moment;
import org.apache.commons.math.DimensionMismatchException;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
public class VectorialMeanTest
extends TestCase {
public VectorialMeanTest(String name) {
super(name);
points = null;
}
public void testMismatch() {
try {
new VectorialMean(8).increment(new double[5]);
fail("an exception should have been thrown");
} catch (DimensionMismatchException dme) {
assertEquals(5, dme.getDimension1());
assertEquals(8, dme.getDimension2());
} catch (Exception e) {
fail("wrong exception type caught: " + e.getClass().getName());
}
}
public void testSimplistic() throws DimensionMismatchException {
VectorialMean stat = new VectorialMean(2);
stat.increment(new double[] {-1.0, 1.0});
stat.increment(new double[] { 1.0, -1.0});
double[] mean = stat.getResult();
assertEquals(0.0, mean[0], 1.0e-12);
assertEquals(0.0, mean[1], 1.0e-12);
}
public void testBasicStats() throws DimensionMismatchException {
VectorialMean stat = new VectorialMean(points[0].length);
for (int i = 0; i < points.length; ++i) {
stat.increment(points[i]);
}
assertEquals(points.length, stat.getN());
double[] mean = stat.getResult();
double[] refMean = new double[] { 1.78, 1.62, 3.12};
for (int i = 0; i < mean.length; ++i) {
assertEquals(refMean[i], mean[i], 1.0e-12);
}
}
public void setUp() {
points = new double[][] {
{ 1.2, 2.3, 4.5},
{-0.7, 2.3, 5.0},
{ 3.1, 0.0, -3.1},
{ 6.0, 1.2, 4.2},
{-0.7, 2.3, 5.0}
};
}
public void tearDown() {
points = null;
}
public static Test suite() {
return new TestSuite(VectorialMeanTest.class);
}
private double [][] points;
}