LongBasedGenerator

abstract def copyInit: Generator

abstract def getSeedBytes(): Array[Byte]

abstract def nextLong(): Long

Generates a random long.

abstract def setSeedBytes(bytes: Array[Byte]): Unit

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def chooseFromArray[A](arr: Array[A])(implicit gen: Generator): A

def chooseFromIterable[A](as: Iterable[A])(implicit gen: Generator): A

def chooseFromSeq[A](seq: Seq[A])(implicit gen: Generator): A

def clone(): AnyRef

def copy: Generator

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

var extra: Boolean

def fillArray[A](arr: Array[A])(implicit arg0: Dist[A]): Unit

Fill an Array[A] using the given Dist[A] instance.

def fillBytes(arr: Array[Byte]): Unit

Fill an array with random Bytes.

def fillGaussians(arr: Array[Double], mean: Double, stddev: Double): Unit

def fillGaussians(arr: Array[Double]): Unit

def fillInts(arr: Array[Int]): Unit

Fill an array with random Ints.

def fillLongs(arr: Array[Long]): Unit

Fill an array with random Longs.

def fillShorts(arr: Array[Short]): Unit

Fill an array with random Shorts.

def finalize(): Unit

def generateArray[A](n: Int)(implicit arg0: Dist[A], arg1: ClassTag[A]): Array[A]

Generate an Array[A] using the given Dist[A] instance.

def generateBytes(n: Int): Array[Byte]

Generate an array of n random Bytes.

def generateGaussians(n: Int, mean: Double, stddev: Double): Array[Double]

def generateGaussians(n: Int): Array[Double]

def generateInts(n: Int): Array[Int]

Generate an array of n random Ints.

def generateLongs(n: Int): Array[Long]

Generate an array of n random Longs.

def generateShorts(n: Int): Array[Short]

Generate an array of n random Shorts.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def iterator[A](implicit next: Dist[A]): Iterator[A]

Generate an infinite iterator of random values using Dist[A].

final def ne(arg0: AnyRef): Boolean

def next[A](implicit next: Dist[A]): A

Generate a random value using a Dist[A] type class instance.

def nextBits(n: Int): Int

Generates a random integer using n bits of state (0 <= n <= 32).

def nextBoolean(): Boolean

Generates a random Boolean.

def nextDouble(from: Double, until: Double): Double

Generates a random double in [from, until).

def nextDouble(n: Double): Double

Generates a random double in [0.

def nextDouble(): Double

Generates a random double in [0.

def nextFloat(from: Float, until: Float): Float

Generates a random float in [from, until).

def nextFloat(n: Float): Float

Generates a random float in [0.

def nextFloat(): Float

Generates a random float in [0.

def nextGaussian(mean: Double, stddev: Double): Double

def nextGaussian(): Double

def nextInt(): Int

Generate an equally-distributed random Int.

def nextInt(from: Int, to: Int): Int

Return an Int in [from, to].

def nextInt(n: Int): Int

Generates a random int between 0 (inclusive) and n (exclusive).

def nextLong(from: Long, to: Long): Long

Return an Long in [from, to].

def nextLong(n: Long): Long

Generates a random int between 0 (inclusive) and n (exclusive).

final def notify(): Unit

final def notifyAll(): Unit

def oneOf[A](as: A*): A

def sampleFromArray[A](as: Array[A], size: Int)(implicit arg0: ClassTag[A], gen: Generator): Array[A]

def sampleFromTraversable[A](as: Traversable[A], size: Int)(implicit arg0: ClassTag[A], gen: Generator): Array[A]

def shuffle[A](as: Array[A])(implicit gen: Generator): Unit

def sync: SyncGenerator

final def synchronized[T0](arg0: ⇒ T0): T0

def toImmutable: immutable.Generator

def toString(): String

var value: Double

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit