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

Merge branch 'feature-MATH-1335' into develop 

Fixes the following issues (see JIRA):
  MATH-1335
  MATH-1337
  MATH-1327
  MATH-1314
This commit is contained in:
Gilles 2016-04-21 23:56:39 +02:00
parent 71760ddf88 3451569887
commit aeb21280ae
123 changed files with 112731 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

229
src/main/java/org/apache/commons/math4/random/RngAdaptor.java Normal file
View File

@ -0,0 +1,229 @@
/*
* 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.math4.random;
import java.io.Serializable;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import org.apache.commons.math4.util.FastMath;
import org.apache.commons.math4.rng.UniformRandomProvider;
import org.apache.commons.math4.rng.RandomSource;
/**
* Adaptor that delegates to a {@link UniformRandomProvider} instance.
* <p>
* It is provided for users who wish to test the new RNG implementations
* the <i>current</i> generators (up to version 3.6 of Commons Math) in
* codes that require the {@code RandomGenerator} interface.
* </p>
* <p>
* Applications should upgrade to use the new generators ASAP.
* If problems are found that jeopardize the upgrade, please report them
* on the project's
* <a href="https://issues.apache.org/jira/browse/MATH">
* issue tracking system</a>.
* </p>
*
* <p>
* <b>Notes:</b>
* <ul>
* <li>
* The
* {@link RandomGenerator#setSeed(int) setSeed(int)},
* {@link RandomGenerator#setSeed(int[]) setSeed(int[])} and
* {@link RandomGenerator#setSeed(long) setSeed(long)}
* methods of the {@link RandomGenerator} are not part of the
* {@link UniformRandomProvider new API}.
* </li>
* <li>
* The new RNG implementations are not {@code Serializable}.
* Use {@link RandomSource#saveState(UniformRandomProvider)}
* instead.
* </li>
* <li>
* {@link RandomGenerator#nextGaussian() nextGaussian()} is not
* part of the {@link UniformRandomProvider new API} as it defines
* a "post-processing" of the output of a <i>uniform</i> RNG in
* order to follow a different distribution.
* </li>
* </p>
*
* @since 4.0
*
* @deprecated As of 4.0. This class is made available for testing
* the {@link RandomSource new RNG implementations} in existing
* applications.
* It will be removed in the next major release.
*/
@Deprecated
public final class RngAdaptor
implements RandomGenerator,
Serializable {
/** Serializable version identifier. */
private static final long serialVersionUID = 12345L;
/** Source. */
private final RandomSource source;
/** Delegate. */
private transient UniformRandomProvider delegate;
/** Next gaussian. */
private double nextGaussian = Double.NaN;
/**
* Creates a new instance.
*
* @param source Source of randomness.
*/
public RngAdaptor(RandomSource source) {
this(source, null);
}
/**
* Creates a new instance.
*
* @param source Source of randomness.
* @param seed Seed. Can be {@code null}.
*/
public RngAdaptor(RandomSource source,
Object seed) {
this.source = source;
delegate = RandomSource.create(source, seed);
}
/** {@inheritDoc} */
@Override
public void setSeed(int seed) {
delegate = RandomSource.create(source, seed);
clear();
}
/** {@inheritDoc} */
@Override
public void setSeed(int[] seed) {
delegate = RandomSource.create(source, seed);
clear();
}
/** {@inheritDoc} */
@Override
public void setSeed(long seed) {
delegate = RandomSource.create(source, seed);
clear();
}
/** {@inheritDoc} */
@Override
public boolean nextBoolean() {
return delegate.nextBoolean();
}
/** {@inheritDoc} */
@Override
public void nextBytes(byte[] bytes) {
delegate.nextBytes(bytes);
}
/** {@inheritDoc} */
@Override
public double nextDouble() {
return delegate.nextDouble();
}
/** {@inheritDoc} */
@Override
public float nextFloat() {
return delegate.nextFloat();
}
/** {@inheritDoc} */
@Override
public double nextGaussian() {
final double random;
if (Double.isNaN(nextGaussian)) {
// generate a new pair of gaussian numbers
final double x = nextDouble();
final double y = nextDouble();
final double alpha = 2 * FastMath.PI * x;
final double r = FastMath.sqrt(-2 * FastMath.log(y));
random = r * FastMath.cos(alpha);
nextGaussian = r * FastMath.sin(alpha);
} else {
// use the second element of the pair already generated
random = nextGaussian;
nextGaussian = Double.NaN;
}
return random;
}
/** {@inheritDoc} */
@Override
public int nextInt() {
return delegate.nextInt();
}
/** {@inheritDoc} */
@Override
public int nextInt(int n) {
return delegate.nextInt(n);
}
/** {@inheritDoc} */
@Override
public long nextLong() {
return delegate.nextLong();
}
/**
* Clears the cache used by the default implementation of
* {@link #nextGaussian}.
*/
private void clear() {
nextGaussian = Double.NaN;
}
/**
* @param out Output stream.
* @throws IOException if an error occurs.
*/
private void writeObject(ObjectOutputStream out)
throws IOException {
// Write non-transient fields.
out.defaultWriteObject();
// Save current state.
out.writeObject(RandomSource.saveState(delegate));
}
/**
* @param in Input stream.
* @throws IOException if an error occurs.
* @throws ClassNotFoundException if an error occurs.
*/
private void readObject(ObjectInputStream in)
throws IOException,
ClassNotFoundException {
// Read non-transient fields.
in.defaultReadObject();
// Recreate the "delegate" from serialized info.
delegate = RandomSource.create(source);
// And restore its state.
final RandomSource.State state = (RandomSource.State) in.readObject();
RandomSource.restoreState(delegate, state);
}
}

417
src/main/java/org/apache/commons/math4/rng/RandomSource.java Normal file
View File

@ -0,0 +1,417 @@
/*
* 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.math4.rng;
import org.apache.commons.math4.exception.MathUnsupportedOperationException;
import org.apache.commons.math4.rng.internal.ProviderBuilder;
import org.apache.commons.math4.rng.internal.BaseProvider;
import org.apache.commons.math4.rng.internal.util.SeedFactory;
import org.apache.commons.math4.rng.internal.source64.TwoCmres;
/**
* This class provides the API for creating generators of random numbers.
* <p>
* Usage examples:
* <pre><code>
* UniformRandomProvider rng = RandomSource.create(RandomSource.MT);
* </code></pre>
* or
* <pre><code>
* final int[] seed = new int[] { 196, 9, 0, 226 };
* UniformRandomProvider rng = RandomSource.create(RandomSource.MT, seed);
* </code></pre>
* or
* <pre><code>
* final int[] seed = RandomSource.createIntArray(256);
* UniformRandomProvider rng = RandomSource.create(RandomSource.MT, seed);
* </code></pre>
* where the first argument to method {@code create} is the identifier
* of the generator's concrete implementation, and the second the is the
* (optional) seed.
* <br>
* In the first form, a random seed will be {@link SeedFactory generated
* automatically}; the random seed generation step is explicit in the
* third form.
* </p>
*
* <p>
* Seeding is the procedure by which a value (or set of values) is
* used to <i>initialize</i> a generator instance.
* The requirement that a given seed will always result in the same
* internal state allows to create different instances of a generator
* that will produce the same sequence of pseudo-random numbers.
* </p>
*
* <p>
* The type of data used as a seed depends on the concrete implementation
* as some types may not provide enough information to fully initialize
* the generator's internal state.
* <br>
* The reference algorithm's seeding procedure (if provided) operates
* on a value of a (single) <i>native</i> type:
* Each concrete implementation's constructor creates an instance using
* the native type whose information contents is used to set the
* internal state.
* <br>
* When the seed value passed by the caller is of the native type, it is
* expected that the sequences produced will be the same as those
* produced by other implementations of the algorithm.
* <br>
* However, when the seed value passed by the caller is not of the native
* type, a transformation is performed by this library and the resulting
* native type value will <i>not</i> contain more information than the
* original seed value.
* If the algorithm's native type is "simpler" than the type passed by
* the caller, then some (unuse) information will even be lost.
* <br>
* The transformation from non-native to native seed type is arbitrary,
* as long as it does not reduce the amount of information required by
* the algorithm to initialize its state.
* The consequence of the transformation is that the sequences produced
* by this library may not be the same as the sequences produced by other
* implementations of the same algorithm!
* </p>
*
* <p>
* This class provides methods to generate random seeds (single values
* or arrays of values, of {@code int} or {@code long} types) that can
* be passed to the {@link RandomSource#create(RandomSource,Object,Object[])
* generators factory method}.
* <br>
* Although the seed-generating methods defined in this class will likely
* return different values for all calls, there is no guarantee that the
* produced seed will result always in a "good" sequence of numbers, even
* if the generator is good.
* The only way to ensure that the selected seed will make the generator
* produce a "good" sequence is to submit that sequence to a series of
* stringent tests, as provided by tools such as
* <a href="http://www.phy.duke.edu/~rgb/General/dieharder.php">dieharder</a>
* or <a href="http://simul.iro.umontreal.ca/testu01/tu01.html">TestU01</a>.
* </p>
*
* <p>
* The current implementations have no provision for producing non-overlapping
* sequences.
* For parallel applications, a possible workaround is that each thread uses
* a generator of a different type (see {@link #TWO_CMRES_SELECT}).
* </p>
*
* <p>
* <b>Note:</b>
* Seeding is not equivalent to restoring the internal state of an
* <i>already initialized</i> generator.
* Indeed, generators can have a state that is more complex than the
* seed, and seeding is thus a transformation (from seed to state).
* Implementations do not provide the inverse transformation (from
* state to seed), hence it is not generally possible to know the seed
* that would initialize a new generator instance to the current state
* of another instance.
* Reseeding is also inefficient if the purpose is to continue the
* same sequence where another instance left off, as it would require
* to "replay" all the calls performed by that other instance (and it
* would require to know the number of calls to the primary source of
* randomness, which is also not usually accessible).
* <br>
* This factory thus provides a method for
* {@link #saveState(UniformRandomProvider) saving} the internal
* state of a generator.
* The state is encapsulated in an {@link State "opaque object"} to be
* used for {@link #restoreState(UniformRandomProvider,State) restoring}
* a generator (of the same type) to an identical state (e.g. to allow
* persistent storage, or to continue a sequence from where the original
* instance left off.).
* </p>
*
* @since 4.0
*/
public enum RandomSource {
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source32.JDKRandom}.
* Native seed type: {@code Long}.
*/
JDK(ProviderBuilder.RandomSourceInternal.JDK),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source32.Well512a}.
* Native seed type: {@code int[]}.
*/
WELL_512_A(ProviderBuilder.RandomSourceInternal.WELL_512_A),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source32.Well1024a}.
* Native seed type: {@code int[]}.
*/
WELL_1024_A(ProviderBuilder.RandomSourceInternal.WELL_1024_A),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source32.Well19937a}.
* Native seed type: {@code int[]}.
*/
WELL_19937_A(ProviderBuilder.RandomSourceInternal.WELL_19937_A),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source32.Well19937c}.
* Native seed type: {@code int[]}.
*/
WELL_19937_C(ProviderBuilder.RandomSourceInternal.WELL_19937_C),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source32.Well44497a}.
* Native seed type: {@code int[]}.
*/
WELL_44497_A(ProviderBuilder.RandomSourceInternal.WELL_44497_A),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source32.Well44497b}.
* Native seed type: {@code int[]}.
*/
WELL_44497_B(ProviderBuilder.RandomSourceInternal.WELL_44497_B),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source32.MersenneTwister}.
* Native seed type: {@code int[]}.
*/
MT(ProviderBuilder.RandomSourceInternal.MT),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source32.ISAACRandom}.
* Native seed type: {@code int[]}.
*/
ISAAC(ProviderBuilder.RandomSourceInternal.ISAAC),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source64.SplitMix64}.
* Native seed type: {@code Long}.
*/
SPLIT_MIX_64(ProviderBuilder.RandomSourceInternal.SPLIT_MIX_64),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source64.XorShift1024Star}.
* Native seed type: {@code long[]}.
*/
XOR_SHIFT_1024_S(ProviderBuilder.RandomSourceInternal.XOR_SHIFT_1024_S),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source64.TwoCmres}.
* Native seed type: {@code Integer}.
*/
TWO_CMRES(ProviderBuilder.RandomSourceInternal.TWO_CMRES),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source64.TwoCmres},
* with explicit selection of the two subcycle generators.
* Native seed type: {@code Integer}.
*/
TWO_CMRES_SELECT(ProviderBuilder.RandomSourceInternal.TWO_CMRES_SELECT),
/**
* Source of randomness is {@link org.apache.commons.math4.rng.internal.source64.MersenneTwister64}.
* Native seed type: {@code long[]}.
*/
MT_64(ProviderBuilder.RandomSourceInternal.MT_64);
/** Internal identifier. */
private final ProviderBuilder.RandomSourceInternal internalIdentifier;
/**
* @param id Internal identifier.
*/
RandomSource(ProviderBuilder.RandomSourceInternal id) {
internalIdentifier = id;
}
/**
* @return the internal identifier.
*/
ProviderBuilder.RandomSourceInternal getInternalIdentifier() {
return internalIdentifier;
}
/**
* Checks whether the type of given {@code seed} is the native type
* of the implementation.
*
* @param seed Seed value.
* @return {@code true} if the seed can be passed to the builder
* for this RNG type.
*/
public boolean isNativeSeed(Object seed) {
return internalIdentifier.isNativeSeed(seed);
}
/**
* Marker interface used to define the "save" and "restore"
* functionality of the generators.
*/
public interface State {}
/**
* Creates a random number generator with a random seed.
*
* <p>
* Example of usage:
* <pre><code>
* UniformRandomProvider rng = RandomSource.create(Source.MT);
* </code></pre>
* </p>
*
* @param source {@link RandomSource RNG type}.
* @return the RNG.
*/
public static UniformRandomProvider create(RandomSource source) {
return create(source, null);
}
/**
* Creates a random number generator with the given {@code seed}.
*
* <p>
* Example of usage:
* <pre><code>
* UniformRandomProvider rng = RandomSource.create(Source.TWO_CMRES_SELECT, 26219, 6, 9);
* </code></pre>
* </p>
*
* <p>
* Valid types for the {@code seed} are:
* <ul>
* <li>{@code Integer} (or {@code int})</li>
* <li>{@code Long} (or {@code long})</li>
* <li>{@code int[]}</li>
* <li>{@code long[]}</li>
* </ul>
* </p>
*
* <p>
* Notes:
* <ul>
* <li>
* When the seed type passed as argument is more complex (i.e. more
* bits can be independently chosen) than the generator's
* {@link #isNativeSeed(Object) native type}, the conversion of a
* set of different seeds will necessarily result in the same value
* of the native seed type.
* </li>
* <li>
* When the native seed type is an array, the same remark applies
* when the array contains more bits than the state of the generator.
* </li>
* <li>
* When the native seed type is an array and the {@code seed} is
* {@code null}, the size of the generated array will be 128.
* </li>
* </p>
*
* @param source {@link RandomSource RNG type}.
* @param seed Seed value. It can be {@code null} (in which case a
* random value will be used).
* @param data Additional arguments to the implementation's constructor.
* Please refer to the documentation of each specific implementation.
* @return the RNG.
* @throws MathUnsupportedOperationException if the type of the
* {@code seed} is invalid.
* @throws org.apache.commons.math4.exception.InsufficientDataException
* if data is missing to initialize the generator implemented by the
* given {@code source}.
*/
public static UniformRandomProvider create(RandomSource source,
Object seed,
Object ... data) {
return ProviderBuilder.create(source.getInternalIdentifier(), seed, data);
}
/**
* Gets the number of elements of the set of "subcycle" generators from
* which two can be selected in order to create a {@link TwoCmres} RNG.
*
* @return the number of implemented subcycle generators.
*/
public static int numberOfCmresGenerators() {
return TwoCmres.numberOfSubcycleGenerators();
}
/**
* Saves the state of a RNG.
*
* @param provider Provider.
* @return the current state of the given {@code provider}.
* @throws MathUnsupportedOperationException if the {@code provider} is
* not an object created by this factory or the underlying source of
* randomness does not support this functionality.
*
* @see #restoreState(UniformRandomProvider,RandomSource.State)
*/
public static State saveState(UniformRandomProvider provider) {
if (!(provider instanceof BaseProvider)) {
throw new MathUnsupportedOperationException();
} else {
return ((BaseProvider) provider).getState();
}
}
/**
* Restores the state of a RNG.
*
* @param provider Provider.
* @param state State which the {@code provider} will be set to.
* This parameter must have been obtained by a call to
* {@link #saveState(UniformRandomProvider) saveState(rng)}
* where {@code rng} is either the same object as {@code provider},
* or an object of the same concrete type.
* @throws MathUnsupportedOperationException if the {@code provider} is
* not an object created by this factory or the underlying source of
* randomness does not support this functionality.
* @throws org.apache.commons.math4.exception.InsufficientDataException
* if it was detected that the {@code state} is incompatible with the
* given {@code provider}.
*
* @see #saveState(UniformRandomProvider)
*/
public static void restoreState(UniformRandomProvider provider,
State state) {
if (!(provider instanceof BaseProvider)) {
throw new MathUnsupportedOperationException();
} else {
((BaseProvider) provider).setState(state);
}
}
/**
* Creates a number for use as a seed.
*
* @return a random number.
*/
public static int createInt() {
return SeedFactory.createInt();
}
/**
* Creates a number for use as a seed.
*
* @return a random number.
*/
public static long createLong() {
return SeedFactory.createLong();
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @return an array of {@code n} random numbers.
*/
public static int[] createIntArray(int n) {
return SeedFactory.createIntArray(n);
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @return an array of {@code n} random numbers.
*/
public static long[] createLongArray(int n) {
return SeedFactory.createLongArray(n);
}
}

118
src/main/java/org/apache/commons/math4/rng/UniformRandomProvider.java Normal file
View File

@ -0,0 +1,118 @@
/*
* 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.math4.rng;
/**
* Applies to generators of random number sequences that follow a uniform
* distribution.
*
* @since 4.0
*/
public interface UniformRandomProvider {
/**
* Generates {@code byte} values and places them into a user-supplied array.
* <p>
* The number of random bytes produced is equal to the length of the
* the byte array.
* </p>
*
* @param bytes Byte array in which to put the random bytes.
* Cannot be {@code null}.
*/
void nextBytes(byte[] bytes);
/**
* Generates {@code byte} values and places them into a user-supplied array.
*
* <p>
* The array is filled with bytes extracted from random integers.
* This implies that the number of random bytes generated may be larger than
* the length of the byte array.
* </p>
*
* @param bytes Array in which to put the generated bytes.
* Cannot be {@code null}.
* @param start Index at which to start inserting the generated bytes.
* @param len Number of bytes to insert.
* @throws org.apache.commons.math4.exception.OutOfRangeException
* if {@code start < 0} or {@code start >= bytes.length}.
* @throws org.apache.commons.math4.exception.OutOfRangeException
* if {@code len < 0} or {@code len > bytes.length - start}.
*/
void nextBytes(byte[] bytes,
int start,
int len);
/**
* Generates an {@code int} value.
*
* @return the next random value.
*/
int nextInt();
/**
* Generates an {@code int} value between 0 (inclusive) and the
* specified value (exclusive).
*
* @param n Bound on the random number to be returned. Must be positive.
* @return a random {@code int} value between 0 (inclusive) and n
* (exclusive).
* @throws org.apache.commons.math4.exception.NotStrictlyPositiveException
* if {@code n} is not positive.
*/
int nextInt(int n);
/**
* Generates a {@code long} value.
*
* @return the next random value.
*/
long nextLong();
/**
* Generates a {@code long} value between 0 (inclusive) and the specified
* value (exclusive).
*
* @param n Bound on the random number to be returned. Must be positive.
* @return a random {@code long} value between 0 (inclusive) and n
* (exclusive).
* @throws org.apache.commons.math4.exception.NotStrictlyPositiveException
* if {@code n} is not positive.
*/
long nextLong(long n);
/**
* Generates a {@code boolean} value.
*
* @return the next random value.
*/
boolean nextBoolean();
/**
* Generates a {@code float} value between 0 and 1.
*
* @return the next random value between 0 and 1.
*/
float nextFloat();
/**
* Generates a {@code double} value between 0 and 1.
*
* @return the next random value between 0 and 1.
*/
double nextDouble();
}

141
src/main/java/org/apache/commons/math4/rng/internal/BaseProvider.java Normal file
View File

@ -0,0 +1,141 @@
/*
* 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.math4.rng.internal;
import java.util.Arrays;
import java.io.Serializable;
import org.apache.commons.math4.exception.MathUnsupportedOperationException;
import org.apache.commons.math4.exception.NotStrictlyPositiveException;
import org.apache.commons.math4.rng.UniformRandomProvider;
import org.apache.commons.math4.rng.RandomSource;
/**
* Base class with default implementation for common methods.
*/
public abstract class BaseProvider
implements UniformRandomProvider,
StateSettable {
/** {@inheritDoc} */
@Override
public int nextInt(int n) throws IllegalArgumentException {
if (n > 0) {
if ((n & -n) == n) {
return (int) ((n * (long) (nextInt() >>> 1)) >> 31);
}
int bits;
int val;
do {
bits = nextInt() >>> 1;
val = bits % n;
} while (bits - val + (n - 1) < 0);
return val;
}
throw new NotStrictlyPositiveException(n);
}
/** {@inheritDoc} */
@Override
public long nextLong(long n) {
if (n > 0) {
long bits;
long val;
do {
bits = nextLong() >>> 1;
val = bits % n;
} while (bits - val + (n - 1) < 0);
return val;
}
throw new NotStrictlyPositiveException(n);
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getName();
}
/** {@inheritDoc} */
@Override
public RandomSource.State getState() {
return new State(getStateInternal());
}
/** {@inheritDoc} */
@Override
public void setState(RandomSource.State state) {
// Cast will intentionally fail if the argument is not one we created.
final State s = (State) state;
setStateInternal(s.getState());
}
/**
* Creates a snapshot of the RNG state.
*
* @return the internal state.
* @throws MathUnsupportedOperationException if not implemented.
*/
protected byte[] getStateInternal() {
throw new MathUnsupportedOperationException();
}
/**
* Resets the RNG to the given {@code state}.
*
* @param state State (previously obtained by a call to
* {@link #getStateInternal()}).
* @throws MathUnsupportedOperationException if not implemented.
*/
protected void setStateInternal(byte[] state) {
throw new MathUnsupportedOperationException();
}
/**
* "Black-box" state.
* Its sole purpose is to store all the data needed to recover
* the same state in order to restart a sequence where it left
* off.
* External code should not to modify the data contained in
* instances of this class.
*/
private static class State
implements RandomSource.State,
Serializable {
/** Serializable version identifier. */
private static final long serialVersionUID = 4720160226L;
/** Internal state. */
private byte[] state;
/**
* @param state Mapping of all the data which a subclass of
* {@link BaseProvider} needs in order to reset its internal
* state.
*/
State(byte[] state) {
this.state = Arrays.copyOf(state, state.length);
}
/**
* @return the internal state.
*/
byte[] getState() {
return Arrays.copyOf(state, state.length);
}
}
}

346
src/main/java/org/apache/commons/math4/rng/internal/ProviderBuilder.java Normal file
View File

@ -0,0 +1,346 @@
/*
* 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.math4.rng.internal;
import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import org.apache.commons.math4.exception.MathUnsupportedOperationException;
import org.apache.commons.math4.exception.MathInternalError;
import org.apache.commons.math4.rng.UniformRandomProvider;
import org.apache.commons.math4.rng.internal.util.SeedFactory;
import org.apache.commons.math4.rng.internal.util.NoOpConverter;
import org.apache.commons.math4.rng.internal.util.Int2Long;
import org.apache.commons.math4.rng.internal.util.Long2Int;
import org.apache.commons.math4.rng.internal.util.Long2IntArray;
import org.apache.commons.math4.rng.internal.util.Long2LongArray;
import org.apache.commons.math4.rng.internal.util.IntArray2LongArray;
import org.apache.commons.math4.rng.internal.util.LongArray2IntArray;
import org.apache.commons.math4.rng.internal.util.LongArray2Long;
import org.apache.commons.math4.rng.internal.util.IntArray2Int;
import org.apache.commons.math4.rng.internal.util.SeedConverter;
import org.apache.commons.math4.rng.internal.util.SeedConverterComposer;
import org.apache.commons.math4.rng.internal.source32.JDKRandom;
import org.apache.commons.math4.rng.internal.source32.Well512a;
import org.apache.commons.math4.rng.internal.source32.Well1024a;
import org.apache.commons.math4.rng.internal.source32.Well19937a;
import org.apache.commons.math4.rng.internal.source32.Well19937c;
import org.apache.commons.math4.rng.internal.source32.Well44497a;
import org.apache.commons.math4.rng.internal.source32.Well44497b;
import org.apache.commons.math4.rng.internal.source32.ISAACRandom;
import org.apache.commons.math4.rng.internal.source32.MersenneTwister;
import org.apache.commons.math4.rng.internal.source64.SplitMix64;
import org.apache.commons.math4.rng.internal.source64.XorShift1024Star;
import org.apache.commons.math4.rng.internal.source64.TwoCmres;
import org.apache.commons.math4.rng.internal.source64.MersenneTwister64;
/**
* RNG builder.
* <p>
* It uses reflection to find the factory method of the RNG implementation,
* and performs seed type conversions.
* </p>
*/
public class ProviderBuilder {
/** Length of the seed array (for random seed). */
private static final int RANDOM_SEED_ARRAY_SIZE = 128;
/** Seed converter. */
private static final Long2Int LONG_TO_INT = new Long2Int();
/** Seed converter. */
private static final Int2Long INT_TO_LONG = new Int2Long();
/** Seed converter. */
private static final Long2IntArray LONG_TO_INT_ARRAY = new Long2IntArray(RANDOM_SEED_ARRAY_SIZE);
/** Seed converter. */
private static final Long2LongArray LONG_TO_LONG_ARRAY = new Long2LongArray(RANDOM_SEED_ARRAY_SIZE);
/** Seed converter. */
private static final LongArray2Long LONG_ARRAY_TO_LONG = new LongArray2Long();
/** Seed converter. */
private static final IntArray2Int INT_ARRAY_TO_INT = new IntArray2Int();
/** Seed converter. */
private static final LongArray2IntArray LONG_ARRAY_TO_INT_ARRAY = new LongArray2IntArray();
/** Seed converter. */
private static final IntArray2LongArray INT_ARRAY_TO_LONG_ARRAY = new IntArray2LongArray();
/** Map to convert "Integer" seeds. */
private static final Map<Class<?>, SeedConverter<Integer,?>> CONV_INT = new HashMap<>();
/** Map to convert "int[]" seeds. */
private static final Map<Class<?>, SeedConverter<int[],?>> CONV_INT_ARRAY = new HashMap<>();
/** Map to convert "Long" seeds. */
private static final Map<Class<?>, SeedConverter<Long,?>> CONV_LONG = new HashMap<>();
/** Map to convert "long[]" seeds. */
private static final Map<Class<?>, SeedConverter<long[],?>> CONV_LONG_ARRAY = new HashMap<>();
static {
// Input seed type is "Long".
// Key is the implementation's "native" seed type.
CONV_LONG.put(Integer.class, LONG_TO_INT);
CONV_LONG.put(Long.class, new NoOpConverter<Long>());
CONV_LONG.put(int[].class, LONG_TO_INT_ARRAY);
CONV_LONG.put(long[].class, LONG_TO_LONG_ARRAY);
// Input seed type is "Integer".
// Key is the implementation's "native" seed type.
CONV_INT.put(Integer.class, new NoOpConverter<Integer>());
CONV_INT.put(Long.class, INT_TO_LONG);
CONV_INT.put(int[].class, new SeedConverterComposer<Integer,Long,int[]>(INT_TO_LONG, LONG_TO_INT_ARRAY));
CONV_INT.put(long[].class, new SeedConverterComposer<Integer,Long,long[]>(INT_TO_LONG, LONG_TO_LONG_ARRAY));
// Input seed type is "int[]".
// Key is the implementation's "native" seed type.
CONV_INT_ARRAY.put(Integer.class, INT_ARRAY_TO_INT);
CONV_INT_ARRAY.put(Long.class, new SeedConverterComposer<int[],Integer,Long>(INT_ARRAY_TO_INT, INT_TO_LONG));
CONV_INT_ARRAY.put(int[].class, new NoOpConverter<int[]>());
CONV_INT_ARRAY.put(long[].class, INT_ARRAY_TO_LONG_ARRAY);
// Input seed type is "long[]".
// Key is the implementation's "native" seed type.
CONV_LONG_ARRAY.put(Integer.class, new SeedConverterComposer<long[],Long,Integer>(LONG_ARRAY_TO_LONG, LONG_TO_INT));
CONV_LONG_ARRAY.put(Long.class, LONG_ARRAY_TO_LONG);
CONV_LONG_ARRAY.put(int[].class, LONG_ARRAY_TO_INT_ARRAY);
CONV_LONG_ARRAY.put(long[].class, new NoOpConverter<long[]>());
}
/**
* Class only contains static method.
*/
private ProviderBuilder() {}
/**
* Creates a RNG instance.
*
* @param source RNG specification.
* @param seed Seed value. It can be {@code null} (in which case a
* random value will be used).
* @param args Additional arguments to the implementation's constructor.
* @return a new RNG instance.
* @throws MathUnsupportedOperationException if the seed type is
* invalid.
*/
public static UniformRandomProvider create(RandomSourceInternal source,
Object seed,
Object[] args) {
// Convert seed to native type.
final Object nativeSeed = createSeed(source, seed);
// Build a single array with all the arguments to be passed
// (in the right order) to the constructor.
final List<Object> all = new ArrayList<>();
all.add(nativeSeed);
if (args != null) {
all.addAll(Arrays.asList(args));
}
// Instantiate.
return create(createConstructor(source), all.toArray());
}
/**
* Creates a native seed from any of the supported seed types.
*
* @param source Source.
* @param seed Input seed.
* @return the native seed.
* @throw MathUnsupportedOperationException if the {@code seed} type
* is invalid.
*/
private static Object createSeed(RandomSourceInternal source,
Object seed) {
Object nativeSeed = null;
if (seed == null) {
// Create a random seed of the appropriate native type.
if (source.getSeed().equals(Integer.class)) {
nativeSeed = SeedFactory.createInt();
} else if (source.getSeed().equals(Long.class)) {
nativeSeed = SeedFactory.createLong();
} else if (source.getSeed().equals(int[].class)) {
nativeSeed = SeedFactory.createIntArray(RANDOM_SEED_ARRAY_SIZE);
} else if (source.getSeed().equals(long[].class)) {
nativeSeed = SeedFactory.createLongArray(RANDOM_SEED_ARRAY_SIZE);
}
} else {
// Convert to native type.
if (seed instanceof Integer) {
nativeSeed = CONV_INT.get(source.getSeed()).convert((Integer) seed);
} else if (seed instanceof Long) {
nativeSeed = CONV_LONG.get(source.getSeed()).convert((Long) seed);
} else if (seed instanceof int[]) {
nativeSeed = CONV_INT_ARRAY.get(source.getSeed()).convert((int[]) seed);
} else if (seed instanceof long[]) {
nativeSeed = CONV_LONG_ARRAY.get(source.getSeed()).convert((long[]) seed);
}
if (nativeSeed == null) {
// Since the input seed was not null, getting here means that
// no suitable converter is present in the maps.
throw new MathUnsupportedOperationException();
}
if (!source.isNativeSeed(nativeSeed)) {
// Conversion setup is wrong.
throw new MathInternalError();
}
}
return nativeSeed;
}
/**
* Creates a constructor.
*
* @param source RNG specification.
* @return a RNG constructor.
*/
private static Constructor<?> createConstructor(RandomSourceInternal source) {
try {
return source.getRng().getConstructor(source.getArgs());
} catch (NoSuchMethodException e) {
// Info in "RandomSourceInternal" is inconsistent with the
// constructor of the implementation.
throw new MathInternalError(e);
}
}
/**
* Creates a RNG.
*
* @param rng RNG specification.
* @param args Arguments to the implementation's constructor.
* @return a new RNG instance.
*/
private static UniformRandomProvider create(Constructor<?> rng,
Object[] args) {
try {
return (UniformRandomProvider) rng.newInstance(args);
} catch (InvocationTargetException |
InstantiationException |
IllegalArgumentException |
IllegalAccessException e) {
throw new MathInternalError(e);
}
}
/**
* Identifiers of the generators.
*/
public enum RandomSourceInternal {
/** Source of randomness is {@link JDKRandom}. */
JDK(JDKRandom.class,
Long.class),
/** Source of randomness is {@link Well512a}. */
WELL_512_A(Well512a.class,
int[].class),
/** Source of randomness is {@link Well1024a}. */
WELL_1024_A(Well1024a.class,
int[].class),
/** Source of randomness is {@link Well19937a}. */
WELL_19937_A(Well19937a.class,
int[].class),
/** Source of randomness is {@link Well19937c}. */
WELL_19937_C(Well19937c.class,
int[].class),
/** Source of randomness is {@link Well44497a}. */
WELL_44497_A(Well44497a.class,
int[].class),
/** Source of randomness is {@link Well44497b}. */
WELL_44497_B(Well44497b.class,
int[].class),
/** Source of randomness is {@link MersenneTwister}. */
MT(MersenneTwister.class,
int[].class),
/** Source of randomness is {@link ISAACRandom}. */
ISAAC(ISAACRandom.class,
int[].class),
/** Source of randomness is {@link SplitMix64}. */
SPLIT_MIX_64(SplitMix64.class,
Long.class),
/** Source of randomness is {@link XorShift1024Star}. */
XOR_SHIFT_1024_S(XorShift1024Star.class,
long[].class),
/** Source of randomness is {@link TwoCmres}. */
TWO_CMRES(TwoCmres.class,
Integer.class),
/**
* Source of randomness is {@link TwoCmres} with explicit selection
* of the two subcycle generators.
*/
TWO_CMRES_SELECT(TwoCmres.class,
Integer.class,
Integer.TYPE,
Integer.TYPE),
/** Source of randomness is {@link MersenneTwister64}. */
MT_64(MersenneTwister64.class,
long[].class);
/** Source type. */
private final Class<? extends UniformRandomProvider> rng;
/** Data needed to build the generator. */
private final Class<?>[] args;
/**
* @param rng Source type.
* @param args Data needed to create a generator instance.
* The first element must be the native seed type.
*/
RandomSourceInternal(Class<? extends UniformRandomProvider> rng,
Class<?> ... args) {
this.rng = rng;
this.args = Arrays.copyOf(args, args.length);
}
/**
* @return the source type.
*/
public Class<?> getRng() {
return rng;
}
/**
* @return the seed type.
*/
Class<?> getSeed() {
return args[0];
}
/**
* @return the data needed to build the generator.
*/
Class<?>[] getArgs() {
return args;
}
/**
* Checks whether the type of given {@code seed} is the native type
* of the implementation.
*
* @param <SEED> Seed type.
*
* @param seed Seed value.
* @return {@code true} if the seed can be passed to the builder
* for this RNG type.
*/
public <SEED> boolean isNativeSeed(SEED seed) {
return getSeed().equals(seed.getClass());
}
}
}

49
src/main/java/org/apache/commons/math4/rng/internal/StateSettable.java Normal file
View File

@ -0,0 +1,49 @@
/*
* 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.math4.rng.internal;
import org.apache.commons.math4.rng.RandomSource;
/**
* Indicates that the state of the instance can be saved and restored.
*
* @since 4.0
*/
public interface StateSettable {
/**
* Sets the instance's state.
*
* @param state State. The given argument must have been retrieved
* by a call to {@link #getState()}.
*
* @throws org.apache.commons.math4.exception.MathUnsupportedOperationException
* if not implemented.
*/
void setState(RandomSource.State state);
/**
* Gets the instance's state.
*
* @return the current state. The given argument can then be passed
* to {@link #setState(RandomSource.State)} in order to recover the
* current state.
*
* @throws org.apache.commons.math4.exception.MathUnsupportedOperationException
* if not implemented.
*/
RandomSource.State getState();
}

51
src/main/java/org/apache/commons/math4/rng/internal/package-info.java Normal file
View File

@ -0,0 +1,51 @@
/*
* 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.
*/
/**
* <h3>Base classes for the {@link org.apache.commons.math4.rng.UniformRandomProvider
* generation of uniformly distributed random numbers}.
* </h3>
*
* <p>
* <b>For internal use only:</b> Direct access to classes in this package
* and below, is discouraged, as they could be modified without notice.
* </p>
*
* <p><b>Notes for developers</b></p>
*
* <p>
* This package contains the common functionality.
* <br>
* Implementations that produce
* {@link org.apache.commons.math4.rng.internal.source32.RandomIntSource int}
* values are defined in the
* {@link org.apache.commons.math4.rng.internal.source32 source32} package.
* <br>
* Implementations that produce
* {@link org.apache.commons.math4.rng.internal.source64.RandomLongSource long}
* values are defined in the
* {@link org.apache.commons.math4.rng.internal.source64 source64} package.
* </p>
*
* <p>
* Each implementation must have an identifier in
* {@link org.apache.commons.math4.rng.internal.ProviderBuilder.RandomSourceInternal}
* which must be referred to from the {@link org.apache.commons.math4.rng.RandomSource public API}.
* </p>
*/
package org.apache.commons.math4.rng.internal;

208
src/main/java/org/apache/commons/math4/rng/internal/source32/AbstractWell.java Normal file
View File

@ -0,0 +1,208 @@
/*
* 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.math4.rng.internal.source32;
import java.util.Arrays;
import org.apache.commons.math4.exception.InsufficientDataException;
import org.apache.commons.math4.rng.internal.util.NumberFactory;
/**
* This abstract class implements the WELL class of pseudo-random number
* generator from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto
* Matsumoto.
* <p>
* This generator is described in a paper by Fran&ccedil;ois Panneton,
* Pierre L'Ecuyer and Makoto Matsumoto
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
* Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
* ACM Transactions on Mathematical Software, 32, 1 (2006).
* The errata for the paper are in
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
* </p>
*
* @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
*
* @since 4.0
*/
public abstract class AbstractWell extends IntProvider {
/** Current index in the bytes pool. */
protected int index;
/** Bytes pool. */
protected final int[] v;
/**
* Creates a new random number generator using an int array seed.
*
* @param k Number of bits in the pool (not necessarily a multiple of 32).
* @param seed Initial seed.
*/
protected AbstractWell(final int k,
final int[] seed) {
final int r = calculateBlockCount(k);
v = new int[r];
index = 0;
// Initialize the pool content.
setSeedInternal(seed);
}
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
final int[] s = Arrays.copyOf(v, v.length + 1);
s[v.length] = index;
return NumberFactory.makeByteArray(s);
}
/** {@inheritDoc} */
@Override
protected void setStateInternal(byte[] s) {
if (s.length != (v.length + 1) * 4) {
throw new InsufficientDataException();
}
final int[] tmp = NumberFactory.makeIntArray(s);
System.arraycopy(tmp, 0, v, 0, v.length);
index = tmp[v.length];
}
/**
* Reinitialize the generator as if just built with the given int array seed.
*
* <p>The state of the generator is exactly the same as a new generator built
* with the same seed.</p>
*
* @param seed Seed. Cannot be null.
*/
private void setSeedInternal(final int[] seed) {
System.arraycopy(seed, 0, v, 0, Math.min(seed.length, v.length));
if (seed.length < v.length) {
for (int i = seed.length; i < v.length; ++i) {
final long current = v[i - seed.length];
v[i] = (int) ((1812433253L * (current ^ (current >> 30)) + i) & 0xffffffffL);
}
}
index = 0;
}
/**
* Calculate the number of 32-bits blocks.
*
* @param k Number of bits in the pool (not necessarily a multiple of 32).
* @return the number of 32-bits blocks.
*/
private static int calculateBlockCount(final int k) {
// the bits pool contains k bits, k = r w - p where r is the number
// of w bits blocks, w is the block size (always 32 in the original paper)
// and p is the number of unused bits in the last block
final int w = 32;
final int r = (k + w - 1) / w;
return r;
}
/**
* Inner class used to store the indirection index table which is fixed for a given
* type of WELL class of pseudo-random number generator.
*/
protected static final class IndexTable {
/** Index indirection table giving for each index its predecessor taking table size into account. */
private final int[] iRm1;
/** Index indirection table giving for each index its second predecessor taking table size into account. */
private final int[] iRm2;
/** Index indirection table giving for each index the value index + m1 taking table size into account. */
private final int[] i1;
/** Index indirection table giving for each index the value index + m2 taking table size into account. */
private final int[] i2;
/** Index indirection table giving for each index the value index + m3 taking table size into account. */
private final int[] i3;
/** Creates a new pre-calculated indirection index table.
* @param k number of bits in the pool (not necessarily a multiple of 32)
* @param m1 first parameter of the algorithm
* @param m2 second parameter of the algorithm
* @param m3 third parameter of the algorithm
*/
public IndexTable(final int k, final int m1, final int m2, final int m3) {
final int r = calculateBlockCount(k);
// precompute indirection index tables. These tables are used for optimizing access
// they allow saving computations like "(j + r - 2) % r" with costly modulo operations
iRm1 = new int[r];
iRm2 = new int[r];
i1 = new int[r];
i2 = new int[r];
i3 = new int[r];
for (int j = 0; j < r; ++j) {
iRm1[j] = (j + r - 1) % r;
iRm2[j] = (j + r - 2) % r;
i1[j] = (j + m1) % r;
i2[j] = (j + m2) % r;
i3[j] = (j + m3) % r;
}
}
/**
* Returns the predecessor of the given index modulo the table size.
* @param index the index to look at
* @return (index - 1) % table size
*/
public int getIndexPred(final int index) {
return iRm1[index];
}
/**
* Returns the second predecessor of the given index modulo the table size.
* @param index the index to look at
* @return (index - 2) % table size
*/
public int getIndexPred2(final int index) {
return iRm2[index];
}
/**
* Returns index + M1 modulo the table size.
* @param index the index to look at
* @return (index + M1) % table size
*/
public int getIndexM1(final int index) {
return i1[index];
}
/**
* Returns index + M2 modulo the table size.
* @param index the index to look at
* @return (index + M2) % table size
*/
public int getIndexM2(final int index) {
return i2[index];
}
/**
* Returns index + M3 modulo the table size.
* @param index the index to look at
* @return (index + M3) % table size
*/
public int getIndexM3(final int index) {
return i3[index];
}
}
}

270
src/main/java/org/apache/commons/math4/rng/internal/source32/ISAACRandom.java Normal file
View File

@ -0,0 +1,270 @@
/*
* 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.math4.rng.internal.source32;
import java.util.Arrays;
import org.apache.commons.math4.exception.InsufficientDataException;
import org.apache.commons.math4.rng.internal.util.NumberFactory;
/**
* A fast cryptographic pseudo-random number generator.
* <p>
* ISAAC (Indirection, Shift, Accumulate, Add, and Count) generates 32-bit
* random numbers.
* ISAAC has been designed to be cryptographically secure and is inspired
* by RC4.
* Cycles are guaranteed to be at least 2<sup>40</sup> values long, and they
* are 2<sup>8295</sup> values long on average.
* The results are uniformly distributed, unbiased, and unpredictable unless
* you know the seed.
* <p>
* This code is based (with minor changes and improvements) on the original
* implementation of the algorithm by Bob Jenkins.
*
* @see <a href="http://burtleburtle.net/bob/rand/isaacafa.html">
* ISAAC: a fast cryptographic pseudo-random number generator</a>
*
* @since 4.0
*/
public class ISAACRandom extends IntProvider {
/** Log of size of rsl[] and mem[] */
private static final int SIZE_L = 8;
/** Size of rsl[] and mem[] */
private static final int SIZE = 1 << SIZE_L;
/** Half-size of rsl[] and mem[] */
private static final int H_SIZE = SIZE >> 1;
/** For pseudo-random lookup */
private static final int MASK = SIZE - 1 << 2;
/** The golden ratio */
private static final int GLD_RATIO = 0x9e3779b9;
/** The results given to the user */
private final int[] rsl = new int[SIZE];
/** The internal state */
private final int[] mem = new int[SIZE];
/** Count through the results in rsl[] */
private int count;
/** Accumulator */
private int isaacA;
/** The last result */
private int isaacB;
/** Counter, guarantees cycle is at least 2^40 */
private int isaacC;
/** Service variable. */
private final int[] arr = new int[8];
/** Service variable. */
private int isaacX;
/** Service variable. */
private int isaacI;
/** Service variable. */
private int isaacJ;
/**
* Creates a new ISAAC random number generator.
*
* @param seed Initial seed
*/
public ISAACRandom(int[] seed) {
setSeedInternal(seed);
}
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
final int[] sRsl = Arrays.copyOf(rsl, SIZE);
final int[] sMem = Arrays.copyOf(mem, SIZE);
final int[] sRem = Arrays.copyOf(new int[] { count, isaacA, isaacB, isaacC }, 4);
final int[] s = new int[2 * SIZE + sRem.length];
System.arraycopy(sRsl, 0, s, 0, SIZE);
System.arraycopy(sMem, 0, s, SIZE, SIZE);
System.arraycopy(sRem, 0, s, 2 * SIZE, sRem.length);
return NumberFactory.makeByteArray(s);
}
/** {@inheritDoc} */
@Override
protected void setStateInternal(byte[] s) {
if (s.length != (2 * SIZE + 4) * 4) {
throw new InsufficientDataException();
}
final int[] tmp = NumberFactory.makeIntArray(s);
System.arraycopy(tmp, 0, rsl, 0, SIZE);
System.arraycopy(tmp, SIZE, mem, 0, SIZE);
final int offset = 2 * SIZE;
count = tmp[offset];
isaacA = tmp[offset + 1];
isaacB = tmp[offset + 2];
isaacC = tmp[offset + 3];
}
/**
* Reseeds the RNG.
*
* @param seed Seed. Cannot be null.
*/
private void setSeedInternal(int[] seed) {
final int seedLen = seed.length;
final int rslLen = rsl.length;
System.arraycopy(seed, 0, rsl, 0, Math.min(seedLen, rslLen));
if (seedLen < rslLen) {
for (int j = seedLen; j < rslLen; j++) {
long k = rsl[j - seedLen];
rsl[j] = (int) (0x6c078965L * (k ^ k >> 30) + j & 0xffffffffL);
}
}
initState();
}
/** {@inheritDoc} */
@Override
public int next() {
if (count < 0) {
isaac();
count = SIZE - 1;
}
return rsl[count--];
}
/** Generate 256 results */
private void isaac() {
isaacI = 0;
isaacJ = H_SIZE;
isaacB += ++isaacC;
while (isaacI < H_SIZE) {
isaac2();
}
isaacJ = 0;
while (isaacJ < H_SIZE) {
isaac2();
}
}
/** Intermediate internal loop. */
private void isaac2() {
isaacX = mem[isaacI];
isaacA ^= isaacA << 13;
isaacA += mem[isaacJ++];
isaac3();
isaacX = mem[isaacI];
isaacA ^= isaacA >>> 6;
isaacA += mem[isaacJ++];
isaac3();
isaacX = mem[isaacI];
isaacA ^= isaacA << 2;
isaacA += mem[isaacJ++];
isaac3();
isaacX = mem[isaacI];
isaacA ^= isaacA >>> 16;
isaacA += mem[isaacJ++];
isaac3();
}
/** Lowest level internal loop. */
private void isaac3() {
mem[isaacI] = mem[(isaacX & MASK) >> 2] + isaacA + isaacB;
isaacB = mem[(mem[isaacI] >> SIZE_L & MASK) >> 2] + isaacX;
rsl[isaacI++] = isaacB;
}
/** Initialize, or reinitialize, this instance of rand. */
private void initState() {
isaacA = 0;
isaacB = 0;
isaacC = 0;
for (int j = 0; j < arr.length; j++) {
arr[j] = GLD_RATIO;
}
for (int j = 0; j < 4; j++) {
shuffle();
}
// fill in mem[] with messy stuff
for (int j = 0; j < SIZE; j += 8) {
arr[0] += rsl[j];
arr[1] += rsl[j + 1];
arr[2] += rsl[j + 2];
arr[3] += rsl[j + 3];
arr[4] += rsl[j + 4];
arr[5] += rsl[j + 5];
arr[6] += rsl[j + 6];
arr[7] += rsl[j + 7];
shuffle();
setState(j);
}
// second pass makes all of seed affect all of mem
for (int j = 0; j < SIZE; j += 8) {
arr[0] += mem[j];
arr[1] += mem[j + 1];
arr[2] += mem[j + 2];
arr[3] += mem[j + 3];
arr[4] += mem[j + 4];
arr[5] += mem[j + 5];
arr[6] += mem[j + 6];
arr[7] += mem[j + 7];
shuffle();
setState(j);
}
isaac();
count = SIZE - 1;
}
/** Shuffle array. */
private void shuffle() {
arr[0] ^= arr[1] << 11;
arr[3] += arr[0];
arr[1] += arr[2];
arr[1] ^= arr[2] >>> 2;
arr[4] += arr[1];
arr[2] += arr[3];
arr[2] ^= arr[3] << 8;
arr[5] += arr[2];
arr[3] += arr[4];
arr[3] ^= arr[4] >>> 16;
arr[6] += arr[3];
arr[4] += arr[5];
arr[4] ^= arr[5] << 10;
arr[7] += arr[4];
arr[5] += arr[6];
arr[5] ^= arr[6] >>> 4;
arr[0] += arr[5];
arr[6] += arr[7];
arr[6] ^= arr[7] << 8;
arr[1] += arr[6];
arr[7] += arr[0];
arr[7] ^= arr[0] >>> 9;
arr[2] += arr[7];
arr[0] += arr[1];
}
/** Set the state by copying the internal arrays.
*
* @param start First index into {@link #mem} array.
*/
private void setState(int start) {
mem[start] = arr[0];
mem[start + 1] = arr[1];
mem[start + 2] = arr[2];
mem[start + 3] = arr[3];
mem[start + 4] = arr[4];
mem[start + 5] = arr[5];
mem[start + 6] = arr[6];
mem[start + 7] = arr[7];
}
}

137
src/main/java/org/apache/commons/math4/rng/internal/source32/IntProvider.java Normal file
View File

@ -0,0 +1,137 @@
/*
* 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.math4.rng.internal.source32;
import org.apache.commons.math4.exception.OutOfRangeException;
import org.apache.commons.math4.rng.internal.util.NumberFactory;
import org.apache.commons.math4.rng.internal.BaseProvider;
/**
* Base class for all implementations that provide an {@code int}-based
* source randomness.
*/
public abstract class IntProvider
extends BaseProvider
implements RandomIntSource {
/** {@inheritDoc} */
@Override
public abstract int next();
/** {@inheritDoc} */
@Override
public int nextInt() {
return next();
}
/** {@inheritDoc} */
@Override
public boolean nextBoolean() {
return NumberFactory.makeBoolean(nextInt());
}
/** {@inheritDoc} */
@Override
public double nextDouble() {
return NumberFactory.makeDouble(nextInt(), nextInt());
}
/** {@inheritDoc} */
@Override
public float nextFloat() {
return NumberFactory.makeFloat(nextInt());
}
/** {@inheritDoc} */
@Override
public long nextLong() {
return NumberFactory.makeLong(nextInt(), nextInt());
}
/** {@inheritDoc} */
@Override
public void nextBytes(byte[] bytes) {
nextBytesFill(this, bytes, 0, bytes.length);
}
/** {@inheritDoc} */
@Override
public void nextBytes(byte[] bytes,
int start,
int len) {
if (start < 0 ||
start >= bytes.length) {
throw new OutOfRangeException(start, 0, bytes.length);
}
if (len < 0 ||
len > bytes.length - start) {
throw new OutOfRangeException(len, 0, bytes.length - start);
}
nextBytesFill(this, bytes, start, len);
}
/**
* Generates random bytes and places them into a user-supplied array.
*
* <p>
* The array is filled with bytes extracted from random {@code int} values.
* This implies that the number of random bytes generated may be larger than
* the length of the byte array.
* </p>
*
* @param source Source of randomness.
* @param bytes Array in which to put the generated bytes. Cannot be null.
* @param start Index at which to start inserting the generated bytes.
* @param len Number of bytes to insert.
*/
static void nextBytesFill(RandomIntSource source,
byte[] bytes,
int start,
int len) {
int index = start; // Index of first insertion.
// Index of first insertion plus multiple of 4 part of length
// (i.e. length with 2 least significant bits unset).
final int indexLoopLimit = index + (len & 0x7ffffffc);
// Start filling in the byte array, 4 bytes at a time.
while (index < indexLoopLimit) {
final int random = source.next();
bytes[index++] = (byte) random;
bytes[index++] = (byte) (random >>> 8);
bytes[index++] = (byte) (random >>> 16);
bytes[index++] = (byte) (random >>> 24);
}
final int indexLimit = start + len; // Index of last insertion + 1.
// Fill in the remaining bytes.
if (index < indexLimit) {
int random = source.next();
while (true) {
bytes[index++] = (byte) random;
if (index < indexLimit) {
random >>>= 8;
} else {
break;
}
}
}
}
}

95
src/main/java/org/apache/commons/math4/rng/internal/source32/JDKRandom.java Normal file
View File

@ -0,0 +1,95 @@
/*
* 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.math4.rng.internal.source32;
import java.util.Random;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
/**
* A provider that uses the {@link Random#nextInt()} method of the JDK's
* {@code Random} class as the source of randomness.
*
* <p>
* <b>Caveat:</b> All the other calls will be redirected to the methods
* implemented within this library.
* </p>
*
* <p>
* The state of this source of randomness is saved and restored through
* the serialization of the {@link Random} instance.
* </p>
*
* @since 4.0
*/
public class JDKRandom extends IntProvider {
/** Delegate. Cannot be "final" (to allow serialization). */
private Random delegate;
/**
* Creates an instance with the given seed.
*
* @param seed Initial seed.
*/
public JDKRandom(Long seed) {
delegate = new Random(seed);
}
/**
* {@inheritDoc}
*
* @see Random#nextInt()
*/
@Override
public int next() {
return delegate.nextInt();
}
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
try {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final ObjectOutputStream oos = new ObjectOutputStream(bos);
// Serialize the "delegate".
oos.writeObject(delegate);
return bos.toByteArray();
} catch (IOException e) {
// Workaround checked exception.
throw new RuntimeException(e);
}
}
/** {@inheritDoc} */
@Override
protected void setStateInternal(byte[] s) {
try {
final ByteArrayInputStream bis = new ByteArrayInputStream(s);
final ObjectInputStream ois = new ObjectInputStream(bis);
delegate = (Random) ois.readObject();
} catch (ClassNotFoundException|IOException e) {
// Workaround checked exception.
throw new RuntimeException(e);
}
}
}

230
src/main/java/org/apache/commons/math4/rng/internal/source32/MersenneTwister.java Normal file
View File

@ -0,0 +1,230 @@
/*
* 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.math4.rng.internal.source32;
import java.util.Arrays;
import org.apache.commons.math4.exception.InsufficientDataException;
import org.apache.commons.math4.rng.internal.util.NumberFactory;
/**
* This class implements a powerful pseudo-random number generator
* developed by Makoto Matsumoto and Takuji Nishimura during
* 1996-1997.
*
* <p>
* This generator features an extremely long period
* (2<sup>19937</sup>-1) and 623-dimensional equidistribution up to
* 32 bits accuracy. The home page for this generator is located at
* <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html">
* http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html</a>.
* </p>
*
* <p>
* This generator is described in a paper by Makoto Matsumoto and
* Takuji Nishimura in 1998:
* <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/mt.pdf">
* Mersenne Twister: A 623-Dimensionally Equidistributed Uniform Pseudo-Random
* Number Generator</a>,
* ACM Transactions on Modeling and Computer Simulation, Vol. 8, No. 1,
* January 1998, pp 3--30
* </p>
*
* <p>
* This class is mainly a Java port of the
* <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html">
* 2002-01-26 version of the generator</a> written in C by Makoto Matsumoto
* and Takuji Nishimura. Here is their original copyright:
* </p>
*
* <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
* <tr><td>Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
* All rights reserved.</td></tr>
*
* <tr><td>Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* <ol>
* <li>Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.</li>
* <li>Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.</li>
* <li>The names of its contributors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.</li>
* </ol></td></tr>
*
* <tr><td><strong>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.</strong></td></tr>
* </table>
*
* @since 4.0
*/
public class MersenneTwister extends IntProvider {
/** Mask 32 most significant bits. */
private static final long INT_MASK_LONG = 0xffffffffL;
/** Most significant w-r bits. */
private static final long UPPER_MASK_LONG = 0x80000000L;
/** Least significant r bits */
private static final long LOWER_MASK_LONG = 0x7fffffffL;
/** Most significant w-r bits. */
private static final int UPPER_MASK = 0x80000000;
/** Least significant r bits */
private static final int LOWER_MASK = 0x7fffffff;
/** Size of the bytes pool. */
private static final int N = 624;
/** Period second parameter. */
private static final int M = 397;
/** X * MATRIX_A for X = {0, 1}. */
private static final int[] MAG01 = { 0x0, 0x9908b0df };
/** Bytes pool. */
private int[] mt = new int[N];
/** Current index in the bytes pool. */
private int mti;
/**
* Creates a new random number generator.
*
* @param seed Initial seed.
*/
public MersenneTwister(int[] seed) {
setSeedInternal(seed);
}
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
final int[] s = Arrays.copyOf(mt, N + 1);
s[N] = mti;
return NumberFactory.makeByteArray(s);
}
/** {@inheritDoc} */
@Override
protected void setStateInternal(byte[] s) {
if (s.length != (N + 1) * 4) {
throw new InsufficientDataException();
}
final int[] tmp = NumberFactory.makeIntArray(s);
System.arraycopy(tmp, 0, mt, 0, N);
mti = tmp[N];
}
/**
* Reinitializes the generator as if just built with the given seed.
*
* @param seed Initial seed.
*/
private void setSeedInternal(int[] seed) {
initState(19650218);
int i = 1;
int j = 0;
for (int k = Math.max(N, seed.length); k != 0; k--) {
final long l0 = (mt[i] & LOWER_MASK_LONG) | ((mt[i] < 0) ? UPPER_MASK_LONG : 0);
final long l1 = (mt[i-1] & LOWER_MASK_LONG) | ((mt[i-1] < 0) ? UPPER_MASK_LONG : 0);
final long l = (l0 ^ ((l1 ^ (l1 >> 30)) * 1664525l)) + seed[j] + j; // non linear
mt[i] = (int) (l & INT_MASK_LONG);
i++; j++;
if (i >= N) {
mt[0] = mt[N - 1];
i = 1;
}
if (j >= seed.length) {
j = 0;
}
}
for (int k = N - 1; k != 0; k--) {
final long l0 = (mt[i] & LOWER_MASK_LONG) | ((mt[i] < 0) ? UPPER_MASK_LONG : 0);
final long l1 = (mt[i-1] & LOWER_MASK_LONG) | ((mt[i-1] < 0) ? UPPER_MASK_LONG : 0);
final long l = (l0 ^ ((l1 ^ (l1 >> 30)) * 1566083941l)) - i; // non linear
mt[i] = (int) (l & INT_MASK_LONG);
i++;
if (i >= N) {
mt[0] = mt[N - 1];
i = 1;
}
}
mt[0] = UPPER_MASK; // MSB is 1; assuring non-zero initial array
}
/**
* Initialize the internal state of this instance.
*
* @param seed Seed.
*/
private void initState(int seed) {
long longMT = seed & INT_MASK_LONG;
mt[0]= (int) longMT;
for (mti = 1; mti < N; ++mti) {
longMT = (1812433253L * (longMT ^ (longMT >> 30)) + mti) & INT_MASK_LONG;
mt[mti]= (int) longMT;
}
}
/** {@inheritDoc} */
@Override
public int next() {
int y;
if (mti >= N) { // Generate N words at one time.
int mtNext = mt[0];
for (int k = 0; k < N - M; ++k) {
int mtCurr = mtNext;
mtNext = mt[k + 1];
y = (mtCurr & UPPER_MASK) | (mtNext & LOWER_MASK);
mt[k] = mt[k + M] ^ (y >>> 1) ^ MAG01[y & 1];
}
for (int k = N - M; k < N - 1; ++k) {
int mtCurr = mtNext;
mtNext = mt[k + 1];
y = (mtCurr & UPPER_MASK) | (mtNext & LOWER_MASK);
mt[k] = mt[k + (M - N)] ^ (y >>> 1) ^ MAG01[y & 1];
}
y = (mtNext & UPPER_MASK) | (mt[0] & LOWER_MASK);
mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ MAG01[y & 1];
mti = 0;
}
y = mt[mti++];
// Tempering.
y ^= y >>> 11;
y ^= (y << 7) & 0x9d2c5680;
y ^= (y << 15) & 0xefc60000;
y ^= y >>> 18;
return y;
}
}

30
src/main/java/org/apache/commons/math4/rng/internal/source32/RandomIntSource.java Normal file
View File

@ -0,0 +1,30 @@
/*
* 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.math4.rng.internal.source32;
/**
* Source of randomness that generate values of type {@code int}.
*
* @since 4.0
*/
public interface RandomIntSource {
/**
* @return the next random value.
*/
int next();
}

78
src/main/java/org/apache/commons/math4/rng/internal/source32/Well1024a.java Normal file
View File

@ -0,0 +1,78 @@
/*
* 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.math4.rng.internal.source32;
/**
* This class implements the WELL1024a pseudo-random number generator
* from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
* <p>
* This generator is described in a paper by Fran&ccedil;ois Panneton,
* Pierre L'Ecuyer and Makoto Matsumoto
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
* Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
* ACM Transactions on Mathematical Software, 32, 1 (2006).
* The errata for the paper are in
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
* </p>
*
* @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
* @since 4.0
*/
public class Well1024a extends AbstractWell {
/** Number of bits in the pool. */
private static final int K = 1024;
/** First parameter of the algorithm. */
private static final int M1 = 3;
/** Second parameter of the algorithm. */
private static final int M2 = 24;
/** Third parameter of the algorithm. */
private static final int M3 = 10;
/** The indirection index table. */
private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
/**
* Creates a new random number generator.
*
* @param seed Initial seed.
*/
public Well1024a(int[] seed) {
super(K, seed);
}
/** {@inheritDoc} */
@Override
public int next() {
final int indexRm1 = TABLE.getIndexPred(index);
final int v0 = v[index];
final int vM1 = v[TABLE.getIndexM1(index)];
final int vM2 = v[TABLE.getIndexM2(index)];
final int vM3 = v[TABLE.getIndexM3(index)];
final int z0 = v[indexRm1];
final int z1 = v0 ^ (vM1 ^ (vM1 >>> 8));
final int z2 = (vM2 ^ (vM2 << 19)) ^ (vM3 ^ (vM3 << 14));
final int z3 = z1 ^ z2;
final int z4 = (z0 ^ (z0 << 11)) ^ (z1 ^ (z1 << 7)) ^ (z2 ^ (z2 << 13));
v[index] = z3;
v[indexRm1] = z4;
index = indexRm1;
return z4;
}
}

80
src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937a.java Normal file
View File

@ -0,0 +1,80 @@
/*
* 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.math4.rng.internal.source32;
/**
* This class implements the WELL19937a pseudo-random number generator
* from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
* <p>
* This generator is described in a paper by Fran&ccedil;ois Panneton,
* Pierre L'Ecuyer and Makoto Matsumoto
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
* Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
* ACM Transactions on Mathematical Software, 32, 1 (2006).
* The errata for the paper are in
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
* </p>
*
* @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
* @since 4.0
*/
public class Well19937a extends AbstractWell {
/** Number of bits in the pool. */
private static final int K = 19937;
/** First parameter of the algorithm. */
private static final int M1 = 70;
/** Second parameter of the algorithm. */
private static final int M2 = 179;
/** Third parameter of the algorithm. */
private static final int M3 = 449;
/** The indirection index table. */
private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
/**
* Creates a new random number generator.
*
* @param seed Initial seed.
*/
public Well19937a(int[] seed) {
super(K, seed);
}
/** {@inheritDoc} */
@Override
public int next() {
final int indexRm1 = TABLE.getIndexPred(index);
final int indexRm2 = TABLE.getIndexPred2(index);
final int v0 = v[index];
final int vM1 = v[TABLE.getIndexM1(index)];
final int vM2 = v[TABLE.getIndexM2(index)];
final int vM3 = v[TABLE.getIndexM3(index)];
final int z0 = (0x80000000 & v[indexRm1]) ^ (0x7FFFFFFF & v[indexRm2]);
final int z1 = (v0 ^ (v0 << 25)) ^ (vM1 ^ (vM1 >>> 27));
final int z2 = (vM2 >>> 9) ^ (vM3 ^ (vM3 >>> 1));
final int z3 = z1 ^ z2;
final int z4 = z0 ^ (z1 ^ (z1 << 9)) ^ (z2 ^ (z2 << 21)) ^ (z3 ^ (z3 >>> 21));
v[index] = z3;
v[indexRm1] = z4;
v[indexRm2] &= 0x80000000;
index = indexRm1;
return z4;
}
}

85
src/main/java/org/apache/commons/math4/rng/internal/source32/Well19937c.java Normal file
View File

@ -0,0 +1,85 @@
/*
* 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.math4.rng.internal.source32;
/**
* This class implements the WELL19937c pseudo-random number generator
* from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
* <p>
* This generator is described in a paper by Fran&ccedil;ois Panneton,
* Pierre L'Ecuyer and Makoto Matsumoto
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
* Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
* ACM Transactions on Mathematical Software, 32, 1 (2006).
* The errata for the paper are in
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
* </p>
*
* @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
* @since 2.2
*/
public class Well19937c extends AbstractWell {
/** Number of bits in the pool. */
private static final int K = 19937;
/** First parameter of the algorithm. */
private static final int M1 = 70;
/** Second parameter of the algorithm. */
private static final int M2 = 179;
/** Third parameter of the algorithm. */
private static final int M3 = 449;
/** The indirection index table. */
private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
/**
* Creates a new random number generator.
*
* @param seed Initial seed.
*/
public Well19937c(int[] seed) {
super(K, seed);
}
/** {@inheritDoc} */
@Override
public int next() {
final int indexRm1 = TABLE.getIndexPred(index);
final int indexRm2 = TABLE.getIndexPred2(index);
final int v0 = v[index];
final int vM1 = v[TABLE.getIndexM1(index)];
final int vM2 = v[TABLE.getIndexM2(index)];
final int vM3 = v[TABLE.getIndexM3(index)];
final int z0 = (0x80000000 & v[indexRm1]) ^ (0x7FFFFFFF & v[indexRm2]);
final int z1 = (v0 ^ (v0 << 25)) ^ (vM1 ^ (vM1 >>> 27));
final int z2 = (vM2 >>> 9) ^ (vM3 ^ (vM3 >>> 1));
final int z3 = z1 ^ z2;
int z4 = z0 ^ (z1 ^ (z1 << 9)) ^ (z2 ^ (z2 << 21)) ^ (z3 ^ (z3 >>> 21));
v[index] = z3;
v[indexRm1] = z4;
v[indexRm2] &= 0x80000000;
index = indexRm1;
// add Matsumoto-Kurita tempering
// to get a maximally-equidistributed generator
z4 ^= (z4 << 7) & 0xe46e1700;
z4 ^= (z4 << 15) & 0x9b868000;
return z4;
}
}

83
src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497a.java Normal file
View File

@ -0,0 +1,83 @@
/*
* 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.math4.rng.internal.source32;
/**
* This class implements the WELL44497a pseudo-random number generator
* from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
* <p>
* This generator is described in a paper by Fran&ccedil;ois Panneton,
* Pierre L'Ecuyer and Makoto Matsumoto
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
* Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
* ACM Transactions on Mathematical Software, 32, 1 (2006).
* The errata for the paper are in
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
* </p>
*
* @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
* @since 4.0
*/
public class Well44497a extends AbstractWell {
/** Number of bits in the pool. */
private static final int K = 44497;
/** First parameter of the algorithm. */
private static final int M1 = 23;
/** Second parameter of the algorithm. */
private static final int M2 = 481;
/** Third parameter of the algorithm. */
private static final int M3 = 229;
/** The indirection index table. */
private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
/**
* Creates a new random number generator.
*
* @param seed Initial seed.
*/
public Well44497a(int[] seed) {
super(K, seed);
}
/** {@inheritDoc} */
@Override
public int next() {
final int indexRm1 = TABLE.getIndexPred(index);
final int indexRm2 = TABLE.getIndexPred2(index);
final int v0 = v[index];
final int vM1 = v[TABLE.getIndexM1(index)];
final int vM2 = v[TABLE.getIndexM2(index)];
final int vM3 = v[TABLE.getIndexM3(index)];
// the values below include the errata of the original article
final int z0 = (0xFFFF8000 & v[indexRm1]) ^ (0x00007FFF & v[indexRm2]);
final int z1 = (v0 ^ (v0 << 24)) ^ (vM1 ^ (vM1 >>> 30));
final int z2 = (vM2 ^ (vM2 << 10)) ^ (vM3 << 26);
final int z3 = z1 ^ z2;
final int z2Prime = ((z2 << 9) ^ (z2 >>> 23)) & 0xfbffffff;
final int z2Second = ((z2 & 0x00020000) != 0) ? (z2Prime ^ 0xb729fcec) : z2Prime;
final int z4 = z0 ^ (z1 ^ (z1 >>> 20)) ^ z2Second ^ z3;
v[index] = z3;
v[indexRm1] = z4;
v[indexRm2] &= 0xFFFF8000;
index = indexRm1;
return z4;
}
}

90
src/main/java/org/apache/commons/math4/rng/internal/source32/Well44497b.java Normal file
View File

@ -0,0 +1,90 @@
/*
* 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.math4.rng.internal.source32;
/**
* This class implements the WELL44497b pseudo-random number generator
* from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
* <p>
* This generator is described in a paper by Fran&ccedil;ois Panneton,
* Pierre L'Ecuyer and Makoto Matsumoto
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
* Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
* ACM Transactions on Mathematical Software, 32, 1 (2006).
* The errata for the paper are in
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
* </p>
*
* @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
* @since 4.0
*/
public class Well44497b extends AbstractWell {
/** Number of bits in the pool. */
private static final int K = 44497;
/** First parameter of the algorithm. */
private static final int M1 = 23;
/** Second parameter of the algorithm. */
private static final int M2 = 481;
/** Third parameter of the algorithm. */
private static final int M3 = 229;
/** The indirection index table. */
private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
/**
* Creates a new random number generator.
*
* @param seed Initial seed.
*/
public Well44497b(int[] seed) {
super(K, seed);
}
/** {@inheritDoc} */
@Override
public int next() {
// compute raw value given by WELL44497a generator
// which is NOT maximally-equidistributed
final int indexRm1 = TABLE.getIndexPred(index);
final int indexRm2 = TABLE.getIndexPred2(index);
final int v0 = v[index];
final int vM1 = v[TABLE.getIndexM1(index)];
final int vM2 = v[TABLE.getIndexM2(index)];
final int vM3 = v[TABLE.getIndexM3(index)];
// the values below include the errata of the original article
final int z0 = (0xFFFF8000 & v[indexRm1]) ^ (0x00007FFF & v[indexRm2]);
final int z1 = (v0 ^ (v0 << 24)) ^ (vM1 ^ (vM1 >>> 30));
final int z2 = (vM2 ^ (vM2 << 10)) ^ (vM3 << 26);
final int z3 = z1 ^ z2;
final int z2Prime = ((z2 << 9) ^ (z2 >>> 23)) & 0xfbffffff;
final int z2Second = ((z2 & 0x00020000) != 0) ? (z2Prime ^ 0xb729fcec) : z2Prime;
int z4 = z0 ^ (z1 ^ (z1 >>> 20)) ^ z2Second ^ z3;
v[index] = z3;
v[indexRm1] = z4;
v[indexRm2] &= 0xFFFF8000;
index = indexRm1;
// add Matsumoto-Kurita tempering
// to get a maximally-equidistributed generator
z4 ^= (z4 << 7) & 0x93dd1400;
z4 ^= (z4 << 15) & 0xfa118000;
return z4;
}
}

78
src/main/java/org/apache/commons/math4/rng/internal/source32/Well512a.java Normal file
View File

@ -0,0 +1,78 @@
/*
* 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.math4.rng.internal.source32;
/**
* This class implements the WELL512a pseudo-random number generator
* from Fran&ccedil;ois Panneton, Pierre L'Ecuyer and Makoto Matsumoto.
* <p>
* This generator is described in a paper by Fran&ccedil;ois Panneton,
* Pierre L'Ecuyer and Makoto Matsumoto
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng.pdf">
* Improved Long-Period Generators Based on Linear Recurrences Modulo 2</a>
* ACM Transactions on Mathematical Software, 32, 1 (2006).
* The errata for the paper are in
* <a href="http://www.iro.umontreal.ca/~lecuyer/myftp/papers/wellrng-errata.txt">wellrng-errata.txt</a>.
* </p>
*
* @see <a href="http://www.iro.umontreal.ca/~panneton/WELLRNG.html">WELL Random number generator</a>
* @since 4.0
*/
public class Well512a extends AbstractWell {
/** Number of bits in the pool. */
private static final int K = 512;
/** First parameter of the algorithm. */
private static final int M1 = 13;
/** Second parameter of the algorithm. */
private static final int M2 = 9;
/** Third parameter of the algorithm. */
private static final int M3 = 5;
/** The indirection index table. */
private static final IndexTable TABLE = new IndexTable(K, M1, M2, M3);
/**
* Creates a new random number generator.
*
* @param seed Initial seed.
*/
public Well512a(int[] seed) {
super(K, seed);
}
/** {@inheritDoc} */
@Override
public int next() {
final int indexRm1 = TABLE.getIndexPred(index);
final int vi = v[index];
final int vi1 = v[TABLE.getIndexM1(index)];
final int vi2 = v[TABLE.getIndexM2(index)];
final int z0 = v[indexRm1];
// the values below include the errata of the original article
final int z1 = (vi ^ (vi << 16)) ^ (vi1 ^ (vi1 << 15));
final int z2 = vi2 ^ (vi2 >>> 11);
final int z3 = z1 ^ z2;
final int z4 = (z0 ^ (z0 << 2)) ^ (z1 ^ (z1 << 18)) ^ (z2 << 28) ^ (z3 ^ ((z3 << 5) & 0xda442d24));
v[index] = z3;
v[indexRm1] = z4;
index = indexRm1;
return z4;
}
}

52
src/main/java/org/apache/commons/math4/rng/internal/source32/package-info.java Normal file
View File

@ -0,0 +1,52 @@
/*
* 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.
*/
/**
* <h3>
* Concrete algorithms for {@code int}-based sources of randomness
* </h3>
*
* <p>
* <b>For internal use only:</b> Direct access to classes in this package
* is discouraged, as they could be modified without notice.
* </p>
*
* <p><b>Notes for developers</b></p>
*
* <ul>
* <li>
* A source of randomness must inherit from
* {@link org.apache.commons.math4.rng.internal.source32.IntProvider}
* </li>
* <li>
* The "provider" must specify <em>one</em> way for setting the seed.
* For a given seed, the generated sequence must always be the same.
* </li>
* <li>
* The "provider" must implement methods {@code getStateInternal} and
* {@code setStateInternal} in order to save and restore the state of an
* instance (cf. {@link org.apache.commons.math4.rng.internal.BaseProvider}).
* </li>
* <li>
* When a new class is implemented here, user-access to it must be provided
* through associated {@link org.apache.commons.math4.rng.RandomSource
* factory methods}.
* </li>
* </ul>
*/
package org.apache.commons.math4.rng.internal.source32;

141
src/main/java/org/apache/commons/math4/rng/internal/source64/LongProvider.java Normal file
View File

@ -0,0 +1,141 @@
/*
* 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.math4.rng.internal.source64;
import org.apache.commons.math4.exception.OutOfRangeException;
import org.apache.commons.math4.rng.internal.util.NumberFactory;
import org.apache.commons.math4.rng.internal.BaseProvider;
/**
* Base class for all implementations that provide a {@code long}-based
* source randomness.
*/
public abstract class LongProvider
extends BaseProvider
implements RandomLongSource {
/** {@inheritDoc} */
@Override
public abstract long next();
/** {@inheritDoc} */
@Override
public long nextLong() {
return next();
}
/** {@inheritDoc} */
@Override
public int nextInt() {
return NumberFactory.makeInt(nextLong());
}
/** {@inheritDoc} */
@Override
public double nextDouble() {
return NumberFactory.makeDouble(nextLong());
}
/** {@inheritDoc} */
@Override
public boolean nextBoolean() {
return NumberFactory.makeBoolean(nextLong());
}
/** {@inheritDoc} */
@Override
public float nextFloat() {
return NumberFactory.makeFloat(nextInt());
}
/** {@inheritDoc} */
@Override
public void nextBytes(byte[] bytes) {
nextBytesFill(this, bytes, 0, bytes.length);
}
/** {@inheritDoc} */
@Override
public void nextBytes(byte[] bytes,
int start,
int len) {
if (start < 0 ||
start >= bytes.length) {
throw new OutOfRangeException(start, 0, bytes.length);
}
if (len < 0 ||
len > bytes.length - start) {
throw new OutOfRangeException(len, 0, bytes.length - start);
}
nextBytesFill(this, bytes, start, len);
}
/**
* Generates random bytes and places them into a user-supplied array.
*
* <p>
* The array is filled with bytes extracted from random {@code long} values.
* This implies that the number of random bytes generated may be larger than
* the length of the byte array.
* </p>
*
* @param source Source of randomness.
* @param bytes Array in which to put the generated bytes. Cannot be null.
* @param start Index at which to start inserting the generated bytes.
* @param len Number of bytes to insert.
*/
static void nextBytesFill(RandomLongSource source,
byte[] bytes,
int start,
int len) {
int index = start; // Index of first insertion.
// Index of first insertion plus multiple of 8 part of length
// (i.e. length with 3 least significant bits unset).
final int indexLoopLimit = index + (len & 0x7ffffff8);
// Start filling in the byte array, 8 bytes at a time.
while (index < indexLoopLimit) {
final long random = source.next();
bytes[index++] = (byte) random;
bytes[index++] = (byte) (random >>> 8);
bytes[index++] = (byte) (random >>> 16);
bytes[index++] = (byte) (random >>> 24);
bytes[index++] = (byte) (random >>> 32);
bytes[index++] = (byte) (random >>> 40);
bytes[index++] = (byte) (random >>> 48);
bytes[index++] = (byte) (random >>> 56);
}
final int indexLimit = start + len; // Index of last insertion + 1.
// Fill in the remaining bytes.
if (index < indexLimit) {
long random = source.next();
while (true) {
bytes[index++] = (byte) random;
if (index < indexLimit) {
random >>>= 8;
} else {
break;
}
}
}
}
}

201
src/main/java/org/apache/commons/math4/rng/internal/source64/MersenneTwister64.java Normal file
View File

@ -0,0 +1,201 @@
/*
* 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.math4.rng.internal.source64;
import java.util.Arrays;
import org.apache.commons.math4.exception.InsufficientDataException;
import org.apache.commons.math4.rng.internal.util.NumberFactory;
/**
* This class provides the 64-bits version of the originally 32-bits
* {@link org.apache.commons.math4.rng.internal.source32.MersenneTwister
* Mersenne Twister}.
*
* <p>
* This class is mainly a Java port of
* <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt64.html">
* the 2014/2/23 version of the generator
* </a> written in C by Takuji Nishimura and Makoto Matsumoto.
* </p>
*
* <p>
* Here is their original copyright:
* </p>
*
* <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
* <tr><td>Copyright (C) 2004, Makoto Matsumoto and Takuji Nishimura,
* All rights reserved.</td></tr>
*
* <tr><td>Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* <ol>
* <li>Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.</li>
* <li>Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.</li>
* <li>The names of its contributors may not be used to endorse or promote
* products derived from this software without specific prior written
* permission.</li>
* </ol></td></tr>
*
* <tr><td><strong>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.</strong></td></tr>
* </table>
*
* @since 4.0
*/
public class MersenneTwister64 extends LongProvider {
/** Size of the bytes pool. */
private static final int NN = 312;
/** Period second parameter. */
private static final int MM = 156;
/** X * MATRIX_A for X = {0, 1}. */
private static final long[] MAG01 = { 0x0, 0xb5026f5aa96619e9L };
/** Most significant 33 bits. */
private static final long UM = 0xffffffff80000000L;
/** Least significant 31 bits. */
private static final long LM = 0x7fffffffL;
/** Bytes pool. */
private long[] mt = new long[NN];
/** Current index in the bytes pool. */
private int mti;
/**
* Creates a new random number generator.
*
* @param seed Initial seed.
*/
public MersenneTwister64(long[] seed) {
setSeedInternal(seed);
}
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
final long[] s = Arrays.copyOf(mt, NN + 1);
s[NN] = mti;
return NumberFactory.makeByteArray(s);
}
/** {@inheritDoc} */
@Override
protected void setStateInternal(byte[] s) {
if (s.length != (NN + 1) * 8) {
throw new InsufficientDataException();
}
final long[] tmp = NumberFactory.makeLongArray(s);
System.arraycopy(tmp, 0, mt, 0, NN);
mti = (int) tmp[NN];
}
/**
* Reinitializes the generator as if just built with the given seed.
*
* @param seed Initial seed.
*/
private void setSeedInternal(long[] seed) {
initState(19650218L);
int i = 1;
int j = 0;
for (int k = Math.max(NN, seed.length); k != 0; k--) {
final long mm1 = mt[i - 1];
mt[i] = (mt[i] ^ ((mm1 ^ (mm1 >>> 62)) * 0x369dea0f31a53f85L)) + seed[j] + j; // non linear
i++;
j++;
if (i >= NN) {
mt[0] = mt[NN - 1];
i = 1;
}
if (j >= seed.length) {
j = 0;
}
}
for (int k = NN - 1; k != 0; k--) {
final long mm1 = mt[i - 1];
mt[i] = (mt[i] ^ ((mm1 ^ (mm1 >>> 62)) * 0x27bb2ee687b0b0fdL)) - i; // non linear
i++;
if (i >= NN) {
mt[0] = mt[NN - 1];
i = 1;
}
}
mt[0] = 0x8000000000000000L; // MSB is 1; assuring non-zero initial array
}
/**
* Initialize the internal state of this instance.
*
* @param seed Seed.
*/
private void initState(long seed) {
mt[0] = seed;
for (mti = 1; mti < NN; mti++) {
final long mm1 = mt[mti - 1];
mt[mti] = 0x5851f42d4c957f2dL * (mm1 ^ (mm1 >>> 62)) + mti;
}
}
/** {@inheritDoc} */
@Override
public long next() {
long x;
if (mti >= NN) { // generate NN words at one time
for (int i = 0; i < NN - MM; i++) {
x = (mt[i] & UM) | (mt[i + 1] & LM);
mt[i] = mt[i + MM] ^ (x >>> 1) ^ MAG01[(int)(x & 0x1L)];
}
for (int i = NN - MM; i < NN - 1; i++) {
x = (mt[i] & UM) | (mt[i + 1] & LM);
mt[i] = mt[ i + (MM - NN)] ^ (x >>> 1) ^ MAG01[(int)(x & 0x1L)];
}
x = (mt[NN - 1] & UM) | (mt[0] & LM);
mt[NN - 1] = mt[MM - 1] ^ (x >>> 1) ^ MAG01[(int)(x & 0x1L)];
mti = 0;
}
x = mt[mti++];
x ^= (x >>> 29) & 0x5555555555555555L;
x ^= (x << 17) & 0x71d67fffeda60000L;
x ^= (x << 37) & 0xfff7eee000000000L;
x ^= x >>> 43;
return x;
}
}

30
src/main/java/org/apache/commons/math4/rng/internal/source64/RandomLongSource.java Normal file
View File

@ -0,0 +1,30 @@
/*
* 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.math4.rng.internal.source64;
/**
* Source of randomness that generate values of type {@code long}.
*
* @since 4.0
*/
public interface RandomLongSource {
/**
* @return the next random value.
*/
long next();
}

78
src/main/java/org/apache/commons/math4/rng/internal/source64/SplitMix64.java Normal file
View File

@ -0,0 +1,78 @@
/*
* 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.math4.rng.internal.source64;
import org.apache.commons.math4.exception.InsufficientDataException;
import org.apache.commons.math4.rng.internal.util.NumberFactory;
/**
* A fast RNG, with 64 bits of state, that can be used to initialize the
* state of other generators.
*
* @see <a href="http://xorshift.di.unimi.it/splitmix64.c">
* Original source code</a>
*
* @since 4.0
*/
public class SplitMix64 extends LongProvider {
/** State. */
private long state;
/**
* Creates a new instance.
*
* @param seed Initial seed.
*/
public SplitMix64(Long seed) {
setSeedInternal(seed);
}
/**
* Seeds the RNG.
*
* @param seed Seed.
*/
private void setSeedInternal(Long seed) {
state = seed;
}
/** {@inheritDoc} */
@Override
public long next() {
long z = state += 0x9e3779b97f4a7c15L;
z = (z ^ (z >>> 30)) * 0xbf58476d1ce4e5b9L;
z = (z ^ (z >>> 27)) * 0x94d049bb133111ebL;
return z ^ (z >>> 31);
}
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
return NumberFactory.makeByteArray(state);
}
/** {@inheritDoc} */
@Override
protected void setStateInternal(byte[] s) {
if (s.length != 8) {
throw new InsufficientDataException();
}
state = NumberFactory.makeLong(s);
}
}

310
src/main/java/org/apache/commons/math4/rng/internal/source64/TwoCmres.java Normal file
View File

@ -0,0 +1,310 @@
/*
* 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.math4.rng.internal.source64;
import java.util.List;
import java.util.ArrayList;
import org.apache.commons.math4.exception.MathInternalError;
import org.apache.commons.math4.exception.OutOfRangeException;
import org.apache.commons.math4.exception.InsufficientDataException;
import org.apache.commons.math4.rng.internal.util.NumberFactory;
/**
* Random number generator designed by Mark D. Overton.
* <p>
* It is one of the many generators described by the author in the following article series:
* <ul>
* <li><a href="http://www.drdobbs.com/tools/fast-high-quality-parallel-random-number/229625477">Part one</a></li>
* <li><a href="http://www.drdobbs.com/tools/fast-high-quality-parallel-random-number/231000484">Part two</a></li>
* </ul>
* </p>
*
* @since 4.0
*/
public class TwoCmres extends LongProvider {
/** A small positive integer. */
private static final byte SEED_GUARD = 9;
/** Factory of instances of this class. Singleton. */
private static final Cmres.Factory FACTORY = new Cmres.Factory();
/** First subcycle generator. */
private final Cmres x;
/** Second subcycle generator. */
private final Cmres y;
/** State of first subcycle generator. */
private long xx;
/** State of second subcycle generator. */
private long yy;
/**
* Creates a new instance.
*
* @param seed Initial seed.
* @param x First subcycle generator.
* @param y Second subcycle generator.
* @throws InsufficientDataException if {@code x == y}.
*/
private TwoCmres(int seed,
Cmres x,
Cmres y) {
if (x == y) {
throw new InsufficientDataException();
}
this.x = x;
this.y = y;
setSeedInternal(seed);
}
/**
* Creates a new instance.
*
* @param seed Seed.
*/
public TwoCmres(Integer seed) {
this(seed, 0, 1);
}
/**
* Creates a new instance.
*
* @param seed Seed.
* @param i Table entry for first subcycle generator.
* @param j Table entry for second subcycle generator.
* @throws InsufficientDataException if {@code i == j}.
* @throws OutOfRangeException if {@code i < 0} or
* {@code i >= numberOfSubcycleGenerators()}.
* @throws OutOfRangeException if {@code j < 0} or
* {@code j >= numberOfSubcycleGenerators()}.
*/
public TwoCmres(Integer seed,
int i,
int j) {
this(seed, FACTORY.get(i), FACTORY.get(j));
}
/** {@inheritDoc} */
@Override
public long next() {
xx = x.transform(xx);
yy = y.transform(yy);
return xx + yy;
}
/** {@inheritDoc} */
@Override
public String toString() {
return super.toString() + " (" + x + " + " + y + ")";
}
/**
* @return the number of subcycle generators.
*/
public static int numberOfSubcycleGenerators() {
return FACTORY.numberOfSubcycleGenerators();
}
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
return NumberFactory.makeByteArray(new long[] { xx, yy });
}
/** {@inheritDoc} */
@Override
protected void setStateInternal(byte[] s) {
if (s.length != 16) {
throw new InsufficientDataException();
}
final long[] state = NumberFactory.makeLongArray(s);
xx = state[0];
yy = state[1];
}
/**
* @param seed Seed.
*/
private void setSeedInternal(int seed) {
// The seeding procedure consists in going away from some
// point known to be in the cycle.
// The total number of calls to the "transform" method will
// not exceed about 130,000 (which is negligible as seeding
// will not occur more than once in normal usage).
// Make two positive 16-bits integers.
final long s = NumberFactory.makeLong(0, seed); // s >= 0
final int xMax = (int) (s & 0xffff + SEED_GUARD);
final int yMax = (int) ((s >> 16) + SEED_GUARD);
if (xMax < 0 ||
yMax < 0) {
throw new MathInternalError();
}
xx = x.getStart();
for (int i = xMax; i > 0; i--) {
xx = x.transform(xx);
}
yy = y.getStart();
for (int i = yMax; i > 0; i--) {
yy = y.transform(yy);
}
}
/**
* Subcycle generator.
* Class is immutable.
*/
static class Cmres {
/** Cycle start. */
private final int start;
/** Multiplier. */
private final long multiply;
/** Rotation. */
private final int rotate;
/**
* @param multiply Multiplier.
* @param rotate Positive number. Must be in {@code [0, 64]}.
* @param start Cycle start.
*/
Cmres(long multiply,
int rotate,
int start) {
this.multiply = multiply;
this.rotate = rotate;
this.start = start;
}
/** {@inheritDoc} */
@Override
public String toString() {
final String sep = ", ";
// Use hexadecimal for "multiplier" field.
final String m = String.format((java.util.Locale) null, "0x%016xL", multiply);
return "Cmres: [" + m + sep + rotate + sep + start + "]";
}
/**
* @return the multiplier.
*/
public long getMultiply() {
return multiply;
}
/**
* @return the cycle start.
*/
public int getStart() {
return start;
}
/**
* @param state Current state.
* @return the new state.
*/
long transform(long state) {
long s = state;
s *= multiply;
s = rotl(s);
s -= state;
return s;
}
/**
* @param state State.
* @return the rotated state.
*/
private long rotl(long state) {
return (state << rotate) | (state >>> (64 - rotate));
}
/** Factory. */
static class Factory {
/** List of good "Cmres" subcycle generators. */
private static final List<Cmres> TABLE = new ArrayList<Cmres>();
/**
* Populates the table.
* It lists parameters known to be good (provided in
* the article referred to above).
* To maintain compatibility, new entries must be added
* only at the end of the table.
*/
static {
add(0xedce446814d3b3d9L, 33, 0x13b572e7);
add(0xc5b3cf786c806df7L, 33, 0x13c8e18a);
add(0xdd91bbb8ab9e0e65L, 31, 0x06dd03a6);
add(0x7b69342c0790221dL, 31, 0x1646bb8b);
add(0x0c72c0d18614c32bL, 33, 0x06014a3d);
add(0xd8d98c13bebe26c9L, 33, 0x014e8475);
add(0xcb039dc328bbc40fL, 31, 0x008684bd);
add(0x858c5ef3c021ed2fL, 32, 0x0dc8d622);
add(0x4c8be96bfc23b127L, 33, 0x0b6b20cc);
add(0x11eab77f808cf641L, 32, 0x06534421);
add(0xbc9bd78810fd28fdL, 31, 0x1d9ba40d);
add(0x0f1505c780688cb5L, 33, 0x0b7b7b67);
add(0xadc174babc2053afL, 31, 0x267f4197);
add(0x900b6b82b31686d9L, 31, 0x023c6985);
// Add new entries here.
}
/**
* @return the number of subcycle generators.
*/
int numberOfSubcycleGenerators() {
return TABLE.size();
}
/**
* @param index Index into the list of available generators.
* @return the subcycle generator entry at index {@code index}.
*/
Cmres get(int index) {
if (index < 0 ||
index >= TABLE.size()) {
throw new OutOfRangeException(index, 0, TABLE.size());
}
return TABLE.get(index);
}
/**
* Adds an entry to the {@link Factory#TABLE}.
*
* @param multiply Multiplier.
* @param rotate Rotate.
* @param start Cycle start.
*/
private static void add(long multiply,
int rotate,
int start) {
// Sanity check: if there are duplicates, the class initialization
// will fail (and the JVM will report "NoClassDefFoundError").
for (Cmres sg : TABLE) {
if (multiply == sg.getMultiply()) {
throw new MathInternalError();
}
}
TABLE.add(new Cmres(multiply, rotate, start));
}
}
}
}

108
src/main/java/org/apache/commons/math4/rng/internal/source64/XorShift1024Star.java Normal file
View File

@ -0,0 +1,108 @@
/*
* 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.math4.rng.internal.source64;
import java.util.Arrays;
import org.apache.commons.math4.exception.InsufficientDataException;
import org.apache.commons.math4.rng.internal.util.NumberFactory;
/**
* A fast RNG.
*
* @see <a href="http://xorshift.di.unimi.it/xorshift1024star.c">
* Original source code</a>
*
* @since 4.0
*/
public class XorShift1024Star extends LongProvider {
/** Size of the state vector. */
private static final int SEED_SIZE = 16;
/** State. */
private final long[] state = new long[SEED_SIZE];
/** Index in "state" array. */
private int index;
/**
* Creates a new instance.
*
* @param seed Initial seed.
* If the length is larger than 16, only the first 16 elements will
* be used; if smaller, the remaining elements will be automatically
* set.
*/
public XorShift1024Star(long[] seed) {
setSeedInternal(seed);
}
/** {@inheritDoc} */
@Override
protected byte[] getStateInternal() {
final long[] s = Arrays.copyOf(state, SEED_SIZE + 1);
s[SEED_SIZE] = index;
return NumberFactory.makeByteArray(s);
}
/** {@inheritDoc} */
@Override
protected void setStateInternal(byte[] s) {
if (s.length != (SEED_SIZE + 1) * 8) {
throw new InsufficientDataException();
}
final long[] tmp = NumberFactory.makeLongArray(s);
System.arraycopy(tmp, 0, state, 0, SEED_SIZE);
index = (int) tmp[SEED_SIZE];
}
/**
* Seeds the RNG.
*
* @param seed Seed.
*/
private void setSeedInternal(long[] seed) {
// Reset the whole state of this RNG (i.e. "state" and "index").
// Seeding procedure is not part of the reference code.
System.arraycopy(seed, 0, state, 0, Math.min(seed.length, state.length));
if (seed.length < SEED_SIZE) {
for (int i = seed.length; i < SEED_SIZE; i++) {
state[i] = 26021969L * i;
}
for (int i = SEED_SIZE - 1; i > seed.length; i--) {
state[i] ^= state[SEED_SIZE - i - 1];
}
state[seed.length] = 0x8000000000000000L; // Ensuring non-zero initial array.
}
index = 0;
}
/** {@inheritDoc} */
@Override
public long next() {
final long s0 = state[index];
long s1 = state[index = (index + 1) & 15];
s1 ^= s1 << 31; // a
state[index] = s1 ^ s0 ^ (s1 >>> 11) ^ (s0 >>> 30); // b,c
return state[index] * 1181783497276652981L;
}
}

52
src/main/java/org/apache/commons/math4/rng/internal/source64/package-info.java Normal file
View File

@ -0,0 +1,52 @@
/*
* 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.
*/
/**
* <h3>
* Concrete algorithms for {@code long}-based sources of randomness
* </h3>
*
* <p>
* <b>For internal use only:</b> Direct access to classes in this package
* is discouraged, as they could be modified without notice.
* </p>
*
* <p><b>Notes for developers</b></p>
*
* <ul>
* <li>
* A source of randomness must inherit from
* {@link org.apache.commons.math4.rng.internal.source64.LongProvider}
* </li>
* <li>
* The "provider" must specify <em>one</em> way for setting the seed.
* For a given seed, the generated sequence must always be the same.
* </li>
* <li>
* The "provider" must implement methods {@code getStateInternal} and
* {@code setStateInternal} in order to save and restore the state of an
* instance (cf. {@link org.apache.commons.math4.rng.internal.BaseProvider}).
* </li>
* <li>
* When a new class is implemented here, user-access to it must be provided
* through associated {@link org.apache.commons.math4.rng.RandomSource
* factory methods}.
* </li>
* </ul>
*/
package org.apache.commons.math4.rng.internal.source64;

37
src/main/java/org/apache/commons/math4/rng/internal/util/Int2Long.java Normal file
View File

@ -0,0 +1,37 @@
/*
* 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.math4.rng.internal.util;
/**
* Converts a {@code Integer} to an {@code Long}.
*
* @since 4.0
*/
public class Int2Long implements SeedConverter<Integer, Long> {
/** {@inheritDoc} */
@Override
public Long convert(Integer seed) {
final int s = seed;
return NumberFactory.makeLong(s, ~s);
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName();
}
}

41
src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2Int.java Normal file
View File

@ -0,0 +1,41 @@
/*
* 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.math4.rng.internal.util;
/**
* Creates a single value by "xor" of all the values in the input array.
*
* @since 4.0
*/
public class IntArray2Int implements SeedConverter<int[], Integer> {
/** {@inheritDoc} */
@Override
public Integer convert(int[] seed) {
int out = 0;
for (int i = 0; i < seed.length; i++) {
out ^= seed[i];
}
return out;
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName();
}
}

44
src/main/java/org/apache/commons/math4/rng/internal/util/IntArray2LongArray.java Normal file
View File

@ -0,0 +1,44 @@
/*
* 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.math4.rng.internal.util;
/**
* Creates a {@code long[]} from an {@code int[]}.
*
* @since 4.0
*/
public class IntArray2LongArray implements SeedConverter<int[], long[]> {
/** {@inheritDoc} */
@Override
public long[] convert(int[] seed) {
final int outSize = (seed.length + 1) / 2;
final long[] out = new long[outSize];
for (int i = 0; i < outSize; i++) {
final int lo = seed[i];
final int hi = outSize + i < seed.length ? seed[outSize + i] : 0;
out[i] = NumberFactory.makeLong(hi, lo) ;
}
return out;
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName();
}
}

36
src/main/java/org/apache/commons/math4/rng/internal/util/Long2Int.java Normal file
View File

@ -0,0 +1,36 @@
/*
* 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.math4.rng.internal.util;
/**
* Converts a {@code Long} to an {@code Integer}.
*
* @since 4.0
*/
public class Long2Int implements SeedConverter<Long, Integer> {
/** {@inheritDoc} */
@Override
public Integer convert(Long seed) {
return NumberFactory.makeInt(seed);
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName();
}
}

50
src/main/java/org/apache/commons/math4/rng/internal/util/Long2IntArray.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.math4.rng.internal.util;
import org.apache.commons.math4.rng.internal.source64.SplitMix64;
/**
* Uses a {@code long} value to seed a {@link SplitMix64} RNG and
* create a {@code int[]} with the requested number of random
* values.
*
* @since 4.0
*/
public class Long2IntArray implements SeedConverter<Long, int[]> {
/** Size of the output array. */
private final int size;
/**
* @param size Size of the output array.
*/
public Long2IntArray(int size) {
this.size = size;
}
/** {@inheritDoc} */
@Override
public int[] convert(Long seed) {
return SeedFactory.createIntArray(size, new SplitMix64(seed));
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName() + "(size=" + size + ")";
}
}

56
src/main/java/org/apache/commons/math4/rng/internal/util/Long2LongArray.java Normal file
View File

@ -0,0 +1,56 @@
/*
* 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.math4.rng.internal.util;
import org.apache.commons.math4.rng.internal.source64.SplitMix64;
/**
* Uses a {@code Long} value to seed a {@link SplitMix64} RNG and
* create a {@code long[]} with the requested number of random
* values.
*
* @since 4.0
*/
public class Long2LongArray implements SeedConverter<Long, long[]> {
/** Size of the output array. */
private final int size;
/**
* @param size Size of the output array.
*/
public Long2LongArray(int size) {
this.size = size;
}
/** {@inheritDoc} */
@Override
public long[] convert(Long seed) {
final long[] out = new long[size];
final SplitMix64 rng = new SplitMix64(seed);
for (int i = 0; i < size; i++) {
out[i] = rng.nextLong();
}
return out;
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName() + "(size: " + size + ")";
}
}

43
src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2IntArray.java Normal file
View File

@ -0,0 +1,43 @@
/*
* 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.math4.rng.internal.util;
/**
* Creates an {@code int[]} from a {@code long[]}.
*
* @since 4.0
*/
public class LongArray2IntArray implements SeedConverter<long[], int[]> {
/** {@inheritDoc} */
@Override
public int[] convert(long[] seed) {
final int[] out = new int[seed.length * 2];
for (int i = 0; i < seed.length; i++) {
final long current = seed[i];
out[i] = NumberFactory.extractLo(current);
out[seed.length + i] = NumberFactory.extractHi(current);
}
return out;
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName();
}
}

41
src/main/java/org/apache/commons/math4/rng/internal/util/LongArray2Long.java Normal file
View File

@ -0,0 +1,41 @@
/*
* 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.math4.rng.internal.util;
/**
* Creates a single value by "xor" of all the values in the input array.
*
* @since 4.0
*/
public class LongArray2Long implements SeedConverter<long[], Long> {
/** {@inheritDoc} */
@Override
public Long convert(long[] seed) {
long out = 0;
for (int i = 0; i < seed.length; i++) {
out ^= seed[i];
}
return out;
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName();
}
}

50
src/main/java/org/apache/commons/math4/rng/internal/util/LongMixInt.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.math4.rng.internal.util;
import org.apache.commons.math4.rng.internal.source64.SplitMix64;
/**
* Uses a {@code long} value to seed a {@link SplitMix64} RNG and
* create an {@code int[]} with the requested number of random
* values.
*
* @since 4.0
*/
public class LongMixInt implements SeedConverter<Long, int[]> {
/** Size of the output array. */
private final int size;
/**
* @param size Size of the output array.
*/
public LongMixInt(int size) {
this.size = size;
}
/** {@inheritDoc} */
@Override
public int[] convert(Long seed) {
return SeedFactory.createIntArray(size, new SplitMix64(seed));
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName() + "(size=" + size + ")";
}
}

56
src/main/java/org/apache/commons/math4/rng/internal/util/LongMixLong.java Normal file
View File

@ -0,0 +1,56 @@
/*
* 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.math4.rng.internal.util;
import org.apache.commons.math4.rng.internal.source64.SplitMix64;
/**
* Uses a {@code long} value to seed a {@link SplitMix64} RNG and
* create a {@code long[]} with the requested number of random
* values.
*
* @since 4.0
*/
public class LongMixLong implements SeedConverter<Long, long[]> {
/** Size of the output array. */
private final int size;
/**
* @param size Size of the output array.
*/
public LongMixLong(int size) {
this.size = size;
}
/** {@inheritDoc} */
@Override
public long[] convert(Long seed) {
final long[] out = new long[size];
final SplitMix64 rng = new SplitMix64(seed);
for (int i = 0; i < size; i++) {
out[i] = rng.nextLong();
}
return out;
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName() + "(size: " + size + ")";
}
}

40
src/main/java/org/apache/commons/math4/rng/internal/util/NoOpConverter.java Normal file
View File

@ -0,0 +1,40 @@
/*
* 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.math4.rng.internal.util;
/**
* Dummy converter that simply passes on its input.
* It can be useful to avoid "unchecked" compiler warnings.
*
* @param <SEED> Seed type.
*
* @since 4.0
*/
public class NoOpConverter<SEED> implements SeedConverter<SEED, SEED> {
/** {@inheritDoc} */
@Override
public SEED convert(SEED seed) {
return seed;
}
/** {@inheritDoc} */
@Override
public String toString() {
return "Pass-through";
}
}

327
src/main/java/org/apache/commons/math4/rng/internal/util/NumberFactory.java Normal file
View File

@ -0,0 +1,327 @@
/*
* 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.math4.rng.internal.util;
import java.util.Arrays;
import org.apache.commons.math4.exception.DimensionMismatchException;
/**
* Utility for creating number types from one or two {@code int} values
* or one {@code long} value, or a sequence of bytes.
*/
public final class NumberFactory {
/** See {@link #makeDouble(long)} */
private static final long DOUBLE_HIGH_BITS = 0x3ffL << 52;
/** See {@link #makeFloat(int)} */
private static final float FLOAT_MULTIPLIER = 0x1.0p-23f;
/** See {@link #makeDouble(int, int)} */
private static final double DOUBLE_MULTIPLIER = 0x1.0p-52d;
/** Lowest byte mask. */
private static final long LONG_LOWEST_BYTE_MASK = 0xffL;
/** Number of bytes in a {@code long} */
private static final int LONG_SIZE = 8;
/** Lowest byte mask. */
private static final int INT_LOWEST_BYTE_MASK = 0xff;
/** Number of bytes in a {@code int} */
private static final int INT_SIZE = 4;
/**
* Class contains only static methods.
*/
private NumberFactory() {}
/**
* @param v Number.
* @return a boolean.
*/
public static boolean makeBoolean(int v) {
return (v >>> 31) != 0;
}
/**
* @param v Number.
* @return a boolean.
*/
public static boolean makeBoolean(long v) {
return (v >>> 63) != 0;
}
/**
* @param v Number.
* @return a {@code double} value in the interval {@code [0, 1]}.
*/
public static double makeDouble(long v) {
// http://xorshift.di.unimi.it
return Double.longBitsToDouble(DOUBLE_HIGH_BITS | v >>> 12) - 1d;
}
/**
* @param v Number (high order bits).
* @param w Number (low order bits).
* @return a {@code double} value in the interval {@code [0, 1]}.
*/
public static double makeDouble(int v,
int w) {
final long high = ((long) (v >>> 6)) << 26;
final int low = w >>> 6;
return (high | low) * DOUBLE_MULTIPLIER;
}
/**
* @param v Number.
* @return a {@code float} value in the interval {@code [0, 1]}.
*/
public static float makeFloat(int v) {
return (v >>> 9) * FLOAT_MULTIPLIER;
}
/**
* @param v Number (high order bits).
* @param w Number (low order bits).
* @return a {@code long} value.
*/
public static long makeLong(int v,
int w) {
return (((long) v) << 32) | (w & 0xffffffffL);
}
/**
* Creates an {@code int} from a {@code long}.
*
* @param v Number.
* @return an {@code int} value made from the "xor" of the
* {@link #extractHi(long) high order bits} and
* {@link #extractLo(long) low order bits} of {@code v}.
*/
public static int makeInt(long v) {
return extractHi(v) ^ extractLo(v);
}
/**
* Creates an {@code int} from a {@code long}, using the high order bits.
* <p>
* The returned value is such that if
* <pre><code>
* vL = extractLo(v);
* vH = extractHi(v);
* </code></pre>
* then {@code v} is equal to {@link #makeLong(int,int) makeLong(vH, vL)}.
* </p>
*
* @param v Number.
* @return an {@code int} value made from the most significant bits
* of {@code v}.
*/
public static int extractHi(long v) {
return (int) (v >>> 32);
}
/**
* Creates an {@code int} from a {@code long}, using the low order bits.
* <p>
* The returned value is such that if
* <pre><code>
* vL = extractLo(v);
* vH = extractHi(v);
* </code></pre>
* then {@code v} is equal to {@link #makeLong(int,int) makeLong(vH, vL)}.
* </p>
*
* @param v Number.
* @return an {@code int} value made from the least significant bits
* of {@code v}.
*/
public static int extractLo(long v) {
return (int) v;
}
/**
* Splits a {@code long} into 8 bytes.
*
* @param v Value.
* @return the bytes that compose the given value (least-significant
* byte first).
*/
public static byte[] makeByteArray(long v) {
final byte[] b = new byte[LONG_SIZE];
for (int i = 0; i < LONG_SIZE; i++) {
final int shift = i * 8;
b[i] = (byte) ((v >>> shift) & LONG_LOWEST_BYTE_MASK);
}
return b;
}
/**
* Creates a {@code long} from 8 bytes.
*
* @param input Input.
* @return the value that correspond to the given bytes assuming
* that the is ordered in increasing byte significance (i.e. the
* first byte in the array is the least-siginficant).
* @throws DimensionMismatchException if {@code input.length != 8}.
*/
public static long makeLong(byte[] input) {
if (input.length != LONG_SIZE) {
throw new DimensionMismatchException(input.length, LONG_SIZE);
}
long v = 0;
for (int i = 0; i < LONG_SIZE; i++) {
final int shift = i * 8;
v |= (((long) input[i]) & LONG_LOWEST_BYTE_MASK) << shift;
}
return v;
}
/**
* Splits an array of {@code long} values into a sequence of bytes.
* This method calls {@link #makeByteArray(long)} for each element of
* the {@code input}.
*
* @param input Input.
* @return an array of bytes.
*/
public static byte[] makeByteArray(long[] input) {
final int size = input.length * LONG_SIZE;
final byte[] b = new byte[size];
for (int i = 0; i < input.length; i++) {
final byte[] current = makeByteArray(input[i]);
System.arraycopy(current, 0, b, i * LONG_SIZE, LONG_SIZE);
}
return b;
}
/**
* Creates an array of {@code long} values from a sequence of bytes.
* This method calls {@link #makeLong(byte[])} for each subsequence
* of 8 bytes.
*
* @param input Input.
* @return an array of {@code long}.
* @throws DimensionMismatchException if {@code input.length} is not
* a multiple of 8.
*/
public static long[] makeLongArray(byte[] input) {
final int size = input.length;
final int num = size / LONG_SIZE;
if (num * LONG_SIZE != size) {
throw new DimensionMismatchException(size, num * LONG_SIZE);
}
final long[] output = new long[num];
for (int i = 0; i < num; i++) {
final int from = i * LONG_SIZE;
final byte[] current = Arrays.copyOfRange(input, from, from + LONG_SIZE);
output[i] = makeLong(current);
}
return output;
}
/**
* Splits an {@code int} into 4 bytes.
*
* @param v Value.
* @return the bytes that compose the given value (least-significant
* byte first).
*/
public static byte[] makeByteArray(int v) {
final byte[] b = new byte[INT_SIZE];
for (int i = 0; i < INT_SIZE; i++) {
final int shift = i * 8;
b[i] = (byte) ((v >>> shift) & INT_LOWEST_BYTE_MASK);
}
return b;
}
/**
* Creates an {@code int} from 4 bytes.
*
* @param input Input.
* @return the value that correspond to the given bytes assuming
* that the is ordered in increasing byte significance (i.e. the
* first byte in the array is the least-siginficant).
* @throws DimensionMismatchException if {@code input.length != 4}.
*/
public static int makeInt(byte[] input) {
if (input.length != INT_SIZE) {
throw new DimensionMismatchException(input.length, INT_SIZE);
}
int v = 0;
for (int i = 0; i < INT_SIZE; i++) {
final int shift = i * 8;
v |= (((int) input[i]) & INT_LOWEST_BYTE_MASK) << shift;
}
return v;
}
/**
* Splits an array of {@code int} values into a sequence of bytes.
* This method calls {@link #makeByteArray(int)} for each element of
* the {@code input}.
*
* @param input Input.
* @return an array of bytes.
*/
public static byte[] makeByteArray(int[] input) {
final int size = input.length * INT_SIZE;
final byte[] b = new byte[size];
for (int i = 0; i < input.length; i++) {
final byte[] current = makeByteArray(input[i]);
System.arraycopy(current, 0, b, i * INT_SIZE, INT_SIZE);
}
return b;
}
/**
* Creates an array of {@code int} values from a sequence of bytes.
* This method calls {@link #makeInt(byte[])} for each subsequence
* of 4 bytes.
*
* @param input Input. Length must be a multiple of 4.
* @return an array of {@code int}.
* @throws DimensionMismatchException if {@code input.length} is not
* a multiple of 4.
*/
public static int[] makeIntArray(byte[] input) {
final int size = input.length;
final int num = size / INT_SIZE;
if (num * INT_SIZE != size) {
throw new DimensionMismatchException(size, num * INT_SIZE);
}
final int[] output = new int[num];
for (int i = 0; i < num; i++) {
final int from = i * INT_SIZE;
final byte[] current = Arrays.copyOfRange(input, from, from + INT_SIZE);
output[i] = makeInt(current);
}
return output;
}
}

35
src/main/java/org/apache/commons/math4/rng/internal/util/SeedConverter.java Normal file
View File

@ -0,0 +1,35 @@
/*
* 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.math4.rng.internal.util;
/**
* Seed converter.
*
* @param <IN> Input seed type.
* @param <OUT> Output seed type.
*
* @since 4.0
*/
public interface SeedConverter<IN, OUT> {
/**
* Converts seed from input type to output type.
*
* @param seed Original seed value.
* @return the converted seed value.
*/
OUT convert(IN seed);
}

56
src/main/java/org/apache/commons/math4/rng/internal/util/SeedConverterComposer.java Normal file
View File

@ -0,0 +1,56 @@
/*
* 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.math4.rng.internal.util;
/**
* Composes two {@link SeedConverter converters}.
*
* @param <IN> Input seed type.
* @param <TRANS> Transitional seed type.
* @param <OUT> Output seed type.
*
* @since 4.0
*/
public class SeedConverterComposer<IN, TRANS, OUT> implements SeedConverter<IN, OUT> {
/** First conversion. */
private SeedConverter<IN, TRANS> first;
/** Second conversion. */
private SeedConverter<TRANS, OUT> second;
/**
* @param first First conversion.
* @param second second conversion.
*/
public SeedConverterComposer(SeedConverter<IN, TRANS> first,
SeedConverter<TRANS, OUT> second) {
this.first = first;
this.second = second;
}
/** {@inheritDoc} */
@Override
public OUT convert(IN seed) {
final TRANS trans = first.convert(seed);
return second.convert(trans);
}
/** {@inheritDoc} */
@Override
public String toString() {
return getClass().getSimpleName() + " (" + second + " o " + first + ")";
}
}

262
src/main/java/org/apache/commons/math4/rng/internal/util/SeedFactory.java Normal file
View File

@ -0,0 +1,262 @@
/*
* 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.math4.rng.internal.util;
import org.apache.commons.math4.rng.internal.source32.RandomIntSource;
import org.apache.commons.math4.rng.internal.source32.Well44497b;
import org.apache.commons.math4.rng.internal.source64.RandomLongSource;
import org.apache.commons.math4.rng.internal.source64.SplitMix64;
/**
* Utilities related to seeding.
*
* <p>
* This class provides methods to generate random seeds (single values
* or arrays of values, of {@code int} or {@code long} types) that can
* be passed to the {@link org.apache.commons.math4.rng.RandomSource
* methods that create a generator instance}.
* <br>
* Although the seed-generating methods defined in this class will likely
* return different values for all calls, there is no guarantee that the
* produced seed will result always in a "good" sequence of numbers (even
* if the generator initialized with that seed is good).
* <br>
* There is <i>no guarantee</i> that sequences will not overlap.
* </p>
*
* @since 4.0
*/
public class SeedFactory {
/** Generator with a long period. */
private static final RandomIntSource SEED_GENERATOR;
static {
// Another RNG for initializing the "SEED_GENERATOR".
final long t = System.currentTimeMillis();
final int h = System.identityHashCode(Runtime.getRuntime());
final SplitMix64 rng = new SplitMix64(t ^ NumberFactory.makeLong(h, ~h));
final int blockCount = 1391; // Size of the state array of "Well44497b".
SEED_GENERATOR = new Well44497b(createIntArray(blockCount, rng));
}
/**
* Class contains only static methods.
*/
private SeedFactory() {}
/**
* Creates a number for use as a seed.
*
* @return a random number.
*/
public static int createInt() {
return createInt(SEED_GENERATOR, System.identityHashCode(new Object()));
}
/**
* Creates a number for use as a seed.
*
* @return a random number.
*/
public static long createLong() {
return createLong(SEED_GENERATOR, System.identityHashCode(new Object()));
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @return an array of {@code n} random numbers.
*/
public static int[] createIntArray(int n) {
return createIntArray(n, SEED_GENERATOR, new Object());
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @return an array of {@code n} random numbers.
*/
public static long[] createLongArray(int n) {
return createLongArray(n, SEED_GENERATOR, new Object());
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @param source Source of randomness.
* @return an array of {@code n} random numbers drawn from the
* {@code source}.
*/
static long[] createLongArray(int n,
RandomIntSource source) {
return createLongArray(n, source, null);
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @param source Source of randomness.
* @return an array of {@code n} random numbers drawn from the
* {@code source}.
*/
static int[] createIntArray(int n,
RandomLongSource source) {
return createIntArray(n, source, null);
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @param source Source of randomness.
* @return an array of {@code n} random numbers drawn from the
* {@code source}.
*/
static int[] createIntArray(int n,
RandomIntSource source) {
return createIntArray(n, source, null);
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @param source Source of randomness.
* @param h Arbitrary object whose {@link System#identityHashCode(Object)
* hash code} will be combined with the next number drawn from
* the {@code source}.
* @return an array of {@code n} random numbers.
*/
private static long[] createLongArray(int n,
RandomIntSource source,
Object h) {
final long[] array = new long[n];
final int hash = System.identityHashCode(h);
for (int i = 0; i < n; i++) {
array[i] = createLong(source, hash);
}
return array;
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @param source Source of randomness.
* @param h Arbitrary object whose {@link System#identityHashCode(Object)
* hash code} will be combined with the next number drawn from
* the {@code source}.
* @return an array of {@code n} random numbers.
*/
private static int[] createIntArray(int n,
RandomLongSource source,
Object h) {
final int[] array = new int[n];
final int hash = System.identityHashCode(h);
for (int i = 0; i < n; i += 2) {
final long v = createLong(source, hash);
array[i] = NumberFactory.extractHi(v);
if (i + 1 < n) {
array[i + 1] = NumberFactory.extractLo(v);
}
}
return array;
}
/**
* Creates an array of numbers for use as a seed.
*
* @param n Size of the array to create.
* @param source Source of randomness.
* @param h Arbitrary object whose {@link System#identityHashCode(Object)
* hash code} will be combined with the next number drawn from
* the {@code source}.
* @return an array of {@code n} random numbers.
*/
private static int[] createIntArray(int n,
RandomIntSource source,
Object h) {
final int[] array = new int[n];
final int hash = System.identityHashCode(h);
for (int i = 0; i < n; i++) {
array[i] = createInt(source, hash);
}
return array;
}
/**
* Creates a random number by performing an "xor" between the
* next value in the sequence of the {@code source} and the
* given {@code number}.
*
* @param source Source of randomness.
* @param number Arbitrary number.
* @return a random number.
*/
private static long createLong(RandomLongSource source,
int number) {
synchronized (source) {
return source.next() ^ NumberFactory.makeLong(number, number);
}
}
/**
* Creates a random number by performing an "xor" between the
* the next value in the sequence of the {@code source} and the
* given {@code number}.
*
* @param source Source of randomness.
* @param number Arbitrary number.
* @return a random number.
*/
private static long createLong(RandomIntSource source,
int number) {
synchronized (source) {
return NumberFactory.makeLong(source.next() ^ number,
source.next() ^ number);
}
}
/**
* Creates a random number by performing an "xor" between the
* next value in the sequence of the {@code source} and the
* given {@code number}.
*
* @param source Source of randomness.
* @param number Arbitrary number.
* @return a random number.
*/
private static int createInt(RandomIntSource source,
int number) {
synchronized (source) {
return source.next() ^ number;
}
}
}

22
src/main/java/org/apache/commons/math4/rng/internal/util/package-info.java Normal file
View File

@ -0,0 +1,22 @@
/*
* 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.
*/
/**
* Utilities for seed conversion.
*/
package org.apache.commons.math4.rng.internal.util;

95
src/main/java/org/apache/commons/math4/rng/package-info.java Normal file
View File

@ -0,0 +1,95 @@
/*
* 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.
*/
/**
* <h3>Randomness Providers</h3>
*
* <p>
* This package contains the public API for generating sequences of
* pseudo-random numbers that are <i>uniformly distributed</i> in a
* specified range.
* <br>
* All implemented generators can be instantiated through
* {@link org.apache.commons.math4.rng.RandomSource factory methods}.
* The low-level classes, that define how the randomness is produced,
* are implemented in package {@link org.apache.commons.math4.rng.internal}
* and its sub-packages, but should not be used directly.
* <br>
* The generators are <i>not</i> thread-safe: Parallel applications must
* use different generator instances in different threads.
* </p>
*
* <p>
* In the case of pseudo-random generators, the source of randomness is
* usually a set of numbers whose bits representation are scrambled in such
* a way as to produce a random-looking sequence.
* <br>
* The main property of the sequence is that the numbers must be uniformly
* distributed within their allowed range.
* <br>
* Classes in this package do not provide any further processing of the
* number generation such as to match other types of distribution.
* </p>
*
* <p>
* Which source of randomness to choose may depend on which properties
* are more important.
* Considerations can include speed of generation, memory usage, period
* size, equidistribution, correlation, etc.
* <br>
* For some of the generators, interesting properties (of the reference
* implementations) are proven in scientific papers.
* Some generators can also suffer from potential weaknesses.
* </p>
*
* <p>
* For simple sampling, any of the generators implemented in this library
* may be sufficient.
* <br>
* For Monte-Carlo simulations that require generating high-dimensional
* vectors), equidistribution and non-correlation are crucial.
* The <i>Mersenne Twister</i> and <i>Well</i> generators have
* equidistribution properties proven according to their bits pool size
* which is directly related to their period (all of them have maximal
* period, i.e. a generator with size {@code n} pool has a period
* <code>2<sup>n</sup>-1</code>).
* They also have equidistribution properties for 32 bits blocks up to
* {@code s/32} dimension where {@code s} is their pool size.
* <br>
* For example, {@code Well19937c} is equidistributed up to dimension 623
* (i.e. 19937 divided by 32).
* It means that a Monte-Carlo simulation generating vectors of {@code n}
* (32-bits integer) variables at each iteration has some guarantee on the
* properties of its components as long as {@code n < 623}.
* Note that if the variables are of type {@code double}, the limit is
* divided by two (since 64 bits are needed to create a {@code double}).
* <br>
* Reference to the relevant publications are listed in the specific
* documentation of each class.
* </p>
*
* <p>
* Memory usage can vary a lot between providers.
* The state of {@code MersenneTwister} is composed of 624 integers,
* using about 2.5 kB.
* The <i>Well</i> generators use 6 integer arrays, the length of each
* being equal to the pool size; thus, for example, {@code Well44497b}
* uses about 33 kB.
* </p>
*/
package org.apache.commons.math4.rng;

228
src/site/apt/userguide/rng.apt Normal file
View File

@ -0,0 +1,228 @@
~~
~~ 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.
~~
-----------------------------------------------
The Commons Math User Guide - Random Number Generators
-----------------------------------------------
20 Random Number Generators
* 20.1 Overview
The <<<rng>>> package contains the random number generation functionality.
Please refer to the {{{../apidocs/org/apache/commons/math4/rng/package-summary.html}Javadoc}} of the package for details.
* 20.2 Performance
This section reports benchmarks of the RNG implementations.
All runs were performed on a platform with the following characteristics:
* CPU: Intel(R) Core(TM) i7-3770 CPU @ 3.40GHz
* Java runtime: 1.7.0_95-b00
* JVM: OpenJDK 64-Bit Server VM 24.95-b01
[]
The following tables indicates the performance for generating
* a sequence of 32-bits integers (a.k.a. Java type <<<int>>>)
* a sequence of 64-bits integers (a.k.a. Java type <<<long>>>)
* a sequence of 64-bits floating point numbers (a.k.a. Java type <<<double>>>)
[]
The first column is the RNG identifier (see {{{../apidocs/org/apache/commons/math4/rng/RandomSource.html}RandomSource}}).
Two independent benchmarking tools were used:
* Commons Math <<<PerfTestUtils>>>
* {{{http://openjdk.java.net/projects/code-tools/jmh/}JMH}}
[]
The results of those tools are reported in second and third columns, respectively, where
the value is the ratio of the performance of the implementation with respect to the
corresponding performance of the JDK's <<<java.util.Random>>> class.
In these tables, <lower> is <better>.
** Generating <<<int>>> values
*---------------------------------*------------------------+--------------+
|| RNG identifier || Ratio (PerfTestUtils) || Ratio (JMH) |
*---------------------------------*------------------------+--------------+
| JDK | 1.21 | 1.000 |
*---------------------------------*------------------------+--------------+
| MT | 1.19 | 0.639 |
*---------------------------------*------------------------+--------------+
| WELL_512_A | 1.33 | 0.740 |
*---------------------------------*------------------------+--------------+
| WELL_1024_A | 1.38 | 0.795 |
*---------------------------------*------------------------+--------------+
| WELL_19937_A | 1.47 | 1.039 |
*---------------------------------*------------------------+--------------+
| WELL_19937_C | 1.54 | 1.102 |
*---------------------------------*------------------------+--------------+
| WELL_44497_A | 1.53 | 1.187 |
*---------------------------------*------------------------+--------------+
| WELL_44497_B | 1.59 | 1.114 |
*---------------------------------*------------------------+--------------+
| ISAAC | 1.30 | 0.610 |
*---------------------------------*------------------------+--------------+
| MT_64 | 1.31 | 0.734 |
*---------------------------------*------------------------+--------------+
| SPLIT_MIX_64 | 1.00 | 0.361 |
*---------------------------------*------------------------+--------------+
| XOR_SHIFT_1024_S | 1.09 | 0.450 |
*---------------------------------*------------------------+--------------+
| TWO_CMRES | 1.14 | 0.464 |
*---------------------------------*------------------------+--------------+
** Generating <<<long>>> values
*---------------------------------*------------------------+--------------+
|| RNG identifier || Ratio (PerfTestUtils) || Ratio (JMH) |
*---------------------------------*------------------------+--------------+
| JDK | 1.40 | 1.002 |
*---------------------------------*------------------------+--------------+
| MT | 0.85 | 0.569 |
*---------------------------------*------------------------+--------------+
| WELL_512_A | 1.05 | 0.798 |
*---------------------------------*------------------------+--------------+
| WELL_1024_A | 1.08 | 0.873 |
*---------------------------------*------------------------+--------------+
| WELL_19937_A | 1.21 | 0.968 |
*---------------------------------*------------------------+--------------+
| WELL_19937_C | 1.27 | 1.020 |
*---------------------------------*------------------------+--------------+
| WELL_44497_A | 1.26 | 1.103 |
*---------------------------------*------------------------+--------------+
| WELL_44497_B | 1.31 | 1.043 |
*---------------------------------*------------------------+--------------+
| ISAAC | 0.96 | 0.515 |
*---------------------------------*------------------------+--------------+
| MT_64 | 0.67 | 0.343 |
*---------------------------------*------------------------+--------------+
| SPLIT_MIX_64 | 0.55 | 0.175 |
*---------------------------------*------------------------+--------------+
| XOR_SHIFT_1024_S | 0.59 | 0.207 |
*---------------------------------*------------------------+--------------+
| TWO_CMRES | 0.61 | 0.223 |
*---------------------------------*------------------------+--------------+
** Generating <<<double>>> values
*---------------------------------*------------------------+--------------+
|| RNG identifier || Ratio (PerfTestUtils) || Ratio (JMH) |
*---------------------------------*------------------------+--------------+
| JDK | 1.15 | 1.001 |
*---------------------------------*------------------------+--------------+
| MT | 0.86 | 0.614 |
*---------------------------------*------------------------+--------------+
| WELL_512_A | 1.08 | 0.839 |
*---------------------------------*------------------------+--------------+
| WELL_1024_A | 1.11 | 0.899 |
*---------------------------------*------------------------+--------------+
| WELL_19937_A | 1.23 | 0.984 |
*---------------------------------*------------------------+--------------+
| WELL_19937_C | 1.29 | 1.069 |
*---------------------------------*------------------------+--------------+
| WELL_44497_A | 1.28 | 1.125 |
*---------------------------------*------------------------+--------------+
| WELL_44497_B | 1.33 | 1.093 |
*---------------------------------*------------------------+--------------+
| ISAAC | 0.98 | 0.583 |
*---------------------------------*------------------------+--------------+
| MT_64 | 0.66 | 0.391 |
*---------------------------------*------------------------+--------------+
| SPLIT_MIX_64 | 0.57 | 0.226 |
*---------------------------------*------------------------+--------------+
| XOR_SHIFT_1024_S | 0.59 | 0.262 |
*---------------------------------*------------------------+--------------+
| TWO_CMRES | 0.60 | 0.284 |
*---------------------------------*------------------------+--------------+
* 20.3 Quality
This section reports results of performing "stress tests" that aim at detecting failures
of an implementation to produce sequences of numbers that follow a uniform distribution.
Two different test suites were used:
* {{{http://www.phy.duke.edu/~rgb/General/dieharder.php}Dieharder}}
* {{{http://simul.iro.umontreal.ca/testu01/tu01.html}TestU01}}
[]
The first column is the RNG identifier (see {{{../apidocs/org/apache/commons/math4/rng/RandomSource.html}RandomSource}}).
The second and third columns contain the number of tests which <Dieharder> and <TestU01>
respectively reported as below the accepted threshold for considering the sequence as
uniformly random; hence, in this table, <lower> is <better>.
For each the two test suites, two runs were performed (using random seeds): Click on one
of the numbers of the comma-separated list in order to see the text report of the
corresponding run.
Note: For <Dieharder>, a failure on the "Diehard Sums Test" can be {{{http://www.phy.duke.edu/~rgb/General/dieharder.php}ignored}}.
*---------------------------------*----------------*---------------------*
|| RNG identifier || Dieharder || TestU01 (BigCrush) |
*----------------*----------------*----------------*---------------------*
| JDK | {{{../txt/userguide/rng/stress/dh/run_1/dh_1}13}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_1}11}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_1}77}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_1}74}} |
*---------------------------------*----------------*----------------*
| MT | {{{../txt/userguide/rng/stress/dh/run_1/dh_2}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_2}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_2}2}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_2}2}} |
*---------------------------------*----------------*----------------*
| WELL_512_A | {{{../txt/userguide/rng/stress/dh/run_1/dh_3}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_3}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_3}6}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_3}7}} |
*---------------------------------*----------------*----------------*
| WELL_1024_A | {{{../txt/userguide/rng/stress/dh/run_1/dh_4}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_4}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_4}5}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_4}4}} |
*---------------------------------*----------------*----------------*
| WELL_19937_A | {{{../txt/userguide/rng/stress/dh/run_1/dh_5}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_5}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_5}3}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_5}3}} |
*---------------------------------*----------------*----------------*
| WELL_19937_C | {{{../txt/userguide/rng/stress/dh/run_1/dh_6}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_6}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_6}3}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_6}2}} |
*---------------------------------*----------------*----------------*
| WELL_44497_A | {{{../txt/userguide/rng/stress/dh/run_1/dh_7}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_7}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_7}2}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_7}2}} |
*---------------------------------*----------------*----------------*
| WELL_44497_B | {{{../txt/userguide/rng/stress/dh/run_1/dh_8}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_8}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_8}3}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_8}2}} |
*---------------------------------*----------------*----------------*
| ISAAC | {{{../txt/userguide/rng/stress/dh/run_1/dh_9}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_9}1}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_9}1}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_9}0}} |
*---------------------------------*----------------*----------------*
| MT_64 | {{{../txt/userguide/rng/stress/dh/run_1/dh_10}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_10}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_10}2}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_10}2}} |
*---------------------------------*----------------*----------------*
| SPLIT_MIX_64 | {{{../txt/userguide/rng/stress/dh/run_1/dh_11}1}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_11}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_11}0}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_11}0}} |
*---------------------------------*----------------*----------------*
| XOR_SHIFT_1024_S | {{{../txt/userguide/rng/stress/dh/run_1/dh_12}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_12}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_12}2}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_12}0}} |
*---------------------------------*----------------*----------------*
| TWO_CMRES | {{{../txt/userguide/rng/stress/dh/run_1/dh_13}0}}, {{{../txt/userguide/rng/stress/dh/run_2/dh_13}0}} | {{{../txt/userguide/rng/stress/tu/run_1/tu_13}1}}, {{{../txt/userguide/rng/stress/tu/run_2/tu_13}0}} |
*---------------------------------*----------------*----------------*

146
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_1 Normal file
View File

@ -0,0 +1,146 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.JDKRandom
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.46e+06 |3234096741|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.03946185| PASSED
diehard_operm5| 0| 1000000| 100|0.01629539| PASSED
diehard_rank_32x32| 0| 40000| 100|0.98579998| PASSED
diehard_rank_6x8| 0| 100000| 100|0.53483219| PASSED
diehard_bitstream| 0| 2097152| 100|0.99560702| WEAK
diehard_bitstream| 0| 2097152| 200|0.47019123| PASSED
diehard_opso| 0| 2097152| 100|0.58743463| PASSED
diehard_oqso| 0| 2097152| 100|0.00000000| FAILED
diehard_dna| 0| 2097152| 100|0.00000000| FAILED
diehard_count_1s_str| 0| 256000| 100|0.90699558| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.97545849| PASSED
diehard_parking_lot| 0| 12000| 100|0.01296474| PASSED
diehard_2dsphere| 2| 8000| 100|0.51391418| PASSED
diehard_3dsphere| 3| 4000| 100|0.18584250| PASSED
diehard_squeeze| 0| 100000| 100|0.00726652| PASSED
diehard_sums| 0| 100| 100|0.40869228| PASSED
diehard_runs| 0| 100000| 100|0.05169565| PASSED
diehard_runs| 0| 100000| 100|0.98866390| PASSED
diehard_craps| 0| 200000| 100|0.35494552| PASSED
diehard_craps| 0| 200000| 100|0.47365191| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.14780252| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.29338446| PASSED
sts_monobit| 1| 100000| 100|0.97888201| PASSED
sts_runs| 2| 100000| 100|0.74655596| PASSED
sts_serial| 1| 100000| 100|0.41897552| PASSED
sts_serial| 2| 100000| 100|0.38034056| PASSED
sts_serial| 3| 100000| 100|0.99170185| PASSED
sts_serial| 3| 100000| 100|0.76457270| PASSED
sts_serial| 4| 100000| 100|0.80172413| PASSED
sts_serial| 4| 100000| 100|0.52177712| PASSED
sts_serial| 5| 100000| 100|0.99297019| PASSED
sts_serial| 5| 100000| 100|0.59183271| PASSED
sts_serial| 6| 100000| 100|0.94001454| PASSED
sts_serial| 6| 100000| 100|0.39218216| PASSED
sts_serial| 7| 100000| 100|0.69888838| PASSED
sts_serial| 7| 100000| 100|0.16541368| PASSED
sts_serial| 8| 100000| 100|0.47131229| PASSED
sts_serial| 8| 100000| 100|0.09817778| PASSED
sts_serial| 9| 100000| 100|0.42261781| PASSED
sts_serial| 9| 100000| 100|0.05344107| PASSED
sts_serial| 10| 100000| 100|0.77804588| PASSED
sts_serial| 10| 100000| 100|0.57799732| PASSED
sts_serial| 11| 100000| 100|0.01016312| PASSED
sts_serial| 11| 100000| 100|0.06073112| PASSED
sts_serial| 12| 100000| 100|0.65917138| PASSED
sts_serial| 12| 100000| 100|0.63230695| PASSED
sts_serial| 13| 100000| 100|0.84190399| PASSED
sts_serial| 13| 100000| 100|0.85277783| PASSED
sts_serial| 14| 100000| 100|0.49213152| PASSED
sts_serial| 14| 100000| 100|0.30112917| PASSED
sts_serial| 15| 100000| 100|0.14544079| PASSED
sts_serial| 15| 100000| 100|0.94737293| PASSED
sts_serial| 16| 100000| 100|0.39262889| PASSED
sts_serial| 16| 100000| 100|0.84185055| PASSED
rgb_bitdist| 1| 100000| 100|0.54063417| PASSED
rgb_bitdist| 2| 100000| 100|0.09286365| PASSED
rgb_bitdist| 3| 100000| 100|0.27436056| PASSED
rgb_bitdist| 4| 100000| 100|0.10595606| PASSED
rgb_bitdist| 5| 100000| 100|0.72828807| PASSED
rgb_bitdist| 6| 100000| 100|0.78439941| PASSED
rgb_bitdist| 7| 100000| 100|0.54939794| PASSED
rgb_bitdist| 8| 100000| 100|0.49285600| PASSED
rgb_bitdist| 9| 100000| 100|0.55836635| PASSED
rgb_bitdist| 10| 100000| 100|0.09735886| PASSED
rgb_bitdist| 11| 100000| 100|0.99987371| WEAK
rgb_bitdist| 11| 100000| 200|0.72189984| PASSED
rgb_bitdist| 12| 100000| 100|0.16961094| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.20393701| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.00000002| FAILED
rgb_minimum_distance| 4| 10000| 1000|0.00000000| FAILED
rgb_minimum_distance| 5| 10000| 1000|0.00000000| FAILED
rgb_permutations| 2| 100000| 100|0.57021718| PASSED
rgb_permutations| 3| 100000| 100|0.62537216| PASSED
rgb_permutations| 4| 100000| 100|0.34391663| PASSED
rgb_permutations| 5| 100000| 100|0.51106315| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.75921017| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.11901881| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.98766090| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.59129144| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.42126930| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.28570675| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.61879754| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.44777033| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.95714236| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.55158775| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.99968320| WEAK
rgb_lagged_sum| 10| 1000000| 200|0.94120047| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.00001553| WEAK
rgb_lagged_sum| 11| 1000000| 200|0.00000000| FAILED
rgb_lagged_sum| 12| 1000000| 100|0.88935254| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.76358163| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.93169219| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.00000000| FAILED
rgb_lagged_sum| 16| 1000000| 100|0.97118631| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.94598742| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.59454816| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.00027545| WEAK
rgb_lagged_sum| 19| 1000000| 200|0.00000001| FAILED
rgb_lagged_sum| 20| 1000000| 100|0.87996908| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.76558265| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.35273627| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.00007767| WEAK
rgb_lagged_sum| 23| 1000000| 200|0.00000000| FAILED
rgb_lagged_sum| 24| 1000000| 100|0.48030158| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.98040339| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.58094512| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.26354148| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.02516105| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.19290606| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.98500384| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.00000000| FAILED
rgb_lagged_sum| 32| 1000000| 100|0.73025626| PASSED
rgb_kstest_test| 0| 10000| 1000|0.02497988| PASSED
dab_bytedistrib| 0| 51200000| 1|1.00000000| FAILED
dab_dct| 256| 50000| 1|0.92579052| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.00000240| WEAK
dab_filltree| 32| 15000000| 1|0.00309996| WEAK
dab_filltree| 32| 15000000| 101|0.00000000| FAILED
dab_filltree| 32| 15000000| 101|0.00000000| FAILED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.24726392| PASSED
dab_filltree2| 1| 5000000| 1|0.74594891| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.66141319| PASSED
#
# Test duration: 165.6195733010167 minutes
#

139
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_10 Normal file
View File

@ -0,0 +1,139 @@
#
# RNG: org.apache.commons.math4.rng.internal.source64.MersenneTwister64
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.35e+06 |4060973066|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.38038146| PASSED
diehard_operm5| 0| 1000000| 100|0.82073994| PASSED
diehard_rank_32x32| 0| 40000| 100|0.99419941| PASSED
diehard_rank_6x8| 0| 100000| 100|0.84421559| PASSED
diehard_bitstream| 0| 2097152| 100|0.68114221| PASSED
diehard_opso| 0| 2097152| 100|0.49571971| PASSED
diehard_oqso| 0| 2097152| 100|0.50489838| PASSED
diehard_dna| 0| 2097152| 100|0.56038693| PASSED
diehard_count_1s_str| 0| 256000| 100|0.52187833| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.82794918| PASSED
diehard_parking_lot| 0| 12000| 100|0.94334354| PASSED
diehard_2dsphere| 2| 8000| 100|0.41934767| PASSED
diehard_3dsphere| 3| 4000| 100|0.38986875| PASSED
diehard_squeeze| 0| 100000| 100|0.30645416| PASSED
diehard_sums| 0| 100| 100|0.95555200| PASSED
diehard_runs| 0| 100000| 100|0.45678041| PASSED
diehard_runs| 0| 100000| 100|0.77628546| PASSED
diehard_craps| 0| 200000| 100|0.66628776| PASSED
diehard_craps| 0| 200000| 100|0.74815016| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.42574679| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.95301550| PASSED
sts_monobit| 1| 100000| 100|0.01768472| PASSED
sts_runs| 2| 100000| 100|0.66990502| PASSED
sts_serial| 1| 100000| 100|0.56397489| PASSED
sts_serial| 2| 100000| 100|0.14554819| PASSED
sts_serial| 3| 100000| 100|0.10532469| PASSED
sts_serial| 3| 100000| 100|0.50086684| PASSED
sts_serial| 4| 100000| 100|0.87214766| PASSED
sts_serial| 4| 100000| 100|0.96260182| PASSED
sts_serial| 5| 100000| 100|0.46155357| PASSED
sts_serial| 5| 100000| 100|0.93540615| PASSED
sts_serial| 6| 100000| 100|0.06399709| PASSED
sts_serial| 6| 100000| 100|0.37475484| PASSED
sts_serial| 7| 100000| 100|0.19960274| PASSED
sts_serial| 7| 100000| 100|0.71409873| PASSED
sts_serial| 8| 100000| 100|0.58265537| PASSED
sts_serial| 8| 100000| 100|0.30875682| PASSED
sts_serial| 9| 100000| 100|0.89120538| PASSED
sts_serial| 9| 100000| 100|0.08055589| PASSED
sts_serial| 10| 100000| 100|0.94326678| PASSED
sts_serial| 10| 100000| 100|0.63560702| PASSED
sts_serial| 11| 100000| 100|0.63552036| PASSED
sts_serial| 11| 100000| 100|0.41447321| PASSED
sts_serial| 12| 100000| 100|0.11137836| PASSED
sts_serial| 12| 100000| 100|0.31247769| PASSED
sts_serial| 13| 100000| 100|0.11571281| PASSED
sts_serial| 13| 100000| 100|0.34165091| PASSED
sts_serial| 14| 100000| 100|0.45691599| PASSED
sts_serial| 14| 100000| 100|0.86847228| PASSED
sts_serial| 15| 100000| 100|0.20344802| PASSED
sts_serial| 15| 100000| 100|0.01403264| PASSED
sts_serial| 16| 100000| 100|0.49704173| PASSED
sts_serial| 16| 100000| 100|0.99251040| PASSED
rgb_bitdist| 1| 100000| 100|0.82107588| PASSED
rgb_bitdist| 2| 100000| 100|0.26857984| PASSED
rgb_bitdist| 3| 100000| 100|0.74121909| PASSED
rgb_bitdist| 4| 100000| 100|0.85664588| PASSED
rgb_bitdist| 5| 100000| 100|0.14846957| PASSED
rgb_bitdist| 6| 100000| 100|0.58492538| PASSED
rgb_bitdist| 7| 100000| 100|0.50773594| PASSED
rgb_bitdist| 8| 100000| 100|0.51477335| PASSED
rgb_bitdist| 9| 100000| 100|0.58560247| PASSED
rgb_bitdist| 10| 100000| 100|0.73157176| PASSED
rgb_bitdist| 11| 100000| 100|0.35133278| PASSED
rgb_bitdist| 12| 100000| 100|0.69691200| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.11088599| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.56158689| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.85110247| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.85208203| PASSED
rgb_permutations| 2| 100000| 100|0.30212792| PASSED
rgb_permutations| 3| 100000| 100|0.37729899| PASSED
rgb_permutations| 4| 100000| 100|0.32979222| PASSED
rgb_permutations| 5| 100000| 100|0.68814175| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.57882968| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.93734672| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.64486630| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.94899438| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.12065130| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.98819337| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.05992105| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.07167199| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.56228730| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.10534144| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.53198515| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.97513880| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.84345586| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.68663096| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.90102702| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.33847765| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.60279321| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.58322395| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.42415615| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.36335552| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.81338367| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.75672514| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.72069324| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.31844638| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.94061253| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.83342998| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.31439533| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.97325800| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.84734559| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.93209485| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.51632833| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.99249230| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.11288279| PASSED
rgb_kstest_test| 0| 10000| 1000|0.62750032| PASSED
dab_bytedistrib| 0| 51200000| 1|0.64126517| PASSED
dab_dct| 256| 50000| 1|0.73583907| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.91066506| PASSED
dab_filltree| 32| 15000000| 1|0.72068986| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.43062103| PASSED
dab_filltree2| 1| 5000000| 1|0.68290109| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.99593445| WEAK
dab_monobit2| 12| 65000000| 101|0.01209486| PASSED
#
# Test duration: 127.73469639051667 minutes
#

148
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_11 Normal file
View File

@ -0,0 +1,148 @@
#
# RNG: org.apache.commons.math4.rng.internal.source64.SplitMix64
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 6.56e+06 |3876872701|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.89394608| PASSED
diehard_operm5| 0| 1000000| 100|0.44622126| PASSED
diehard_rank_32x32| 0| 40000| 100|0.93312610| PASSED
diehard_rank_6x8| 0| 100000| 100|0.83502820| PASSED
diehard_bitstream| 0| 2097152| 100|0.47558461| PASSED
diehard_opso| 0| 2097152| 100|0.83393107| PASSED
diehard_oqso| 0| 2097152| 100|0.17085818| PASSED
diehard_dna| 0| 2097152| 100|0.95316222| PASSED
diehard_count_1s_str| 0| 256000| 100|0.58772531| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.92622543| PASSED
diehard_parking_lot| 0| 12000| 100|0.24541775| PASSED
diehard_2dsphere| 2| 8000| 100|0.82051329| PASSED
diehard_3dsphere| 3| 4000| 100|0.16939087| PASSED
diehard_squeeze| 0| 100000| 100|0.26180585| PASSED
diehard_sums| 0| 100| 100|0.00131414| WEAK
diehard_sums| 0| 100| 200|0.00019033| WEAK
diehard_sums| 0| 100| 300|0.00001845| WEAK
diehard_sums| 0| 100| 400|0.00000274| WEAK
diehard_sums| 0| 100| 500|0.00000146| WEAK
diehard_sums| 0| 100| 600|0.00000518| WEAK
diehard_sums| 0| 100| 700|0.00000120| WEAK
diehard_sums| 0| 100| 800|0.00000136| WEAK
diehard_sums| 0| 100| 900|0.00000164| WEAK
diehard_sums| 0| 100| 1000|0.00000038| FAILED
diehard_runs| 0| 100000| 100|0.90697557| PASSED
diehard_runs| 0| 100000| 100|0.46492407| PASSED
diehard_craps| 0| 200000| 100|0.08890164| PASSED
diehard_craps| 0| 200000| 100|0.68877459| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.65830948| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.55949006| PASSED
sts_monobit| 1| 100000| 100|0.91014347| PASSED
sts_runs| 2| 100000| 100|0.46023787| PASSED
sts_serial| 1| 100000| 100|0.37938157| PASSED
sts_serial| 2| 100000| 100|0.79494593| PASSED
sts_serial| 3| 100000| 100|0.25702001| PASSED
sts_serial| 3| 100000| 100|0.56670546| PASSED
sts_serial| 4| 100000| 100|0.83700449| PASSED
sts_serial| 4| 100000| 100|0.15880323| PASSED
sts_serial| 5| 100000| 100|0.73026691| PASSED
sts_serial| 5| 100000| 100|0.79324799| PASSED
sts_serial| 6| 100000| 100|0.12893514| PASSED
sts_serial| 6| 100000| 100|0.43885054| PASSED
sts_serial| 7| 100000| 100|0.58482440| PASSED
sts_serial| 7| 100000| 100|0.59704969| PASSED
sts_serial| 8| 100000| 100|0.17431467| PASSED
sts_serial| 8| 100000| 100|0.88757904| PASSED
sts_serial| 9| 100000| 100|0.29214774| PASSED
sts_serial| 9| 100000| 100|0.21963552| PASSED
sts_serial| 10| 100000| 100|0.97034591| PASSED
sts_serial| 10| 100000| 100|0.68185135| PASSED
sts_serial| 11| 100000| 100|0.44262494| PASSED
sts_serial| 11| 100000| 100|0.60229032| PASSED
sts_serial| 12| 100000| 100|0.60546721| PASSED
sts_serial| 12| 100000| 100|0.68248356| PASSED
sts_serial| 13| 100000| 100|0.70604921| PASSED
sts_serial| 13| 100000| 100|0.33437419| PASSED
sts_serial| 14| 100000| 100|0.76956496| PASSED
sts_serial| 14| 100000| 100|0.45860942| PASSED
sts_serial| 15| 100000| 100|0.99328462| PASSED
sts_serial| 15| 100000| 100|0.27008137| PASSED
sts_serial| 16| 100000| 100|0.77186602| PASSED
sts_serial| 16| 100000| 100|0.95522347| PASSED
rgb_bitdist| 1| 100000| 100|0.65901869| PASSED
rgb_bitdist| 2| 100000| 100|0.96646800| PASSED
rgb_bitdist| 3| 100000| 100|0.56192931| PASSED
rgb_bitdist| 4| 100000| 100|0.71123613| PASSED
rgb_bitdist| 5| 100000| 100|0.60652057| PASSED
rgb_bitdist| 6| 100000| 100|0.40311562| PASSED
rgb_bitdist| 7| 100000| 100|0.94461945| PASSED
rgb_bitdist| 8| 100000| 100|0.94399288| PASSED
rgb_bitdist| 9| 100000| 100|0.18597796| PASSED
rgb_bitdist| 10| 100000| 100|0.16016896| PASSED
rgb_bitdist| 11| 100000| 100|0.43475932| PASSED
rgb_bitdist| 12| 100000| 100|0.99978738| WEAK
rgb_bitdist| 12| 100000| 200|0.68461269| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.16541757| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.24623892| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.01443284| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.11408750| PASSED
rgb_permutations| 2| 100000| 100|0.03121809| PASSED
rgb_permutations| 3| 100000| 100|0.79282729| PASSED
rgb_permutations| 4| 100000| 100|0.86630693| PASSED
rgb_permutations| 5| 100000| 100|0.51763993| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.89857723| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.74404815| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.02292037| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.93288381| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.90626965| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.47551343| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.98593748| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.05946751| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.50416533| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.68245658| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.43373343| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.96109236| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.41697577| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.73468235| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.36902723| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.98028491| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.99078444| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.54349261| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.04822766| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.05522277| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.65230164| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.47670341| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.21627174| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.60489204| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.78484760| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.16596556| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.91582999| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.49254250| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.25321125| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.60415030| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.98270526| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.71498718| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.50196089| PASSED
rgb_kstest_test| 0| 10000| 1000|0.62516898| PASSED
dab_bytedistrib| 0| 51200000| 1|0.57152727| PASSED
dab_dct| 256| 50000| 1|0.59394670| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.17868986| PASSED
dab_filltree| 32| 15000000| 1|0.81965604| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.36858723| PASSED
dab_filltree2| 1| 5000000| 1|0.62765239| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.08817873| PASSED
#
# Test duration: 116.67653443753333 minutes
#

172
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_12 Normal file
View File

@ -0,0 +1,172 @@
#
# RNG: org.apache.commons.math4.rng.internal.source64.XorShift1024Star
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.66e+06 |1277479534|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.86198313| PASSED
diehard_operm5| 0| 1000000| 100|0.63731814| PASSED
diehard_rank_32x32| 0| 40000| 100|0.13115738| PASSED
diehard_rank_6x8| 0| 100000| 100|0.62855999| PASSED
diehard_bitstream| 0| 2097152| 100|0.89731999| PASSED
diehard_opso| 0| 2097152| 100|0.17949849| PASSED
diehard_oqso| 0| 2097152| 100|0.95496419| PASSED
diehard_dna| 0| 2097152| 100|0.92220752| PASSED
diehard_count_1s_str| 0| 256000| 100|0.02583854| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.17781796| PASSED
diehard_parking_lot| 0| 12000| 100|0.39368629| PASSED
diehard_2dsphere| 2| 8000| 100|0.23540279| PASSED
diehard_3dsphere| 3| 4000| 100|0.09913499| PASSED
diehard_squeeze| 0| 100000| 100|0.46914639| PASSED
diehard_sums| 0| 100| 100|0.71241446| PASSED
diehard_runs| 0| 100000| 100|0.29355985| PASSED
diehard_runs| 0| 100000| 100|0.45855161| PASSED
diehard_craps| 0| 200000| 100|0.99743024| WEAK
diehard_craps| 0| 200000| 100|0.13198940| PASSED
diehard_craps| 0| 200000| 200|0.50198767| PASSED
diehard_craps| 0| 200000| 200|0.58025917| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.58571899| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.27724347| PASSED
sts_monobit| 1| 100000| 100|0.61773671| PASSED
sts_runs| 2| 100000| 100|0.16306655| PASSED
sts_serial| 1| 100000| 100|0.17914389| PASSED
sts_serial| 2| 100000| 100|0.67763220| PASSED
sts_serial| 3| 100000| 100|0.67391299| PASSED
sts_serial| 3| 100000| 100|0.99988809| WEAK
sts_serial| 4| 100000| 100|0.52472648| PASSED
sts_serial| 4| 100000| 100|0.55467848| PASSED
sts_serial| 5| 100000| 100|0.14392479| PASSED
sts_serial| 5| 100000| 100|0.58369865| PASSED
sts_serial| 6| 100000| 100|0.86311731| PASSED
sts_serial| 6| 100000| 100|0.62412787| PASSED
sts_serial| 7| 100000| 100|0.16807248| PASSED
sts_serial| 7| 100000| 100|0.06111990| PASSED
sts_serial| 8| 100000| 100|0.25524956| PASSED
sts_serial| 8| 100000| 100|0.72448783| PASSED
sts_serial| 9| 100000| 100|0.02704149| PASSED
sts_serial| 9| 100000| 100|0.41529079| PASSED
sts_serial| 10| 100000| 100|0.85009126| PASSED
sts_serial| 10| 100000| 100|0.48010293| PASSED
sts_serial| 11| 100000| 100|0.82872611| PASSED
sts_serial| 11| 100000| 100|0.89756655| PASSED
sts_serial| 12| 100000| 100|0.95201682| PASSED
sts_serial| 12| 100000| 100|0.25576598| PASSED
sts_serial| 13| 100000| 100|0.62201514| PASSED
sts_serial| 13| 100000| 100|0.57304663| PASSED
sts_serial| 14| 100000| 100|0.82023812| PASSED
sts_serial| 14| 100000| 100|0.16026739| PASSED
sts_serial| 15| 100000| 100|0.53508630| PASSED
sts_serial| 15| 100000| 100|0.26418736| PASSED
sts_serial| 16| 100000| 100|0.58894749| PASSED
sts_serial| 16| 100000| 100|0.46526557| PASSED
sts_serial| 1| 100000| 200|0.72352161| PASSED
sts_serial| 2| 100000| 200|0.75042646| PASSED
sts_serial| 3| 100000| 200|0.93847445| PASSED
sts_serial| 3| 100000| 200|0.62306511| PASSED
sts_serial| 4| 100000| 200|0.40341318| PASSED
sts_serial| 4| 100000| 200|0.26698158| PASSED
sts_serial| 5| 100000| 200|0.43240432| PASSED
sts_serial| 5| 100000| 200|0.97831152| PASSED
sts_serial| 6| 100000| 200|0.76521236| PASSED
sts_serial| 6| 100000| 200|0.66183325| PASSED
sts_serial| 7| 100000| 200|0.89309989| PASSED
sts_serial| 7| 100000| 200|0.03053954| PASSED
sts_serial| 8| 100000| 200|0.12273168| PASSED
sts_serial| 8| 100000| 200|0.08494183| PASSED
sts_serial| 9| 100000| 200|0.09684804| PASSED
sts_serial| 9| 100000| 200|0.47562336| PASSED
sts_serial| 10| 100000| 200|0.74134447| PASSED
sts_serial| 10| 100000| 200|0.97905748| PASSED
sts_serial| 11| 100000| 200|0.97413987| PASSED
sts_serial| 11| 100000| 200|0.91786276| PASSED
sts_serial| 12| 100000| 200|0.99116165| PASSED
sts_serial| 12| 100000| 200|0.42648513| PASSED
sts_serial| 13| 100000| 200|0.93068328| PASSED
sts_serial| 13| 100000| 200|0.98032272| PASSED
sts_serial| 14| 100000| 200|0.29657434| PASSED
sts_serial| 14| 100000| 200|0.09694261| PASSED
sts_serial| 15| 100000| 200|0.56619393| PASSED
sts_serial| 15| 100000| 200|0.82196711| PASSED
sts_serial| 16| 100000| 200|0.79646115| PASSED
sts_serial| 16| 100000| 200|0.78757244| PASSED
rgb_bitdist| 1| 100000| 100|0.55875683| PASSED
rgb_bitdist| 2| 100000| 100|0.98546150| PASSED
rgb_bitdist| 3| 100000| 100|0.64529161| PASSED
rgb_bitdist| 4| 100000| 100|0.90867536| PASSED
rgb_bitdist| 5| 100000| 100|0.99998913| WEAK
rgb_bitdist| 5| 100000| 200|0.31096608| PASSED
rgb_bitdist| 6| 100000| 100|0.54070259| PASSED
rgb_bitdist| 7| 100000| 100|0.85454917| PASSED
rgb_bitdist| 8| 100000| 100|0.75137668| PASSED
rgb_bitdist| 9| 100000| 100|0.52054867| PASSED
rgb_bitdist| 10| 100000| 100|0.05003706| PASSED
rgb_bitdist| 11| 100000| 100|0.51572696| PASSED
rgb_bitdist| 12| 100000| 100|0.33144705| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.47858895| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.01305979| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.72853927| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.37077925| PASSED
rgb_permutations| 2| 100000| 100|0.36844956| PASSED
rgb_permutations| 3| 100000| 100|0.15435203| PASSED
rgb_permutations| 4| 100000| 100|0.92635060| PASSED
rgb_permutations| 5| 100000| 100|0.12448644| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.07050481| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.90574934| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.97049936| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.15551539| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.39742832| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.06560771| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.25967033| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.23465718| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.95894771| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.99644149| WEAK
rgb_lagged_sum| 9| 1000000| 200|0.72122320| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.40592463| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.11499425| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.09093057| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.83672570| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.06379458| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.25409683| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.45738764| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.27200323| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.96676225| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.21539480| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.46300952| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.33383290| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.22278328| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.99014659| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.60055427| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.84297553| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.11376412| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.74618911| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.35634899| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.95186868| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.51735206| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.32749912| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.44005272| PASSED
rgb_kstest_test| 0| 10000| 1000|0.97185072| PASSED
dab_bytedistrib| 0| 51200000| 1|0.99007726| PASSED
dab_dct| 256| 50000| 1|0.09683268| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.27626888| PASSED
dab_filltree| 32| 15000000| 1|0.69368536| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.58725536| PASSED
dab_filltree2| 1| 5000000| 1|0.32244773| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.69535825| PASSED
#
# Test duration: 118.87736675828334 minutes
#

168
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_13 Normal file
View File

@ -0,0 +1,168 @@
#
# RNG: org.apache.commons.math4.rng.internal.source64.TwoCmres (Cmres: [0xedce446814d3b3d9L, 33, 330658535] + Cmres: [0xc5b3cf786c806df7L, 33, 331932042])
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 7.87e+06 |1623170409|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.06673649| PASSED
diehard_operm5| 0| 1000000| 100|0.30427840| PASSED
diehard_rank_32x32| 0| 40000| 100|0.25200666| PASSED
diehard_rank_6x8| 0| 100000| 100|0.13734856| PASSED
diehard_bitstream| 0| 2097152| 100|0.66626521| PASSED
diehard_opso| 0| 2097152| 100|0.56775058| PASSED
diehard_oqso| 0| 2097152| 100|0.28852698| PASSED
diehard_dna| 0| 2097152| 100|0.12361343| PASSED
diehard_count_1s_str| 0| 256000| 100|0.60377568| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.79315934| PASSED
diehard_parking_lot| 0| 12000| 100|0.95039058| PASSED
diehard_2dsphere| 2| 8000| 100|0.16615086| PASSED
diehard_3dsphere| 3| 4000| 100|0.33710498| PASSED
diehard_squeeze| 0| 100000| 100|0.31917042| PASSED
diehard_sums| 0| 100| 100|0.76356650| PASSED
diehard_runs| 0| 100000| 100|0.98291382| PASSED
diehard_runs| 0| 100000| 100|0.51985231| PASSED
diehard_craps| 0| 200000| 100|0.96403781| PASSED
diehard_craps| 0| 200000| 100|0.02637301| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.72890473| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.69803814| PASSED
sts_monobit| 1| 100000| 100|0.63975148| PASSED
sts_runs| 2| 100000| 100|0.15337659| PASSED
sts_serial| 1| 100000| 100|0.12204467| PASSED
sts_serial| 2| 100000| 100|0.86816684| PASSED
sts_serial| 3| 100000| 100|0.94763649| PASSED
sts_serial| 3| 100000| 100|0.79632534| PASSED
sts_serial| 4| 100000| 100|0.99876777| WEAK
sts_serial| 4| 100000| 100|0.83069123| PASSED
sts_serial| 5| 100000| 100|0.75728847| PASSED
sts_serial| 5| 100000| 100|0.62780517| PASSED
sts_serial| 6| 100000| 100|0.91234446| PASSED
sts_serial| 6| 100000| 100|0.64583386| PASSED
sts_serial| 7| 100000| 100|0.67214207| PASSED
sts_serial| 7| 100000| 100|0.79137329| PASSED
sts_serial| 8| 100000| 100|0.57000983| PASSED
sts_serial| 8| 100000| 100|0.92782289| PASSED
sts_serial| 9| 100000| 100|0.67721181| PASSED
sts_serial| 9| 100000| 100|0.55798035| PASSED
sts_serial| 10| 100000| 100|0.90302847| PASSED
sts_serial| 10| 100000| 100|0.70802558| PASSED
sts_serial| 11| 100000| 100|0.10814216| PASSED
sts_serial| 11| 100000| 100|0.73924740| PASSED
sts_serial| 12| 100000| 100|0.96310906| PASSED
sts_serial| 12| 100000| 100|0.42933642| PASSED
sts_serial| 13| 100000| 100|0.89363587| PASSED
sts_serial| 13| 100000| 100|0.71140691| PASSED
sts_serial| 14| 100000| 100|0.75667049| PASSED
sts_serial| 14| 100000| 100|0.53365354| PASSED
sts_serial| 15| 100000| 100|0.81564398| PASSED
sts_serial| 15| 100000| 100|0.81890036| PASSED
sts_serial| 16| 100000| 100|0.22787288| PASSED
sts_serial| 16| 100000| 100|0.51079464| PASSED
sts_serial| 1| 100000| 200|0.45248588| PASSED
sts_serial| 2| 100000| 200|0.73940169| PASSED
sts_serial| 3| 100000| 200|0.76608817| PASSED
sts_serial| 3| 100000| 200|0.68569219| PASSED
sts_serial| 4| 100000| 200|0.97533008| PASSED
sts_serial| 4| 100000| 200|0.66357569| PASSED
sts_serial| 5| 100000| 200|0.51585852| PASSED
sts_serial| 5| 100000| 200|0.76937150| PASSED
sts_serial| 6| 100000| 200|0.20423389| PASSED
sts_serial| 6| 100000| 200|0.24855182| PASSED
sts_serial| 7| 100000| 200|0.83937387| PASSED
sts_serial| 7| 100000| 200|0.10776938| PASSED
sts_serial| 8| 100000| 200|0.46985760| PASSED
sts_serial| 8| 100000| 200|0.91624018| PASSED
sts_serial| 9| 100000| 200|0.31272546| PASSED
sts_serial| 9| 100000| 200|0.41419756| PASSED
sts_serial| 10| 100000| 200|0.24132141| PASSED
sts_serial| 10| 100000| 200|0.95518257| PASSED
sts_serial| 11| 100000| 200|0.07700528| PASSED
sts_serial| 11| 100000| 200|0.46704231| PASSED
sts_serial| 12| 100000| 200|0.25784729| PASSED
sts_serial| 12| 100000| 200|0.58129670| PASSED
sts_serial| 13| 100000| 200|0.16331253| PASSED
sts_serial| 13| 100000| 200|0.93405341| PASSED
sts_serial| 14| 100000| 200|0.18029999| PASSED
sts_serial| 14| 100000| 200|0.72961703| PASSED
sts_serial| 15| 100000| 200|0.61321362| PASSED
sts_serial| 15| 100000| 200|0.63184058| PASSED
sts_serial| 16| 100000| 200|0.20773905| PASSED
sts_serial| 16| 100000| 200|0.71586909| PASSED
rgb_bitdist| 1| 100000| 100|0.69415931| PASSED
rgb_bitdist| 2| 100000| 100|0.12624091| PASSED
rgb_bitdist| 3| 100000| 100|0.22538287| PASSED
rgb_bitdist| 4| 100000| 100|0.32055635| PASSED
rgb_bitdist| 5| 100000| 100|0.13052601| PASSED
rgb_bitdist| 6| 100000| 100|0.52801646| PASSED
rgb_bitdist| 7| 100000| 100|0.67087873| PASSED
rgb_bitdist| 8| 100000| 100|0.63129626| PASSED
rgb_bitdist| 9| 100000| 100|0.98800258| PASSED
rgb_bitdist| 10| 100000| 100|0.30029002| PASSED
rgb_bitdist| 11| 100000| 100|0.94642893| PASSED
rgb_bitdist| 12| 100000| 100|0.99443795| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.55457479| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.07265421| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.49304406| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.38882417| PASSED
rgb_permutations| 2| 100000| 100|0.85766631| PASSED
rgb_permutations| 3| 100000| 100|0.93256747| PASSED
rgb_permutations| 4| 100000| 100|0.55684664| PASSED
rgb_permutations| 5| 100000| 100|0.74620535| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.17980216| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.63342243| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.22324314| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.59564694| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.65899678| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.39673184| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.46298516| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.16100713| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.84282969| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.97992525| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.68272004| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.17844944| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.11191312| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.29326968| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.99177158| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.80801444| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.17813701| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.17939213| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.88358710| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.84354589| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.57913594| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.71916259| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.61143784| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.14727082| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.90142206| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.94430752| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.80380200| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.28284147| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.20001887| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.81875443| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.54027690| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.66221005| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.98646262| PASSED
rgb_kstest_test| 0| 10000| 1000|0.01721435| PASSED
dab_bytedistrib| 0| 51200000| 1|0.48656023| PASSED
dab_dct| 256| 50000| 1|0.26895122| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.80215939| PASSED
dab_filltree| 32| 15000000| 1|0.23290890| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.70369720| PASSED
dab_filltree2| 1| 5000000| 1|0.17892404| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.29468051| PASSED
#
# Test duration: 120.78482549196669 minutes
#

139
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_2 Normal file
View File

@ -0,0 +1,139 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.MersenneTwister
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.63e+06 | 909089418|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.57666818| PASSED
diehard_operm5| 0| 1000000| 100|0.10676771| PASSED
diehard_rank_32x32| 0| 40000| 100|0.74337120| PASSED
diehard_rank_6x8| 0| 100000| 100|0.68880686| PASSED
diehard_bitstream| 0| 2097152| 100|0.69978963| PASSED
diehard_opso| 0| 2097152| 100|0.97501727| PASSED
diehard_oqso| 0| 2097152| 100|0.81350437| PASSED
diehard_dna| 0| 2097152| 100|0.20400884| PASSED
diehard_count_1s_str| 0| 256000| 100|0.15322777| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.14494589| PASSED
diehard_parking_lot| 0| 12000| 100|0.51474850| PASSED
diehard_2dsphere| 2| 8000| 100|0.95366320| PASSED
diehard_3dsphere| 3| 4000| 100|0.43818452| PASSED
diehard_squeeze| 0| 100000| 100|0.40334241| PASSED
diehard_sums| 0| 100| 100|0.76348841| PASSED
diehard_runs| 0| 100000| 100|0.79256591| PASSED
diehard_runs| 0| 100000| 100|0.25445506| PASSED
diehard_craps| 0| 200000| 100|0.32367700| PASSED
diehard_craps| 0| 200000| 100|0.70730899| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.01837715| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.81349523| PASSED
sts_monobit| 1| 100000| 100|0.64167023| PASSED
sts_runs| 2| 100000| 100|0.55130082| PASSED
sts_serial| 1| 100000| 100|0.44545864| PASSED
sts_serial| 2| 100000| 100|0.35537223| PASSED
sts_serial| 3| 100000| 100|0.13085564| PASSED
sts_serial| 3| 100000| 100|0.76794555| PASSED
sts_serial| 4| 100000| 100|0.23072317| PASSED
sts_serial| 4| 100000| 100|0.10561915| PASSED
sts_serial| 5| 100000| 100|0.78697932| PASSED
sts_serial| 5| 100000| 100|0.81793074| PASSED
sts_serial| 6| 100000| 100|0.67895492| PASSED
sts_serial| 6| 100000| 100|0.88569864| PASSED
sts_serial| 7| 100000| 100|0.98638259| PASSED
sts_serial| 7| 100000| 100|0.56313192| PASSED
sts_serial| 8| 100000| 100|0.42004340| PASSED
sts_serial| 8| 100000| 100|0.45497062| PASSED
sts_serial| 9| 100000| 100|0.41746404| PASSED
sts_serial| 9| 100000| 100|0.92447592| PASSED
sts_serial| 10| 100000| 100|0.74648127| PASSED
sts_serial| 10| 100000| 100|0.36009885| PASSED
sts_serial| 11| 100000| 100|0.69574999| PASSED
sts_serial| 11| 100000| 100|0.40293019| PASSED
sts_serial| 12| 100000| 100|0.03981890| PASSED
sts_serial| 12| 100000| 100|0.69569396| PASSED
sts_serial| 13| 100000| 100|0.63061198| PASSED
sts_serial| 13| 100000| 100|0.63037669| PASSED
sts_serial| 14| 100000| 100|0.87816463| PASSED
sts_serial| 14| 100000| 100|0.21663864| PASSED
sts_serial| 15| 100000| 100|0.87852591| PASSED
sts_serial| 15| 100000| 100|0.41693707| PASSED
sts_serial| 16| 100000| 100|0.33631835| PASSED
sts_serial| 16| 100000| 100|0.65572542| PASSED
rgb_bitdist| 1| 100000| 100|0.97695501| PASSED
rgb_bitdist| 2| 100000| 100|0.88067359| PASSED
rgb_bitdist| 3| 100000| 100|0.89288899| PASSED
rgb_bitdist| 4| 100000| 100|0.42071996| PASSED
rgb_bitdist| 5| 100000| 100|0.96788278| PASSED
rgb_bitdist| 6| 100000| 100|0.03237150| PASSED
rgb_bitdist| 7| 100000| 100|0.99273662| PASSED
rgb_bitdist| 8| 100000| 100|0.58534734| PASSED
rgb_bitdist| 9| 100000| 100|0.24754216| PASSED
rgb_bitdist| 10| 100000| 100|0.86834877| PASSED
rgb_bitdist| 11| 100000| 100|0.70560945| PASSED
rgb_bitdist| 12| 100000| 100|0.90617943| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.60172035| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.62349099| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.93111162| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.68394275| PASSED
rgb_permutations| 2| 100000| 100|0.42623990| PASSED
rgb_permutations| 3| 100000| 100|0.09156349| PASSED
rgb_permutations| 4| 100000| 100|0.24806729| PASSED
rgb_permutations| 5| 100000| 100|0.99945481| WEAK
rgb_permutations| 5| 100000| 200|0.98242354| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.28501418| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.14402422| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.42909551| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.96931894| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.24946832| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.76140626| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.76905041| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.23977956| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.58321098| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.63502451| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.93678255| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.18382447| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.58329523| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.75276909| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.84309855| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.52505871| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.66504576| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.37592499| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.98037413| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.08356807| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.28079745| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.70923675| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.43704352| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.56901929| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.46522224| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.81510301| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.89165619| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.09809237| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.85382352| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.10819683| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.68401331| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.83058076| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.28293116| PASSED
rgb_kstest_test| 0| 10000| 1000|0.40832593| PASSED
dab_bytedistrib| 0| 51200000| 1|0.56819550| PASSED
dab_dct| 256| 50000| 1|0.11083045| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.46591225| PASSED
dab_filltree| 32| 15000000| 1|0.22493349| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.25637799| PASSED
dab_filltree2| 1| 5000000| 1|0.08104752| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.57265590| PASSED
#
# Test duration: 116.58544601305 minutes
#

173
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_3 Normal file
View File

@ -0,0 +1,173 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well512a
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.51e+06 |4211420527|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.73569699| PASSED
diehard_operm5| 0| 1000000| 100|0.08622316| PASSED
diehard_rank_32x32| 0| 40000| 100|0.80836729| PASSED
diehard_rank_6x8| 0| 100000| 100|0.99111559| PASSED
diehard_bitstream| 0| 2097152| 100|0.83659726| PASSED
diehard_opso| 0| 2097152| 100|0.70330969| PASSED
diehard_oqso| 0| 2097152| 100|0.65389789| PASSED
diehard_dna| 0| 2097152| 100|0.48126817| PASSED
diehard_count_1s_str| 0| 256000| 100|0.90155342| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.24169832| PASSED
diehard_parking_lot| 0| 12000| 100|0.95085394| PASSED
diehard_2dsphere| 2| 8000| 100|0.70520965| PASSED
diehard_3dsphere| 3| 4000| 100|0.99881464| WEAK
diehard_3dsphere| 3| 4000| 200|0.65540217| PASSED
diehard_squeeze| 0| 100000| 100|0.88558219| PASSED
diehard_sums| 0| 100| 100|0.97435568| PASSED
diehard_runs| 0| 100000| 100|0.46447902| PASSED
diehard_runs| 0| 100000| 100|0.77608604| PASSED
diehard_craps| 0| 200000| 100|0.74670227| PASSED
diehard_craps| 0| 200000| 100|0.07572357| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.49225755| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.01154094| PASSED
sts_monobit| 1| 100000| 100|0.51545966| PASSED
sts_runs| 2| 100000| 100|0.46898980| PASSED
sts_serial| 1| 100000| 100|0.48264154| PASSED
sts_serial| 2| 100000| 100|0.87095634| PASSED
sts_serial| 3| 100000| 100|0.93502495| PASSED
sts_serial| 3| 100000| 100|0.92442039| PASSED
sts_serial| 4| 100000| 100|0.20983709| PASSED
sts_serial| 4| 100000| 100|0.11248912| PASSED
sts_serial| 5| 100000| 100|0.33340568| PASSED
sts_serial| 5| 100000| 100|0.83923511| PASSED
sts_serial| 6| 100000| 100|0.77159773| PASSED
sts_serial| 6| 100000| 100|0.99729842| WEAK
sts_serial| 7| 100000| 100|0.69682384| PASSED
sts_serial| 7| 100000| 100|0.49451383| PASSED
sts_serial| 8| 100000| 100|0.21687301| PASSED
sts_serial| 8| 100000| 100|0.20732811| PASSED
sts_serial| 9| 100000| 100|0.15358619| PASSED
sts_serial| 9| 100000| 100|0.79842773| PASSED
sts_serial| 10| 100000| 100|0.28868417| PASSED
sts_serial| 10| 100000| 100|0.72864074| PASSED
sts_serial| 11| 100000| 100|0.52528201| PASSED
sts_serial| 11| 100000| 100|0.56684576| PASSED
sts_serial| 12| 100000| 100|0.94363896| PASSED
sts_serial| 12| 100000| 100|0.75370192| PASSED
sts_serial| 13| 100000| 100|0.64929204| PASSED
sts_serial| 13| 100000| 100|0.16172691| PASSED
sts_serial| 14| 100000| 100|0.25057488| PASSED
sts_serial| 14| 100000| 100|0.48541434| PASSED
sts_serial| 15| 100000| 100|0.22064194| PASSED
sts_serial| 15| 100000| 100|0.01808135| PASSED
sts_serial| 16| 100000| 100|0.80793746| PASSED
sts_serial| 16| 100000| 100|0.43733434| PASSED
sts_serial| 1| 100000| 200|0.34976204| PASSED
sts_serial| 2| 100000| 200|0.93526197| PASSED
sts_serial| 3| 100000| 200|0.50858476| PASSED
sts_serial| 3| 100000| 200|0.19465837| PASSED
sts_serial| 4| 100000| 200|0.01310388| PASSED
sts_serial| 4| 100000| 200|0.23421588| PASSED
sts_serial| 5| 100000| 200|0.96469089| PASSED
sts_serial| 5| 100000| 200|0.16949722| PASSED
sts_serial| 6| 100000| 200|0.43346233| PASSED
sts_serial| 6| 100000| 200|0.69913325| PASSED
sts_serial| 7| 100000| 200|0.71578405| PASSED
sts_serial| 7| 100000| 200|0.22797027| PASSED
sts_serial| 8| 100000| 200|0.26581934| PASSED
sts_serial| 8| 100000| 200|0.14862050| PASSED
sts_serial| 9| 100000| 200|0.22688915| PASSED
sts_serial| 9| 100000| 200|0.70814818| PASSED
sts_serial| 10| 100000| 200|0.46870704| PASSED
sts_serial| 10| 100000| 200|0.80822502| PASSED
sts_serial| 11| 100000| 200|0.07913288| PASSED
sts_serial| 11| 100000| 200|0.62243568| PASSED
sts_serial| 12| 100000| 200|0.90482873| PASSED
sts_serial| 12| 100000| 200|0.76035109| PASSED
sts_serial| 13| 100000| 200|0.55907604| PASSED
sts_serial| 13| 100000| 200|0.04002659| PASSED
sts_serial| 14| 100000| 200|0.42102911| PASSED
sts_serial| 14| 100000| 200|0.43398037| PASSED
sts_serial| 15| 100000| 200|0.35645685| PASSED
sts_serial| 15| 100000| 200|0.32876181| PASSED
sts_serial| 16| 100000| 200|0.30750171| PASSED
sts_serial| 16| 100000| 200|0.09587246| PASSED
rgb_bitdist| 1| 100000| 100|0.87310037| PASSED
rgb_bitdist| 2| 100000| 100|0.31592448| PASSED
rgb_bitdist| 3| 100000| 100|0.61824218| PASSED
rgb_bitdist| 4| 100000| 100|0.99942776| WEAK
rgb_bitdist| 4| 100000| 200|0.92398512| PASSED
rgb_bitdist| 5| 100000| 100|0.88343458| PASSED
rgb_bitdist| 6| 100000| 100|0.83272604| PASSED
rgb_bitdist| 7| 100000| 100|0.98829206| PASSED
rgb_bitdist| 8| 100000| 100|0.99907992| WEAK
rgb_bitdist| 8| 100000| 200|0.86791402| PASSED
rgb_bitdist| 9| 100000| 100|0.46498741| PASSED
rgb_bitdist| 10| 100000| 100|0.61928372| PASSED
rgb_bitdist| 11| 100000| 100|0.84783913| PASSED
rgb_bitdist| 12| 100000| 100|0.23328216| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.93646288| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.99761569| WEAK
rgb_minimum_distance| 3| 10000| 1100|0.97748827| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.81621178| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.11447885| PASSED
rgb_permutations| 2| 100000| 100|0.96689779| PASSED
rgb_permutations| 3| 100000| 100|0.81610330| PASSED
rgb_permutations| 4| 100000| 100|0.56063833| PASSED
rgb_permutations| 5| 100000| 100|0.80868060| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.04484539| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.99994915| WEAK
rgb_lagged_sum| 1| 1000000| 200|0.25055014| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.27636319| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.16970026| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.04565450| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.55001363| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.81626184| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.53218931| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.42800661| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.64722177| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.59656239| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.07248502| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.60370774| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.67685289| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.67111539| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.13888373| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.89991041| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.87684042| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.28816255| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.63431690| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.04818588| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.22299419| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.81364986| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.76859070| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.25131951| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.13082282| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.26551839| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.13675576| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.72796549| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.60128457| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.79992817| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.42925500| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.28257611| PASSED
rgb_kstest_test| 0| 10000| 1000|0.14339836| PASSED
dab_bytedistrib| 0| 51200000| 1|0.94043589| PASSED
dab_dct| 256| 50000| 1|0.50865939| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.77604985| PASSED
dab_filltree| 32| 15000000| 1|0.14225807| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.83200748| PASSED
dab_filltree2| 1| 5000000| 1|0.02390761| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.57871202| PASSED
#
# Test duration: 118.20524420808334 minutes
#

140
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_4 Normal file
View File

@ -0,0 +1,140 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well1024a
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.42e+06 |2497224856|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.93943859| PASSED
diehard_operm5| 0| 1000000| 100|0.63728896| PASSED
diehard_rank_32x32| 0| 40000| 100|0.95580176| PASSED
diehard_rank_6x8| 0| 100000| 100|0.18097112| PASSED
diehard_bitstream| 0| 2097152| 100|0.99343489| PASSED
diehard_opso| 0| 2097152| 100|0.94166579| PASSED
diehard_oqso| 0| 2097152| 100|0.22314485| PASSED
diehard_dna| 0| 2097152| 100|0.79986859| PASSED
diehard_count_1s_str| 0| 256000| 100|0.70848092| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.83114286| PASSED
diehard_parking_lot| 0| 12000| 100|0.40502936| PASSED
diehard_2dsphere| 2| 8000| 100|0.62710075| PASSED
diehard_3dsphere| 3| 4000| 100|0.74542315| PASSED
diehard_squeeze| 0| 100000| 100|0.41799689| PASSED
diehard_sums| 0| 100| 100|0.00534029| PASSED
diehard_runs| 0| 100000| 100|0.90021313| PASSED
diehard_runs| 0| 100000| 100|0.16525007| PASSED
diehard_craps| 0| 200000| 100|0.97941614| PASSED
diehard_craps| 0| 200000| 100|0.79551098| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.25751371| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.53841215| PASSED
sts_monobit| 1| 100000| 100|0.75586975| PASSED
sts_runs| 2| 100000| 100|0.66449057| PASSED
sts_serial| 1| 100000| 100|0.47969343| PASSED
sts_serial| 2| 100000| 100|0.97479350| PASSED
sts_serial| 3| 100000| 100|0.80306348| PASSED
sts_serial| 3| 100000| 100|0.89855897| PASSED
sts_serial| 4| 100000| 100|0.79521344| PASSED
sts_serial| 4| 100000| 100|0.82696406| PASSED
sts_serial| 5| 100000| 100|0.72777371| PASSED
sts_serial| 5| 100000| 100|0.90364439| PASSED
sts_serial| 6| 100000| 100|0.94248747| PASSED
sts_serial| 6| 100000| 100|0.84120341| PASSED
sts_serial| 7| 100000| 100|0.57766358| PASSED
sts_serial| 7| 100000| 100|0.94269176| PASSED
sts_serial| 8| 100000| 100|0.72358453| PASSED
sts_serial| 8| 100000| 100|0.42902721| PASSED
sts_serial| 9| 100000| 100|0.70277439| PASSED
sts_serial| 9| 100000| 100|0.74865473| PASSED
sts_serial| 10| 100000| 100|0.69649290| PASSED
sts_serial| 10| 100000| 100|0.56688921| PASSED
sts_serial| 11| 100000| 100|0.46844177| PASSED
sts_serial| 11| 100000| 100|0.65632957| PASSED
sts_serial| 12| 100000| 100|0.33209458| PASSED
sts_serial| 12| 100000| 100|0.07622771| PASSED
sts_serial| 13| 100000| 100|0.08350208| PASSED
sts_serial| 13| 100000| 100|0.39915645| PASSED
sts_serial| 14| 100000| 100|0.71431624| PASSED
sts_serial| 14| 100000| 100|0.41316037| PASSED
sts_serial| 15| 100000| 100|0.61006624| PASSED
sts_serial| 15| 100000| 100|0.57857458| PASSED
sts_serial| 16| 100000| 100|0.77349407| PASSED
sts_serial| 16| 100000| 100|0.63593005| PASSED
rgb_bitdist| 1| 100000| 100|0.30023699| PASSED
rgb_bitdist| 2| 100000| 100|0.00249511| WEAK
rgb_bitdist| 2| 100000| 200|0.08721476| PASSED
rgb_bitdist| 3| 100000| 100|0.98468481| PASSED
rgb_bitdist| 4| 100000| 100|0.09495465| PASSED
rgb_bitdist| 5| 100000| 100|0.49274571| PASSED
rgb_bitdist| 6| 100000| 100|0.10569290| PASSED
rgb_bitdist| 7| 100000| 100|0.47612470| PASSED
rgb_bitdist| 8| 100000| 100|0.90156059| PASSED
rgb_bitdist| 9| 100000| 100|0.30526760| PASSED
rgb_bitdist| 10| 100000| 100|0.70397740| PASSED
rgb_bitdist| 11| 100000| 100|0.79932716| PASSED
rgb_bitdist| 12| 100000| 100|0.66661217| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.99069444| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.77935640| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.60074439| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.70558491| PASSED
rgb_permutations| 2| 100000| 100|0.88696488| PASSED
rgb_permutations| 3| 100000| 100|0.12568196| PASSED
rgb_permutations| 4| 100000| 100|0.48262897| PASSED
rgb_permutations| 5| 100000| 100|0.89950526| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.03246953| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.21606141| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.96675656| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.59100832| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.25778641| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.69962887| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.63056047| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.28816373| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.84364800| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.23523932| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.81983359| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.97430489| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.90295208| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.11930308| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.63926431| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.26795824| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.68419648| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.12107420| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.31015405| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.72145665| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.72609446| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.84462652| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.95286882| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.89006976| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.30068378| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.60464167| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.28938971| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.99518634| WEAK
rgb_lagged_sum| 27| 1000000| 200|0.90965463| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.55903539| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.50446676| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.07112938| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.52086491| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.74499506| PASSED
rgb_kstest_test| 0| 10000| 1000|0.36734192| PASSED
dab_bytedistrib| 0| 51200000| 1|0.66315774| PASSED
dab_dct| 256| 50000| 1|0.80017590| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.18763190| PASSED
dab_filltree| 32| 15000000| 1|0.67790596| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.74471137| PASSED
dab_filltree2| 1| 5000000| 1|0.50106617| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.36989956| PASSED
#
# Test duration: 122.20074466720001 minutes
#

140
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_5 Normal file
View File

@ -0,0 +1,140 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well19937a
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.06e+06 | 944676986|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.82045877| PASSED
diehard_operm5| 0| 1000000| 100|0.84473310| PASSED
diehard_rank_32x32| 0| 40000| 100|0.45195539| PASSED
diehard_rank_6x8| 0| 100000| 100|0.70289015| PASSED
diehard_bitstream| 0| 2097152| 100|0.27390588| PASSED
diehard_opso| 0| 2097152| 100|0.91111976| PASSED
diehard_oqso| 0| 2097152| 100|0.02130490| PASSED
diehard_dna| 0| 2097152| 100|0.16227625| PASSED
diehard_count_1s_str| 0| 256000| 100|0.50065029| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.84089195| PASSED
diehard_parking_lot| 0| 12000| 100|0.09561419| PASSED
diehard_2dsphere| 2| 8000| 100|0.99368228| PASSED
diehard_3dsphere| 3| 4000| 100|0.02820788| PASSED
diehard_squeeze| 0| 100000| 100|0.82285003| PASSED
diehard_sums| 0| 100| 100|0.07114222| PASSED
diehard_runs| 0| 100000| 100|0.94217033| PASSED
diehard_runs| 0| 100000| 100|0.98486755| PASSED
diehard_craps| 0| 200000| 100|0.20251530| PASSED
diehard_craps| 0| 200000| 100|0.97545408| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.46275263| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.83452806| PASSED
sts_monobit| 1| 100000| 100|0.63882607| PASSED
sts_runs| 2| 100000| 100|0.65857445| PASSED
sts_serial| 1| 100000| 100|0.28813074| PASSED
sts_serial| 2| 100000| 100|0.59340831| PASSED
sts_serial| 3| 100000| 100|0.73841124| PASSED
sts_serial| 3| 100000| 100|0.11029865| PASSED
sts_serial| 4| 100000| 100|0.69147207| PASSED
sts_serial| 4| 100000| 100|0.24211323| PASSED
sts_serial| 5| 100000| 100|0.42113289| PASSED
sts_serial| 5| 100000| 100|0.22195716| PASSED
sts_serial| 6| 100000| 100|0.40125433| PASSED
sts_serial| 6| 100000| 100|0.49315024| PASSED
sts_serial| 7| 100000| 100|0.84984551| PASSED
sts_serial| 7| 100000| 100|0.95984864| PASSED
sts_serial| 8| 100000| 100|0.11799542| PASSED
sts_serial| 8| 100000| 100|0.96167249| PASSED
sts_serial| 9| 100000| 100|0.71524974| PASSED
sts_serial| 9| 100000| 100|0.52923584| PASSED
sts_serial| 10| 100000| 100|0.26515863| PASSED
sts_serial| 10| 100000| 100|0.49996394| PASSED
sts_serial| 11| 100000| 100|0.84125453| PASSED
sts_serial| 11| 100000| 100|0.98729007| PASSED
sts_serial| 12| 100000| 100|0.74606799| PASSED
sts_serial| 12| 100000| 100|0.96135142| PASSED
sts_serial| 13| 100000| 100|0.79151378| PASSED
sts_serial| 13| 100000| 100|0.95646369| PASSED
sts_serial| 14| 100000| 100|0.85182328| PASSED
sts_serial| 14| 100000| 100|0.45431179| PASSED
sts_serial| 15| 100000| 100|0.92779031| PASSED
sts_serial| 15| 100000| 100|0.97606049| PASSED
sts_serial| 16| 100000| 100|0.43128126| PASSED
sts_serial| 16| 100000| 100|0.93524173| PASSED
rgb_bitdist| 1| 100000| 100|0.56998908| PASSED
rgb_bitdist| 2| 100000| 100|0.09449602| PASSED
rgb_bitdist| 3| 100000| 100|0.69656828| PASSED
rgb_bitdist| 4| 100000| 100|0.87135093| PASSED
rgb_bitdist| 5| 100000| 100|0.62350313| PASSED
rgb_bitdist| 6| 100000| 100|0.14372522| PASSED
rgb_bitdist| 7| 100000| 100|0.86877141| PASSED
rgb_bitdist| 8| 100000| 100|0.95728455| PASSED
rgb_bitdist| 9| 100000| 100|0.59624944| PASSED
rgb_bitdist| 10| 100000| 100|0.60481178| PASSED
rgb_bitdist| 11| 100000| 100|0.19222006| PASSED
rgb_bitdist| 12| 100000| 100|0.63945132| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.85307803| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.81294855| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.03739119| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.09435474| PASSED
rgb_permutations| 2| 100000| 100|0.92217060| PASSED
rgb_permutations| 3| 100000| 100|0.80890515| PASSED
rgb_permutations| 4| 100000| 100|0.91880038| PASSED
rgb_permutations| 5| 100000| 100|0.53864209| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.68568696| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.01107186| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.86445672| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.39067655| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.82306252| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.94609907| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.49706294| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.13833086| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.63595987| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.89354116| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.02182848| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.45525029| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.58704773| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.93376289| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.41769046| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.94415602| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.07320999| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.82047033| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.67145729| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.88456306| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.46426107| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.58381577| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.95930190| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.46210194| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.58002195| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.98402509| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.99557167| WEAK
rgb_lagged_sum| 26| 1000000| 200|0.90058729| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.94462086| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.76724806| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.69144938| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.66929207| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.28894366| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.27274575| PASSED
rgb_kstest_test| 0| 10000| 1000|0.98606330| PASSED
dab_bytedistrib| 0| 51200000| 1|0.31163606| PASSED
dab_dct| 256| 50000| 1|0.29595322| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.54632049| PASSED
dab_filltree| 32| 15000000| 1|0.61008716| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.43951189| PASSED
dab_filltree2| 1| 5000000| 1|0.10556475| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.99867968| WEAK
dab_monobit2| 12| 65000000| 101|0.12153278| PASSED
#
# Test duration: 134.41813858098334 minutes
#

146
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_6 Normal file
View File

@ -0,0 +1,146 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well19937c
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.36e+06 |1937046421|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.51267882| PASSED
diehard_operm5| 0| 1000000| 100|0.99052334| PASSED
diehard_rank_32x32| 0| 40000| 100|0.43110254| PASSED
diehard_rank_6x8| 0| 100000| 100|0.58244765| PASSED
diehard_bitstream| 0| 2097152| 100|0.62006555| PASSED
diehard_opso| 0| 2097152| 100|0.31077148| PASSED
diehard_oqso| 0| 2097152| 100|0.87976687| PASSED
diehard_dna| 0| 2097152| 100|0.14495226| PASSED
diehard_count_1s_str| 0| 256000| 100|0.54976486| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.43678777| PASSED
diehard_parking_lot| 0| 12000| 100|0.77995133| PASSED
diehard_2dsphere| 2| 8000| 100|0.25538371| PASSED
diehard_3dsphere| 3| 4000| 100|0.80797587| PASSED
diehard_squeeze| 0| 100000| 100|0.67499976| PASSED
diehard_sums| 0| 100| 100|0.52413111| PASSED
diehard_runs| 0| 100000| 100|0.80051199| PASSED
diehard_runs| 0| 100000| 100|0.65987492| PASSED
diehard_craps| 0| 200000| 100|0.17261905| PASSED
diehard_craps| 0| 200000| 100|0.78770120| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.93072090| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.99652021| WEAK
marsaglia_tsang_gcd| 0| 10000000| 200|0.32666708| PASSED
marsaglia_tsang_gcd| 0| 10000000| 200|0.99727340| WEAK
marsaglia_tsang_gcd| 0| 10000000| 300|0.49401547| PASSED
marsaglia_tsang_gcd| 0| 10000000| 300|0.54350483| PASSED
sts_monobit| 1| 100000| 100|0.39866950| PASSED
sts_runs| 2| 100000| 100|0.83581386| PASSED
sts_serial| 1| 100000| 100|0.31625711| PASSED
sts_serial| 2| 100000| 100|0.92545666| PASSED
sts_serial| 3| 100000| 100|0.98151795| PASSED
sts_serial| 3| 100000| 100|0.60175234| PASSED
sts_serial| 4| 100000| 100|0.80972298| PASSED
sts_serial| 4| 100000| 100|0.70233360| PASSED
sts_serial| 5| 100000| 100|0.98481379| PASSED
sts_serial| 5| 100000| 100|0.97210811| PASSED
sts_serial| 6| 100000| 100|0.65595365| PASSED
sts_serial| 6| 100000| 100|0.82899224| PASSED
sts_serial| 7| 100000| 100|0.03672567| PASSED
sts_serial| 7| 100000| 100|0.59821253| PASSED
sts_serial| 8| 100000| 100|0.53663446| PASSED
sts_serial| 8| 100000| 100|0.03086427| PASSED
sts_serial| 9| 100000| 100|0.29828922| PASSED
sts_serial| 9| 100000| 100|0.55836146| PASSED
sts_serial| 10| 100000| 100|0.81740386| PASSED
sts_serial| 10| 100000| 100|0.04205089| PASSED
sts_serial| 11| 100000| 100|0.96668011| PASSED
sts_serial| 11| 100000| 100|0.71260192| PASSED
sts_serial| 12| 100000| 100|0.78493579| PASSED
sts_serial| 12| 100000| 100|0.62422816| PASSED
sts_serial| 13| 100000| 100|0.80078069| PASSED
sts_serial| 13| 100000| 100|0.76059009| PASSED
sts_serial| 14| 100000| 100|0.96779536| PASSED
sts_serial| 14| 100000| 100|0.56582383| PASSED
sts_serial| 15| 100000| 100|0.90362059| PASSED
sts_serial| 15| 100000| 100|0.18441234| PASSED
sts_serial| 16| 100000| 100|0.59537281| PASSED
sts_serial| 16| 100000| 100|0.92467399| PASSED
rgb_bitdist| 1| 100000| 100|0.86852256| PASSED
rgb_bitdist| 2| 100000| 100|0.94901006| PASSED
rgb_bitdist| 3| 100000| 100|0.97129520| PASSED
rgb_bitdist| 4| 100000| 100|0.66425505| PASSED
rgb_bitdist| 5| 100000| 100|0.99550191| WEAK
rgb_bitdist| 5| 100000| 200|0.84437025| PASSED
rgb_bitdist| 6| 100000| 100|0.38268114| PASSED
rgb_bitdist| 7| 100000| 100|0.74953095| PASSED
rgb_bitdist| 8| 100000| 100|0.78092226| PASSED
rgb_bitdist| 9| 100000| 100|0.99702703| WEAK
rgb_bitdist| 9| 100000| 200|0.62351723| PASSED
rgb_bitdist| 10| 100000| 100|0.99029363| PASSED
rgb_bitdist| 11| 100000| 100|0.46760973| PASSED
rgb_bitdist| 12| 100000| 100|0.16847988| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.09009079| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.83478823| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.26704122| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.38450616| PASSED
rgb_permutations| 2| 100000| 100|0.41237823| PASSED
rgb_permutations| 3| 100000| 100|0.48576105| PASSED
rgb_permutations| 4| 100000| 100|0.98696409| PASSED
rgb_permutations| 5| 100000| 100|0.99787308| WEAK
rgb_permutations| 5| 100000| 200|0.97615275| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.91424395| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.20599549| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.46422562| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.71232253| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.57603360| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.89803200| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.45340776| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.36442274| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.49480498| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.33094142| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.47641961| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.43372374| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.98913689| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.45877548| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.83162863| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.15850218| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.12786978| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.60886089| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.72649082| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.76492612| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.53206310| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.52133317| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.05441741| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.41107746| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.99588606| WEAK
rgb_lagged_sum| 24| 1000000| 200|0.98990428| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.32617875| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.97442171| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.78299587| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.60922391| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.64487666| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.61066705| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.57863115| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.23473328| PASSED
rgb_kstest_test| 0| 10000| 1000|0.20995162| PASSED
dab_bytedistrib| 0| 51200000| 1|0.63078574| PASSED
dab_dct| 256| 50000| 1|0.42967831| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.11482983| PASSED
dab_filltree| 32| 15000000| 1|0.87492994| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.52338027| PASSED
dab_filltree2| 1| 5000000| 1|0.66207465| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.73112863| PASSED
#
# Test duration: 133.69631865308332 minutes
#

204
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_7 Normal file
View File

@ -0,0 +1,204 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well44497a
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 7.98e+06 | 928607557|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.82007001| PASSED
diehard_operm5| 0| 1000000| 100|0.99547281| WEAK
diehard_operm5| 0| 1000000| 200|0.49051121| PASSED
diehard_rank_32x32| 0| 40000| 100|0.74741099| PASSED
diehard_rank_6x8| 0| 100000| 100|0.50752156| PASSED
diehard_bitstream| 0| 2097152| 100|0.17270720| PASSED
diehard_opso| 0| 2097152| 100|0.35550779| PASSED
diehard_oqso| 0| 2097152| 100|0.49666162| PASSED
diehard_dna| 0| 2097152| 100|0.12894355| PASSED
diehard_count_1s_str| 0| 256000| 100|0.59478096| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.50883747| PASSED
diehard_parking_lot| 0| 12000| 100|0.45749625| PASSED
diehard_2dsphere| 2| 8000| 100|0.96538054| PASSED
diehard_3dsphere| 3| 4000| 100|0.02189419| PASSED
diehard_squeeze| 0| 100000| 100|0.15869088| PASSED
diehard_sums| 0| 100| 100|0.00841445| PASSED
diehard_runs| 0| 100000| 100|0.78690636| PASSED
diehard_runs| 0| 100000| 100|0.58450153| PASSED
diehard_craps| 0| 200000| 100|0.92507252| PASSED
diehard_craps| 0| 200000| 100|0.99015443| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.50464897| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.65940503| PASSED
sts_monobit| 1| 100000| 100|0.06582809| PASSED
sts_runs| 2| 100000| 100|0.85976447| PASSED
sts_serial| 1| 100000| 100|0.47108999| PASSED
sts_serial| 2| 100000| 100|0.13198569| PASSED
sts_serial| 3| 100000| 100|0.60561394| PASSED
sts_serial| 3| 100000| 100|0.81757721| PASSED
sts_serial| 4| 100000| 100|0.29426072| PASSED
sts_serial| 4| 100000| 100|0.41808668| PASSED
sts_serial| 5| 100000| 100|0.40081116| PASSED
sts_serial| 5| 100000| 100|0.81190373| PASSED
sts_serial| 6| 100000| 100|0.80462705| PASSED
sts_serial| 6| 100000| 100|0.40548752| PASSED
sts_serial| 7| 100000| 100|0.84312607| PASSED
sts_serial| 7| 100000| 100|0.48336103| PASSED
sts_serial| 8| 100000| 100|0.68109838| PASSED
sts_serial| 8| 100000| 100|0.25464021| PASSED
sts_serial| 9| 100000| 100|0.27908490| PASSED
sts_serial| 9| 100000| 100|0.82810109| PASSED
sts_serial| 10| 100000| 100|0.10706928| PASSED
sts_serial| 10| 100000| 100|0.63868801| PASSED
sts_serial| 11| 100000| 100|0.01407815| PASSED
sts_serial| 11| 100000| 100|0.09818554| PASSED
sts_serial| 12| 100000| 100|0.00202141| WEAK
sts_serial| 12| 100000| 100|0.20964323| PASSED
sts_serial| 13| 100000| 100|0.05727806| PASSED
sts_serial| 13| 100000| 100|0.90206720| PASSED
sts_serial| 14| 100000| 100|0.00055873| WEAK
sts_serial| 14| 100000| 100|0.17847817| PASSED
sts_serial| 15| 100000| 100|0.27402956| PASSED
sts_serial| 15| 100000| 100|0.91876061| PASSED
sts_serial| 16| 100000| 100|0.03777306| PASSED
sts_serial| 16| 100000| 100|0.53543350| PASSED
sts_serial| 1| 100000| 200|0.95477890| PASSED
sts_serial| 2| 100000| 200|0.82585956| PASSED
sts_serial| 3| 100000| 200|0.36670304| PASSED
sts_serial| 3| 100000| 200|0.50271837| PASSED
sts_serial| 4| 100000| 200|0.27038031| PASSED
sts_serial| 4| 100000| 200|0.76416151| PASSED
sts_serial| 5| 100000| 200|0.35949676| PASSED
sts_serial| 5| 100000| 200|0.38834493| PASSED
sts_serial| 6| 100000| 200|0.53176978| PASSED
sts_serial| 6| 100000| 200|0.58358586| PASSED
sts_serial| 7| 100000| 200|0.99807673| WEAK
sts_serial| 7| 100000| 200|0.51102811| PASSED
sts_serial| 8| 100000| 200|0.68874068| PASSED
sts_serial| 8| 100000| 200|0.77295542| PASSED
sts_serial| 9| 100000| 200|0.71284329| PASSED
sts_serial| 9| 100000| 200|0.94177147| PASSED
sts_serial| 10| 100000| 200|0.76331279| PASSED
sts_serial| 10| 100000| 200|0.70231947| PASSED
sts_serial| 11| 100000| 200|0.16660736| PASSED
sts_serial| 11| 100000| 200|0.08573089| PASSED
sts_serial| 12| 100000| 200|0.01449615| PASSED
sts_serial| 12| 100000| 200|0.10054957| PASSED
sts_serial| 13| 100000| 200|0.08148787| PASSED
sts_serial| 13| 100000| 200|0.83353394| PASSED
sts_serial| 14| 100000| 200|0.06870757| PASSED
sts_serial| 14| 100000| 200|0.91854888| PASSED
sts_serial| 15| 100000| 200|0.21648779| PASSED
sts_serial| 15| 100000| 200|0.46966659| PASSED
sts_serial| 16| 100000| 200|0.31462053| PASSED
sts_serial| 16| 100000| 200|0.97386862| PASSED
sts_serial| 1| 100000| 300|0.85116989| PASSED
sts_serial| 2| 100000| 300|0.73261351| PASSED
sts_serial| 3| 100000| 300|0.69815478| PASSED
sts_serial| 3| 100000| 300|0.55285217| PASSED
sts_serial| 4| 100000| 300|0.33081797| PASSED
sts_serial| 4| 100000| 300|0.32159624| PASSED
sts_serial| 5| 100000| 300|0.70617878| PASSED
sts_serial| 5| 100000| 300|0.35138655| PASSED
sts_serial| 6| 100000| 300|0.50667861| PASSED
sts_serial| 6| 100000| 300|0.56040238| PASSED
sts_serial| 7| 100000| 300|0.78827367| PASSED
sts_serial| 7| 100000| 300|0.97065250| PASSED
sts_serial| 8| 100000| 300|0.90041627| PASSED
sts_serial| 8| 100000| 300|0.96786351| PASSED
sts_serial| 9| 100000| 300|0.57872360| PASSED
sts_serial| 9| 100000| 300|0.46435289| PASSED
sts_serial| 10| 100000| 300|0.98584255| PASSED
sts_serial| 10| 100000| 300|0.62998604| PASSED
sts_serial| 11| 100000| 300|0.30809523| PASSED
sts_serial| 11| 100000| 300|0.10027349| PASSED
sts_serial| 12| 100000| 300|0.26167543| PASSED
sts_serial| 12| 100000| 300|0.19350487| PASSED
sts_serial| 13| 100000| 300|0.37927445| PASSED
sts_serial| 13| 100000| 300|0.71921891| PASSED
sts_serial| 14| 100000| 300|0.21398731| PASSED
sts_serial| 14| 100000| 300|0.71135804| PASSED
sts_serial| 15| 100000| 300|0.41674830| PASSED
sts_serial| 15| 100000| 300|0.36236637| PASSED
sts_serial| 16| 100000| 300|0.53289201| PASSED
sts_serial| 16| 100000| 300|0.88775973| PASSED
rgb_bitdist| 1| 100000| 100|0.94155049| PASSED
rgb_bitdist| 2| 100000| 100|0.81891646| PASSED
rgb_bitdist| 3| 100000| 100|0.23711082| PASSED
rgb_bitdist| 4| 100000| 100|0.41912970| PASSED
rgb_bitdist| 5| 100000| 100|0.98230793| PASSED
rgb_bitdist| 6| 100000| 100|0.92659444| PASSED
rgb_bitdist| 7| 100000| 100|0.11980889| PASSED
rgb_bitdist| 8| 100000| 100|0.56551597| PASSED
rgb_bitdist| 9| 100000| 100|0.24468436| PASSED
rgb_bitdist| 10| 100000| 100|0.31401751| PASSED
rgb_bitdist| 11| 100000| 100|0.49183090| PASSED
rgb_bitdist| 12| 100000| 100|0.05110940| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.87823054| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.46134883| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.29795173| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.02955673| PASSED
rgb_permutations| 2| 100000| 100|0.47685135| PASSED
rgb_permutations| 3| 100000| 100|0.99533406| WEAK
rgb_permutations| 3| 100000| 200|0.10670238| PASSED
rgb_permutations| 4| 100000| 100|0.81368843| PASSED
rgb_permutations| 5| 100000| 100|0.41329332| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.38968451| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.57090927| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.06218170| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.02280486| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.05530322| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.09877564| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.94342191| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.93161832| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.26114296| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.53096461| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.60169214| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.52231633| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.86624830| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.71442269| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.92954668| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.48566554| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.20698682| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.99437670| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.99734998| WEAK
rgb_lagged_sum| 18| 1000000| 200|0.99927818| WEAK
rgb_lagged_sum| 18| 1000000| 300|0.78851563| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.97051716| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.99907913| WEAK
rgb_lagged_sum| 20| 1000000| 200|0.80396797| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.99986353| WEAK
rgb_lagged_sum| 21| 1000000| 200|0.43133733| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.75065276| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.33548964| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.54121548| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.34269794| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.00998816| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.58548470| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.16490566| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.43192865| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.56195536| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.29028720| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.84210168| PASSED
rgb_kstest_test| 0| 10000| 1000|0.39986448| PASSED
dab_bytedistrib| 0| 51200000| 1|0.28901123| PASSED
dab_dct| 256| 50000| 1|0.33677959| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.25513156| PASSED
dab_filltree| 32| 15000000| 1|0.24437722| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.61751696| PASSED
dab_filltree2| 1| 5000000| 1|0.20017244| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.98043063| PASSED
#
# Test duration: 137.55742882765 minutes
#

201
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_8 Normal file
View File

@ -0,0 +1,201 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well44497b
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.21e+06 |2910993051|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.85063748| PASSED
diehard_operm5| 0| 1000000| 100|0.81273589| PASSED
diehard_rank_32x32| 0| 40000| 100|0.87816386| PASSED
diehard_rank_6x8| 0| 100000| 100|0.42814646| PASSED
diehard_bitstream| 0| 2097152| 100|0.04286407| PASSED
diehard_opso| 0| 2097152| 100|0.95793268| PASSED
diehard_oqso| 0| 2097152| 100|0.04253381| PASSED
diehard_dna| 0| 2097152| 100|0.26565466| PASSED
diehard_count_1s_str| 0| 256000| 100|0.99098352| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.97859584| PASSED
diehard_parking_lot| 0| 12000| 100|0.62905479| PASSED
diehard_2dsphere| 2| 8000| 100|0.11737319| PASSED
diehard_3dsphere| 3| 4000| 100|0.41186865| PASSED
diehard_squeeze| 0| 100000| 100|0.85097789| PASSED
diehard_sums| 0| 100| 100|0.00983403| PASSED
diehard_runs| 0| 100000| 100|0.85218797| PASSED
diehard_runs| 0| 100000| 100|0.63267832| PASSED
diehard_craps| 0| 200000| 100|0.09494403| PASSED
diehard_craps| 0| 200000| 100|0.16049734| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.33818020| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.70774106| PASSED
sts_monobit| 1| 100000| 100|0.55866871| PASSED
sts_runs| 2| 100000| 100|0.41167458| PASSED
sts_serial| 1| 100000| 100|0.42240442| PASSED
sts_serial| 2| 100000| 100|0.49861954| PASSED
sts_serial| 3| 100000| 100|0.69015488| PASSED
sts_serial| 3| 100000| 100|0.38179689| PASSED
sts_serial| 4| 100000| 100|0.32935287| PASSED
sts_serial| 4| 100000| 100|0.99876192| WEAK
sts_serial| 5| 100000| 100|0.76971899| PASSED
sts_serial| 5| 100000| 100|0.95269489| PASSED
sts_serial| 6| 100000| 100|0.64367474| PASSED
sts_serial| 6| 100000| 100|0.30994624| PASSED
sts_serial| 7| 100000| 100|0.59407462| PASSED
sts_serial| 7| 100000| 100|0.90373629| PASSED
sts_serial| 8| 100000| 100|0.38899304| PASSED
sts_serial| 8| 100000| 100|0.85683354| PASSED
sts_serial| 9| 100000| 100|0.04054051| PASSED
sts_serial| 9| 100000| 100|0.37007877| PASSED
sts_serial| 10| 100000| 100|0.83745337| PASSED
sts_serial| 10| 100000| 100|0.04265845| PASSED
sts_serial| 11| 100000| 100|0.95766410| PASSED
sts_serial| 11| 100000| 100|0.95252680| PASSED
sts_serial| 12| 100000| 100|0.89359367| PASSED
sts_serial| 12| 100000| 100|0.75449176| PASSED
sts_serial| 13| 100000| 100|0.93758152| PASSED
sts_serial| 13| 100000| 100|0.44311691| PASSED
sts_serial| 14| 100000| 100|0.88013990| PASSED
sts_serial| 14| 100000| 100|0.24008044| PASSED
sts_serial| 15| 100000| 100|0.66719010| PASSED
sts_serial| 15| 100000| 100|0.98859880| PASSED
sts_serial| 16| 100000| 100|0.75320744| PASSED
sts_serial| 16| 100000| 100|0.82605477| PASSED
sts_serial| 1| 100000| 200|0.70218774| PASSED
sts_serial| 2| 100000| 200|0.33264330| PASSED
sts_serial| 3| 100000| 200|0.93737717| PASSED
sts_serial| 3| 100000| 200|0.22252881| PASSED
sts_serial| 4| 100000| 200|0.29425631| PASSED
sts_serial| 4| 100000| 200|0.62150655| PASSED
sts_serial| 5| 100000| 200|0.77358704| PASSED
sts_serial| 5| 100000| 200|0.81543226| PASSED
sts_serial| 6| 100000| 200|0.42100356| PASSED
sts_serial| 6| 100000| 200|0.83357484| PASSED
sts_serial| 7| 100000| 200|0.51110264| PASSED
sts_serial| 7| 100000| 200|0.94708614| PASSED
sts_serial| 8| 100000| 200|0.10923389| PASSED
sts_serial| 8| 100000| 200|0.38931280| PASSED
sts_serial| 9| 100000| 200|0.00381027| WEAK
sts_serial| 9| 100000| 200|0.49556404| PASSED
sts_serial| 10| 100000| 200|0.67352211| PASSED
sts_serial| 10| 100000| 200|0.06990724| PASSED
sts_serial| 11| 100000| 200|0.97317017| PASSED
sts_serial| 11| 100000| 200|0.91392155| PASSED
sts_serial| 12| 100000| 200|0.31583896| PASSED
sts_serial| 12| 100000| 200|0.36224166| PASSED
sts_serial| 13| 100000| 200|0.93394881| PASSED
sts_serial| 13| 100000| 200|0.75358014| PASSED
sts_serial| 14| 100000| 200|0.04553189| PASSED
sts_serial| 14| 100000| 200|0.03960865| PASSED
sts_serial| 15| 100000| 200|0.07846780| PASSED
sts_serial| 15| 100000| 200|0.91198359| PASSED
sts_serial| 16| 100000| 200|0.07651736| PASSED
sts_serial| 16| 100000| 200|0.90458625| PASSED
sts_serial| 1| 100000| 300|0.67888783| PASSED
sts_serial| 2| 100000| 300|0.08930947| PASSED
sts_serial| 3| 100000| 300|0.57405260| PASSED
sts_serial| 3| 100000| 300|0.12699816| PASSED
sts_serial| 4| 100000| 300|0.48341426| PASSED
sts_serial| 4| 100000| 300|0.88008042| PASSED
sts_serial| 5| 100000| 300|0.83753962| PASSED
sts_serial| 5| 100000| 300|0.71883393| PASSED
sts_serial| 6| 100000| 300|0.60118311| PASSED
sts_serial| 6| 100000| 300|0.95967654| PASSED
sts_serial| 7| 100000| 300|0.34960778| PASSED
sts_serial| 7| 100000| 300|0.81568203| PASSED
sts_serial| 8| 100000| 300|0.04737059| PASSED
sts_serial| 8| 100000| 300|0.77372755| PASSED
sts_serial| 9| 100000| 300|0.10220799| PASSED
sts_serial| 9| 100000| 300|0.83617955| PASSED
sts_serial| 10| 100000| 300|0.80896354| PASSED
sts_serial| 10| 100000| 300|0.05407971| PASSED
sts_serial| 11| 100000| 300|0.81497009| PASSED
sts_serial| 11| 100000| 300|0.28593863| PASSED
sts_serial| 12| 100000| 300|0.17207211| PASSED
sts_serial| 12| 100000| 300|0.23507787| PASSED
sts_serial| 13| 100000| 300|0.54749268| PASSED
sts_serial| 13| 100000| 300|0.85545938| PASSED
sts_serial| 14| 100000| 300|0.01394194| PASSED
sts_serial| 14| 100000| 300|0.27324321| PASSED
sts_serial| 15| 100000| 300|0.00610106| PASSED
sts_serial| 15| 100000| 300|0.85419153| PASSED
sts_serial| 16| 100000| 300|0.12431227| PASSED
sts_serial| 16| 100000| 300|0.96686027| PASSED
rgb_bitdist| 1| 100000| 100|0.07811895| PASSED
rgb_bitdist| 2| 100000| 100|0.96058421| PASSED
rgb_bitdist| 3| 100000| 100|0.47663989| PASSED
rgb_bitdist| 4| 100000| 100|0.13308627| PASSED
rgb_bitdist| 5| 100000| 100|0.21738712| PASSED
rgb_bitdist| 6| 100000| 100|0.99254962| PASSED
rgb_bitdist| 7| 100000| 100|0.99904450| WEAK
rgb_bitdist| 7| 100000| 200|0.56160349| PASSED
rgb_bitdist| 8| 100000| 100|0.81772225| PASSED
rgb_bitdist| 9| 100000| 100|0.22529749| PASSED
rgb_bitdist| 10| 100000| 100|0.86439946| PASSED
rgb_bitdist| 11| 100000| 100|0.89902137| PASSED
rgb_bitdist| 12| 100000| 100|0.94699045| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.98995603| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.64762751| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.59382517| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.96436469| PASSED
rgb_permutations| 2| 100000| 100|0.26633926| PASSED
rgb_permutations| 3| 100000| 100|0.45745610| PASSED
rgb_permutations| 4| 100000| 100|0.26976054| PASSED
rgb_permutations| 5| 100000| 100|0.26228593| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.23747334| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.77237790| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.39637512| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.99700103| WEAK
rgb_lagged_sum| 3| 1000000| 200|0.50593047| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.11801391| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.58938886| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.96624158| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.05537309| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.08385241| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.90865689| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.49378572| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.90752931| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.78843768| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.45118102| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.16730631| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.43344461| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.73398837| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.90429587| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.99527076| WEAK
rgb_lagged_sum| 18| 1000000| 200|0.80510357| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.74948425| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.82568360| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.52313986| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.73570579| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.05313203| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.51517067| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.97969953| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.91039025| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.94098808| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.99265881| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.36105124| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.65170344| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.28699845| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.77234618| PASSED
rgb_kstest_test| 0| 10000| 1000|0.74177706| PASSED
dab_bytedistrib| 0| 51200000| 1|0.21989665| PASSED
dab_dct| 256| 50000| 1|0.95075593| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.72913115| PASSED
dab_filltree| 32| 15000000| 1|0.27600544| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.45765439| PASSED
dab_filltree2| 1| 5000000| 1|0.71345018| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.16245895| PASSED
#
# Test duration: 126.65715881980002 minutes
#

143
src/site/resources/txt/userguide/rng/stress/dh/run_1/dh_9 Normal file
View File

@ -0,0 +1,143 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.ISAACRandom
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 6.30e+06 |2172845642|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.20670107| PASSED
diehard_operm5| 0| 1000000| 100|0.78001700| PASSED
diehard_rank_32x32| 0| 40000| 100|0.35493394| PASSED
diehard_rank_6x8| 0| 100000| 100|0.92377787| PASSED
diehard_bitstream| 0| 2097152| 100|0.49773359| PASSED
diehard_opso| 0| 2097152| 100|0.25439379| PASSED
diehard_oqso| 0| 2097152| 100|0.53137774| PASSED
diehard_dna| 0| 2097152| 100|0.68339120| PASSED
diehard_count_1s_str| 0| 256000| 100|0.62172476| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.31383541| PASSED
diehard_parking_lot| 0| 12000| 100|0.36104913| PASSED
diehard_2dsphere| 2| 8000| 100|0.94578959| PASSED
diehard_3dsphere| 3| 4000| 100|0.93483509| PASSED
diehard_squeeze| 0| 100000| 100|0.77909624| PASSED
diehard_sums| 0| 100| 100|0.02187112| PASSED
diehard_runs| 0| 100000| 100|0.04592615| PASSED
diehard_runs| 0| 100000| 100|0.08649807| PASSED
diehard_craps| 0| 200000| 100|0.99288037| PASSED
diehard_craps| 0| 200000| 100|0.57261537| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.99707121| WEAK
marsaglia_tsang_gcd| 0| 10000000| 100|0.06992656| PASSED
marsaglia_tsang_gcd| 0| 10000000| 200|0.93772565| PASSED
marsaglia_tsang_gcd| 0| 10000000| 200|0.08229452| PASSED
sts_monobit| 1| 100000| 100|0.86135560| PASSED
sts_runs| 2| 100000| 100|0.89338196| PASSED
sts_serial| 1| 100000| 100|0.72294158| PASSED
sts_serial| 2| 100000| 100|0.56063265| PASSED
sts_serial| 3| 100000| 100|0.74160336| PASSED
sts_serial| 3| 100000| 100|0.44158164| PASSED
sts_serial| 4| 100000| 100|0.90160450| PASSED
sts_serial| 4| 100000| 100|0.59272149| PASSED
sts_serial| 5| 100000| 100|0.13190688| PASSED
sts_serial| 5| 100000| 100|0.57876824| PASSED
sts_serial| 6| 100000| 100|0.26746526| PASSED
sts_serial| 6| 100000| 100|0.20589715| PASSED
sts_serial| 7| 100000| 100|0.32117179| PASSED
sts_serial| 7| 100000| 100|0.82871234| PASSED
sts_serial| 8| 100000| 100|0.93975526| PASSED
sts_serial| 8| 100000| 100|0.96787785| PASSED
sts_serial| 9| 100000| 100|0.92844528| PASSED
sts_serial| 9| 100000| 100|0.46291505| PASSED
sts_serial| 10| 100000| 100|0.69120501| PASSED
sts_serial| 10| 100000| 100|0.87888496| PASSED
sts_serial| 11| 100000| 100|0.83927442| PASSED
sts_serial| 11| 100000| 100|0.59246076| PASSED
sts_serial| 12| 100000| 100|0.27892839| PASSED
sts_serial| 12| 100000| 100|0.01182971| PASSED
sts_serial| 13| 100000| 100|0.76906876| PASSED
sts_serial| 13| 100000| 100|0.80424172| PASSED
sts_serial| 14| 100000| 100|0.44036194| PASSED
sts_serial| 14| 100000| 100|0.17877200| PASSED
sts_serial| 15| 100000| 100|0.85848151| PASSED
sts_serial| 15| 100000| 100|0.90726316| PASSED
sts_serial| 16| 100000| 100|0.98994663| PASSED
sts_serial| 16| 100000| 100|0.92925223| PASSED
rgb_bitdist| 1| 100000| 100|0.90044701| PASSED
rgb_bitdist| 2| 100000| 100|0.46248158| PASSED
rgb_bitdist| 3| 100000| 100|0.93285651| PASSED
rgb_bitdist| 4| 100000| 100|0.89291881| PASSED
rgb_bitdist| 5| 100000| 100|0.88046327| PASSED
rgb_bitdist| 6| 100000| 100|0.62040673| PASSED
rgb_bitdist| 7| 100000| 100|0.98007235| PASSED
rgb_bitdist| 8| 100000| 100|0.95048032| PASSED
rgb_bitdist| 9| 100000| 100|0.78019518| PASSED
rgb_bitdist| 10| 100000| 100|0.28539233| PASSED
rgb_bitdist| 11| 100000| 100|0.18588791| PASSED
rgb_bitdist| 12| 100000| 100|0.17947094| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.11148307| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.33939380| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.04620613| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.99983314| WEAK
rgb_minimum_distance| 5| 10000| 1100|0.99765656| WEAK
rgb_minimum_distance| 5| 10000| 1200|0.93470420| PASSED
rgb_permutations| 2| 100000| 100|0.43793294| PASSED
rgb_permutations| 3| 100000| 100|0.94647548| PASSED
rgb_permutations| 4| 100000| 100|0.06571911| PASSED
rgb_permutations| 5| 100000| 100|0.78592139| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.76126990| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.82970137| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.28570727| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.42851728| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.53024569| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.87601460| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.04867236| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.11738690| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.64898192| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.64493123| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.47007712| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.86883990| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.96496572| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.63170559| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.10372391| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.51228021| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.80271064| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.76104849| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.50381960| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.47853096| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.41436075| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.09040258| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.57530915| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.99327254| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.89376099| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.74113432| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.38035803| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.19664273| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.65211304| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.08659366| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.07771201| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.73285927| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.99996862| WEAK
rgb_lagged_sum| 32| 1000000| 200|0.53857461| PASSED
rgb_kstest_test| 0| 10000| 1000|0.48268826| PASSED
dab_bytedistrib| 0| 51200000| 1|0.14566213| PASSED
dab_dct| 256| 50000| 1|0.72666906| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.13946531| PASSED
dab_filltree| 32| 15000000| 1|0.91373961| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.95156252| PASSED
dab_filltree2| 1| 5000000| 1|0.69433445| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.90451670| PASSED
#
# Test duration: 126.64687635416666 minutes
#

146
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_1 Normal file
View File

@ -0,0 +1,146 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.JDKRandom
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.26e+06 |2112158018|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.39551175| PASSED
diehard_operm5| 0| 1000000| 100|0.01638871| PASSED
diehard_rank_32x32| 0| 40000| 100|0.78049209| PASSED
diehard_rank_6x8| 0| 100000| 100|0.34865144| PASSED
diehard_bitstream| 0| 2097152| 100|0.52307003| PASSED
diehard_opso| 0| 2097152| 100|0.18051558| PASSED
diehard_oqso| 0| 2097152| 100|0.00000000| FAILED
diehard_dna| 0| 2097152| 100|0.00000000| FAILED
diehard_count_1s_str| 0| 256000| 100|0.61503829| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.50896368| PASSED
diehard_parking_lot| 0| 12000| 100|0.91507220| PASSED
diehard_2dsphere| 2| 8000| 100|0.01185796| PASSED
diehard_3dsphere| 3| 4000| 100|0.46183478| PASSED
diehard_squeeze| 0| 100000| 100|0.73634198| PASSED
diehard_sums| 0| 100| 100|0.28173715| PASSED
diehard_runs| 0| 100000| 100|0.16963573| PASSED
diehard_runs| 0| 100000| 100|0.79914087| PASSED
diehard_craps| 0| 200000| 100|0.00624281| PASSED
diehard_craps| 0| 200000| 100|0.00984013| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.77215769| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.38272860| PASSED
sts_monobit| 1| 100000| 100|0.08921400| PASSED
sts_runs| 2| 100000| 100|0.89059755| PASSED
sts_serial| 1| 100000| 100|0.72380148| PASSED
sts_serial| 2| 100000| 100|0.92622647| PASSED
sts_serial| 3| 100000| 100|0.01922055| PASSED
sts_serial| 3| 100000| 100|0.24748347| PASSED
sts_serial| 4| 100000| 100|0.20938540| PASSED
sts_serial| 4| 100000| 100|0.97499289| PASSED
sts_serial| 5| 100000| 100|0.21258357| PASSED
sts_serial| 5| 100000| 100|0.84160381| PASSED
sts_serial| 6| 100000| 100|0.14074346| PASSED
sts_serial| 6| 100000| 100|0.71820628| PASSED
sts_serial| 7| 100000| 100|0.48148409| PASSED
sts_serial| 7| 100000| 100|0.91477979| PASSED
sts_serial| 8| 100000| 100|0.97405700| PASSED
sts_serial| 8| 100000| 100|0.96765038| PASSED
sts_serial| 9| 100000| 100|0.85433874| PASSED
sts_serial| 9| 100000| 100|0.96817705| PASSED
sts_serial| 10| 100000| 100|0.98018984| PASSED
sts_serial| 10| 100000| 100|0.81314848| PASSED
sts_serial| 11| 100000| 100|0.97118546| PASSED
sts_serial| 11| 100000| 100|0.71497230| PASSED
sts_serial| 12| 100000| 100|0.74387481| PASSED
sts_serial| 12| 100000| 100|0.92198078| PASSED
sts_serial| 13| 100000| 100|0.72773474| PASSED
sts_serial| 13| 100000| 100|0.35936114| PASSED
sts_serial| 14| 100000| 100|0.97405149| PASSED
sts_serial| 14| 100000| 100|0.23387605| PASSED
sts_serial| 15| 100000| 100|0.85995233| PASSED
sts_serial| 15| 100000| 100|0.36625336| PASSED
sts_serial| 16| 100000| 100|0.94326461| PASSED
sts_serial| 16| 100000| 100|0.62443342| PASSED
rgb_bitdist| 1| 100000| 100|0.20619215| PASSED
rgb_bitdist| 2| 100000| 100|0.72263974| PASSED
rgb_bitdist| 3| 100000| 100|0.60159278| PASSED
rgb_bitdist| 4| 100000| 100|0.49577750| PASSED
rgb_bitdist| 5| 100000| 100|0.27600807| PASSED
rgb_bitdist| 6| 100000| 100|0.91404718| PASSED
rgb_bitdist| 7| 100000| 100|0.48671626| PASSED
rgb_bitdist| 8| 100000| 100|0.83192803| PASSED
rgb_bitdist| 9| 100000| 100|0.55592104| PASSED
rgb_bitdist| 10| 100000| 100|0.43915356| PASSED
rgb_bitdist| 11| 100000| 100|0.20397356| PASSED
rgb_bitdist| 12| 100000| 100|0.09113635| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.27607082| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.00000001| FAILED
rgb_minimum_distance| 4| 10000| 1000|0.00000000| FAILED
rgb_minimum_distance| 5| 10000| 1000|0.00000000| FAILED
rgb_permutations| 2| 100000| 100|0.98902753| PASSED
rgb_permutations| 3| 100000| 100|0.64029886| PASSED
rgb_permutations| 4| 100000| 100|0.03482400| PASSED
rgb_permutations| 5| 100000| 100|0.17978988| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.40238149| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.35754973| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.94014887| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.00011083| WEAK
rgb_lagged_sum| 3| 1000000| 200|0.00000003| FAILED
rgb_lagged_sum| 4| 1000000| 100|0.38873599| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.73749013| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.79623901| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.00000536| WEAK
rgb_lagged_sum| 7| 1000000| 200|0.00000000| FAILED
rgb_lagged_sum| 8| 1000000| 100|0.68228881| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.93800352| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.99168634| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.35169487| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.53996422| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.00540083| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.99625042| WEAK
rgb_lagged_sum| 14| 1000000| 200|0.99609054| WEAK
rgb_lagged_sum| 14| 1000000| 300|0.77485138| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.00009127| WEAK
rgb_lagged_sum| 15| 1000000| 200|0.00000000| FAILED
rgb_lagged_sum| 16| 1000000| 100|0.99889543| WEAK
rgb_lagged_sum| 16| 1000000| 200|0.81971042| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.03302253| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.81600518| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.27907363| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.54051536| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.97145774| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.54137492| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.09777112| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.30051939| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.55496032| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.75418746| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.05940748| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.16745497| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.15184415| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.87682520| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.31666592| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.95714405| PASSED
rgb_kstest_test| 0| 10000| 1000|0.89905458| PASSED
dab_bytedistrib| 0| 51200000| 1|1.00000000| FAILED
dab_dct| 256| 50000| 1|0.19204543| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.00006893| WEAK
dab_filltree| 32| 15000000| 1|0.00014568| WEAK
dab_filltree| 32| 15000000| 101|0.00000000| FAILED
dab_filltree| 32| 15000000| 101|0.00000000| FAILED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.82737453| PASSED
dab_filltree2| 1| 5000000| 1|0.33898398| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.80932347| PASSED
#
# Test duration: 200.7653692116667 minutes
#

172
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_10 Normal file
View File

@ -0,0 +1,172 @@
#
# RNG: org.apache.commons.math4.rng.internal.source64.MersenneTwister64
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.43e+06 | 65196341|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.77393593| PASSED
diehard_operm5| 0| 1000000| 100|0.17506318| PASSED
diehard_rank_32x32| 0| 40000| 100|0.95522455| PASSED
diehard_rank_6x8| 0| 100000| 100|0.53205969| PASSED
diehard_bitstream| 0| 2097152| 100|0.23688694| PASSED
diehard_opso| 0| 2097152| 100|0.73918395| PASSED
diehard_oqso| 0| 2097152| 100|0.31135650| PASSED
diehard_dna| 0| 2097152| 100|0.44805445| PASSED
diehard_count_1s_str| 0| 256000| 100|0.01849881| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.67854943| PASSED
diehard_parking_lot| 0| 12000| 100|0.83699181| PASSED
diehard_2dsphere| 2| 8000| 100|0.82267572| PASSED
diehard_3dsphere| 3| 4000| 100|0.91560437| PASSED
diehard_squeeze| 0| 100000| 100|0.02920041| PASSED
diehard_sums| 0| 100| 100|0.40395437| PASSED
diehard_runs| 0| 100000| 100|0.81213684| PASSED
diehard_runs| 0| 100000| 100|0.71356831| PASSED
diehard_craps| 0| 200000| 100|0.14777897| PASSED
diehard_craps| 0| 200000| 100|0.23480249| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.28319249| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.46725297| PASSED
sts_monobit| 1| 100000| 100|0.90843962| PASSED
sts_runs| 2| 100000| 100|0.99601137| WEAK
sts_runs| 2| 100000| 200|0.85241048| PASSED
sts_serial| 1| 100000| 100|0.57903662| PASSED
sts_serial| 2| 100000| 100|0.92277059| PASSED
sts_serial| 3| 100000| 100|0.85558613| PASSED
sts_serial| 3| 100000| 100|0.82689250| PASSED
sts_serial| 4| 100000| 100|0.21146680| PASSED
sts_serial| 4| 100000| 100|0.87093728| PASSED
sts_serial| 5| 100000| 100|0.54737605| PASSED
sts_serial| 5| 100000| 100|0.89422059| PASSED
sts_serial| 6| 100000| 100|0.98154808| PASSED
sts_serial| 6| 100000| 100|0.65700573| PASSED
sts_serial| 7| 100000| 100|0.43081117| PASSED
sts_serial| 7| 100000| 100|0.34762085| PASSED
sts_serial| 8| 100000| 100|0.46617263| PASSED
sts_serial| 8| 100000| 100|0.64056917| PASSED
sts_serial| 9| 100000| 100|0.95246172| PASSED
sts_serial| 9| 100000| 100|0.45537826| PASSED
sts_serial| 10| 100000| 100|0.49564166| PASSED
sts_serial| 10| 100000| 100|0.18647826| PASSED
sts_serial| 11| 100000| 100|0.88334832| PASSED
sts_serial| 11| 100000| 100|0.99729981| WEAK
sts_serial| 12| 100000| 100|0.04487347| PASSED
sts_serial| 12| 100000| 100|0.07061114| PASSED
sts_serial| 13| 100000| 100|0.54891810| PASSED
sts_serial| 13| 100000| 100|0.68499137| PASSED
sts_serial| 14| 100000| 100|0.16635928| PASSED
sts_serial| 14| 100000| 100|0.71003648| PASSED
sts_serial| 15| 100000| 100|0.08063234| PASSED
sts_serial| 15| 100000| 100|0.97293993| PASSED
sts_serial| 16| 100000| 100|0.40370620| PASSED
sts_serial| 16| 100000| 100|0.74985908| PASSED
sts_serial| 1| 100000| 200|0.78709899| PASSED
sts_serial| 2| 100000| 200|0.62803292| PASSED
sts_serial| 3| 100000| 200|0.30933408| PASSED
sts_serial| 3| 100000| 200|0.11787851| PASSED
sts_serial| 4| 100000| 200|0.21135855| PASSED
sts_serial| 4| 100000| 200|0.37638290| PASSED
sts_serial| 5| 100000| 200|0.54237676| PASSED
sts_serial| 5| 100000| 200|0.71371444| PASSED
sts_serial| 6| 100000| 200|0.73921505| PASSED
sts_serial| 6| 100000| 200|0.52316682| PASSED
sts_serial| 7| 100000| 200|0.75112761| PASSED
sts_serial| 7| 100000| 200|0.72005591| PASSED
sts_serial| 8| 100000| 200|0.90205200| PASSED
sts_serial| 8| 100000| 200|0.54622671| PASSED
sts_serial| 9| 100000| 200|0.93761558| PASSED
sts_serial| 9| 100000| 200|0.92367380| PASSED
sts_serial| 10| 100000| 200|0.54833953| PASSED
sts_serial| 10| 100000| 200|0.15454070| PASSED
sts_serial| 11| 100000| 200|0.88714505| PASSED
sts_serial| 11| 100000| 200|0.79952825| PASSED
sts_serial| 12| 100000| 200|0.22935506| PASSED
sts_serial| 12| 100000| 200|0.81065185| PASSED
sts_serial| 13| 100000| 200|0.91718096| PASSED
sts_serial| 13| 100000| 200|0.66107482| PASSED
sts_serial| 14| 100000| 200|0.89397341| PASSED
sts_serial| 14| 100000| 200|0.78689572| PASSED
sts_serial| 15| 100000| 200|0.29907934| PASSED
sts_serial| 15| 100000| 200|0.99258192| PASSED
sts_serial| 16| 100000| 200|0.88212572| PASSED
sts_serial| 16| 100000| 200|0.44320798| PASSED
rgb_bitdist| 1| 100000| 100|0.48756819| PASSED
rgb_bitdist| 2| 100000| 100|0.16781758| PASSED
rgb_bitdist| 3| 100000| 100|0.01326397| PASSED
rgb_bitdist| 4| 100000| 100|0.29941916| PASSED
rgb_bitdist| 5| 100000| 100|0.07399842| PASSED
rgb_bitdist| 6| 100000| 100|0.64459014| PASSED
rgb_bitdist| 7| 100000| 100|0.07093541| PASSED
rgb_bitdist| 8| 100000| 100|0.85720209| PASSED
rgb_bitdist| 9| 100000| 100|0.77552102| PASSED
rgb_bitdist| 10| 100000| 100|0.88525749| PASSED
rgb_bitdist| 11| 100000| 100|0.99857719| WEAK
rgb_bitdist| 11| 100000| 200|0.57762074| PASSED
rgb_bitdist| 12| 100000| 100|0.65870675| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.99641563| WEAK
rgb_minimum_distance| 2| 10000| 1100|0.96129992| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.10831138| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.48424754| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.74105213| PASSED
rgb_permutations| 2| 100000| 100|0.27138425| PASSED
rgb_permutations| 3| 100000| 100|0.99123993| PASSED
rgb_permutations| 4| 100000| 100|0.76223624| PASSED
rgb_permutations| 5| 100000| 100|0.96472560| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.55325789| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.37582970| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.95796737| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.91519934| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.34774506| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.13192176| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.73793948| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.46275363| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.26947437| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.94336080| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.81907638| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.63532196| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.91816728| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.48472825| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.18849714| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.99543588| WEAK
rgb_lagged_sum| 15| 1000000| 200|0.98140516| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.72146672| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.25663529| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.49601297| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.16977272| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.80457283| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.18842898| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.48211543| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.08829944| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.20373754| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.60300923| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.35125415| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.54331550| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.32180759| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.86980491| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.18116049| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.14811981| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.57453124| PASSED
rgb_kstest_test| 0| 10000| 1000|0.90603371| PASSED
dab_bytedistrib| 0| 51200000| 1|0.04174385| PASSED
dab_dct| 256| 50000| 1|0.69965085| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.51316451| PASSED
dab_filltree| 32| 15000000| 1|0.70016839| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.74454854| PASSED
dab_filltree2| 1| 5000000| 1|0.07070269| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.30658733| PASSED
#
# Test duration: 149.76614831083333 minutes
#

259
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_11 Normal file
View File

@ -0,0 +1,259 @@
#
# RNG: org.apache.commons.math4.rng.internal.source64.SplitMix64
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 1.21e+07 | 819939227|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.65130319| PASSED
diehard_operm5| 0| 1000000| 100|0.42848657| PASSED
diehard_rank_32x32| 0| 40000| 100|0.99197105| PASSED
diehard_rank_6x8| 0| 100000| 100|0.93624281| PASSED
diehard_bitstream| 0| 2097152| 100|0.67567225| PASSED
diehard_opso| 0| 2097152| 100|0.18053904| PASSED
diehard_oqso| 0| 2097152| 100|0.93998513| PASSED
diehard_dna| 0| 2097152| 100|0.85381608| PASSED
diehard_count_1s_str| 0| 256000| 100|0.07879285| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.51257809| PASSED
diehard_parking_lot| 0| 12000| 100|0.82824986| PASSED
diehard_2dsphere| 2| 8000| 100|0.86277034| PASSED
diehard_3dsphere| 3| 4000| 100|0.96747895| PASSED
diehard_squeeze| 0| 100000| 100|0.04392786| PASSED
diehard_sums| 0| 100| 100|0.08986396| PASSED
diehard_runs| 0| 100000| 100|0.65830365| PASSED
diehard_runs| 0| 100000| 100|0.95113109| PASSED
diehard_craps| 0| 200000| 100|0.73510806| PASSED
diehard_craps| 0| 200000| 100|0.74377626| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.19429933| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.21689040| PASSED
sts_monobit| 1| 100000| 100|0.66954403| PASSED
sts_runs| 2| 100000| 100|0.39085737| PASSED
sts_serial| 1| 100000| 100|0.38379903| PASSED
sts_serial| 2| 100000| 100|0.26568121| PASSED
sts_serial| 3| 100000| 100|0.50785557| PASSED
sts_serial| 3| 100000| 100|0.58023393| PASSED
sts_serial| 4| 100000| 100|0.54233628| PASSED
sts_serial| 4| 100000| 100|0.84921829| PASSED
sts_serial| 5| 100000| 100|0.95073679| PASSED
sts_serial| 5| 100000| 100|0.88545369| PASSED
sts_serial| 6| 100000| 100|0.95073539| PASSED
sts_serial| 6| 100000| 100|0.14384287| PASSED
sts_serial| 7| 100000| 100|0.42463259| PASSED
sts_serial| 7| 100000| 100|0.69419843| PASSED
sts_serial| 8| 100000| 100|0.24220688| PASSED
sts_serial| 8| 100000| 100|0.75347138| PASSED
sts_serial| 9| 100000| 100|0.12717188| PASSED
sts_serial| 9| 100000| 100|0.68064930| PASSED
sts_serial| 10| 100000| 100|0.02148683| PASSED
sts_serial| 10| 100000| 100|0.10301291| PASSED
sts_serial| 11| 100000| 100|0.30103069| PASSED
sts_serial| 11| 100000| 100|0.41385219| PASSED
sts_serial| 12| 100000| 100|0.13643935| PASSED
sts_serial| 12| 100000| 100|0.83847274| PASSED
sts_serial| 13| 100000| 100|0.92166105| PASSED
sts_serial| 13| 100000| 100|0.99950128| WEAK
sts_serial| 14| 100000| 100|0.12574218| PASSED
sts_serial| 14| 100000| 100|0.29623219| PASSED
sts_serial| 15| 100000| 100|0.96613665| PASSED
sts_serial| 15| 100000| 100|0.64378973| PASSED
sts_serial| 16| 100000| 100|0.71854774| PASSED
sts_serial| 16| 100000| 100|0.44482901| PASSED
sts_serial| 1| 100000| 200|0.67504828| PASSED
sts_serial| 2| 100000| 200|0.50964247| PASSED
sts_serial| 3| 100000| 200|0.66875166| PASSED
sts_serial| 3| 100000| 200|0.84146775| PASSED
sts_serial| 4| 100000| 200|0.49968330| PASSED
sts_serial| 4| 100000| 200|0.25629735| PASSED
sts_serial| 5| 100000| 200|0.41389110| PASSED
sts_serial| 5| 100000| 200|0.94237091| PASSED
sts_serial| 6| 100000| 200|0.68311036| PASSED
sts_serial| 6| 100000| 200|0.19749474| PASSED
sts_serial| 7| 100000| 200|0.79210326| PASSED
sts_serial| 7| 100000| 200|0.97196134| PASSED
sts_serial| 8| 100000| 200|0.92286499| PASSED
sts_serial| 8| 100000| 200|0.88672932| PASSED
sts_serial| 9| 100000| 200|0.56033577| PASSED
sts_serial| 9| 100000| 200|0.75729568| PASSED
sts_serial| 10| 100000| 200|0.28711716| PASSED
sts_serial| 10| 100000| 200|0.17368631| PASSED
sts_serial| 11| 100000| 200|0.96770656| PASSED
sts_serial| 11| 100000| 200|0.34341952| PASSED
sts_serial| 12| 100000| 200|0.99687982| WEAK
sts_serial| 12| 100000| 200|0.67554006| PASSED
sts_serial| 13| 100000| 200|0.90892531| PASSED
sts_serial| 13| 100000| 200|0.98458137| PASSED
sts_serial| 14| 100000| 200|0.94620601| PASSED
sts_serial| 14| 100000| 200|0.80422641| PASSED
sts_serial| 15| 100000| 200|0.37569225| PASSED
sts_serial| 15| 100000| 200|0.54794692| PASSED
sts_serial| 16| 100000| 200|0.24098810| PASSED
sts_serial| 16| 100000| 200|0.30436068| PASSED
sts_serial| 1| 100000| 300|0.97204404| PASSED
sts_serial| 2| 100000| 300|0.88073743| PASSED
sts_serial| 3| 100000| 300|0.80544082| PASSED
sts_serial| 3| 100000| 300|0.85649486| PASSED
sts_serial| 4| 100000| 300|0.56286566| PASSED
sts_serial| 4| 100000| 300|0.51864908| PASSED
sts_serial| 5| 100000| 300|0.25653791| PASSED
sts_serial| 5| 100000| 300|0.81389220| PASSED
sts_serial| 6| 100000| 300|0.99633932| WEAK
sts_serial| 6| 100000| 300|0.16601696| PASSED
sts_serial| 7| 100000| 300|0.61561137| PASSED
sts_serial| 7| 100000| 300|0.97066641| PASSED
sts_serial| 8| 100000| 300|0.77309095| PASSED
sts_serial| 8| 100000| 300|0.65502534| PASSED
sts_serial| 9| 100000| 300|0.93053708| PASSED
sts_serial| 9| 100000| 300|0.62463182| PASSED
sts_serial| 10| 100000| 300|0.54734419| PASSED
sts_serial| 10| 100000| 300|0.50740403| PASSED
sts_serial| 11| 100000| 300|0.87249357| PASSED
sts_serial| 11| 100000| 300|0.58996589| PASSED
sts_serial| 12| 100000| 300|0.96602452| PASSED
sts_serial| 12| 100000| 300|0.72674687| PASSED
sts_serial| 13| 100000| 300|0.54751109| PASSED
sts_serial| 13| 100000| 300|0.93759680| PASSED
sts_serial| 14| 100000| 300|0.89220444| PASSED
sts_serial| 14| 100000| 300|0.96051387| PASSED
sts_serial| 15| 100000| 300|0.68690283| PASSED
sts_serial| 15| 100000| 300|0.76934858| PASSED
sts_serial| 16| 100000| 300|0.45354506| PASSED
sts_serial| 16| 100000| 300|0.97960069| PASSED
sts_serial| 1| 100000| 400|0.94091702| PASSED
sts_serial| 2| 100000| 400|0.27638744| PASSED
sts_serial| 3| 100000| 400|0.92986482| PASSED
sts_serial| 3| 100000| 400|0.80878797| PASSED
sts_serial| 4| 100000| 400|0.68588392| PASSED
sts_serial| 4| 100000| 400|0.48513545| PASSED
sts_serial| 5| 100000| 400|0.73714455| PASSED
sts_serial| 5| 100000| 400|0.47861256| PASSED
sts_serial| 6| 100000| 400|0.91481150| PASSED
sts_serial| 6| 100000| 400|0.11535560| PASSED
sts_serial| 7| 100000| 400|0.86349621| PASSED
sts_serial| 7| 100000| 400|0.92029293| PASSED
sts_serial| 8| 100000| 400|0.86653286| PASSED
sts_serial| 8| 100000| 400|0.71278050| PASSED
sts_serial| 9| 100000| 400|0.71347996| PASSED
sts_serial| 9| 100000| 400|0.44657478| PASSED
sts_serial| 10| 100000| 400|0.37015976| PASSED
sts_serial| 10| 100000| 400|0.76038237| PASSED
sts_serial| 11| 100000| 400|0.99684176| WEAK
sts_serial| 11| 100000| 400|0.81430850| PASSED
sts_serial| 12| 100000| 400|0.90328065| PASSED
sts_serial| 12| 100000| 400|0.80247381| PASSED
sts_serial| 13| 100000| 400|0.59656608| PASSED
sts_serial| 13| 100000| 400|0.90689206| PASSED
sts_serial| 14| 100000| 400|0.84603980| PASSED
sts_serial| 14| 100000| 400|0.90430810| PASSED
sts_serial| 15| 100000| 400|0.39247079| PASSED
sts_serial| 15| 100000| 400|0.41296654| PASSED
sts_serial| 16| 100000| 400|0.18169630| PASSED
sts_serial| 16| 100000| 400|0.41683888| PASSED
sts_serial| 1| 100000| 500|0.69320651| PASSED
sts_serial| 2| 100000| 500|0.10917949| PASSED
sts_serial| 3| 100000| 500|0.56299477| PASSED
sts_serial| 3| 100000| 500|0.31094316| PASSED
sts_serial| 4| 100000| 500|0.33317132| PASSED
sts_serial| 4| 100000| 500|0.65841777| PASSED
sts_serial| 5| 100000| 500|0.30829427| PASSED
sts_serial| 5| 100000| 500|0.60157652| PASSED
sts_serial| 6| 100000| 500|0.88025153| PASSED
sts_serial| 6| 100000| 500|0.04660464| PASSED
sts_serial| 7| 100000| 500|0.96944836| PASSED
sts_serial| 7| 100000| 500|0.97102302| PASSED
sts_serial| 8| 100000| 500|0.89481786| PASSED
sts_serial| 8| 100000| 500|0.78816533| PASSED
sts_serial| 9| 100000| 500|0.33904423| PASSED
sts_serial| 9| 100000| 500|0.32592935| PASSED
sts_serial| 10| 100000| 500|0.28013100| PASSED
sts_serial| 10| 100000| 500|0.76769840| PASSED
sts_serial| 11| 100000| 500|0.99066696| PASSED
sts_serial| 11| 100000| 500|0.81779354| PASSED
sts_serial| 12| 100000| 500|0.87172641| PASSED
sts_serial| 12| 100000| 500|0.46324166| PASSED
sts_serial| 13| 100000| 500|0.98324252| PASSED
sts_serial| 13| 100000| 500|0.99472778| PASSED
sts_serial| 14| 100000| 500|0.53993180| PASSED
sts_serial| 14| 100000| 500|0.46009474| PASSED
sts_serial| 15| 100000| 500|0.97975293| PASSED
sts_serial| 15| 100000| 500|0.87764916| PASSED
sts_serial| 16| 100000| 500|0.79198726| PASSED
sts_serial| 16| 100000| 500|0.21613635| PASSED
rgb_bitdist| 1| 100000| 100|0.68120105| PASSED
rgb_bitdist| 2| 100000| 100|0.90639560| PASSED
rgb_bitdist| 3| 100000| 100|0.94656851| PASSED
rgb_bitdist| 4| 100000| 100|0.12251952| PASSED
rgb_bitdist| 5| 100000| 100|0.61456409| PASSED
rgb_bitdist| 6| 100000| 100|0.52350159| PASSED
rgb_bitdist| 7| 100000| 100|0.87956511| PASSED
rgb_bitdist| 8| 100000| 100|0.89413760| PASSED
rgb_bitdist| 9| 100000| 100|0.28575731| PASSED
rgb_bitdist| 10| 100000| 100|0.49093734| PASSED
rgb_bitdist| 11| 100000| 100|0.26660227| PASSED
rgb_bitdist| 12| 100000| 100|0.96468479| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.33405128| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.36253717| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.54979726| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.12334255| PASSED
rgb_permutations| 2| 100000| 100|0.97168259| PASSED
rgb_permutations| 3| 100000| 100|0.83233143| PASSED
rgb_permutations| 4| 100000| 100|0.71352165| PASSED
rgb_permutations| 5| 100000| 100|0.59973194| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.49917365| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.70611235| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.59359761| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.57186179| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.30795009| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.53465999| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.31533107| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.94058815| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.90566697| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.64301348| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.32913816| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.03880868| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.95173167| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.27721428| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.81328176| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.61209416| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.33620210| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.95627576| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.02142494| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.26605904| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.97753126| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.01423671| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.14396401| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.47421297| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.51423760| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.81571899| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.99702972| WEAK
rgb_lagged_sum| 26| 1000000| 200|0.52849528| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.95999913| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.90199933| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.39451836| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.39232515| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.84792631| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.88075632| PASSED
rgb_kstest_test| 0| 10000| 1000|0.26412166| PASSED
dab_bytedistrib| 0| 51200000| 1|0.97769960| PASSED
dab_dct| 256| 50000| 1|0.24267823| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.88006729| PASSED
dab_filltree| 32| 15000000| 1|0.95082422| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.12386267| PASSED
dab_filltree2| 1| 5000000| 1|0.70985509| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.30670303| PASSED
#
# Test duration: 135.24708653241666 minutes
#

168
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_12 Normal file
View File

@ -0,0 +1,168 @@
#
# RNG: org.apache.commons.math4.rng.internal.source64.XorShift1024Star
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.67e+06 |4049234644|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.43986711| PASSED
diehard_operm5| 0| 1000000| 100|0.86075341| PASSED
diehard_rank_32x32| 0| 40000| 100|0.62133164| PASSED
diehard_rank_6x8| 0| 100000| 100|0.40501983| PASSED
diehard_bitstream| 0| 2097152| 100|0.21450471| PASSED
diehard_opso| 0| 2097152| 100|0.14529679| PASSED
diehard_oqso| 0| 2097152| 100|0.42952368| PASSED
diehard_dna| 0| 2097152| 100|0.62661288| PASSED
diehard_count_1s_str| 0| 256000| 100|0.38079796| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.91119869| PASSED
diehard_parking_lot| 0| 12000| 100|0.99280463| PASSED
diehard_2dsphere| 2| 8000| 100|0.26539580| PASSED
diehard_3dsphere| 3| 4000| 100|0.84202820| PASSED
diehard_squeeze| 0| 100000| 100|0.95952556| PASSED
diehard_sums| 0| 100| 100|0.06744412| PASSED
diehard_runs| 0| 100000| 100|0.69092881| PASSED
diehard_runs| 0| 100000| 100|0.01348188| PASSED
diehard_craps| 0| 200000| 100|0.65927335| PASSED
diehard_craps| 0| 200000| 100|0.16087370| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.83170722| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.83595386| PASSED
sts_monobit| 1| 100000| 100|0.09001001| PASSED
sts_runs| 2| 100000| 100|0.15108464| PASSED
sts_serial| 1| 100000| 100|0.09519062| PASSED
sts_serial| 2| 100000| 100|0.99529374| WEAK
sts_serial| 3| 100000| 100|0.19986415| PASSED
sts_serial| 3| 100000| 100|0.52295559| PASSED
sts_serial| 4| 100000| 100|0.98417753| PASSED
sts_serial| 4| 100000| 100|0.67069285| PASSED
sts_serial| 5| 100000| 100|0.56911975| PASSED
sts_serial| 5| 100000| 100|0.90964413| PASSED
sts_serial| 6| 100000| 100|0.95518599| PASSED
sts_serial| 6| 100000| 100|0.56937053| PASSED
sts_serial| 7| 100000| 100|0.47793310| PASSED
sts_serial| 7| 100000| 100|0.21857744| PASSED
sts_serial| 8| 100000| 100|0.28709825| PASSED
sts_serial| 8| 100000| 100|0.38737847| PASSED
sts_serial| 9| 100000| 100|0.94874889| PASSED
sts_serial| 9| 100000| 100|0.90658668| PASSED
sts_serial| 10| 100000| 100|0.83220602| PASSED
sts_serial| 10| 100000| 100|0.34854881| PASSED
sts_serial| 11| 100000| 100|0.94357460| PASSED
sts_serial| 11| 100000| 100|0.74871348| PASSED
sts_serial| 12| 100000| 100|0.62709624| PASSED
sts_serial| 12| 100000| 100|0.76152945| PASSED
sts_serial| 13| 100000| 100|0.92395096| PASSED
sts_serial| 13| 100000| 100|0.78993724| PASSED
sts_serial| 14| 100000| 100|0.37069384| PASSED
sts_serial| 14| 100000| 100|0.27746731| PASSED
sts_serial| 15| 100000| 100|0.17526422| PASSED
sts_serial| 15| 100000| 100|0.21895898| PASSED
sts_serial| 16| 100000| 100|0.05918295| PASSED
sts_serial| 16| 100000| 100|0.07329479| PASSED
sts_serial| 1| 100000| 200|0.74068880| PASSED
sts_serial| 2| 100000| 200|0.93915184| PASSED
sts_serial| 3| 100000| 200|0.06170017| PASSED
sts_serial| 3| 100000| 200|0.12790917| PASSED
sts_serial| 4| 100000| 200|0.20067613| PASSED
sts_serial| 4| 100000| 200|0.50188373| PASSED
sts_serial| 5| 100000| 200|0.32524639| PASSED
sts_serial| 5| 100000| 200|0.33585786| PASSED
sts_serial| 6| 100000| 200|0.25966230| PASSED
sts_serial| 6| 100000| 200|0.82193807| PASSED
sts_serial| 7| 100000| 200|0.54395252| PASSED
sts_serial| 7| 100000| 200|0.18979469| PASSED
sts_serial| 8| 100000| 200|0.94930808| PASSED
sts_serial| 8| 100000| 200|0.67127739| PASSED
sts_serial| 9| 100000| 200|0.60733327| PASSED
sts_serial| 9| 100000| 200|0.96994624| PASSED
sts_serial| 10| 100000| 200|0.62606979| PASSED
sts_serial| 10| 100000| 200|0.40033589| PASSED
sts_serial| 11| 100000| 200|0.80899190| PASSED
sts_serial| 11| 100000| 200|0.89986722| PASSED
sts_serial| 12| 100000| 200|0.39663416| PASSED
sts_serial| 12| 100000| 200|0.06467541| PASSED
sts_serial| 13| 100000| 200|0.21524272| PASSED
sts_serial| 13| 100000| 200|0.82559608| PASSED
sts_serial| 14| 100000| 200|0.77172495| PASSED
sts_serial| 14| 100000| 200|0.14008237| PASSED
sts_serial| 15| 100000| 200|0.98463956| PASSED
sts_serial| 15| 100000| 200|0.49808309| PASSED
sts_serial| 16| 100000| 200|0.55248697| PASSED
sts_serial| 16| 100000| 200|0.58672133| PASSED
rgb_bitdist| 1| 100000| 100|0.92225732| PASSED
rgb_bitdist| 2| 100000| 100|0.36445678| PASSED
rgb_bitdist| 3| 100000| 100|0.96225262| PASSED
rgb_bitdist| 4| 100000| 100|0.76926547| PASSED
rgb_bitdist| 5| 100000| 100|0.59270749| PASSED
rgb_bitdist| 6| 100000| 100|0.27159563| PASSED
rgb_bitdist| 7| 100000| 100|0.77094872| PASSED
rgb_bitdist| 8| 100000| 100|0.48930166| PASSED
rgb_bitdist| 9| 100000| 100|0.70790945| PASSED
rgb_bitdist| 10| 100000| 100|0.98539462| PASSED
rgb_bitdist| 11| 100000| 100|0.96861063| PASSED
rgb_bitdist| 12| 100000| 100|0.89141142| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.96790115| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.80411688| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.52446188| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.47978117| PASSED
rgb_permutations| 2| 100000| 100|0.40777196| PASSED
rgb_permutations| 3| 100000| 100|0.95076980| PASSED
rgb_permutations| 4| 100000| 100|0.08936872| PASSED
rgb_permutations| 5| 100000| 100|0.26510667| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.74705832| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.59459494| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.97178777| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.17394485| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.80415340| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.96850998| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.03325897| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.67259803| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.43739569| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.22073208| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.26353974| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.39073326| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.64778518| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.36232598| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.82578596| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.15625029| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.07173397| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.30506458| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.79791891| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.14586711| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.48057611| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.32640210| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.61535302| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.72472744| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.71146280| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.90294638| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.13115386| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.20782030| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.17832007| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.46665024| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.62685486| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.36271734| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.24656354| PASSED
rgb_kstest_test| 0| 10000| 1000|0.29974209| PASSED
dab_bytedistrib| 0| 51200000| 1|0.66226186| PASSED
dab_dct| 256| 50000| 1|0.01688589| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.30797985| PASSED
dab_filltree| 32| 15000000| 1|0.09215619| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.71199761| PASSED
dab_filltree2| 1| 5000000| 1|0.63044442| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.59958440| PASSED
#
# Test duration: 142.62414436471667 minutes
#

261
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_13 Normal file
View File

@ -0,0 +1,261 @@
#
# RNG: org.apache.commons.math4.rng.internal.source64.TwoCmres (Cmres: [0xedce446814d3b3d9L, 33, 330658535] + Cmres: [0xc5b3cf786c806df7L, 33, 331932042])
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.57e+06 |4137854788|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.41377932| PASSED
diehard_operm5| 0| 1000000| 100|0.43068389| PASSED
diehard_rank_32x32| 0| 40000| 100|0.09864020| PASSED
diehard_rank_6x8| 0| 100000| 100|0.33203502| PASSED
diehard_bitstream| 0| 2097152| 100|0.46716732| PASSED
diehard_opso| 0| 2097152| 100|0.52705769| PASSED
diehard_oqso| 0| 2097152| 100|0.61769679| PASSED
diehard_dna| 0| 2097152| 100|0.09792456| PASSED
diehard_count_1s_str| 0| 256000| 100|0.64272247| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.22613773| PASSED
diehard_parking_lot| 0| 12000| 100|0.98727196| PASSED
diehard_2dsphere| 2| 8000| 100|0.63824725| PASSED
diehard_3dsphere| 3| 4000| 100|0.32779128| PASSED
diehard_squeeze| 0| 100000| 100|0.40226180| PASSED
diehard_sums| 0| 100| 100|0.00712395| PASSED
diehard_runs| 0| 100000| 100|0.79789724| PASSED
diehard_runs| 0| 100000| 100|0.05642734| PASSED
diehard_craps| 0| 200000| 100|0.95181698| PASSED
diehard_craps| 0| 200000| 100|0.28904414| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.98520547| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.37339961| PASSED
sts_monobit| 1| 100000| 100|0.66302572| PASSED
sts_runs| 2| 100000| 100|0.97092640| PASSED
sts_serial| 1| 100000| 100|0.16638697| PASSED
sts_serial| 2| 100000| 100|0.36061922| PASSED
sts_serial| 3| 100000| 100|0.06431213| PASSED
sts_serial| 3| 100000| 100|0.26283736| PASSED
sts_serial| 4| 100000| 100|0.53979796| PASSED
sts_serial| 4| 100000| 100|0.86011045| PASSED
sts_serial| 5| 100000| 100|0.67844160| PASSED
sts_serial| 5| 100000| 100|0.73843150| PASSED
sts_serial| 6| 100000| 100|0.82803712| PASSED
sts_serial| 6| 100000| 100|0.70984129| PASSED
sts_serial| 7| 100000| 100|0.21575629| PASSED
sts_serial| 7| 100000| 100|0.22745102| PASSED
sts_serial| 8| 100000| 100|0.13213154| PASSED
sts_serial| 8| 100000| 100|0.30575979| PASSED
sts_serial| 9| 100000| 100|0.34686823| PASSED
sts_serial| 9| 100000| 100|0.36243200| PASSED
sts_serial| 10| 100000| 100|0.70363959| PASSED
sts_serial| 10| 100000| 100|0.84298185| PASSED
sts_serial| 11| 100000| 100|0.98918819| PASSED
sts_serial| 11| 100000| 100|0.95692442| PASSED
sts_serial| 12| 100000| 100|0.80698265| PASSED
sts_serial| 12| 100000| 100|0.68704909| PASSED
sts_serial| 13| 100000| 100|0.61600331| PASSED
sts_serial| 13| 100000| 100|0.25682490| PASSED
sts_serial| 14| 100000| 100|0.71221014| PASSED
sts_serial| 14| 100000| 100|0.99934597| WEAK
sts_serial| 15| 100000| 100|0.98061769| PASSED
sts_serial| 15| 100000| 100|0.55623022| PASSED
sts_serial| 16| 100000| 100|0.74324230| PASSED
sts_serial| 16| 100000| 100|0.19663505| PASSED
sts_serial| 1| 100000| 200|0.01030154| PASSED
sts_serial| 2| 100000| 200|0.28075457| PASSED
sts_serial| 3| 100000| 200|0.00620861| PASSED
sts_serial| 3| 100000| 200|0.02592878| PASSED
sts_serial| 4| 100000| 200|0.16909100| PASSED
sts_serial| 4| 100000| 200|0.82086476| PASSED
sts_serial| 5| 100000| 200|0.20192706| PASSED
sts_serial| 5| 100000| 200|0.79643142| PASSED
sts_serial| 6| 100000| 200|0.57211541| PASSED
sts_serial| 6| 100000| 200|0.53233417| PASSED
sts_serial| 7| 100000| 200|0.67540321| PASSED
sts_serial| 7| 100000| 200|0.91595629| PASSED
sts_serial| 8| 100000| 200|0.84776370| PASSED
sts_serial| 8| 100000| 200|0.48084876| PASSED
sts_serial| 9| 100000| 200|0.71105599| PASSED
sts_serial| 9| 100000| 200|0.78257380| PASSED
sts_serial| 10| 100000| 200|0.33994953| PASSED
sts_serial| 10| 100000| 200|0.16533311| PASSED
sts_serial| 11| 100000| 200|0.17915407| PASSED
sts_serial| 11| 100000| 200|0.97757438| PASSED
sts_serial| 12| 100000| 200|0.15767885| PASSED
sts_serial| 12| 100000| 200|0.70660237| PASSED
sts_serial| 13| 100000| 200|0.04894857| PASSED
sts_serial| 13| 100000| 200|0.26161827| PASSED
sts_serial| 14| 100000| 200|0.03320222| PASSED
sts_serial| 14| 100000| 200|0.33848541| PASSED
sts_serial| 15| 100000| 200|0.00478397| WEAK
sts_serial| 15| 100000| 200|0.89452421| PASSED
sts_serial| 16| 100000| 200|0.01756813| PASSED
sts_serial| 16| 100000| 200|0.19931613| PASSED
sts_serial| 1| 100000| 300|0.00205544| WEAK
sts_serial| 2| 100000| 300|0.61937202| PASSED
sts_serial| 3| 100000| 300|0.03071851| PASSED
sts_serial| 3| 100000| 300|0.03032828| PASSED
sts_serial| 4| 100000| 300|0.08984246| PASSED
sts_serial| 4| 100000| 300|0.69920341| PASSED
sts_serial| 5| 100000| 300|0.32288784| PASSED
sts_serial| 5| 100000| 300|0.41056062| PASSED
sts_serial| 6| 100000| 300|0.44916924| PASSED
sts_serial| 6| 100000| 300|0.16270803| PASSED
sts_serial| 7| 100000| 300|0.78587871| PASSED
sts_serial| 7| 100000| 300|0.73347325| PASSED
sts_serial| 8| 100000| 300|0.98347896| PASSED
sts_serial| 8| 100000| 300|0.36027085| PASSED
sts_serial| 9| 100000| 300|0.58191302| PASSED
sts_serial| 9| 100000| 300|0.96187028| PASSED
sts_serial| 10| 100000| 300|0.78912775| PASSED
sts_serial| 10| 100000| 300|0.33754471| PASSED
sts_serial| 11| 100000| 300|0.07653014| PASSED
sts_serial| 11| 100000| 300|0.43036478| PASSED
sts_serial| 12| 100000| 300|0.10557524| PASSED
sts_serial| 12| 100000| 300|0.63105000| PASSED
sts_serial| 13| 100000| 300|0.14206597| PASSED
sts_serial| 13| 100000| 300|0.54619202| PASSED
sts_serial| 14| 100000| 300|0.09345313| PASSED
sts_serial| 14| 100000| 300|0.52252062| PASSED
sts_serial| 15| 100000| 300|0.01806564| PASSED
sts_serial| 15| 100000| 300|0.97807773| PASSED
sts_serial| 16| 100000| 300|0.03263752| PASSED
sts_serial| 16| 100000| 300|0.07051090| PASSED
sts_serial| 1| 100000| 400|0.01502923| PASSED
sts_serial| 2| 100000| 400|0.13228516| PASSED
sts_serial| 3| 100000| 400|0.00360645| WEAK
sts_serial| 3| 100000| 400|0.00984887| PASSED
sts_serial| 4| 100000| 400|0.02166662| PASSED
sts_serial| 4| 100000| 400|0.53249206| PASSED
sts_serial| 5| 100000| 400|0.13757613| PASSED
sts_serial| 5| 100000| 400|0.22631392| PASSED
sts_serial| 6| 100000| 400|0.91482934| PASSED
sts_serial| 6| 100000| 400|0.09023090| PASSED
sts_serial| 7| 100000| 400|0.64054033| PASSED
sts_serial| 7| 100000| 400|0.44242911| PASSED
sts_serial| 8| 100000| 400|0.86399072| PASSED
sts_serial| 8| 100000| 400|0.14521041| PASSED
sts_serial| 9| 100000| 400|0.79289110| PASSED
sts_serial| 9| 100000| 400|0.66282885| PASSED
sts_serial| 10| 100000| 400|0.88414860| PASSED
sts_serial| 10| 100000| 400|0.58068627| PASSED
sts_serial| 11| 100000| 400|0.91275543| PASSED
sts_serial| 11| 100000| 400|0.70471939| PASSED
sts_serial| 12| 100000| 400|0.22167518| PASSED
sts_serial| 12| 100000| 400|0.68048707| PASSED
sts_serial| 13| 100000| 400|0.33805718| PASSED
sts_serial| 13| 100000| 400|0.70857165| PASSED
sts_serial| 14| 100000| 400|0.35577976| PASSED
sts_serial| 14| 100000| 400|0.96667107| PASSED
sts_serial| 15| 100000| 400|0.21076038| PASSED
sts_serial| 15| 100000| 400|0.98253218| PASSED
sts_serial| 16| 100000| 400|0.06071902| PASSED
sts_serial| 16| 100000| 400|0.08412877| PASSED
sts_serial| 1| 100000| 500|0.13834123| PASSED
sts_serial| 2| 100000| 500|0.25024803| PASSED
sts_serial| 3| 100000| 500|0.01785919| PASSED
sts_serial| 3| 100000| 500|0.03648554| PASSED
sts_serial| 4| 100000| 500|0.05924361| PASSED
sts_serial| 4| 100000| 500|0.38646230| PASSED
sts_serial| 5| 100000| 500|0.15596968| PASSED
sts_serial| 5| 100000| 500|0.50872450| PASSED
sts_serial| 6| 100000| 500|0.88291851| PASSED
sts_serial| 6| 100000| 500|0.02081203| PASSED
sts_serial| 7| 100000| 500|0.65824396| PASSED
sts_serial| 7| 100000| 500|0.55644469| PASSED
sts_serial| 8| 100000| 500|0.92441847| PASSED
sts_serial| 8| 100000| 500|0.12875775| PASSED
sts_serial| 9| 100000| 500|0.82424125| PASSED
sts_serial| 9| 100000| 500|0.64618913| PASSED
sts_serial| 10| 100000| 500|0.85661010| PASSED
sts_serial| 10| 100000| 500|0.14667206| PASSED
sts_serial| 11| 100000| 500|0.92863616| PASSED
sts_serial| 11| 100000| 500|0.95895694| PASSED
sts_serial| 12| 100000| 500|0.28474931| PASSED
sts_serial| 12| 100000| 500|0.54895548| PASSED
sts_serial| 13| 100000| 500|0.25982749| PASSED
sts_serial| 13| 100000| 500|0.46806655| PASSED
sts_serial| 14| 100000| 500|0.49922708| PASSED
sts_serial| 14| 100000| 500|0.81653416| PASSED
sts_serial| 15| 100000| 500|0.35050729| PASSED
sts_serial| 15| 100000| 500|0.96227025| PASSED
sts_serial| 16| 100000| 500|0.26401565| PASSED
sts_serial| 16| 100000| 500|0.37069644| PASSED
rgb_bitdist| 1| 100000| 100|0.92425608| PASSED
rgb_bitdist| 2| 100000| 100|0.83940461| PASSED
rgb_bitdist| 3| 100000| 100|0.84689557| PASSED
rgb_bitdist| 4| 100000| 100|0.33128106| PASSED
rgb_bitdist| 5| 100000| 100|0.12842913| PASSED
rgb_bitdist| 6| 100000| 100|0.21486534| PASSED
rgb_bitdist| 7| 100000| 100|0.90751856| PASSED
rgb_bitdist| 8| 100000| 100|0.16633581| PASSED
rgb_bitdist| 9| 100000| 100|0.31056439| PASSED
rgb_bitdist| 10| 100000| 100|0.99965960| WEAK
rgb_bitdist| 10| 100000| 200|0.91538601| PASSED
rgb_bitdist| 11| 100000| 100|0.24070042| PASSED
rgb_bitdist| 12| 100000| 100|0.49027792| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.13794213| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.72970342| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.32452086| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.46581590| PASSED
rgb_permutations| 2| 100000| 100|0.38494734| PASSED
rgb_permutations| 3| 100000| 100|0.55243592| PASSED
rgb_permutations| 4| 100000| 100|0.62705490| PASSED
rgb_permutations| 5| 100000| 100|0.78412476| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.95652731| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.97125545| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.28441088| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.10571028| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.18579692| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.77950641| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.59250046| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.02505981| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.47302995| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.98595871| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.98853717| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.61490023| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.50160482| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.12027240| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.96754010| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.21334535| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.88783046| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.99955140| WEAK
rgb_lagged_sum| 17| 1000000| 200|0.99971790| WEAK
rgb_lagged_sum| 17| 1000000| 300|0.40146641| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.41667502| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.08874978| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.90107966| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.34200440| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.37963530| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.97024129| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.27937268| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.23074718| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.77447675| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.93043715| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.69797099| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.49932176| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.15535844| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.88161991| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.79593086| PASSED
rgb_kstest_test| 0| 10000| 1000|0.19101819| PASSED
dab_bytedistrib| 0| 51200000| 1|0.42748649| PASSED
dab_dct| 256| 50000| 1|0.87136468| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.56742800| PASSED
dab_filltree| 32| 15000000| 1|0.82856739| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.26510823| PASSED
dab_filltree2| 1| 5000000| 1|0.50524832| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.67910494| PASSED
#
# Test duration: 150.40452241786667 minutes
#

140
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_2 Normal file
View File

@ -0,0 +1,140 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.MersenneTwister
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 1.15e+07 |1277800222|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.83018903| PASSED
diehard_operm5| 0| 1000000| 100|0.83633437| PASSED
diehard_rank_32x32| 0| 40000| 100|0.50851126| PASSED
diehard_rank_6x8| 0| 100000| 100|0.14990437| PASSED
diehard_bitstream| 0| 2097152| 100|0.92071822| PASSED
diehard_opso| 0| 2097152| 100|0.81766238| PASSED
diehard_oqso| 0| 2097152| 100|0.73439841| PASSED
diehard_dna| 0| 2097152| 100|0.30440003| PASSED
diehard_count_1s_str| 0| 256000| 100|0.78889002| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.65339742| PASSED
diehard_parking_lot| 0| 12000| 100|0.00043440| WEAK
diehard_parking_lot| 0| 12000| 200|0.04327588| PASSED
diehard_2dsphere| 2| 8000| 100|0.48631739| PASSED
diehard_3dsphere| 3| 4000| 100|0.95061316| PASSED
diehard_squeeze| 0| 100000| 100|0.14096759| PASSED
diehard_sums| 0| 100| 100|0.46750328| PASSED
diehard_runs| 0| 100000| 100|0.95663857| PASSED
diehard_runs| 0| 100000| 100|0.73895911| PASSED
diehard_craps| 0| 200000| 100|0.37410375| PASSED
diehard_craps| 0| 200000| 100|0.52228801| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.68805022| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.54566978| PASSED
sts_monobit| 1| 100000| 100|0.71086339| PASSED
sts_runs| 2| 100000| 100|0.27451357| PASSED
sts_serial| 1| 100000| 100|0.28377179| PASSED
sts_serial| 2| 100000| 100|0.36220838| PASSED
sts_serial| 3| 100000| 100|0.41180880| PASSED
sts_serial| 3| 100000| 100|0.75252825| PASSED
sts_serial| 4| 100000| 100|0.41476323| PASSED
sts_serial| 4| 100000| 100|0.85743608| PASSED
sts_serial| 5| 100000| 100|0.64963035| PASSED
sts_serial| 5| 100000| 100|0.82901243| PASSED
sts_serial| 6| 100000| 100|0.43147096| PASSED
sts_serial| 6| 100000| 100|0.13121044| PASSED
sts_serial| 7| 100000| 100|0.98669558| PASSED
sts_serial| 7| 100000| 100|0.92833177| PASSED
sts_serial| 8| 100000| 100|0.45968500| PASSED
sts_serial| 8| 100000| 100|0.94041262| PASSED
sts_serial| 9| 100000| 100|0.99274909| PASSED
sts_serial| 9| 100000| 100|0.71353226| PASSED
sts_serial| 10| 100000| 100|0.35758926| PASSED
sts_serial| 10| 100000| 100|0.62132348| PASSED
sts_serial| 11| 100000| 100|0.95598741| PASSED
sts_serial| 11| 100000| 100|0.35974491| PASSED
sts_serial| 12| 100000| 100|0.75156429| PASSED
sts_serial| 12| 100000| 100|0.16837932| PASSED
sts_serial| 13| 100000| 100|0.98373346| PASSED
sts_serial| 13| 100000| 100|0.94512769| PASSED
sts_serial| 14| 100000| 100|0.61157975| PASSED
sts_serial| 14| 100000| 100|0.15294120| PASSED
sts_serial| 15| 100000| 100|0.69383273| PASSED
sts_serial| 15| 100000| 100|0.49247879| PASSED
sts_serial| 16| 100000| 100|0.23449799| PASSED
sts_serial| 16| 100000| 100|0.09706383| PASSED
rgb_bitdist| 1| 100000| 100|0.76006007| PASSED
rgb_bitdist| 2| 100000| 100|0.97512548| PASSED
rgb_bitdist| 3| 100000| 100|0.99523447| WEAK
rgb_bitdist| 3| 100000| 200|0.12743870| PASSED
rgb_bitdist| 4| 100000| 100|0.22950891| PASSED
rgb_bitdist| 5| 100000| 100|0.27343882| PASSED
rgb_bitdist| 6| 100000| 100|0.83359583| PASSED
rgb_bitdist| 7| 100000| 100|0.97493515| PASSED
rgb_bitdist| 8| 100000| 100|0.72344973| PASSED
rgb_bitdist| 9| 100000| 100|0.18869202| PASSED
rgb_bitdist| 10| 100000| 100|0.64357304| PASSED
rgb_bitdist| 11| 100000| 100|0.23423637| PASSED
rgb_bitdist| 12| 100000| 100|0.46106820| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.78010679| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.69567338| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.33331609| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.59933760| PASSED
rgb_permutations| 2| 100000| 100|0.38829960| PASSED
rgb_permutations| 3| 100000| 100|0.55789991| PASSED
rgb_permutations| 4| 100000| 100|0.69001051| PASSED
rgb_permutations| 5| 100000| 100|0.62157374| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.01700889| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.29371434| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.85272567| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.57261486| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.95761395| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.33288937| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.20187862| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.39926490| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.18720819| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.88746650| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.45892693| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.01445470| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.83809167| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.31910381| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.99430621| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.14805002| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.57730846| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.20003188| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.66040701| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.91001847| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.09730677| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.28863728| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.69063750| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.56653569| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.92151039| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.07121380| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.67797694| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.78638953| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.50998415| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.34697518| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.71245062| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.70362965| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.96068361| PASSED
rgb_kstest_test| 0| 10000| 1000|0.05987099| PASSED
dab_bytedistrib| 0| 51200000| 1|0.92951828| PASSED
dab_dct| 256| 50000| 1|0.86323735| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.03464038| PASSED
dab_filltree| 32| 15000000| 1|0.76944755| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.25825632| PASSED
dab_filltree2| 1| 5000000| 1|0.67560717| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.20729674| PASSED
#
# Test duration: 143.5374114685 minutes
#

139
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_3 Normal file
View File

@ -0,0 +1,139 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well512a
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.35e+06 |3039926621|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.65925723| PASSED
diehard_operm5| 0| 1000000| 100|0.24838406| PASSED
diehard_rank_32x32| 0| 40000| 100|0.89217314| PASSED
diehard_rank_6x8| 0| 100000| 100|0.22808738| PASSED
diehard_bitstream| 0| 2097152| 100|0.12742827| PASSED
diehard_opso| 0| 2097152| 100|0.37088973| PASSED
diehard_oqso| 0| 2097152| 100|0.36624898| PASSED
diehard_dna| 0| 2097152| 100|0.19975594| PASSED
diehard_count_1s_str| 0| 256000| 100|0.28857097| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.86523679| PASSED
diehard_parking_lot| 0| 12000| 100|0.47786440| PASSED
diehard_2dsphere| 2| 8000| 100|0.41599958| PASSED
diehard_3dsphere| 3| 4000| 100|0.94099937| PASSED
diehard_squeeze| 0| 100000| 100|0.95474734| PASSED
diehard_sums| 0| 100| 100|0.10394147| PASSED
diehard_runs| 0| 100000| 100|0.99190374| PASSED
diehard_runs| 0| 100000| 100|0.58456385| PASSED
diehard_craps| 0| 200000| 100|0.75100681| PASSED
diehard_craps| 0| 200000| 100|0.93956528| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.74829394| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.55266383| PASSED
sts_monobit| 1| 100000| 100|0.91676243| PASSED
sts_runs| 2| 100000| 100|0.84245917| PASSED
sts_serial| 1| 100000| 100|0.98952676| PASSED
sts_serial| 2| 100000| 100|0.53452615| PASSED
sts_serial| 3| 100000| 100|0.92861142| PASSED
sts_serial| 3| 100000| 100|0.97923884| PASSED
sts_serial| 4| 100000| 100|0.80345231| PASSED
sts_serial| 4| 100000| 100|0.48689085| PASSED
sts_serial| 5| 100000| 100|0.66464949| PASSED
sts_serial| 5| 100000| 100|0.42874876| PASSED
sts_serial| 6| 100000| 100|0.40619496| PASSED
sts_serial| 6| 100000| 100|0.46529689| PASSED
sts_serial| 7| 100000| 100|0.74711429| PASSED
sts_serial| 7| 100000| 100|0.70443318| PASSED
sts_serial| 8| 100000| 100|0.87013219| PASSED
sts_serial| 8| 100000| 100|0.84304190| PASSED
sts_serial| 9| 100000| 100|0.17309720| PASSED
sts_serial| 9| 100000| 100|0.04198352| PASSED
sts_serial| 10| 100000| 100|0.86229712| PASSED
sts_serial| 10| 100000| 100|0.15973091| PASSED
sts_serial| 11| 100000| 100|0.87446331| PASSED
sts_serial| 11| 100000| 100|0.54795254| PASSED
sts_serial| 12| 100000| 100|0.74764833| PASSED
sts_serial| 12| 100000| 100|0.82470249| PASSED
sts_serial| 13| 100000| 100|0.96686471| PASSED
sts_serial| 13| 100000| 100|0.94974559| PASSED
sts_serial| 14| 100000| 100|0.64004526| PASSED
sts_serial| 14| 100000| 100|0.83637589| PASSED
sts_serial| 15| 100000| 100|0.81053687| PASSED
sts_serial| 15| 100000| 100|0.54090818| PASSED
sts_serial| 16| 100000| 100|0.94014624| PASSED
sts_serial| 16| 100000| 100|0.37794867| PASSED
rgb_bitdist| 1| 100000| 100|0.84667603| PASSED
rgb_bitdist| 2| 100000| 100|0.45601246| PASSED
rgb_bitdist| 3| 100000| 100|0.49010180| PASSED
rgb_bitdist| 4| 100000| 100|0.83470734| PASSED
rgb_bitdist| 5| 100000| 100|0.17934962| PASSED
rgb_bitdist| 6| 100000| 100|0.28786832| PASSED
rgb_bitdist| 7| 100000| 100|0.88723743| PASSED
rgb_bitdist| 8| 100000| 100|0.86241962| PASSED
rgb_bitdist| 9| 100000| 100|0.35217801| PASSED
rgb_bitdist| 10| 100000| 100|0.12286924| PASSED
rgb_bitdist| 11| 100000| 100|0.50554388| PASSED
rgb_bitdist| 12| 100000| 100|0.82754029| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.60571436| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.08957350| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.47456926| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.59956612| PASSED
rgb_permutations| 2| 100000| 100|0.66657895| PASSED
rgb_permutations| 3| 100000| 100|0.14698778| PASSED
rgb_permutations| 4| 100000| 100|0.22614237| PASSED
rgb_permutations| 5| 100000| 100|0.74233560| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.88951138| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.68300915| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.55070313| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.87706432| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.34048283| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.80266702| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.27051638| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.99977720| WEAK
rgb_lagged_sum| 7| 1000000| 200|0.70214908| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.58065020| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.60779307| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.17029790| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.73086778| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.85769018| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.20253527| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.81906672| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.05452111| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.31488148| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.57561285| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.33432498| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.87556478| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.62064793| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.44057796| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.77145320| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.44218644| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.34580454| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.86707698| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.25065903| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.08845387| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.44035148| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.98840474| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.89618865| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.03461368| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.71574074| PASSED
rgb_kstest_test| 0| 10000| 1000|0.83334922| PASSED
dab_bytedistrib| 0| 51200000| 1|0.94003448| PASSED
dab_dct| 256| 50000| 1|0.64360075| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.17896690| PASSED
dab_filltree| 32| 15000000| 1|0.59765176| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.20525483| PASSED
dab_filltree2| 1| 5000000| 1|0.49968819| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.70382284| PASSED
#
# Test duration: 146.3986435312167 minutes
#

171
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_4 Normal file
View File

@ -0,0 +1,171 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well1024a
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.28e+06 |4183199985|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.37967206| PASSED
diehard_operm5| 0| 1000000| 100|0.16896039| PASSED
diehard_rank_32x32| 0| 40000| 100|0.10234056| PASSED
diehard_rank_6x8| 0| 100000| 100|0.99915806| WEAK
diehard_rank_6x8| 0| 100000| 200|0.76328994| PASSED
diehard_bitstream| 0| 2097152| 100|0.04550289| PASSED
diehard_opso| 0| 2097152| 100|0.18093229| PASSED
diehard_oqso| 0| 2097152| 100|0.88977379| PASSED
diehard_dna| 0| 2097152| 100|0.39711689| PASSED
diehard_count_1s_str| 0| 256000| 100|0.91868508| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.09864004| PASSED
diehard_parking_lot| 0| 12000| 100|0.84439484| PASSED
diehard_2dsphere| 2| 8000| 100|0.63769359| PASSED
diehard_3dsphere| 3| 4000| 100|0.99667292| WEAK
diehard_3dsphere| 3| 4000| 200|0.97890583| PASSED
diehard_squeeze| 0| 100000| 100|0.08113282| PASSED
diehard_sums| 0| 100| 100|0.18304848| PASSED
diehard_runs| 0| 100000| 100|0.93055788| PASSED
diehard_runs| 0| 100000| 100|0.02722999| PASSED
diehard_craps| 0| 200000| 100|0.95649653| PASSED
diehard_craps| 0| 200000| 100|0.10594796| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.95130745| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.94675735| PASSED
sts_monobit| 1| 100000| 100|0.94965858| PASSED
sts_runs| 2| 100000| 100|0.49268154| PASSED
sts_serial| 1| 100000| 100|0.67414934| PASSED
sts_serial| 2| 100000| 100|0.52573235| PASSED
sts_serial| 3| 100000| 100|0.81327554| PASSED
sts_serial| 3| 100000| 100|0.90513972| PASSED
sts_serial| 4| 100000| 100|0.71732065| PASSED
sts_serial| 4| 100000| 100|0.13308603| PASSED
sts_serial| 5| 100000| 100|0.23540984| PASSED
sts_serial| 5| 100000| 100|0.44328515| PASSED
sts_serial| 6| 100000| 100|0.33156927| PASSED
sts_serial| 6| 100000| 100|0.78537532| PASSED
sts_serial| 7| 100000| 100|0.49729112| PASSED
sts_serial| 7| 100000| 100|0.95479854| PASSED
sts_serial| 8| 100000| 100|0.05387016| PASSED
sts_serial| 8| 100000| 100|0.15736901| PASSED
sts_serial| 9| 100000| 100|0.13780496| PASSED
sts_serial| 9| 100000| 100|0.74793613| PASSED
sts_serial| 10| 100000| 100|0.56198066| PASSED
sts_serial| 10| 100000| 100|0.39265977| PASSED
sts_serial| 11| 100000| 100|0.66864511| PASSED
sts_serial| 11| 100000| 100|0.41904624| PASSED
sts_serial| 12| 100000| 100|0.95726079| PASSED
sts_serial| 12| 100000| 100|0.26374857| PASSED
sts_serial| 13| 100000| 100|0.96889789| PASSED
sts_serial| 13| 100000| 100|0.65655695| PASSED
sts_serial| 14| 100000| 100|0.98593485| PASSED
sts_serial| 14| 100000| 100|0.42000525| PASSED
sts_serial| 15| 100000| 100|0.99865014| WEAK
sts_serial| 15| 100000| 100|0.78080800| PASSED
sts_serial| 16| 100000| 100|0.94693227| PASSED
sts_serial| 16| 100000| 100|0.57689706| PASSED
sts_serial| 1| 100000| 200|0.75009672| PASSED
sts_serial| 2| 100000| 200|0.45933997| PASSED
sts_serial| 3| 100000| 200|0.88239488| PASSED
sts_serial| 3| 100000| 200|0.38370527| PASSED
sts_serial| 4| 100000| 200|0.87910017| PASSED
sts_serial| 4| 100000| 200|0.85888426| PASSED
sts_serial| 5| 100000| 200|0.64148870| PASSED
sts_serial| 5| 100000| 200|0.72448038| PASSED
sts_serial| 6| 100000| 200|0.52416264| PASSED
sts_serial| 6| 100000| 200|0.59597198| PASSED
sts_serial| 7| 100000| 200|0.63751373| PASSED
sts_serial| 7| 100000| 200|0.40881850| PASSED
sts_serial| 8| 100000| 200|0.23992923| PASSED
sts_serial| 8| 100000| 200|0.71371195| PASSED
sts_serial| 9| 100000| 200|0.15240908| PASSED
sts_serial| 9| 100000| 200|0.44579086| PASSED
sts_serial| 10| 100000| 200|0.22104239| PASSED
sts_serial| 10| 100000| 200|0.71386608| PASSED
sts_serial| 11| 100000| 200|0.47257227| PASSED
sts_serial| 11| 100000| 200|0.36853280| PASSED
sts_serial| 12| 100000| 200|0.88238100| PASSED
sts_serial| 12| 100000| 200|0.69923733| PASSED
sts_serial| 13| 100000| 200|0.77501701| PASSED
sts_serial| 13| 100000| 200|0.53610861| PASSED
sts_serial| 14| 100000| 200|0.90628335| PASSED
sts_serial| 14| 100000| 200|0.00777700| PASSED
sts_serial| 15| 100000| 200|0.83242333| PASSED
sts_serial| 15| 100000| 200|0.46827261| PASSED
sts_serial| 16| 100000| 200|0.93963409| PASSED
sts_serial| 16| 100000| 200|0.93327416| PASSED
rgb_bitdist| 1| 100000| 100|0.90555951| PASSED
rgb_bitdist| 2| 100000| 100|0.43684064| PASSED
rgb_bitdist| 3| 100000| 100|0.29045486| PASSED
rgb_bitdist| 4| 100000| 100|0.31604577| PASSED
rgb_bitdist| 5| 100000| 100|0.59786472| PASSED
rgb_bitdist| 6| 100000| 100|0.33428311| PASSED
rgb_bitdist| 7| 100000| 100|0.82649800| PASSED
rgb_bitdist| 8| 100000| 100|0.92805252| PASSED
rgb_bitdist| 9| 100000| 100|0.53762168| PASSED
rgb_bitdist| 10| 100000| 100|0.25936001| PASSED
rgb_bitdist| 11| 100000| 100|0.94071508| PASSED
rgb_bitdist| 12| 100000| 100|0.96301533| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.89820332| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.83852811| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.07554308| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.22658770| PASSED
rgb_permutations| 2| 100000| 100|0.30090736| PASSED
rgb_permutations| 3| 100000| 100|0.94143138| PASSED
rgb_permutations| 4| 100000| 100|0.61659743| PASSED
rgb_permutations| 5| 100000| 100|0.31714668| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.72028204| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.91126692| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.92236868| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.57543958| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.49015039| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.45677219| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.14915843| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.45441388| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.83995691| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.75774590| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.68958257| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.64431849| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.63493083| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.14803740| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.96401463| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.99827869| WEAK
rgb_lagged_sum| 15| 1000000| 200|0.78902787| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.70048950| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.97155656| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.13683972| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.66010592| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.79100372| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.10614381| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.78268174| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.67852033| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.44990687| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.21184617| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.16578623| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.51146717| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.47461193| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.11560118| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.82871666| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.59624564| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.56418510| PASSED
rgb_kstest_test| 0| 10000| 1000|0.53357570| PASSED
dab_bytedistrib| 0| 51200000| 1|0.29132571| PASSED
dab_dct| 256| 50000| 1|0.80875808| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.88308721| PASSED
dab_filltree| 32| 15000000| 1|0.74581447| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.09046849| PASSED
dab_filltree2| 1| 5000000| 1|0.11531268| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.90158558| PASSED
#
# Test duration: 148.72610797815003 minutes
#

143
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_5 Normal file
View File

@ -0,0 +1,143 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well19937a
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.11e+06 |1324685015|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.97873706| PASSED
diehard_operm5| 0| 1000000| 100|0.31625234| PASSED
diehard_rank_32x32| 0| 40000| 100|0.81874010| PASSED
diehard_rank_6x8| 0| 100000| 100|0.38511330| PASSED
diehard_bitstream| 0| 2097152| 100|0.72448209| PASSED
diehard_opso| 0| 2097152| 100|0.21526395| PASSED
diehard_oqso| 0| 2097152| 100|0.14809241| PASSED
diehard_dna| 0| 2097152| 100|0.13975350| PASSED
diehard_count_1s_str| 0| 256000| 100|0.27264345| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.23899278| PASSED
diehard_parking_lot| 0| 12000| 100|0.59288414| PASSED
diehard_2dsphere| 2| 8000| 100|0.44640415| PASSED
diehard_3dsphere| 3| 4000| 100|0.89918701| PASSED
diehard_squeeze| 0| 100000| 100|0.85012417| PASSED
diehard_sums| 0| 100| 100|0.07862421| PASSED
diehard_runs| 0| 100000| 100|0.22539800| PASSED
diehard_runs| 0| 100000| 100|0.25024342| PASSED
diehard_craps| 0| 200000| 100|0.66918238| PASSED
diehard_craps| 0| 200000| 100|0.74263938| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.76388825| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.12763949| PASSED
sts_monobit| 1| 100000| 100|0.90379684| PASSED
sts_runs| 2| 100000| 100|0.96725937| PASSED
sts_serial| 1| 100000| 100|0.89179612| PASSED
sts_serial| 2| 100000| 100|0.72323704| PASSED
sts_serial| 3| 100000| 100|0.52010951| PASSED
sts_serial| 3| 100000| 100|0.22447689| PASSED
sts_serial| 4| 100000| 100|0.31207188| PASSED
sts_serial| 4| 100000| 100|0.00723587| PASSED
sts_serial| 5| 100000| 100|0.97048978| PASSED
sts_serial| 5| 100000| 100|0.81338656| PASSED
sts_serial| 6| 100000| 100|0.13820363| PASSED
sts_serial| 6| 100000| 100|0.01043639| PASSED
sts_serial| 7| 100000| 100|0.03953577| PASSED
sts_serial| 7| 100000| 100|0.02379927| PASSED
sts_serial| 8| 100000| 100|0.47458458| PASSED
sts_serial| 8| 100000| 100|0.46015889| PASSED
sts_serial| 9| 100000| 100|0.81464024| PASSED
sts_serial| 9| 100000| 100|0.66406361| PASSED
sts_serial| 10| 100000| 100|0.53261452| PASSED
sts_serial| 10| 100000| 100|0.88051566| PASSED
sts_serial| 11| 100000| 100|0.56643984| PASSED
sts_serial| 11| 100000| 100|0.11383998| PASSED
sts_serial| 12| 100000| 100|0.29462130| PASSED
sts_serial| 12| 100000| 100|0.02722840| PASSED
sts_serial| 13| 100000| 100|0.55119783| PASSED
sts_serial| 13| 100000| 100|0.72716120| PASSED
sts_serial| 14| 100000| 100|0.53381465| PASSED
sts_serial| 14| 100000| 100|0.31932292| PASSED
sts_serial| 15| 100000| 100|0.68645828| PASSED
sts_serial| 15| 100000| 100|0.94979473| PASSED
sts_serial| 16| 100000| 100|0.13657316| PASSED
sts_serial| 16| 100000| 100|0.26675130| PASSED
rgb_bitdist| 1| 100000| 100|0.02478061| PASSED
rgb_bitdist| 2| 100000| 100|0.07528420| PASSED
rgb_bitdist| 3| 100000| 100|0.57858945| PASSED
rgb_bitdist| 4| 100000| 100|0.80502569| PASSED
rgb_bitdist| 5| 100000| 100|0.00483505| WEAK
rgb_bitdist| 5| 100000| 200|0.10185402| PASSED
rgb_bitdist| 6| 100000| 100|0.32770207| PASSED
rgb_bitdist| 7| 100000| 100|0.36675591| PASSED
rgb_bitdist| 8| 100000| 100|0.88234317| PASSED
rgb_bitdist| 9| 100000| 100|0.07422959| PASSED
rgb_bitdist| 10| 100000| 100|0.89191964| PASSED
rgb_bitdist| 11| 100000| 100|0.99910018| WEAK
rgb_bitdist| 11| 100000| 200|0.41561250| PASSED
rgb_bitdist| 12| 100000| 100|0.74345980| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.10392245| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.38843244| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.03155304| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.16214581| PASSED
rgb_permutations| 2| 100000| 100|0.64186486| PASSED
rgb_permutations| 3| 100000| 100|0.06742496| PASSED
rgb_permutations| 4| 100000| 100|0.91809323| PASSED
rgb_permutations| 5| 100000| 100|0.54190175| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.81729482| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.19767763| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.99809832| WEAK
rgb_lagged_sum| 2| 1000000| 200|0.41500829| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.17526318| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.19400369| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.52139840| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.48238904| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.69067647| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.91361815| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.06310703| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.29108052| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.94573219| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.90058722| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.96964807| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.23084181| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.40614194| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.99734781| WEAK
rgb_lagged_sum| 16| 1000000| 200|0.90592642| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.78266848| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.90745627| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.46898421| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.64303764| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.78785428| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.64289335| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.99712926| WEAK
rgb_lagged_sum| 23| 1000000| 200|0.83532125| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.37457204| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.72225826| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.85509807| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.19342055| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.55197797| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.94564052| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.98416036| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.97123174| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.41819068| PASSED
rgb_kstest_test| 0| 10000| 1000|0.87419667| PASSED
dab_bytedistrib| 0| 51200000| 1|0.50271402| PASSED
dab_dct| 256| 50000| 1|0.35130777| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.09459145| PASSED
dab_filltree| 32| 15000000| 1|0.10110627| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.07851894| PASSED
dab_filltree2| 1| 5000000| 1|0.50633037| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.45029930| PASSED
#
# Test duration: 162.06253442048333 minutes
#

260
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_6 Normal file
View File

@ -0,0 +1,260 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well19937c
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.37e+06 |3334361804|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.33902894| PASSED
diehard_operm5| 0| 1000000| 100|0.16900958| PASSED
diehard_rank_32x32| 0| 40000| 100|0.98520421| PASSED
diehard_rank_6x8| 0| 100000| 100|0.95411917| PASSED
diehard_bitstream| 0| 2097152| 100|0.65099743| PASSED
diehard_opso| 0| 2097152| 100|0.72997564| PASSED
diehard_oqso| 0| 2097152| 100|0.96814123| PASSED
diehard_dna| 0| 2097152| 100|0.22517961| PASSED
diehard_count_1s_str| 0| 256000| 100|0.86241438| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.17957029| PASSED
diehard_parking_lot| 0| 12000| 100|0.83744977| PASSED
diehard_2dsphere| 2| 8000| 100|0.13941120| PASSED
diehard_3dsphere| 3| 4000| 100|0.68303986| PASSED
diehard_squeeze| 0| 100000| 100|0.57025791| PASSED
diehard_sums| 0| 100| 100|0.52231410| PASSED
diehard_runs| 0| 100000| 100|0.64626314| PASSED
diehard_runs| 0| 100000| 100|0.81897851| PASSED
diehard_craps| 0| 200000| 100|0.93418601| PASSED
diehard_craps| 0| 200000| 100|0.60805271| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.81819286| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.52754285| PASSED
sts_monobit| 1| 100000| 100|0.37890714| PASSED
sts_runs| 2| 100000| 100|0.96148485| PASSED
sts_serial| 1| 100000| 100|0.31001355| PASSED
sts_serial| 2| 100000| 100|0.99599161| WEAK
sts_serial| 3| 100000| 100|0.52488613| PASSED
sts_serial| 3| 100000| 100|0.31877707| PASSED
sts_serial| 4| 100000| 100|0.82948358| PASSED
sts_serial| 4| 100000| 100|0.20185553| PASSED
sts_serial| 5| 100000| 100|0.82606199| PASSED
sts_serial| 5| 100000| 100|0.40795669| PASSED
sts_serial| 6| 100000| 100|0.99209107| PASSED
sts_serial| 6| 100000| 100|0.58524695| PASSED
sts_serial| 7| 100000| 100|0.54602489| PASSED
sts_serial| 7| 100000| 100|0.51515163| PASSED
sts_serial| 8| 100000| 100|0.20279979| PASSED
sts_serial| 8| 100000| 100|0.98276260| PASSED
sts_serial| 9| 100000| 100|0.99017482| PASSED
sts_serial| 9| 100000| 100|0.40115439| PASSED
sts_serial| 10| 100000| 100|0.98381543| PASSED
sts_serial| 10| 100000| 100|0.97169831| PASSED
sts_serial| 11| 100000| 100|0.69916793| PASSED
sts_serial| 11| 100000| 100|0.82244173| PASSED
sts_serial| 12| 100000| 100|0.98881736| PASSED
sts_serial| 12| 100000| 100|0.88903637| PASSED
sts_serial| 13| 100000| 100|0.62493512| PASSED
sts_serial| 13| 100000| 100|0.02643409| PASSED
sts_serial| 14| 100000| 100|0.94146388| PASSED
sts_serial| 14| 100000| 100|0.05129506| PASSED
sts_serial| 15| 100000| 100|0.33783283| PASSED
sts_serial| 15| 100000| 100|0.42022922| PASSED
sts_serial| 16| 100000| 100|0.93096511| PASSED
sts_serial| 16| 100000| 100|0.08534973| PASSED
sts_serial| 1| 100000| 200|0.31374350| PASSED
sts_serial| 2| 100000| 200|0.77622320| PASSED
sts_serial| 3| 100000| 200|0.87277999| PASSED
sts_serial| 3| 100000| 200|0.99891004| WEAK
sts_serial| 4| 100000| 200|0.34087456| PASSED
sts_serial| 4| 100000| 200|0.21548720| PASSED
sts_serial| 5| 100000| 200|0.70669660| PASSED
sts_serial| 5| 100000| 200|0.96704079| PASSED
sts_serial| 6| 100000| 200|0.74448169| PASSED
sts_serial| 6| 100000| 200|0.02327035| PASSED
sts_serial| 7| 100000| 200|0.13512242| PASSED
sts_serial| 7| 100000| 200|0.04402775| PASSED
sts_serial| 8| 100000| 200|0.04657087| PASSED
sts_serial| 8| 100000| 200|0.82707014| PASSED
sts_serial| 9| 100000| 200|0.78715084| PASSED
sts_serial| 9| 100000| 200|0.97043527| PASSED
sts_serial| 10| 100000| 200|0.97470209| PASSED
sts_serial| 10| 100000| 200|0.96197967| PASSED
sts_serial| 11| 100000| 200|0.47919447| PASSED
sts_serial| 11| 100000| 200|0.33035068| PASSED
sts_serial| 12| 100000| 200|0.73206815| PASSED
sts_serial| 12| 100000| 200|0.90999844| PASSED
sts_serial| 13| 100000| 200|0.83430520| PASSED
sts_serial| 13| 100000| 200|0.52363389| PASSED
sts_serial| 14| 100000| 200|0.89567712| PASSED
sts_serial| 14| 100000| 200|0.05256107| PASSED
sts_serial| 15| 100000| 200|0.39651524| PASSED
sts_serial| 15| 100000| 200|0.73344344| PASSED
sts_serial| 16| 100000| 200|0.45612542| PASSED
sts_serial| 16| 100000| 200|0.48364900| PASSED
sts_serial| 1| 100000| 300|0.39005846| PASSED
sts_serial| 2| 100000| 300|0.91116693| PASSED
sts_serial| 3| 100000| 300|0.90918793| PASSED
sts_serial| 3| 100000| 300|0.97378321| PASSED
sts_serial| 4| 100000| 300|0.77199373| PASSED
sts_serial| 4| 100000| 300|0.66547445| PASSED
sts_serial| 5| 100000| 300|0.98378648| PASSED
sts_serial| 5| 100000| 300|0.98923215| PASSED
sts_serial| 6| 100000| 300|0.72237614| PASSED
sts_serial| 6| 100000| 300|0.13975497| PASSED
sts_serial| 7| 100000| 300|0.73870875| PASSED
sts_serial| 7| 100000| 300|0.33515098| PASSED
sts_serial| 8| 100000| 300|0.16446282| PASSED
sts_serial| 8| 100000| 300|0.72851585| PASSED
sts_serial| 9| 100000| 300|0.99692292| WEAK
sts_serial| 9| 100000| 300|0.98870291| PASSED
sts_serial| 10| 100000| 300|0.88653931| PASSED
sts_serial| 10| 100000| 300|0.99880041| WEAK
sts_serial| 11| 100000| 300|0.23009197| PASSED
sts_serial| 11| 100000| 300|0.36184916| PASSED
sts_serial| 12| 100000| 300|0.65393093| PASSED
sts_serial| 12| 100000| 300|0.74718009| PASSED
sts_serial| 13| 100000| 300|0.57240783| PASSED
sts_serial| 13| 100000| 300|0.39080265| PASSED
sts_serial| 14| 100000| 300|0.84261940| PASSED
sts_serial| 14| 100000| 300|0.21697709| PASSED
sts_serial| 15| 100000| 300|0.98280056| PASSED
sts_serial| 15| 100000| 300|0.98523833| PASSED
sts_serial| 16| 100000| 300|0.96840606| PASSED
sts_serial| 16| 100000| 300|0.59220393| PASSED
sts_serial| 1| 100000| 400|0.79952430| PASSED
sts_serial| 2| 100000| 400|0.82688750| PASSED
sts_serial| 3| 100000| 400|0.65765573| PASSED
sts_serial| 3| 100000| 400|0.93382369| PASSED
sts_serial| 4| 100000| 400|0.98598169| PASSED
sts_serial| 4| 100000| 400|0.99718327| WEAK
sts_serial| 5| 100000| 400|0.99980289| WEAK
sts_serial| 5| 100000| 400|0.81777062| PASSED
sts_serial| 6| 100000| 400|0.33252618| PASSED
sts_serial| 6| 100000| 400|0.13433104| PASSED
sts_serial| 7| 100000| 400|0.72568325| PASSED
sts_serial| 7| 100000| 400|0.28657646| PASSED
sts_serial| 8| 100000| 400|0.10275109| PASSED
sts_serial| 8| 100000| 400|0.68117960| PASSED
sts_serial| 9| 100000| 400|0.49822099| PASSED
sts_serial| 9| 100000| 400|0.67154776| PASSED
sts_serial| 10| 100000| 400|0.55659657| PASSED
sts_serial| 10| 100000| 400|0.98400849| PASSED
sts_serial| 11| 100000| 400|0.35113327| PASSED
sts_serial| 11| 100000| 400|0.68666619| PASSED
sts_serial| 12| 100000| 400|0.77204559| PASSED
sts_serial| 12| 100000| 400|0.17557545| PASSED
sts_serial| 13| 100000| 400|0.58660251| PASSED
sts_serial| 13| 100000| 400|0.28361520| PASSED
sts_serial| 14| 100000| 400|0.36144480| PASSED
sts_serial| 14| 100000| 400|0.09021380| PASSED
sts_serial| 15| 100000| 400|0.26006754| PASSED
sts_serial| 15| 100000| 400|0.54397030| PASSED
sts_serial| 16| 100000| 400|0.27929650| PASSED
sts_serial| 16| 100000| 400|0.61477373| PASSED
sts_serial| 1| 100000| 500|0.64627198| PASSED
sts_serial| 2| 100000| 500|0.90417640| PASSED
sts_serial| 3| 100000| 500|0.37806243| PASSED
sts_serial| 3| 100000| 500|0.81436817| PASSED
sts_serial| 4| 100000| 500|0.92155913| PASSED
sts_serial| 4| 100000| 500|0.92992166| PASSED
sts_serial| 5| 100000| 500|0.92457412| PASSED
sts_serial| 5| 100000| 500|0.77345272| PASSED
sts_serial| 6| 100000| 500|0.21939241| PASSED
sts_serial| 6| 100000| 500|0.06760935| PASSED
sts_serial| 7| 100000| 500|0.35973975| PASSED
sts_serial| 7| 100000| 500|0.24111951| PASSED
sts_serial| 8| 100000| 500|0.04265546| PASSED
sts_serial| 8| 100000| 500|0.41737169| PASSED
sts_serial| 9| 100000| 500|0.27501433| PASSED
sts_serial| 9| 100000| 500|0.55471507| PASSED
sts_serial| 10| 100000| 500|0.35831064| PASSED
sts_serial| 10| 100000| 500|0.83433061| PASSED
sts_serial| 11| 100000| 500|0.09874252| PASSED
sts_serial| 11| 100000| 500|0.37036257| PASSED
sts_serial| 12| 100000| 500|0.66754332| PASSED
sts_serial| 12| 100000| 500|0.93833550| PASSED
sts_serial| 13| 100000| 500|0.41458670| PASSED
sts_serial| 13| 100000| 500|0.38120717| PASSED
sts_serial| 14| 100000| 500|0.15984249| PASSED
sts_serial| 14| 100000| 500|0.02687063| PASSED
sts_serial| 15| 100000| 500|0.53058827| PASSED
sts_serial| 15| 100000| 500|0.58253309| PASSED
sts_serial| 16| 100000| 500|0.63785859| PASSED
sts_serial| 16| 100000| 500|0.57310525| PASSED
rgb_bitdist| 1| 100000| 100|0.32573254| PASSED
rgb_bitdist| 2| 100000| 100|0.48041520| PASSED
rgb_bitdist| 3| 100000| 100|0.71306959| PASSED
rgb_bitdist| 4| 100000| 100|0.41851101| PASSED
rgb_bitdist| 5| 100000| 100|0.64475492| PASSED
rgb_bitdist| 6| 100000| 100|0.73449149| PASSED
rgb_bitdist| 7| 100000| 100|0.70937060| PASSED
rgb_bitdist| 8| 100000| 100|0.34067798| PASSED
rgb_bitdist| 9| 100000| 100|0.56997054| PASSED
rgb_bitdist| 10| 100000| 100|0.42287847| PASSED
rgb_bitdist| 11| 100000| 100|0.44738156| PASSED
rgb_bitdist| 12| 100000| 100|0.22232608| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.19327258| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.81055025| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.90244006| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.27507361| PASSED
rgb_permutations| 2| 100000| 100|0.82969465| PASSED
rgb_permutations| 3| 100000| 100|0.60470846| PASSED
rgb_permutations| 4| 100000| 100|0.93710623| PASSED
rgb_permutations| 5| 100000| 100|0.12832164| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.01452483| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.78105258| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.15312110| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.96704133| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.89155575| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.10410746| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.62843428| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.08391358| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.61503919| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.49047843| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.39668875| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.25226931| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.09436183| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.74510400| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.81857951| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.90137981| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.94752528| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.83341319| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.70513074| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.89718522| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.33647555| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.98390612| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.23675547| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.48135017| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.09079197| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.02305748| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.26733513| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.97214481| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.69460385| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.58585169| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.13119563| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.31757199| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.95214009| PASSED
rgb_kstest_test| 0| 10000| 1000|0.10787252| PASSED
dab_bytedistrib| 0| 51200000| 1|0.93611706| PASSED
dab_dct| 256| 50000| 1|0.34752816| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.64217530| PASSED
dab_filltree| 32| 15000000| 1|0.44229477| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.99556903| WEAK
dab_filltree2| 1| 5000000| 1|0.90214349| PASSED
dab_filltree2| 0| 5000000| 101|0.92818702| PASSED
dab_filltree2| 1| 5000000| 101|0.94608261| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.46644015| PASSED
#
# Test duration: 157.60660263953335 minutes
#

143
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_7 Normal file
View File

@ -0,0 +1,143 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well44497a
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.19e+06 |1041997854|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.80187216| PASSED
diehard_operm5| 0| 1000000| 100|0.61100451| PASSED
diehard_rank_32x32| 0| 40000| 100|0.75146496| PASSED
diehard_rank_6x8| 0| 100000| 100|0.93193662| PASSED
diehard_bitstream| 0| 2097152| 100|0.62788669| PASSED
diehard_opso| 0| 2097152| 100|0.53661676| PASSED
diehard_oqso| 0| 2097152| 100|0.12407821| PASSED
diehard_dna| 0| 2097152| 100|0.98715269| PASSED
diehard_count_1s_str| 0| 256000| 100|0.62644200| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.70348326| PASSED
diehard_parking_lot| 0| 12000| 100|0.79600924| PASSED
diehard_2dsphere| 2| 8000| 100|0.61535064| PASSED
diehard_3dsphere| 3| 4000| 100|0.45708543| PASSED
diehard_squeeze| 0| 100000| 100|0.50570394| PASSED
diehard_sums| 0| 100| 100|0.35238433| PASSED
diehard_runs| 0| 100000| 100|0.15945898| PASSED
diehard_runs| 0| 100000| 100|0.24231765| PASSED
diehard_craps| 0| 200000| 100|0.21559884| PASSED
diehard_craps| 0| 200000| 100|0.55447355| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.71289644| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.62127133| PASSED
sts_monobit| 1| 100000| 100|0.72272298| PASSED
sts_runs| 2| 100000| 100|0.86196986| PASSED
sts_serial| 1| 100000| 100|0.35360871| PASSED
sts_serial| 2| 100000| 100|0.66877839| PASSED
sts_serial| 3| 100000| 100|0.85271378| PASSED
sts_serial| 3| 100000| 100|0.97392361| PASSED
sts_serial| 4| 100000| 100|0.73341160| PASSED
sts_serial| 4| 100000| 100|0.54790218| PASSED
sts_serial| 5| 100000| 100|0.99490903| PASSED
sts_serial| 5| 100000| 100|0.25972060| PASSED
sts_serial| 6| 100000| 100|0.52193260| PASSED
sts_serial| 6| 100000| 100|0.36805573| PASSED
sts_serial| 7| 100000| 100|0.32489079| PASSED
sts_serial| 7| 100000| 100|0.03388755| PASSED
sts_serial| 8| 100000| 100|0.07298106| PASSED
sts_serial| 8| 100000| 100|0.94677478| PASSED
sts_serial| 9| 100000| 100|0.10061493| PASSED
sts_serial| 9| 100000| 100|0.18182045| PASSED
sts_serial| 10| 100000| 100|0.80509182| PASSED
sts_serial| 10| 100000| 100|0.34719024| PASSED
sts_serial| 11| 100000| 100|0.82251854| PASSED
sts_serial| 11| 100000| 100|0.37241756| PASSED
sts_serial| 12| 100000| 100|0.57742830| PASSED
sts_serial| 12| 100000| 100|0.14971630| PASSED
sts_serial| 13| 100000| 100|0.22184499| PASSED
sts_serial| 13| 100000| 100|0.85784401| PASSED
sts_serial| 14| 100000| 100|0.33978075| PASSED
sts_serial| 14| 100000| 100|0.97289399| PASSED
sts_serial| 15| 100000| 100|0.97904833| PASSED
sts_serial| 15| 100000| 100|0.62298556| PASSED
sts_serial| 16| 100000| 100|0.12878687| PASSED
sts_serial| 16| 100000| 100|0.43284759| PASSED
rgb_bitdist| 1| 100000| 100|0.77380541| PASSED
rgb_bitdist| 2| 100000| 100|0.73200370| PASSED
rgb_bitdist| 3| 100000| 100|0.31724334| PASSED
rgb_bitdist| 4| 100000| 100|0.01702691| PASSED
rgb_bitdist| 5| 100000| 100|0.22686084| PASSED
rgb_bitdist| 6| 100000| 100|0.99971773| WEAK
rgb_bitdist| 6| 100000| 200|0.48818561| PASSED
rgb_bitdist| 7| 100000| 100|0.74742009| PASSED
rgb_bitdist| 8| 100000| 100|0.03339909| PASSED
rgb_bitdist| 9| 100000| 100|0.38858045| PASSED
rgb_bitdist| 10| 100000| 100|0.20831290| PASSED
rgb_bitdist| 11| 100000| 100|0.43093782| PASSED
rgb_bitdist| 12| 100000| 100|0.17196967| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.69443555| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.89796205| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.80301917| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.57935885| PASSED
rgb_permutations| 2| 100000| 100|0.99951200| WEAK
rgb_permutations| 2| 100000| 200|0.99044316| PASSED
rgb_permutations| 3| 100000| 100|0.46595580| PASSED
rgb_permutations| 4| 100000| 100|0.54471856| PASSED
rgb_permutations| 5| 100000| 100|0.56908207| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.86946802| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.96657641| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.90691978| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.28864821| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.99943487| WEAK
rgb_lagged_sum| 4| 1000000| 200|0.77533347| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.39390734| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.93343776| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.83992481| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.72689904| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.53910749| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.52059801| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.30613618| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.77276205| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.40964865| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.86534443| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.38541883| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.89672716| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.67161251| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.18683541| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.98107536| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.67779362| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.04985419| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.36235990| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.54694571| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.27203710| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.78936783| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.44740362| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.94535534| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.65166475| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.69670377| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.53551941| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.79843436| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.70285114| PASSED
rgb_kstest_test| 0| 10000| 1000|0.48404789| PASSED
dab_bytedistrib| 0| 51200000| 1|0.56870408| PASSED
dab_dct| 256| 50000| 1|0.74939723| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.63125846| PASSED
dab_filltree| 32| 15000000| 1|0.76546612| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.99763961| WEAK
dab_filltree2| 1| 5000000| 1|0.81326588| PASSED
dab_filltree2| 0| 5000000| 101|0.69542422| PASSED
dab_filltree2| 1| 5000000| 101|0.22172752| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.41617820| PASSED
#
# Test duration: 156.2953042299667 minutes
#

800
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_8 Normal file
View File

@ -0,0 +1,800 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.Well44497b
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 8.14e+06 |3240771676|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.81680343| PASSED
diehard_operm5| 0| 1000000| 100|0.83093104| PASSED
diehard_rank_32x32| 0| 40000| 100|0.69890950| PASSED
diehard_rank_6x8| 0| 100000| 100|0.73757194| PASSED
diehard_bitstream| 0| 2097152| 100|0.79560953| PASSED
diehard_opso| 0| 2097152| 100|0.91743161| PASSED
diehard_oqso| 0| 2097152| 100|0.30375937| PASSED
diehard_dna| 0| 2097152| 100|0.48183957| PASSED
diehard_count_1s_str| 0| 256000| 100|0.58403744| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.13206026| PASSED
diehard_parking_lot| 0| 12000| 100|0.39368629| PASSED
diehard_2dsphere| 2| 8000| 100|0.92222474| PASSED
diehard_3dsphere| 3| 4000| 100|0.43358713| PASSED
diehard_squeeze| 0| 100000| 100|0.41102170| PASSED
diehard_sums| 0| 100| 100|0.11298386| PASSED
diehard_runs| 0| 100000| 100|0.88159233| PASSED
diehard_runs| 0| 100000| 100|0.90214433| PASSED
diehard_craps| 0| 200000| 100|0.03843281| PASSED
diehard_craps| 0| 200000| 100|0.77456635| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.39987405| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.05747832| PASSED
sts_monobit| 1| 100000| 100|0.99464121| PASSED
sts_runs| 2| 100000| 100|0.94267702| PASSED
sts_serial| 1| 100000| 100|0.20950020| PASSED
sts_serial| 2| 100000| 100|0.50407611| PASSED
sts_serial| 3| 100000| 100|0.85057752| PASSED
sts_serial| 3| 100000| 100|0.65487831| PASSED
sts_serial| 4| 100000| 100|0.60209893| PASSED
sts_serial| 4| 100000| 100|0.32116768| PASSED
sts_serial| 5| 100000| 100|0.17223680| PASSED
sts_serial| 5| 100000| 100|0.37939987| PASSED
sts_serial| 6| 100000| 100|0.66671747| PASSED
sts_serial| 6| 100000| 100|0.04386058| PASSED
sts_serial| 7| 100000| 100|0.34604983| PASSED
sts_serial| 7| 100000| 100|0.47838019| PASSED
sts_serial| 8| 100000| 100|0.83460317| PASSED
sts_serial| 8| 100000| 100|0.62981425| PASSED
sts_serial| 9| 100000| 100|0.77962063| PASSED
sts_serial| 9| 100000| 100|0.99955982| WEAK
sts_serial| 10| 100000| 100|0.27605490| PASSED
sts_serial| 10| 100000| 100|0.15126031| PASSED
sts_serial| 11| 100000| 100|0.47920323| PASSED
sts_serial| 11| 100000| 100|0.84941018| PASSED
sts_serial| 12| 100000| 100|0.19624503| PASSED
sts_serial| 12| 100000| 100|0.41833940| PASSED
sts_serial| 13| 100000| 100|0.99389349| PASSED
sts_serial| 13| 100000| 100|0.77268057| PASSED
sts_serial| 14| 100000| 100|0.12123384| PASSED
sts_serial| 14| 100000| 100|0.08863515| PASSED
sts_serial| 15| 100000| 100|0.92644666| PASSED
sts_serial| 15| 100000| 100|0.27845301| PASSED
sts_serial| 16| 100000| 100|0.68209282| PASSED
sts_serial| 16| 100000| 100|0.37365079| PASSED
sts_serial| 1| 100000| 200|0.85514360| PASSED
sts_serial| 2| 100000| 200|0.25674755| PASSED
sts_serial| 3| 100000| 200|0.93645219| PASSED
sts_serial| 3| 100000| 200|0.37775574| PASSED
sts_serial| 4| 100000| 200|0.37714408| PASSED
sts_serial| 4| 100000| 200|0.08978336| PASSED
sts_serial| 5| 100000| 200|0.03040927| PASSED
sts_serial| 5| 100000| 200|0.33012285| PASSED
sts_serial| 6| 100000| 200|0.15022462| PASSED
sts_serial| 6| 100000| 200|0.62285283| PASSED
sts_serial| 7| 100000| 200|0.60916939| PASSED
sts_serial| 7| 100000| 200|0.09498785| PASSED
sts_serial| 8| 100000| 200|0.99833151| WEAK
sts_serial| 8| 100000| 200|0.61048753| PASSED
sts_serial| 9| 100000| 200|0.72509686| PASSED
sts_serial| 9| 100000| 200|0.83391077| PASSED
sts_serial| 10| 100000| 200|0.31533498| PASSED
sts_serial| 10| 100000| 200|0.07040741| PASSED
sts_serial| 11| 100000| 200|0.90100087| PASSED
sts_serial| 11| 100000| 200|0.56791314| PASSED
sts_serial| 12| 100000| 200|0.15266979| PASSED
sts_serial| 12| 100000| 200|0.20452573| PASSED
sts_serial| 13| 100000| 200|0.65792351| PASSED
sts_serial| 13| 100000| 200|0.57757768| PASSED
sts_serial| 14| 100000| 200|0.28899730| PASSED
sts_serial| 14| 100000| 200|0.39326344| PASSED
sts_serial| 15| 100000| 200|0.91378879| PASSED
sts_serial| 15| 100000| 200|0.98983256| PASSED
sts_serial| 16| 100000| 200|0.58185239| PASSED
sts_serial| 16| 100000| 200|0.71642908| PASSED
sts_serial| 1| 100000| 300|0.82681350| PASSED
sts_serial| 2| 100000| 300|0.10070102| PASSED
sts_serial| 3| 100000| 300|0.99186311| PASSED
sts_serial| 3| 100000| 300|0.42794292| PASSED
sts_serial| 4| 100000| 300|0.66544070| PASSED
sts_serial| 4| 100000| 300|0.74721513| PASSED
sts_serial| 5| 100000| 300|0.07913374| PASSED
sts_serial| 5| 100000| 300|0.76937303| PASSED
sts_serial| 6| 100000| 300|0.41149255| PASSED
sts_serial| 6| 100000| 300|0.72328073| PASSED
sts_serial| 7| 100000| 300|0.18088411| PASSED
sts_serial| 7| 100000| 300|0.07732748| PASSED
sts_serial| 8| 100000| 300|0.99778892| WEAK
sts_serial| 8| 100000| 300|0.19794588| PASSED
sts_serial| 9| 100000| 300|0.31694204| PASSED
sts_serial| 9| 100000| 300|0.40963719| PASSED
sts_serial| 10| 100000| 300|0.58866464| PASSED
sts_serial| 10| 100000| 300|0.37044609| PASSED
sts_serial| 11| 100000| 300|0.90954698| PASSED
sts_serial| 11| 100000| 300|0.93679327| PASSED
sts_serial| 12| 100000| 300|0.16721541| PASSED
sts_serial| 12| 100000| 300|0.29015556| PASSED
sts_serial| 13| 100000| 300|0.98544489| PASSED
sts_serial| 13| 100000| 300|0.49195350| PASSED
sts_serial| 14| 100000| 300|0.40461847| PASSED
sts_serial| 14| 100000| 300|0.15438435| PASSED
sts_serial| 15| 100000| 300|0.51499395| PASSED
sts_serial| 15| 100000| 300|0.48512487| PASSED
sts_serial| 16| 100000| 300|0.55473985| PASSED
sts_serial| 16| 100000| 300|0.99925069| WEAK
sts_serial| 1| 100000| 400|0.91477126| PASSED
sts_serial| 2| 100000| 400|0.15222902| PASSED
sts_serial| 3| 100000| 400|0.96838682| PASSED
sts_serial| 3| 100000| 400|0.37167619| PASSED
sts_serial| 4| 100000| 400|0.54585635| PASSED
sts_serial| 4| 100000| 400|0.40316876| PASSED
sts_serial| 5| 100000| 400|0.36013870| PASSED
sts_serial| 5| 100000| 400|0.41187042| PASSED
sts_serial| 6| 100000| 400|0.61926551| PASSED
sts_serial| 6| 100000| 400|0.47016641| PASSED
sts_serial| 7| 100000| 400|0.01319731| PASSED
sts_serial| 7| 100000| 400|0.02256028| PASSED
sts_serial| 8| 100000| 400|0.89223551| PASSED
sts_serial| 8| 100000| 400|0.44511237| PASSED
sts_serial| 9| 100000| 400|0.13665073| PASSED
sts_serial| 9| 100000| 400|0.81777364| PASSED
sts_serial| 10| 100000| 400|0.35117496| PASSED
sts_serial| 10| 100000| 400|0.32811900| PASSED
sts_serial| 11| 100000| 400|0.51927196| PASSED
sts_serial| 11| 100000| 400|0.46028397| PASSED
sts_serial| 12| 100000| 400|0.56846897| PASSED
sts_serial| 12| 100000| 400|0.40343961| PASSED
sts_serial| 13| 100000| 400|0.67339065| PASSED
sts_serial| 13| 100000| 400|0.07356258| PASSED
sts_serial| 14| 100000| 400|0.99961302| WEAK
sts_serial| 14| 100000| 400|0.39703484| PASSED
sts_serial| 15| 100000| 400|0.93626795| PASSED
sts_serial| 15| 100000| 400|0.34835385| PASSED
sts_serial| 16| 100000| 400|0.89094486| PASSED
sts_serial| 16| 100000| 400|0.94074061| PASSED
sts_serial| 1| 100000| 500|0.99764292| WEAK
sts_serial| 2| 100000| 500|0.10353788| PASSED
sts_serial| 3| 100000| 500|0.92483869| PASSED
sts_serial| 3| 100000| 500|0.58729338| PASSED
sts_serial| 4| 100000| 500|0.43825816| PASSED
sts_serial| 4| 100000| 500|0.50964777| PASSED
sts_serial| 5| 100000| 500|0.68467771| PASSED
sts_serial| 5| 100000| 500|0.35440277| PASSED
sts_serial| 6| 100000| 500|0.72101174| PASSED
sts_serial| 6| 100000| 500|0.85784275| PASSED
sts_serial| 7| 100000| 500|0.01312564| PASSED
sts_serial| 7| 100000| 500|0.01124853| PASSED
sts_serial| 8| 100000| 500|0.68702794| PASSED
sts_serial| 8| 100000| 500|0.14592370| PASSED
sts_serial| 9| 100000| 500|0.40761042| PASSED
sts_serial| 9| 100000| 500|0.74684653| PASSED
sts_serial| 10| 100000| 500|0.38239694| PASSED
sts_serial| 10| 100000| 500|0.46906467| PASSED
sts_serial| 11| 100000| 500|0.66678934| PASSED
sts_serial| 11| 100000| 500|0.95223451| PASSED
sts_serial| 12| 100000| 500|0.19149871| PASSED
sts_serial| 12| 100000| 500|0.22826763| PASSED
sts_serial| 13| 100000| 500|0.79736117| PASSED
sts_serial| 13| 100000| 500|0.31747450| PASSED
sts_serial| 14| 100000| 500|0.98998414| PASSED
sts_serial| 14| 100000| 500|0.27483287| PASSED
sts_serial| 15| 100000| 500|0.91326397| PASSED
sts_serial| 15| 100000| 500|0.24579086| PASSED
sts_serial| 16| 100000| 500|0.93879994| PASSED
sts_serial| 16| 100000| 500|0.83805166| PASSED
sts_serial| 1| 100000| 600|0.78485463| PASSED
sts_serial| 2| 100000| 600|0.32392650| PASSED
sts_serial| 3| 100000| 600|0.91841337| PASSED
sts_serial| 3| 100000| 600|0.41798964| PASSED
sts_serial| 4| 100000| 600|0.54476915| PASSED
sts_serial| 4| 100000| 600|0.40208091| PASSED
sts_serial| 5| 100000| 600|0.66246372| PASSED
sts_serial| 5| 100000| 600|0.42489368| PASSED
sts_serial| 6| 100000| 600|0.43583042| PASSED
sts_serial| 6| 100000| 600|0.31021111| PASSED
sts_serial| 7| 100000| 600|0.00039352| WEAK
sts_serial| 7| 100000| 600|0.00146274| WEAK
sts_serial| 8| 100000| 600|0.44118099| PASSED
sts_serial| 8| 100000| 600|0.07235683| PASSED
sts_serial| 9| 100000| 600|0.44458653| PASSED
sts_serial| 9| 100000| 600|0.81046431| PASSED
sts_serial| 10| 100000| 600|0.51987632| PASSED
sts_serial| 10| 100000| 600|0.87105281| PASSED
sts_serial| 11| 100000| 600|0.67131290| PASSED
sts_serial| 11| 100000| 600|0.85232113| PASSED
sts_serial| 12| 100000| 600|0.18431319| PASSED
sts_serial| 12| 100000| 600|0.11597416| PASSED
sts_serial| 13| 100000| 600|0.72127533| PASSED
sts_serial| 13| 100000| 600|0.16330688| PASSED
sts_serial| 14| 100000| 600|0.93531023| PASSED
sts_serial| 14| 100000| 600|0.17729286| PASSED
sts_serial| 15| 100000| 600|0.85965667| PASSED
sts_serial| 15| 100000| 600|0.44778523| PASSED
sts_serial| 16| 100000| 600|0.92673903| PASSED
sts_serial| 16| 100000| 600|0.56719213| PASSED
sts_serial| 1| 100000| 700|0.94579474| PASSED
sts_serial| 2| 100000| 700|0.08143280| PASSED
sts_serial| 3| 100000| 700|0.81955562| PASSED
sts_serial| 3| 100000| 700|0.80963159| PASSED
sts_serial| 4| 100000| 700|0.33248546| PASSED
sts_serial| 4| 100000| 700|0.59198853| PASSED
sts_serial| 5| 100000| 700|0.73958194| PASSED
sts_serial| 5| 100000| 700|0.43709310| PASSED
sts_serial| 6| 100000| 700|0.96687779| PASSED
sts_serial| 6| 100000| 700|0.68857633| PASSED
sts_serial| 7| 100000| 700|0.00089270| WEAK
sts_serial| 7| 100000| 700|0.00092661| WEAK
sts_serial| 8| 100000| 700|0.66233470| PASSED
sts_serial| 8| 100000| 700|0.13924117| PASSED
sts_serial| 9| 100000| 700|0.30536680| PASSED
sts_serial| 9| 100000| 700|0.80029719| PASSED
sts_serial| 10| 100000| 700|0.64051471| PASSED
sts_serial| 10| 100000| 700|0.83393044| PASSED
sts_serial| 11| 100000| 700|0.62712714| PASSED
sts_serial| 11| 100000| 700|0.91325196| PASSED
sts_serial| 12| 100000| 700|0.43310696| PASSED
sts_serial| 12| 100000| 700|0.34001489| PASSED
sts_serial| 13| 100000| 700|0.52875568| PASSED
sts_serial| 13| 100000| 700|0.14286094| PASSED
sts_serial| 14| 100000| 700|0.93895562| PASSED
sts_serial| 14| 100000| 700|0.29284026| PASSED
sts_serial| 15| 100000| 700|0.56926292| PASSED
sts_serial| 15| 100000| 700|0.74315221| PASSED
sts_serial| 16| 100000| 700|0.92764752| PASSED
sts_serial| 16| 100000| 700|0.97917867| PASSED
sts_serial| 1| 100000| 800|0.99992965| WEAK
sts_serial| 2| 100000| 800|0.30498925| PASSED
sts_serial| 3| 100000| 800|0.47310147| PASSED
sts_serial| 3| 100000| 800|0.55419435| PASSED
sts_serial| 4| 100000| 800|0.27240850| PASSED
sts_serial| 4| 100000| 800|0.76247014| PASSED
sts_serial| 5| 100000| 800|0.53829860| PASSED
sts_serial| 5| 100000| 800|0.67014909| PASSED
sts_serial| 6| 100000| 800|0.99361371| PASSED
sts_serial| 6| 100000| 800|0.72099846| PASSED
sts_serial| 7| 100000| 800|0.00674251| PASSED
sts_serial| 7| 100000| 800|0.00041677| WEAK
sts_serial| 8| 100000| 800|0.84526855| PASSED
sts_serial| 8| 100000| 800|0.08436608| PASSED
sts_serial| 9| 100000| 800|0.64567990| PASSED
sts_serial| 9| 100000| 800|0.77859499| PASSED
sts_serial| 10| 100000| 800|0.89803433| PASSED
sts_serial| 10| 100000| 800|0.97597483| PASSED
sts_serial| 11| 100000| 800|0.75303628| PASSED
sts_serial| 11| 100000| 800|0.70893781| PASSED
sts_serial| 12| 100000| 800|0.29705854| PASSED
sts_serial| 12| 100000| 800|0.33449916| PASSED
sts_serial| 13| 100000| 800|0.61926537| PASSED
sts_serial| 13| 100000| 800|0.08300415| PASSED
sts_serial| 14| 100000| 800|0.80560218| PASSED
sts_serial| 14| 100000| 800|0.07971245| PASSED
sts_serial| 15| 100000| 800|0.34440994| PASSED
sts_serial| 15| 100000| 800|0.86732059| PASSED
sts_serial| 16| 100000| 800|0.93641193| PASSED
sts_serial| 16| 100000| 800|0.99378250| PASSED
sts_serial| 1| 100000| 900|0.97268295| PASSED
sts_serial| 2| 100000| 900|0.26275510| PASSED
sts_serial| 3| 100000| 900|0.15139991| PASSED
sts_serial| 3| 100000| 900|0.27809823| PASSED
sts_serial| 4| 100000| 900|0.15182430| PASSED
sts_serial| 4| 100000| 900|0.63138280| PASSED
sts_serial| 5| 100000| 900|0.63265600| PASSED
sts_serial| 5| 100000| 900|0.42202151| PASSED
sts_serial| 6| 100000| 900|0.89267137| PASSED
sts_serial| 6| 100000| 900|0.83841948| PASSED
sts_serial| 7| 100000| 900|0.05245939| PASSED
sts_serial| 7| 100000| 900|0.00169352| WEAK
sts_serial| 8| 100000| 900|0.87346669| PASSED
sts_serial| 8| 100000| 900|0.10310322| PASSED
sts_serial| 9| 100000| 900|0.75809475| PASSED
sts_serial| 9| 100000| 900|0.90772018| PASSED
sts_serial| 10| 100000| 900|0.99208917| PASSED
sts_serial| 10| 100000| 900|0.80495036| PASSED
sts_serial| 11| 100000| 900|0.58769548| PASSED
sts_serial| 11| 100000| 900|0.34727661| PASSED
sts_serial| 12| 100000| 900|0.12968038| PASSED
sts_serial| 12| 100000| 900|0.34546602| PASSED
sts_serial| 13| 100000| 900|0.44569517| PASSED
sts_serial| 13| 100000| 900|0.26801594| PASSED
sts_serial| 14| 100000| 900|0.48233899| PASSED
sts_serial| 14| 100000| 900|0.19980494| PASSED
sts_serial| 15| 100000| 900|0.66126080| PASSED
sts_serial| 15| 100000| 900|0.72453315| PASSED
sts_serial| 16| 100000| 900|0.91430088| PASSED
sts_serial| 16| 100000| 900|0.87273205| PASSED
sts_serial| 1| 100000| 1000|0.82411233| PASSED
sts_serial| 2| 100000| 1000|0.26998969| PASSED
sts_serial| 3| 100000| 1000|0.14408595| PASSED
sts_serial| 3| 100000| 1000|0.44563640| PASSED
sts_serial| 4| 100000| 1000|0.18231844| PASSED
sts_serial| 4| 100000| 1000|0.41612297| PASSED
sts_serial| 5| 100000| 1000|0.59258354| PASSED
sts_serial| 5| 100000| 1000|0.37009573| PASSED
sts_serial| 6| 100000| 1000|0.97605186| PASSED
sts_serial| 6| 100000| 1000|0.83416557| PASSED
sts_serial| 7| 100000| 1000|0.02783969| PASSED
sts_serial| 7| 100000| 1000|0.00202682| WEAK
sts_serial| 8| 100000| 1000|0.71656832| PASSED
sts_serial| 8| 100000| 1000|0.00813774| PASSED
sts_serial| 9| 100000| 1000|0.46700666| PASSED
sts_serial| 9| 100000| 1000|0.56956917| PASSED
sts_serial| 10| 100000| 1000|0.82740340| PASSED
sts_serial| 10| 100000| 1000|0.77197956| PASSED
sts_serial| 11| 100000| 1000|0.14951925| PASSED
sts_serial| 11| 100000| 1000|0.16565264| PASSED
sts_serial| 12| 100000| 1000|0.05325737| PASSED
sts_serial| 12| 100000| 1000|0.48046528| PASSED
sts_serial| 13| 100000| 1000|0.30264306| PASSED
sts_serial| 13| 100000| 1000|0.48529480| PASSED
sts_serial| 14| 100000| 1000|0.34908410| PASSED
sts_serial| 14| 100000| 1000|0.31098177| PASSED
sts_serial| 15| 100000| 1000|0.42339092| PASSED
sts_serial| 15| 100000| 1000|0.52634295| PASSED
sts_serial| 16| 100000| 1000|0.82317727| PASSED
sts_serial| 16| 100000| 1000|0.91461036| PASSED
sts_serial| 1| 100000| 1100|0.91371549| PASSED
sts_serial| 2| 100000| 1100|0.47206645| PASSED
sts_serial| 3| 100000| 1100|0.06463235| PASSED
sts_serial| 3| 100000| 1100|0.57932876| PASSED
sts_serial| 4| 100000| 1100|0.07286050| PASSED
sts_serial| 4| 100000| 1100|0.29406646| PASSED
sts_serial| 5| 100000| 1100|0.30699003| PASSED
sts_serial| 5| 100000| 1100|0.54070676| PASSED
sts_serial| 6| 100000| 1100|0.71784287| PASSED
sts_serial| 6| 100000| 1100|0.84008280| PASSED
sts_serial| 7| 100000| 1100|0.08586917| PASSED
sts_serial| 7| 100000| 1100|0.00440856| WEAK
sts_serial| 8| 100000| 1100|0.44039805| PASSED
sts_serial| 8| 100000| 1100|0.00565388| PASSED
sts_serial| 9| 100000| 1100|0.37467495| PASSED
sts_serial| 9| 100000| 1100|0.69559816| PASSED
sts_serial| 10| 100000| 1100|0.65886410| PASSED
sts_serial| 10| 100000| 1100|0.95890422| PASSED
sts_serial| 11| 100000| 1100|0.06356606| PASSED
sts_serial| 11| 100000| 1100|0.06560565| PASSED
sts_serial| 12| 100000| 1100|0.04793661| PASSED
sts_serial| 12| 100000| 1100|0.48707844| PASSED
sts_serial| 13| 100000| 1100|0.80661224| PASSED
sts_serial| 13| 100000| 1100|0.14242905| PASSED
sts_serial| 14| 100000| 1100|0.51415682| PASSED
sts_serial| 14| 100000| 1100|0.21942618| PASSED
sts_serial| 15| 100000| 1100|0.20047033| PASSED
sts_serial| 15| 100000| 1100|0.22904578| PASSED
sts_serial| 16| 100000| 1100|0.66874015| PASSED
sts_serial| 16| 100000| 1100|0.94393624| PASSED
sts_serial| 1| 100000| 1200|0.83256312| PASSED
sts_serial| 2| 100000| 1200|0.54502958| PASSED
sts_serial| 3| 100000| 1200|0.30225528| PASSED
sts_serial| 3| 100000| 1200|0.67315402| PASSED
sts_serial| 4| 100000| 1200|0.07155105| PASSED
sts_serial| 4| 100000| 1200|0.18371377| PASSED
sts_serial| 5| 100000| 1200|0.17266011| PASSED
sts_serial| 5| 100000| 1200|0.72410320| PASSED
sts_serial| 6| 100000| 1200|0.50540113| PASSED
sts_serial| 6| 100000| 1200|0.76683179| PASSED
sts_serial| 7| 100000| 1200|0.31259978| PASSED
sts_serial| 7| 100000| 1200|0.00453731| WEAK
sts_serial| 8| 100000| 1200|0.56282680| PASSED
sts_serial| 8| 100000| 1200|0.05513951| PASSED
sts_serial| 9| 100000| 1200|0.62161232| PASSED
sts_serial| 9| 100000| 1200|0.46001506| PASSED
sts_serial| 10| 100000| 1200|0.76817901| PASSED
sts_serial| 10| 100000| 1200|0.93601114| PASSED
sts_serial| 11| 100000| 1200|0.07653136| PASSED
sts_serial| 11| 100000| 1200|0.08153342| PASSED
sts_serial| 12| 100000| 1200|0.14402564| PASSED
sts_serial| 12| 100000| 1200|0.42213918| PASSED
sts_serial| 13| 100000| 1200|0.80226269| PASSED
sts_serial| 13| 100000| 1200|0.34730320| PASSED
sts_serial| 14| 100000| 1200|0.49397783| PASSED
sts_serial| 14| 100000| 1200|0.15008752| PASSED
sts_serial| 15| 100000| 1200|0.17104398| PASSED
sts_serial| 15| 100000| 1200|0.24731581| PASSED
sts_serial| 16| 100000| 1200|0.49367500| PASSED
sts_serial| 16| 100000| 1200|0.82105876| PASSED
sts_serial| 1| 100000| 1300|0.92274318| PASSED
sts_serial| 2| 100000| 1300|0.63805111| PASSED
sts_serial| 3| 100000| 1300|0.36082068| PASSED
sts_serial| 3| 100000| 1300|0.70604654| PASSED
sts_serial| 4| 100000| 1300|0.11335910| PASSED
sts_serial| 4| 100000| 1300|0.21437386| PASSED
sts_serial| 5| 100000| 1300|0.29961043| PASSED
sts_serial| 5| 100000| 1300|0.63716795| PASSED
sts_serial| 6| 100000| 1300|0.37024703| PASSED
sts_serial| 6| 100000| 1300|0.65282461| PASSED
sts_serial| 7| 100000| 1300|0.24149584| PASSED
sts_serial| 7| 100000| 1300|0.00301040| WEAK
sts_serial| 8| 100000| 1300|0.34119283| PASSED
sts_serial| 8| 100000| 1300|0.03534010| PASSED
sts_serial| 9| 100000| 1300|0.30884092| PASSED
sts_serial| 9| 100000| 1300|0.18952870| PASSED
sts_serial| 10| 100000| 1300|0.63752445| PASSED
sts_serial| 10| 100000| 1300|0.42766349| PASSED
sts_serial| 11| 100000| 1300|0.04311184| PASSED
sts_serial| 11| 100000| 1300|0.11501413| PASSED
sts_serial| 12| 100000| 1300|0.16731505| PASSED
sts_serial| 12| 100000| 1300|0.60143648| PASSED
sts_serial| 13| 100000| 1300|0.60826059| PASSED
sts_serial| 13| 100000| 1300|0.53157449| PASSED
sts_serial| 14| 100000| 1300|0.43211642| PASSED
sts_serial| 14| 100000| 1300|0.19293483| PASSED
sts_serial| 15| 100000| 1300|0.12771534| PASSED
sts_serial| 15| 100000| 1300|0.30582300| PASSED
sts_serial| 16| 100000| 1300|0.63225566| PASSED
sts_serial| 16| 100000| 1300|0.93152615| PASSED
sts_serial| 1| 100000| 1400|0.77736273| PASSED
sts_serial| 2| 100000| 1400|0.56918231| PASSED
sts_serial| 3| 100000| 1400|0.55055131| PASSED
sts_serial| 3| 100000| 1400|0.81925225| PASSED
sts_serial| 4| 100000| 1400|0.17224631| PASSED
sts_serial| 4| 100000| 1400|0.31339860| PASSED
sts_serial| 5| 100000| 1400|0.32544492| PASSED
sts_serial| 5| 100000| 1400|0.52238003| PASSED
sts_serial| 6| 100000| 1400|0.56629527| PASSED
sts_serial| 6| 100000| 1400|0.69243979| PASSED
sts_serial| 7| 100000| 1400|0.08242956| PASSED
sts_serial| 7| 100000| 1400|0.00057844| WEAK
sts_serial| 8| 100000| 1400|0.39479926| PASSED
sts_serial| 8| 100000| 1400|0.04064990| PASSED
sts_serial| 9| 100000| 1400|0.40248037| PASSED
sts_serial| 9| 100000| 1400|0.18754970| PASSED
sts_serial| 10| 100000| 1400|0.48319195| PASSED
sts_serial| 10| 100000| 1400|0.43277261| PASSED
sts_serial| 11| 100000| 1400|0.06813786| PASSED
sts_serial| 11| 100000| 1400|0.15420448| PASSED
sts_serial| 12| 100000| 1400|0.39617325| PASSED
sts_serial| 12| 100000| 1400|0.45351934| PASSED
sts_serial| 13| 100000| 1400|0.74529191| PASSED
sts_serial| 13| 100000| 1400|0.61146146| PASSED
sts_serial| 14| 100000| 1400|0.47009628| PASSED
sts_serial| 14| 100000| 1400|0.21393676| PASSED
sts_serial| 15| 100000| 1400|0.12323527| PASSED
sts_serial| 15| 100000| 1400|0.31276375| PASSED
sts_serial| 16| 100000| 1400|0.75635646| PASSED
sts_serial| 16| 100000| 1400|0.94133178| PASSED
sts_serial| 1| 100000| 1500|0.81000036| PASSED
sts_serial| 2| 100000| 1500|0.98236363| PASSED
sts_serial| 3| 100000| 1500|0.72644430| PASSED
sts_serial| 3| 100000| 1500|0.90972061| PASSED
sts_serial| 4| 100000| 1500|0.32339138| PASSED
sts_serial| 4| 100000| 1500|0.55759988| PASSED
sts_serial| 5| 100000| 1500|0.54408244| PASSED
sts_serial| 5| 100000| 1500|0.46032452| PASSED
sts_serial| 6| 100000| 1500|0.69297720| PASSED
sts_serial| 6| 100000| 1500|0.64094130| PASSED
sts_serial| 7| 100000| 1500|0.05381328| PASSED
sts_serial| 7| 100000| 1500|0.00173982| WEAK
sts_serial| 8| 100000| 1500|0.39892360| PASSED
sts_serial| 8| 100000| 1500|0.02143211| PASSED
sts_serial| 9| 100000| 1500|0.35289759| PASSED
sts_serial| 9| 100000| 1500|0.20117257| PASSED
sts_serial| 10| 100000| 1500|0.56342408| PASSED
sts_serial| 10| 100000| 1500|0.27142404| PASSED
sts_serial| 11| 100000| 1500|0.04509473| PASSED
sts_serial| 11| 100000| 1500|0.01492224| PASSED
sts_serial| 12| 100000| 1500|0.53370220| PASSED
sts_serial| 12| 100000| 1500|0.47791977| PASSED
sts_serial| 13| 100000| 1500|0.89187219| PASSED
sts_serial| 13| 100000| 1500|0.51447055| PASSED
sts_serial| 14| 100000| 1500|0.43332804| PASSED
sts_serial| 14| 100000| 1500|0.31753356| PASSED
sts_serial| 15| 100000| 1500|0.18918418| PASSED
sts_serial| 15| 100000| 1500|0.43101496| PASSED
sts_serial| 16| 100000| 1500|0.93716939| PASSED
sts_serial| 16| 100000| 1500|0.86733760| PASSED
sts_serial| 1| 100000| 1600|0.76184902| PASSED
sts_serial| 2| 100000| 1600|0.99915613| WEAK
sts_serial| 3| 100000| 1600|0.76666027| PASSED
sts_serial| 3| 100000| 1600|0.92478197| PASSED
sts_serial| 4| 100000| 1600|0.47692755| PASSED
sts_serial| 4| 100000| 1600|0.46847946| PASSED
sts_serial| 5| 100000| 1600|0.78978912| PASSED
sts_serial| 5| 100000| 1600|0.25192213| PASSED
sts_serial| 6| 100000| 1600|0.73932074| PASSED
sts_serial| 6| 100000| 1600|0.59158050| PASSED
sts_serial| 7| 100000| 1600|0.04622548| PASSED
sts_serial| 7| 100000| 1600|0.00124978| WEAK
sts_serial| 8| 100000| 1600|0.32313708| PASSED
sts_serial| 8| 100000| 1600|0.00804022| PASSED
sts_serial| 9| 100000| 1600|0.42206573| PASSED
sts_serial| 9| 100000| 1600|0.39843716| PASSED
sts_serial| 10| 100000| 1600|0.49478862| PASSED
sts_serial| 10| 100000| 1600|0.49202955| PASSED
sts_serial| 11| 100000| 1600|0.02973993| PASSED
sts_serial| 11| 100000| 1600|0.01946525| PASSED
sts_serial| 12| 100000| 1600|0.39044990| PASSED
sts_serial| 12| 100000| 1600|0.38913968| PASSED
sts_serial| 13| 100000| 1600|0.95788218| PASSED
sts_serial| 13| 100000| 1600|0.35178639| PASSED
sts_serial| 14| 100000| 1600|0.56114226| PASSED
sts_serial| 14| 100000| 1600|0.40303996| PASSED
sts_serial| 15| 100000| 1600|0.12277171| PASSED
sts_serial| 15| 100000| 1600|0.43726352| PASSED
sts_serial| 16| 100000| 1600|0.88618219| PASSED
sts_serial| 16| 100000| 1600|0.78861412| PASSED
sts_serial| 1| 100000| 1700|0.63181734| PASSED
sts_serial| 2| 100000| 1700|0.99365384| PASSED
sts_serial| 3| 100000| 1700|0.71641322| PASSED
sts_serial| 3| 100000| 1700|0.70347035| PASSED
sts_serial| 4| 100000| 1700|0.62243769| PASSED
sts_serial| 4| 100000| 1700|0.49733460| PASSED
sts_serial| 5| 100000| 1700|0.83027883| PASSED
sts_serial| 5| 100000| 1700|0.29310567| PASSED
sts_serial| 6| 100000| 1700|0.70140417| PASSED
sts_serial| 6| 100000| 1700|0.52144357| PASSED
sts_serial| 7| 100000| 1700|0.04266698| PASSED
sts_serial| 7| 100000| 1700|0.00149197| WEAK
sts_serial| 8| 100000| 1700|0.30610432| PASSED
sts_serial| 8| 100000| 1700|0.00934316| PASSED
sts_serial| 9| 100000| 1700|0.54878347| PASSED
sts_serial| 9| 100000| 1700|0.60752522| PASSED
sts_serial| 10| 100000| 1700|0.43286110| PASSED
sts_serial| 10| 100000| 1700|0.45373918| PASSED
sts_serial| 11| 100000| 1700|0.07602053| PASSED
sts_serial| 11| 100000| 1700|0.04644017| PASSED
sts_serial| 12| 100000| 1700|0.50105416| PASSED
sts_serial| 12| 100000| 1700|0.59916935| PASSED
sts_serial| 13| 100000| 1700|0.71681850| PASSED
sts_serial| 13| 100000| 1700|0.30969231| PASSED
sts_serial| 14| 100000| 1700|0.88845616| PASSED
sts_serial| 14| 100000| 1700|0.60075207| PASSED
sts_serial| 15| 100000| 1700|0.20434702| PASSED
sts_serial| 15| 100000| 1700|0.48959599| PASSED
sts_serial| 16| 100000| 1700|0.98447746| PASSED
sts_serial| 16| 100000| 1700|0.83867799| PASSED
sts_serial| 1| 100000| 1800|0.58627801| PASSED
sts_serial| 2| 100000| 1800|0.98011063| PASSED
sts_serial| 3| 100000| 1800|0.77687580| PASSED
sts_serial| 3| 100000| 1800|0.73110104| PASSED
sts_serial| 4| 100000| 1800|0.47989786| PASSED
sts_serial| 4| 100000| 1800|0.45100274| PASSED
sts_serial| 5| 100000| 1800|0.83153314| PASSED
sts_serial| 5| 100000| 1800|0.33507173| PASSED
sts_serial| 6| 100000| 1800|0.36943890| PASSED
sts_serial| 6| 100000| 1800|0.45533320| PASSED
sts_serial| 7| 100000| 1800|0.04772195| PASSED
sts_serial| 7| 100000| 1800|0.00223851| WEAK
sts_serial| 8| 100000| 1800|0.54716709| PASSED
sts_serial| 8| 100000| 1800|0.01703973| PASSED
sts_serial| 9| 100000| 1800|0.59021583| PASSED
sts_serial| 9| 100000| 1800|0.30023970| PASSED
sts_serial| 10| 100000| 1800|0.29010593| PASSED
sts_serial| 10| 100000| 1800|0.27946468| PASSED
sts_serial| 11| 100000| 1800|0.09680659| PASSED
sts_serial| 11| 100000| 1800|0.03906677| PASSED
sts_serial| 12| 100000| 1800|0.32254234| PASSED
sts_serial| 12| 100000| 1800|0.49988569| PASSED
sts_serial| 13| 100000| 1800|0.57219382| PASSED
sts_serial| 13| 100000| 1800|0.29760085| PASSED
sts_serial| 14| 100000| 1800|0.81229863| PASSED
sts_serial| 14| 100000| 1800|0.69796981| PASSED
sts_serial| 15| 100000| 1800|0.44633976| PASSED
sts_serial| 15| 100000| 1800|0.27286585| PASSED
sts_serial| 16| 100000| 1800|0.96307867| PASSED
sts_serial| 16| 100000| 1800|0.72486610| PASSED
sts_serial| 1| 100000| 1900|0.75862642| PASSED
sts_serial| 2| 100000| 1900|0.97508292| PASSED
sts_serial| 3| 100000| 1900|0.57052065| PASSED
sts_serial| 3| 100000| 1900|0.90572245| PASSED
sts_serial| 4| 100000| 1900|0.38913217| PASSED
sts_serial| 4| 100000| 1900|0.58588475| PASSED
sts_serial| 5| 100000| 1900|0.88828104| PASSED
sts_serial| 5| 100000| 1900|0.31880379| PASSED
sts_serial| 6| 100000| 1900|0.36276708| PASSED
sts_serial| 6| 100000| 1900|0.51418500| PASSED
sts_serial| 7| 100000| 1900|0.05268077| PASSED
sts_serial| 7| 100000| 1900|0.00210539| WEAK
sts_serial| 8| 100000| 1900|0.73113743| PASSED
sts_serial| 8| 100000| 1900|0.01971416| PASSED
sts_serial| 9| 100000| 1900|0.66459759| PASSED
sts_serial| 9| 100000| 1900|0.22773934| PASSED
sts_serial| 10| 100000| 1900|0.44611405| PASSED
sts_serial| 10| 100000| 1900|0.21677275| PASSED
sts_serial| 11| 100000| 1900|0.06766129| PASSED
sts_serial| 11| 100000| 1900|0.02085774| PASSED
sts_serial| 12| 100000| 1900|0.23775078| PASSED
sts_serial| 12| 100000| 1900|0.49416831| PASSED
sts_serial| 13| 100000| 1900|0.66510739| PASSED
sts_serial| 13| 100000| 1900|0.22445717| PASSED
sts_serial| 14| 100000| 1900|0.70173255| PASSED
sts_serial| 14| 100000| 1900|0.58186778| PASSED
sts_serial| 15| 100000| 1900|0.37810628| PASSED
sts_serial| 15| 100000| 1900|0.19459492| PASSED
sts_serial| 16| 100000| 1900|0.99092844| PASSED
sts_serial| 16| 100000| 1900|0.72455520| PASSED
sts_serial| 1| 100000| 2000|0.50185498| PASSED
sts_serial| 2| 100000| 2000|0.94671319| PASSED
sts_serial| 3| 100000| 2000|0.49494481| PASSED
sts_serial| 3| 100000| 2000|0.96843881| PASSED
sts_serial| 4| 100000| 2000|0.34386068| PASSED
sts_serial| 4| 100000| 2000|0.36958380| PASSED
sts_serial| 5| 100000| 2000|0.70726676| PASSED
sts_serial| 5| 100000| 2000|0.35828509| PASSED
sts_serial| 6| 100000| 2000|0.35570236| PASSED
sts_serial| 6| 100000| 2000|0.59079599| PASSED
sts_serial| 7| 100000| 2000|0.04513913| PASSED
sts_serial| 7| 100000| 2000|0.00199436| WEAK
sts_serial| 8| 100000| 2000|0.74561405| PASSED
sts_serial| 8| 100000| 2000|0.01336202| PASSED
sts_serial| 9| 100000| 2000|0.57185834| PASSED
sts_serial| 9| 100000| 2000|0.24424734| PASSED
sts_serial| 10| 100000| 2000|0.49247842| PASSED
sts_serial| 10| 100000| 2000|0.18455062| PASSED
sts_serial| 11| 100000| 2000|0.10555616| PASSED
sts_serial| 11| 100000| 2000|0.01363137| PASSED
sts_serial| 12| 100000| 2000|0.23290045| PASSED
sts_serial| 12| 100000| 2000|0.37989284| PASSED
sts_serial| 13| 100000| 2000|0.85301514| PASSED
sts_serial| 13| 100000| 2000|0.24974837| PASSED
sts_serial| 14| 100000| 2000|0.57041912| PASSED
sts_serial| 14| 100000| 2000|0.47576450| PASSED
sts_serial| 15| 100000| 2000|0.35127341| PASSED
sts_serial| 15| 100000| 2000|0.10414440| PASSED
sts_serial| 16| 100000| 2000|0.98328739| PASSED
sts_serial| 16| 100000| 2000|0.79169835| PASSED
sts_serial| 1| 100000| 2100|0.47490098| PASSED
sts_serial| 2| 100000| 2100|0.84414482| PASSED
sts_serial| 3| 100000| 2100|0.50143598| PASSED
sts_serial| 3| 100000| 2100|0.95422605| PASSED
sts_serial| 4| 100000| 2100|0.37916453| PASSED
sts_serial| 4| 100000| 2100|0.30775747| PASSED
sts_serial| 5| 100000| 2100|0.56741394| PASSED
sts_serial| 5| 100000| 2100|0.56506493| PASSED
sts_serial| 6| 100000| 2100|0.28592773| PASSED
sts_serial| 6| 100000| 2100|0.52026019| PASSED
sts_serial| 7| 100000| 2100|0.09699332| PASSED
sts_serial| 7| 100000| 2100|0.00299178| WEAK
sts_serial| 8| 100000| 2100|0.81269842| PASSED
sts_serial| 8| 100000| 2100|0.02348495| PASSED
sts_serial| 9| 100000| 2100|0.62895590| PASSED
sts_serial| 9| 100000| 2100|0.19754659| PASSED
sts_serial| 10| 100000| 2100|0.71972641| PASSED
sts_serial| 10| 100000| 2100|0.22902343| PASSED
sts_serial| 11| 100000| 2100|0.09595733| PASSED
sts_serial| 11| 100000| 2100|0.00718452| PASSED
sts_serial| 12| 100000| 2100|0.23922763| PASSED
sts_serial| 12| 100000| 2100|0.52839650| PASSED
sts_serial| 13| 100000| 2100|0.90758620| PASSED
sts_serial| 13| 100000| 2100|0.30996045| PASSED
sts_serial| 14| 100000| 2100|0.55852599| PASSED
sts_serial| 14| 100000| 2100|0.44590008| PASSED
sts_serial| 15| 100000| 2100|0.32624015| PASSED
sts_serial| 15| 100000| 2100|0.09377023| PASSED
sts_serial| 16| 100000| 2100|0.98865059| PASSED
sts_serial| 16| 100000| 2100|0.59357838| PASSED
sts_serial| 1| 100000| 2200|0.44918609| PASSED
sts_serial| 2| 100000| 2200|0.80728270| PASSED
sts_serial| 3| 100000| 2200|0.61163760| PASSED
sts_serial| 3| 100000| 2200|0.99877518| WEAK
sts_serial| 4| 100000| 2200|0.32402755| PASSED
sts_serial| 4| 100000| 2200|0.50853106| PASSED
sts_serial| 5| 100000| 2200|0.57173050| PASSED
sts_serial| 5| 100000| 2200|0.74843643| PASSED
sts_serial| 6| 100000| 2200|0.58043723| PASSED
sts_serial| 6| 100000| 2200|0.76916150| PASSED
sts_serial| 7| 100000| 2200|0.15306859| PASSED
sts_serial| 7| 100000| 2200|0.00580800| PASSED
sts_serial| 8| 100000| 2200|0.80843841| PASSED
sts_serial| 8| 100000| 2200|0.03071090| PASSED
sts_serial| 9| 100000| 2200|0.68316272| PASSED
sts_serial| 9| 100000| 2200|0.27354677| PASSED
sts_serial| 10| 100000| 2200|0.82402928| PASSED
sts_serial| 10| 100000| 2200|0.27790257| PASSED
sts_serial| 11| 100000| 2200|0.09262009| PASSED
sts_serial| 11| 100000| 2200|0.01086558| PASSED
sts_serial| 12| 100000| 2200|0.24453638| PASSED
sts_serial| 12| 100000| 2200|0.52323854| PASSED
sts_serial| 13| 100000| 2200|0.88898826| PASSED
sts_serial| 13| 100000| 2200|0.29584341| PASSED
sts_serial| 14| 100000| 2200|0.59752375| PASSED
sts_serial| 14| 100000| 2200|0.39102616| PASSED
sts_serial| 15| 100000| 2200|0.43704260| PASSED
sts_serial| 15| 100000| 2200|0.13260799| PASSED
sts_serial| 16| 100000| 2200|0.99015086| PASSED
sts_serial| 16| 100000| 2200|0.52197271| PASSED
sts_serial| 1| 100000| 2300|0.44755305| PASSED
sts_serial| 2| 100000| 2300|0.86508985| PASSED
sts_serial| 3| 100000| 2300|0.70274787| PASSED
sts_serial| 3| 100000| 2300|0.98228774| PASSED
sts_serial| 4| 100000| 2300|0.32533810| PASSED
sts_serial| 4| 100000| 2300|0.42352819| PASSED
sts_serial| 5| 100000| 2300|0.58385424| PASSED
sts_serial| 5| 100000| 2300|0.78151515| PASSED
sts_serial| 6| 100000| 2300|0.72391324| PASSED
sts_serial| 6| 100000| 2300|0.61981085| PASSED
sts_serial| 7| 100000| 2300|0.15893656| PASSED
sts_serial| 7| 100000| 2300|0.01481637| PASSED
sts_serial| 8| 100000| 2300|0.83467699| PASSED
sts_serial| 8| 100000| 2300|0.03116149| PASSED
sts_serial| 9| 100000| 2300|0.72801965| PASSED
sts_serial| 9| 100000| 2300|0.20434985| PASSED
sts_serial| 10| 100000| 2300|0.79508708| PASSED
sts_serial| 10| 100000| 2300|0.25943233| PASSED
sts_serial| 11| 100000| 2300|0.05806935| PASSED
sts_serial| 11| 100000| 2300|0.01133229| PASSED
sts_serial| 12| 100000| 2300|0.32280893| PASSED
sts_serial| 12| 100000| 2300|0.46947576| PASSED
sts_serial| 13| 100000| 2300|0.91825546| PASSED
sts_serial| 13| 100000| 2300|0.30479787| PASSED
sts_serial| 14| 100000| 2300|0.50360900| PASSED
sts_serial| 14| 100000| 2300|0.24722754| PASSED
sts_serial| 15| 100000| 2300|0.51102753| PASSED
sts_serial| 15| 100000| 2300|0.07958363| PASSED
sts_serial| 16| 100000| 2300|0.99087437| PASSED
sts_serial| 16| 100000| 2300|0.86245064| PASSED
rgb_bitdist| 1| 100000| 100|0.84299386| PASSED
rgb_bitdist| 2| 100000| 100|0.77136192| PASSED
rgb_bitdist| 3| 100000| 100|0.16094576| PASSED
rgb_bitdist| 4| 100000| 100|0.82786506| PASSED
rgb_bitdist| 5| 100000| 100|0.65614955| PASSED
rgb_bitdist| 6| 100000| 100|0.20409618| PASSED
rgb_bitdist| 7| 100000| 100|0.51982583| PASSED
rgb_bitdist| 8| 100000| 100|0.57119684| PASSED
rgb_bitdist| 9| 100000| 100|0.93699028| PASSED
rgb_bitdist| 10| 100000| 100|0.14851199| PASSED
rgb_bitdist| 11| 100000| 100|0.32072911| PASSED
rgb_bitdist| 12| 100000| 100|0.71985848| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.58669648| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.70067921| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.56029570| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.03218202| PASSED
rgb_permutations| 2| 100000| 100|0.10089228| PASSED
rgb_permutations| 3| 100000| 100|0.81993233| PASSED
rgb_permutations| 4| 100000| 100|0.35169436| PASSED
rgb_permutations| 5| 100000| 100|0.95915086| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.47547304| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.99764818| WEAK
rgb_lagged_sum| 1| 1000000| 200|0.59742695| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.09261855| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.94553898| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.99708960| WEAK
rgb_lagged_sum| 4| 1000000| 200|0.30445032| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.17537517| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.68796973| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.23050463| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.19961188| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.25228769| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.33034369| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.96894967| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.22687060| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.06439499| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.78703319| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.37057974| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.72612544| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.98517311| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.74679052| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.89983005| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.40325651| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.45127906| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.25602012| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.45346967| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.73107982| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.46672596| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.77836826| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.87491781| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.94292289| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.95504266| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.22599821| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.69815285| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.08943179| PASSED
rgb_kstest_test| 0| 10000| 1000|0.20323250| PASSED
dab_bytedistrib| 0| 51200000| 1|0.23346032| PASSED
dab_dct| 256| 50000| 1|0.02458160| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.10654186| PASSED
dab_filltree| 32| 15000000| 1|0.98020536| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.44472851| PASSED
dab_filltree2| 1| 5000000| 1|0.80526071| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.91826083| PASSED
#
# Test duration: 158.92324526918335 minutes
#

175
src/site/resources/txt/userguide/rng/stress/dh/run_2/dh_9 Normal file
View File

@ -0,0 +1,175 @@
#
# RNG: org.apache.commons.math4.rng.internal.source32.ISAACRandom
#
# Java: 1.8.0_66
# Runtime: 1.8.0_66-b17
# JVM: Java HotSpot(TM) 64-Bit Server VM 25.66-b17
# OS: Linux 3.16.0-4-amd64 amd64
#
# Analyzer: /usr/bin/dieharder -a -g 200 -Y 1 -k 2
#
#=============================================================================#
# dieharder version 3.31.1 Copyright 2003 Robert G. Brown #
#=============================================================================#
rng_name |rands/second| Seed |
stdin_input_raw| 1.18e+07 | 497564842|
#=============================================================================#
test_name |ntup| tsamples |psamples| p-value |Assessment
#=============================================================================#
diehard_birthdays| 0| 100| 100|0.35374914| PASSED
diehard_operm5| 0| 1000000| 100|0.59069448| PASSED
diehard_rank_32x32| 0| 40000| 100|0.43612131| PASSED
diehard_rank_6x8| 0| 100000| 100|0.74197773| PASSED
diehard_bitstream| 0| 2097152| 100|0.83750479| PASSED
diehard_opso| 0| 2097152| 100|0.31158581| PASSED
diehard_oqso| 0| 2097152| 100|0.84060093| PASSED
diehard_dna| 0| 2097152| 100|0.42145904| PASSED
diehard_count_1s_str| 0| 256000| 100|0.71132913| PASSED
diehard_count_1s_byt| 0| 256000| 100|0.70714491| PASSED
diehard_parking_lot| 0| 12000| 100|0.54683180| PASSED
diehard_2dsphere| 2| 8000| 100|0.28081789| PASSED
diehard_3dsphere| 3| 4000| 100|0.78254047| PASSED
diehard_squeeze| 0| 100000| 100|0.92143241| PASSED
diehard_sums| 0| 100| 100|0.00010924| WEAK
diehard_sums| 0| 100| 200|0.00003613| WEAK
diehard_sums| 0| 100| 300|0.00013445| WEAK
diehard_sums| 0| 100| 400|0.00010952| WEAK
diehard_sums| 0| 100| 500|0.00000919| WEAK
diehard_sums| 0| 100| 600|0.00000165| WEAK
diehard_sums| 0| 100| 700|0.00000016| FAILED
diehard_runs| 0| 100000| 100|0.34008263| PASSED
diehard_runs| 0| 100000| 100|0.00670337| PASSED
diehard_craps| 0| 200000| 100|0.93617848| PASSED
diehard_craps| 0| 200000| 100|0.11439052| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.87864160| PASSED
marsaglia_tsang_gcd| 0| 10000000| 100|0.29279911| PASSED
sts_monobit| 1| 100000| 100|0.97322027| PASSED
sts_runs| 2| 100000| 100|0.32151434| PASSED
sts_serial| 1| 100000| 100|0.45816918| PASSED
sts_serial| 2| 100000| 100|0.05693067| PASSED
sts_serial| 3| 100000| 100|0.27177228| PASSED
sts_serial| 3| 100000| 100|0.62784580| PASSED
sts_serial| 4| 100000| 100|0.30933771| PASSED
sts_serial| 4| 100000| 100|0.80494271| PASSED
sts_serial| 5| 100000| 100|0.94943059| PASSED
sts_serial| 5| 100000| 100|0.20993620| PASSED
sts_serial| 6| 100000| 100|0.90542502| PASSED
sts_serial| 6| 100000| 100|0.86467206| PASSED
sts_serial| 7| 100000| 100|0.56421895| PASSED
sts_serial| 7| 100000| 100|0.86877060| PASSED
sts_serial| 8| 100000| 100|0.98525616| PASSED
sts_serial| 8| 100000| 100|0.28527702| PASSED
sts_serial| 9| 100000| 100|0.63916254| PASSED
sts_serial| 9| 100000| 100|0.12606074| PASSED
sts_serial| 10| 100000| 100|0.48519022| PASSED
sts_serial| 10| 100000| 100|0.79594465| PASSED
sts_serial| 11| 100000| 100|0.19871085| PASSED
sts_serial| 11| 100000| 100|0.19029163| PASSED
sts_serial| 12| 100000| 100|0.82889857| PASSED
sts_serial| 12| 100000| 100|0.03457363| PASSED
sts_serial| 13| 100000| 100|0.85973678| PASSED
sts_serial| 13| 100000| 100|0.36479869| PASSED
sts_serial| 14| 100000| 100|0.54213412| PASSED
sts_serial| 14| 100000| 100|0.99810579| WEAK
sts_serial| 15| 100000| 100|0.24295957| PASSED
sts_serial| 15| 100000| 100|0.10399853| PASSED
sts_serial| 16| 100000| 100|0.69927942| PASSED
sts_serial| 16| 100000| 100|0.25609478| PASSED
sts_serial| 1| 100000| 200|0.15012642| PASSED
sts_serial| 2| 100000| 200|0.44808137| PASSED
sts_serial| 3| 100000| 200|0.62375609| PASSED
sts_serial| 3| 100000| 200|0.81806595| PASSED
sts_serial| 4| 100000| 200|0.64167235| PASSED
sts_serial| 4| 100000| 200|0.99198656| PASSED
sts_serial| 5| 100000| 200|0.69024667| PASSED
sts_serial| 5| 100000| 200|0.09311174| PASSED
sts_serial| 6| 100000| 200|0.76046917| PASSED
sts_serial| 6| 100000| 200|0.90897121| PASSED
sts_serial| 7| 100000| 200|0.40768604| PASSED
sts_serial| 7| 100000| 200|0.54661418| PASSED
sts_serial| 8| 100000| 200|0.47518217| PASSED
sts_serial| 8| 100000| 200|0.10192384| PASSED
sts_serial| 9| 100000| 200|0.19074350| PASSED
sts_serial| 9| 100000| 200|0.48858586| PASSED
sts_serial| 10| 100000| 200|0.78976019| PASSED
sts_serial| 10| 100000| 200|0.32778006| PASSED
sts_serial| 11| 100000| 200|0.67548835| PASSED
sts_serial| 11| 100000| 200|0.74458339| PASSED
sts_serial| 12| 100000| 200|0.95546290| PASSED
sts_serial| 12| 100000| 200|0.16110007| PASSED
sts_serial| 13| 100000| 200|0.31546551| PASSED
sts_serial| 13| 100000| 200|0.25978662| PASSED
sts_serial| 14| 100000| 200|0.02736663| PASSED
sts_serial| 14| 100000| 200|0.16251749| PASSED
sts_serial| 15| 100000| 200|0.78060042| PASSED
sts_serial| 15| 100000| 200|0.20094257| PASSED
sts_serial| 16| 100000| 200|0.48697350| PASSED
sts_serial| 16| 100000| 200|0.43392026| PASSED
rgb_bitdist| 1| 100000| 100|0.08388708| PASSED
rgb_bitdist| 2| 100000| 100|0.74624476| PASSED
rgb_bitdist| 3| 100000| 100|0.96873964| PASSED
rgb_bitdist| 4| 100000| 100|0.65143929| PASSED
rgb_bitdist| 5| 100000| 100|0.83496501| PASSED
rgb_bitdist| 6| 100000| 100|0.67105685| PASSED
rgb_bitdist| 7| 100000| 100|0.29809745| PASSED
rgb_bitdist| 8| 100000| 100|0.94043550| PASSED
rgb_bitdist| 9| 100000| 100|0.97347808| PASSED
rgb_bitdist| 10| 100000| 100|0.99348777| PASSED
rgb_bitdist| 11| 100000| 100|0.41763768| PASSED
rgb_bitdist| 12| 100000| 100|0.03098129| PASSED
rgb_minimum_distance| 2| 10000| 1000|0.31530075| PASSED
rgb_minimum_distance| 3| 10000| 1000|0.81456839| PASSED
rgb_minimum_distance| 4| 10000| 1000|0.36921067| PASSED
rgb_minimum_distance| 5| 10000| 1000|0.90733972| PASSED
rgb_permutations| 2| 100000| 100|0.34952033| PASSED
rgb_permutations| 3| 100000| 100|0.43945554| PASSED
rgb_permutations| 4| 100000| 100|0.78184214| PASSED
rgb_permutations| 5| 100000| 100|0.39033347| PASSED
rgb_lagged_sum| 0| 1000000| 100|0.93704275| PASSED
rgb_lagged_sum| 1| 1000000| 100|0.98747394| PASSED
rgb_lagged_sum| 2| 1000000| 100|0.44799883| PASSED
rgb_lagged_sum| 3| 1000000| 100|0.19630019| PASSED
rgb_lagged_sum| 4| 1000000| 100|0.09039870| PASSED
rgb_lagged_sum| 5| 1000000| 100|0.33906385| PASSED
rgb_lagged_sum| 6| 1000000| 100|0.43332179| PASSED
rgb_lagged_sum| 7| 1000000| 100|0.69585324| PASSED
rgb_lagged_sum| 8| 1000000| 100|0.83947414| PASSED
rgb_lagged_sum| 9| 1000000| 100|0.65175667| PASSED
rgb_lagged_sum| 10| 1000000| 100|0.51247847| PASSED
rgb_lagged_sum| 11| 1000000| 100|0.14010074| PASSED
rgb_lagged_sum| 12| 1000000| 100|0.99722066| WEAK
rgb_lagged_sum| 12| 1000000| 200|0.96500133| PASSED
rgb_lagged_sum| 13| 1000000| 100|0.80390216| PASSED
rgb_lagged_sum| 14| 1000000| 100|0.18909264| PASSED
rgb_lagged_sum| 15| 1000000| 100|0.78289464| PASSED
rgb_lagged_sum| 16| 1000000| 100|0.92852678| PASSED
rgb_lagged_sum| 17| 1000000| 100|0.70690359| PASSED
rgb_lagged_sum| 18| 1000000| 100|0.28389751| PASSED
rgb_lagged_sum| 19| 1000000| 100|0.26175376| PASSED
rgb_lagged_sum| 20| 1000000| 100|0.40097449| PASSED
rgb_lagged_sum| 21| 1000000| 100|0.93922485| PASSED
rgb_lagged_sum| 22| 1000000| 100|0.62567689| PASSED
rgb_lagged_sum| 23| 1000000| 100|0.63904120| PASSED
rgb_lagged_sum| 24| 1000000| 100|0.68885659| PASSED
rgb_lagged_sum| 25| 1000000| 100|0.52922307| PASSED
rgb_lagged_sum| 26| 1000000| 100|0.76450329| PASSED
rgb_lagged_sum| 27| 1000000| 100|0.85008648| PASSED
rgb_lagged_sum| 28| 1000000| 100|0.13351208| PASSED
rgb_lagged_sum| 29| 1000000| 100|0.63907788| PASSED
rgb_lagged_sum| 30| 1000000| 100|0.92353327| PASSED
rgb_lagged_sum| 31| 1000000| 100|0.72849039| PASSED
rgb_lagged_sum| 32| 1000000| 100|0.90021014| PASSED
rgb_kstest_test| 0| 10000| 1000|0.60184224| PASSED
dab_bytedistrib| 0| 51200000| 1|0.42241921| PASSED
dab_dct| 256| 50000| 1|0.18173767| PASSED
Preparing to run test 207. ntuple = 0
dab_filltree| 32| 15000000| 1|0.36572673| PASSED
dab_filltree| 32| 15000000| 1|0.69629195| PASSED
Preparing to run test 208. ntuple = 0
dab_filltree2| 0| 5000000| 1|0.27853367| PASSED
dab_filltree2| 1| 5000000| 1|0.50830727| PASSED
Preparing to run test 209. ntuple = 0
dab_monobit2| 12| 65000000| 1|0.85962195| PASSED
#
# Test duration: 147.66484655655 minutes
#

3882
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_1 Normal file
View File

File diff suppressed because it is too large Load Diff

3803
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_10 Normal file
View File

File diff suppressed because it is too large Load Diff

3795
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_11 Normal file
View File

File diff suppressed because it is too large Load Diff

3803
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_12 Normal file
View File

File diff suppressed because it is too large Load Diff

3802
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_13 Normal file
View File

File diff suppressed because it is too large Load Diff

3803
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_2 Normal file
View File

File diff suppressed because it is too large Load Diff

3807
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_3 Normal file
View File

File diff suppressed because it is too large Load Diff

3806
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_4 Normal file
View File

File diff suppressed because it is too large Load Diff

3804
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_5 Normal file
View File

File diff suppressed because it is too large Load Diff

3804
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_6 Normal file
View File

File diff suppressed because it is too large Load Diff

3803
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_7 Normal file
View File

File diff suppressed because it is too large Load Diff

3804
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_8 Normal file
View File

File diff suppressed because it is too large Load Diff

3802
src/site/resources/txt/userguide/rng/stress/tu/run_1/tu_9 Normal file
View File

File diff suppressed because it is too large Load Diff

3879
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_1 Normal file
View File

File diff suppressed because it is too large Load Diff

3803
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_10 Normal file
View File

File diff suppressed because it is too large Load Diff

3795
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_11 Normal file
View File

File diff suppressed because it is too large Load Diff

3795
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_12 Normal file
View File

File diff suppressed because it is too large Load Diff

3795
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_13 Normal file
View File

File diff suppressed because it is too large Load Diff

3803
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_2 Normal file
View File

File diff suppressed because it is too large Load Diff

3808
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_3 Normal file
View File

File diff suppressed because it is too large Load Diff

3805
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_4 Normal file
View File

File diff suppressed because it is too large Load Diff

3804
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_5 Normal file
View File

File diff suppressed because it is too large Load Diff

3803
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_6 Normal file
View File

File diff suppressed because it is too large Load Diff

3803
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_7 Normal file
View File

File diff suppressed because it is too large Load Diff

3803
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_8 Normal file
View File

File diff suppressed because it is too large Load Diff

3795
src/site/resources/txt/userguide/rng/stress/tu/run_2/tu_9 Normal file
View File

File diff suppressed because it is too large Load Diff

1
src/site/site.xml
View File

@ -76,6 +76,7 @@
<item name="Filters" href="/userguide/filter.html"/>
<item name="Machine Learning" href="/userguide/ml.html"/>
<item name="Exceptions" href="/userguide/exceptions.html"/>
<item name="Random Number Generators" href="/userguide/rng.html"/>
</menu>
<head>

7
src/site/xdoc/userguide/index.xml
View File

@ -183,6 +183,13 @@
<li><a href="exceptions.html#a19.4_Features">19.4 Features</a></li>
</ul>
</li>
<li><a href="rng.html">20. Random Number Generators</a>
<ul>
<li><a href="rng.html#a20.1_Overview">20.1 Overview</a></li>
<li><a href="rng.html#a20.2_Performance">20.2 Performance</a></li>
<li><a href="rng.html#a20.3_Quality">20.3 Quality</a></li>
</ul>
</li>
</ul>
</section>

64
src/test/java/org/apache/commons/math4/rng/Providers32ParametricTest.java Normal file
View File

@ -0,0 +1,64 @@
/*
* 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.math4.rng;
import java.util.Arrays;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
/**
* Tests which all 32-bits based generators must pass.
*/
@RunWith(value=Parameterized.class)
public class Providers32ParametricTest {
/** RNG under test. */
private final UniformRandomProvider generator;
/**
* Initializes generator instance.
*
* @param rng RNG to be tested.
*/
public Providers32ParametricTest(ProvidersList.Data data) {
final RandomSource source = data.getSource();
final Object seed = data.getSeed();
final Object[] args = data.getArgs();
generator = RandomSource.create(source, seed, args);
}
@Parameters(name = "{index}: data={0}")
public static Iterable<ProvidersList.Data[]> getList() {
return ProvidersList.list32();
}
@Test
public void testNextBytesChunks() {
final int[] chunkSizes = { 4, 8, 12, 16 };
final int[] chunks = { 1, 2, 3, 4, 5 };
for (int chunkSize : chunkSizes) {
for (int numChunks : chunks) {
ProvidersCommonParametricTest.checkNextBytesChunks(generator,
chunkSize,
numChunks);
}
}
}
}

Some files were not shown because too many files have changed in this diff Show More