001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.commons.math.random;
018
019 import java.util.Random;
020
021 /**
022 * Extension of <code>java.util.Random</code> wrapping a
023 * {@link RandomGenerator}.
024 *
025 * @since 1.1
026 * @version $Revision: 1003886 $ $Date: 2010-10-02 23:04:44 +0200 (sam. 02 oct. 2010) $
027 */
028 public class RandomAdaptor extends Random implements RandomGenerator {
029
030 /** Serializable version identifier. */
031 private static final long serialVersionUID = 2306581345647615033L;
032
033 /** Wrapped randomGenerator instance */
034 private final RandomGenerator randomGenerator;
035
036 /**
037 * Prevent instantiation without a generator argument
038 */
039 @SuppressWarnings("unused")
040 private RandomAdaptor() { randomGenerator = null; }
041
042 /**
043 * Construct a RandomAdaptor wrapping the supplied RandomGenerator.
044 *
045 * @param randomGenerator the wrapped generator
046 */
047 public RandomAdaptor(RandomGenerator randomGenerator) {
048 this.randomGenerator = randomGenerator;
049 }
050
051 /**
052 * Factory method to create a <code>Random</code> using the supplied
053 * <code>RandomGenerator</code>.
054 *
055 * @param randomGenerator wrapped RandomGenerator instance
056 * @return a Random instance wrapping the RandomGenerator
057 */
058 public static Random createAdaptor(RandomGenerator randomGenerator) {
059 return new RandomAdaptor(randomGenerator);
060 }
061
062 /**
063 * Returns the next pseudorandom, uniformly distributed
064 * <code>boolean</code> value from this random number generator's
065 * sequence.
066 *
067 * @return the next pseudorandom, uniformly distributed
068 * <code>boolean</code> value from this random number generator's
069 * sequence
070 */
071 @Override
072 public boolean nextBoolean() {
073 return randomGenerator.nextBoolean();
074 }
075
076 /**
077 * Generates random bytes and places them into a user-supplied
078 * byte array. The number of random bytes produced is equal to
079 * the length of the byte array.
080 *
081 * @param bytes the non-null byte array in which to put the
082 * random bytes
083 */
084 @Override
085 public void nextBytes(byte[] bytes) {
086 randomGenerator.nextBytes(bytes);
087 }
088
089 /**
090 * Returns the next pseudorandom, uniformly distributed
091 * <code>double</code> value between <code>0.0</code> and
092 * <code>1.0</code> from this random number generator's sequence.
093 *
094 * @return the next pseudorandom, uniformly distributed
095 * <code>double</code> value between <code>0.0</code> and
096 * <code>1.0</code> from this random number generator's sequence
097 */
098 @Override
099 public double nextDouble() {
100 return randomGenerator.nextDouble();
101 }
102
103 /**
104 * Returns the next pseudorandom, uniformly distributed <code>float</code>
105 * value between <code>0.0</code> and <code>1.0</code> from this random
106 * number generator's sequence.
107 *
108 * @return the next pseudorandom, uniformly distributed <code>float</code>
109 * value between <code>0.0</code> and <code>1.0</code> from this
110 * random number generator's sequence
111 */
112 @Override
113 public float nextFloat() {
114 return randomGenerator.nextFloat();
115 }
116
117 /**
118 * Returns the next pseudorandom, Gaussian ("normally") distributed
119 * <code>double</code> value with mean <code>0.0</code> and standard
120 * deviation <code>1.0</code> from this random number generator's sequence.
121 *
122 * @return the next pseudorandom, Gaussian ("normally") distributed
123 * <code>double</code> value with mean <code>0.0</code> and
124 * standard deviation <code>1.0</code> from this random number
125 * generator's sequence
126 */
127 @Override
128 public double nextGaussian() {
129 return randomGenerator.nextGaussian();
130 }
131
132 /**
133 * Returns the next pseudorandom, uniformly distributed <code>int</code>
134 * value from this random number generator's sequence.
135 * All 2<font size="-1"><sup>32</sup></font> possible <tt>int</tt> values
136 * should be produced with (approximately) equal probability.
137 *
138 * @return the next pseudorandom, uniformly distributed <code>int</code>
139 * value from this random number generator's sequence
140 */
141 @Override
142 public int nextInt() {
143 return randomGenerator.nextInt();
144 }
145
146 /**
147 * Returns a pseudorandom, uniformly distributed <tt>int</tt> value
148 * between 0 (inclusive) and the specified value (exclusive), drawn from
149 * this random number generator's sequence.
150 *
151 * @param n the bound on the random number to be returned. Must be
152 * positive.
153 * @return a pseudorandom, uniformly distributed <tt>int</tt>
154 * value between 0 (inclusive) and n (exclusive).
155 * @throws IllegalArgumentException if n is not positive.
156 */
157 @Override
158 public int nextInt(int n) {
159 return randomGenerator.nextInt(n);
160 }
161
162 /**
163 * Returns the next pseudorandom, uniformly distributed <code>long</code>
164 * value from this random number generator's sequence. All
165 * 2<font size="-1"><sup>64</sup></font> possible <tt>long</tt> values
166 * should be produced with (approximately) equal probability.
167 *
168 * @return the next pseudorandom, uniformly distributed <code>long</code>
169 *value from this random number generator's sequence
170 */
171 @Override
172 public long nextLong() {
173 return randomGenerator.nextLong();
174 }
175
176 /** {@inheritDoc} */
177 public void setSeed(int seed) {
178 if (randomGenerator != null) { // required to avoid NPE in constructor
179 randomGenerator.setSeed(seed);
180 }
181 }
182
183 /** {@inheritDoc} */
184 public void setSeed(int[] seed) {
185 if (randomGenerator != null) { // required to avoid NPE in constructor
186 randomGenerator.setSeed(seed);
187 }
188 }
189
190 /** {@inheritDoc} */
191 @Override
192 public void setSeed(long seed) {
193 if (randomGenerator != null) { // required to avoid NPE in constructor
194 randomGenerator.setSeed(seed);
195 }
196 }
197
198 }