Randomizer

Instance Constructors

new Randomizer(seed: Long)

seed

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def chooseByte(from: Byte, to: Byte): (Byte, Randomizer)

Given a range of Bytes, chooses one of them randomly.
Given a range of Bytes, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseChar(from: Char, to: Char): (Char, Randomizer)

Given a range of Chars, chooses one of them randomly.
Given a range of Chars, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseDouble(from: Double, to: Double): (Double, Randomizer)

Given a range of Doubles, chooses one of them randomly.
Given a range of Doubles, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseFiniteDouble(from: FiniteDouble, to: FiniteDouble): (FiniteDouble, Randomizer)

Given a range of finite Doubles, chooses one of them randomly.
Given a range of finite Doubles, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseFiniteFloat(from: FiniteFloat, to: FiniteFloat): (FiniteFloat, Randomizer)

Given a range of finite Floats, chooses one of them randomly.
Given a range of finite Floats, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseFloat(from: Float, to: Float): (Float, Randomizer)

Given a range of Floats, chooses one of them randomly.
Given a range of Floats, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseInt(from: Int, to: Int): (Int, Randomizer)

Given a range of Ints, chooses one of them randomly.
Given a range of Ints, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseLong(from: Long, to: Long): (Long, Randomizer)

Given a range of Longs, chooses one of them randomly.
Given a range of Longs, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegDouble(from: NegDouble, to: NegDouble): (NegDouble, Randomizer)

Given a range of negative Doubles, chooses one of them randomly.
Given a range of negative Doubles, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegFiniteDouble(from: NegFiniteDouble, to: NegFiniteDouble): (NegFiniteDouble, Randomizer)

Given a range of negative, finite Doubles, chooses one of them randomly.
Given a range of negative, finite Doubles, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegFiniteFloat(from: NegFiniteFloat, to: NegFiniteFloat): (NegFiniteFloat, Randomizer)

Given a range of negative, finite Floats, chooses one of them randomly.
Given a range of negative, finite Floats, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegFloat(from: NegFloat, to: NegFloat): (NegFloat, Randomizer)

Given a range of negative Floats, chooses one of them randomly.
Given a range of negative Floats, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegInt(from: NegInt, to: NegInt): (NegInt, Randomizer)

Given a range of negative Ints, chooses one of them randomly.
Given a range of negative Ints, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegLong(from: NegLong, to: NegLong): (NegLong, Randomizer)

Given a range of negative Longs, chooses one of them randomly.
Given a range of negative Longs, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegZDouble(from: NegZDouble, to: NegZDouble): (NegZDouble, Randomizer)

Given a range of negative Doubles (maybe including zero), chooses one of them randomly.
Given a range of negative Doubles (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegZFiniteDouble(from: NegZFiniteDouble, to: NegZFiniteDouble): (NegZFiniteDouble, Randomizer)

Given a range of negative, finite Doubles (maybe including zero), chooses one of them randomly.
Given a range of negative, finite Doubles (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegZFiniteFloat(from: NegZFiniteFloat, to: NegZFiniteFloat): (NegZFiniteFloat, Randomizer)

Given a range of negative, finite Floats (maybe including zero), chooses one of them randomly.
Given a range of negative, finite Floats (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegZFloat(from: NegZFloat, to: NegZFloat): (NegZFloat, Randomizer)

Given a range of negative Floats (maybe including zero), chooses one of them randomly.
Given a range of negative Floats (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegZInt(from: NegZInt, to: NegZInt): (NegZInt, Randomizer)

Given a range of negative Ints (maybe including zero), chooses one of them randomly.
Given a range of negative Ints (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNegZLong(from: NegZLong, to: NegZLong): (NegZLong, Randomizer)

Given a range of negative Longs (maybe including zero), chooses one of them randomly.
Given a range of negative Longs (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNonZeroDouble(from: NonZeroDouble, to: NonZeroDouble): (NonZeroDouble, Randomizer)

Given a range of Doubles (excluding zero), chooses one of them randomly.
Given a range of Doubles (excluding zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
In order to avoid returning 0, this function is very slightly biased towards returning 1 instead.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNonZeroFiniteDouble(from: NonZeroFiniteDouble, to: NonZeroFiniteDouble): (NonZeroFiniteDouble, Randomizer)

Given a range of finite Doubles (excluding zero), chooses one of them randomly.
Given a range of finite Doubles (excluding zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
In order to avoid returning 0, this function is very slightly biased towards returning 1 instead.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNonZeroFiniteFloat(from: NonZeroFiniteFloat, to: NonZeroFiniteFloat): (NonZeroFiniteFloat, Randomizer)

Given a range of finite Floats (excluding zero), chooses one of them randomly.
Given a range of finite Floats (excluding zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
In order to avoid returning 0, this function is very slightly biased towards returning 1 instead.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNonZeroFloat(from: NonZeroFloat, to: NonZeroFloat): (NonZeroFloat, Randomizer)

Given a range of Floats (excluding zero), chooses one of them randomly.
Given a range of Floats (excluding zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
In order to avoid returning 0, this function is very slightly biased towards returning 1 instead.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNonZeroInt(from: NonZeroInt, to: NonZeroInt): (NonZeroInt, Randomizer)

Given a range of Ints (excluding zero), chooses one of them randomly.
Given a range of Ints (excluding zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
In order to avoid returning 0, this function is very slightly biased towards returning 1 instead.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseNonZeroLong(from: NonZeroLong, to: NonZeroLong): (NonZeroLong, Randomizer)

Given a range of Longs (excluding zero), chooses one of them randomly.
Given a range of Longs (excluding zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
In order to avoid returning 0, this function is very slightly biased towards returning 1 instead.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosDouble(from: PosDouble, to: PosDouble): (PosDouble, Randomizer)

Given a range of positive Doubles, chooses one of them randomly.
Given a range of positive Doubles, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosFiniteDouble(from: PosFiniteDouble, to: PosFiniteDouble): (PosFiniteDouble, Randomizer)

Given a range of positive finite Doubles, chooses one of them randomly.
Given a range of positive finite Doubles, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosFiniteFloat(from: PosFiniteFloat, to: PosFiniteFloat): (PosFiniteFloat, Randomizer)

Given a range of positive, finite Floats, chooses one of them randomly.
Given a range of positive, finite Floats, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosFloat(from: PosFloat, to: PosFloat): (PosFloat, Randomizer)

Given a range of positive Floats, chooses one of them randomly.
Given a range of positive Floats, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosInt(from: PosInt, to: PosInt): (PosInt, Randomizer)

Given a range of positive Ints, chooses one of them randomly.
Given a range of positive Ints, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosLong(from: PosLong, to: PosLong): (PosLong, Randomizer)

Given a range of positive Longs, chooses one of them randomly.
Given a range of positive Longs, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosZDouble(from: PosZDouble, to: PosZDouble): (PosZDouble, Randomizer)

Given a range of positive Doubles (maybe including zero), chooses one of them randomly.
Given a range of positive Doubles (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosZFiniteDouble(from: PosZFiniteDouble, to: PosZFiniteDouble): (PosZFiniteDouble, Randomizer)

Given a range of positive, finite Doubles (maybe including zero), chooses one of them randomly.
Given a range of positive, finite Doubles (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosZFiniteFloat(from: PosZFiniteFloat, to: PosZFiniteFloat): (PosZFiniteFloat, Randomizer)

Given a range of positive, finite Floats (maybe including zero), chooses one of them randomly.
Given a range of positive, finite Floats (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosZFloat(from: PosZFloat, to: PosZFloat): (PosZFloat, Randomizer)

Given a range of positive Floats (maybe including zero), chooses one of them randomly.
Given a range of positive Floats (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosZInt(from: PosZInt, to: PosZInt): (PosZInt, Randomizer)

Given a range of positive Ints (maybe including zero), chooses one of them randomly.
Given a range of positive Ints (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def choosePosZLong(from: PosZLong, to: PosZLong): (PosZLong, Randomizer)

Given a range of positive Longs (maybe including zero), chooses one of them randomly.
Given a range of positive Longs (maybe including zero), chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def chooseShort(from: Short, to: Short): (Short, Randomizer)

Given a range of Shorts, chooses one of them randomly.
Given a range of Shorts, chooses one of them randomly.
Note that, while the from parameter is usually smaller than to, that is not required; the function will cope appropriately if they are in reverse order.
The choice is inclusive: either the from or to values may be returned.
from
One end of the range to select from.
to
The other end of the range.
returns
A value from that range, inclusive of the ends.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def finiteFloatBetweenAlgorithm(between0And1: Float, min: Float, max: Float): Float

Given the endpoints of a finite-Float range, and a scaling factor, this computes the number that far across the range.
Given the endpoints of a finite-Float range, and a scaling factor, this computes the number that far across the range.
This deals with edge cases that can result in infinities in the math.
between0And1
A scaling factor between 0 and 1.
min
The lower end of the range.
max
The upper end of the range.
returns
The Float that is the scaling factor distance across that range.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def next(bits: Int): (Int, Randomizer)

Get a certain number of random bits.
Get a certain number of random bits.
You don't usually call this directly. Instead, call more-specific functions such as nextInt, which calls this for the correct number of bits and then casts that to the desired type.
bits
The number of random bits you need.
returns
The random bits, and the next Randomizer to user.
def nextBit: (Int, Randomizer)

Get a 1 or a 0.
Get a 1 or a 0.
returns
a 1 or 0 as an Int.
def nextByte: (Byte, Randomizer)

Get a random 8-bit Byte.
Get a random 8-bit Byte.
returns
A random Byte, and the next Randomizer to use.
def nextChar: (Char, Randomizer)

Get a random 16-bit Char.
Get a random 16-bit Char.
Note: this intentionally avoids invalid Unicode chars between 0xD800 and 0xDFFF; when one of those is generated, this instead returns a Char between 0x0000 and 0x00FF. So this function slightly favors that first code block. (Which is the most common one in practice, anyway.)
returns
A random Char, and the next Randomizer to use.
def nextDouble: (Double, Randomizer)

Get a random Double.
Get a random Double.
This will randomize the sign, exponent and mantissa, so it can return any possible Double.
returns
A random Double, and the next Randomizer to use.
def nextDoubleBetween0And1: (Double, Randomizer)

Get a random Double between 0 and 1.
Get a random Double between 0 and 1.
When working with Double, you often want a value between 0 and 1 -- this sort of proportion is a common use case for Double. This function makes it easy to grab one.
returns
A random Double in that range, and the next Randomizer to use.
def nextFiniteDouble: (FiniteDouble, Randomizer)

Get a random non-infinite Double.
Get a random non-infinite Double.
This can return either a positive or negative value, or zero, but guards against returning either Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN.
returns
A random finite Double, and the next Randomizer to use.
def nextFiniteFloat: (FiniteFloat, Randomizer)

Get a random non-infinite Float.
Get a random non-infinite Float.
This can return either a positive or negative value, or zero, but guards against returning either Float.PositiveInfinity, Float.NegativeInfinity, or Float.NaN.
returns
A random finite Float, and the next Randomizer to use.
def nextFloat: (Float, Randomizer)

Get a random Float.
Get a random Float.
This will randomize the sign, exponent and mantissa, so it can return any possible Float.
returns
A random Float, and the next Randomizer to use.
def nextFloatBetween0And1: (Float, Randomizer)

Get a random Float between 0 and 1.
Get a random Float between 0 and 1.
When working with Floats, you often want a value between 0 and 1 -- this sort of proportion is one of the more common use cases for Floats. This function makes it easy to grab one.
returns
A random Float in that range, and the next Randomizer to use.
def nextInt: (Int, Randomizer)

Get a random 32-bit Int.
Get a random 32-bit Int.
returns
A random Int, and the next Randomizer to use.
def nextList[T](length: PosZInt)(implicit genOfT: Generator[T]): (List[T], Randomizer)

Get a random list of elements of type T.
Get a random list of elements of type T.
This function requires an implicit parameter that says how to generate values of T, as well as the number of them to generate. (Which may be zero.)
T
The type to generate.
length
How many values to generate for the List.
genOfT
A Generator, that provides values of type T.
returns
A List of values of the desired type.
def nextLong: (Long, Randomizer)

Get a random 64-bit Long.
Get a random 64-bit Long.
returns
A random Long, and the next Randomizer to use.
def nextNegDouble: (NegDouble, Randomizer)

Get a random Double less than zero.
Get a random Double less than zero.
Note: it is possible (although rare) for this to return Double.NegativeInfinity. If you want to avoid that, use nextNegFiniteDouble instead.
returns
A random negative Double, and the next Randomizer to use.
def nextNegFiniteDouble: (NegFiniteDouble, Randomizer)

Get a random Double less than zero.
Get a random Double less than zero.
This guards against returning Double.NegativeInfinity, so you can have confidence that the returned number is real and finite.
returns
A random negative Double, and the next Randomizer to use.
def nextNegFiniteFloat: (NegFiniteFloat, Randomizer)

Get a random Float less than zero.
Get a random Float less than zero.
This guards against returning Float.NegativeInfinity, so you can have confidence that the returned number is real and finite.
returns
A random negative Float, and the next Randomizer to use.
def nextNegFloat: (NegFloat, Randomizer)

Get a random Float less than zero.
Get a random Float less than zero.
Note: it is possible (although rare) for this to return Float.NegativeInfinity. If you want to avoid that, use nextNegFiniteFloat instead.
returns
A random negative Float, and the next Randomizer to use.
def nextNegInt: (NegInt, Randomizer)

Get a random Int less than zero.
Get a random Int less than zero.
returns
A random negative Int, and the next Randomizer to use.
def nextNegLong: (NegLong, Randomizer)

Get a random Long less than zero.
Get a random Long less than zero.
returns
A random negative Long, and the next Randomizer to use.
def nextNegZDouble: (NegZDouble, Randomizer)

Get a random Double less than or equal to zero.
Get a random Double less than or equal to zero.
Note: it is possible (although rare) for this to return Double.NegativeInfinity. If you want to avoid that, use nextNegZFiniteDouble instead.
returns
A random negative-or-zero Double, and the next Randomizer to use.
def nextNegZFiniteDouble: (NegZFiniteDouble, Randomizer)

Get a random Double less than or equal to zero.
Get a random Double less than or equal to zero.
This guards against Double.NegativeInfinity, so it will always return a non-infinite value.
returns
A random negative-or-zero Double, and the next Randomizer to use.
def nextNegZFiniteFloat: (NegZFiniteFloat, Randomizer)

Get a random Float less than or equal to zero.
Get a random Float less than or equal to zero.
This guards against Float.NegativeInfinity, so it will always return a non-infinite value.
returns
A random negative-or-zero Float, and the next Randomizer to use.
def nextNegZFloat: (NegZFloat, Randomizer)

Get a random Float less than or equal to zero.
Get a random Float less than or equal to zero.
Note: it is possible (although rare) for this to return Float.NegativeInfinity. If you want to avoid that, use nextNegZFiniteFloat instead.
returns
A random negative-or-zero Float, and the next Randomizer to use.
def nextNegZInt: (NegZInt, Randomizer)

Get a random Int less than or equal to zero.
Get a random Int less than or equal to zero.
returns
A random negative-or-zero Int, and the next Randomizer to use.
def nextNegZLong: (NegZLong, Randomizer)

Get a random Long less than or equal to zero.
Get a random Long less than or equal to zero.
returns
A random negative-or-zero Long, and the next Randomizer to use.
def nextNonZeroDouble: (NonZeroDouble, Randomizer)

Get a random non-zero Double.
Get a random non-zero Double.
This can return any Double except zero.
Note that this can return infinite values; if you want to avoid that, use nextNonZeroFiniteDouble instead.
returns
A random non-zero Double, and the next Randomizer to use.
def nextNonZeroFiniteDouble: (NonZeroFiniteDouble, Randomizer)

Get a random non-zero Double.
Get a random non-zero Double.
This can return any Double except zero, Double.PositiveInfinity, or Double.NegativeInfinity.
returns
A random non-zero Double, and the next Randomizer to use.
def nextNonZeroFiniteFloat: (NonZeroFiniteFloat, Randomizer)

Get a random non-zero Float.
Get a random non-zero Float.
This can return any Float except zero, Float.PositiveInfinity, or Float.NegativeInfinity.
returns
A random non-zero Float, and the next Randomizer to use.
def nextNonZeroFloat: (NonZeroFloat, Randomizer)

Get a random non-zero Float.
Get a random non-zero Float.
This can return any Float except zero.
Note that this can return infinite values; if you want to avoid that, use nextNonZeroFiniteFloat instead.
returns
A random non-zero Float, and the next Randomizer to use.
def nextNonZeroInt: (NonZeroInt, Randomizer)

Get a random non-zero Int.
Get a random non-zero Int.
This can return any Int except zero.
returns
A random non-zero Int, and the next Randomizer to use.
def nextNonZeroLong: (NonZeroLong, Randomizer)

Get a random non-zero Long.
Get a random non-zero Long.
This can return any Long except zero.
returns
A random non-zero Long, and the next Randomizer to use.
def nextPosDouble: (PosDouble, Randomizer)

Get a random Double greater than zero.
Get a random Double greater than zero.
Note: it is possible (although rare) for this to return Double.PositiveInfinity. If you want to avoid that, use nextPosFiniteDouble instead.
returns
A random positive Double, and the next Randomizer to use.
def nextPosFiniteDouble: (PosFiniteDouble, Randomizer)

Get a random Double greater than zero.
Get a random Double greater than zero.
This guards against returning Double.PositiveInfinity, so you can have confidence that the returned number is real and finite.
returns
A random positive Double, and the next Randomizer to use.
def nextPosFiniteFloat: (PosFiniteFloat, Randomizer)

Get a random, finite Float greater than zero.
Get a random, finite Float greater than zero.
This methods guards against returning Float.PositiveInfinity -- you will always receive a real value.
returns
A random positive Float, and the next Randomizer to use.
def nextPosFloat: (PosFloat, Randomizer)

Get a random Float greater than zero.
Get a random Float greater than zero.
Note: it is possible (although rare) for this to return Float.PositiveInfinity. If you want to avoid that, use nextPosFiniteFloat instead.
returns
A random positive Float, and the next Randomizer to use.
def nextPosInt: (PosInt, Randomizer)

Get a random Integer greater than zero.
Get a random Integer greater than zero.
Note: if the underlying algorithm tries to generate 0, this generates 1, so it is very slightly biased towards returning 1.
returns
A random positive Integer, and the next Randomizer to use.
def nextPosLong: (PosLong, Randomizer)

Get a random Long greater than zero.
Get a random Long greater than zero.
returns
A random positive Long, and the next Randomizer to use.
def nextPosZDouble: (PosZDouble, Randomizer)

Get a random Double greater than or equal to zero.
Get a random Double greater than or equal to zero.
Note: it is possible (although rare) for this to return Double.NegativeInfinity. If you want to avoid that, use nextPosZFiniteDouble instead.
returns
A random positive Double, and the next Randomizer to use.
def nextPosZFiniteDouble: (PosZFiniteDouble, Randomizer)

Get a random Double greater than or equal to zero.
Get a random Double greater than or equal to zero.
This guards against returning Double.NegativeInfinity.
returns
A random negative Double, and the next Randomizer to use.
def nextPosZFiniteFloat: (PosZFiniteFloat, Randomizer)

Get a random Float greater than or equal to zero.
Get a random Float greater than or equal to zero.
This guards against returning Float.PositiveInfinity.
returns
A random positive Float, and the next Randomizer to use.
def nextPosZFloat: (PosZFloat, Randomizer)

Get a random Float greater than or equal to zero.
Get a random Float greater than or equal to zero.
Note: it is possible (although rare) for this to return Float.PositiveInfinity. If you want to avoid that, use nextPosZFiniteFloat instead.
returns
A random positive Float, and the next Randomizer to use.
def nextPosZInt: (PosZInt, Randomizer)

Get a random Integer greater than or equal to zero.
Get a random Integer greater than or equal to zero.
returns
A random positive Integer (or zero), and the next Randomizer to use.
def nextPosZLong: (PosZLong, Randomizer)

Get a random Long greater than or equal to zero.
Get a random Long greater than or equal to zero.
returns
A random positive Long (or zero), and the next Randomizer to use.
def nextRandomizer: Randomizer

Computes the next Randomizer to use.
Computes the next Randomizer to use.
Since Randomizer is immutable (and would thus return the same value over and over), you don't usually use the same instance more than once. Instead, you should fetch the next one, and use that for the next operation.
You usually don't need to call this directly; instead, the next Randomizer is returned from each operation, along with the random value.
returns
The next Randomizer, ready to use.
def nextShort: (Short, Randomizer)

Get a random 16-bit Short.
Get a random 16-bit Short.
returns
A random Short, and the next Randomizer to use.
def nextString(length: PosZInt): (String, Randomizer)

Get a random String.
Get a random String.
This takes a desired length, and generates a String of that length. Do not expect this String to make any sense -- it is literally just a string of random Unicode characters, and will typically contain little or no conventional ASCII.
length
The number of characters to include in the String.
returns
A highly-random String of the specified length, and the next Randomizer to use.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

class Randomizer extends AnyRef

Instance Constructors

new Randomizer(seed: Long)

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def chooseByte(from: Byte, to: Byte): (Byte, Randomizer)

def chooseChar(from: Char, to: Char): (Char, Randomizer)

def chooseDouble(from: Double, to: Double): (Double, Randomizer)

def chooseFiniteDouble(from: FiniteDouble, to: FiniteDouble): (FiniteDouble, Randomizer)

def chooseFiniteFloat(from: FiniteFloat, to: FiniteFloat): (FiniteFloat, Randomizer)

def chooseFloat(from: Float, to: Float): (Float, Randomizer)

def chooseInt(from: Int, to: Int): (Int, Randomizer)

def chooseLong(from: Long, to: Long): (Long, Randomizer)

def chooseNegDouble(from: NegDouble, to: NegDouble): (NegDouble, Randomizer)

def chooseNegFiniteDouble(from: NegFiniteDouble, to: NegFiniteDouble): (NegFiniteDouble, Randomizer)

def chooseNegFiniteFloat(from: NegFiniteFloat, to: NegFiniteFloat): (NegFiniteFloat, Randomizer)

def chooseNegFloat(from: NegFloat, to: NegFloat): (NegFloat, Randomizer)

def chooseNegInt(from: NegInt, to: NegInt): (NegInt, Randomizer)

def chooseNegLong(from: NegLong, to: NegLong): (NegLong, Randomizer)

def chooseNegZDouble(from: NegZDouble, to: NegZDouble): (NegZDouble, Randomizer)

def chooseNegZFiniteDouble(from: NegZFiniteDouble, to: NegZFiniteDouble): (NegZFiniteDouble, Randomizer)

def chooseNegZFiniteFloat(from: NegZFiniteFloat, to: NegZFiniteFloat): (NegZFiniteFloat, Randomizer)

def chooseNegZFloat(from: NegZFloat, to: NegZFloat): (NegZFloat, Randomizer)

def chooseNegZInt(from: NegZInt, to: NegZInt): (NegZInt, Randomizer)

def chooseNegZLong(from: NegZLong, to: NegZLong): (NegZLong, Randomizer)

def chooseNonZeroDouble(from: NonZeroDouble, to: NonZeroDouble): (NonZeroDouble, Randomizer)

def chooseNonZeroFiniteDouble(from: NonZeroFiniteDouble, to: NonZeroFiniteDouble): (NonZeroFiniteDouble, Randomizer)

def chooseNonZeroFiniteFloat(from: NonZeroFiniteFloat, to: NonZeroFiniteFloat): (NonZeroFiniteFloat, Randomizer)

def chooseNonZeroFloat(from: NonZeroFloat, to: NonZeroFloat): (NonZeroFloat, Randomizer)

def chooseNonZeroInt(from: NonZeroInt, to: NonZeroInt): (NonZeroInt, Randomizer)

def chooseNonZeroLong(from: NonZeroLong, to: NonZeroLong): (NonZeroLong, Randomizer)

def choosePosDouble(from: PosDouble, to: PosDouble): (PosDouble, Randomizer)

def choosePosFiniteDouble(from: PosFiniteDouble, to: PosFiniteDouble): (PosFiniteDouble, Randomizer)

def choosePosFiniteFloat(from: PosFiniteFloat, to: PosFiniteFloat): (PosFiniteFloat, Randomizer)

def choosePosFloat(from: PosFloat, to: PosFloat): (PosFloat, Randomizer)

def choosePosInt(from: PosInt, to: PosInt): (PosInt, Randomizer)

def choosePosLong(from: PosLong, to: PosLong): (PosLong, Randomizer)

def choosePosZDouble(from: PosZDouble, to: PosZDouble): (PosZDouble, Randomizer)

def choosePosZFiniteDouble(from: PosZFiniteDouble, to: PosZFiniteDouble): (PosZFiniteDouble, Randomizer)

def choosePosZFiniteFloat(from: PosZFiniteFloat, to: PosZFiniteFloat): (PosZFiniteFloat, Randomizer)

def choosePosZFloat(from: PosZFloat, to: PosZFloat): (PosZFloat, Randomizer)

def choosePosZInt(from: PosZInt, to: PosZInt): (PosZInt, Randomizer)

def choosePosZLong(from: PosZLong, to: PosZLong): (PosZLong, Randomizer)

def chooseShort(from: Short, to: Short): (Short, Randomizer)

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def finiteFloatBetweenAlgorithm(between0And1: Float, min: Float, max: Float): Float

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def next(bits: Int): (Int, Randomizer)

def nextBit: (Int, Randomizer)

def nextByte: (Byte, Randomizer)

def nextChar: (Char, Randomizer)

def nextDouble: (Double, Randomizer)

def nextDoubleBetween0And1: (Double, Randomizer)

def nextFiniteDouble: (FiniteDouble, Randomizer)

def nextFiniteFloat: (FiniteFloat, Randomizer)

def nextFloat: (Float, Randomizer)

def nextFloatBetween0And1: (Float, Randomizer)

def nextInt: (Int, Randomizer)

def nextList[T](length: PosZInt)(implicit genOfT: Generator[T]): (List[T], Randomizer)

def nextLong: (Long, Randomizer)

def nextNegDouble: (NegDouble, Randomizer)

def nextNegFiniteDouble: (NegFiniteDouble, Randomizer)

def nextNegFiniteFloat: (NegFiniteFloat, Randomizer)

def nextNegFloat: (NegFloat, Randomizer)

def nextNegInt: (NegInt, Randomizer)

def nextNegLong: (NegLong, Randomizer)

def nextNegZDouble: (NegZDouble, Randomizer)

def nextNegZFiniteDouble: (NegZFiniteDouble, Randomizer)