A scope for a Monte-Carlo computations or multi-coroutine random number generation. The scope preserves the order of random generator calls as long as all concurrency calls is done via launch and async functions.

Mean

class Mean<T>(group: Ring<T>, division: (T, count: Int) -> T) : ComposableStatistic<T, Pair<T, Int>, T> , BlockingStatistic<T, T>

Arithmetic mean

Median

class Median<T>(comparator: Comparator<T>) : BlockingStatistic<T, T>

Non-composable median

RandomChain

class RandomChain<out R>(generator: RandomGenerator, gen: suspend RandomGenerator.() -> R) : Chain<R>

A possibly stateful chain producing random values.

RandomGenerator

interface RandomGenerator

An interface that is implemented by random number generator algorithms.

RandomGeneratorProvider

class RandomGeneratorProvider(generator: RandomGenerator) : UniformRandomProvider

Implements UniformRandomProvider by delegating all operations to RandomGenerator.

RandomSourceGenerator

class RandomSourceGenerator : RandomGenerator

Implements RandomGenerator by delegating all operations to RandomSource.

Sampler

fun interface Sampler<out T : Any>

Sampler that generates chains of values of type T.

SamplerSpace

class SamplerSpace<T : Any, out S : Group<T>, ScaleOperations<T>>(algebra: S) : Group<Sampler<T>> , ScaleOperations<Sampler<T>>

A space of samplers. Allows performing simple operations on distributions.

Statistic

fun interface Statistic<in T, out R>

A function, that transforms a buffer of random quantities to some resulting value

UniformDistribution

class UniformDistribution(range: ClosedFloatingPointRange<Double>) : Distribution1D<Double>

UniformDoubleChain

class UniformDoubleChain(generator: RandomGenerator) : BlockingDoubleChain

A type-specific double chunk random chain

ValueAndError

data class ValueAndError(value: Double, dispersion: Double)

A combination of a random value and its dispersion.

ValueAndErrorField

object ValueAndErrorField : Field<ValueAndError>

An algebra for double value + its error combination. The multiplication assumes linear error propagation

Functions

asUniformRandomProvider

fun RandomGenerator.asUniformRandomProvider(): UniformRandomProvider

Represent this RandomGenerator as commons-rng UniformRandomProvider preserving and mirroring its current state. Getting new value from one of those changes the state of another.

async

inline fun <T> MCScope.async(context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, crossinline block: suspend MCScope.() -> T): Deferred<T>

Specialized async for MCScope. Behaves the same way as regular CoroutineScope.async, but also stores the generator fork. The method itself is not thread safe.

chain

fun <R> RandomGenerator.chain(generator: suspend RandomGenerator.() -> R): RandomChain<R>

Create a generic random chain with provided generator

flow

fun <T, I, R> ComposableStatistic<T, I, R>.flow(flow: Flow<Buffer<T>>, dispatcher: CoroutineDispatcher = Dispatchers.Default): Flow<R>

Perform a streaming statistical analysis on a chunked data. The computation of inner representation is done in parallel if dispatcher allows it.

fromSource

fun RandomGenerator.Companion.fromSource(source: RandomSource, seed: Long? = null): RandomSourceGenerator

Returns RandomSourceGenerator with given RandomSource and seed.

invoke

operator fun <T, R> BlockingStatistic<T, R>.invoke(data: Buffer<T>): R

suspend operator fun <T, R> Statistic<T, R>.invoke(data: Buffer<T>): R

launch

inline fun MCScope.launch(context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, crossinline block: suspend MCScope.() -> Unit): Job

Specialized launch for MCScope. Behaves the same way as regular CoroutineScope.launch, but also stores the generator fork. The method itself is not thread safe.

mcScope