Re: random real number between 0 (inclusive) and 1 (inclusive)
Patricia Shanahan wrote:
Daniel Pitts wrote:
Sorry if this is a double post, network problems...
Patricia Shanahan wrote:
Piotr Kobzda wrote:
Patricia Shanahan wrote:
[...]
How about first obtaining a long in the range [0,2^53]. That could be
done by combining the results of a couple of nextInt calls. Then
divide
by (double)(1L << 53).
Or, instead of using nextInt() calls, the following should work as
well:
Random r = new Random() {
public double nextDouble() {
return (((long)(next(26)) << 27) + next(27) + next(1))
/ (double)(1L << 53);
}
};
If you are going to do that you have to extend Random, because next is
protected.
Patricia
He did extend Random.
Although, my argument would be that he shouldn't override nextDouble,
but create a new method, as the new method has different semantics than
the original nextDouble.
Yup, I realized that, and canceled my message just after I sent it, but
cancel does not always catch up :-(
I agree that the new method should be given a different name, because of
the different semantics.
Yes, you are both right. In fact, I have had a different name of that
method in my initial approach, but have changed that for simplicity just
while editing my post.
Of course, the general purpose solution should not change nextDouble()
semantics.
But the problem here is, that the general purpose implementation must
extend the concrete Random implementation (which can not be anonymous
class). The best approach I can think of to achieve that might look as
follows:
public class RandomExtend extends java.util.Random {
public interface BitsProvider {
int nextBits(int numBits);
void setSeed(long seed);
}
protected BitsProvider bitsProvider;
private class DefaultBitsProvider implements BitsProvider {
public final int nextBits(int numBits) {
return RandomExtend.this.defaultNext(numBits);
}
public final void setSeed(long seed) {
RandomExtend.this.defaultSetSeed(seed);
}
}
public RandomExtend() {
super();
this.bitsProvider = new DefaultBitsProvider();
}
public RandomExtend(long seed) {
super(seed);
this.bitsProvider = new DefaultBitsProvider();
}
public RandomExtend(BitsProvider bitsProvider) {
super(0L);
this.bitsProvider = bitsProvider;
}
@Override
protected final int next(int numBits) {
return bitsProvider.nextBits(numBits);
}
@Override
public void setSeed(long seed) {
bitsProvider.setSeed(seed);
}
final int defaultNext(int bits) {
return super.next(bits);
}
final void defaultSetSeed(long seed) {
super.setSeed(seed);
}
public double nextDoubleWith1() {
return (((long)(next(26)) << 27) + next(27) + next(1))
/ (double)(1L << 53);
}
}
Note that the above implementation allows for any concrete Random
support through the use of BitsProvider interface (any Random
implementation, including SecureRandom, even when not extendable may be
supported with that).
However, as you can see, there is much more coding necessary than in the
approach with broken semantics of nextDouble() in anonymous class.
So, is that all extra coding really worth the effort? I think, that
"yes" is not always the only right answer...
piotr