korge-foundation/korlibs.datastructure.random/FastRandom

FastRandom

open class FastRandom : Random

Inheritors

Companion

Constructors

FastRandom

constructor(seed: Long)

constructor()

Types

Companion

object Companion : FastRandom

Functions

doubles

fun Random.doubles(): Sequence<Double>

floats

fun Random.floats(): Sequence<Float>

get

operator fun Random.get(rectangle: Rectangle): Point

operator fun <T> Random.get(list: List<T>): T

operator fun Random.get(range: IntRange): Int

operator fun Random.get(range: LongRange): Long

operator fun <T : Interpolable<T>> Random.get(l: T, r: T): T

operator fun Random.get(l: Angle, r: Angle): Angle

operator fun Random.get(min: Ratio, max: Ratio): Ratio

operator fun Random.get(min: Double, max: Double): Double

operator fun Random.get(min: Float, max: Float): Float

operator fun Random.get(min: Int, max: Int): Int

ints

fun Random.ints(): Sequence<Int>

fun Random.ints(range: IntRange): Sequence<Int>

fun Random.ints(from: Int, until: Int): Sequence<Int>

nextBits

open override fun nextBits(bitCount: Int): Int

nextBoolean

open fun nextBoolean(): Boolean

nextBytes

open fun nextBytes(array: ByteArray): ByteArray

open fun nextBytes(size: Int): ByteArray

open fun nextBytes(array: ByteArray, fromIndex: Int, toIndex: Int): ByteArray

nextDouble

open fun nextDouble(): Double

open fun nextDouble(until: Double): Double

open fun nextDouble(from: Double, until: Double): Double

nextDoubleInclusive

fun Random.nextDoubleInclusive(): Double

nextFloat

open fun nextFloat(): Float

nextInt

open override fun nextInt(): Int

open override fun nextInt(from: Int, until: Int): Int

open fun nextInt(until: Int): Int

nextLong

open override fun nextLong(from: Long, until: Long): Long

open fun nextLong(): Long

open fun nextLong(until: Long): Long

nextRatio

fun Random.nextRatio(): Ratio

nextRatioInclusive

fun Random.nextRatioInclusive(): Ratio

shuffledWeighted

fun <T> Random.shuffledWeighted(weights: RandomWeights<T>): List<T>

fun <T> Random.shuffledWeighted(weights: Map<T, Double>): List<T>

fun <T> Random.shuffledWeighted(values: List<T>, weights: List<Double>): List<T>

weighted

fun <T> Random.weighted(weights: RandomWeights<T>): T

fun <T> Random.weighted(weights: Map<T, Double>): T