latest dev

.gitignore

@@ -19,3 +19,4 @@ out/
 
 !/.idea/copyright/
 !/.idea/scopes/
+/kotlin-js-store/yarn.lock

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

@@ -15,8 +15,10 @@ import space.kscience.kmath.linear.invoke
 import space.kscience.kmath.linear.linearSpace
 import space.kscience.kmath.multik.multikAlgebra
 import space.kscience.kmath.operations.DoubleField
+import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.tensorflow.produceWithTF
+import space.kscience.kmath.tensors.core.DoubleTensorAlgebra
 import space.kscience.kmath.tensors.core.tensorAlgebra
 import kotlin.random.Random
 
@@ -90,4 +92,9 @@ internal class DotBenchmark {
     fun doubleDot(blackhole: Blackhole) = with(DoubleField.linearSpace) {
         blackhole.consume(matrix1 dot matrix2)
     }
+
+    @Benchmark
+    fun doubleTensorDot(blackhole: Blackhole) = DoubleTensorAlgebra.invoke {
+        blackhole.consume(matrix1 dot matrix2)
+    }
 }

build.gradle.kts

@@ -1,16 +1,17 @@
 plugins {
     id("ru.mipt.npm.gradle.project")
-    id("org.jetbrains.kotlinx.kover") version "0.5.0-RC"
+    id("org.jetbrains.kotlinx.kover") version "0.5.0"
 }
 
 allprojects {
     repositories {
+        maven("https://repo.kotlin.link")
         maven("https://oss.sonatype.org/content/repositories/snapshots")
         mavenCentral()
     }
 
     group = "space.kscience"
-    version = "0.3.0-dev-19"
+    version = "0.3.0-dev-20"
 }
 
 subprojects {

buildSrc/build.gradle.kts

@@ -7,6 +7,7 @@ plugins {
 java.targetCompatibility = JavaVersion.VERSION_11
 
 repositories {
+    mavenLocal()
     maven("https://repo.kotlin.link")
     mavenCentral()
     gradlePluginPortal()
@@ -14,7 +15,7 @@ repositories {
 
 val toolsVersion: String by extra
 val kotlinVersion = npmlibs.versions.kotlin.asProvider().get()
-val benchmarksVersion = "0.4.2"
+val benchmarksVersion = npmlibs.versions.kotlinx.benchmark.get()
 
 dependencies {
     api("ru.mipt.npm:gradle-tools:$toolsVersion")

buildSrc/gradle.properties

@@ -4,11 +4,5 @@
 #
 
 kotlin.code.style=official
-kotlin.mpp.stability.nowarn=true
 
-kotlin.jupyter.add.scanner=false
-
-org.gradle.configureondemand=true
-org.gradle.parallel=true
-
-toolsVersion=0.10.9-kotlin-1.6.10
+toolsVersion=0.11.1-kotlin-1.6.10

buildSrc/settings.gradle.kts

@@ -3,7 +3,6 @@
  * 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")
 enableFeaturePreview("VERSION_CATALOGS")
 
@@ -12,8 +11,10 @@ dependencyResolutionManagement {
     val toolsVersion: String by extra
 
     repositories {
+        mavenLocal()
         maven("https://repo.kotlin.link")
         mavenCentral()
+        gradlePluginPortal()
     }
 
     versionCatalogs {
@@ -21,4 +22,4 @@ dependencyResolutionManagement {
             from("ru.mipt.npm:version-catalog:$toolsVersion")
         }
     }
-}
+}

examples/src/main/kotlin/space/kscience/kmath/functions/interpolateSquare.kt

@@ -5,8 +5,8 @@
 
 package space.kscience.kmath.functions
 
-import space.kscience.kmath.interpolation.SplineInterpolator
 import space.kscience.kmath.interpolation.interpolatePolynomials
+import space.kscience.kmath.interpolation.splineInterpolator
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.real.map
 import space.kscience.kmath.real.step
@@ -28,7 +28,7 @@ fun main() {
     val xs = 0.0..100.0 step 0.5
     val ys = xs.map(function)
 
-    val polynomial: PiecewisePolynomial<Double> = SplineInterpolator.double.interpolatePolynomials(xs, ys)
+    val polynomial: PiecewisePolynomial<Double> = DoubleField.splineInterpolator.interpolatePolynomials(xs, ys)
 
     val polyFunction = polynomial.asFunction(DoubleField, 0.0)
 

gradle.properties

@@ -5,11 +5,10 @@
 
 kotlin.code.style=official
 kotlin.mpp.stability.nowarn=true
+kotlin.native.ignoreDisabledTargets=true
 
 kotlin.jupyter.add.scanner=false
 
 org.gradle.configureondemand=true
 org.gradle.parallel=true
 org.gradle.jvmargs=-XX:MaxMetaspaceSize=1G
-
-toolsVersion=0.11.1-kotlin-1.6.10

kmath-functions/src/commonMain/kotlin/space/kscience/kmath/integration/SplineIntegrator.kt

@@ -28,6 +28,8 @@ public fun <T : Comparable<T>> PiecewisePolynomial<T>.integrate(algebra: Field<T
 /**
  * Compute definite integral of given [PiecewisePolynomial] piece by piece in a given [range]
  * Requires [UnivariateIntegrationNodes] or [IntegrationRange] and [IntegrandMaxCalls]
+ *
+ * TODO use context receiver for algebra
  */
 @UnstableKMathAPI
 public fun <T : Comparable<T>> PiecewisePolynomial<T>.integrate(
@@ -98,6 +100,7 @@ public object DoubleSplineIntegrator : UnivariateIntegrator<Double> {
     }
 }
 
+@Suppress("unused")
 @UnstableKMathAPI
 public inline val DoubleField.splineIntegrator: UnivariateIntegrator<Double>
     get() = DoubleSplineIntegrator

kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/Interpolator.kt

@@ -9,6 +9,7 @@ package space.kscience.kmath.interpolation
 
 import space.kscience.kmath.data.XYColumnarData
 import space.kscience.kmath.functions.PiecewisePolynomial
+import space.kscience.kmath.functions.asFunction
 import space.kscience.kmath.functions.value
 import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.Ring
@@ -59,3 +60,33 @@ public fun <T : Comparable<T>> PolynomialInterpolator<T>.interpolatePolynomials(
     val pointSet = XYColumnarData.of(data.map { it.first }.asBuffer(), data.map { it.second }.asBuffer())
     return interpolatePolynomials(pointSet)
 }
+
+public fun <T : Comparable<T>> PolynomialInterpolator<T>.interpolate(
+    x: Buffer<T>,
+    y: Buffer<T>,
+): (T) -> T? = interpolatePolynomials(x, y).asFunction(algebra)
+
+public fun <T : Comparable<T>> PolynomialInterpolator<T>.interpolate(
+    data: Map<T, T>,
+): (T) -> T? = interpolatePolynomials(data).asFunction(algebra)
+
+public fun <T : Comparable<T>> PolynomialInterpolator<T>.interpolate(
+    data: List<Pair<T, T>>,
+): (T) -> T? = interpolatePolynomials(data).asFunction(algebra)
+
+
+public fun <T : Comparable<T>> PolynomialInterpolator<T>.interpolate(
+    x: Buffer<T>,
+    y: Buffer<T>,
+    defaultValue: T,
+): (T) -> T = interpolatePolynomials(x, y).asFunction(algebra, defaultValue)
+
+public fun <T : Comparable<T>> PolynomialInterpolator<T>.interpolate(
+    data: Map<T, T>,
+    defaultValue: T,
+): (T) -> T = interpolatePolynomials(data).asFunction(algebra, defaultValue)
+
+public fun <T : Comparable<T>> PolynomialInterpolator<T>.interpolate(
+    data: List<Pair<T, T>>,
+    defaultValue: T,
+): (T) -> T = interpolatePolynomials(data).asFunction(algebra, defaultValue)

kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/LinearInterpolator.kt

@@ -22,6 +22,7 @@ internal fun <T : Comparable<T>> insureSorted(points: XYColumnarData<*, T, *>) {
  * Reference JVM implementation: https://github.com/apache/commons-math/blob/master/src/main/java/org/apache/commons/math4/analysis/interpolation/LinearInterpolator.java
  */
 public class LinearInterpolator<T : Comparable<T>>(override val algebra: Field<T>) : PolynomialInterpolator<T> {
+
     @OptIn(UnstableKMathAPI::class)
     override fun interpolatePolynomials(points: XYColumnarData<T, T, T>): PiecewisePolynomial<T> = algebra {
         require(points.size > 0) { "Point array should not be empty" }
@@ -37,3 +38,6 @@ public class LinearInterpolator<T : Comparable<T>>(override val algebra: Field<T
         }
     }
 }
+
+public val <T : Comparable<T>> Field<T>.linearInterpolator: LinearInterpolator<T>
+    get() = LinearInterpolator(this)

kmath-functions/src/commonMain/kotlin/space/kscience/kmath/interpolation/SplineInterpolator.kt

@@ -63,8 +63,8 @@ public class SplineInterpolator<T : Comparable<T>>(
                 //Shift coefficients to represent absolute polynomial instead of one with an offset
                 val polynomial = Polynomial(
                     a - b * x0 + c * x02 - d * x03,
-                    b - 2*c*x0 + 3*d*x02,
-                    c - 3*d*x0,
+                    b - 2 * c * x0 + 3 * d * x02,
+                    c - 3 * d * x0,
                     d
                 )
                 cOld = c
@@ -72,8 +72,12 @@ public class SplineInterpolator<T : Comparable<T>>(
             }
         }
     }
-
-    public companion object {
-        public val double: SplineInterpolator<Double> = SplineInterpolator(DoubleField, ::DoubleBuffer)
-    }
 }
+
+
+public fun <T : Comparable<T>> Field<T>.splineInterpolator(
+    bufferFactory: MutableBufferFactory<T>,
+): SplineInterpolator<T> = SplineInterpolator(this, bufferFactory)
+
+public val DoubleField.splineInterpolator: SplineInterpolator<Double>
+    get() = SplineInterpolator(this, ::DoubleBuffer)

kmath-functions/src/commonTest/kotlin/space/kscience/kmath/interpolation/LinearInterpolatorTest.kt

@@ -5,8 +5,6 @@
 
 package space.kscience.kmath.interpolation
 
-import space.kscience.kmath.functions.PiecewisePolynomial
-import space.kscience.kmath.functions.asFunction
 import space.kscience.kmath.operations.DoubleField
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -21,8 +19,8 @@ internal class LinearInterpolatorTest {
             3.0 to 4.0
         )
 
-        val polynomial: PiecewisePolynomial<Double> = LinearInterpolator(DoubleField).interpolatePolynomials(data)
-        val function = polynomial.asFunction(DoubleField)
+        //val polynomial: PiecewisePolynomial<Double> = DoubleField.linearInterpolator.interpolatePolynomials(data)
+        val function = DoubleField.linearInterpolator.interpolate(data)
         assertEquals(null, function(-1.0))
         assertEquals(0.5, function(0.5))
         assertEquals(2.0, function(1.5))

kmath-functions/src/commonTest/kotlin/space/kscience/kmath/interpolation/SplineInterpolatorTest.kt

@@ -5,8 +5,6 @@
 
 package space.kscience.kmath.interpolation
 
-import space.kscience.kmath.functions.PiecewisePolynomial
-import space.kscience.kmath.functions.asFunction
 import space.kscience.kmath.operations.DoubleField
 import kotlin.math.PI
 import kotlin.math.sin
@@ -21,9 +19,10 @@ internal class SplineInterpolatorTest {
             x to sin(x)
         }
 
-        val polynomial: PiecewisePolynomial<Double> = SplineInterpolator.double.interpolatePolynomials(data)
+        //val polynomial: PiecewisePolynomial<Double> = DoubleField.splineInterpolator.interpolatePolynomials(data)
+
+        val function = DoubleField.splineInterpolator.interpolate(data, Double.NaN)
 
-        val function = polynomial.asFunction(DoubleField, Double.NaN)
         assertEquals(Double.NaN, function(-1.0))
         assertEquals(sin(0.5), function(0.5), 0.1)
         assertEquals(sin(1.5), function(1.5), 0.1)

kmath-multik/src/test/kotlin/space/kscience/kmath/multik/MultikNDTest.kt

@@ -6,13 +6,38 @@
 package space.kscience.kmath.multik
 
 import org.junit.jupiter.api.Test
+import space.kscience.kmath.nd.StructureND
 import space.kscience.kmath.nd.one
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.operations.invoke
+import space.kscience.kmath.tensors.core.DoubleTensorAlgebra
+import space.kscience.kmath.tensors.core.tensorAlgebra
+import kotlin.test.assertTrue
 
 internal class MultikNDTest {
     @Test
     fun basicAlgebra(): Unit = DoubleField.multikAlgebra{
         one(2,2) + 1.0
     }
+
+    @Test
+    fun dotResult(){
+        val dim = 100
+
+        val tensor1 = DoubleTensorAlgebra.randomNormal(shape = intArrayOf(dim, dim), 12224)
+        val tensor2 = DoubleTensorAlgebra.randomNormal(shape = intArrayOf(dim, dim), 12225)
+
+        val multikResult = with(DoubleField.multikAlgebra){
+            tensor1 dot tensor2
+        }
+
+        val defaultResult = with(DoubleField.tensorAlgebra){
+            tensor1 dot tensor2
+        }
+
+        assertTrue {
+            StructureND.contentEquals(multikResult, defaultResult)
+        }
+
+    }
 }

kmath-tensorflow/src/test/kotlin/space/kscience/kmath/tensorflow/DoubleTensorFlowOps.kt

@@ -6,7 +6,6 @@ import space.kscience.kmath.nd.structureND
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.tensors.core.DoubleTensorAlgebra
 import space.kscience.kmath.tensors.core.DoubleTensorAlgebra.Companion.sum
-import kotlin.random.Random
 import kotlin.test.assertEquals
 
 class DoubleTensorFlowOps {
@@ -23,7 +22,6 @@ class DoubleTensorFlowOps {
 
     @Test
     fun dot(){
-        val random = Random(12224)
         val dim = 1000
 
         val tensor1 = DoubleTensorAlgebra.randomNormal(shape = intArrayOf(dim, dim), 12224)

settings.gradle.kts

@@ -3,22 +3,6 @@ rootProject.name = "kmath"
 enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
 enableFeaturePreview("VERSION_CATALOGS")
 
-dependencyResolutionManagement {
-
-    val toolsVersion: String by extra
-
-    repositories {
-        maven("https://repo.kotlin.link")
-        mavenCentral()
-    }
-
-    versionCatalogs {
-        create("npmlibs") {
-            from("ru.mipt.npm:version-catalog:$toolsVersion")
-        }
-    }
-}
-
 include(
     ":kmath-memory",
     ":kmath-complex",