2023-06-19 16:11:59 +03:00
260 changed files with 2194 additions and 1500 deletions
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@ -15,7 +15,7 @@ jobs:
    runs-on: ${{matrix.os}}
    steps:
      - uses: actions/checkout@v3.0.0
-      - uses: actions/setup-java@v3.0.0
+      - uses: actions/setup-java@v3.10.0
        with:
          java-version: 11
          distribution: liberica
@ -26,26 +26,25 @@ jobs:
          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
          restore-keys: |
            ${{ runner.os }}-gradle-
-      - uses: gradle/wrapper-validation-action@v1.0.4
      - name: Publish Windows Artifacts
        if: matrix.os == 'windows-latest'
-        uses: gradle/gradle-build-action@v2.1.5
+        uses: gradle/gradle-build-action@v2.4.0
        with:
          arguments: |
-            releaseAll
-            -Ppublishing.enabled=true
-            -Ppublishing.sonatype=false
+            publishAllPublicationsToSpaceRepository
+            -Ppublishing.targets=all
            -Ppublishing.space.user=${{ secrets.SPACE_APP_ID }}
            -Ppublishing.space.token=${{ secrets.SPACE_APP_SECRET }}
      - name: Publish Mac Artifacts
        if: matrix.os == 'macOS-latest'
-        uses: gradle/gradle-build-action@v2.1.5
+        uses: gradle/gradle-build-action@v2.4.0
        with:
          arguments: |
-            releaseMacosX64
-            releaseIosArm64
-            releaseIosX64
-            -Ppublishing.enabled=true
-            -Ppublishing.sonatype=false            
+            publishMacosX64PublicationToSpaceRepository
+            publishMacosArm64PublicationToSpaceRepository
+            publishIosX64PublicationToSpaceRepository
+            publishIosArm64PublicationToSpaceRepository
+            publishIosSimulatorArm64PublicationToSpaceRepository
+            -Ppublishing.targets=all
            -Ppublishing.space.user=${{ secrets.SPACE_APP_ID }}
            -Ppublishing.space.token=${{ secrets.SPACE_APP_SECRET }}
--- a/.gitignore
+++ b/.gitignore
@ -3,10 +3,9 @@ build/
 out/

 .idea/
-
-
 .vscode/

+
 # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
 !gradle-wrapper.jar

@ -19,4 +18,5 @@ out/

 !/.idea/copyright/
 !/.idea/scopes/
-/kotlin-js-store/yarn.lock
+/gradle/yarn.lock
+
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,32 +1,47 @@
 # KMath

-## [Unreleased]
+## Unreleased
+
 ### Added
