Remove buildSrc

benchmarks/build.gradle.kts

@@ -1,11 +1,18 @@
-@file:Suppress("UNUSED_VARIABLE")
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-
+import com.fasterxml.jackson.module.kotlin.readValue
-import space.kscience.kmath.benchmarks.addBenchmarkProperties
+import kotlinx.benchmark.gradle.BenchmarksExtension
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.time.format.DateTimeFormatterBuilder
+import java.time.format.SignStyle
+import java.time.temporal.ChronoField.*
+import java.util.*
 
 plugins {
     kotlin("multiplatform")
     alias(spclibs.plugins.kotlin.plugin.allopen)
-    id("org.jetbrains.kotlinx.benchmark")
+    alias(spclibs.plugins.kotlinx.benchmark)
 }
 
 allOpen.annotation("org.openjdk.jmh.annotations.State")
@@ -158,8 +165,141 @@ kotlin {
     }
 }
 
-readme {
+
-    maturity = space.kscience.gradle.Maturity.EXPERIMENTAL
+private data class JmhReport(
+    val jmhVersion: String,
+    val benchmark: String,
+    val mode: String,
+    val threads: Int,
+    val forks: Int,
+    val jvm: String,
+    val jvmArgs: List<String>,
+    val jdkVersion: String,
+    val vmName: String,
+    val vmVersion: String,
+    val warmupIterations: Int,
+    val warmupTime: String,
+    val warmupBatchSize: Int,
+    val measurementIterations: Int,
+    val measurementTime: String,
+    val measurementBatchSize: Int,
+    val params: Map<String, String> = emptyMap(),
+    val primaryMetric: PrimaryMetric,
+    val secondaryMetrics: Map<String, SecondaryMetric>,
+) {
+    interface Metric {
+        val score: Double
+        val scoreError: Double
+        val scoreConfidence: List<Double>
+        val scorePercentiles: Map<Double, Double>
+        val scoreUnit: String
+    }
+
+    data class PrimaryMetric(
+        override val score: Double,
+        override val scoreError: Double,
+        override val scoreConfidence: List<Double>,
+        override val scorePercentiles: Map<Double, Double>,
+        override val scoreUnit: String,
+        val rawDataHistogram: List<List<List<List<Double>>>>? = null,
+        val rawData: List<List<Double>>? = null,
+    ) : Metric
+
+    data class SecondaryMetric(
+        override val score: Double,
+        override val scoreError: Double,
+        override val scoreConfidence: List<Double>,
+        override val scorePercentiles: Map<Double, Double>,
+        override val scoreUnit: String,
+        val rawData: List<List<Double>>,
+    ) : Metric
 }
 
-addBenchmarkProperties()
+readme {
+    maturity = space.kscience.gradle.Maturity.EXPERIMENTAL
+
+    val jsonMapper = jacksonObjectMapper()
+
+
+    val ISO_DATE_TIME: DateTimeFormatter = DateTimeFormatterBuilder().run {
+        parseCaseInsensitive()
+        appendValue(YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
+        appendLiteral('-')
+        appendValue(MONTH_OF_YEAR, 2)
+        appendLiteral('-')
+        appendValue(DAY_OF_MONTH, 2)
+        appendLiteral('T')
+        appendValue(HOUR_OF_DAY, 2)
+        appendLiteral('.')
+        appendValue(MINUTE_OF_HOUR, 2)
+        optionalStart()
+        appendLiteral('.')
+        appendValue(SECOND_OF_MINUTE, 2)
+        optionalStart()
+        appendFraction(NANO_OF_SECOND, 0, 9, true)
+        optionalStart()
+        appendOffsetId()
+        optionalStart()
+        appendLiteral('[')
+        parseCaseSensitive()
+        appendZoneRegionId()
+        appendLiteral(']')
+        toFormatter()
+    }
+
+    fun noun(number: Number, singular: String, plural: String) = if (number.toLong() == 1L) singular else plural
+
+    extensions.findByType(BenchmarksExtension::class.java)?.configurations?.forEach { cfg ->
+        property("benchmark${cfg.name.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }}") {
+            val launches = layout.buildDirectory.dir("reports/benchmarks/${cfg.name}").get()
+
+            val resDirectory = launches.files().maxByOrNull {
+                LocalDateTime.parse(it.name, ISO_DATE_TIME).atZone(ZoneId.systemDefault()).toInstant()
+            }
+
+            if (resDirectory == null || !(resDirectory.resolve("jvm.json")).exists()) {
+                "> **Can't find appropriate benchmark data. Try generating readme files after running benchmarks**."
+            } else {
+                val reports: List<JmhReport> =
+                    jsonMapper.readValue<List<JmhReport>>(resDirectory.resolve("jvm.json"))
+
+                buildString {
+                    appendLine("<details>")
+                    appendLine("<summary>")
+                    appendLine("Report for benchmark configuration <code>${cfg.name}</code>")
+                    appendLine("</summary>")
+                    appendLine()
+                    val first = reports.first()
+
+                    appendLine("* Run on ${first.vmName} (build ${first.vmVersion}) with Java process:")
+                    appendLine()
+                    appendLine("```")
+                    appendLine(
+                        "${first.jvm} ${
+                            first.jvmArgs.joinToString(" ")
+                        }"
+                    )
+                    appendLine("```")
+
+                    appendLine(
+                        "* JMH ${first.jmhVersion} was used in `${first.mode}` mode with ${first.warmupIterations} warmup ${
+                            noun(first.warmupIterations, "iteration", "iterations")
+                        } by ${first.warmupTime} and ${first.measurementIterations} measurement ${
+                            noun(first.measurementIterations, "iteration", "iterations")
+                        } by ${first.measurementTime}."
+                    )
+
+                    appendLine()
+                    appendLine("| Benchmark | Score |")
+                    appendLine("|:---------:|:-----:|")
+
+                    reports.forEach { report ->
+                        appendLine("|`${report.benchmark}`|${report.primaryMetric.score} &plusmn; ${report.primaryMetric.scoreError} ${report.primaryMetric.scoreUnit}|")
+                    }
+
+                    appendLine("</details>")
+                }
+            }
+        }
+    }
+}

