Options for running an optimizer.

Map over the underlying monad of a RunOpts.

Options for running an optimizer in a concurrent setting.

Map over the underlying monad of a ParallelOpts.

Run an optimizer on some input, given a monadic action to produce each new sample. When the action produces Nothing, the running immediately terminates even if the stop condition has not yet been met.

A version of opto that also returns an updated optimizer state that can be resumed.

A version of optoNonSampling that also returns an updated optimizer state that can be resumed.

Run a non-sampling optimizer on some input until the stop condition is met.

Given an optimizer and some initial value, produce a ConduitT that takes in samples and outputs each successively optimized versions of the value. This essentially is a convenient wrapper over opto.

To get the final optimized result after a stream has terminated, compose this with a sink like last.

optoConduit ro x0 o .| last
  :: ConduitT r o m (Maybe a)

optoConduit ro x0 o .| lastDef x0
  :: ConduitT r o m a

Note that this emits every single updated version of the value, but still only runs roReport at the frequency of roFreq.

A version of optoConduit that also returns an updated optimizer state that can be resumed.

Convenient wrapper over opto to allow consumption over a list of samples.

A version of optoFold' that also returns an updated optimizer state that can be resumed.

Run an optimizer in parallel on multiple threads on some value, given a (thread-safe) monadic action to produce each new sample.

It does this by repeatedly:

1. Splitting into multiple threads (based on poThreads)
2. Running opto (single-threaded optimiztion) on each thread, independently, from the same initial value.
3. After poSplit items have been processed, all threads wait on each other to stop. After each thread is done, each thread's optimized value is then aggregated using poCombine (by default, it takes the mean).
4. This new optimized combined value is then used to begin the cycle again.

When action produces Nothing for all threads, the running immediately terminates on all threads and returns even if the stop condition has not yet been met. If the stop condition is met, the value given to the stop condition will be used as the final result, ignoring all other thread pools.

A version of optoPar that performs a batch fetch for each thread's entire sample pool before beginning parallel optimization. This can be useful if the sampling is faster in batch amounts.

Run a non-sampling optimizer in parallel on multiple threads on some value until the stop condition is met.

See optoPar for a detailed description of how parallel optimization is implemented.

Given an optimizer, some initial value, and a conduit source, returns a conduit sorce that outputs succesively optimized versions of the value after each thread recombination, where each version is optimized using parallel multi-threaded optimization.

See optoPar for a detailed description on how parallel optimization is implemented.

Note that, unlike optoConduit, which is a conduit, this is a conduit (source) transformer. It takes a source outputting samples and returns a new source of optimized values.

A value is emitted after every thread recombination/call of poCombine.

A version of optoConduitPar that performs a batch fetch from the input source for each thread's entire sample pool before beginning parallel optimization. This can be useful if the source can produce values faster in batch amounts.

The mean of the values in a non-empty container.