Refactoring

benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/BufferBenchmark.kt

@@ -6,31 +6,38 @@
 package space.kscience.kmath.benchmarks
 
 import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Blackhole
 import kotlinx.benchmark.Scope
 import kotlinx.benchmark.State
 import space.kscience.kmath.complex.Complex
+import space.kscience.kmath.complex.ComplexField
 import space.kscience.kmath.complex.complex
+import space.kscience.kmath.operations.invoke
+import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.DoubleBuffer
-import space.kscience.kmath.structures.MutableBuffer
 
 @State(Scope.Benchmark)
 internal class BufferBenchmark {
     @Benchmark
-    fun genericDoubleBufferReadWrite() {
+    fun genericDoubleBufferReadWrite(blackhole: Blackhole) {
         val buffer = DoubleBuffer(size) { it.toDouble() }
-
+        var res = 0.0
         (0 until size).forEach {
-            buffer[it]
+            res += buffer[it]
         }
+        blackhole.consume(res)
     }
 
     @Benchmark
-    fun complexBufferReadWrite() {
+    fun complexBufferReadWrite(blackhole: Blackhole) = ComplexField {
-        val buffer = MutableBuffer.complex(size / 2) { Complex(it.toDouble(), -it.toDouble()) }
+        val buffer = Buffer.complex(size / 2) { Complex(it.toDouble(), -it.toDouble()) }
 
+        var res = zero
         (0 until size / 2).forEach {
-            buffer[it]
+            res += buffer[it]
         }
+
+        blackhole.consume(res)
     }
 
     private companion object {

examples/src/main/kotlin/space/kscience/kmath/fit/chiSquared.kt

@@ -16,10 +16,10 @@ import space.kscience.kmath.optimization.FunctionOptimizationTarget
 import space.kscience.kmath.optimization.optimizeWith
 import space.kscience.kmath.optimization.resultPoint
 import space.kscience.kmath.optimization.resultValue
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.real.DoubleVector
 import space.kscience.kmath.real.map
 import space.kscience.kmath.real.step
-import space.kscience.kmath.stat.RandomGenerator
 import space.kscience.kmath.structures.asIterable
 import space.kscience.kmath.structures.toList
 import space.kscience.plotly.*

examples/src/main/kotlin/space/kscience/kmath/fit/qowFit.kt

@@ -17,9 +17,9 @@ import space.kscience.kmath.optimization.QowOptimizer
 import space.kscience.kmath.optimization.chiSquaredOrNull
 import space.kscience.kmath.optimization.fitWith
 import space.kscience.kmath.optimization.resultPoint
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.real.map
 import space.kscience.kmath.real.step
-import space.kscience.kmath.stat.RandomGenerator
 import space.kscience.kmath.structures.asIterable
 import space.kscience.kmath.structures.toList
 import space.kscience.plotly.*

examples/src/main/kotlin/space/kscience/kmath/stat/DistributionBenchmark.kt

@@ -10,6 +10,7 @@ import kotlinx.coroutines.async
 import kotlinx.coroutines.runBlocking
 import org.apache.commons.rng.sampling.distribution.BoxMullerNormalizedGaussianSampler
 import org.apache.commons.rng.simple.RandomSource
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.samplers.GaussianSampler
 import java.time.Duration
 import java.time.Instant

examples/src/main/kotlin/space/kscience/kmath/stat/DistributionDemo.kt

@@ -9,6 +9,7 @@ import kotlinx.coroutines.runBlocking
 import space.kscience.kmath.chains.Chain
 import space.kscience.kmath.chains.collectWithState
 import space.kscience.kmath.distributions.NormalDistribution
+import space.kscience.kmath.random.RandomGenerator
 
 private data class AveragingChainState(var num: Int = 0, var value: Double = 0.0)
 

kmath-commons/src/main/kotlin/space/kscience/kmath/commons/random/CMRandomGeneratorWrapper.kt

@@ -8,9 +8,9 @@ package space.kscience.kmath.commons.random
 import kotlinx.coroutines.runBlocking
 import space.kscience.kmath.misc.PerformancePitfall
 import space.kscience.kmath.misc.toIntExact
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.samplers.GaussianSampler
 import space.kscience.kmath.samplers.next
-import space.kscience.kmath.stat.RandomGenerator
 
 
 public class CMRandomGeneratorWrapper(

kmath-commons/src/test/kotlin/space/kscience/kmath/commons/optimization/OptimizeTest.kt

@@ -14,7 +14,7 @@ import space.kscience.kmath.expressions.Symbol.Companion.y
 import space.kscience.kmath.expressions.chiSquaredExpression
 import space.kscience.kmath.expressions.symbol
 import space.kscience.kmath.optimization.*
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.structures.DoubleBuffer
 import space.kscience.kmath.structures.asBuffer
 import space.kscience.kmath.structures.map

kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/BufferAlgebra.kt

@@ -21,11 +21,6 @@ public interface BufferAlgebra<T, out A : Algebra<T>> : Algebra<Buffer<T>> {
     public val elementAlgebra: A
     public val bufferFactory: BufferFactory<T>
 
-    public fun buffer(size: Int, vararg elements: T): Buffer<T> {
-        require(elements.size == size) { "Expected $size elements but found ${elements.size}" }
-        return bufferFactory(size) { elements[it] }
-    }
-
     //TODO move to multi-receiver inline extension
     public fun Buffer<T>.map(block: A.(T) -> T): Buffer<T> = mapInline(this, block)
 
@@ -49,12 +44,15 @@ public interface BufferAlgebra<T, out A : Algebra<T>> : Algebra<Buffer<T>> {
     }
 }
 
+public fun <T, A : Algebra<T>> BufferAlgebra<T, A>.buffer(vararg elements: T): Buffer<T> =
+    bufferFactory(elements.size) { elements[it] }
+
 /**
  * Inline map
  */
 private inline fun <T, A : Algebra<T>> BufferAlgebra<T, A>.mapInline(
     buffer: Buffer<T>,
-    crossinline block: A.(T) -> T
+    crossinline block: A.(T) -> T,
 ): Buffer<T> = bufferFactory(buffer.size) { elementAlgebra.block(buffer[it]) }
 
 /**
@@ -62,7 +60,7 @@ private inline fun <T, A : Algebra<T>> BufferAlgebra<T, A>.mapInline(
  */
 private inline fun <T, A : Algebra<T>> BufferAlgebra<T, A>.mapIndexedInline(
     buffer: Buffer<T>,
-    crossinline block: A.(index: Int, arg: T) -> T
+    crossinline block: A.(index: Int, arg: T) -> T,
 ): Buffer<T> = bufferFactory(buffer.size) { elementAlgebra.block(it, buffer[it]) }
 
 /**
@@ -71,7 +69,7 @@ private inline fun <T, A : Algebra<T>> BufferAlgebra<T, A>.mapIndexedInline(
 private inline fun <T, A : Algebra<T>> BufferAlgebra<T, A>.zipInline(
     l: Buffer<T>,
     r: Buffer<T>,
-    crossinline block: A.(l: T, r: T) -> T
+    crossinline block: A.(l: T, r: T) -> T,
 ): Buffer<T> {
     require(l.size == r.size) { "Incompatible buffer sizes. left: ${l.size}, right: ${r.size}" }
     return bufferFactory(l.size) { elementAlgebra.block(l[it], r[it]) }
@@ -155,7 +153,8 @@ public val ShortRing.bufferAlgebra: BufferRingOps<Short, ShortRing>
 public open class BufferFieldOps<T, A : Field<T>>(
     elementAlgebra: A,
     bufferFactory: BufferFactory<T>,
-) : BufferRingOps<T, A>(elementAlgebra, bufferFactory), BufferAlgebra<T, A>, FieldOps<Buffer<T>>, ScaleOperations<Buffer<T>> {
+) : BufferRingOps<T, A>(elementAlgebra, bufferFactory), BufferAlgebra<T, A>, FieldOps<Buffer<T>>,
+    ScaleOperations<Buffer<T>> {
 
     override fun add(left: Buffer<T>, right: Buffer<T>): Buffer<T> = zipInline(left, right) { l, r -> l + r }
     override fun multiply(left: Buffer<T>, right: Buffer<T>): Buffer<T> = zipInline(left, right) { l, r -> l * r }
@@ -172,7 +171,7 @@ public open class BufferFieldOps<T, A : Field<T>>(
 public class BufferField<T, A : Field<T>>(
     elementAlgebra: A,
     bufferFactory: BufferFactory<T>,
-    override val size: Int
+    override val size: Int,
 ) : BufferFieldOps<T, A>(elementAlgebra, bufferFactory), Field<Buffer<T>>, WithSize {
 
     override val zero: Buffer<T> = bufferFactory(size) { elementAlgebra.zero }

kmath-core/src/commonMain/kotlin/space/kscience/kmath/operations/DoubleBufferOps.kt

@@ -135,6 +135,7 @@ public abstract class DoubleBufferOps : BufferAlgebra<Double, DoubleField>, Exte
     override fun scale(a: Buffer<Double>, value: Double): DoubleBuffer = a.mapInline { it * value }
 
     public companion object : DoubleBufferOps() {
+
         public inline fun Buffer<Double>.mapInline(block: (Double) -> Double): DoubleBuffer =
             if (this is DoubleBuffer) {
                 DoubleArray(size) { block(array[it]) }.asBuffer()
@@ -144,6 +145,14 @@ public abstract class DoubleBufferOps : BufferAlgebra<Double, DoubleField>, Exte
     }
 }
 
+public inline fun BufferAlgebra<Double, DoubleField>.buffer(size: Int, init: (Int) -> Double): DoubleBuffer {
+    val res = DoubleArray(size)
+    for (i in 0 until size) {
+        res[i] = init(i)
+    }
+    return res.asBuffer()
+}
+
 public object DoubleL2Norm : Norm<Point<Double>, Double> {
     override fun norm(arg: Point<Double>): Double = sqrt(arg.fold(0.0) { acc: Double, d: Double -> acc + d.pow(2) })
 }

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/distributions/Distribution.kt

@@ -6,8 +6,8 @@
 package space.kscience.kmath.distributions
 
 import space.kscience.kmath.chains.Chain
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.samplers.Sampler
-import space.kscience.kmath.stat.RandomGenerator
 
 /**
  * A distribution of typed objects.

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/distributions/FactorizedDistribution.kt

@@ -7,7 +7,7 @@ package space.kscience.kmath.distributions
 
 import space.kscience.kmath.chains.Chain
 import space.kscience.kmath.chains.SimpleChain
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 
 /**
  * A multivariate distribution that takes a map of parameters.

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/distributions/NormalDistribution.kt

@@ -6,11 +6,11 @@
 package space.kscience.kmath.distributions
 
 import space.kscience.kmath.chains.Chain
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.samplers.GaussianSampler
 import space.kscience.kmath.samplers.InternalErf
 import space.kscience.kmath.samplers.NormalizedGaussianSampler
 import space.kscience.kmath.samplers.ZigguratNormalizedGaussianSampler
-import space.kscience.kmath.stat.RandomGenerator
 import kotlin.math.*
 
 /**

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/distributions/UniformDistribution.kt

@@ -7,7 +7,7 @@ package space.kscience.kmath.distributions
 
 import space.kscience.kmath.chains.Chain
 import space.kscience.kmath.chains.SimpleChain
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 
 public class UniformDistribution(public val range: ClosedFloatingPointRange<Double>) : UnivariateDistribution<Double> {
     private val length: Double = range.endInclusive - range.start

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/random/MCScope.kt

@@ -22,6 +22,10 @@ public class MCScope(
     public val random: RandomGenerator,
 )
 
+public fun MCScope.asCoroutineScope(): CoroutineScope = object : CoroutineScope {
+    override val coroutineContext: CoroutineContext get() = this@asCoroutineScope.coroutineContext
+}
+
 /**
  * Launches a supervised Monte-Carlo scope
  */

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/AhrensDieterExponentialSampler.kt

@@ -6,7 +6,7 @@
 package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.BlockingDoubleChain
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.structures.DoubleBuffer
 import kotlin.math.ln
 import kotlin.math.pow

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/AhrensDieterMarsagliaTsangGammaSampler.kt

@@ -6,8 +6,8 @@
 package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.Chain
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
-import space.kscience.kmath.stat.chain
+import space.kscience.kmath.random.chain
 import kotlin.math.*
 
 /**
@@ -23,14 +23,14 @@ import kotlin.math.*
  */
 public class AhrensDieterMarsagliaTsangGammaSampler private constructor(
     alpha: Double,
-    theta: Double
+    theta: Double,
 ) : Sampler<Double> {
     private val delegate: BaseGammaSampler =
         if (alpha < 1) AhrensDieterGammaSampler(alpha, theta) else MarsagliaTsangGammaSampler(alpha, theta)
 
     private abstract class BaseGammaSampler internal constructor(
         protected val alpha: Double,
-        protected val theta: Double
+        protected val theta: Double,
     ) : Sampler<Double> {
         init {
             require(alpha > 0) { "alpha is not strictly positive: $alpha" }
@@ -117,7 +117,7 @@ public class AhrensDieterMarsagliaTsangGammaSampler private constructor(
     public companion object {
         public fun of(
             alpha: Double,
-            theta: Double
+            theta: Double,
         ): Sampler<Double> = AhrensDieterMarsagliaTsangGammaSampler(alpha, theta)
     }
 }

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/AliasMethodDiscreteSampler.kt

@@ -6,8 +6,8 @@
 package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.Chain
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
-import space.kscience.kmath.stat.chain
+import space.kscience.kmath.random.chain
 import kotlin.math.ceil
 import kotlin.math.max
 import kotlin.math.min

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/BoxMullerSampler.kt

@@ -6,7 +6,7 @@
 package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.BlockingDoubleChain
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.structures.DoubleBuffer
 import kotlin.math.*
 

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/GaussianSampler.kt

@@ -7,7 +7,7 @@ package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.BlockingDoubleChain
 import space.kscience.kmath.chains.map
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 
 /**
  * Sampling from a Gaussian distribution with given mean and standard deviation.
@@ -21,7 +21,7 @@ import space.kscience.kmath.stat.RandomGenerator
 public class GaussianSampler(
     public val mean: Double,
     public val standardDeviation: Double,
-    private val normalized: NormalizedGaussianSampler = BoxMullerSampler
+    private val normalized: NormalizedGaussianSampler = BoxMullerSampler,
 ) : BlockingDoubleSampler {
 
     init {

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/KempSmallMeanPoissonSampler.kt

@@ -6,7 +6,7 @@
 package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.BlockingIntChain
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.structures.IntBuffer
 import kotlin.math.exp
 

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/MarsagliaNormalizedGaussianSampler.kt

@@ -6,7 +6,7 @@
 package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.BlockingDoubleChain
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.structures.DoubleBuffer
 import kotlin.math.ln
 import kotlin.math.sqrt

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/NormalizedGaussianSampler.kt

@@ -6,7 +6,7 @@
 package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.BlockingDoubleChain
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 
 public interface BlockingDoubleSampler : Sampler<Double> {
     override fun sample(generator: RandomGenerator): BlockingDoubleChain

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/PoissonSampler.kt

@@ -7,7 +7,7 @@ package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.BlockingIntChain
 import space.kscience.kmath.misc.toIntExact
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.structures.IntBuffer
 import kotlin.math.*
 

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/Sampler.kt

@@ -8,7 +8,7 @@ package space.kscience.kmath.samplers
 import kotlinx.coroutines.flow.first
 import space.kscience.kmath.chains.Chain
 import space.kscience.kmath.chains.collect
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.BufferFactory
 import space.kscience.kmath.structures.DoubleBuffer

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/SamplerAlgebra.kt

@@ -12,7 +12,7 @@ import space.kscience.kmath.chains.zip
 import space.kscience.kmath.operations.Group
 import space.kscience.kmath.operations.ScaleOperations
 import space.kscience.kmath.operations.invoke
-import space.kscience.kmath.stat.RandomGenerator
+import space.kscience.kmath.random.RandomGenerator
 
 /**
  * Implements [Sampler] by sampling only certain [value].

kmath-stat/src/commonMain/kotlin/space/kscience/kmath/samplers/ZigguratNormalizedGaussianSampler.kt

@@ -6,8 +6,7 @@
 package space.kscience.kmath.samplers
 
 import space.kscience.kmath.chains.BlockingDoubleChain
-import space.kscience.kmath.misc.toIntExact
+import space.kscience.kmath.random.RandomGenerator
-import space.kscience.kmath.stat.RandomGenerator
 import space.kscience.kmath.structures.DoubleBuffer
 import kotlin.math.*
 

kmath-stat/src/jvmMain/kotlin/space/kscience/kmath/stat/RandomSourceGenerator.kt

@@ -7,13 +7,17 @@ package space.kscience.kmath.stat
 
 import org.apache.commons.rng.UniformRandomProvider
 import org.apache.commons.rng.simple.RandomSource
+import space.kscience.kmath.random.RandomGenerator
 
 /**
  * Implements [RandomGenerator] by delegating all operations to [RandomSource].
  *
  * @property source the underlying [RandomSource] object.
  */
-public class RandomSourceGenerator internal constructor(public val source: RandomSource, seed: Long?) : RandomGenerator {
+public class RandomSourceGenerator internal constructor(
+    public val source: RandomSource,
+    seed: Long?,
+) : RandomGenerator {
     internal val random: UniformRandomProvider = seed?.let { RandomSource.create(source, seed) }
         ?: RandomSource.create(source)
 

kmath-stat/src/jvmTest/kotlin/space/kscience/kmath/stat/CommonsDistributionsTest.kt

@@ -8,6 +8,7 @@ package space.kscience.kmath.stat
 import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.samplers.GaussianSampler
 
 internal class CommonsDistributionsTest {

kmath-stat/src/jvmTest/kotlin/space/kscience/kmath/stat/MCScopeTest.kt

@@ -6,15 +6,17 @@
 package space.kscience.kmath.stat
 
 import kotlinx.coroutines.*
+import space.kscience.kmath.random.launch
+import space.kscience.kmath.random.mcScope
 import java.util.*
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
 data class RandomResult(val branch: String, val order: Int, val value: Int)
 
-typealias ATest = suspend CoroutineScope.() -> Set<RandomResult>
+internal typealias ATest = suspend () -> Set<RandomResult>
 
-class MCScopeTest {
+internal class MCScopeTest {
     val simpleTest: ATest = {
         mcScope(1111) {
             val res = Collections.synchronizedSet(HashSet<RandomResult>())

kmath-stat/src/jvmTest/kotlin/space/kscience/kmath/stat/SamplerTest.kt

@@ -6,6 +6,8 @@
 package space.kscience.kmath.stat
 
 import kotlinx.coroutines.runBlocking
+import space.kscience.kmath.random.RandomGenerator
+import space.kscience.kmath.random.chain
 import space.kscience.kmath.samplers.Sampler
 import space.kscience.kmath.samplers.sampleBuffer
 import kotlin.test.Test

kmath-stat/src/jvmTest/kotlin/space/kscience/kmath/stat/StatisticTest.kt

@@ -9,6 +9,8 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.last
 import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.runBlocking
+import space.kscience.kmath.random.RandomGenerator
+import space.kscience.kmath.random.chain
 import space.kscience.kmath.streaming.chunked
 import kotlin.test.Test
 import kotlin.test.assertEquals

kmath-tensors/src/commonMain/kotlin/space/kscience/kmath/tensors/core/internal/utils.kt

@@ -6,8 +6,8 @@
 package space.kscience.kmath.tensors.core.internal
 
 import space.kscience.kmath.nd.as1D
+import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.samplers.GaussianSampler
-import space.kscience.kmath.stat.RandomGenerator
 import space.kscience.kmath.structures.*
 import space.kscience.kmath.tensors.core.BufferedTensor
 import space.kscience.kmath.tensors.core.DoubleTensor