- Type-aliases for numbers like `Float64`
- 2D optimal trajectory computation in a separate module `kmath-trajectory`
- Autodiff for generic algebra elements in core!
- Algebra now has an obligatory `bufferFactory` (#477).

 ### Changed
- Tensor operations switched to prefix notation
- Row-wise and column-wise ND shapes in the core
- Shape is read-only
- Major refactor of tensors (only minor API changes)
- Kotlin 1.7.20
- `LazyStructure` `deffered` -> `async` to comply with coroutines code style
- Default `dot` operation in tensor algebra no longer support broadcasting. Instead `matmul` operation is added to `DoubleTensorAlgebra`.
- Multik went MPP

 ### Deprecated

 ### Removed
- Polynomials moved to https://github.com/SciProgCentre/kmath-polynomial

 ### Fixed

 ### Security

-## [0.3.0]
+## 0.3.1-dev-RC - 2023-04-09
+
+### Added
+- Wasm support for `memory`, `core`, `complex` and `functions` modules.
+- Generic builders for `BufferND` and `MutableBufferND`
+- `NamedMatrix` - matrix with symbol-based indexing
+- `Expression` with default arguments
+- Type-aliases for numbers like `Float64`
+- Autodiff for generic algebra elements in core!
+- Algebra now has an obligatory `bufferFactory` (#477).
+
+### Changed
+- Geometry uses type-safe angles
+- Tensor operations switched to prefix notation
+- Row-wise and column-wise ND shapes in the core
+- Shape is read-only
+- Major refactor of tensors (only minor API changes)
+- Kotlin 1.8.20
+- `LazyStructure` `deffered` -> `async` to comply with coroutines code style
+- Default `dot` operation in tensor algebra no longer support broadcasting. Instead `matmul` operation is added to `DoubleTensorAlgebra`.
+- Multik went MPP
+
+### Removed
+- Trajectory moved to https://github.com/SciProgCentre/maps-kt
+- Polynomials moved to https://github.com/SciProgCentre/kmath-polynomial
+
+## 0.3.0
+
 ### Added
 - `ScaleOperations` interface
 - `Field` extends `ScaleOperations`
@ -51,8 +66,8 @@
 - `contentEquals` with tolerance: #364
 - Compilation to TeX for MST: #254

-
 ### Changed
+- Annotations moved to `space.kscience.kmath`
 - Exponential operations merged with hyperbolic functions
 - Space is replaced by Group. Space is reserved for vector spaces.
 - VectorSpace is now a vector space
@ -84,11 +99,9 @@
 - Rework of histograms.
 - `UnivariateFunction` -> `Function1D`, `MultivariateFunction` -> `FunctionND`

-
 ### Deprecated
 - Specialized `DoubleBufferAlgebra`

-
 ### Removed
 - Nearest in Domain. To be implemented in geometry package.
 - Number multiplication and division in main Algebra chain
@ -99,15 +112,12 @@
 - Second generic from DifferentiableExpression
 - Algebra elements are completely removed. Use algebra contexts instead.

-
 ### Fixed
 - Ring inherits RingOperations, not GroupOperations
 - Univariate histogram filling

+## 0.2.0

-### Security
-
-## [0.2.0]
 ### Added
 - `fun` annotation for SAM interfaces in library
 - Explicit `public` visibility for all public APIs
@ -127,7 +137,6 @@
 - New `MatrixFeature` interfaces for matrix decompositions
 - Basic Quaternion vector support in `kmath-complex`.

-
 ### Changed
 - Package changed from `scientifik` to `space.kscience`
 - Gradle version: 6.6 -> 6.8.2
@ -152,7 +161,6 @@
 - `symbol` method in `Algebra` renamed to `bindSymbol` to avoid ambiguity
 - Add `out` projection to `Buffer` generic

-
 ### Removed
 - `kmath-koma` module because it doesn't support Kotlin 1.4.
 - Support of `legacy` JS backend (we will support only IR)
@ -161,11 +169,11 @@
 - `Real` class
 - StructureND identity and equals

-
 ### Fixed
 - `symbol` method in `MstExtendedField` (https://github.com/mipt-npm/kmath/pull/140)

-## [0.1.4]
+## 0.1.4
+
 ### Added
 - Functional Expressions API
 - Mathematical Syntax Tree, its interpreter and API
@ -183,7 +191,6 @@
 - Full hyperbolic functions support and default implementations within `ExtendedField`
 - Norm support for `Complex`

-
 ### Changed
 - `readAsMemory` now has `throws IOException` in JVM signature.
 - Several functions taking functional types were made `inline`.
@ -195,7 +202,6 @@
 - Gradle version: 6.3 -> 6.6
 - Moved probability distributions to commons-rng and to `kmath-prob`

-
 ### Fixed
 - Missing copy method in Memory implementation on JS (https://github.com/mipt-npm/kmath/pull/106)
 - D3.dim value in `kmath-dimensions`
--- a/README.md
+++ b/README.md
@ -214,28 +214,6 @@ One can still use generic algebras though.
 >
 > **Maturity**: EXPERIMENTAL

-### [kmath-polynomial](kmath-polynomial)
-> 
->
-> **Maturity**: PROTOTYPE
->
-> **Features:**
-> - [polynomial abstraction](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/Polynomial.kt) : Abstraction for polynomial spaces.
-> - [rational function abstraction](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/RationalFunction.kt) : Abstraction for rational functions spaces.
-> - ["list" polynomials](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/ListRationalFunction.kt) : List implementation of univariate polynomials.
-> - ["list" rational functions](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/ListPolynomial.kt) : List implementation of univariate rational functions.
-> - ["list" polynomials and rational functions constructors](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/listConstructors.kt) : Constructors for list polynomials and rational functions.
-> - ["list" polynomials and rational functions utilities](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/listUtil.kt) : Utilities for list polynomials and rational functions.
-> - ["numbered" polynomials](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedRationalFunction.kt) : Numbered implementation of multivariate polynomials.
-> - ["numbered" rational functions](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedPolynomial.kt) : Numbered implementation of multivariate rational functions.
-> - ["numbered" polynomials and rational functions constructors](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/numberedConstructors.kt) : Constructors for numbered polynomials and rational functions.
-> - ["numbered" polynomials and rational functions utilities](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/numberedUtil.kt) : Utilities for numbered polynomials and rational functions.
-> - ["labeled" polynomials](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledRationalFunction.kt) : Labeled implementation of multivariate polynomials.
-> - ["labeled" rational functions](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledPolynomial.kt) : Labeled implementation of multivariate rational functions.
-> - ["labeled" polynomials and rational functions constructors](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/labeledConstructors.kt) : Constructors for labeled polynomials and rational functions.
-> - ["labeled" polynomials and rational functions utilities](kmath-polynomial/src/commonMain/kotlin/space/kscience/kmath/functions/labeledUtil.kt) : Utilities for labeled polynomials and rational functions.
-
-
 ### [kmath-stat](kmath-stat)
 > 
 >
@ -262,11 +240,6 @@ One can still use generic algebras though.
 > - [linear algebra operations](kmath-tensors/src/commonMain/kotlin/space/kscience/kmath/tensors/api/LinearOpsTensorAlgebra.kt) : Advanced linear algebra operations like LU decomposition, SVD, etc.


-### [kmath-trajectory](kmath-trajectory)
-> Path and trajectory optimization
->
-> **Maturity**: PROTOTYPE
-
 ### [kmath-viktor](kmath-viktor)
 > 
 >
@ -325,4 +298,4 @@ Gradle `6.0+` is required for multiplatform artifacts.
 The project requires a lot of additional work. The most important thing we need is a feedback about what features are
 required the most. Feel free to create feature requests. We are also welcome to code contributions, especially in issues
 marked with
-[waiting for a hero](https://github.com/SciProgCentre/kmath/labels/waiting%20for%20a%20hero) label.
+[waiting for a hero](https://github.com/mipt-npm/kmath/labels/waiting%20for%20a%20hero) label.
--- a/benchmarks/build.gradle.kts
+++ b/benchmarks/build.gradle.kts
@ -5,7 +5,7 @@ import space.kscience.kmath.benchmarks.addBenchmarkProperties

 plugins {
    kotlin("multiplatform")
-    kotlin("plugin.allopen")
+    alias(spclibs.plugins.kotlin.plugin.allopen)
    id("org.jetbrains.kotlinx.benchmark")
 }

@ -44,7 +44,7 @@ kotlin {
                implementation(project(":kmath-tensors"))
                implementation(project(":kmath-multik"))
                implementation("org.jetbrains.kotlinx:multik-default:$multikVersion")
-                implementation(npmlibs.kotlinx.benchmark.runtime)
+                implementation(spclibs.kotlinx.benchmark.runtime)
            }
        }

@ -142,12 +142,10 @@ benchmark {
        commonConfiguration()
        include("ViktorLogBenchmark")
    }
-}

-// Fix kotlinx-benchmarks bug
-afterEvaluate {
-    val jvmBenchmarkJar by tasks.getting(org.gradle.jvm.tasks.Jar::class) {
-        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    configurations.register("integration") {
+        commonConfiguration()
+        include("IntegrationBenchmark")
    }
 }

--- a/benchmarks/src/jsMain/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
+++ b/benchmarks/src/jsMain/kotlin/space/kscience/kmath/benchmarks/ExpressionsInterpretersBenchmark.kt
@ -9,8 +9,8 @@ import kotlinx.benchmark.Benchmark
 import kotlinx.benchmark.Blackhole
 import kotlinx.benchmark.Scope
 import kotlinx.benchmark.State
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.expressions.*
-import space.kscience.kmath.operations.Algebra
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.operations.bindSymbol
 import space.kscience.kmath.operations.invoke
@ -94,6 +94,7 @@ class ExpressionsInterpretersBenchmark {
        }

        private val mst = node.toExpression(DoubleField)
+        @OptIn(UnstableKMathAPI::class)
        private val wasm = node.wasmCompileToExpression(DoubleField)
        private val estree = node.estreeCompileToExpression(DoubleField)

--- a/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/BigIntBenchmark.kt
+++ b/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/BigIntBenchmark.kt
@ -10,7 +10,7 @@ import kotlinx.benchmark.Blackhole
 import org.openjdk.jmh.annotations.Benchmark
 import org.openjdk.jmh.annotations.Scope
 import org.openjdk.jmh.annotations.State
-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.BigIntField
 import space.kscience.kmath.operations.JBigIntegerField
 import space.kscience.kmath.operations.invoke
--- a/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/IntegrationBenchmark.kt
+++ b/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/IntegrationBenchmark.kt
@ -0,0 +1,40 @@
+/*
+ * Copyright 2018-2023 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 org.openjdk.jmh.annotations.Benchmark
+import org.openjdk.jmh.annotations.Scope
+import org.openjdk.jmh.annotations.State
+import org.openjdk.jmh.infra.Blackhole
+import space.kscience.kmath.complex.Complex
+import space.kscience.kmath.complex.algebra
+import space.kscience.kmath.integration.gaussIntegrator
+import space.kscience.kmath.integration.integrate
+import space.kscience.kmath.integration.value
+import space.kscience.kmath.operations.algebra
+
+
+@State(Scope.Benchmark)
+internal class IntegrationBenchmark {
+
+    @Benchmark
+    fun doubleIntegration(blackhole: Blackhole) {
+        val res = Double.algebra.gaussIntegrator.integrate(0.0..1.0, intervals = 1000) { x: Double ->
+            //sin(1 / x)
+            1/x
+        }.value
+        blackhole.consume(res)
+    }
+
+    @Benchmark
+    fun complexIntegration(blackhole: Blackhole) = with(Complex.algebra) {
+        val res = gaussIntegrator.integrate(0.0..1.0, intervals = 1000) { x: Double ->
+//            sin(1 / x) + i * cos(1 / x)
+            1/x - i/x
+        }.value
+        blackhole.consume(res)
+    }
+}
--- a/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/NDFieldBenchmark.kt
+++ b/benchmarks/src/jvmMain/kotlin/space/kscience/kmath/benchmarks/NDFieldBenchmark.kt
@ -13,7 +13,7 @@ import org.jetbrains.kotlinx.multik.api.Multik
 import org.jetbrains.kotlinx.multik.api.ones
 import org.jetbrains.kotlinx.multik.ndarray.data.DN
 import org.jetbrains.kotlinx.multik.ndarray.data.DataType
-import space.kscience.kmath.misc.UnsafeKMathAPI
+import space.kscience.kmath.UnsafeKMathAPI
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.nd4j.nd4j
 import space.kscience.kmath.operations.DoubleField
--- a/build.gradle.kts
+++ b/build.gradle.kts
@ -15,7 +15,7 @@ allprojects {
    }

    group = "space.kscience"
-    version = "0.3.1-dev-7"
+    version = "0.3.1-dev-RC"
 }

 subprojects {
@ -55,18 +55,6 @@ subprojects {
            }
        }
    }
-
-    plugins.withId("org.jetbrains.kotlin.multiplatform") {
-        configure<org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension> {
-            sourceSets {
-                val commonTest by getting {
-                    dependencies {
-                        implementation(projects.testUtils)
-                    }
-                }
-            }
-        }
-    }
 }

 readme.readmeTemplate = file("docs/templates/README-TEMPLATE.md")
--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@ -1,7 +1,6 @@
 plugins {
    `kotlin-dsl`
    `version-catalog`
-    kotlin("plugin.serialization") version "1.6.21"
 }

 java.targetCompatibility = JavaVersion.VERSION_11
@ -13,18 +12,18 @@ repositories {
    gradlePluginPortal()
 }

-val toolsVersion = npmlibs.versions.tools.get()
-val kotlinVersion = npmlibs.versions.kotlin.asProvider().get()
-val benchmarksVersion = npmlibs.versions.kotlinx.benchmark.get()
+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")
-    api(npmlibs.atomicfu.gradle)
    //plugins form benchmarks
-    api("org.jetbrains.kotlinx:kotlinx-benchmark-plugin:$benchmarksVersion")
-    api("org.jetbrains.kotlin:kotlin-allopen:$kotlinVersion")
+    api("org.jetbrains.kotlinx:kotlinx-benchmark-plugin:0.4.7")
+    //api("org.jetbrains.kotlin:kotlin-allopen:$kotlinVersion")
    //to be used inside build-script only
-    implementation(npmlibs.kotlinx.serialization.json)
+    //implementation(spclibs.kotlinx.serialization.json)
+    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.14.+")
 }

 kotlin.sourceSets.all {
--- a/buildSrc/settings.gradle.kts
+++ b/buildSrc/settings.gradle.kts
@ -26,7 +26,7 @@ dependencyResolutionManagement {
    }

    versionCatalogs {
-        create("npmlibs") {
+        create("spclibs") {
            from("space.kscience:version-catalog:$toolsVersion")
        }
    }
--- a/buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/JmhReport.kt
+++ b/buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/JmhReport.kt
@ -5,9 +5,6 @@

 package space.kscience.kmath.benchmarks

-import kotlinx.serialization.Serializable
-
-@Serializable
 data class JmhReport(
    val jmhVersion: String,
    val benchmark: String,
@ -37,7 +34,6 @@ data class JmhReport(
        val scoreUnit: String
    }

-    @Serializable
    data class PrimaryMetric(
        override val score: Double,
        override val scoreError: Double,
@ -48,7 +44,6 @@ data class JmhReport(
        val rawData: List<List<Double>>? = null,
    ) : Metric

-    @Serializable
    data class SecondaryMetric(
        override val score: Double,
        override val scoreError: Double,
--- a/buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/addBenchmarkProperties.kt
+++ b/buildSrc/src/main/kotlin/space/kscience/kmath/benchmarks/addBenchmarkProperties.kt
@ -6,8 +6,8 @@
 package space.kscience.kmath.benchmarks

 import kotlinx.benchmark.gradle.BenchmarksExtension
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.json.Json
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
 import org.gradle.api.Project
 import space.kscience.gradle.KScienceReadmeExtension
 import java.time.LocalDateTime
@ -45,6 +45,8 @@ private val ISO_DATE_TIME: DateTimeFormatter = DateTimeFormatterBuilder().run {

 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 ->
@ -60,8 +62,7 @@ fun Project.addBenchmarkProperties() {
                    if (resDirectory == null || !(resDirectory.resolve("jvm.json")).exists()) {
                        "> **Can't find appropriate benchmark data. Try generating readme files after running benchmarks**."
                    } else {
-                        val reports =
-                            Json.decodeFromString<List<JmhReport>>(resDirectory.resolve("jvm.json").readText())
+                        val reports: List<JmhReport> = jsonMapper.readValue<List<JmhReport>>(resDirectory.resolve("jvm.json"))

                        buildString {
                            appendLine("<details>")
--- a/buildSrc/src/main/kotlin/space/kscience/kmath/ejml/codegen/ejmlCodegen.kt
+++ b/buildSrc/src/main/kotlin/space/kscience/kmath/ejml/codegen/ejmlCodegen.kt
@ -385,7 +385,7 @@ import org.ejml.sparse.csc.factory.LinearSolverFactory_DSCC
 import org.ejml.sparse.csc.factory.LinearSolverFactory_FSCC
 import space.kscience.kmath.linear.*
 import space.kscience.kmath.linear.Matrix
-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.nd.StructureFeature
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.operations.FloatField
--- a/examples/build.gradle.kts
+++ b/examples/build.gradle.kts
@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile
+
 plugins {
    kotlin("jvm")
 }
@ -33,6 +35,8 @@ dependencies {
    implementation(project(":kmath-multik"))
    implementation("org.jetbrains.kotlinx:multik-default:$multikVersion")

+    //datetime
+    implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.4.0")

    implementation("org.nd4j:nd4j-native:1.0.0-beta7")

@ -46,25 +50,24 @@ dependencies {
 //    } else
    implementation("org.nd4j:nd4j-native-platform:1.0.0-beta7")

-    // multik implementation
-    implementation("org.jetbrains.kotlinx:multik-default:0.1.0")
-
    implementation("org.slf4j:slf4j-simple:1.7.32")
    // plotting
    implementation("space.kscience:plotlykt-server:0.5.0")
 }

-kotlin.sourceSets.all {
+kotlin {
+    jvmToolchain(11)
+    sourceSets.all {
        with(languageSettings) {
            optIn("kotlin.contracts.ExperimentalContracts")
            optIn("kotlin.ExperimentalUnsignedTypes")
            optIn("space.kscience.kmath.misc.UnstableKMathAPI")
        }
    }
+}

-tasks.withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile> {
+tasks.withType<KotlinJvmCompile> {
    kotlinOptions {
-        jvmTarget = "11"
        freeCompilerArgs = freeCompilerArgs + "-Xjvm-default=all" + "-Xopt-in=kotlin.RequiresOptIn" + "-Xlambdas=indy"
    }
 }
--- a/examples/notebooks/Naive
+++ b/examples/notebooks/Naive
@ -0,0 +1,418 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "source": [
+    "%use kmath(0.3.1-dev-5)\n",
+    "%use plotly(0.5.0)\n",
+    "@file:DependsOn(\"space.kscience:kmath-commons:0.3.1-dev-5\")"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "lQbSB87rNAn9lV6poArVWW",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "//Uncomment to work in Jupyter classic or DataLore\n",
+    "//Plotly.jupyter.notebook()"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "0UP158hfccGgjQtHz0wAi6",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# The model\n",
+    "\n",
+    "Defining the input data format, the statistic abstraction and the statistic implementation based on a weighted sum of elements."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "class XYValues(val xValues: DoubleArray, val yValues: DoubleArray) {\n",
+    "    init {\n",
+    "        require(xValues.size == yValues.size)\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "fun interface XYStatistic {\n",
+    "    operator fun invoke(values: XYValues): Double\n",
+    "}\n",
+    "\n",
+    "class ConvolutionalXYStatistic(val weights: DoubleArray) : XYStatistic {\n",
+    "    override fun invoke(values: XYValues): Double {\n",
+    "        require(weights.size == values.yValues.size)\n",
+    "        val norm = values.yValues.sum()\n",
+    "        return values.yValues.zip(weights) { value, weight -> value * weight }.sum()/norm\n",
+    "    }\n",
+    "}"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "Zhgz1Ui91PWz0meJiQpHol",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# Generator\n",
+    "Generate sample data for parabolas and hyperbolas"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "fun generateParabolas(xValues: DoubleArray, a: Double, b: Double, c: Double): XYValues {\n",
+    "    val yValues = xValues.map { x -> a * x * x + b * x + c }.toDoubleArray()\n",
+    "    return XYValues(xValues, yValues)\n",
+    "}\n",
+    "\n",
+    "fun generateHyperbols(xValues: DoubleArray, gamma: Double, x0: Double, y0: Double): XYValues {\n",
+    "    val yValues = xValues.map { x -> y0 + gamma / (x - x0) }.toDoubleArray()\n",
+    "    return XYValues(xValues, yValues)\n",
+    "}"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "val xValues = (1.0..10.0).step(1.0).toDoubleArray()\n",
+    "\n",
+    "val xy = generateHyperbols(xValues, 1.0, 0.0, 0.0)\n",
+    "\n",
+    "Plotly.plot {\n",
+    "    scatter {\n",
+    "        this.x.doubles = xValues\n",
+    "        this.y.doubles = xy.yValues\n",
+    "    }\n",
+    "}"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "ZE2atNvFzQsCvpAF8KK4ch",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Create a default statistic with uniform weights"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "val statistic = ConvolutionalXYStatistic(DoubleArray(xValues.size){1.0})\n",
+    "statistic(xy)"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "EA5HaydTddRKYrtAUwd29h",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "import kotlin.random.Random\n",
+    "\n",
+    "val random = Random(1288)\n",
+    "\n",
+    "val parabolas = buildList{\n",
+    "    repeat(500){\n",
+    "        add(\n",
+    "            generateParabolas(\n",
+    "                xValues, \n",
+    "                random.nextDouble(), \n",
+    "                random.nextDouble(), \n",
+    "                random.nextDouble()\n",
+    "            )\n",
+    "        )\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "val hyperbolas: List<XYValues> =  buildList{\n",
+    "    repeat(500){\n",
+    "        add(\n",
+    "            generateHyperbols(\n",
+    "                xValues, \n",
+    "                random.nextDouble()*10, \n",
+    "                random.nextDouble(), \n",
+    "                random.nextDouble()\n",
+    "            )\n",
+    "        )\n",
+    "    }\n",
+    "}"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "t5t6IYmD7Q1ykeo9uijFfQ",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "Plotly.plot { \n",
+    "    scatter { \n",
+    "        x.doubles = xValues\n",
+    "        y.doubles = parabolas[257].yValues\n",
+    "    }\n",
+    "    scatter { \n",
+    "        x.doubles = xValues\n",
+    "        y.doubles = hyperbolas[252].yValues\n",
+    "    }\n",
+    " }"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "oXB8lmju7YVYjMRXITKnhO",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "Plotly.plot { \n",
+    "    histogram { \n",
+    "        name = \"parabolae\"\n",
+    "        x.numbers = parabolas.map { statistic(it) }\n",
+    "    }\n",
+    "    histogram { \n",
+    "        name = \"hyperbolae\"\n",
+    "        x.numbers = hyperbolas.map { statistic(it) }\n",
+    "    }\n",
+    "}"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "8EIIecUZrt2NNrOkhxG5P0",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "val lossFunction: (XYStatistic) -> Double = { statistic ->\n",
+    "    - abs(parabolas.sumOf { statistic(it) } - hyperbolas.sumOf { statistic(it) })\n",
+    "}"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "h7UmglJW5zXkAfKHK40oIL",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Using commons-math optimizer to optimize weights"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "import org.apache.commons.math3.optim.*\n",
+    "import org.apache.commons.math3.optim.nonlinear.scalar.*\n",
+    "import org.apache.commons.math3.optim.nonlinear.scalar.noderiv.*\n",
+    "\n",
+    "val optimizer = SimplexOptimizer(1e-1, Double.MAX_VALUE)\n",
+    "\n",
+    "val result = optimizer.optimize(\n",
+    "    ObjectiveFunction { point ->\n",
+    "        lossFunction(ConvolutionalXYStatistic(point))\n",
+    "    },\n",
+    "    NelderMeadSimplex(xValues.size),\n",
+    "    InitialGuess(DoubleArray(xValues.size){ 1.0 }),\n",
+    "    GoalType.MINIMIZE,\n",
+    "    MaxEval(100000)\n",
+    ")"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "0EG3K4aCUciMlgGQKPvJ57",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Print resulting weights of optimization"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "result.point"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "LelUlY0ZSlJEO9yC6SLk5B",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "Plotly.plot { \n",
+    "    scatter { \n",
+    "        y.doubles = result.point\n",
+    "     }\n",
+    "}"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "AuFOq5t9KpOIkGrOLsVXNf",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "# The resulting statistic distribution"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "val resultStatistic = ConvolutionalXYStatistic(result.point)\n",
+    "Plotly.plot { \n",
+    "    histogram { \n",
+    "        name = \"parabolae\"\n",
+    "        x.numbers = parabolas.map { resultStatistic(it) }\n",
+    "    }\n",
+    "    histogram { \n",
+    "        name = \"hyperbolae\"\n",
+    "        x.numbers = hyperbolas.map { resultStatistic(it) }\n",
+    "    }\n",
+    "}"
+   ],
+   "execution_count": null,
+   "outputs": [],
+   "metadata": {
+    "datalore": {
+     "node_id": "zvmq42DRdM5mZ3SpzviHwI",
+     "type": "CODE",
+     "hide_input_from_viewers": false,
+     "hide_output_from_viewers": false
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Kotlin",
+   "language": "kotlin",
+   "name": "kotlin"
+  },
+  "datalore": {
+   "version": 1,
+   "computation_mode": "JUPYTER",
+   "package_manager": "pip",
+   "base_environment": "default",
+   "packages": []
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
--- a/examples/src/main/kotlin/space/kscience/kmath/expressions/autodiff.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/expressions/autodiff.kt
@ -0,0 +1,91 @@
+/*
+ * Copyright 2018-2023 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.expressions
+
+import space.kscience.kmath.UnstableKMathAPI
+// Only kmath-core is needed.
+
+// Let's declare some variables
+val x by symbol
+val y by symbol
+val z by symbol
+
+@OptIn(UnstableKMathAPI::class)
+fun main() {
+    // Let's define some random expression.
+    val someExpression = Double.autodiff.differentiate {
+        // We bind variables `x` and `y` to the builder scope,
+        val x = bindSymbol(x)
+        val y = bindSymbol(y)
+
+        // Then we use the bindings to define expression `xy + x + y - 1`
+        x * y + x + y - 1
+    }
+
+    // Then we can evaluate it at any point ((-1, -1) in the case):
+    println(someExpression(mapOf(x to -1.0, y to -1.0)))
+    // >>> -2.0
+
+    // We can also construct its partial derivatives:
+    val dxExpression = someExpression.derivative(x) // ∂/∂x. Must be `y+1`
+    val dyExpression = someExpression.derivative(y) // ∂/∂y. Must be `x+1`
+    val dxdxExpression = someExpression.derivative(x, x) // ∂^2/∂x^2. Must be `0`
+
+    // We can evaluate them as well
+    println(dxExpression(mapOf(x to 57.0, y to 6.0)))
+    // >>> 7.0
+    println(dyExpression(mapOf(x to -1.0, y to 179.0)))
+    // >>> 0.0
+    println(dxdxExpression(mapOf(x to 239.0, y to 30.0)))
+    // >>> 0.0
+
+    // You can also provide extra arguments that obviously won't affect the result:
+    println(dxExpression(mapOf(x to 57.0, y to 6.0, z to 42.0)))
+    // >>> 7.0
+    println(dyExpression(mapOf(x to -1.0, y to 179.0, z to 0.0)))
+    // >>> 0.0
+    println(dxdxExpression(mapOf(x to 239.0, y to 30.0, z to 100_000.0)))
+    // >>> 0.0
+
+    // But in case you forgot to specify bound symbol's value, exception is thrown:
+    println( runCatching { someExpression(mapOf(z to 4.0)) } )
+    // >>> Failure(java.lang.IllegalStateException: Symbol 'x' is not supported in ...)
+
+    // The reason is that the expression is evaluated lazily,
+    // and each `bindSymbol` operation actually substitutes the provided symbol with the corresponding value.
+
+    // For example, let there be an expression
+    val simpleExpression = Double.autodiff.differentiate {
+        val x = bindSymbol(x)
+        x pow 2
+    }
+    // When you evaluate it via
+    simpleExpression(mapOf(x to 1.0, y to 57.0, z to 179.0))
+    // lambda above has the context of map `{x: 1.0, y: 57.0, z: 179.0}`.
+    // When x is bound, you can think of it as substitution `x -> 1.0`.
+    // Other values are unused which does not make any problem to us.
+    // But in the case the corresponding value is not provided,
+    // we cannot bind the variable. Thus, exception is thrown.
+
+    // There is also a function `bindSymbolOrNull` that fixes the problem:
+    val fixedExpression = Double.autodiff.differentiate {
+        val x = bindSymbolOrNull(x) ?: const(8.0)
+        x pow -2
+    }
+    println(fixedExpression())
+    // >>> 0.015625
+    // It works!
+
+    // The expression provides a bunch of operations:
+    // 1. Constant bindings (via `const` and `number`).
+    // 2. Variable bindings (via `bindVariable`, `bindVariableOrNull`).
+    // 3. Arithmetic operations (via `+`, `-`, `*`, and `-`).
+    // 4. Exponentiation (via `pow` or `power`).
+    // 5. `exp` and `ln`.
+    // 6. Trigonometrical functions (`sin`, `cos`, `tan`, `cot`).
+    // 7. Inverse trigonometrical functions (`asin`, `acos`, `atan`, `acot`).
+    // 8. Hyperbolic functions and inverse hyperbolic functions.
+}
--- a/examples/src/main/kotlin/space/kscience/kmath/fit/chiSquared.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/fit/chiSquared.kt
@ -7,10 +7,9 @@ package space.kscience.kmath.fit

 import kotlinx.html.br
 import kotlinx.html.h3
-import space.kscience.kmath.commons.expressions.DSProcessor
 import space.kscience.kmath.commons.optimization.CMOptimizer
 import space.kscience.kmath.distributions.NormalDistribution
-import space.kscience.kmath.expressions.chiSquaredExpression
+import space.kscience.kmath.expressions.autodiff
 import space.kscience.kmath.expressions.symbol
 import space.kscience.kmath.operations.asIterable
 import space.kscience.kmath.operations.toList
@ -22,6 +21,7 @@ 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.chiSquaredExpression
 import space.kscience.plotly.*
 import space.kscience.plotly.models.ScatterMode
 import space.kscience.plotly.models.TraceValues
@ -67,7 +67,7 @@ suspend fun main() {
    val yErr = y.map { sqrt(it) }//RealVector.same(x.size, sigma)

    // compute differentiable chi^2 sum for given model ax^2 + bx + c
-    val chi2 = DSProcessor.chiSquaredExpression(x, y, yErr) { arg ->
+    val chi2 = Double.autodiff.chiSquaredExpression(x, y, yErr) { arg ->
        //bind variables to autodiff context
        val a = bindSymbol(a)
        val b = bindSymbol(b)
--- a/examples/src/main/kotlin/space/kscience/kmath/fit/qowFit.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/fit/qowFit.kt
@ -7,18 +7,15 @@ package space.kscience.kmath.fit

 import kotlinx.html.br
 import kotlinx.html.h3
-import space.kscience.kmath.commons.expressions.DSProcessor
 import space.kscience.kmath.data.XYErrorColumnarData
 import space.kscience.kmath.distributions.NormalDistribution
 import space.kscience.kmath.expressions.Symbol
+import space.kscience.kmath.expressions.autodiff
 import space.kscience.kmath.expressions.binding
 import space.kscience.kmath.expressions.symbol
 import space.kscience.kmath.operations.asIterable
 import space.kscience.kmath.operations.toList
-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.optimization.*
 import space.kscience.kmath.random.RandomGenerator
 import space.kscience.kmath.real.map
 import space.kscience.kmath.real.step
@ -32,6 +29,8 @@ import kotlin.math.sqrt
 private val a by symbol
 private val b by symbol
 private val c by symbol
+private val d by symbol
+private val e by symbol


 /**
@ -63,17 +62,23 @@ suspend fun main() {

    val result = XYErrorColumnarData.of(x, y, yErr).fitWith(
        QowOptimizer,
-        DSProcessor,
-        mapOf(a to 0.9, b to 1.2, c to 2.0)
+        Double.autodiff,
+        mapOf(a to 0.9, b to 1.2, c to 2.0, e to 1.0, d to 1.0, e to 0.0),
+        OptimizationParameters(a, b, c, d)
    ) { arg ->
        //bind variables to autodiff context
        val a by binding
        val b by binding
        //Include default value for c if it is not provided as a parameter
        val c = bindSymbolOrNull(c) ?: one
-        a * arg.pow(2) + b * arg + c
+        val d by binding
+        val e by binding
+
+        a * arg.pow(2) + b * arg + c + d * arg.pow(3) + e / arg
    }

+    println("Resulting chi2/dof: ${result.chiSquaredOrNull}/${result.dof}")
+
    //display a page with plot and numerical results
    val page = Plotly.page {
        plot {
@ -89,7 +94,7 @@ suspend fun main() {
            scatter {
                mode = ScatterMode.lines
                x(x)
-                y(x.map { result.model(result.resultPoint + (Symbol.x to it)) })
+                y(x.map { result.model(result.startPoint + result.resultPoint + (Symbol.x to it)) })
                name = "fit"
            }
        }
@ -98,7 +103,7 @@ suspend fun main() {
            +"Fit result: ${result.resultPoint}"
        }
        h3 {
-            +"Chi2/dof = ${result.chiSquaredOrNull!! / (x.size - 3)}"
+            +"Chi2/dof = ${result.chiSquaredOrNull!! / result.dof}"
        }
    }

--- a/examples/src/main/kotlin/space/kscience/kmath/functions/integrate.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/functions/integrate.kt
@ -5,6 +5,11 @@

 package space.kscience.kmath.functions

+import space.kscience.kmath.complex.Complex
+import space.kscience.kmath.complex.ComplexField
+import space.kscience.kmath.complex.ComplexField.div
+import space.kscience.kmath.complex.ComplexField.minus
+import space.kscience.kmath.complex.algebra
 import space.kscience.kmath.integration.gaussIntegrator
 import space.kscience.kmath.integration.integrate
 import space.kscience.kmath.integration.value
@ -20,4 +25,12 @@ fun main() {

    //the value is nullable because in some cases the integration could not succeed
    println(result.value)
+
+
+    repeat(100000) {
+        Complex.algebra.gaussIntegrator.integrate(0.0..1.0, intervals = 1000) { x: Double ->
+//            sin(1 / x) + i * cos(1 / x)
+            1 / x - ComplexField.i / x
+        }.value
+    }
 }
--- a/examples/src/main/kotlin/space/kscience/kmath/functions/matrixIntegration.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/functions/matrixIntegration.kt
@ -12,10 +12,9 @@ import space.kscience.kmath.nd.StructureND
 import space.kscience.kmath.nd.structureND
 import space.kscience.kmath.nd.withNdAlgebra
 import space.kscience.kmath.operations.algebra
-import space.kscience.kmath.operations.invoke
+import kotlin.math.pow

-fun main(): Unit = Double.algebra {
-    withNdAlgebra(2, 2) {
+fun main(): Unit = Double.algebra.withNdAlgebra(2, 2) {

    //Produce a diagonal StructureND
    fun diagonal(v: Double) = structureND { (i, j) ->
@ -31,4 +30,3 @@ fun main(): Unit = Double.algebra {
    //the value is nullable because in some cases the integration could not succeed
    println(result.value)
 }
-}
--- a/examples/src/main/kotlin/space/kscience/kmath/linear/dotPerformance.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/linear/dotPerformance.kt
@ -7,8 +7,10 @@ package space.kscience.kmath.linear

 import space.kscience.kmath.operations.algebra
 import kotlin.random.Random
-import kotlin.system.measureTimeMillis
+import kotlin.time.ExperimentalTime
+import kotlin.time.measureTime

+@OptIn(ExperimentalTime::class)
 fun main() {
    val random = Random(12224)
    val dim = 1000
@ -21,7 +23,7 @@ fun main() {
        if (i <= j) random.nextDouble() else 0.0
    }

-    val time = measureTimeMillis {
+    val time = measureTime {
        with(Double.algebra.linearSpace) {
            repeat(10) {
                matrix1 dot matrix2
--- a/examples/src/main/kotlin/space/kscience/kmath/series/DateTimeSeries.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/series/DateTimeSeries.kt
@ -0,0 +1,17 @@
+/*
+ * Copyright 2018-2023 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.series
+
+import kotlinx.datetime.Instant
+import space.kscience.kmath.operations.algebra
+import space.kscience.kmath.operations.bufferAlgebra
+import kotlin.time.Duration
+
+fun SeriesAlgebra.Companion.time(zero: Instant, step: Duration) = MonotonicSeriesAlgebra(
+    bufferAlgebra = Double.algebra.bufferAlgebra,
+    offsetToLabel = { zero + step * it },
+    labelToOffset = { (it - zero) / step }
+)
--- a/examples/src/main/kotlin/space/kscience/kmath/series/analyzeDif.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/series/analyzeDif.kt
@ -1,9 +1,8 @@
 package space.kscience.kmath.series


-import kotlinx.html.FlowContent
 import kotlinx.html.h1
-import space.kscience.kmath.operations.DoubleBufferOps
+import kotlinx.html.p
 import space.kscience.kmath.operations.algebra
 import space.kscience.kmath.operations.bufferAlgebra
 import space.kscience.kmath.operations.toList
@ -15,35 +14,43 @@ import space.kscience.plotly.*
 import kotlin.math.PI

 fun main() = with(Double.algebra.bufferAlgebra.seriesAlgebra()) {
-    fun FlowContent.plotSeries(buffer: Buffer<Double>) {
-        val ls = buffer.labels
-        plot {
+
+
+    fun Plot.plotSeries(name: String, buffer: Buffer<Double>) {
        scatter {
-                x.numbers = ls
+            this.name = name
+            x.numbers = buffer.labels
            y.numbers = buffer.toList()
        }
+    }
+
+
+    val s1 = series(100) { sin(2 * PI * it / 100) + 1.0 }
+
+    val s2 = s1.slice(20..50).moveTo(40)
+
+    val s3: Buffer<Double> = s1.zip(s2) { l, r -> l + r } //s1 + s2
+    val s4 = s3.map { ln(it) }
+
+    val kmTest: KMComparisonResult<Double> = ksComparisonStatistic(s1, s2)
+
+    Plotly.page {
+        h1 { +"This is my plot" }
+        p{
+            +"Kolmogorov-smirnov test for s1 and s2: ${kmTest.value}"
+        }
+        plot{
+            plotSeries("s1", s1)
+            plotSeries("s2", s2)
+            plotSeries("s3", s3)
+            plotSeries("s4", s4)
            layout {
                xaxis {
                    range(0.0..100.0)
                }
            }
        }
-    }

-
-    val s1 = series(100) { sin(2 * PI * it / 100) + 1.0 }
-    val s2 = s1.slice(20..50).moveTo(40)
-
-    val s3: Buffer<Double> = s1.zip(s2) { l, r -> l + r } //s1 + s2
-    val s4 = DoubleBufferOps.ln(s3)
-
-    val kmTest: KMComparisonResult<Double> = ksComparisonStatistic(s1, s2)
-
-    Plotly.page {
-        h1 { +"This is my plot" }
-        plotSeries(s1)
-        plotSeries(s2)
-        plotSeries(s4)
    }.makeFile()

 }
--- a/examples/src/main/kotlin/space/kscience/kmath/stat/DistributionBenchmark.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/stat/DistributionBenchmark.kt
@ -36,7 +36,7 @@ private suspend fun runKMathChained(): Duration {
    return Duration.between(startTime, Instant.now())
 }

-private fun runApacheDirect(): Duration {
+private fun runCMDirect(): Duration {
    val rng = RandomSource.create(RandomSource.MT, 123L)

    val sampler = CMGaussianSampler.of(
@ -65,7 +65,7 @@ private fun runApacheDirect(): Duration {
 * Comparing chain sampling performance with direct sampling performance
 */
 fun main(): Unit = runBlocking(Dispatchers.Default) {
-    val directJob = async { runApacheDirect() }
+    val directJob = async { runCMDirect() }
    val chainJob = async { runKMathChained() }
    println("KMath Chained: ${chainJob.await()}")
    println("Apache Direct: ${directJob.await()}")
--- a/examples/src/main/kotlin/space/kscience/kmath/structures/StreamDoubleFieldND.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/structures/StreamDoubleFieldND.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.structures

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.operations.ExtendedField
--- a/examples/src/main/kotlin/space/kscience/kmath/structures/StructureReadBenchmark.kt
+++ b/examples/src/main/kotlin/space/kscience/kmath/structures/StructureReadBenchmark.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.structures

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.nd.BufferND
 import space.kscience.kmath.nd.ColumnStrides
 import space.kscience.kmath.nd.ShapeND
--- a/gradle.properties
+++ b/gradle.properties
@ -5,12 +5,11 @@
 kotlin.code.style=official
 kotlin.mpp.stability.nowarn=true
 kotlin.native.ignoreDisabledTargets=true
-kotlin.incremental.js.ir=true

 org.gradle.configureondemand=true
 org.gradle.jvmargs=-Xmx4096m

-toolsVersion=0.13.1-kotlin-1.7.20
+toolsVersion=0.14.6-kotlin-1.8.20


 org.gradle.parallel=true
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
--- a/kmath-ast/README.md
+++ b/kmath-ast/README.md
@ -10,7 +10,7 @@ Extensions to MST API: transformations, dynamic compilation and visualization.

 ## Artifact:

-The Maven coordinates of this project are `space.kscience:kmath-ast:0.3.1-dev-1`.
+The Maven coordinates of this project are `space.kscience:kmath-ast:0.4.0-dev-1`.

 **Gradle Groovy:**
 ```groovy
@ -20,7 +20,7 @@ repositories {
 }

 dependencies {
-    implementation 'space.kscience:kmath-ast:0.3.1-dev-1'
+    implementation 'space.kscience:kmath-ast:0.4.0-dev-1'
 }
 ```
 **Gradle Kotlin DSL:**
@ -31,7 +31,7 @@ repositories {
 }

 dependencies {
-    implementation("space.kscience:kmath-ast:0.3.1-dev-1")
+    implementation("space.kscience:kmath-ast:0.4.0-dev-1")
 }
 ```

--- a/kmath-ast/build.gradle.kts
+++ b/kmath-ast/build.gradle.kts
@ -3,10 +3,33 @@ plugins {
 }

 kscience{
+    jvm()
+    js()
    native()
+
+    dependencies {
+        api(projects.kmathCore)
+        api("com.github.h0tk3y.betterParse:better-parse:0.4.4")
    }

-kotlin.js {
+    testDependencies {
+        implementation(projects.kmathComplex)
+    }
+
+    dependencies(jsMain) {
+        implementation(npm("astring", "1.7.5"))
+        implementation(npm("binaryen", "101.0.0"))
+        implementation(npm("js-base64", "3.6.1"))
+    }
+
+    dependencies(jvmMain){
+        implementation("org.ow2.asm:asm-commons:9.2")
+    }
+
+}
+
+kotlin {
+    js {
        nodejs {
            testTask {
                useMocha().timeout = "0"
@ -20,48 +43,18 @@ kotlin.js {
        }
    }

-kotlin.sourceSets {
+    sourceSets {
        filter { it.name.contains("test", true) }
            .map(org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet::languageSettings)
            .forEach { it.optIn("space.kscience.kmath.misc.UnstableKMathAPI") }
-
-    commonMain {
-        dependencies {
-            api("com.github.h0tk3y.betterParse:better-parse:0.4.4")
-            api(project(":kmath-core"))
    }
 }

-    commonTest {
-        dependencies {
-            implementation(project(":kmath-complex"))
-        }
-    }
-
-    jsMain {
-        dependencies {
-            implementation(npm("astring", "1.7.5"))
-            implementation(npm("binaryen", "101.0.0"))
-            implementation(npm("js-base64", "3.6.1"))
-        }
-    }
-
-    jvmMain {
-        dependencies {
-            implementation("org.ow2.asm:asm-commons:9.2")
-        }
-    }
-}
-
-//Workaround for https://github.com/Kotlin/dokka/issues/1455
-tasks.dokkaHtml {
-    dependsOn(tasks.build)
-}
-
-if (System.getProperty("space.kscience.kmath.ast.dump.generated.classes") == "1")
-    tasks.jvmTest {
+if (System.getProperty("space.kscience.kmath.ast.dump.generated.classes") == "1") {
+    tasks.withType<org.jetbrains.kotlin.gradle.targets.jvm.tasks.KotlinJvmTest> {
        jvmArgs("-Dspace.kscience.kmath.ast.dump.generated.classes=1")
    }
+}

 readme {
    maturity = space.kscience.gradle.Maturity.EXPERIMENTAL
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/TypedMst.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/TypedMst.kt
@ -7,7 +7,6 @@ package space.kscience.kmath.ast

 import space.kscience.kmath.expressions.Expression
 import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.Algebra
 import space.kscience.kmath.operations.NumericAlgebra

@ -16,7 +15,6 @@ import space.kscience.kmath.operations.NumericAlgebra
 *
 * @param T the type.
 */
-@UnstableKMathAPI
 public sealed interface TypedMst<T> {
    /**
     * A node containing a unary operation.
@ -133,7 +131,6 @@ public sealed interface TypedMst<T> {
 /**
 * Interprets the [TypedMst] node with this [Algebra] and [arguments].
 */
-@UnstableKMathAPI
 public fun <T> TypedMst<T>.interpret(algebra: Algebra<T>, arguments: Map<Symbol, T>): T = when (this) {
    is TypedMst.Unary -> algebra.unaryOperation(operation, interpret(algebra, arguments))

@ -158,7 +155,6 @@ public fun <T> TypedMst<T>.interpret(algebra: Algebra<T>, arguments: Map<Symbol,
 /**
 * Interprets the [TypedMst] node with this [Algebra] and optional [arguments].
 */
-@UnstableKMathAPI
 public fun <T> TypedMst<T>.interpret(algebra: Algebra<T>, vararg arguments: Pair<Symbol, T>): T = interpret(
    algebra,
    when (arguments.size) {
@ -171,7 +167,6 @@ public fun <T> TypedMst<T>.interpret(algebra: Algebra<T>, vararg arguments: Pair
 /**
 * Interpret this [TypedMst] node as expression.
 */
-@UnstableKMathAPI
 public fun <T : Any> TypedMst<T>.toExpression(algebra: Algebra<T>): Expression<T> = Expression { arguments ->
    interpret(algebra, arguments)
 }
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/evaluateConstants.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/evaluateConstants.kt
@ -7,7 +7,6 @@ package space.kscience.kmath.ast

 import space.kscience.kmath.expressions.MST
 import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.Algebra
 import space.kscience.kmath.operations.NumericAlgebra
 import space.kscience.kmath.operations.bindSymbolOrNull
@ -15,7 +14,6 @@ import space.kscience.kmath.operations.bindSymbolOrNull
 /**
 * Evaluates constants in given [MST] for given [algebra] at the same time with converting to [TypedMst].
 */
-@UnstableKMathAPI
 public fun <T> MST.evaluateConstants(algebra: Algebra<T>): TypedMst<T> = when (this) {
    is MST.Numeric -> TypedMst.Constant(
        (algebra as? NumericAlgebra<T>)?.number(value) ?: error("Numeric nodes are not supported by $algebra"),
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/LatexSyntaxRenderer.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/LatexSyntaxRenderer.kt
@ -5,8 +5,6 @@

 package space.kscience.kmath.ast.rendering

-import space.kscience.kmath.misc.UnstableKMathAPI
-
 /**
 * [SyntaxRenderer] implementation for LaTeX.
 *
@ -25,7 +23,6 @@ import space.kscience.kmath.misc.UnstableKMathAPI
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public object LatexSyntaxRenderer : SyntaxRenderer {
    override fun render(node: MathSyntax, output: Appendable): Unit = output.run {
        fun render(syntax: MathSyntax) = render(syntax, output)
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathMLSyntaxRenderer.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathMLSyntaxRenderer.kt
@ -5,8 +5,6 @@

 package space.kscience.kmath.ast.rendering

-import space.kscience.kmath.misc.UnstableKMathAPI
-
 /**
 * [SyntaxRenderer] implementation for MathML.
 *
@ -14,7 +12,6 @@ import space.kscience.kmath.misc.UnstableKMathAPI
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public object MathMLSyntaxRenderer : SyntaxRenderer {
    override fun render(node: MathSyntax, output: Appendable) {
        output.append("<math xmlns=\"https://www.w3.org/1998/Math/MathML\"><mrow>")
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathRenderer.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathRenderer.kt
@ -6,14 +6,12 @@
 package space.kscience.kmath.ast.rendering

 import space.kscience.kmath.expressions.MST
-import space.kscience.kmath.misc.UnstableKMathAPI

 /**
 * Renders [MST] to [MathSyntax].
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public fun interface MathRenderer {
    /**
     * Renders [MST] to [MathSyntax].
@ -27,7 +25,6 @@ public fun interface MathRenderer {
 * @property features The applied features.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public open class FeaturedMathRenderer(public val features: List<RenderFeature>) : MathRenderer {
    override fun render(mst: MST): MathSyntax {
        for (feature in features) feature.render(this, mst)?.let { return it }
@ -51,7 +48,6 @@ public open class FeaturedMathRenderer(public val features: List<RenderFeature>)
 * @property stages The applied stages.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public open class FeaturedMathRendererWithPostProcess(
    features: List<RenderFeature>,
    public val stages: List<PostProcessPhase>,
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathSyntax.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/MathSyntax.kt
@ -5,14 +5,11 @@

 package space.kscience.kmath.ast.rendering

-import space.kscience.kmath.misc.UnstableKMathAPI
-
 /**
 * Syntax node for mathematical typography.
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public sealed class MathSyntax {
    /**
     * The parent node of this syntax node.
@ -25,7 +22,6 @@ public sealed class MathSyntax {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public sealed class TerminalSyntax : MathSyntax()

 /**
@ -33,7 +29,6 @@ public sealed class TerminalSyntax : MathSyntax()
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public sealed class OperationSyntax : MathSyntax() {
    /**
     * The operation token.
@ -46,7 +41,6 @@ public sealed class OperationSyntax : MathSyntax() {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public sealed class UnarySyntax : OperationSyntax() {
    /**
     * The operand of this node.
@ -59,7 +53,6 @@ public sealed class UnarySyntax : OperationSyntax() {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public sealed class BinarySyntax : OperationSyntax() {
    /**
     * The left-hand side operand.
@ -78,7 +71,6 @@ public sealed class BinarySyntax : OperationSyntax() {
 * @property string The digits of number.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class NumberSyntax(public var string: String) : TerminalSyntax()

 /**
@ -87,7 +79,6 @@ public data class NumberSyntax(public var string: String) : TerminalSyntax()
 * @property string The symbol.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class SymbolSyntax(public var string: String) : TerminalSyntax()

 /**
@ -98,7 +89,6 @@ public data class SymbolSyntax(public var string: String) : TerminalSyntax()
 * @see UnaryOperatorSyntax
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class OperatorNameSyntax(public var name: String) : TerminalSyntax()

 /**
@ -107,7 +97,6 @@ public data class OperatorNameSyntax(public var name: String) : TerminalSyntax()
 * @property kind The kind of symbol.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class SpecialSymbolSyntax(public var kind: Kind) : TerminalSyntax() {
    /**
     * The kind of symbol.
@ -132,7 +121,6 @@ public data class SpecialSymbolSyntax(public var kind: Kind) : TerminalSyntax()
 * @property parentheses Whether the operand should be wrapped with parentheses.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class OperandSyntax(
    public val operand: MathSyntax,
    public var parentheses: Boolean,
@ -148,7 +136,6 @@ public data class OperandSyntax(
 * @property prefix The prefix.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class UnaryOperatorSyntax(
    override val operation: String,
    public var prefix: MathSyntax,
@ -164,7 +151,6 @@ public data class UnaryOperatorSyntax(
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class UnaryPlusSyntax(
    override val operation: String,
    override val operand: OperandSyntax,
@ -179,7 +165,6 @@ public data class UnaryPlusSyntax(
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class UnaryMinusSyntax(
    override val operation: String,
    override val operand: OperandSyntax,
@ -195,7 +180,6 @@ public data class UnaryMinusSyntax(
 * @property operand The radicand.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class RadicalSyntax(
    override val operation: String,
    override val operand: MathSyntax,
@ -213,7 +197,6 @@ public data class RadicalSyntax(
 * (*e<sup>x</sup>*).
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class ExponentSyntax(
    override val operation: String,
    override val operand: OperandSyntax,
@ -231,7 +214,6 @@ public data class ExponentSyntax(
 * @property right The superscript.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class SuperscriptSyntax(
    override val operation: String,
    override val left: MathSyntax,
@ -250,7 +232,6 @@ public data class SuperscriptSyntax(
 * @property right The subscript.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class SubscriptSyntax(
    override val operation: String,
    override val left: MathSyntax,
@ -268,7 +249,6 @@ public data class SubscriptSyntax(
 * @property prefix The prefix.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class BinaryOperatorSyntax(
    override val operation: String,
    public var prefix: MathSyntax,
@ -288,7 +268,6 @@ public data class BinaryOperatorSyntax(
 * @param right The addend.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class BinaryPlusSyntax(
    override val operation: String,
    override val left: OperandSyntax,
@ -307,7 +286,6 @@ public data class BinaryPlusSyntax(
 * @param right The subtrahend.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class BinaryMinusSyntax(
    override val operation: String,
    override val left: OperandSyntax,
@ -327,7 +305,6 @@ public data class BinaryMinusSyntax(
 * @property infix Whether infix (*1 / 2*) or normal (*&frac12;*) fraction should be made.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class FractionSyntax(
    override val operation: String,
    override val left: OperandSyntax,
@ -347,7 +324,6 @@ public data class FractionSyntax(
 * @property right The radicand.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class RadicalWithIndexSyntax(
    override val operation: String,
    override val left: MathSyntax,
@ -367,7 +343,6 @@ public data class RadicalWithIndexSyntax(
 * @property times Whether the times (&times;) symbol should be used.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public data class MultiplicationSyntax(
    override val operation: String,
    override val left: OperandSyntax,
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/SyntaxRenderer.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/SyntaxRenderer.kt
@ -5,15 +5,12 @@

 package space.kscience.kmath.ast.rendering

-import space.kscience.kmath.misc.UnstableKMathAPI
-
 /**
 * Abstraction of writing [MathSyntax] as a string of an actual markup language. Typical implementation should
 * involve traversal of MathSyntax with handling each subtype.
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public fun interface SyntaxRenderer {
    /**
     * Renders the [MathSyntax] to [output].
@ -26,7 +23,6 @@ public fun interface SyntaxRenderer {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public fun SyntaxRenderer.renderWithStringBuilder(node: MathSyntax): String {
    val sb = StringBuilder()
    render(node, sb)
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/features.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/features.kt
@ -8,7 +8,6 @@ package space.kscience.kmath.ast.rendering
 import space.kscience.kmath.ast.rendering.FeaturedMathRenderer.RenderFeature
 import space.kscience.kmath.expressions.MST
 import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import kotlin.reflect.KClass

@ -17,7 +16,6 @@ import kotlin.reflect.KClass
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public val PrintSymbol: RenderFeature = RenderFeature { _, node ->
    if (node !is Symbol) null
    else SymbolSyntax(string = node.identity)
@ -28,7 +26,6 @@ public val PrintSymbol: RenderFeature = RenderFeature { _, node ->
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public val PrintNumeric: RenderFeature = RenderFeature { _, node ->
    if (node !is MST.Numeric)
        null
@ -36,7 +33,6 @@ public val PrintNumeric: RenderFeature = RenderFeature { _, node ->
        NumberSyntax(string = node.value.toString())
 }

-@UnstableKMathAPI
 private fun printSignedNumberString(s: String): MathSyntax = if (s.startsWith('-'))
    UnaryMinusSyntax(
        operation = GroupOps.MINUS_OPERATION,
@ -55,7 +51,6 @@ else
 * @property types The suitable types.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class PrettyPrintFloats(public val types: Set<KClass<out Number>>) : RenderFeature {
    override fun render(renderer: FeaturedMathRenderer, node: MST): MathSyntax? {
        if (node !is MST.Numeric || node.value::class !in types) return null
@ -115,7 +110,6 @@ public class PrettyPrintFloats(public val types: Set<KClass<out Number>>) : Rend
 * @property types The suitable types.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class PrettyPrintIntegers(public val types: Set<KClass<out Number>>) : RenderFeature {
    override fun render(renderer: FeaturedMathRenderer, node: MST): MathSyntax? =
        if (node !is MST.Numeric || node.value::class !in types)
@ -138,7 +132,6 @@ public class PrettyPrintIntegers(public val types: Set<KClass<out Number>>) : Re
 * @property symbols The allowed symbols.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class PrettyPrintPi(public val symbols: Set<String>) : RenderFeature {
    override fun render(renderer: FeaturedMathRenderer, node: MST): MathSyntax? =
        if (node !is Symbol || node.identity !in symbols)
@ -161,7 +154,6 @@ public class PrettyPrintPi(public val symbols: Set<String>) : RenderFeature {
 * @param operations the allowed operations. If `null`, any operation is accepted.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public abstract class Unary(public val operations: Collection<String>?) : RenderFeature {
    /**
     * The actual render function specialized for [MST.Unary].
@ -182,7 +174,6 @@ public abstract class Unary(public val operations: Collection<String>?) : Render
 * @property operations the allowed operations. If `null`, any operation is accepted.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public abstract class Binary(public val operations: Collection<String>?) : RenderFeature {
    /**
     * The actual render function specialized for [MST.Binary].
@ -200,7 +191,6 @@ public abstract class Binary(public val operations: Collection<String>?) : Rende
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class BinaryPlus(operations: Collection<String>?) : Binary(operations) {
    override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
        BinaryPlusSyntax(
@ -222,7 +212,6 @@ public class BinaryPlus(operations: Collection<String>?) : Binary(operations) {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class BinaryMinus(operations: Collection<String>?) : Binary(operations) {
    override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
        BinaryMinusSyntax(
@ -244,7 +233,6 @@ public class BinaryMinus(operations: Collection<String>?) : Binary(operations) {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class UnaryPlus(operations: Collection<String>?) : Unary(operations) {
    override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax = UnaryPlusSyntax(
        operation = node.operation,
@ -264,7 +252,6 @@ public class UnaryPlus(operations: Collection<String>?) : Unary(operations) {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class UnaryMinus(operations: Collection<String>?) : Unary(operations) {
    override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax = UnaryMinusSyntax(
        operation = node.operation,
@ -284,7 +271,6 @@ public class UnaryMinus(operations: Collection<String>?) : Unary(operations) {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class Fraction(operations: Collection<String>?) : Binary(operations) {
    override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax = FractionSyntax(
        operation = node.operation,
@ -306,7 +292,6 @@ public class Fraction(operations: Collection<String>?) : Binary(operations) {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class BinaryOperator(operations: Collection<String>?) : Binary(operations) {
    override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
        BinaryOperatorSyntax(
@ -329,7 +314,6 @@ public class BinaryOperator(operations: Collection<String>?) : Binary(operations
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class UnaryOperator(operations: Collection<String>?) : Unary(operations) {
    override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax =
        UnaryOperatorSyntax(
@ -351,7 +335,6 @@ public class UnaryOperator(operations: Collection<String>?) : Unary(operations)
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class Power(operations: Collection<String>?) : Binary(operations) {
    override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
        SuperscriptSyntax(
@ -371,7 +354,6 @@ public class Power(operations: Collection<String>?) : Binary(operations) {
 /**
 * Handles binary nodes by producing [RadicalSyntax] with no index.
 */
-@UnstableKMathAPI
 public class SquareRoot(operations: Collection<String>?) : Unary(operations) {
    override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax =
        RadicalSyntax(operation = node.operation, operand = parent.render(node.value))
@ -389,7 +371,6 @@ public class SquareRoot(operations: Collection<String>?) : Unary(operations) {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class Exponent(operations: Collection<String>?) : Unary(operations) {
    override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax = ExponentSyntax(
        operation = node.operation,
@ -410,7 +391,6 @@ public class Exponent(operations: Collection<String>?) : Unary(operations) {
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class Multiplication(operations: Collection<String>?) : Binary(operations) {
    override fun renderBinary(parent: FeaturedMathRenderer, node: MST.Binary): MathSyntax =
        MultiplicationSyntax(
@ -433,7 +413,6 @@ public class Multiplication(operations: Collection<String>?) : Binary(operations
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class InverseTrigonometricOperations(operations: Collection<String>?) : Unary(operations) {
    override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax =
        UnaryOperatorSyntax(
@ -460,7 +439,6 @@ public class InverseTrigonometricOperations(operations: Collection<String>?) : U
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class InverseHyperbolicOperations(operations: Collection<String>?) : Unary(operations) {
    override fun renderUnary(parent: FeaturedMathRenderer, node: MST.Unary): MathSyntax =
        UnaryOperatorSyntax(
--- a/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/phases.kt
+++ b/kmath-ast/src/commonMain/kotlin/space/kscience/kmath/ast/rendering/phases.kt
@ -6,7 +6,6 @@
 package space.kscience.kmath.ast.rendering

 import space.kscience.kmath.ast.rendering.FeaturedMathRendererWithPostProcess.PostProcessPhase
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.FieldOps
 import space.kscience.kmath.operations.GroupOps
 import space.kscience.kmath.operations.PowerOperations
@ -17,7 +16,6 @@ import space.kscience.kmath.operations.RingOps
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public val BetterMultiplication: PostProcessPhase = PostProcessPhase { node ->
    fun perform(node: MathSyntax): Unit = when (node) {
        is NumberSyntax -> Unit
@ -91,7 +89,6 @@ public val BetterMultiplication: PostProcessPhase = PostProcessPhase { node ->
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public val BetterFraction: PostProcessPhase = PostProcessPhase { node ->
    fun perform(node: MathSyntax, infix: Boolean = false): Unit = when (node) {
        is NumberSyntax -> Unit
@ -162,7 +159,6 @@ public val BetterFraction: PostProcessPhase = PostProcessPhase { node ->
 *
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public val BetterExponent: PostProcessPhase = PostProcessPhase { node ->
    fun perform(node: MathSyntax): Boolean {
        return when (node) {
@ -202,7 +198,6 @@ public val BetterExponent: PostProcessPhase = PostProcessPhase { node ->
 * @property precedenceFunction Returns the precedence number for syntax node. Higher number is lower priority.
 * @author Iaroslav Postovalov
 */
-@UnstableKMathAPI
 public class SimplifyParentheses(public val precedenceFunction: (MathSyntax) -> Int) :
    PostProcessPhase {
    override fun perform(node: MathSyntax): Unit = when (node) {
--- a/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/estree/estree.kt
+++ b/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/estree/estree.kt
@ -5,6 +5,7 @@

 package space.kscience.kmath.estree

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.ast.TypedMst
 import space.kscience.kmath.ast.evaluateConstants
 import space.kscience.kmath.estree.internal.ESTreeBuilder
@ -13,7 +14,6 @@ import space.kscience.kmath.expressions.MST
 import space.kscience.kmath.expressions.Symbol
 import space.kscience.kmath.expressions.invoke
 import space.kscience.kmath.internal.estree.BaseExpression
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.Algebra

 /**
--- a/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/internal/WasmBuilder.kt
+++ b/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/internal/WasmBuilder.kt
@ -5,11 +5,11 @@

 package space.kscience.kmath.wasm.internal

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.ast.TypedMst
 import space.kscience.kmath.expressions.*
 import space.kscience.kmath.internal.binaryen.*
 import space.kscience.kmath.internal.webassembly.Instance
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.internal.binaryen.Module as BinaryenModule
 import space.kscience.kmath.internal.webassembly.Module as WasmModule
--- a/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/wasm.kt
+++ b/kmath-ast/src/jsMain/kotlin/space/kscience/kmath/wasm/wasm.kt
@ -7,10 +7,10 @@

 package space.kscience.kmath.wasm

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.ast.TypedMst
 import space.kscience.kmath.ast.evaluateConstants
 import space.kscience.kmath.expressions.*
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.operations.IntRing
 import space.kscience.kmath.wasm.internal.DoubleWasmBuilder
--- a/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/asm.kt
+++ b/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/asm.kt
@ -7,11 +7,11 @@

 package space.kscience.kmath.asm

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.asm.internal.*
 import space.kscience.kmath.ast.TypedMst
 import space.kscience.kmath.ast.evaluateConstants
 import space.kscience.kmath.expressions.*
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.Algebra
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.operations.IntRing
--- a/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/internal/PrimitiveAsmBuilder.kt
+++ b/kmath-ast/src/jvmMain/kotlin/space/kscience/kmath/asm/internal/PrimitiveAsmBuilder.kt
@ -11,9 +11,9 @@ import org.objectweb.asm.Opcodes.*
 import org.objectweb.asm.Type
 import org.objectweb.asm.Type.*
 import org.objectweb.asm.commons.InstructionAdapter
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.ast.TypedMst
 import space.kscience.kmath.expressions.*
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import java.lang.invoke.MethodHandles
 import java.lang.invoke.MethodType
--- a/kmath-commons/README.md
+++ b/kmath-commons/README.md
@ -6,7 +6,7 @@ Commons math binding for kmath

 ## Artifact:

-The Maven coordinates of this project are `space.kscience:kmath-commons:0.3.1-dev-1`.
+The Maven coordinates of this project are `space.kscience:kmath-commons:0.4.0-dev-1`.

 **Gradle Groovy:**
 ```groovy
@ -16,7 +16,7 @@ repositories {
 }

 dependencies {
-    implementation 'space.kscience:kmath-commons:0.3.1-dev-1'
+    implementation 'space.kscience:kmath-commons:0.4.0-dev-1'
 }
 ```
 **Gradle Kotlin DSL:**
@ -27,6 +27,6 @@ repositories {
 }

 dependencies {
-    implementation("space.kscience:kmath-commons:0.3.1-dev-1")
+    implementation("space.kscience:kmath-commons:0.4.0-dev-1")
 }
 ```
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpression.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpression.kt
@ -3,11 +3,13 @@
 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

+@file:Suppress("DEPRECATION")
+
 package space.kscience.kmath.commons.expressions

 import org.apache.commons.math3.analysis.differentiation.DerivativeStructure
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.expressions.*
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.ExtendedField
 import space.kscience.kmath.operations.NumbersAddOps

@ -18,7 +20,8 @@ import space.kscience.kmath.operations.NumbersAddOps
 * @param bindings The map of bindings values. All bindings are considered free parameters
 */
@OptIn(UnstableKMathAPI::class)
-public class DerivativeStructureField(
+@Deprecated("Use generic DSAlgebra from the core")
+public class CmDsField(
    public val order: Int,
    bindings: Map<Symbol, Double>,
 ) : ExtendedField<DerivativeStructure>, ExpressionAlgebra<Double, DerivativeStructure>,
@ -108,25 +111,27 @@ public class DerivativeStructureField(
 /**
 * Auto-diff processor based on Commons-math [DerivativeStructure]
 */
-public object DSProcessor : AutoDiffProcessor<Double, DerivativeStructure, DerivativeStructureField> {
+@Deprecated("Use generic DSAlgebra from the core")
+public object CmDsProcessor : AutoDiffProcessor<Double, DerivativeStructure, CmDsField> {
     override fun differentiate(
-        function: DerivativeStructureField.() -> DerivativeStructure,
-    ): DerivativeStructureExpression = DerivativeStructureExpression(function)
+         function: CmDsField.() -> DerivativeStructure,
+    ): CmDsExpression = CmDsExpression(function)
 }

 /**
 * A constructs that creates a derivative structure with required order on-demand
 */
-public class DerivativeStructureExpression(
-    public val function: DerivativeStructureField.() -> DerivativeStructure,
+@Deprecated("Use generic DSAlgebra from the core")
+public class CmDsExpression(
+    public val function: CmDsField.() -> DerivativeStructure,
 ) : DifferentiableExpression<Double> {
    override operator fun invoke(arguments: Map<Symbol, Double>): Double =
-        DerivativeStructureField(0, arguments).function().value
+        CmDsField(0, arguments).function().value

    /**
     * Get the derivative expression with given orders
     */
    override fun derivativeOrNull(symbols: List<Symbol>): Expression<Double> = Expression { arguments ->
-        with(DerivativeStructureField(symbols.size, arguments)) { function().derivative(symbols) }
+        with(CmDsField(symbols.size, arguments)) { function().derivative(symbols) }
    }
 }
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/integration/CMIntegrator.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/integration/CMIntegrator.kt
@ -7,8 +7,8 @@ package space.kscience.kmath.commons.integration

 import org.apache.commons.math3.analysis.integration.IterativeLegendreGaussIntegrator
 import org.apache.commons.math3.analysis.integration.SimpsonIntegrator
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.integration.*
-import space.kscience.kmath.misc.UnstableKMathAPI

 /**
 * Integration wrapper for Common-maths UnivariateIntegrator
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMMatrix.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/linear/CMMatrix.kt
@ -6,8 +6,8 @@
 package space.kscience.kmath.commons.linear

 import org.apache.commons.math3.linear.*
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.*
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.StructureFeature
 import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.structures.Buffer
--- a/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/optimization/CMOptimizer.kt
+++ b/kmath-commons/src/main/kotlin/space/kscience/kmath/commons/optimization/CMOptimizer.kt
@ -13,11 +13,11 @@ import org.apache.commons.math3.optim.nonlinear.scalar.ObjectiveFunctionGradient
 import org.apache.commons.math3.optim.nonlinear.scalar.gradient.NonLinearConjugateGradientOptimizer
 import org.apache.commons.math3.optim.nonlinear.scalar.noderiv.NelderMeadSimplex
 import org.apache.commons.math3.optim.nonlinear.scalar.noderiv.SimplexOptimizer
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.expressions.Symbol
 import space.kscience.kmath.expressions.SymbolIndexer
 import space.kscience.kmath.expressions.derivative
 import space.kscience.kmath.expressions.withSymbols
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.misc.log
 import space.kscience.kmath.optimization.*
 import kotlin.collections.set
--- a/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpressionTest.kt
+++ b/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/expressions/DerivativeStructureExpressionTest.kt
@ -3,6 +3,8 @@
 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

+@file:Suppress("DEPRECATION")
+
 package space.kscience.kmath.commons.expressions

 import space.kscience.kmath.expressions.*
@ -15,10 +17,10 @@ import kotlin.test.assertFails
 internal inline fun diff(
    order: Int,
    vararg parameters: Pair<Symbol, Double>,
-    block: DerivativeStructureField.() -> Unit,
+    block: CmDsField.() -> Unit,
 ) {
    contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
-    DerivativeStructureField(order, mapOf(*parameters)).run(block)
+    CmDsField(order, mapOf(*parameters)).run(block)
 }

 internal class AutoDiffTest {
@ -41,7 +43,7 @@ internal class AutoDiffTest {

    @Test
    fun autoDifTest() {
-        val f = DerivativeStructureExpression {
+        val f = CmDsExpression {
            val x by binding
            val y by binding
            x.pow(2) + 2 * x * y + y.pow(2) + 1
--- a/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/integration/IntegrationTest.kt
+++ b/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/integration/IntegrationTest.kt
@ -6,9 +6,9 @@
 package space.kscience.kmath.commons.integration

 import org.junit.jupiter.api.Test
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.integration.integrate
 import space.kscience.kmath.integration.value
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.DoubleField.sin
 import kotlin.math.PI
 import kotlin.math.abs
--- a/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/optimization/OptimizeTest.kt
+++ b/kmath-commons/src/test/kotlin/space/kscience/kmath/commons/optimization/OptimizeTest.kt
@ -6,22 +6,25 @@
 package space.kscience.kmath.commons.optimization

 import kotlinx.coroutines.runBlocking
-import space.kscience.kmath.commons.expressions.DSProcessor
-import space.kscience.kmath.commons.expressions.DerivativeStructureExpression
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.distributions.NormalDistribution
+import space.kscience.kmath.expressions.DSFieldExpression
 import space.kscience.kmath.expressions.Symbol.Companion.x
 import space.kscience.kmath.expressions.Symbol.Companion.y
-import space.kscience.kmath.expressions.chiSquaredExpression
+import space.kscience.kmath.expressions.autodiff
 import space.kscience.kmath.expressions.symbol
 import space.kscience.kmath.operations.DoubleBufferOps.Companion.map
+import space.kscience.kmath.operations.DoubleField
 import space.kscience.kmath.optimization.*
 import space.kscience.kmath.random.RandomGenerator
+import space.kscience.kmath.stat.chiSquaredExpression
 import space.kscience.kmath.structures.DoubleBuffer
 import space.kscience.kmath.structures.asBuffer
 import kotlin.test.Test

+@OptIn(UnstableKMathAPI::class)
 internal class OptimizeTest {
-    val normal = DerivativeStructureExpression {
+    val normal = DSFieldExpression(DoubleField) {
        exp(-bindSymbol(x).pow(2) / 2) + exp(-bindSymbol(y).pow(2) / 2)
    }

@ -60,7 +63,7 @@ internal class OptimizeTest {

        val yErr = DoubleBuffer(x.size) { sigma }

-        val chi2 = DSProcessor.chiSquaredExpression(
+        val chi2 = Double.autodiff.chiSquaredExpression(
            x, y, yErr
        ) { arg ->
            val cWithDefault = bindSymbolOrNull(c) ?: one
--- a/kmath-complex/README.md
+++ b/kmath-complex/README.md
@ -8,7 +8,7 @@ Complex and hypercomplex number systems in KMath.

 ## Artifact:

-The Maven coordinates of this project are `space.kscience:kmath-complex:0.3.1-dev-1`.
+The Maven coordinates of this project are `space.kscience:kmath-complex:0.4.0-dev-1`.

 **Gradle Groovy:**
 ```groovy
@ -18,7 +18,7 @@ repositories {
 }

 dependencies {
-    implementation 'space.kscience:kmath-complex:0.3.1-dev-1'
+    implementation 'space.kscience:kmath-complex:0.4.0-dev-1'
 }
 ```
 **Gradle Kotlin DSL:**
@ -29,6 +29,6 @@ repositories {
 }

 dependencies {
-    implementation("space.kscience:kmath-complex:0.3.1-dev-1")
+    implementation("space.kscience:kmath-complex:0.4.0-dev-1")
 }
 ```
--- a/kmath-complex/build.gradle.kts
+++ b/kmath-complex/build.gradle.kts
@ -3,15 +3,35 @@ plugins {
 }

 kscience {
+    jvm()
+    js()
    native()
+
+    wasm{
+        browser {
+            testTask {
+                useKarma {
+                    this.webpackConfig.experiments.add("topLevelAwait")
+                    useChromeHeadless()
+                    useConfigDirectory(project.projectDir.resolve("karma.config.d").resolve("wasm"))
+                }
+            }
+        }
    }

-kotlin.sourceSets {
-    commonMain {
+    wasmTest{
        dependencies {
-            api(project(":kmath-core"))
+            implementation(kotlin("test"))
        }
    }
+
+    dependencies {
+        api(projects.kmathCore)
+    }
+
+    testDependencies {
+        implementation(projects.testUtils)
+    }
 }

 readme {
--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Complex.kt
@ -5,10 +5,10 @@

 package space.kscience.kmath.complex

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.memory.MemoryReader
 import space.kscience.kmath.memory.MemorySpec
 import space.kscience.kmath.memory.MemoryWriter
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.*
 import kotlin.math.*
@ -80,6 +80,8 @@ public object ComplexField :
    override fun add(left: Complex, right: Complex): Complex = Complex(left.re + right.re, left.im + right.im)
 //    override fun multiply(a: Complex, k: Number): Complex = Complex(a.re * k.toDouble(), a.im * k.toDouble())

+//    override fun Complex.minus(arg: Complex): Complex = Complex(re - arg.re, im - arg.im)
+
    override fun multiply(left: Complex, right: Complex): Complex =
        Complex(left.re * right.re - left.im * right.im, left.re * right.im + left.im * right.re)

--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexFieldND.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/ComplexFieldND.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.complex

-import space.kscience.kmath.misc.PerformancePitfall
-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.PerformancePitfall
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
--- a/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
+++ b/kmath-complex/src/commonMain/kotlin/space/kscience/kmath/complex/Quaternion.kt
@ -5,10 +5,10 @@

 package space.kscience.kmath.complex

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.memory.MemoryReader
 import space.kscience.kmath.memory.MemorySpec
 import space.kscience.kmath.memory.MemoryWriter
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.MemoryBuffer
--- a/kmath-core/README.md
+++ b/kmath-core/README.md
@ -15,7 +15,7 @@ performance calculations to code generation.

 ## Artifact:

-The Maven coordinates of this project are `space.kscience:kmath-core:0.3.1-dev-1`.
+The Maven coordinates of this project are `space.kscience:kmath-core:0.4.0-dev-1`.

 **Gradle Groovy:**
 ```groovy
@ -25,7 +25,7 @@ repositories {
 }

 dependencies {
-    implementation 'space.kscience:kmath-core:0.3.1-dev-1'
+    implementation 'space.kscience:kmath-core:0.4.0-dev-1'
 }
 ```
 **Gradle Kotlin DSL:**
@ -36,6 +36,6 @@ repositories {
 }

 dependencies {
-    implementation("space.kscience:kmath-core:0.3.1-dev-1")
+    implementation("space.kscience:kmath-core:0.4.0-dev-1")
 }
 ```
--- a/kmath-core/build.gradle.kts
+++ b/kmath-core/build.gradle.kts
@ -3,10 +3,33 @@ plugins {
 }

 kscience{
+    jvm()
+    js()
    native()
+    wasm{
+        browser {
+            testTask {
+                useKarma {
+                    this.webpackConfig.experiments.add("topLevelAwait")
+                    useChromeHeadless()
+                    useConfigDirectory(project.projectDir.resolve("karma.config.d").resolve("wasm"))
+                }
+            }
+        }
+    }
+
+    wasmTest{
+        dependencies {
+            implementation(kotlin("test"))
+        }
+    }

    dependencies {
-        api(project(":kmath-memory"))
+        api(projects.kmathMemory)
+    }
+
+    testDependencies {
+        implementation(projects.testUtils)
    }
 }

--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/ColumnarData.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/ColumnarData.kt
@ -5,9 +5,9 @@

 package space.kscience.kmath.data

+import space.kscience.kmath.PerformancePitfall
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.misc.PerformancePitfall
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.Structure2D
 import space.kscience.kmath.structures.Buffer

--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYColumnarData.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYColumnarData.kt
@ -5,9 +5,9 @@

 package space.kscience.kmath.data

+import space.kscience.kmath.PerformancePitfall
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.misc.PerformancePitfall
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.Structure2D
 import space.kscience.kmath.structures.Buffer
 import kotlin.math.max
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYErrorColumnarData.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYErrorColumnarData.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.data

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.structures.Buffer


--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYZColumnarData.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/data/XYZColumnarData.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.data

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.expressions.Symbol
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.structures.Buffer

 /**
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Domain1D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/Domain1D.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.domains

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.misc.UnstableKMathAPI

@UnstableKMathAPI
 public abstract class Domain1D<T : Comparable<T>>(public val range: ClosedRange<T>) : Domain<T> {
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/DoubleDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/DoubleDomain.kt
@ -4,7 +4,7 @@
 */
 package space.kscience.kmath.domains

-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI

 /**
 * n-dimensional volume
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/HyperSquareDomain.kt
@ -4,8 +4,8 @@
 */
 package space.kscience.kmath.domains

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.DoubleBuffer
 import space.kscience.kmath.structures.indices
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/domains/UnconstrainedDomain.kt
@ -4,8 +4,8 @@
 */
 package space.kscience.kmath.domains

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.misc.UnstableKMathAPI

@UnstableKMathAPI
 public class UnconstrainedDomain(override val dimension: Int) : DoubleDomain {
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DSAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DSAlgebra.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.expressions

-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.MutableBuffer
@ -80,7 +80,6 @@ public abstract class DSAlgebra<T, A : Ring<T>>(
    public val algebra: A,
    public val order: Int,
    bindings: Map<Symbol, T>,
-    public val valueBufferFactory: MutableBufferFactory<T> = algebra.bufferFactory,
 ) : ExpressionAlgebra<T, DS<T, A>>, SymbolIndexer {

    /**
@ -116,7 +115,6 @@ public abstract class DSAlgebra<T, A : Ring<T>>(

                    newCache[p][o] = DSCompiler(
                        algebra,
-                        valueBufferFactory,
                        p,
                        o,
                        valueCompiler,
@ -141,7 +139,7 @@ public abstract class DSAlgebra<T, A : Ring<T>>(
    override val symbols: List<Symbol> = bindings.map { it.key }

    private fun bufferForVariable(index: Int, value: T): Buffer<T> {
-        val buffer = valueBufferFactory(compiler.size) { algebra.zero }
+        val buffer = algebra.bufferFactory(compiler.size) { algebra.zero }
        buffer[0] = value
        if (compiler.order > 0) {
            // the derivative of the variable with respect to itself is 1.
@ -207,7 +205,7 @@ public abstract class DSAlgebra<T, A : Ring<T>>(
    }

    public override fun const(value: T): DS<T, A> {
-        val buffer = valueBufferFactory(compiler.size) { algebra.zero }
+        val buffer = algebra.bufferFactory(compiler.size) { algebra.zero }
        buffer[0] = value

        return DS(buffer)
@ -245,11 +243,14 @@ public open class DSRing<T, A>(
    algebra: A,
    order: Int,
    bindings: Map<Symbol, T>,
-    valueBufferFactory: MutableBufferFactory<T>,
-) : DSAlgebra<T, A>(algebra, order, bindings, valueBufferFactory),
-    Ring<DS<T, A>>, ScaleOperations<DS<T, A>>,
+) : DSAlgebra<T, A>(algebra, order, bindings),
+    Ring<DS<T, A>>,
+    ScaleOperations<DS<T, A>>,
    NumericAlgebra<DS<T, A>>,
-    NumbersAddOps<DS<T, A>> where A : Ring<T>, A : NumericAlgebra<T>, A : ScaleOperations<T> {
+    NumbersAddOps<DS<T, A>>
+        where A : Ring<T>, A : NumericAlgebra<T>, A : ScaleOperations<T> {
+
+    public val elementBufferFactory: MutableBufferFactory<T> = algebra.bufferFactory

    override fun bindSymbolOrNull(value: String): DSSymbol? =
        super<DSAlgebra>.bindSymbolOrNull(value)
@ -261,14 +262,14 @@ public open class DSRing<T, A>(
     */
    protected inline fun DS<T, A>.transformDataBuffer(block: A.(MutableBuffer<T>) -> Unit): DS<T, A> {
        require(derivativeAlgebra == this@DSRing) { "All derivative operations should be done in the same algebra" }
-        val newData = valueBufferFactory(compiler.size) { data[it] }
+        val newData = elementBufferFactory(compiler.size) { data[it] }
        algebra.block(newData)
        return DS(newData)
    }

    protected fun DS<T, A>.mapData(block: A.(T) -> T): DS<T, A> {
        require(derivativeAlgebra == this@DSRing) { "All derivative operations should be done in the same algebra" }
-        val newData: Buffer<T> = data.mapToBuffer(valueBufferFactory) {
+        val newData: Buffer<T> = data.mapToBuffer(elementBufferFactory) {
            algebra.block(it)
        }
        return DS(newData)
@ -276,7 +277,7 @@ public open class DSRing<T, A>(

    protected fun DS<T, A>.mapDataIndexed(block: (Int, T) -> T): DS<T, A> {
        require(derivativeAlgebra == this@DSRing) { "All derivative operations should be done in the same algebra" }
-        val newData: Buffer<T> = data.mapIndexedToBuffer(valueBufferFactory, block)
+        val newData: Buffer<T> = data.mapIndexedToBuffer(elementBufferFactory, block)
        return DS(newData)
    }

@ -329,22 +330,21 @@ public class DerivativeStructureRingExpression<T, A>(
    public val function: DSRing<T, A>.() -> DS<T, A>,
 ) : DifferentiableExpression<T> where A : Ring<T>, A : ScaleOperations<T>, A : NumericAlgebra<T> {
    override operator fun invoke(arguments: Map<Symbol, T>): T =
-        DSRing(algebra, 0, arguments, elementBufferFactory).function().value
+        DSRing(algebra, 0, arguments).function().value

    override fun derivativeOrNull(symbols: List<Symbol>): Expression<T> = Expression { arguments ->
        with(
            DSRing(
                algebra,
                symbols.size,
-                arguments,
-                elementBufferFactory
+                arguments
            )
        ) { function().derivative(symbols) }
    }
 }

 /**
- * A field over commons-math [DerivativeStructure].
+ * A field over [DS].
 *
 * @property order The derivation order.
 * @param bindings The map of bindings values. All bindings are considered free parameters.
@ -354,8 +354,7 @@ public class DSField<T, A : ExtendedField<T>>(
    algebra: A,
    order: Int,
    bindings: Map<Symbol, T>,
-    valueBufferFactory: MutableBufferFactory<T>,
-) : DSRing<T, A>(algebra, order, bindings, valueBufferFactory), ExtendedField<DS<T, A>> {
+) : DSRing<T, A>(algebra, order, bindings), ExtendedField<DS<T, A>> {
    override fun number(value: Number): DS<T, A> = const(algebra.number(value))

    override fun divide(left: DS<T, A>, right: DS<T, A>): DS<T, A> = left.transformDataBuffer { result ->
@ -414,6 +413,7 @@ public class DSField<T, A : ExtendedField<T>>(
        is Int -> arg.transformDataBuffer { result ->
            compiler.pow(arg.data, 0, pow, result, 0)
        }
+
        else -> arg.transformDataBuffer { result ->
            compiler.pow(arg.data, 0, pow.toDouble(), result, 0)
        }
@ -439,18 +439,29 @@ public class DSField<T, A : ExtendedField<T>>(
@UnstableKMathAPI
 public class DSFieldExpression<T, A : ExtendedField<T>>(
    public val algebra: A,
-    private val valueBufferFactory: MutableBufferFactory<T> = algebra.bufferFactory,
    public val function: DSField<T, A>.() -> DS<T, A>,
 ) : DifferentiableExpression<T> {
    override operator fun invoke(arguments: Map<Symbol, T>): T =
-        DSField(algebra, 0, arguments, valueBufferFactory).function().value
+        DSField(algebra, 0, arguments).function().value

    override fun derivativeOrNull(symbols: List<Symbol>): Expression<T> = Expression { arguments ->
        DSField(
            algebra,
            symbols.size,
            arguments,
-            valueBufferFactory,
        ).run { function().derivative(symbols) }
    }
 }
+
+
+@UnstableKMathAPI
+public class DSFieldProcessor<T, A : ExtendedField<T>>(
+    public val algebra: A,
+) : AutoDiffProcessor<T, DS<T, A>, DSField<T, A>> {
+    override fun differentiate(
+        function: DSField<T, A>.() -> DS<T, A>,
+    ): DifferentiableExpression<T> = DSFieldExpression(algebra, function)
+}
+
+@UnstableKMathAPI
+public val Double.Companion.autodiff: DSFieldProcessor<Double, DoubleField> get() = DSFieldProcessor(DoubleField)
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DSCompiler.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/DSCompiler.kt
@ -9,7 +9,6 @@ package space.kscience.kmath.expressions
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.MutableBuffer
-import space.kscience.kmath.structures.MutableBufferFactory
 import kotlin.math.min

 internal fun <T> MutableBuffer<T>.fill(element: T, fromIndex: Int = 0, toIndex: Int = size) {
@ -56,7 +55,6 @@ internal fun <T> MutableBuffer<T>.fill(element: T, fromIndex: Int = 0, toIndex:
 */
 public class DSCompiler<T, out A : Algebra<T>> internal constructor(
    public val algebra: A,
-    public val bufferFactory: MutableBufferFactory<T>,
    public val freeParameters: Int,
    public val order: Int,
    valueCompiler: DSCompiler<T, A>?,
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/Expression.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/Expression.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.expressions

-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.Algebra
 import kotlin.jvm.JvmName
 import kotlin.properties.ReadOnlyProperty
@ -48,6 +48,10 @@ public interface DoubleExpression : Expression<Double> {
     * @return the value.
     */
    public operator fun invoke(arguments: DoubleArray): Double
+
+    public companion object{
+        internal val EMPTY_DOUBLE_ARRAY = DoubleArray(0)
+    }
 }

 /**
@ -73,6 +77,10 @@ public interface IntExpression : Expression<Int> {
     * @return the value.
     */
    public operator fun invoke(arguments: IntArray): Int
+
+    public companion object{
+        internal val EMPTY_INT_ARRAY = IntArray(0)
+    }
 }

 /**
@ -98,6 +106,10 @@ public interface LongExpression : Expression<Long> {
     * @return the value.
     */
    public operator fun invoke(arguments: LongArray): Long
+
+    public companion object{
+        internal val EMPTY_LONG_ARRAY = LongArray(0)
+    }
 }

 /**
@ -145,7 +157,7 @@ public operator fun <T> Expression<T>.invoke(vararg pairs: Pair<String, T>): T =
    }
 )

-private val EMPTY_DOUBLE_ARRAY = DoubleArray(0)
+

 /**
 * Calls this expression without providing any arguments.
@ -153,7 +165,7 @@ private val EMPTY_DOUBLE_ARRAY = DoubleArray(0)
 * @return a value.
 */
@UnstableKMathAPI
-public operator fun DoubleExpression.invoke(): Double = this(EMPTY_DOUBLE_ARRAY)
+public operator fun DoubleExpression.invoke(): Double = this(DoubleExpression.EMPTY_DOUBLE_ARRAY)

 /**
 * Calls this expression from arguments.
@ -164,15 +176,13 @@ public operator fun DoubleExpression.invoke(): Double = this(EMPTY_DOUBLE_ARRAY)
@UnstableKMathAPI
 public operator fun DoubleExpression.invoke(vararg arguments: Double): Double = this(arguments)

-private val EMPTY_INT_ARRAY = IntArray(0)
-
 /**
 * Calls this expression without providing any arguments.
 *
 * @return a value.
 */
@UnstableKMathAPI
-public operator fun IntExpression.invoke(): Int = this(EMPTY_INT_ARRAY)
+public operator fun IntExpression.invoke(): Int = this(IntExpression.EMPTY_INT_ARRAY)

 /**
 * Calls this expression from arguments.
@ -183,15 +193,13 @@ public operator fun IntExpression.invoke(): Int = this(EMPTY_INT_ARRAY)
@UnstableKMathAPI
 public operator fun IntExpression.invoke(vararg arguments: Int): Int = this(arguments)

-private val EMPTY_LONG_ARRAY = LongArray(0)
-
 /**
 * Calls this expression without providing any arguments.
 *
 * @return a value.
 */
@UnstableKMathAPI
-public operator fun LongExpression.invoke(): Long = this(EMPTY_LONG_ARRAY)
+public operator fun LongExpression.invoke(): Long = this(LongExpression.EMPTY_LONG_ARRAY)

 /**
 * Calls this expression from arguments.
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/ExpressionWithDefault.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/ExpressionWithDefault.kt
@ -0,0 +1,31 @@
+/*
+ * Copyright 2018-2023 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.expressions
+
+public class ExpressionWithDefault<T>(
+    private val origin: Expression<T>,
+    private val defaultArgs: Map<Symbol, T>,
+) : Expression<T> {
+    override fun invoke(arguments: Map<Symbol, T>): T = origin.invoke(defaultArgs + arguments)
+}
+
+public fun <T> Expression<T>.withDefaultArgs(defaultArgs: Map<Symbol, T>): ExpressionWithDefault<T> =
+    ExpressionWithDefault(this, defaultArgs)
+
+
+public class DiffExpressionWithDefault<T>(
+    private val origin: DifferentiableExpression<T>,
+    private val defaultArgs: Map<Symbol, T>,
+) : DifferentiableExpression<T> {
+
+    override fun invoke(arguments: Map<Symbol, T>): T = origin.invoke(defaultArgs + arguments)
+
+    override fun derivativeOrNull(symbols: List<Symbol>): Expression<T>? =
+        origin.derivativeOrNull(symbols)?.withDefaultArgs(defaultArgs)
+}
+
+public fun <T> DifferentiableExpression<T>.withDefaultArgs(defaultArgs: Map<Symbol, T>): DiffExpressionWithDefault<T> =
+    DiffExpressionWithDefault(this, defaultArgs)
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/MstAlgebra.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/MstAlgebra.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.expressions

-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.*

 /**
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/NamedMatrix.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/NamedMatrix.kt
@ -0,0 +1,39 @@
+/*
+ * Copyright 2018-2023 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.
+ */
+
+@file:OptIn(UnstableKMathAPI::class)
+
+package space.kscience.kmath.expressions
+
+import space.kscience.kmath.PerformancePitfall
+import space.kscience.kmath.UnstableKMathAPI
+import space.kscience.kmath.linear.Matrix
+import space.kscience.kmath.structures.getOrNull
+
+public class NamedMatrix<T>(public val values: Matrix<T>, public val indexer: SymbolIndexer) : Matrix<T> by values {
+    public operator fun get(i: Symbol, j: Symbol): T = get(indexer.indexOf(i), indexer.indexOf(j))
+
+    public companion object {
+
+        @OptIn(PerformancePitfall::class)
+        public fun toStringWithSymbols(values: Matrix<*>, indexer: SymbolIndexer): String = buildString {
+            appendLine(indexer.symbols.joinToString(separator = "\t", prefix = "\t\t"))
+            indexer.symbols.forEach { i ->
+                append(i.identity + "\t")
+                values.rows.getOrNull(indexer.indexOf(i))?.let { row ->
+                    indexer.symbols.forEach { j ->
+                        append(row.getOrNull(indexer.indexOf(j)).toString())
+                        append("\t")
+                    }
+                    appendLine()
+                }
+            }
+        }
+    }
+}
+
+public fun <T> Matrix<T>.named(indexer: SymbolIndexer): NamedMatrix<T> = NamedMatrix(this, indexer)
+
+public fun <T> Matrix<T>.named(symbols: List<Symbol>): NamedMatrix<T> = named(SimpleSymbolIndexer(symbols))
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/SimpleAutoDiff.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/SimpleAutoDiff.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.expressions

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.asBuffer
 import kotlin.contracts.InvocationKind
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/SymbolIndexer.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/expressions/SymbolIndexer.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.expressions

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.linear.Point
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.Structure2D
 import space.kscience.kmath.structures.BufferFactory
 import space.kscience.kmath.structures.DoubleBuffer
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/BufferedLinearSpace.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.linear

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.Buffer
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/DoubleLinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/DoubleLinearSpace.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.linear

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.DoubleBufferOps
 import space.kscience.kmath.operations.DoubleField
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LinearSpace.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.linear

-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.nd.MutableStructure2D
 import space.kscience.kmath.nd.Structure2D
 import space.kscience.kmath.nd.StructureFeature
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.linear

-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.BufferAccessor2D
 import space.kscience.kmath.structures.DoubleBuffer
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.linear

-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.Ring
 import space.kscience.kmath.structures.BufferAccessor2D
 import space.kscience.kmath.structures.MutableBuffer
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.linear

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.misc.FeatureSet
-import space.kscience.kmath.misc.UnstableKMathAPI
 import space.kscience.kmath.nd.StructureFeature
 import space.kscience.kmath.operations.Ring
 import kotlin.reflect.KClass
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/Featured.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/Featured.kt
@ -9,7 +9,7 @@ import kotlin.jvm.JvmInline
 import kotlin.reflect.KClass

 /**
- * A entity that contains a set of features defined by their types
+ * An entity that contains a set of features defined by their types
 */
 public interface Featured<F : Any> {
    public fun <T : F> getFeature(type: FeatureKey<T>): T?
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/collections.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/collections.kt
@ -0,0 +1,22 @@
+/*
+ * Copyright 2018-2023 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.misc
+
+/**
+ * The same as [zipWithNext], but includes link between last and first element
+ */
+public inline fun <T, R> List<T>.zipWithNextCircular(transform: (a: T, b: T) -> R): List<R> {
+    if (isEmpty()) return emptyList()
+    return indices.map { i ->
+        if (i == size - 1) {
+            transform(last(), first())
+        } else {
+            transform(get(i), get(i + 1))
+        }
+    }
+}
+
+public fun <T> List<T>.zipWithNextCircular(): List<Pair<T,T>> = zipWithNextCircular { l, r -> l to r  }
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/sorting.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/misc/sorting.kt
@ -6,6 +6,7 @@

 package space.kscience.kmath.misc

+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.VirtualBuffer

--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/AlgebraND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/AlgebraND.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.PerformancePitfall
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import kotlin.reflect.KClass

--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferAlgebraND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferAlgebraND.kt
@ -7,8 +7,8 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.PerformancePitfall
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.*

 public interface BufferAlgebraND<T, out A : Algebra<T>> : AlgebraND<T, A> {
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/BufferND.kt
@ -5,9 +5,11 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.structures.Buffer
+import space.kscience.kmath.structures.BufferFactory
 import space.kscience.kmath.structures.MutableBuffer
+import space.kscience.kmath.structures.MutableBufferFactory

 /**
 * Represents [StructureND] over [Buffer].
@ -29,6 +31,18 @@ public open class BufferND<out T>(
    override fun toString(): String = StructureND.toString(this)
 }

+/**
+ * Create a generic [BufferND] using provided [initializer]
+ */
+public fun <T> BufferND(
+    shape: ShapeND,
+    bufferFactory: BufferFactory<T> = BufferFactory.boxing(),
+    initializer: (IntArray) -> T,
+): BufferND<T> {
+    val strides = Strides(shape)
+    return BufferND(strides, bufferFactory(strides.linearSize) { initializer(strides.index(it)) })
+}
+
 ///**
 // * Transform structure to a new structure using provided [BufferFactory] and optimizing if argument is [BufferND]
 // */
@ -67,6 +81,18 @@ public open class MutableBufferND<T>(
    }
 }

+/**
+ * Create a generic [BufferND] using provided [initializer]
+ */
+public fun <T> MutableBufferND(
+    shape: ShapeND,
+    bufferFactory: MutableBufferFactory<T> = MutableBufferFactory.boxing(),
+    initializer: (IntArray) -> T,
+): MutableBufferND<T> {
+    val strides = Strides(shape)
+    return MutableBufferND(strides, bufferFactory(strides.linearSize) { initializer(strides.index(it)) })
+}
+
 ///**
 // * Transform structure to a new structure using provided [MutableBufferFactory] and optimizing if argument is [MutableBufferND]
 // */
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/DoubleFieldND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/DoubleFieldND.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.PerformancePitfall
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.*
 import space.kscience.kmath.structures.DoubleBuffer
 import kotlin.contracts.InvocationKind
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/IntRingND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/IntRingND.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.IntRing
 import space.kscience.kmath.operations.NumbersAddOps
 import space.kscience.kmath.operations.bufferAlgebra
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/PermutedStructureND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/PermutedStructureND.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall


 public class PermutedStructureND<T>(
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/ShapeND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/ShapeND.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.UnsafeKMathAPI
+import space.kscience.kmath.UnsafeKMathAPI
 import kotlin.jvm.JvmInline

 /**
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/ShortRingND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/ShortRingND.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.operations.NumbersAddOps
 import space.kscience.kmath.operations.ShortRing
 import space.kscience.kmath.operations.bufferAlgebra
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure1D.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.operations.asSequence
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.MutableBuffer
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/Structure2D.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.structures.Buffer
 import space.kscience.kmath.structures.MutableBuffer
 import space.kscience.kmath.structures.MutableListBuffer
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/StructureND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/StructureND.kt
@ -5,10 +5,10 @@

 package space.kscience.kmath.nd

+import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.linear.LinearSpace
 import space.kscience.kmath.misc.Feature
 import space.kscience.kmath.misc.Featured
-import space.kscience.kmath.misc.PerformancePitfall
 import space.kscience.kmath.operations.Ring
 import space.kscience.kmath.operations.invoke
 import space.kscience.kmath.structures.Buffer
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/VirtualStructureND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/VirtualStructureND.kt
@ -5,8 +5,8 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
-import space.kscience.kmath.misc.UnstableKMathAPI
+import space.kscience.kmath.PerformancePitfall
+import space.kscience.kmath.UnstableKMathAPI

 public open class VirtualStructureND<T>(
    override val shape: ShapeND,
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/operationsND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/operationsND.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall

@OptIn(PerformancePitfall::class)
 public fun <T> StructureND<T>.roll(axis: Int, step: Int = 1): StructureND<T> {
--- a/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/primitiveStructureND.kt
+++ b/kmath-core/src/commonMain/kotlin/space/kscience/kmath/nd/primitiveStructureND.kt
@ -5,7 +5,7 @@

 package space.kscience.kmath.nd

-import space.kscience.kmath.misc.PerformancePitfall
+import space.kscience.kmath.PerformancePitfall

 public interface StructureNDOfDouble : StructureND<Double> {
    /**
--- a/Show More
+++ b/Show More