kmath-coroutines/space.kscience.kmath.chains/StatefulChain

StatefulChain

class StatefulChain<S, out R>(state: S, seed: S.() -> R, forkState: (S) -> S, gen: suspend S.(R) -> R) : Chain<R> (source)

A chain with possibly mutable state. The state must not be changed outside the chain. Two chins should never share the state.

Parameters

the state of the chain.

forkState

the function to copy current state without modifying it.

Constructors

StatefulChain

constructor(state: S, seed: S.() -> R, forkState: (S) -> S, gen: suspend S.(R) -> R)

Functions

asSequence

fun <R> Chain<R>.asSequence(): Sequence<R>

Represent a chain as a sequence

async

inline fun <T, R> Flow<T>.async(dispatcher: CoroutineDispatcher = Dispatchers.Default, crossinline block: suspend CoroutineScope.(T) -> R): AsyncFlow<R>

chunked

fun Flow<Double>.chunked(bufferSize: Int): Flow<DoubleBuffer>

Specialized flow chunker for real buffer

fun <T> Flow<T>.chunked(bufferSize: Int, bufferFactory: BufferFactory<T>): Flow<Buffer<T>>

Collect incoming flow into fixed size chunks

collect

open suspend override fun collect(collector: FlowCollector<R>)

combine

@UnstableKMathAPI

fun <T, R> Chain<T>.combine(mapper: suspend (Chain<T>) -> R): Chain<R>

Map the whole chain

combineWithState

@UnstableKMathAPI

fun <T, S, R> Chain<T>.combineWithState(state: S, stateFork: (S) -> S, mapper: suspend S.(Chain<T>) -> R): Chain<R>

cumulativeSum

fun <T> Flow<T>.cumulativeSum(group: GroupOps<T>): Flow<T>

filter

fun <T> Chain<T>.filter(block: (T) -> Boolean): Chain<T>

block must be a pure function or at least not use external random variables, otherwise fork could be broken

fork

open suspend override fun fork(): Chain<R>

Create a copy of current chain state. Consuming resulting chain does not affect initial chain.

iterator

operator fun <R> Chain<R>.iterator(): Iterator<R>

Represent a chain as regular iterator (uses blocking calls)

map

fun <T, R> Chain<T>.map(func: suspend (T) -> R): Chain<R>

Map the chain result using suspended transformation. Initial chain result can no longer be safely consumed since mapped chain consumes tokens. Accepts regular transformation function.

mapParallel