build.gradle.kts

@@ -2,7 +2,7 @@ import space.kscience.gradle.useApache2Licence
 import space.kscience.gradle.useSPCTeam
 
 plugins {
-    id("space.kscience.gradle.project")
+    alias(spclibs.plugins.kscience.project)
     alias(spclibs.plugins.kotlinx.kover)
 }
 

buildSrc/build.gradle.kts

@@ -1,33 +0,0 @@
-plugins {
-    kotlin("jvm") version "1.9.23"
-    `kotlin-dsl`
-    `version-catalog`
-}
-
-repositories {
-    mavenLocal()
-    maven("https://repo.kotlin.link")
-    mavenCentral()
-    gradlePluginPortal()
-}
-
-val toolsVersion = spclibs.versions.tools.get()
-val kotlinVersion = spclibs.versions.kotlin.asProvider().get()
-val benchmarksVersion = spclibs.versions.kotlinx.benchmark.get()
-
-dependencies {
-    api("space.kscience:gradle-tools:$toolsVersion")
-    //plugins form benchmarks
-    api("org.jetbrains.kotlinx:kotlinx-benchmark-plugin:$benchmarksVersion")
-    //api("org.jetbrains.kotlin:kotlin-allopen:$kotlinVersion")
-    //to be used inside build-script only
-    //implementation(spclibs.kotlinx.serialization.json)
-    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.14.+")
-}
-
-kotlin {
-    jvmToolchain(11)
-    compilerOptions {
-        optIn.add("kotlin.OptIn")
-    }
-}

buildSrc/settings.gradle.kts

