1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2006-2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala
package util
import scala.collection.mutable.ArrayBuffer
import scala.collection.generic.CanBuildFrom
import scala.collection.immutable.{ List, Stream }
import scala.language.{implicitConversions, higherKinds}
/**
* @author Stephane Micheloud
*
*/
class Random(val self: java.util.Random) extends AnyRef with Serializable {
/** Creates a new random number generator using a single long seed. */
def this(seed: Long) = this(new java.util.Random(seed))
/** Creates a new random number generator using a single integer seed. */
def this(seed: Int) = this(seed.toLong)
/** Creates a new random number generator. */
def this() = this(new java.util.Random())
/** Returns the next pseudorandom, uniformly distributed boolean value
* from this random number generator's sequence.
*/
def nextBoolean(): Boolean = self.nextBoolean()
/** Generates random bytes and places them into a user-supplied byte
* array.
*/
def nextBytes(bytes: Array[Byte]) { self.nextBytes(bytes) }
/** Returns the next pseudorandom, uniformly distributed double value
* between 0.0 and 1.0 from this random number generator's sequence.
*/
def nextDouble(): Double = self.nextDouble()
/** Returns the next pseudorandom, uniformly distributed float value
* between 0.0 and 1.0 from this random number generator's sequence.
*/
def nextFloat(): Float = self.nextFloat()
/** Returns the next pseudorandom, Gaussian ("normally") distributed
* double value with mean 0.0 and standard deviation 1.0 from this
* random number generator's sequence.
*/
def nextGaussian(): Double = self.nextGaussian()
/** Returns the next pseudorandom, uniformly distributed int value
* from this random number generator's sequence.
*/
def nextInt(): Int = self.nextInt()
/** Returns a pseudorandom, uniformly distributed int value between 0
* (inclusive) and the specified value (exclusive), drawn from this
* random number generator's sequence.
*/
def nextInt(n: Int): Int = self.nextInt(n)
/** Returns the next pseudorandom, uniformly distributed long value
* from this random number generator's sequence.
*/
def nextLong(): Long = self.nextLong()
/** Returns a pseudorandomly generated String. This routine does
* not take any measures to preserve the randomness of the distribution
* in the face of factors like unicode's variable-length encoding,
* so please don't use this for anything important. It's primarily
* intended for generating test data.
*
* @param length the desired length of the String
* @return the String
*/
def nextString(length: Int) = {
def safeChar() = {
val surrogateStart: Int = 0xD800
val res = nextInt(surrogateStart - 1) + 1
res.toChar
}
List.fill(length)(safeChar()).mkString
}
/** Returns the next pseudorandom, uniformly distributed value
* from the ASCII range 33-126.
*/
def nextPrintableChar(): Char = {
val low = 33
val high = 127
(self.nextInt(high - low) + low).toChar
}
def setSeed(seed: Long) { self.setSeed(seed) }
/** Returns a new collection of the same type in a randomly chosen order.
*
* @return the shuffled collection
*/
def shuffle[T, CC[X] <: TraversableOnce[X]](xs: CC[T])(implicit bf: CanBuildFrom[CC[T], T, CC[T]]): CC[T] = {
val buf = new ArrayBuffer[T] ++= xs
def swap(i1: Int, i2: Int) {
val tmp = buf(i1)
buf(i1) = buf(i2)
buf(i2) = tmp
}
for (n <- buf.length to 2 by -1) {
val k = nextInt(n)
swap(n - 1, k)
}
(bf(xs) ++= buf).result()
}
@deprecated("Preserved for backwards binary compatibility. To remove in 2.12.x.", "2.11.6")
final def `scala$util$Random$$isAlphaNum$1`(c: Char) = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')
/** Returns a Stream of pseudorandomly chosen alphanumeric characters,
* equally chosen from A-Z, a-z, and 0-9.
*
* @since 2.8
*/
def alphanumeric: Stream[Char] = {
def nextAlphaNum: Char = {
val chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
chars charAt (self nextInt chars.length)
}
Stream continually nextAlphaNum
}
}
/** The object `Random` offers a default implementation
* of scala.util.Random and random-related convenience methods.
*
* @since 2.8
*/
object Random extends Random {
implicit def javaRandomToRandom(r: java.util.Random): Random = new Random(r)
}
|