@@ -1,38 +0,0 @@
-/*
- * Copyright 2018-2021 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
-
-plugins {
-    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
-}
-
-dependencyResolutionManagement {
-    val projectProperties = java.util.Properties()
-    file("../gradle.properties").inputStream().use {
-        projectProperties.load(it)
-    }
-
-    projectProperties.forEach { key, value ->
-        extra.set(key.toString(), value)
-    }
-
-
-    val toolsVersion: String = projectProperties["toolsVersion"].toString()
-
-    @Suppress("UnstableApiUsage")
-    repositories {
-        mavenLocal()
-        maven("https://repo.kotlin.link")
-        mavenCentral()
-        gradlePluginPortal()
-    }
-
-    versionCatalogs {
-        create("spclibs") {
-            from("space.kscience:version-catalog:$toolsVersion")
-        }
-    }
-}

buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/JmhReport.kt

@@ -1,55 +0,0 @@
-/*
- * Copyright 2018-2024 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.benchmarks
-
-data class JmhReport(
-    val jmhVersion: String,
-    val benchmark: String,
-    val mode: String,
-    val threads: Int,
-    val forks: Int,
-    val jvm: String,
-    val jvmArgs: List<String>,
-    val jdkVersion: String,
-    val vmName: String,
-    val vmVersion: String,
-    val warmupIterations: Int,
-    val warmupTime: String,
-    val warmupBatchSize: Int,
-    val measurementIterations: Int,
-    val measurementTime: String,
-    val measurementBatchSize: Int,
-    val params: Map<String, String> = emptyMap(),
-    val primaryMetric: PrimaryMetric,
-    val secondaryMetrics: Map<String, SecondaryMetric>,
-) {
-    interface Metric {
-        val score: Double
-        val scoreError: Double
-        val scoreConfidence: List<Double>
-        val scorePercentiles: Map<Double, Double>
-        val scoreUnit: String
-    }
-
-    data class PrimaryMetric(
-        override val score: Double,
-        override val scoreError: Double,
-        override val scoreConfidence: List<Double>,
-        override val scorePercentiles: Map<Double, Double>,
-        override val scoreUnit: String,
-        val rawDataHistogram: List<List<List<List<Double>>>>? = null,
-        val rawData: List<List<Double>>? = null,
-    ) : Metric
-
-    data class SecondaryMetric(
-        override val score: Double,
-        override val scoreError: Double,
-        override val scoreConfidence: List<Double>,
-        override val scorePercentiles: Map<Double, Double>,
-        override val scoreUnit: String,
-        val rawData: List<List<Double>>,
-    ) : Metric
-}

buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/addBenchmarkProperties.kt

@@ -1,110 +0,0 @@
-/*
- * Copyright 2018-2024 KMath contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package space.kscience.kmath.benchmarks
-
-import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-import com.fasterxml.jackson.module.kotlin.readValue
-import kotlinx.benchmark.gradle.BenchmarksExtension
-import org.gradle.api.Project
-import space.kscience.gradle.KScienceReadmeExtension
-import java.time.LocalDateTime
-import java.time.ZoneId
-import java.time.format.DateTimeFormatter
-import java.time.format.DateTimeFormatterBuilder
-import java.time.format.SignStyle
-import java.time.temporal.ChronoField.*
-import java.util.*
-
-private val ISO_DATE_TIME: DateTimeFormatter = DateTimeFormatterBuilder().run {
-    parseCaseInsensitive()
-    appendValue(YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
-    appendLiteral('-')
-    appendValue(MONTH_OF_YEAR, 2)
-    appendLiteral('-')
-    appendValue(DAY_OF_MONTH, 2)
-    appendLiteral('T')
-    appendValue(HOUR_OF_DAY, 2)
-    appendLiteral('.')
-    appendValue(MINUTE_OF_HOUR, 2)
-    optionalStart()
-    appendLiteral('.')
-    appendValue(SECOND_OF_MINUTE, 2)
-    optionalStart()
-    appendFraction(NANO_OF_SECOND, 0, 9, true)
-    optionalStart()
-    appendOffsetId()
-    optionalStart()
-    appendLiteral('[')
-    parseCaseSensitive()
-    appendZoneRegionId()
-    appendLiteral(']')
-    toFormatter()
-}
-
-private fun noun(number: Number, singular: String, plural: String) = if (number.toLong() == 1L) singular else plural
-
-private val jsonMapper = jacksonObjectMapper()
-
-fun Project.addBenchmarkProperties() {
-    val benchmarksProject = this
-    rootProject.subprojects.forEach { p ->
-        p.extensions.findByType(KScienceReadmeExtension::class.java)?.run {
-            benchmarksProject.extensions.findByType(BenchmarksExtension::class.java)?.configurations?.forEach { cfg ->
-                property("benchmark${cfg.name.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }}") {
-                    val launches = benchmarksProject.layout.buildDirectory.dir("reports/benchmarks/${cfg.name}").get()
-
-                    val resDirectory = launches.files().maxByOrNull {
-                        LocalDateTime.parse(it.name, ISO_DATE_TIME).atZone(ZoneId.systemDefault()).toInstant()
-                    }
-
-                    if (resDirectory == null || !(resDirectory.resolve("jvm.json")).exists()) {
-                        "> **Can't find appropriate benchmark data. Try generating readme files after running benchmarks**."
-                    } else {
-                        val reports: List<JmhReport> =
-                            jsonMapper.readValue<List<JmhReport>>(resDirectory.resolve("jvm.json"))
-
-                        buildString {
-                            appendLine("<details>")
-                            appendLine("<summary>")
-                            appendLine("Report for benchmark configuration <code>${cfg.name}</code>")
-                            appendLine("</summary>")
-                            appendLine()
-                            val first = reports.first()
-
-                            appendLine("* Run on ${first.vmName} (build ${first.vmVersion}) with Java process:")
-                            appendLine()
-                            appendLine("```")
-                            appendLine(
-                                "${first.jvm} ${
-                                    first.jvmArgs.joinToString(" ")
-                                }"
-                            )
-                            appendLine("```")
-
-                            appendLine(
-                                "* JMH ${first.jmhVersion} was used in `${first.mode}` mode with ${first.warmupIterations} warmup ${
-                                    noun(first.warmupIterations, "iteration", "iterations")
-                                } by ${first.warmupTime} and ${first.measurementIterations} measurement ${
-                                    noun(first.measurementIterations, "iteration", "iterations")
-                                } by ${first.measurementTime}."
-                            )
-
-                            appendLine()
-                            appendLine("| Benchmark | Score |")
-                            appendLine("|:---------:|:-----:|")
-
-                            reports.forEach { report ->
-                                appendLine("|`${report.benchmark}`|${report.primaryMetric.score} &plusmn; ${report.primaryMetric.scoreError} ${report.primaryMetric.scoreUnit}|")
-                            }
-
-                            appendLine("</details>")
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

gradle.properties

@@ -11,5 +11,3 @@ org.gradle.parallel=true
 org.gradle.workers.max=4
 
 toolsVersion=0.15.4-kotlin-2.0.0
-#kotlin.experimental.tryK2=true
-#kscience.wasm.disabled=true

gradle/libs.versions.toml

@@ -10,3 +10,5 @@ commons-rng-sampling = { module = "org.apache.commons:commons-rng-sampling", ver
 
 multik-core = { module = "org.jetbrains.kotlinx:multik-core", version.ref = "multik" }
 multik-default = { module = "org.jetbrains.kotlinx:multik-default", version.ref = "multik" }
+
+[plugins]

kmath-commons/src/jvmMain/kotlin/space/kscience/kmath/commons/linear/CMMatrix.kt

@@ -109,6 +109,7 @@ public object CMLinearSpace : LinearSpace<Double, Float64Field> {
     override fun Double.times(v: Point<Float64>): CMVector =
         v * this
 
+    @OptIn(UnstableKMathAPI::class)
     override fun <V, A : StructureAttribute<V>> computeAttribute(structure: Structure2D<Float64>, attribute: A): V? {
 
         val origin = structure.toCM().origin

kmath-ejml/src/jvmMain/kotlin/space/kscience/kmath/ejml/implementations.kt

@@ -21,6 +21,7 @@ import org.ejml.sparse.csc.factory.DecompositionFactory_DSCC
 import org.ejml.sparse.csc.factory.DecompositionFactory_FSCC
 import space.kscience.attributes.SafeType
 import space.kscience.attributes.safeTypeOf
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.complex.Complex
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.linear.Matrix
@@ -216,6 +217,7 @@ public object EjmlLinearSpaceDDRM : EjmlLinearSpace<Double, Float64Field, DMatri
 
     override fun Double.times(v: Point<Float64>): EjmlDoubleVector<DMatrixRMaj> = v * this
 
+    @OptIn(UnstableKMathAPI::class)
     override fun <V, A : StructureAttribute<V>> computeAttribute(structure: Structure2D<Float64>, attribute: A): V? {
         val origin: DMatrixRMaj = structure.toEjml().origin
 

kmath-stat/src/commonTest/kotlin/space/kscience/kmath/samplers/TestMetropolisHastingsSampler.kt

@@ -24,7 +24,7 @@ class TestMetropolisHastingsSampler {
 
     data class TestSetup(val mean: Double, val startPoint: Double, val sigma: Double = 0.5)
 
-    private val sample = 1e6.toInt()
+    private val sample = 1e5.toInt()
     private val burnIn = sample / 5
 
     @Test
@@ -40,7 +40,7 @@ class TestMetropolisHastingsSampler {
                 .univariateNormal(it.startPoint, it.sigma, distribution::probability)
             val sampledValues = sampler.sample(generator).discard(burnIn).nextBuffer(sample)
 
-            assertEquals(it.mean, Float64Field.mean(sampledValues), 1e-2)
+            assertEquals(it.mean, Float64Field.mean(sampledValues), 0.05)
         }
     }
 
@@ -59,7 +59,7 @@ class TestMetropolisHastingsSampler {
             }
             val sampledValues = sampler.sample(generator).discard(burnIn).nextBuffer(sample)
 
-            assertEquals(1.0 / setup.mean, Float64Field.mean(sampledValues), 1e-2)
+            assertEquals(1.0 / setup.mean, Float64Field.mean(sampledValues), 0.1)
         }
     }
 
@@ -82,7 +82,7 @@ class TestMetropolisHastingsSampler {
             }
             val sampledValues = sampler.sample(generator).discard(burnIn).nextBuffer(sample)
 
-            assertEquals(setup.mean * sqrt(PI / 2), Float64Field.mean(sampledValues), 1e-2)
+            assertEquals(setup.mean * sqrt(PI / 2), Float64Field.mean(sampledValues), 0.05)
         }
     }
 

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

@@ -18,7 +18,7 @@ public class RandomSourceGenerator internal constructor(
     public val source: RandomSource,
     seed: Long?,
 ) : RandomGenerator {
-    internal val random: UniformRandomProvider = seed?.let { RandomSource.create(source, seed) }
+    internal val random: UniformRandomProvider = seed?.let { source.create(seed) }
         ?: RandomSource.create(source)
 
     override fun nextBoolean(): Boolean = random.nextBoolean()

settings.gradle.kts

@@ -2,14 +2,31 @@ rootProject.name = "kmath"
 
 enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
 
+pluginManagement {
+    val toolsVersion: String by extra
+
+    repositories {
+        mavenLocal()
+        gradlePluginPortal()
+        mavenCentral()
+        maven("https://repo.kotlin.link")
+    }
+
+    plugins {
+        id("space.kscience.gradle.project") version toolsVersion
+        id("space.kscience.gradle.mpp") version toolsVersion
+        id("space.kscience.gradle.jvm") version toolsVersion
+    }
+}
+
 dependencyResolutionManagement {
     val toolsVersion: String by extra
 
     repositories {
         mavenLocal()
-        maven("https://repo.kotlin.link")
-        mavenCentral()
         gradlePluginPortal()
+        mavenCentral()
+        maven("https://repo.kotlin.link")
     }
 
     versionCatalogs {